diff options
Diffstat (limited to 'src/Java/api/player/server')
| -rw-r--r-- | src/Java/api/player/server/IServerPlayer.java | 983 | ||||
| -rw-r--r-- | src/Java/api/player/server/IServerPlayerAPI.java | 26 | ||||
| -rw-r--r-- | src/Java/api/player/server/ServerPlayerAPI.java | 6017 | ||||
| -rw-r--r-- | src/Java/api/player/server/ServerPlayerBase.java | 1207 | ||||
| -rw-r--r-- | src/Java/api/player/server/ServerPlayerBaseSorter.java | 259 | ||||
| -rw-r--r-- | src/Java/api/player/server/ServerPlayerBaseSorting.java | 3909 | ||||
| -rw-r--r-- | src/Java/api/player/server/ServerPlayerClassVisitor.java | 4856 | ||||
| -rw-r--r-- | src/Java/api/player/server/ServerPlayerConstructorVisitor.java | 65 |
8 files changed, 17322 insertions, 0 deletions
diff --git a/src/Java/api/player/server/IServerPlayer.java b/src/Java/api/player/server/IServerPlayer.java new file mode 100644 index 0000000000..0e8a5e6dc5 --- /dev/null +++ b/src/Java/api/player/server/IServerPlayer.java @@ -0,0 +1,983 @@ +// ================================================================== +// This file is part of Player API. +// +// Player API is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// Player API is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and the GNU General Public License along with Player API. +// If not, see <http://www.gnu.org/licenses/>. +// ================================================================== + +package api.player.server; + +public interface IServerPlayer +{ + ServerPlayerBase getServerPlayerBase(String baseId); + + java.util.Set<String> getServerPlayerBaseIds(); + + Object dynamic(String key, Object[] parameters); + + void realAddExhaustion(float paramFloat); + + void superAddExhaustion(float paramFloat); + + void localAddExhaustion(float paramFloat); + + void realAddExperience(int paramInt); + + void superAddExperience(int paramInt); + + void localAddExperience(int paramInt); + + void realAddExperienceLevel(int paramInt); + + void superAddExperienceLevel(int paramInt); + + void localAddExperienceLevel(int paramInt); + + void realAddMovementStat(double paramDouble1, double paramDouble2, double paramDouble3); + + void superAddMovementStat(double paramDouble1, double paramDouble2, double paramDouble3); + + void localAddMovementStat(double paramDouble1, double paramDouble2, double paramDouble3); + + boolean realAttackEntityFrom(net.minecraft.util.DamageSource paramDamageSource, float paramFloat); + + boolean superAttackEntityFrom(net.minecraft.util.DamageSource paramDamageSource, float paramFloat); + + boolean localAttackEntityFrom(net.minecraft.util.DamageSource paramDamageSource, float paramFloat); + + void realAttackTargetEntityWithCurrentItem(net.minecraft.entity.Entity paramEntity); + + void superAttackTargetEntityWithCurrentItem(net.minecraft.entity.Entity paramEntity); + + void localAttackTargetEntityWithCurrentItem(net.minecraft.entity.Entity paramEntity); + + boolean realCanBreatheUnderwater(); + + boolean superCanBreatheUnderwater(); + + boolean localCanBreatheUnderwater(); + + boolean realCanHarvestBlock(net.minecraft.block.Block paramBlock); + + boolean superCanHarvestBlock(net.minecraft.block.Block paramBlock); + + boolean localCanHarvestBlock(net.minecraft.block.Block paramBlock); + + boolean realCanPlayerEdit(int paramInt1, int paramInt2, int paramInt3, int paramInt4, net.minecraft.item.ItemStack paramItemStack); + + boolean superCanPlayerEdit(int paramInt1, int paramInt2, int paramInt3, int paramInt4, net.minecraft.item.ItemStack paramItemStack); + + boolean localCanPlayerEdit(int paramInt1, int paramInt2, int paramInt3, int paramInt4, net.minecraft.item.ItemStack paramItemStack); + + boolean realCanTriggerWalking(); + + boolean superCanTriggerWalking(); + + boolean localCanTriggerWalking(); + + void realClonePlayer(net.minecraft.entity.player.EntityPlayer paramEntityPlayer, boolean paramBoolean); + + void superClonePlayer(net.minecraft.entity.player.EntityPlayer paramEntityPlayer, boolean paramBoolean); + + void localClonePlayer(net.minecraft.entity.player.EntityPlayer paramEntityPlayer, boolean paramBoolean); + + void realDamageEntity(net.minecraft.util.DamageSource paramDamageSource, float paramFloat); + + void superDamageEntity(net.minecraft.util.DamageSource paramDamageSource, float paramFloat); + + void localDamageEntity(net.minecraft.util.DamageSource paramDamageSource, float paramFloat); + + void realDisplayGUIChest(net.minecraft.inventory.IInventory paramIInventory); + + void superDisplayGUIChest(net.minecraft.inventory.IInventory paramIInventory); + + void localDisplayGUIChest(net.minecraft.inventory.IInventory paramIInventory); + + void realDisplayGUIDispenser(net.minecraft.tileentity.TileEntityDispenser paramTileEntityDispenser); + + void superDisplayGUIDispenser(net.minecraft.tileentity.TileEntityDispenser paramTileEntityDispenser); + + void localDisplayGUIDispenser(net.minecraft.tileentity.TileEntityDispenser paramTileEntityDispenser); + + void realDisplayGUIFurnace(net.minecraft.tileentity.TileEntityFurnace paramTileEntityFurnace); + + void superDisplayGUIFurnace(net.minecraft.tileentity.TileEntityFurnace paramTileEntityFurnace); + + void localDisplayGUIFurnace(net.minecraft.tileentity.TileEntityFurnace paramTileEntityFurnace); + + void realDisplayGUIWorkbench(int paramInt1, int paramInt2, int paramInt3); + + void superDisplayGUIWorkbench(int paramInt1, int paramInt2, int paramInt3); + + void localDisplayGUIWorkbench(int paramInt1, int paramInt2, int paramInt3); + + net.minecraft.entity.item.EntityItem realDropOneItem(boolean paramBoolean); + + net.minecraft.entity.item.EntityItem superDropOneItem(boolean paramBoolean); + + net.minecraft.entity.item.EntityItem localDropOneItem(boolean paramBoolean); + + net.minecraft.entity.item.EntityItem realDropPlayerItem(net.minecraft.item.ItemStack paramItemStack, boolean paramBoolean); + + net.minecraft.entity.item.EntityItem superDropPlayerItem(net.minecraft.item.ItemStack paramItemStack, boolean paramBoolean); + + net.minecraft.entity.item.EntityItem localDropPlayerItem(net.minecraft.item.ItemStack paramItemStack, boolean paramBoolean); + + void realFall(float paramFloat); + + void superFall(float paramFloat); + + void localFall(float paramFloat); + + float realGetAIMoveSpeed(); + + float superGetAIMoveSpeed(); + + float localGetAIMoveSpeed(); + + float realGetCurrentPlayerStrVsBlock(net.minecraft.block.Block paramBlock, boolean paramBoolean); + + float superGetCurrentPlayerStrVsBlock(net.minecraft.block.Block paramBlock, boolean paramBoolean); + + float localGetCurrentPlayerStrVsBlock(net.minecraft.block.Block paramBlock, boolean paramBoolean); + + float realGetCurrentPlayerStrVsBlockForge(net.minecraft.block.Block paramBlock, boolean paramBoolean, int paramInt); + + float superGetCurrentPlayerStrVsBlockForge(net.minecraft.block.Block paramBlock, boolean paramBoolean, int paramInt); + + float localGetCurrentPlayerStrVsBlockForge(net.minecraft.block.Block paramBlock, boolean paramBoolean, int paramInt); + + double realGetDistanceSq(double paramDouble1, double paramDouble2, double paramDouble3); + + double superGetDistanceSq(double paramDouble1, double paramDouble2, double paramDouble3); + + double localGetDistanceSq(double paramDouble1, double paramDouble2, double paramDouble3); + + float realGetBrightness(float paramFloat); + + float superGetBrightness(float paramFloat); + + float localGetBrightness(float paramFloat); + + float realGetEyeHeight(); + + float superGetEyeHeight(); + + float localGetEyeHeight(); + + void realHeal(float paramFloat); + + void superHeal(float paramFloat); + + void localHeal(float paramFloat); + + boolean realIsEntityInsideOpaqueBlock(); + + boolean superIsEntityInsideOpaqueBlock(); + + boolean localIsEntityInsideOpaqueBlock(); + + boolean realIsInWater(); + + boolean superIsInWater(); + + boolean localIsInWater(); + + boolean realIsInsideOfMaterial(net.minecraft.block.material.Material paramMaterial); + + boolean superIsInsideOfMaterial(net.minecraft.block.material.Material paramMaterial); + + boolean localIsInsideOfMaterial(net.minecraft.block.material.Material paramMaterial); + + boolean realIsOnLadder(); + + boolean superIsOnLadder(); + + boolean localIsOnLadder(); + + boolean realIsPlayerSleeping(); + + boolean superIsPlayerSleeping(); + + boolean localIsPlayerSleeping(); + + boolean realIsSneaking(); + + boolean superIsSneaking(); + + boolean localIsSneaking(); + + void realJump(); + + void superJump(); + + void localJump(); + + void realKnockBack(net.minecraft.entity.Entity paramEntity, float paramFloat, double paramDouble1, double paramDouble2); + + void superKnockBack(net.minecraft.entity.Entity paramEntity, float paramFloat, double paramDouble1, double paramDouble2); + + void localKnockBack(net.minecraft.entity.Entity paramEntity, float paramFloat, double paramDouble1, double paramDouble2); + + void realMountEntity(net.minecraft.entity.Entity paramEntity); + + void superMountEntity(net.minecraft.entity.Entity paramEntity); + + void localMountEntity(net.minecraft.entity.Entity paramEntity); + + void realMoveEntity(double paramDouble1, double paramDouble2, double paramDouble3); + + void superMoveEntity(double paramDouble1, double paramDouble2, double paramDouble3); + + void localMoveEntity(double paramDouble1, double paramDouble2, double paramDouble3); + + void realMoveEntityWithHeading(float paramFloat1, float paramFloat2); + + void superMoveEntityWithHeading(float paramFloat1, float paramFloat2); + + void localMoveEntityWithHeading(float paramFloat1, float paramFloat2); + + void realMoveFlying(float paramFloat1, float paramFloat2, float paramFloat3); + + void superMoveFlying(float paramFloat1, float paramFloat2, float paramFloat3); + + void localMoveFlying(float paramFloat1, float paramFloat2, float paramFloat3); + + void realOnDeath(net.minecraft.util.DamageSource paramDamageSource); + + void superOnDeath(net.minecraft.util.DamageSource paramDamageSource); + + void localOnDeath(net.minecraft.util.DamageSource paramDamageSource); + + void realOnLivingUpdate(); + + void superOnLivingUpdate(); + + void localOnLivingUpdate(); + + void realOnKillEntity(net.minecraft.entity.EntityLivingBase paramEntityLivingBase); + + void superOnKillEntity(net.minecraft.entity.EntityLivingBase paramEntityLivingBase); + + void localOnKillEntity(net.minecraft.entity.EntityLivingBase paramEntityLivingBase); + + void realOnStruckByLightning(net.minecraft.entity.effect.EntityLightningBolt paramEntityLightningBolt); + + void superOnStruckByLightning(net.minecraft.entity.effect.EntityLightningBolt paramEntityLightningBolt); + + void localOnStruckByLightning(net.minecraft.entity.effect.EntityLightningBolt paramEntityLightningBolt); + + void realOnUpdate(); + + void superOnUpdate(); + + void localOnUpdate(); + + void realOnUpdateEntity(); + + void localOnUpdateEntity(); + + void realReadEntityFromNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound); + + void superReadEntityFromNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound); + + void localReadEntityFromNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound); + + void realSetDead(); + + void superSetDead(); + + void localSetDead(); + + void realSetEntityActionState(float paramFloat1, float paramFloat2, boolean paramBoolean1, boolean paramBoolean2); + + void localSetEntityActionState(float paramFloat1, float paramFloat2, boolean paramBoolean1, boolean paramBoolean2); + + void realSetPosition(double paramDouble1, double paramDouble2, double paramDouble3); + + void superSetPosition(double paramDouble1, double paramDouble2, double paramDouble3); + + void localSetPosition(double paramDouble1, double paramDouble2, double paramDouble3); + + void realSetSneaking(boolean paramBoolean); + + void superSetSneaking(boolean paramBoolean); + + void localSetSneaking(boolean paramBoolean); + + void realSetSprinting(boolean paramBoolean); + + void superSetSprinting(boolean paramBoolean); + + void localSetSprinting(boolean paramBoolean); + + void realSwingItem(); + + void superSwingItem(); + + void localSwingItem(); + + void realUpdateEntityActionState(); + + void superUpdateEntityActionState(); + + void localUpdateEntityActionState(); + + void realUpdatePotionEffects(); + + void superUpdatePotionEffects(); + + void localUpdatePotionEffects(); + + void realUpdateRidden(); + + void superUpdateRidden(); + + void localUpdateRidden(); + + void realWakeUpPlayer(boolean paramBoolean1, boolean paramBoolean2, boolean paramBoolean3); + + void superWakeUpPlayer(boolean paramBoolean1, boolean paramBoolean2, boolean paramBoolean3); + + void localWakeUpPlayer(boolean paramBoolean1, boolean paramBoolean2, boolean paramBoolean3); + + void realWriteEntityToNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound); + + void superWriteEntityToNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound); + + void localWriteEntityToNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound); + + boolean getAddedToChunkField(); + + void setAddedToChunkField(boolean addedToChunk); + + int getArrowHitTimerField(); + + void setArrowHitTimerField(int arrowHitTimer); + + int getAttackTimeField(); + + void setAttackTimeField(int attackTime); + + float getAttackedAtYawField(); + + void setAttackedAtYawField(float attackedAtYaw); + + net.minecraft.entity.player.EntityPlayer getAttackingPlayerField(); + + void setAttackingPlayerField(net.minecraft.entity.player.EntityPlayer attackingPlayer); + + net.minecraft.util.AxisAlignedBB getBoundingBoxField(); + + float getCameraPitchField(); + + void setCameraPitchField(float cameraPitch); + + float getCameraYawField(); + + void setCameraYawField(float cameraYaw); + + net.minecraft.entity.player.PlayerCapabilities getCapabilitiesField(); + + void setCapabilitiesField(net.minecraft.entity.player.PlayerCapabilities capabilities); + + boolean getChatColoursField(); + + void setChatColoursField(boolean chatColours); + + net.minecraft.entity.player.EntityPlayer.EnumChatVisibility getChatVisibilityField(); + + void setChatVisibilityField(net.minecraft.entity.player.EntityPlayer.EnumChatVisibility chatVisibility); + + int getChunkCoordXField(); + + void setChunkCoordXField(int chunkCoordX); + + int getChunkCoordYField(); + + void setChunkCoordYField(int chunkCoordY); + + int getChunkCoordZField(); + + void setChunkCoordZField(int chunkCoordZ); + + int getCurrentWindowIdField(); + + void setCurrentWindowIdField(int currentWindowId); + + net.minecraft.entity.DataWatcher getDataWatcherField(); + + void setDataWatcherField(net.minecraft.entity.DataWatcher dataWatcher); + + boolean getDeadField(); + + void setDeadField(boolean dead); + + int getDeathTimeField(); + + void setDeathTimeField(int deathTime); + + java.util.List<?> getDestroyedItemsNetCacheField(); + + int getDimensionField(); + + void setDimensionField(int dimension); + + float getDistanceWalkedModifiedField(); + + void setDistanceWalkedModifiedField(float distanceWalkedModified); + + float getDistanceWalkedOnStepModifiedField(); + + void setDistanceWalkedOnStepModifiedField(float distanceWalkedOnStepModified); + + int getEntityAgeField(); + + void setEntityAgeField(int entityAge); + + float getEntityCollisionReductionField(); + + void setEntityCollisionReductionField(float entityCollisionReduction); + + java.util.UUID getEntityUniqueIDField(); + + void setEntityUniqueIDField(java.util.UUID entityUniqueID); + + float getExperienceField(); + + void setExperienceField(float experience); + + int getExperienceLevelField(); + + void setExperienceLevelField(int experienceLevel); + + int getExperienceTotalField(); + + void setExperienceTotalField(int experienceTotal); + + float getFallDistanceField(); + + void setFallDistanceField(float fallDistance); + + float getField_110154_aXField(); + + void setField_110154_aXField(float field_110154_aX); + + float getField_130068_bOField(); + + void setField_130068_bOField(float field_130068_bO); + + long getField_143005_bXField(); + + void setField_143005_bXField(long field_143005_bX); + + int getField_147101_bUField(); + + void setField_147101_bUField(int field_147101_bU); + + net.minecraft.stats.StatisticsFile getField_147103_bOField(); + + boolean getField_70135_KField(); + + void setField_70135_KField(boolean field_70135_K); + + float getField_70741_aBField(); + + void setField_70741_aBField(float field_70741_aB); + + float getField_70763_axField(); + + void setField_70763_axField(float field_70763_ax); + + float getField_70764_awField(); + + void setField_70764_awField(float field_70764_aw); + + float getField_70768_auField(); + + void setField_70768_auField(float field_70768_au); + + float getField_70769_aoField(); + + void setField_70769_aoField(float field_70769_ao); + + float getField_70770_apField(); + + void setField_70770_apField(float field_70770_ap); + + float getField_71079_bUField(); + + void setField_71079_bUField(float field_71079_bU); + + float getField_71082_cxField(); + + void setField_71082_cxField(float field_71082_cx); + + double getField_71085_bRField(); + + void setField_71085_bRField(double field_71085_bR); + + float getField_71089_bVField(); + + void setField_71089_bVField(float field_71089_bV); + + double getField_71091_bMField(); + + void setField_71091_bMField(double field_71091_bM); + + double getField_71094_bPField(); + + void setField_71094_bPField(double field_71094_bP); + + double getField_71095_bQField(); + + void setField_71095_bQField(double field_71095_bQ); + + double getField_71096_bNField(); + + void setField_71096_bNField(double field_71096_bN); + + double getField_71097_bOField(); + + void setField_71097_bOField(double field_71097_bO); + + int getFireResistanceField(); + + void setFireResistanceField(int fireResistance); + + net.minecraft.entity.projectile.EntityFishHook getFishEntityField(); + + void setFishEntityField(net.minecraft.entity.projectile.EntityFishHook fishEntity); + + int getFlyToggleTimerField(); + + void setFlyToggleTimerField(int flyToggleTimer); + + net.minecraft.util.FoodStats getFoodStatsField(); + + void setFoodStatsField(net.minecraft.util.FoodStats foodStats); + + boolean getForceSpawnField(); + + void setForceSpawnField(boolean forceSpawn); + + float getHeightField(); + + void setHeightField(float height); + + int getHurtResistantTimeField(); + + void setHurtResistantTimeField(int hurtResistantTime); + + int getHurtTimeField(); + + void setHurtTimeField(int hurtTime); + + boolean getIgnoreFrustumCheckField(); + + void setIgnoreFrustumCheckField(boolean ignoreFrustumCheck); + + boolean getInPortalField(); + + void setInPortalField(boolean inPortal); + + boolean getInWaterField(); + + void setInWaterField(boolean inWater); + + net.minecraft.entity.player.InventoryPlayer getInventoryField(); + + void setInventoryField(net.minecraft.entity.player.InventoryPlayer inventory); + + net.minecraft.inventory.Container getInventoryContainerField(); + + void setInventoryContainerField(net.minecraft.inventory.Container inventoryContainer); + + boolean getIsAirBorneField(); + + void setIsAirBorneField(boolean isAirBorne); + + boolean getIsChangingQuantityOnlyField(); + + void setIsChangingQuantityOnlyField(boolean isChangingQuantityOnly); + + boolean getIsCollidedField(); + + void setIsCollidedField(boolean isCollided); + + boolean getIsCollidedHorizontallyField(); + + void setIsCollidedHorizontallyField(boolean isCollidedHorizontally); + + boolean getIsCollidedVerticallyField(); + + void setIsCollidedVerticallyField(boolean isCollidedVertically); + + boolean getIsDeadField(); + + void setIsDeadField(boolean isDead); + + boolean getIsImmuneToFireField(); + + void setIsImmuneToFireField(boolean isImmuneToFire); + + boolean getIsInWebField(); + + void setIsInWebField(boolean isInWeb); + + boolean getIsJumpingField(); + + void setIsJumpingField(boolean isJumping); + + boolean getIsSwingInProgressField(); + + void setIsSwingInProgressField(boolean isSwingInProgress); + + float getJumpMovementFactorField(); + + void setJumpMovementFactorField(float jumpMovementFactor); + + float getLastDamageField(); + + void setLastDamageField(float lastDamage); + + int getLastExperienceField(); + + void setLastExperienceField(int lastExperience); + + int getLastFoodLevelField(); + + void setLastFoodLevelField(int lastFoodLevel); + + float getLastHealthField(); + + void setLastHealthField(float lastHealth); + + double getLastTickPosXField(); + + void setLastTickPosXField(double lastTickPosX); + + double getLastTickPosYField(); + + void setLastTickPosYField(double lastTickPosY); + + double getLastTickPosZField(); + + void setLastTickPosZField(double lastTickPosZ); + + float getLimbSwingField(); + + void setLimbSwingField(float limbSwing); + + float getLimbSwingAmountField(); + + void setLimbSwingAmountField(float limbSwingAmount); + + java.util.List<?> getLoadedChunksField(); + + org.apache.logging.log4j.Logger getLoggerField(); + + double getManagedPosXField(); + + void setManagedPosXField(double managedPosX); + + double getManagedPosZField(); + + void setManagedPosZField(double managedPosZ); + + int getMaxHurtResistantTimeField(); + + void setMaxHurtResistantTimeField(int maxHurtResistantTime); + + int getMaxHurtTimeField(); + + void setMaxHurtTimeField(int maxHurtTime); + + net.minecraft.server.MinecraftServer getMcServerField(); + + double getMotionXField(); + + void setMotionXField(double motionX); + + double getMotionYField(); + + void setMotionYField(double motionY); + + double getMotionZField(); + + void setMotionZField(double motionZ); + + float getMoveForwardField(); + + void setMoveForwardField(float moveForward); + + float getMoveStrafingField(); + + void setMoveStrafingField(float moveStrafing); + + net.minecraft.entity.Entity.EnumEntitySize getMyEntitySizeField(); + + void setMyEntitySizeField(net.minecraft.entity.Entity.EnumEntitySize myEntitySize); + + int getNewPosRotationIncrementsField(); + + void setNewPosRotationIncrementsField(int newPosRotationIncrements); + + double getNewPosXField(); + + void setNewPosXField(double newPosX); + + double getNewPosYField(); + + void setNewPosYField(double newPosY); + + double getNewPosZField(); + + void setNewPosZField(double newPosZ); + + double getNewRotationPitchField(); + + void setNewRotationPitchField(double newRotationPitch); + + double getNewRotationYawField(); + + void setNewRotationYawField(double newRotationYaw); + + boolean getNoClipField(); + + void setNoClipField(boolean noClip); + + boolean getOnGroundField(); + + void setOnGroundField(boolean onGround); + + net.minecraft.inventory.Container getOpenContainerField(); + + void setOpenContainerField(net.minecraft.inventory.Container openContainer); + + int getPingField(); + + void setPingField(int ping); + + boolean getPlayerConqueredTheEndField(); + + void setPlayerConqueredTheEndField(boolean playerConqueredTheEnd); + + net.minecraft.util.ChunkCoordinates getPlayerLocationField(); + + void setPlayerLocationField(net.minecraft.util.ChunkCoordinates playerLocation); + + net.minecraft.network.NetHandlerPlayServer getPlayerNetServerHandlerField(); + + void setPlayerNetServerHandlerField(net.minecraft.network.NetHandlerPlayServer playerNetServerHandler); + + int getPortalCounterField(); + + void setPortalCounterField(int portalCounter); + + double getPosXField(); + + void setPosXField(double posX); + + double getPosYField(); + + void setPosYField(double posY); + + double getPosZField(); + + void setPosZField(double posZ); + + float getPrevCameraPitchField(); + + void setPrevCameraPitchField(float prevCameraPitch); + + float getPrevCameraYawField(); + + void setPrevCameraYawField(float prevCameraYaw); + + float getPrevDistanceWalkedModifiedField(); + + void setPrevDistanceWalkedModifiedField(float prevDistanceWalkedModified); + + float getPrevHealthField(); + + void setPrevHealthField(float prevHealth); + + float getPrevLimbSwingAmountField(); + + void setPrevLimbSwingAmountField(float prevLimbSwingAmount); + + double getPrevPosXField(); + + void setPrevPosXField(double prevPosX); + + double getPrevPosYField(); + + void setPrevPosYField(double prevPosY); + + double getPrevPosZField(); + + void setPrevPosZField(double prevPosZ); + + float getPrevRenderYawOffsetField(); + + void setPrevRenderYawOffsetField(float prevRenderYawOffset); + + float getPrevRotationPitchField(); + + void setPrevRotationPitchField(float prevRotationPitch); + + float getPrevRotationYawField(); + + void setPrevRotationYawField(float prevRotationYaw); + + float getPrevRotationYawHeadField(); + + void setPrevRotationYawHeadField(float prevRotationYawHead); + + float getPrevSwingProgressField(); + + void setPrevSwingProgressField(float prevSwingProgress); + + boolean getPreventEntitySpawningField(); + + void setPreventEntitySpawningField(boolean preventEntitySpawning); + + java.util.Random getRandField(); + + void setRandField(java.util.Random rand); + + float getRandomYawVelocityField(); + + void setRandomYawVelocityField(float randomYawVelocity); + + int getRecentlyHitField(); + + void setRecentlyHitField(int recentlyHit); + + double getRenderDistanceWeightField(); + + void setRenderDistanceWeightField(double renderDistanceWeight); + + float getRenderYawOffsetField(); + + void setRenderYawOffsetField(float renderYawOffset); + + net.minecraft.entity.Entity getRiddenByEntityField(); + + void setRiddenByEntityField(net.minecraft.entity.Entity riddenByEntity); + + net.minecraft.entity.Entity getRidingEntityField(); + + void setRidingEntityField(net.minecraft.entity.Entity ridingEntity); + + float getRotationPitchField(); + + void setRotationPitchField(float rotationPitch); + + float getRotationYawField(); + + void setRotationYawField(float rotationYaw); + + float getRotationYawHeadField(); + + void setRotationYawHeadField(float rotationYawHead); + + int getScoreValueField(); + + void setScoreValueField(int scoreValue); + + int getServerPosXField(); + + void setServerPosXField(int serverPosX); + + int getServerPosYField(); + + void setServerPosYField(int serverPosY); + + int getServerPosZField(); + + void setServerPosZField(int serverPosZ); + + boolean getSleepingField(); + + void setSleepingField(boolean sleeping); + + float getSpeedInAirField(); + + void setSpeedInAirField(float speedInAir); + + float getSpeedOnGroundField(); + + void setSpeedOnGroundField(float speedOnGround); + + float getStepHeightField(); + + void setStepHeightField(float stepHeight); + + float getSwingProgressField(); + + void setSwingProgressField(float swingProgress); + + int getSwingProgressIntField(); + + void setSwingProgressIntField(int swingProgressInt); + + int getTeleportDirectionField(); + + void setTeleportDirectionField(int teleportDirection); + + net.minecraft.server.management.ItemInWorldManager getTheItemInWorldManagerField(); + + int getTicksExistedField(); + + void setTicksExistedField(int ticksExisted); + + int getTimeUntilPortalField(); + + void setTimeUntilPortalField(int timeUntilPortal); + + java.lang.String getTranslatorField(); + + void setTranslatorField(java.lang.String translator); + + boolean getVelocityChangedField(); + + void setVelocityChangedField(boolean velocityChanged); + + boolean getWasHungryField(); + + void setWasHungryField(boolean wasHungry); + + float getWidthField(); + + void setWidthField(float width); + + net.minecraft.world.World getWorldObjField(); + + void setWorldObjField(net.minecraft.world.World worldObj); + + int getXpCooldownField(); + + void setXpCooldownField(int xpCooldown); + + float getYOffsetField(); + + void setYOffsetField(float yOffset); + + float getYSizeField(); + + void setYSizeField(float ySize); + +} diff --git a/src/Java/api/player/server/IServerPlayerAPI.java b/src/Java/api/player/server/IServerPlayerAPI.java new file mode 100644 index 0000000000..29a4cf6a49 --- /dev/null +++ b/src/Java/api/player/server/IServerPlayerAPI.java @@ -0,0 +1,26 @@ +// ================================================================== +// This file is part of Player API. +// +// Player API is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// Player API is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and the GNU General Public License along with Player API. +// If not, see <http://www.gnu.org/licenses/>. +// ================================================================== + +package api.player.server; + +public interface IServerPlayerAPI extends IServerPlayer +{ + ServerPlayerAPI getServerPlayerAPI(); + + net.minecraft.entity.player.EntityPlayerMP getEntityPlayerMP(); +} diff --git a/src/Java/api/player/server/ServerPlayerAPI.java b/src/Java/api/player/server/ServerPlayerAPI.java new file mode 100644 index 0000000000..381c607a1e --- /dev/null +++ b/src/Java/api/player/server/ServerPlayerAPI.java @@ -0,0 +1,6017 @@ +// ================================================================== +// This file is part of Player API. +// +// Player API is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// Player API is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and the GNU General Public License along with Player API. +// If not, see <http://www.gnu.org/licenses/>. +// ================================================================== + +package api.player.server; + +import java.io.*; +import java.text.*; +import java.util.*; +import java.util.logging.*; +import java.lang.reflect.*; + +public final class ServerPlayerAPI +{ + private final static Class<?>[] Class = new Class[] { ServerPlayerAPI.class }; + private final static Class<?>[] Classes = new Class[] { ServerPlayerAPI.class, String.class }; + + private static boolean isCreated; + private static final Logger logger = Logger.getLogger("ServerPlayerAPI"); + + private static void log(String text) + { + System.out.println(text); + logger.fine(text); + } + + public static void register(String id, Class<?> baseClass) + { + register(id, baseClass, null); + } + + public static void register(String id, Class<?> baseClass, ServerPlayerBaseSorting baseSorting) + { + try + { + register(baseClass, id, baseSorting); + } + catch(RuntimeException exception) + { + if(id != null) + log("Server Player: failed to register id '" + id + "'"); + else + log("Server Player: failed to register ServerPlayerBase"); + + throw exception; + } + } + + private static void register(Class<?> baseClass, String id, ServerPlayerBaseSorting baseSorting) + { + if(!isCreated) + { + try + { + Method mandatory = net.minecraft.entity.player.EntityPlayerMP.class.getMethod("getServerPlayerBase", String.class); + if (mandatory.getReturnType() != ServerPlayerBase.class) + throw new NoSuchMethodException(ServerPlayerBase.class.getName() + " " + net.minecraft.entity.player.EntityPlayerMP.class.getName() + ".getServerPlayerBase(" + String.class.getName() + ")"); + } + catch(NoSuchMethodException exception) + { + String[] errorMessageParts = new String[] + { + "========================================", + "The API \"Server Player\" version " + api.player.forge.PlayerAPIPlugin.Version + " of the mod \"Player API Core " + api.player.forge.PlayerAPIPlugin.Version + "\" can not be created!", + "----------------------------------------", + "Mandatory member method \"{0} getServerPlayerBase({3})\" not found in class \"{1}\".", + "There are three scenarios this can happen:", + "* Minecraft Forge is missing a Player API Core which Minecraft version matches its own.", + " Download and install the latest Player API Core for the Minecraft version you were trying to run.", + "* The code of the class \"{2}\" of Player API Core has been modified beyond recognition by another Minecraft Forge coremod.", + " Try temporary deinstallation of other core mods to find the culprit and deinstall it permanently to fix this specific problem.", + "* Player API Core has not been installed correctly.", + " Deinstall Player API Core and install it again following the installation instructions in the readme file.", + "========================================" + }; + + String baseEntityPlayerMPClassName = ServerPlayerBase.class.getName(); + String targetClassName = net.minecraft.entity.player.EntityPlayerMP.class.getName(); + String targetClassFileName = targetClassName.replace(".", File.separator); + String stringClassName = String.class.getName(); + + for(int i=0; i<errorMessageParts.length; i++) + errorMessageParts[i] = MessageFormat.format(errorMessageParts[i], baseEntityPlayerMPClassName, targetClassName, targetClassFileName, stringClassName); + + for(String errorMessagePart : errorMessageParts) + logger.severe(errorMessagePart); + + for(String errorMessagePart : errorMessageParts) + System.err.println(errorMessagePart); + + String errorMessage = "\n\n"; + for(String errorMessagePart : errorMessageParts) + errorMessage += "\t" + errorMessagePart + "\n"; + + throw new RuntimeException(errorMessage, exception); + } + + log("Server Player " + api.player.forge.PlayerAPIPlugin.Version + " Created"); + isCreated = true; + } + + if(id == null) + throw new NullPointerException("Argument 'id' can not be null"); + if(baseClass == null) + throw new NullPointerException("Argument 'baseClass' can not be null"); + + Constructor<?> allreadyRegistered = allBaseConstructors.get(id); + if(allreadyRegistered != null) + throw new IllegalArgumentException("The class '" + baseClass.getName() + "' can not be registered with the id '" + id + "' because the class '" + allreadyRegistered.getDeclaringClass().getName() + "' has allready been registered with the same id"); + + Constructor<?> baseConstructor; + try + { + baseConstructor = baseClass.getDeclaredConstructor(Classes); + } + catch (Throwable t) + { + try + { + baseConstructor = baseClass.getDeclaredConstructor(Class); + } + catch(Throwable s) + { + throw new IllegalArgumentException("Can not find necessary constructor with one argument of type '" + ServerPlayerAPI.class.getName() + "' and eventually a second argument of type 'String' in the class '" + baseClass.getName() + "'", t); + } + } + + allBaseConstructors.put(id, baseConstructor); + + if(baseSorting != null) + { + addSorting(id, allBaseBeforeLocalConstructingSuperiors, baseSorting.getBeforeLocalConstructingSuperiors()); + addSorting(id, allBaseBeforeLocalConstructingInferiors, baseSorting.getBeforeLocalConstructingInferiors()); + addSorting(id, allBaseAfterLocalConstructingSuperiors, baseSorting.getAfterLocalConstructingSuperiors()); + addSorting(id, allBaseAfterLocalConstructingInferiors, baseSorting.getAfterLocalConstructingInferiors()); + + addDynamicSorting(id, allBaseBeforeDynamicSuperiors, baseSorting.getDynamicBeforeSuperiors()); + addDynamicSorting(id, allBaseBeforeDynamicInferiors, baseSorting.getDynamicBeforeInferiors()); + addDynamicSorting(id, allBaseOverrideDynamicSuperiors, baseSorting.getDynamicOverrideSuperiors()); + addDynamicSorting(id, allBaseOverrideDynamicInferiors, baseSorting.getDynamicOverrideInferiors()); + addDynamicSorting(id, allBaseAfterDynamicSuperiors, baseSorting.getDynamicAfterSuperiors()); + addDynamicSorting(id, allBaseAfterDynamicInferiors, baseSorting.getDynamicAfterInferiors()); + + addSorting(id, allBaseBeforeAddExhaustionSuperiors, baseSorting.getBeforeAddExhaustionSuperiors()); + addSorting(id, allBaseBeforeAddExhaustionInferiors, baseSorting.getBeforeAddExhaustionInferiors()); + addSorting(id, allBaseOverrideAddExhaustionSuperiors, baseSorting.getOverrideAddExhaustionSuperiors()); + addSorting(id, allBaseOverrideAddExhaustionInferiors, baseSorting.getOverrideAddExhaustionInferiors()); + addSorting(id, allBaseAfterAddExhaustionSuperiors, baseSorting.getAfterAddExhaustionSuperiors()); + addSorting(id, allBaseAfterAddExhaustionInferiors, baseSorting.getAfterAddExhaustionInferiors()); + + addSorting(id, allBaseBeforeAddExperienceSuperiors, baseSorting.getBeforeAddExperienceSuperiors()); + addSorting(id, allBaseBeforeAddExperienceInferiors, baseSorting.getBeforeAddExperienceInferiors()); + addSorting(id, allBaseOverrideAddExperienceSuperiors, baseSorting.getOverrideAddExperienceSuperiors()); + addSorting(id, allBaseOverrideAddExperienceInferiors, baseSorting.getOverrideAddExperienceInferiors()); + addSorting(id, allBaseAfterAddExperienceSuperiors, baseSorting.getAfterAddExperienceSuperiors()); + addSorting(id, allBaseAfterAddExperienceInferiors, baseSorting.getAfterAddExperienceInferiors()); + + addSorting(id, allBaseBeforeAddExperienceLevelSuperiors, baseSorting.getBeforeAddExperienceLevelSuperiors()); + addSorting(id, allBaseBeforeAddExperienceLevelInferiors, baseSorting.getBeforeAddExperienceLevelInferiors()); + addSorting(id, allBaseOverrideAddExperienceLevelSuperiors, baseSorting.getOverrideAddExperienceLevelSuperiors()); + addSorting(id, allBaseOverrideAddExperienceLevelInferiors, baseSorting.getOverrideAddExperienceLevelInferiors()); + addSorting(id, allBaseAfterAddExperienceLevelSuperiors, baseSorting.getAfterAddExperienceLevelSuperiors()); + addSorting(id, allBaseAfterAddExperienceLevelInferiors, baseSorting.getAfterAddExperienceLevelInferiors()); + + addSorting(id, allBaseBeforeAddMovementStatSuperiors, baseSorting.getBeforeAddMovementStatSuperiors()); + addSorting(id, allBaseBeforeAddMovementStatInferiors, baseSorting.getBeforeAddMovementStatInferiors()); + addSorting(id, allBaseOverrideAddMovementStatSuperiors, baseSorting.getOverrideAddMovementStatSuperiors()); + addSorting(id, allBaseOverrideAddMovementStatInferiors, baseSorting.getOverrideAddMovementStatInferiors()); + addSorting(id, allBaseAfterAddMovementStatSuperiors, baseSorting.getAfterAddMovementStatSuperiors()); + addSorting(id, allBaseAfterAddMovementStatInferiors, baseSorting.getAfterAddMovementStatInferiors()); + + addSorting(id, allBaseBeforeAttackEntityFromSuperiors, baseSorting.getBeforeAttackEntityFromSuperiors()); + addSorting(id, allBaseBeforeAttackEntityFromInferiors, baseSorting.getBeforeAttackEntityFromInferiors()); + addSorting(id, allBaseOverrideAttackEntityFromSuperiors, baseSorting.getOverrideAttackEntityFromSuperiors()); + addSorting(id, allBaseOverrideAttackEntityFromInferiors, baseSorting.getOverrideAttackEntityFromInferiors()); + addSorting(id, allBaseAfterAttackEntityFromSuperiors, baseSorting.getAfterAttackEntityFromSuperiors()); + addSorting(id, allBaseAfterAttackEntityFromInferiors, baseSorting.getAfterAttackEntityFromInferiors()); + + addSorting(id, allBaseBeforeAttackTargetEntityWithCurrentItemSuperiors, baseSorting.getBeforeAttackTargetEntityWithCurrentItemSuperiors()); + addSorting(id, allBaseBeforeAttackTargetEntityWithCurrentItemInferiors, baseSorting.getBeforeAttackTargetEntityWithCurrentItemInferiors()); + addSorting(id, allBaseOverrideAttackTargetEntityWithCurrentItemSuperiors, baseSorting.getOverrideAttackTargetEntityWithCurrentItemSuperiors()); + addSorting(id, allBaseOverrideAttackTargetEntityWithCurrentItemInferiors, baseSorting.getOverrideAttackTargetEntityWithCurrentItemInferiors()); + addSorting(id, allBaseAfterAttackTargetEntityWithCurrentItemSuperiors, baseSorting.getAfterAttackTargetEntityWithCurrentItemSuperiors()); + addSorting(id, allBaseAfterAttackTargetEntityWithCurrentItemInferiors, baseSorting.getAfterAttackTargetEntityWithCurrentItemInferiors()); + + addSorting(id, allBaseBeforeCanBreatheUnderwaterSuperiors, baseSorting.getBeforeCanBreatheUnderwaterSuperiors()); + addSorting(id, allBaseBeforeCanBreatheUnderwaterInferiors, baseSorting.getBeforeCanBreatheUnderwaterInferiors()); + addSorting(id, allBaseOverrideCanBreatheUnderwaterSuperiors, baseSorting.getOverrideCanBreatheUnderwaterSuperiors()); + addSorting(id, allBaseOverrideCanBreatheUnderwaterInferiors, baseSorting.getOverrideCanBreatheUnderwaterInferiors()); + addSorting(id, allBaseAfterCanBreatheUnderwaterSuperiors, baseSorting.getAfterCanBreatheUnderwaterSuperiors()); + addSorting(id, allBaseAfterCanBreatheUnderwaterInferiors, baseSorting.getAfterCanBreatheUnderwaterInferiors()); + + addSorting(id, allBaseBeforeCanHarvestBlockSuperiors, baseSorting.getBeforeCanHarvestBlockSuperiors()); + addSorting(id, allBaseBeforeCanHarvestBlockInferiors, baseSorting.getBeforeCanHarvestBlockInferiors()); + addSorting(id, allBaseOverrideCanHarvestBlockSuperiors, baseSorting.getOverrideCanHarvestBlockSuperiors()); + addSorting(id, allBaseOverrideCanHarvestBlockInferiors, baseSorting.getOverrideCanHarvestBlockInferiors()); + addSorting(id, allBaseAfterCanHarvestBlockSuperiors, baseSorting.getAfterCanHarvestBlockSuperiors()); + addSorting(id, allBaseAfterCanHarvestBlockInferiors, baseSorting.getAfterCanHarvestBlockInferiors()); + + addSorting(id, allBaseBeforeCanPlayerEditSuperiors, baseSorting.getBeforeCanPlayerEditSuperiors()); + addSorting(id, allBaseBeforeCanPlayerEditInferiors, baseSorting.getBeforeCanPlayerEditInferiors()); + addSorting(id, allBaseOverrideCanPlayerEditSuperiors, baseSorting.getOverrideCanPlayerEditSuperiors()); + addSorting(id, allBaseOverrideCanPlayerEditInferiors, baseSorting.getOverrideCanPlayerEditInferiors()); + addSorting(id, allBaseAfterCanPlayerEditSuperiors, baseSorting.getAfterCanPlayerEditSuperiors()); + addSorting(id, allBaseAfterCanPlayerEditInferiors, baseSorting.getAfterCanPlayerEditInferiors()); + + addSorting(id, allBaseBeforeCanTriggerWalkingSuperiors, baseSorting.getBeforeCanTriggerWalkingSuperiors()); + addSorting(id, allBaseBeforeCanTriggerWalkingInferiors, baseSorting.getBeforeCanTriggerWalkingInferiors()); + addSorting(id, allBaseOverrideCanTriggerWalkingSuperiors, baseSorting.getOverrideCanTriggerWalkingSuperiors()); + addSorting(id, allBaseOverrideCanTriggerWalkingInferiors, baseSorting.getOverrideCanTriggerWalkingInferiors()); + addSorting(id, allBaseAfterCanTriggerWalkingSuperiors, baseSorting.getAfterCanTriggerWalkingSuperiors()); + addSorting(id, allBaseAfterCanTriggerWalkingInferiors, baseSorting.getAfterCanTriggerWalkingInferiors()); + + addSorting(id, allBaseBeforeClonePlayerSuperiors, baseSorting.getBeforeClonePlayerSuperiors()); + addSorting(id, allBaseBeforeClonePlayerInferiors, baseSorting.getBeforeClonePlayerInferiors()); + addSorting(id, allBaseOverrideClonePlayerSuperiors, baseSorting.getOverrideClonePlayerSuperiors()); + addSorting(id, allBaseOverrideClonePlayerInferiors, baseSorting.getOverrideClonePlayerInferiors()); + addSorting(id, allBaseAfterClonePlayerSuperiors, baseSorting.getAfterClonePlayerSuperiors()); + addSorting(id, allBaseAfterClonePlayerInferiors, baseSorting.getAfterClonePlayerInferiors()); + + addSorting(id, allBaseBeforeDamageEntitySuperiors, baseSorting.getBeforeDamageEntitySuperiors()); + addSorting(id, allBaseBeforeDamageEntityInferiors, baseSorting.getBeforeDamageEntityInferiors()); + addSorting(id, allBaseOverrideDamageEntitySuperiors, baseSorting.getOverrideDamageEntitySuperiors()); + addSorting(id, allBaseOverrideDamageEntityInferiors, baseSorting.getOverrideDamageEntityInferiors()); + addSorting(id, allBaseAfterDamageEntitySuperiors, baseSorting.getAfterDamageEntitySuperiors()); + addSorting(id, allBaseAfterDamageEntityInferiors, baseSorting.getAfterDamageEntityInferiors()); + + addSorting(id, allBaseBeforeDisplayGUIChestSuperiors, baseSorting.getBeforeDisplayGUIChestSuperiors()); + addSorting(id, allBaseBeforeDisplayGUIChestInferiors, baseSorting.getBeforeDisplayGUIChestInferiors()); + addSorting(id, allBaseOverrideDisplayGUIChestSuperiors, baseSorting.getOverrideDisplayGUIChestSuperiors()); + addSorting(id, allBaseOverrideDisplayGUIChestInferiors, baseSorting.getOverrideDisplayGUIChestInferiors()); + addSorting(id, allBaseAfterDisplayGUIChestSuperiors, baseSorting.getAfterDisplayGUIChestSuperiors()); + addSorting(id, allBaseAfterDisplayGUIChestInferiors, baseSorting.getAfterDisplayGUIChestInferiors()); + + addSorting(id, allBaseBeforeDisplayGUIDispenserSuperiors, baseSorting.getBeforeDisplayGUIDispenserSuperiors()); + addSorting(id, allBaseBeforeDisplayGUIDispenserInferiors, baseSorting.getBeforeDisplayGUIDispenserInferiors()); + addSorting(id, allBaseOverrideDisplayGUIDispenserSuperiors, baseSorting.getOverrideDisplayGUIDispenserSuperiors()); + addSorting(id, allBaseOverrideDisplayGUIDispenserInferiors, baseSorting.getOverrideDisplayGUIDispenserInferiors()); + addSorting(id, allBaseAfterDisplayGUIDispenserSuperiors, baseSorting.getAfterDisplayGUIDispenserSuperiors()); + addSorting(id, allBaseAfterDisplayGUIDispenserInferiors, baseSorting.getAfterDisplayGUIDispenserInferiors()); + + addSorting(id, allBaseBeforeDisplayGUIFurnaceSuperiors, baseSorting.getBeforeDisplayGUIFurnaceSuperiors()); + addSorting(id, allBaseBeforeDisplayGUIFurnaceInferiors, baseSorting.getBeforeDisplayGUIFurnaceInferiors()); + addSorting(id, allBaseOverrideDisplayGUIFurnaceSuperiors, baseSorting.getOverrideDisplayGUIFurnaceSuperiors()); + addSorting(id, allBaseOverrideDisplayGUIFurnaceInferiors, baseSorting.getOverrideDisplayGUIFurnaceInferiors()); + addSorting(id, allBaseAfterDisplayGUIFurnaceSuperiors, baseSorting.getAfterDisplayGUIFurnaceSuperiors()); + addSorting(id, allBaseAfterDisplayGUIFurnaceInferiors, baseSorting.getAfterDisplayGUIFurnaceInferiors()); + + addSorting(id, allBaseBeforeDisplayGUIWorkbenchSuperiors, baseSorting.getBeforeDisplayGUIWorkbenchSuperiors()); + addSorting(id, allBaseBeforeDisplayGUIWorkbenchInferiors, baseSorting.getBeforeDisplayGUIWorkbenchInferiors()); + addSorting(id, allBaseOverrideDisplayGUIWorkbenchSuperiors, baseSorting.getOverrideDisplayGUIWorkbenchSuperiors()); + addSorting(id, allBaseOverrideDisplayGUIWorkbenchInferiors, baseSorting.getOverrideDisplayGUIWorkbenchInferiors()); + addSorting(id, allBaseAfterDisplayGUIWorkbenchSuperiors, baseSorting.getAfterDisplayGUIWorkbenchSuperiors()); + addSorting(id, allBaseAfterDisplayGUIWorkbenchInferiors, baseSorting.getAfterDisplayGUIWorkbenchInferiors()); + + addSorting(id, allBaseBeforeDropOneItemSuperiors, baseSorting.getBeforeDropOneItemSuperiors()); + addSorting(id, allBaseBeforeDropOneItemInferiors, baseSorting.getBeforeDropOneItemInferiors()); + addSorting(id, allBaseOverrideDropOneItemSuperiors, baseSorting.getOverrideDropOneItemSuperiors()); + addSorting(id, allBaseOverrideDropOneItemInferiors, baseSorting.getOverrideDropOneItemInferiors()); + addSorting(id, allBaseAfterDropOneItemSuperiors, baseSorting.getAfterDropOneItemSuperiors()); + addSorting(id, allBaseAfterDropOneItemInferiors, baseSorting.getAfterDropOneItemInferiors()); + + addSorting(id, allBaseBeforeDropPlayerItemSuperiors, baseSorting.getBeforeDropPlayerItemSuperiors()); + addSorting(id, allBaseBeforeDropPlayerItemInferiors, baseSorting.getBeforeDropPlayerItemInferiors()); + addSorting(id, allBaseOverrideDropPlayerItemSuperiors, baseSorting.getOverrideDropPlayerItemSuperiors()); + addSorting(id, allBaseOverrideDropPlayerItemInferiors, baseSorting.getOverrideDropPlayerItemInferiors()); + addSorting(id, allBaseAfterDropPlayerItemSuperiors, baseSorting.getAfterDropPlayerItemSuperiors()); + addSorting(id, allBaseAfterDropPlayerItemInferiors, baseSorting.getAfterDropPlayerItemInferiors()); + + addSorting(id, allBaseBeforeFallSuperiors, baseSorting.getBeforeFallSuperiors()); + addSorting(id, allBaseBeforeFallInferiors, baseSorting.getBeforeFallInferiors()); + addSorting(id, allBaseOverrideFallSuperiors, baseSorting.getOverrideFallSuperiors()); + addSorting(id, allBaseOverrideFallInferiors, baseSorting.getOverrideFallInferiors()); + addSorting(id, allBaseAfterFallSuperiors, baseSorting.getAfterFallSuperiors()); + addSorting(id, allBaseAfterFallInferiors, baseSorting.getAfterFallInferiors()); + + addSorting(id, allBaseBeforeGetAIMoveSpeedSuperiors, baseSorting.getBeforeGetAIMoveSpeedSuperiors()); + addSorting(id, allBaseBeforeGetAIMoveSpeedInferiors, baseSorting.getBeforeGetAIMoveSpeedInferiors()); + addSorting(id, allBaseOverrideGetAIMoveSpeedSuperiors, baseSorting.getOverrideGetAIMoveSpeedSuperiors()); + addSorting(id, allBaseOverrideGetAIMoveSpeedInferiors, baseSorting.getOverrideGetAIMoveSpeedInferiors()); + addSorting(id, allBaseAfterGetAIMoveSpeedSuperiors, baseSorting.getAfterGetAIMoveSpeedSuperiors()); + addSorting(id, allBaseAfterGetAIMoveSpeedInferiors, baseSorting.getAfterGetAIMoveSpeedInferiors()); + + addSorting(id, allBaseBeforeGetCurrentPlayerStrVsBlockSuperiors, baseSorting.getBeforeGetCurrentPlayerStrVsBlockSuperiors()); + addSorting(id, allBaseBeforeGetCurrentPlayerStrVsBlockInferiors, baseSorting.getBeforeGetCurrentPlayerStrVsBlockInferiors()); + addSorting(id, allBaseOverrideGetCurrentPlayerStrVsBlockSuperiors, baseSorting.getOverrideGetCurrentPlayerStrVsBlockSuperiors()); + addSorting(id, allBaseOverrideGetCurrentPlayerStrVsBlockInferiors, baseSorting.getOverrideGetCurrentPlayerStrVsBlockInferiors()); + addSorting(id, allBaseAfterGetCurrentPlayerStrVsBlockSuperiors, baseSorting.getAfterGetCurrentPlayerStrVsBlockSuperiors()); + addSorting(id, allBaseAfterGetCurrentPlayerStrVsBlockInferiors, baseSorting.getAfterGetCurrentPlayerStrVsBlockInferiors()); + + addSorting(id, allBaseBeforeGetCurrentPlayerStrVsBlockForgeSuperiors, baseSorting.getBeforeGetCurrentPlayerStrVsBlockForgeSuperiors()); + addSorting(id, allBaseBeforeGetCurrentPlayerStrVsBlockForgeInferiors, baseSorting.getBeforeGetCurrentPlayerStrVsBlockForgeInferiors()); + addSorting(id, allBaseOverrideGetCurrentPlayerStrVsBlockForgeSuperiors, baseSorting.getOverrideGetCurrentPlayerStrVsBlockForgeSuperiors()); + addSorting(id, allBaseOverrideGetCurrentPlayerStrVsBlockForgeInferiors, baseSorting.getOverrideGetCurrentPlayerStrVsBlockForgeInferiors()); + addSorting(id, allBaseAfterGetCurrentPlayerStrVsBlockForgeSuperiors, baseSorting.getAfterGetCurrentPlayerStrVsBlockForgeSuperiors()); + addSorting(id, allBaseAfterGetCurrentPlayerStrVsBlockForgeInferiors, baseSorting.getAfterGetCurrentPlayerStrVsBlockForgeInferiors()); + + addSorting(id, allBaseBeforeGetDistanceSqSuperiors, baseSorting.getBeforeGetDistanceSqSuperiors()); + addSorting(id, allBaseBeforeGetDistanceSqInferiors, baseSorting.getBeforeGetDistanceSqInferiors()); + addSorting(id, allBaseOverrideGetDistanceSqSuperiors, baseSorting.getOverrideGetDistanceSqSuperiors()); + addSorting(id, allBaseOverrideGetDistanceSqInferiors, baseSorting.getOverrideGetDistanceSqInferiors()); + addSorting(id, allBaseAfterGetDistanceSqSuperiors, baseSorting.getAfterGetDistanceSqSuperiors()); + addSorting(id, allBaseAfterGetDistanceSqInferiors, baseSorting.getAfterGetDistanceSqInferiors()); + + addSorting(id, allBaseBeforeGetBrightnessSuperiors, baseSorting.getBeforeGetBrightnessSuperiors()); + addSorting(id, allBaseBeforeGetBrightnessInferiors, baseSorting.getBeforeGetBrightnessInferiors()); + addSorting(id, allBaseOverrideGetBrightnessSuperiors, baseSorting.getOverrideGetBrightnessSuperiors()); + addSorting(id, allBaseOverrideGetBrightnessInferiors, baseSorting.getOverrideGetBrightnessInferiors()); + addSorting(id, allBaseAfterGetBrightnessSuperiors, baseSorting.getAfterGetBrightnessSuperiors()); + addSorting(id, allBaseAfterGetBrightnessInferiors, baseSorting.getAfterGetBrightnessInferiors()); + + addSorting(id, allBaseBeforeGetEyeHeightSuperiors, baseSorting.getBeforeGetEyeHeightSuperiors()); + addSorting(id, allBaseBeforeGetEyeHeightInferiors, baseSorting.getBeforeGetEyeHeightInferiors()); + addSorting(id, allBaseOverrideGetEyeHeightSuperiors, baseSorting.getOverrideGetEyeHeightSuperiors()); + addSorting(id, allBaseOverrideGetEyeHeightInferiors, baseSorting.getOverrideGetEyeHeightInferiors()); + addSorting(id, allBaseAfterGetEyeHeightSuperiors, baseSorting.getAfterGetEyeHeightSuperiors()); + addSorting(id, allBaseAfterGetEyeHeightInferiors, baseSorting.getAfterGetEyeHeightInferiors()); + + addSorting(id, allBaseBeforeHealSuperiors, baseSorting.getBeforeHealSuperiors()); + addSorting(id, allBaseBeforeHealInferiors, baseSorting.getBeforeHealInferiors()); + addSorting(id, allBaseOverrideHealSuperiors, baseSorting.getOverrideHealSuperiors()); + addSorting(id, allBaseOverrideHealInferiors, baseSorting.getOverrideHealInferiors()); + addSorting(id, allBaseAfterHealSuperiors, baseSorting.getAfterHealSuperiors()); + addSorting(id, allBaseAfterHealInferiors, baseSorting.getAfterHealInferiors()); + + addSorting(id, allBaseBeforeIsEntityInsideOpaqueBlockSuperiors, baseSorting.getBeforeIsEntityInsideOpaqueBlockSuperiors()); + addSorting(id, allBaseBeforeIsEntityInsideOpaqueBlockInferiors, baseSorting.getBeforeIsEntityInsideOpaqueBlockInferiors()); + addSorting(id, allBaseOverrideIsEntityInsideOpaqueBlockSuperiors, baseSorting.getOverrideIsEntityInsideOpaqueBlockSuperiors()); + addSorting(id, allBaseOverrideIsEntityInsideOpaqueBlockInferiors, baseSorting.getOverrideIsEntityInsideOpaqueBlockInferiors()); + addSorting(id, allBaseAfterIsEntityInsideOpaqueBlockSuperiors, baseSorting.getAfterIsEntityInsideOpaqueBlockSuperiors()); + addSorting(id, allBaseAfterIsEntityInsideOpaqueBlockInferiors, baseSorting.getAfterIsEntityInsideOpaqueBlockInferiors()); + + addSorting(id, allBaseBeforeIsInWaterSuperiors, baseSorting.getBeforeIsInWaterSuperiors()); + addSorting(id, allBaseBeforeIsInWaterInferiors, baseSorting.getBeforeIsInWaterInferiors()); + addSorting(id, allBaseOverrideIsInWaterSuperiors, baseSorting.getOverrideIsInWaterSuperiors()); + addSorting(id, allBaseOverrideIsInWaterInferiors, baseSorting.getOverrideIsInWaterInferiors()); + addSorting(id, allBaseAfterIsInWaterSuperiors, baseSorting.getAfterIsInWaterSuperiors()); + addSorting(id, allBaseAfterIsInWaterInferiors, baseSorting.getAfterIsInWaterInferiors()); + + addSorting(id, allBaseBeforeIsInsideOfMaterialSuperiors, baseSorting.getBeforeIsInsideOfMaterialSuperiors()); + addSorting(id, allBaseBeforeIsInsideOfMaterialInferiors, baseSorting.getBeforeIsInsideOfMaterialInferiors()); + addSorting(id, allBaseOverrideIsInsideOfMaterialSuperiors, baseSorting.getOverrideIsInsideOfMaterialSuperiors()); + addSorting(id, allBaseOverrideIsInsideOfMaterialInferiors, baseSorting.getOverrideIsInsideOfMaterialInferiors()); + addSorting(id, allBaseAfterIsInsideOfMaterialSuperiors, baseSorting.getAfterIsInsideOfMaterialSuperiors()); + addSorting(id, allBaseAfterIsInsideOfMaterialInferiors, baseSorting.getAfterIsInsideOfMaterialInferiors()); + + addSorting(id, allBaseBeforeIsOnLadderSuperiors, baseSorting.getBeforeIsOnLadderSuperiors()); + addSorting(id, allBaseBeforeIsOnLadderInferiors, baseSorting.getBeforeIsOnLadderInferiors()); + addSorting(id, allBaseOverrideIsOnLadderSuperiors, baseSorting.getOverrideIsOnLadderSuperiors()); + addSorting(id, allBaseOverrideIsOnLadderInferiors, baseSorting.getOverrideIsOnLadderInferiors()); + addSorting(id, allBaseAfterIsOnLadderSuperiors, baseSorting.getAfterIsOnLadderSuperiors()); + addSorting(id, allBaseAfterIsOnLadderInferiors, baseSorting.getAfterIsOnLadderInferiors()); + + addSorting(id, allBaseBeforeIsPlayerSleepingSuperiors, baseSorting.getBeforeIsPlayerSleepingSuperiors()); + addSorting(id, allBaseBeforeIsPlayerSleepingInferiors, baseSorting.getBeforeIsPlayerSleepingInferiors()); + addSorting(id, allBaseOverrideIsPlayerSleepingSuperiors, baseSorting.getOverrideIsPlayerSleepingSuperiors()); + addSorting(id, allBaseOverrideIsPlayerSleepingInferiors, baseSorting.getOverrideIsPlayerSleepingInferiors()); + addSorting(id, allBaseAfterIsPlayerSleepingSuperiors, baseSorting.getAfterIsPlayerSleepingSuperiors()); + addSorting(id, allBaseAfterIsPlayerSleepingInferiors, baseSorting.getAfterIsPlayerSleepingInferiors()); + + addSorting(id, allBaseBeforeIsSneakingSuperiors, baseSorting.getBeforeIsSneakingSuperiors()); + addSorting(id, allBaseBeforeIsSneakingInferiors, baseSorting.getBeforeIsSneakingInferiors()); + addSorting(id, allBaseOverrideIsSneakingSuperiors, baseSorting.getOverrideIsSneakingSuperiors()); + addSorting(id, allBaseOverrideIsSneakingInferiors, baseSorting.getOverrideIsSneakingInferiors()); + addSorting(id, allBaseAfterIsSneakingSuperiors, baseSorting.getAfterIsSneakingSuperiors()); + addSorting(id, allBaseAfterIsSneakingInferiors, baseSorting.getAfterIsSneakingInferiors()); + + addSorting(id, allBaseBeforeJumpSuperiors, baseSorting.getBeforeJumpSuperiors()); + addSorting(id, allBaseBeforeJumpInferiors, baseSorting.getBeforeJumpInferiors()); + addSorting(id, allBaseOverrideJumpSuperiors, baseSorting.getOverrideJumpSuperiors()); + addSorting(id, allBaseOverrideJumpInferiors, baseSorting.getOverrideJumpInferiors()); + addSorting(id, allBaseAfterJumpSuperiors, baseSorting.getAfterJumpSuperiors()); + addSorting(id, allBaseAfterJumpInferiors, baseSorting.getAfterJumpInferiors()); + + addSorting(id, allBaseBeforeKnockBackSuperiors, baseSorting.getBeforeKnockBackSuperiors()); + addSorting(id, allBaseBeforeKnockBackInferiors, baseSorting.getBeforeKnockBackInferiors()); + addSorting(id, allBaseOverrideKnockBackSuperiors, baseSorting.getOverrideKnockBackSuperiors()); + addSorting(id, allBaseOverrideKnockBackInferiors, baseSorting.getOverrideKnockBackInferiors()); + addSorting(id, allBaseAfterKnockBackSuperiors, baseSorting.getAfterKnockBackSuperiors()); + addSorting(id, allBaseAfterKnockBackInferiors, baseSorting.getAfterKnockBackInferiors()); + + addSorting(id, allBaseBeforeMountEntitySuperiors, baseSorting.getBeforeMountEntitySuperiors()); + addSorting(id, allBaseBeforeMountEntityInferiors, baseSorting.getBeforeMountEntityInferiors()); + addSorting(id, allBaseOverrideMountEntitySuperiors, baseSorting.getOverrideMountEntitySuperiors()); + addSorting(id, allBaseOverrideMountEntityInferiors, baseSorting.getOverrideMountEntityInferiors()); + addSorting(id, allBaseAfterMountEntitySuperiors, baseSorting.getAfterMountEntitySuperiors()); + addSorting(id, allBaseAfterMountEntityInferiors, baseSorting.getAfterMountEntityInferiors()); + + addSorting(id, allBaseBeforeMoveEntitySuperiors, baseSorting.getBeforeMoveEntitySuperiors()); + addSorting(id, allBaseBeforeMoveEntityInferiors, baseSorting.getBeforeMoveEntityInferiors()); + addSorting(id, allBaseOverrideMoveEntitySuperiors, baseSorting.getOverrideMoveEntitySuperiors()); + addSorting(id, allBaseOverrideMoveEntityInferiors, baseSorting.getOverrideMoveEntityInferiors()); + addSorting(id, allBaseAfterMoveEntitySuperiors, baseSorting.getAfterMoveEntitySuperiors()); + addSorting(id, allBaseAfterMoveEntityInferiors, baseSorting.getAfterMoveEntityInferiors()); + + addSorting(id, allBaseBeforeMoveEntityWithHeadingSuperiors, baseSorting.getBeforeMoveEntityWithHeadingSuperiors()); + addSorting(id, allBaseBeforeMoveEntityWithHeadingInferiors, baseSorting.getBeforeMoveEntityWithHeadingInferiors()); + addSorting(id, allBaseOverrideMoveEntityWithHeadingSuperiors, baseSorting.getOverrideMoveEntityWithHeadingSuperiors()); + addSorting(id, allBaseOverrideMoveEntityWithHeadingInferiors, baseSorting.getOverrideMoveEntityWithHeadingInferiors()); + addSorting(id, allBaseAfterMoveEntityWithHeadingSuperiors, baseSorting.getAfterMoveEntityWithHeadingSuperiors()); + addSorting(id, allBaseAfterMoveEntityWithHeadingInferiors, baseSorting.getAfterMoveEntityWithHeadingInferiors()); + + addSorting(id, allBaseBeforeMoveFlyingSuperiors, baseSorting.getBeforeMoveFlyingSuperiors()); + addSorting(id, allBaseBeforeMoveFlyingInferiors, baseSorting.getBeforeMoveFlyingInferiors()); + addSorting(id, allBaseOverrideMoveFlyingSuperiors, baseSorting.getOverrideMoveFlyingSuperiors()); + addSorting(id, allBaseOverrideMoveFlyingInferiors, baseSorting.getOverrideMoveFlyingInferiors()); + addSorting(id, allBaseAfterMoveFlyingSuperiors, baseSorting.getAfterMoveFlyingSuperiors()); + addSorting(id, allBaseAfterMoveFlyingInferiors, baseSorting.getAfterMoveFlyingInferiors()); + + addSorting(id, allBaseBeforeOnDeathSuperiors, baseSorting.getBeforeOnDeathSuperiors()); + addSorting(id, allBaseBeforeOnDeathInferiors, baseSorting.getBeforeOnDeathInferiors()); + addSorting(id, allBaseOverrideOnDeathSuperiors, baseSorting.getOverrideOnDeathSuperiors()); + addSorting(id, allBaseOverrideOnDeathInferiors, baseSorting.getOverrideOnDeathInferiors()); + addSorting(id, allBaseAfterOnDeathSuperiors, baseSorting.getAfterOnDeathSuperiors()); + addSorting(id, allBaseAfterOnDeathInferiors, baseSorting.getAfterOnDeathInferiors()); + + addSorting(id, allBaseBeforeOnLivingUpdateSuperiors, baseSorting.getBeforeOnLivingUpdateSuperiors()); + addSorting(id, allBaseBeforeOnLivingUpdateInferiors, baseSorting.getBeforeOnLivingUpdateInferiors()); + addSorting(id, allBaseOverrideOnLivingUpdateSuperiors, baseSorting.getOverrideOnLivingUpdateSuperiors()); + addSorting(id, allBaseOverrideOnLivingUpdateInferiors, baseSorting.getOverrideOnLivingUpdateInferiors()); + addSorting(id, allBaseAfterOnLivingUpdateSuperiors, baseSorting.getAfterOnLivingUpdateSuperiors()); + addSorting(id, allBaseAfterOnLivingUpdateInferiors, baseSorting.getAfterOnLivingUpdateInferiors()); + + addSorting(id, allBaseBeforeOnKillEntitySuperiors, baseSorting.getBeforeOnKillEntitySuperiors()); + addSorting(id, allBaseBeforeOnKillEntityInferiors, baseSorting.getBeforeOnKillEntityInferiors()); + addSorting(id, allBaseOverrideOnKillEntitySuperiors, baseSorting.getOverrideOnKillEntitySuperiors()); + addSorting(id, allBaseOverrideOnKillEntityInferiors, baseSorting.getOverrideOnKillEntityInferiors()); + addSorting(id, allBaseAfterOnKillEntitySuperiors, baseSorting.getAfterOnKillEntitySuperiors()); + addSorting(id, allBaseAfterOnKillEntityInferiors, baseSorting.getAfterOnKillEntityInferiors()); + + addSorting(id, allBaseBeforeOnStruckByLightningSuperiors, baseSorting.getBeforeOnStruckByLightningSuperiors()); + addSorting(id, allBaseBeforeOnStruckByLightningInferiors, baseSorting.getBeforeOnStruckByLightningInferiors()); + addSorting(id, allBaseOverrideOnStruckByLightningSuperiors, baseSorting.getOverrideOnStruckByLightningSuperiors()); + addSorting(id, allBaseOverrideOnStruckByLightningInferiors, baseSorting.getOverrideOnStruckByLightningInferiors()); + addSorting(id, allBaseAfterOnStruckByLightningSuperiors, baseSorting.getAfterOnStruckByLightningSuperiors()); + addSorting(id, allBaseAfterOnStruckByLightningInferiors, baseSorting.getAfterOnStruckByLightningInferiors()); + + addSorting(id, allBaseBeforeOnUpdateSuperiors, baseSorting.getBeforeOnUpdateSuperiors()); + addSorting(id, allBaseBeforeOnUpdateInferiors, baseSorting.getBeforeOnUpdateInferiors()); + addSorting(id, allBaseOverrideOnUpdateSuperiors, baseSorting.getOverrideOnUpdateSuperiors()); + addSorting(id, allBaseOverrideOnUpdateInferiors, baseSorting.getOverrideOnUpdateInferiors()); + addSorting(id, allBaseAfterOnUpdateSuperiors, baseSorting.getAfterOnUpdateSuperiors()); + addSorting(id, allBaseAfterOnUpdateInferiors, baseSorting.getAfterOnUpdateInferiors()); + + addSorting(id, allBaseBeforeOnUpdateEntitySuperiors, baseSorting.getBeforeOnUpdateEntitySuperiors()); + addSorting(id, allBaseBeforeOnUpdateEntityInferiors, baseSorting.getBeforeOnUpdateEntityInferiors()); + addSorting(id, allBaseOverrideOnUpdateEntitySuperiors, baseSorting.getOverrideOnUpdateEntitySuperiors()); + addSorting(id, allBaseOverrideOnUpdateEntityInferiors, baseSorting.getOverrideOnUpdateEntityInferiors()); + addSorting(id, allBaseAfterOnUpdateEntitySuperiors, baseSorting.getAfterOnUpdateEntitySuperiors()); + addSorting(id, allBaseAfterOnUpdateEntityInferiors, baseSorting.getAfterOnUpdateEntityInferiors()); + + addSorting(id, allBaseBeforeReadEntityFromNBTSuperiors, baseSorting.getBeforeReadEntityFromNBTSuperiors()); + addSorting(id, allBaseBeforeReadEntityFromNBTInferiors, baseSorting.getBeforeReadEntityFromNBTInferiors()); + addSorting(id, allBaseOverrideReadEntityFromNBTSuperiors, baseSorting.getOverrideReadEntityFromNBTSuperiors()); + addSorting(id, allBaseOverrideReadEntityFromNBTInferiors, baseSorting.getOverrideReadEntityFromNBTInferiors()); + addSorting(id, allBaseAfterReadEntityFromNBTSuperiors, baseSorting.getAfterReadEntityFromNBTSuperiors()); + addSorting(id, allBaseAfterReadEntityFromNBTInferiors, baseSorting.getAfterReadEntityFromNBTInferiors()); + + addSorting(id, allBaseBeforeSetDeadSuperiors, baseSorting.getBeforeSetDeadSuperiors()); + addSorting(id, allBaseBeforeSetDeadInferiors, baseSorting.getBeforeSetDeadInferiors()); + addSorting(id, allBaseOverrideSetDeadSuperiors, baseSorting.getOverrideSetDeadSuperiors()); + addSorting(id, allBaseOverrideSetDeadInferiors, baseSorting.getOverrideSetDeadInferiors()); + addSorting(id, allBaseAfterSetDeadSuperiors, baseSorting.getAfterSetDeadSuperiors()); + addSorting(id, allBaseAfterSetDeadInferiors, baseSorting.getAfterSetDeadInferiors()); + + addSorting(id, allBaseBeforeSetEntityActionStateSuperiors, baseSorting.getBeforeSetEntityActionStateSuperiors()); + addSorting(id, allBaseBeforeSetEntityActionStateInferiors, baseSorting.getBeforeSetEntityActionStateInferiors()); + addSorting(id, allBaseOverrideSetEntityActionStateSuperiors, baseSorting.getOverrideSetEntityActionStateSuperiors()); + addSorting(id, allBaseOverrideSetEntityActionStateInferiors, baseSorting.getOverrideSetEntityActionStateInferiors()); + addSorting(id, allBaseAfterSetEntityActionStateSuperiors, baseSorting.getAfterSetEntityActionStateSuperiors()); + addSorting(id, allBaseAfterSetEntityActionStateInferiors, baseSorting.getAfterSetEntityActionStateInferiors()); + + addSorting(id, allBaseBeforeSetPositionSuperiors, baseSorting.getBeforeSetPositionSuperiors()); + addSorting(id, allBaseBeforeSetPositionInferiors, baseSorting.getBeforeSetPositionInferiors()); + addSorting(id, allBaseOverrideSetPositionSuperiors, baseSorting.getOverrideSetPositionSuperiors()); + addSorting(id, allBaseOverrideSetPositionInferiors, baseSorting.getOverrideSetPositionInferiors()); + addSorting(id, allBaseAfterSetPositionSuperiors, baseSorting.getAfterSetPositionSuperiors()); + addSorting(id, allBaseAfterSetPositionInferiors, baseSorting.getAfterSetPositionInferiors()); + + addSorting(id, allBaseBeforeSetSneakingSuperiors, baseSorting.getBeforeSetSneakingSuperiors()); + addSorting(id, allBaseBeforeSetSneakingInferiors, baseSorting.getBeforeSetSneakingInferiors()); + addSorting(id, allBaseOverrideSetSneakingSuperiors, baseSorting.getOverrideSetSneakingSuperiors()); + addSorting(id, allBaseOverrideSetSneakingInferiors, baseSorting.getOverrideSetSneakingInferiors()); + addSorting(id, allBaseAfterSetSneakingSuperiors, baseSorting.getAfterSetSneakingSuperiors()); + addSorting(id, allBaseAfterSetSneakingInferiors, baseSorting.getAfterSetSneakingInferiors()); + + addSorting(id, allBaseBeforeSetSprintingSuperiors, baseSorting.getBeforeSetSprintingSuperiors()); + addSorting(id, allBaseBeforeSetSprintingInferiors, baseSorting.getBeforeSetSprintingInferiors()); + addSorting(id, allBaseOverrideSetSprintingSuperiors, baseSorting.getOverrideSetSprintingSuperiors()); + addSorting(id, allBaseOverrideSetSprintingInferiors, baseSorting.getOverrideSetSprintingInferiors()); + addSorting(id, allBaseAfterSetSprintingSuperiors, baseSorting.getAfterSetSprintingSuperiors()); + addSorting(id, allBaseAfterSetSprintingInferiors, baseSorting.getAfterSetSprintingInferiors()); + + addSorting(id, allBaseBeforeSwingItemSuperiors, baseSorting.getBeforeSwingItemSuperiors()); + addSorting(id, allBaseBeforeSwingItemInferiors, baseSorting.getBeforeSwingItemInferiors()); + addSorting(id, allBaseOverrideSwingItemSuperiors, baseSorting.getOverrideSwingItemSuperiors()); + addSorting(id, allBaseOverrideSwingItemInferiors, baseSorting.getOverrideSwingItemInferiors()); + addSorting(id, allBaseAfterSwingItemSuperiors, baseSorting.getAfterSwingItemSuperiors()); + addSorting(id, allBaseAfterSwingItemInferiors, baseSorting.getAfterSwingItemInferiors()); + + addSorting(id, allBaseBeforeUpdateEntityActionStateSuperiors, baseSorting.getBeforeUpdateEntityActionStateSuperiors()); + addSorting(id, allBaseBeforeUpdateEntityActionStateInferiors, baseSorting.getBeforeUpdateEntityActionStateInferiors()); + addSorting(id, allBaseOverrideUpdateEntityActionStateSuperiors, baseSorting.getOverrideUpdateEntityActionStateSuperiors()); + addSorting(id, allBaseOverrideUpdateEntityActionStateInferiors, baseSorting.getOverrideUpdateEntityActionStateInferiors()); + addSorting(id, allBaseAfterUpdateEntityActionStateSuperiors, baseSorting.getAfterUpdateEntityActionStateSuperiors()); + addSorting(id, allBaseAfterUpdateEntityActionStateInferiors, baseSorting.getAfterUpdateEntityActionStateInferiors()); + + addSorting(id, allBaseBeforeUpdatePotionEffectsSuperiors, baseSorting.getBeforeUpdatePotionEffectsSuperiors()); + addSorting(id, allBaseBeforeUpdatePotionEffectsInferiors, baseSorting.getBeforeUpdatePotionEffectsInferiors()); + addSorting(id, allBaseOverrideUpdatePotionEffectsSuperiors, baseSorting.getOverrideUpdatePotionEffectsSuperiors()); + addSorting(id, allBaseOverrideUpdatePotionEffectsInferiors, baseSorting.getOverrideUpdatePotionEffectsInferiors()); + addSorting(id, allBaseAfterUpdatePotionEffectsSuperiors, baseSorting.getAfterUpdatePotionEffectsSuperiors()); + addSorting(id, allBaseAfterUpdatePotionEffectsInferiors, baseSorting.getAfterUpdatePotionEffectsInferiors()); + + addSorting(id, allBaseBeforeUpdateRiddenSuperiors, baseSorting.getBeforeUpdateRiddenSuperiors()); + addSorting(id, allBaseBeforeUpdateRiddenInferiors, baseSorting.getBeforeUpdateRiddenInferiors()); + addSorting(id, allBaseOverrideUpdateRiddenSuperiors, baseSorting.getOverrideUpdateRiddenSuperiors()); + addSorting(id, allBaseOverrideUpdateRiddenInferiors, baseSorting.getOverrideUpdateRiddenInferiors()); + addSorting(id, allBaseAfterUpdateRiddenSuperiors, baseSorting.getAfterUpdateRiddenSuperiors()); + addSorting(id, allBaseAfterUpdateRiddenInferiors, baseSorting.getAfterUpdateRiddenInferiors()); + + addSorting(id, allBaseBeforeWakeUpPlayerSuperiors, baseSorting.getBeforeWakeUpPlayerSuperiors()); + addSorting(id, allBaseBeforeWakeUpPlayerInferiors, baseSorting.getBeforeWakeUpPlayerInferiors()); + addSorting(id, allBaseOverrideWakeUpPlayerSuperiors, baseSorting.getOverrideWakeUpPlayerSuperiors()); + addSorting(id, allBaseOverrideWakeUpPlayerInferiors, baseSorting.getOverrideWakeUpPlayerInferiors()); + addSorting(id, allBaseAfterWakeUpPlayerSuperiors, baseSorting.getAfterWakeUpPlayerSuperiors()); + addSorting(id, allBaseAfterWakeUpPlayerInferiors, baseSorting.getAfterWakeUpPlayerInferiors()); + + addSorting(id, allBaseBeforeWriteEntityToNBTSuperiors, baseSorting.getBeforeWriteEntityToNBTSuperiors()); + addSorting(id, allBaseBeforeWriteEntityToNBTInferiors, baseSorting.getBeforeWriteEntityToNBTInferiors()); + addSorting(id, allBaseOverrideWriteEntityToNBTSuperiors, baseSorting.getOverrideWriteEntityToNBTSuperiors()); + addSorting(id, allBaseOverrideWriteEntityToNBTInferiors, baseSorting.getOverrideWriteEntityToNBTInferiors()); + addSorting(id, allBaseAfterWriteEntityToNBTSuperiors, baseSorting.getAfterWriteEntityToNBTSuperiors()); + addSorting(id, allBaseAfterWriteEntityToNBTInferiors, baseSorting.getAfterWriteEntityToNBTInferiors()); + + } + + addMethod(id, baseClass, beforeLocalConstructingHookTypes, "beforeLocalConstructing", net.minecraft.server.MinecraftServer.class, net.minecraft.world.WorldServer.class, com.mojang.authlib.GameProfile.class, net.minecraft.server.management.ItemInWorldManager.class); + addMethod(id, baseClass, afterLocalConstructingHookTypes, "afterLocalConstructing", net.minecraft.server.MinecraftServer.class, net.minecraft.world.WorldServer.class, com.mojang.authlib.GameProfile.class, net.minecraft.server.management.ItemInWorldManager.class); + + + addMethod(id, baseClass, beforeAddExhaustionHookTypes, "beforeAddExhaustion", float.class); + addMethod(id, baseClass, overrideAddExhaustionHookTypes, "addExhaustion", float.class); + addMethod(id, baseClass, afterAddExhaustionHookTypes, "afterAddExhaustion", float.class); + + addMethod(id, baseClass, beforeAddExperienceHookTypes, "beforeAddExperience", int.class); + addMethod(id, baseClass, overrideAddExperienceHookTypes, "addExperience", int.class); + addMethod(id, baseClass, afterAddExperienceHookTypes, "afterAddExperience", int.class); + + addMethod(id, baseClass, beforeAddExperienceLevelHookTypes, "beforeAddExperienceLevel", int.class); + addMethod(id, baseClass, overrideAddExperienceLevelHookTypes, "addExperienceLevel", int.class); + addMethod(id, baseClass, afterAddExperienceLevelHookTypes, "afterAddExperienceLevel", int.class); + + addMethod(id, baseClass, beforeAddMovementStatHookTypes, "beforeAddMovementStat", double.class, double.class, double.class); + addMethod(id, baseClass, overrideAddMovementStatHookTypes, "addMovementStat", double.class, double.class, double.class); + addMethod(id, baseClass, afterAddMovementStatHookTypes, "afterAddMovementStat", double.class, double.class, double.class); + + addMethod(id, baseClass, beforeAttackEntityFromHookTypes, "beforeAttackEntityFrom", net.minecraft.util.DamageSource.class, float.class); + addMethod(id, baseClass, overrideAttackEntityFromHookTypes, "attackEntityFrom", net.minecraft.util.DamageSource.class, float.class); + addMethod(id, baseClass, afterAttackEntityFromHookTypes, "afterAttackEntityFrom", net.minecraft.util.DamageSource.class, float.class); + + addMethod(id, baseClass, beforeAttackTargetEntityWithCurrentItemHookTypes, "beforeAttackTargetEntityWithCurrentItem", net.minecraft.entity.Entity.class); + addMethod(id, baseClass, overrideAttackTargetEntityWithCurrentItemHookTypes, "attackTargetEntityWithCurrentItem", net.minecraft.entity.Entity.class); + addMethod(id, baseClass, afterAttackTargetEntityWithCurrentItemHookTypes, "afterAttackTargetEntityWithCurrentItem", net.minecraft.entity.Entity.class); + + addMethod(id, baseClass, beforeCanBreatheUnderwaterHookTypes, "beforeCanBreatheUnderwater"); + addMethod(id, baseClass, overrideCanBreatheUnderwaterHookTypes, "canBreatheUnderwater"); + addMethod(id, baseClass, afterCanBreatheUnderwaterHookTypes, "afterCanBreatheUnderwater"); + + addMethod(id, baseClass, beforeCanHarvestBlockHookTypes, "beforeCanHarvestBlock", net.minecraft.block.Block.class); + addMethod(id, baseClass, overrideCanHarvestBlockHookTypes, "canHarvestBlock", net.minecraft.block.Block.class); + addMethod(id, baseClass, afterCanHarvestBlockHookTypes, "afterCanHarvestBlock", net.minecraft.block.Block.class); + + addMethod(id, baseClass, beforeCanPlayerEditHookTypes, "beforeCanPlayerEdit", int.class, int.class, int.class, int.class, net.minecraft.item.ItemStack.class); + addMethod(id, baseClass, overrideCanPlayerEditHookTypes, "canPlayerEdit", int.class, int.class, int.class, int.class, net.minecraft.item.ItemStack.class); + addMethod(id, baseClass, afterCanPlayerEditHookTypes, "afterCanPlayerEdit", int.class, int.class, int.class, int.class, net.minecraft.item.ItemStack.class); + + addMethod(id, baseClass, beforeCanTriggerWalkingHookTypes, "beforeCanTriggerWalking"); + addMethod(id, baseClass, overrideCanTriggerWalkingHookTypes, "canTriggerWalking"); + addMethod(id, baseClass, afterCanTriggerWalkingHookTypes, "afterCanTriggerWalking"); + + addMethod(id, baseClass, beforeClonePlayerHookTypes, "beforeClonePlayer", net.minecraft.entity.player.EntityPlayer.class, boolean.class); + addMethod(id, baseClass, overrideClonePlayerHookTypes, "clonePlayer", net.minecraft.entity.player.EntityPlayer.class, boolean.class); + addMethod(id, baseClass, afterClonePlayerHookTypes, "afterClonePlayer", net.minecraft.entity.player.EntityPlayer.class, boolean.class); + + addMethod(id, baseClass, beforeDamageEntityHookTypes, "beforeDamageEntity", net.minecraft.util.DamageSource.class, float.class); + addMethod(id, baseClass, overrideDamageEntityHookTypes, "damageEntity", net.minecraft.util.DamageSource.class, float.class); + addMethod(id, baseClass, afterDamageEntityHookTypes, "afterDamageEntity", net.minecraft.util.DamageSource.class, float.class); + + addMethod(id, baseClass, beforeDisplayGUIChestHookTypes, "beforeDisplayGUIChest", net.minecraft.inventory.IInventory.class); + addMethod(id, baseClass, overrideDisplayGUIChestHookTypes, "displayGUIChest", net.minecraft.inventory.IInventory.class); + addMethod(id, baseClass, afterDisplayGUIChestHookTypes, "afterDisplayGUIChest", net.minecraft.inventory.IInventory.class); + + addMethod(id, baseClass, beforeDisplayGUIDispenserHookTypes, "beforeDisplayGUIDispenser", net.minecraft.tileentity.TileEntityDispenser.class); + addMethod(id, baseClass, overrideDisplayGUIDispenserHookTypes, "displayGUIDispenser", net.minecraft.tileentity.TileEntityDispenser.class); + addMethod(id, baseClass, afterDisplayGUIDispenserHookTypes, "afterDisplayGUIDispenser", net.minecraft.tileentity.TileEntityDispenser.class); + + addMethod(id, baseClass, beforeDisplayGUIFurnaceHookTypes, "beforeDisplayGUIFurnace", net.minecraft.tileentity.TileEntityFurnace.class); + addMethod(id, baseClass, overrideDisplayGUIFurnaceHookTypes, "displayGUIFurnace", net.minecraft.tileentity.TileEntityFurnace.class); + addMethod(id, baseClass, afterDisplayGUIFurnaceHookTypes, "afterDisplayGUIFurnace", net.minecraft.tileentity.TileEntityFurnace.class); + + addMethod(id, baseClass, beforeDisplayGUIWorkbenchHookTypes, "beforeDisplayGUIWorkbench", int.class, int.class, int.class); + addMethod(id, baseClass, overrideDisplayGUIWorkbenchHookTypes, "displayGUIWorkbench", int.class, int.class, int.class); + addMethod(id, baseClass, afterDisplayGUIWorkbenchHookTypes, "afterDisplayGUIWorkbench", int.class, int.class, int.class); + + addMethod(id, baseClass, beforeDropOneItemHookTypes, "beforeDropOneItem", boolean.class); + addMethod(id, baseClass, overrideDropOneItemHookTypes, "dropOneItem", boolean.class); + addMethod(id, baseClass, afterDropOneItemHookTypes, "afterDropOneItem", boolean.class); + + addMethod(id, baseClass, beforeDropPlayerItemHookTypes, "beforeDropPlayerItem", net.minecraft.item.ItemStack.class, boolean.class); + addMethod(id, baseClass, overrideDropPlayerItemHookTypes, "dropPlayerItem", net.minecraft.item.ItemStack.class, boolean.class); + addMethod(id, baseClass, afterDropPlayerItemHookTypes, "afterDropPlayerItem", net.minecraft.item.ItemStack.class, boolean.class); + + addMethod(id, baseClass, beforeFallHookTypes, "beforeFall", float.class); + addMethod(id, baseClass, overrideFallHookTypes, "fall", float.class); + addMethod(id, baseClass, afterFallHookTypes, "afterFall", float.class); + + addMethod(id, baseClass, beforeGetAIMoveSpeedHookTypes, "beforeGetAIMoveSpeed"); + addMethod(id, baseClass, overrideGetAIMoveSpeedHookTypes, "getAIMoveSpeed"); + addMethod(id, baseClass, afterGetAIMoveSpeedHookTypes, "afterGetAIMoveSpeed"); + + addMethod(id, baseClass, beforeGetCurrentPlayerStrVsBlockHookTypes, "beforeGetCurrentPlayerStrVsBlock", net.minecraft.block.Block.class, boolean.class); + addMethod(id, baseClass, overrideGetCurrentPlayerStrVsBlockHookTypes, "getCurrentPlayerStrVsBlock", net.minecraft.block.Block.class, boolean.class); + addMethod(id, baseClass, afterGetCurrentPlayerStrVsBlockHookTypes, "afterGetCurrentPlayerStrVsBlock", net.minecraft.block.Block.class, boolean.class); + + addMethod(id, baseClass, beforeGetCurrentPlayerStrVsBlockForgeHookTypes, "beforeGetCurrentPlayerStrVsBlockForge", net.minecraft.block.Block.class, boolean.class, int.class); + addMethod(id, baseClass, overrideGetCurrentPlayerStrVsBlockForgeHookTypes, "getCurrentPlayerStrVsBlockForge", net.minecraft.block.Block.class, boolean.class, int.class); + addMethod(id, baseClass, afterGetCurrentPlayerStrVsBlockForgeHookTypes, "afterGetCurrentPlayerStrVsBlockForge", net.minecraft.block.Block.class, boolean.class, int.class); + + addMethod(id, baseClass, beforeGetDistanceSqHookTypes, "beforeGetDistanceSq", double.class, double.class, double.class); + addMethod(id, baseClass, overrideGetDistanceSqHookTypes, "getDistanceSq", double.class, double.class, double.class); + addMethod(id, baseClass, afterGetDistanceSqHookTypes, "afterGetDistanceSq", double.class, double.class, double.class); + + addMethod(id, baseClass, beforeGetBrightnessHookTypes, "beforeGetBrightness", float.class); + addMethod(id, baseClass, overrideGetBrightnessHookTypes, "getBrightness", float.class); + addMethod(id, baseClass, afterGetBrightnessHookTypes, "afterGetBrightness", float.class); + + addMethod(id, baseClass, beforeGetEyeHeightHookTypes, "beforeGetEyeHeight"); + addMethod(id, baseClass, overrideGetEyeHeightHookTypes, "getEyeHeight"); + addMethod(id, baseClass, afterGetEyeHeightHookTypes, "afterGetEyeHeight"); + + addMethod(id, baseClass, beforeHealHookTypes, "beforeHeal", float.class); + addMethod(id, baseClass, overrideHealHookTypes, "heal", float.class); + addMethod(id, baseClass, afterHealHookTypes, "afterHeal", float.class); + + addMethod(id, baseClass, beforeIsEntityInsideOpaqueBlockHookTypes, "beforeIsEntityInsideOpaqueBlock"); + addMethod(id, baseClass, overrideIsEntityInsideOpaqueBlockHookTypes, "isEntityInsideOpaqueBlock"); + addMethod(id, baseClass, afterIsEntityInsideOpaqueBlockHookTypes, "afterIsEntityInsideOpaqueBlock"); + + addMethod(id, baseClass, beforeIsInWaterHookTypes, "beforeIsInWater"); + addMethod(id, baseClass, overrideIsInWaterHookTypes, "isInWater"); + addMethod(id, baseClass, afterIsInWaterHookTypes, "afterIsInWater"); + + addMethod(id, baseClass, beforeIsInsideOfMaterialHookTypes, "beforeIsInsideOfMaterial", net.minecraft.block.material.Material.class); + addMethod(id, baseClass, overrideIsInsideOfMaterialHookTypes, "isInsideOfMaterial", net.minecraft.block.material.Material.class); + addMethod(id, baseClass, afterIsInsideOfMaterialHookTypes, "afterIsInsideOfMaterial", net.minecraft.block.material.Material.class); + + addMethod(id, baseClass, beforeIsOnLadderHookTypes, "beforeIsOnLadder"); + addMethod(id, baseClass, overrideIsOnLadderHookTypes, "isOnLadder"); + addMethod(id, baseClass, afterIsOnLadderHookTypes, "afterIsOnLadder"); + + addMethod(id, baseClass, beforeIsPlayerSleepingHookTypes, "beforeIsPlayerSleeping"); + addMethod(id, baseClass, overrideIsPlayerSleepingHookTypes, "isPlayerSleeping"); + addMethod(id, baseClass, afterIsPlayerSleepingHookTypes, "afterIsPlayerSleeping"); + + addMethod(id, baseClass, beforeIsSneakingHookTypes, "beforeIsSneaking"); + addMethod(id, baseClass, overrideIsSneakingHookTypes, "isSneaking"); + addMethod(id, baseClass, afterIsSneakingHookTypes, "afterIsSneaking"); + + addMethod(id, baseClass, beforeJumpHookTypes, "beforeJump"); + addMethod(id, baseClass, overrideJumpHookTypes, "jump"); + addMethod(id, baseClass, afterJumpHookTypes, "afterJump"); + + addMethod(id, baseClass, beforeKnockBackHookTypes, "beforeKnockBack", net.minecraft.entity.Entity.class, float.class, double.class, double.class); + addMethod(id, baseClass, overrideKnockBackHookTypes, "knockBack", net.minecraft.entity.Entity.class, float.class, double.class, double.class); + addMethod(id, baseClass, afterKnockBackHookTypes, "afterKnockBack", net.minecraft.entity.Entity.class, float.class, double.class, double.class); + + addMethod(id, baseClass, beforeMountEntityHookTypes, "beforeMountEntity", net.minecraft.entity.Entity.class); + addMethod(id, baseClass, overrideMountEntityHookTypes, "mountEntity", net.minecraft.entity.Entity.class); + addMethod(id, baseClass, afterMountEntityHookTypes, "afterMountEntity", net.minecraft.entity.Entity.class); + + addMethod(id, baseClass, beforeMoveEntityHookTypes, "beforeMoveEntity", double.class, double.class, double.class); + addMethod(id, baseClass, overrideMoveEntityHookTypes, "moveEntity", double.class, double.class, double.class); + addMethod(id, baseClass, afterMoveEntityHookTypes, "afterMoveEntity", double.class, double.class, double.class); + + addMethod(id, baseClass, beforeMoveEntityWithHeadingHookTypes, "beforeMoveEntityWithHeading", float.class, float.class); + addMethod(id, baseClass, overrideMoveEntityWithHeadingHookTypes, "moveEntityWithHeading", float.class, float.class); + addMethod(id, baseClass, afterMoveEntityWithHeadingHookTypes, "afterMoveEntityWithHeading", float.class, float.class); + + addMethod(id, baseClass, beforeMoveFlyingHookTypes, "beforeMoveFlying", float.class, float.class, float.class); + addMethod(id, baseClass, overrideMoveFlyingHookTypes, "moveFlying", float.class, float.class, float.class); + addMethod(id, baseClass, afterMoveFlyingHookTypes, "afterMoveFlying", float.class, float.class, float.class); + + addMethod(id, baseClass, beforeOnDeathHookTypes, "beforeOnDeath", net.minecraft.util.DamageSource.class); + addMethod(id, baseClass, overrideOnDeathHookTypes, "onDeath", net.minecraft.util.DamageSource.class); + addMethod(id, baseClass, afterOnDeathHookTypes, "afterOnDeath", net.minecraft.util.DamageSource.class); + + addMethod(id, baseClass, beforeOnLivingUpdateHookTypes, "beforeOnLivingUpdate"); + addMethod(id, baseClass, overrideOnLivingUpdateHookTypes, "onLivingUpdate"); + addMethod(id, baseClass, afterOnLivingUpdateHookTypes, "afterOnLivingUpdate"); + + addMethod(id, baseClass, beforeOnKillEntityHookTypes, "beforeOnKillEntity", net.minecraft.entity.EntityLivingBase.class); + addMethod(id, baseClass, overrideOnKillEntityHookTypes, "onKillEntity", net.minecraft.entity.EntityLivingBase.class); + addMethod(id, baseClass, afterOnKillEntityHookTypes, "afterOnKillEntity", net.minecraft.entity.EntityLivingBase.class); + + addMethod(id, baseClass, beforeOnStruckByLightningHookTypes, "beforeOnStruckByLightning", net.minecraft.entity.effect.EntityLightningBolt.class); + addMethod(id, baseClass, overrideOnStruckByLightningHookTypes, "onStruckByLightning", net.minecraft.entity.effect.EntityLightningBolt.class); + addMethod(id, baseClass, afterOnStruckByLightningHookTypes, "afterOnStruckByLightning", net.minecraft.entity.effect.EntityLightningBolt.class); + + addMethod(id, baseClass, beforeOnUpdateHookTypes, "beforeOnUpdate"); + addMethod(id, baseClass, overrideOnUpdateHookTypes, "onUpdate"); + addMethod(id, baseClass, afterOnUpdateHookTypes, "afterOnUpdate"); + + addMethod(id, baseClass, beforeOnUpdateEntityHookTypes, "beforeOnUpdateEntity"); + addMethod(id, baseClass, overrideOnUpdateEntityHookTypes, "onUpdateEntity"); + addMethod(id, baseClass, afterOnUpdateEntityHookTypes, "afterOnUpdateEntity"); + + addMethod(id, baseClass, beforeReadEntityFromNBTHookTypes, "beforeReadEntityFromNBT", net.minecraft.nbt.NBTTagCompound.class); + addMethod(id, baseClass, overrideReadEntityFromNBTHookTypes, "readEntityFromNBT", net.minecraft.nbt.NBTTagCompound.class); + addMethod(id, baseClass, afterReadEntityFromNBTHookTypes, "afterReadEntityFromNBT", net.minecraft.nbt.NBTTagCompound.class); + + addMethod(id, baseClass, beforeSetDeadHookTypes, "beforeSetDead"); + addMethod(id, baseClass, overrideSetDeadHookTypes, "setDead"); + addMethod(id, baseClass, afterSetDeadHookTypes, "afterSetDead"); + + addMethod(id, baseClass, beforeSetEntityActionStateHookTypes, "beforeSetEntityActionState", float.class, float.class, boolean.class, boolean.class); + addMethod(id, baseClass, overrideSetEntityActionStateHookTypes, "setEntityActionState", float.class, float.class, boolean.class, boolean.class); + addMethod(id, baseClass, afterSetEntityActionStateHookTypes, "afterSetEntityActionState", float.class, float.class, boolean.class, boolean.class); + + addMethod(id, baseClass, beforeSetPositionHookTypes, "beforeSetPosition", double.class, double.class, double.class); + addMethod(id, baseClass, overrideSetPositionHookTypes, "setPosition", double.class, double.class, double.class); + addMethod(id, baseClass, afterSetPositionHookTypes, "afterSetPosition", double.class, double.class, double.class); + + addMethod(id, baseClass, beforeSetSneakingHookTypes, "beforeSetSneaking", boolean.class); + addMethod(id, baseClass, overrideSetSneakingHookTypes, "setSneaking", boolean.class); + addMethod(id, baseClass, afterSetSneakingHookTypes, "afterSetSneaking", boolean.class); + + addMethod(id, baseClass, beforeSetSprintingHookTypes, "beforeSetSprinting", boolean.class); + addMethod(id, baseClass, overrideSetSprintingHookTypes, "setSprinting", boolean.class); + addMethod(id, baseClass, afterSetSprintingHookTypes, "afterSetSprinting", boolean.class); + + addMethod(id, baseClass, beforeSwingItemHookTypes, "beforeSwingItem"); + addMethod(id, baseClass, overrideSwingItemHookTypes, "swingItem"); + addMethod(id, baseClass, afterSwingItemHookTypes, "afterSwingItem"); + + addMethod(id, baseClass, beforeUpdateEntityActionStateHookTypes, "beforeUpdateEntityActionState"); + addMethod(id, baseClass, overrideUpdateEntityActionStateHookTypes, "updateEntityActionState"); + addMethod(id, baseClass, afterUpdateEntityActionStateHookTypes, "afterUpdateEntityActionState"); + + addMethod(id, baseClass, beforeUpdatePotionEffectsHookTypes, "beforeUpdatePotionEffects"); + addMethod(id, baseClass, overrideUpdatePotionEffectsHookTypes, "updatePotionEffects"); + addMethod(id, baseClass, afterUpdatePotionEffectsHookTypes, "afterUpdatePotionEffects"); + + addMethod(id, baseClass, beforeUpdateRiddenHookTypes, "beforeUpdateRidden"); + addMethod(id, baseClass, overrideUpdateRiddenHookTypes, "updateRidden"); + addMethod(id, baseClass, afterUpdateRiddenHookTypes, "afterUpdateRidden"); + + addMethod(id, baseClass, beforeWakeUpPlayerHookTypes, "beforeWakeUpPlayer", boolean.class, boolean.class, boolean.class); + addMethod(id, baseClass, overrideWakeUpPlayerHookTypes, "wakeUpPlayer", boolean.class, boolean.class, boolean.class); + addMethod(id, baseClass, afterWakeUpPlayerHookTypes, "afterWakeUpPlayer", boolean.class, boolean.class, boolean.class); + + addMethod(id, baseClass, beforeWriteEntityToNBTHookTypes, "beforeWriteEntityToNBT", net.minecraft.nbt.NBTTagCompound.class); + addMethod(id, baseClass, overrideWriteEntityToNBTHookTypes, "writeEntityToNBT", net.minecraft.nbt.NBTTagCompound.class); + addMethod(id, baseClass, afterWriteEntityToNBTHookTypes, "afterWriteEntityToNBT", net.minecraft.nbt.NBTTagCompound.class); + + + addDynamicMethods(id, baseClass); + + addDynamicKeys(id, baseClass, beforeDynamicHookMethods, beforeDynamicHookTypes); + addDynamicKeys(id, baseClass, overrideDynamicHookMethods, overrideDynamicHookTypes); + addDynamicKeys(id, baseClass, afterDynamicHookMethods, afterDynamicHookTypes); + + initialize(); + + for(IServerPlayerAPI instance : getAllInstancesList()) + instance.getServerPlayerAPI().attachServerPlayerBase(id); + + System.out.println("Server Player: registered " + id); + logger.fine("Server Player: registered class '" + baseClass.getName() + "' with id '" + id + "'"); + + initialized = false; + } + + public static boolean unregister(String id) + { + if(id == null) + return false; + + Constructor<?> constructor = allBaseConstructors.remove(id); + if(constructor == null) + return false; + + for(IServerPlayerAPI instance : getAllInstancesList()) + instance.getServerPlayerAPI().detachServerPlayerBase(id); + + beforeLocalConstructingHookTypes.remove(id); + afterLocalConstructingHookTypes.remove(id); + + allBaseBeforeAddExhaustionSuperiors.remove(id); + allBaseBeforeAddExhaustionInferiors.remove(id); + allBaseOverrideAddExhaustionSuperiors.remove(id); + allBaseOverrideAddExhaustionInferiors.remove(id); + allBaseAfterAddExhaustionSuperiors.remove(id); + allBaseAfterAddExhaustionInferiors.remove(id); + + beforeAddExhaustionHookTypes.remove(id); + overrideAddExhaustionHookTypes.remove(id); + afterAddExhaustionHookTypes.remove(id); + + allBaseBeforeAddExperienceSuperiors.remove(id); + allBaseBeforeAddExperienceInferiors.remove(id); + allBaseOverrideAddExperienceSuperiors.remove(id); + allBaseOverrideAddExperienceInferiors.remove(id); + allBaseAfterAddExperienceSuperiors.remove(id); + allBaseAfterAddExperienceInferiors.remove(id); + + beforeAddExperienceHookTypes.remove(id); + overrideAddExperienceHookTypes.remove(id); + afterAddExperienceHookTypes.remove(id); + + allBaseBeforeAddExperienceLevelSuperiors.remove(id); + allBaseBeforeAddExperienceLevelInferiors.remove(id); + allBaseOverrideAddExperienceLevelSuperiors.remove(id); + allBaseOverrideAddExperienceLevelInferiors.remove(id); + allBaseAfterAddExperienceLevelSuperiors.remove(id); + allBaseAfterAddExperienceLevelInferiors.remove(id); + + beforeAddExperienceLevelHookTypes.remove(id); + overrideAddExperienceLevelHookTypes.remove(id); + afterAddExperienceLevelHookTypes.remove(id); + + allBaseBeforeAddMovementStatSuperiors.remove(id); + allBaseBeforeAddMovementStatInferiors.remove(id); + allBaseOverrideAddMovementStatSuperiors.remove(id); + allBaseOverrideAddMovementStatInferiors.remove(id); + allBaseAfterAddMovementStatSuperiors.remove(id); + allBaseAfterAddMovementStatInferiors.remove(id); + + beforeAddMovementStatHookTypes.remove(id); + overrideAddMovementStatHookTypes.remove(id); + afterAddMovementStatHookTypes.remove(id); + + allBaseBeforeAttackEntityFromSuperiors.remove(id); + allBaseBeforeAttackEntityFromInferiors.remove(id); + allBaseOverrideAttackEntityFromSuperiors.remove(id); + allBaseOverrideAttackEntityFromInferiors.remove(id); + allBaseAfterAttackEntityFromSuperiors.remove(id); + allBaseAfterAttackEntityFromInferiors.remove(id); + + beforeAttackEntityFromHookTypes.remove(id); + overrideAttackEntityFromHookTypes.remove(id); + afterAttackEntityFromHookTypes.remove(id); + + allBaseBeforeAttackTargetEntityWithCurrentItemSuperiors.remove(id); + allBaseBeforeAttackTargetEntityWithCurrentItemInferiors.remove(id); + allBaseOverrideAttackTargetEntityWithCurrentItemSuperiors.remove(id); + allBaseOverrideAttackTargetEntityWithCurrentItemInferiors.remove(id); + allBaseAfterAttackTargetEntityWithCurrentItemSuperiors.remove(id); + allBaseAfterAttackTargetEntityWithCurrentItemInferiors.remove(id); + + beforeAttackTargetEntityWithCurrentItemHookTypes.remove(id); + overrideAttackTargetEntityWithCurrentItemHookTypes.remove(id); + afterAttackTargetEntityWithCurrentItemHookTypes.remove(id); + + allBaseBeforeCanBreatheUnderwaterSuperiors.remove(id); + allBaseBeforeCanBreatheUnderwaterInferiors.remove(id); + allBaseOverrideCanBreatheUnderwaterSuperiors.remove(id); + allBaseOverrideCanBreatheUnderwaterInferiors.remove(id); + allBaseAfterCanBreatheUnderwaterSuperiors.remove(id); + allBaseAfterCanBreatheUnderwaterInferiors.remove(id); + + beforeCanBreatheUnderwaterHookTypes.remove(id); + overrideCanBreatheUnderwaterHookTypes.remove(id); + afterCanBreatheUnderwaterHookTypes.remove(id); + + allBaseBeforeCanHarvestBlockSuperiors.remove(id); + allBaseBeforeCanHarvestBlockInferiors.remove(id); + allBaseOverrideCanHarvestBlockSuperiors.remove(id); + allBaseOverrideCanHarvestBlockInferiors.remove(id); + allBaseAfterCanHarvestBlockSuperiors.remove(id); + allBaseAfterCanHarvestBlockInferiors.remove(id); + + beforeCanHarvestBlockHookTypes.remove(id); + overrideCanHarvestBlockHookTypes.remove(id); + afterCanHarvestBlockHookTypes.remove(id); + + allBaseBeforeCanPlayerEditSuperiors.remove(id); + allBaseBeforeCanPlayerEditInferiors.remove(id); + allBaseOverrideCanPlayerEditSuperiors.remove(id); + allBaseOverrideCanPlayerEditInferiors.remove(id); + allBaseAfterCanPlayerEditSuperiors.remove(id); + allBaseAfterCanPlayerEditInferiors.remove(id); + + beforeCanPlayerEditHookTypes.remove(id); + overrideCanPlayerEditHookTypes.remove(id); + afterCanPlayerEditHookTypes.remove(id); + + allBaseBeforeCanTriggerWalkingSuperiors.remove(id); + allBaseBeforeCanTriggerWalkingInferiors.remove(id); + allBaseOverrideCanTriggerWalkingSuperiors.remove(id); + allBaseOverrideCanTriggerWalkingInferiors.remove(id); + allBaseAfterCanTriggerWalkingSuperiors.remove(id); + allBaseAfterCanTriggerWalkingInferiors.remove(id); + + beforeCanTriggerWalkingHookTypes.remove(id); + overrideCanTriggerWalkingHookTypes.remove(id); + afterCanTriggerWalkingHookTypes.remove(id); + + allBaseBeforeClonePlayerSuperiors.remove(id); + allBaseBeforeClonePlayerInferiors.remove(id); + allBaseOverrideClonePlayerSuperiors.remove(id); + allBaseOverrideClonePlayerInferiors.remove(id); + allBaseAfterClonePlayerSuperiors.remove(id); + allBaseAfterClonePlayerInferiors.remove(id); + + beforeClonePlayerHookTypes.remove(id); + overrideClonePlayerHookTypes.remove(id); + afterClonePlayerHookTypes.remove(id); + + allBaseBeforeDamageEntitySuperiors.remove(id); + allBaseBeforeDamageEntityInferiors.remove(id); + allBaseOverrideDamageEntitySuperiors.remove(id); + allBaseOverrideDamageEntityInferiors.remove(id); + allBaseAfterDamageEntitySuperiors.remove(id); + allBaseAfterDamageEntityInferiors.remove(id); + + beforeDamageEntityHookTypes.remove(id); + overrideDamageEntityHookTypes.remove(id); + afterDamageEntityHookTypes.remove(id); + + allBaseBeforeDisplayGUIChestSuperiors.remove(id); + allBaseBeforeDisplayGUIChestInferiors.remove(id); + allBaseOverrideDisplayGUIChestSuperiors.remove(id); + allBaseOverrideDisplayGUIChestInferiors.remove(id); + allBaseAfterDisplayGUIChestSuperiors.remove(id); + allBaseAfterDisplayGUIChestInferiors.remove(id); + + beforeDisplayGUIChestHookTypes.remove(id); + overrideDisplayGUIChestHookTypes.remove(id); + afterDisplayGUIChestHookTypes.remove(id); + + allBaseBeforeDisplayGUIDispenserSuperiors.remove(id); + allBaseBeforeDisplayGUIDispenserInferiors.remove(id); + allBaseOverrideDisplayGUIDispenserSuperiors.remove(id); + allBaseOverrideDisplayGUIDispenserInferiors.remove(id); + allBaseAfterDisplayGUIDispenserSuperiors.remove(id); + allBaseAfterDisplayGUIDispenserInferiors.remove(id); + + beforeDisplayGUIDispenserHookTypes.remove(id); + overrideDisplayGUIDispenserHookTypes.remove(id); + afterDisplayGUIDispenserHookTypes.remove(id); + + allBaseBeforeDisplayGUIFurnaceSuperiors.remove(id); + allBaseBeforeDisplayGUIFurnaceInferiors.remove(id); + allBaseOverrideDisplayGUIFurnaceSuperiors.remove(id); + allBaseOverrideDisplayGUIFurnaceInferiors.remove(id); + allBaseAfterDisplayGUIFurnaceSuperiors.remove(id); + allBaseAfterDisplayGUIFurnaceInferiors.remove(id); + + beforeDisplayGUIFurnaceHookTypes.remove(id); + overrideDisplayGUIFurnaceHookTypes.remove(id); + afterDisplayGUIFurnaceHookTypes.remove(id); + + allBaseBeforeDisplayGUIWorkbenchSuperiors.remove(id); + allBaseBeforeDisplayGUIWorkbenchInferiors.remove(id); + allBaseOverrideDisplayGUIWorkbenchSuperiors.remove(id); + allBaseOverrideDisplayGUIWorkbenchInferiors.remove(id); + allBaseAfterDisplayGUIWorkbenchSuperiors.remove(id); + allBaseAfterDisplayGUIWorkbenchInferiors.remove(id); + + beforeDisplayGUIWorkbenchHookTypes.remove(id); + overrideDisplayGUIWorkbenchHookTypes.remove(id); + afterDisplayGUIWorkbenchHookTypes.remove(id); + + allBaseBeforeDropOneItemSuperiors.remove(id); + allBaseBeforeDropOneItemInferiors.remove(id); + allBaseOverrideDropOneItemSuperiors.remove(id); + allBaseOverrideDropOneItemInferiors.remove(id); + allBaseAfterDropOneItemSuperiors.remove(id); + allBaseAfterDropOneItemInferiors.remove(id); + + beforeDropOneItemHookTypes.remove(id); + overrideDropOneItemHookTypes.remove(id); + afterDropOneItemHookTypes.remove(id); + + allBaseBeforeDropPlayerItemSuperiors.remove(id); + allBaseBeforeDropPlayerItemInferiors.remove(id); + allBaseOverrideDropPlayerItemSuperiors.remove(id); + allBaseOverrideDropPlayerItemInferiors.remove(id); + allBaseAfterDropPlayerItemSuperiors.remove(id); + allBaseAfterDropPlayerItemInferiors.remove(id); + + beforeDropPlayerItemHookTypes.remove(id); + overrideDropPlayerItemHookTypes.remove(id); + afterDropPlayerItemHookTypes.remove(id); + + allBaseBeforeFallSuperiors.remove(id); + allBaseBeforeFallInferiors.remove(id); + allBaseOverrideFallSuperiors.remove(id); + allBaseOverrideFallInferiors.remove(id); + allBaseAfterFallSuperiors.remove(id); + allBaseAfterFallInferiors.remove(id); + + beforeFallHookTypes.remove(id); + overrideFallHookTypes.remove(id); + afterFallHookTypes.remove(id); + + allBaseBeforeGetAIMoveSpeedSuperiors.remove(id); + allBaseBeforeGetAIMoveSpeedInferiors.remove(id); + allBaseOverrideGetAIMoveSpeedSuperiors.remove(id); + allBaseOverrideGetAIMoveSpeedInferiors.remove(id); + allBaseAfterGetAIMoveSpeedSuperiors.remove(id); + allBaseAfterGetAIMoveSpeedInferiors.remove(id); + + beforeGetAIMoveSpeedHookTypes.remove(id); + overrideGetAIMoveSpeedHookTypes.remove(id); + afterGetAIMoveSpeedHookTypes.remove(id); + + allBaseBeforeGetCurrentPlayerStrVsBlockSuperiors.remove(id); + allBaseBeforeGetCurrentPlayerStrVsBlockInferiors.remove(id); + allBaseOverrideGetCurrentPlayerStrVsBlockSuperiors.remove(id); + allBaseOverrideGetCurrentPlayerStrVsBlockInferiors.remove(id); + allBaseAfterGetCurrentPlayerStrVsBlockSuperiors.remove(id); + allBaseAfterGetCurrentPlayerStrVsBlockInferiors.remove(id); + + beforeGetCurrentPlayerStrVsBlockHookTypes.remove(id); + overrideGetCurrentPlayerStrVsBlockHookTypes.remove(id); + afterGetCurrentPlayerStrVsBlockHookTypes.remove(id); + + allBaseBeforeGetCurrentPlayerStrVsBlockForgeSuperiors.remove(id); + allBaseBeforeGetCurrentPlayerStrVsBlockForgeInferiors.remove(id); + allBaseOverrideGetCurrentPlayerStrVsBlockForgeSuperiors.remove(id); + allBaseOverrideGetCurrentPlayerStrVsBlockForgeInferiors.remove(id); + allBaseAfterGetCurrentPlayerStrVsBlockForgeSuperiors.remove(id); + allBaseAfterGetCurrentPlayerStrVsBlockForgeInferiors.remove(id); + + beforeGetCurrentPlayerStrVsBlockForgeHookTypes.remove(id); + overrideGetCurrentPlayerStrVsBlockForgeHookTypes.remove(id); + afterGetCurrentPlayerStrVsBlockForgeHookTypes.remove(id); + + allBaseBeforeGetDistanceSqSuperiors.remove(id); + allBaseBeforeGetDistanceSqInferiors.remove(id); + allBaseOverrideGetDistanceSqSuperiors.remove(id); + allBaseOverrideGetDistanceSqInferiors.remove(id); + allBaseAfterGetDistanceSqSuperiors.remove(id); + allBaseAfterGetDistanceSqInferiors.remove(id); + + beforeGetDistanceSqHookTypes.remove(id); + overrideGetDistanceSqHookTypes.remove(id); + afterGetDistanceSqHookTypes.remove(id); + + allBaseBeforeGetBrightnessSuperiors.remove(id); + allBaseBeforeGetBrightnessInferiors.remove(id); + allBaseOverrideGetBrightnessSuperiors.remove(id); + allBaseOverrideGetBrightnessInferiors.remove(id); + allBaseAfterGetBrightnessSuperiors.remove(id); + allBaseAfterGetBrightnessInferiors.remove(id); + + beforeGetBrightnessHookTypes.remove(id); + overrideGetBrightnessHookTypes.remove(id); + afterGetBrightnessHookTypes.remove(id); + + allBaseBeforeGetEyeHeightSuperiors.remove(id); + allBaseBeforeGetEyeHeightInferiors.remove(id); + allBaseOverrideGetEyeHeightSuperiors.remove(id); + allBaseOverrideGetEyeHeightInferiors.remove(id); + allBaseAfterGetEyeHeightSuperiors.remove(id); + allBaseAfterGetEyeHeightInferiors.remove(id); + + beforeGetEyeHeightHookTypes.remove(id); + overrideGetEyeHeightHookTypes.remove(id); + afterGetEyeHeightHookTypes.remove(id); + + allBaseBeforeHealSuperiors.remove(id); + allBaseBeforeHealInferiors.remove(id); + allBaseOverrideHealSuperiors.remove(id); + allBaseOverrideHealInferiors.remove(id); + allBaseAfterHealSuperiors.remove(id); + allBaseAfterHealInferiors.remove(id); + + beforeHealHookTypes.remove(id); + overrideHealHookTypes.remove(id); + afterHealHookTypes.remove(id); + + allBaseBeforeIsEntityInsideOpaqueBlockSuperiors.remove(id); + allBaseBeforeIsEntityInsideOpaqueBlockInferiors.remove(id); + allBaseOverrideIsEntityInsideOpaqueBlockSuperiors.remove(id); + allBaseOverrideIsEntityInsideOpaqueBlockInferiors.remove(id); + allBaseAfterIsEntityInsideOpaqueBlockSuperiors.remove(id); + allBaseAfterIsEntityInsideOpaqueBlockInferiors.remove(id); + + beforeIsEntityInsideOpaqueBlockHookTypes.remove(id); + overrideIsEntityInsideOpaqueBlockHookTypes.remove(id); + afterIsEntityInsideOpaqueBlockHookTypes.remove(id); + + allBaseBeforeIsInWaterSuperiors.remove(id); + allBaseBeforeIsInWaterInferiors.remove(id); + allBaseOverrideIsInWaterSuperiors.remove(id); + allBaseOverrideIsInWaterInferiors.remove(id); + allBaseAfterIsInWaterSuperiors.remove(id); + allBaseAfterIsInWaterInferiors.remove(id); + + beforeIsInWaterHookTypes.remove(id); + overrideIsInWaterHookTypes.remove(id); + afterIsInWaterHookTypes.remove(id); + + allBaseBeforeIsInsideOfMaterialSuperiors.remove(id); + allBaseBeforeIsInsideOfMaterialInferiors.remove(id); + allBaseOverrideIsInsideOfMaterialSuperiors.remove(id); + allBaseOverrideIsInsideOfMaterialInferiors.remove(id); + allBaseAfterIsInsideOfMaterialSuperiors.remove(id); + allBaseAfterIsInsideOfMaterialInferiors.remove(id); + + beforeIsInsideOfMaterialHookTypes.remove(id); + overrideIsInsideOfMaterialHookTypes.remove(id); + afterIsInsideOfMaterialHookTypes.remove(id); + + allBaseBeforeIsOnLadderSuperiors.remove(id); + allBaseBeforeIsOnLadderInferiors.remove(id); + allBaseOverrideIsOnLadderSuperiors.remove(id); + allBaseOverrideIsOnLadderInferiors.remove(id); + allBaseAfterIsOnLadderSuperiors.remove(id); + allBaseAfterIsOnLadderInferiors.remove(id); + + beforeIsOnLadderHookTypes.remove(id); + overrideIsOnLadderHookTypes.remove(id); + afterIsOnLadderHookTypes.remove(id); + + allBaseBeforeIsPlayerSleepingSuperiors.remove(id); + allBaseBeforeIsPlayerSleepingInferiors.remove(id); + allBaseOverrideIsPlayerSleepingSuperiors.remove(id); + allBaseOverrideIsPlayerSleepingInferiors.remove(id); + allBaseAfterIsPlayerSleepingSuperiors.remove(id); + allBaseAfterIsPlayerSleepingInferiors.remove(id); + + beforeIsPlayerSleepingHookTypes.remove(id); + overrideIsPlayerSleepingHookTypes.remove(id); + afterIsPlayerSleepingHookTypes.remove(id); + + allBaseBeforeIsSneakingSuperiors.remove(id); + allBaseBeforeIsSneakingInferiors.remove(id); + allBaseOverrideIsSneakingSuperiors.remove(id); + allBaseOverrideIsSneakingInferiors.remove(id); + allBaseAfterIsSneakingSuperiors.remove(id); + allBaseAfterIsSneakingInferiors.remove(id); + + beforeIsSneakingHookTypes.remove(id); + overrideIsSneakingHookTypes.remove(id); + afterIsSneakingHookTypes.remove(id); + + allBaseBeforeJumpSuperiors.remove(id); + allBaseBeforeJumpInferiors.remove(id); + allBaseOverrideJumpSuperiors.remove(id); + allBaseOverrideJumpInferiors.remove(id); + allBaseAfterJumpSuperiors.remove(id); + allBaseAfterJumpInferiors.remove(id); + + beforeJumpHookTypes.remove(id); + overrideJumpHookTypes.remove(id); + afterJumpHookTypes.remove(id); + + allBaseBeforeKnockBackSuperiors.remove(id); + allBaseBeforeKnockBackInferiors.remove(id); + allBaseOverrideKnockBackSuperiors.remove(id); + allBaseOverrideKnockBackInferiors.remove(id); + allBaseAfterKnockBackSuperiors.remove(id); + allBaseAfterKnockBackInferiors.remove(id); + + beforeKnockBackHookTypes.remove(id); + overrideKnockBackHookTypes.remove(id); + afterKnockBackHookTypes.remove(id); + + allBaseBeforeMountEntitySuperiors.remove(id); + allBaseBeforeMountEntityInferiors.remove(id); + allBaseOverrideMountEntitySuperiors.remove(id); + allBaseOverrideMountEntityInferiors.remove(id); + allBaseAfterMountEntitySuperiors.remove(id); + allBaseAfterMountEntityInferiors.remove(id); + + beforeMountEntityHookTypes.remove(id); + overrideMountEntityHookTypes.remove(id); + afterMountEntityHookTypes.remove(id); + + allBaseBeforeMoveEntitySuperiors.remove(id); + allBaseBeforeMoveEntityInferiors.remove(id); + allBaseOverrideMoveEntitySuperiors.remove(id); + allBaseOverrideMoveEntityInferiors.remove(id); + allBaseAfterMoveEntitySuperiors.remove(id); + allBaseAfterMoveEntityInferiors.remove(id); + + beforeMoveEntityHookTypes.remove(id); + overrideMoveEntityHookTypes.remove(id); + afterMoveEntityHookTypes.remove(id); + + allBaseBeforeMoveEntityWithHeadingSuperiors.remove(id); + allBaseBeforeMoveEntityWithHeadingInferiors.remove(id); + allBaseOverrideMoveEntityWithHeadingSuperiors.remove(id); + allBaseOverrideMoveEntityWithHeadingInferiors.remove(id); + allBaseAfterMoveEntityWithHeadingSuperiors.remove(id); + allBaseAfterMoveEntityWithHeadingInferiors.remove(id); + + beforeMoveEntityWithHeadingHookTypes.remove(id); + overrideMoveEntityWithHeadingHookTypes.remove(id); + afterMoveEntityWithHeadingHookTypes.remove(id); + + allBaseBeforeMoveFlyingSuperiors.remove(id); + allBaseBeforeMoveFlyingInferiors.remove(id); + allBaseOverrideMoveFlyingSuperiors.remove(id); + allBaseOverrideMoveFlyingInferiors.remove(id); + allBaseAfterMoveFlyingSuperiors.remove(id); + allBaseAfterMoveFlyingInferiors.remove(id); + + beforeMoveFlyingHookTypes.remove(id); + overrideMoveFlyingHookTypes.remove(id); + afterMoveFlyingHookTypes.remove(id); + + allBaseBeforeOnDeathSuperiors.remove(id); + allBaseBeforeOnDeathInferiors.remove(id); + allBaseOverrideOnDeathSuperiors.remove(id); + allBaseOverrideOnDeathInferiors.remove(id); + allBaseAfterOnDeathSuperiors.remove(id); + allBaseAfterOnDeathInferiors.remove(id); + + beforeOnDeathHookTypes.remove(id); + overrideOnDeathHookTypes.remove(id); + afterOnDeathHookTypes.remove(id); + + allBaseBeforeOnLivingUpdateSuperiors.remove(id); + allBaseBeforeOnLivingUpdateInferiors.remove(id); + allBaseOverrideOnLivingUpdateSuperiors.remove(id); + allBaseOverrideOnLivingUpdateInferiors.remove(id); + allBaseAfterOnLivingUpdateSuperiors.remove(id); + allBaseAfterOnLivingUpdateInferiors.remove(id); + + beforeOnLivingUpdateHookTypes.remove(id); + overrideOnLivingUpdateHookTypes.remove(id); + afterOnLivingUpdateHookTypes.remove(id); + + allBaseBeforeOnKillEntitySuperiors.remove(id); + allBaseBeforeOnKillEntityInferiors.remove(id); + allBaseOverrideOnKillEntitySuperiors.remove(id); + allBaseOverrideOnKillEntityInferiors.remove(id); + allBaseAfterOnKillEntitySuperiors.remove(id); + allBaseAfterOnKillEntityInferiors.remove(id); + + beforeOnKillEntityHookTypes.remove(id); + overrideOnKillEntityHookTypes.remove(id); + afterOnKillEntityHookTypes.remove(id); + + allBaseBeforeOnStruckByLightningSuperiors.remove(id); + allBaseBeforeOnStruckByLightningInferiors.remove(id); + allBaseOverrideOnStruckByLightningSuperiors.remove(id); + allBaseOverrideOnStruckByLightningInferiors.remove(id); + allBaseAfterOnStruckByLightningSuperiors.remove(id); + allBaseAfterOnStruckByLightningInferiors.remove(id); + + beforeOnStruckByLightningHookTypes.remove(id); + overrideOnStruckByLightningHookTypes.remove(id); + afterOnStruckByLightningHookTypes.remove(id); + + allBaseBeforeOnUpdateSuperiors.remove(id); + allBaseBeforeOnUpdateInferiors.remove(id); + allBaseOverrideOnUpdateSuperiors.remove(id); + allBaseOverrideOnUpdateInferiors.remove(id); + allBaseAfterOnUpdateSuperiors.remove(id); + allBaseAfterOnUpdateInferiors.remove(id); + + beforeOnUpdateHookTypes.remove(id); + overrideOnUpdateHookTypes.remove(id); + afterOnUpdateHookTypes.remove(id); + + allBaseBeforeOnUpdateEntitySuperiors.remove(id); + allBaseBeforeOnUpdateEntityInferiors.remove(id); + allBaseOverrideOnUpdateEntitySuperiors.remove(id); + allBaseOverrideOnUpdateEntityInferiors.remove(id); + allBaseAfterOnUpdateEntitySuperiors.remove(id); + allBaseAfterOnUpdateEntityInferiors.remove(id); + + beforeOnUpdateEntityHookTypes.remove(id); + overrideOnUpdateEntityHookTypes.remove(id); + afterOnUpdateEntityHookTypes.remove(id); + + allBaseBeforeReadEntityFromNBTSuperiors.remove(id); + allBaseBeforeReadEntityFromNBTInferiors.remove(id); + allBaseOverrideReadEntityFromNBTSuperiors.remove(id); + allBaseOverrideReadEntityFromNBTInferiors.remove(id); + allBaseAfterReadEntityFromNBTSuperiors.remove(id); + allBaseAfterReadEntityFromNBTInferiors.remove(id); + + beforeReadEntityFromNBTHookTypes.remove(id); + overrideReadEntityFromNBTHookTypes.remove(id); + afterReadEntityFromNBTHookTypes.remove(id); + + allBaseBeforeSetDeadSuperiors.remove(id); + allBaseBeforeSetDeadInferiors.remove(id); + allBaseOverrideSetDeadSuperiors.remove(id); + allBaseOverrideSetDeadInferiors.remove(id); + allBaseAfterSetDeadSuperiors.remove(id); + allBaseAfterSetDeadInferiors.remove(id); + + beforeSetDeadHookTypes.remove(id); + overrideSetDeadHookTypes.remove(id); + afterSetDeadHookTypes.remove(id); + + allBaseBeforeSetEntityActionStateSuperiors.remove(id); + allBaseBeforeSetEntityActionStateInferiors.remove(id); + allBaseOverrideSetEntityActionStateSuperiors.remove(id); + allBaseOverrideSetEntityActionStateInferiors.remove(id); + allBaseAfterSetEntityActionStateSuperiors.remove(id); + allBaseAfterSetEntityActionStateInferiors.remove(id); + + beforeSetEntityActionStateHookTypes.remove(id); + overrideSetEntityActionStateHookTypes.remove(id); + afterSetEntityActionStateHookTypes.remove(id); + + allBaseBeforeSetPositionSuperiors.remove(id); + allBaseBeforeSetPositionInferiors.remove(id); + allBaseOverrideSetPositionSuperiors.remove(id); + allBaseOverrideSetPositionInferiors.remove(id); + allBaseAfterSetPositionSuperiors.remove(id); + allBaseAfterSetPositionInferiors.remove(id); + + beforeSetPositionHookTypes.remove(id); + overrideSetPositionHookTypes.remove(id); + afterSetPositionHookTypes.remove(id); + + allBaseBeforeSetSneakingSuperiors.remove(id); + allBaseBeforeSetSneakingInferiors.remove(id); + allBaseOverrideSetSneakingSuperiors.remove(id); + allBaseOverrideSetSneakingInferiors.remove(id); + allBaseAfterSetSneakingSuperiors.remove(id); + allBaseAfterSetSneakingInferiors.remove(id); + + beforeSetSneakingHookTypes.remove(id); + overrideSetSneakingHookTypes.remove(id); + afterSetSneakingHookTypes.remove(id); + + allBaseBeforeSetSprintingSuperiors.remove(id); + allBaseBeforeSetSprintingInferiors.remove(id); + allBaseOverrideSetSprintingSuperiors.remove(id); + allBaseOverrideSetSprintingInferiors.remove(id); + allBaseAfterSetSprintingSuperiors.remove(id); + allBaseAfterSetSprintingInferiors.remove(id); + + beforeSetSprintingHookTypes.remove(id); + overrideSetSprintingHookTypes.remove(id); + afterSetSprintingHookTypes.remove(id); + + allBaseBeforeSwingItemSuperiors.remove(id); + allBaseBeforeSwingItemInferiors.remove(id); + allBaseOverrideSwingItemSuperiors.remove(id); + allBaseOverrideSwingItemInferiors.remove(id); + allBaseAfterSwingItemSuperiors.remove(id); + allBaseAfterSwingItemInferiors.remove(id); + + beforeSwingItemHookTypes.remove(id); + overrideSwingItemHookTypes.remove(id); + afterSwingItemHookTypes.remove(id); + + allBaseBeforeUpdateEntityActionStateSuperiors.remove(id); + allBaseBeforeUpdateEntityActionStateInferiors.remove(id); + allBaseOverrideUpdateEntityActionStateSuperiors.remove(id); + allBaseOverrideUpdateEntityActionStateInferiors.remove(id); + allBaseAfterUpdateEntityActionStateSuperiors.remove(id); + allBaseAfterUpdateEntityActionStateInferiors.remove(id); + + beforeUpdateEntityActionStateHookTypes.remove(id); + overrideUpdateEntityActionStateHookTypes.remove(id); + afterUpdateEntityActionStateHookTypes.remove(id); + + allBaseBeforeUpdatePotionEffectsSuperiors.remove(id); + allBaseBeforeUpdatePotionEffectsInferiors.remove(id); + allBaseOverrideUpdatePotionEffectsSuperiors.remove(id); + allBaseOverrideUpdatePotionEffectsInferiors.remove(id); + allBaseAfterUpdatePotionEffectsSuperiors.remove(id); + allBaseAfterUpdatePotionEffectsInferiors.remove(id); + + beforeUpdatePotionEffectsHookTypes.remove(id); + overrideUpdatePotionEffectsHookTypes.remove(id); + afterUpdatePotionEffectsHookTypes.remove(id); + + allBaseBeforeUpdateRiddenSuperiors.remove(id); + allBaseBeforeUpdateRiddenInferiors.remove(id); + allBaseOverrideUpdateRiddenSuperiors.remove(id); + allBaseOverrideUpdateRiddenInferiors.remove(id); + allBaseAfterUpdateRiddenSuperiors.remove(id); + allBaseAfterUpdateRiddenInferiors.remove(id); + + beforeUpdateRiddenHookTypes.remove(id); + overrideUpdateRiddenHookTypes.remove(id); + afterUpdateRiddenHookTypes.remove(id); + + allBaseBeforeWakeUpPlayerSuperiors.remove(id); + allBaseBeforeWakeUpPlayerInferiors.remove(id); + allBaseOverrideWakeUpPlayerSuperiors.remove(id); + allBaseOverrideWakeUpPlayerInferiors.remove(id); + allBaseAfterWakeUpPlayerSuperiors.remove(id); + allBaseAfterWakeUpPlayerInferiors.remove(id); + + beforeWakeUpPlayerHookTypes.remove(id); + overrideWakeUpPlayerHookTypes.remove(id); + afterWakeUpPlayerHookTypes.remove(id); + + allBaseBeforeWriteEntityToNBTSuperiors.remove(id); + allBaseBeforeWriteEntityToNBTInferiors.remove(id); + allBaseOverrideWriteEntityToNBTSuperiors.remove(id); + allBaseOverrideWriteEntityToNBTInferiors.remove(id); + allBaseAfterWriteEntityToNBTSuperiors.remove(id); + allBaseAfterWriteEntityToNBTInferiors.remove(id); + + beforeWriteEntityToNBTHookTypes.remove(id); + overrideWriteEntityToNBTHookTypes.remove(id); + afterWriteEntityToNBTHookTypes.remove(id); + + for(IServerPlayerAPI instance : getAllInstancesList()) + instance.getServerPlayerAPI().updateServerPlayerBases(); + + Iterator<String> iterator = keysToVirtualIds.keySet().iterator(); + while(iterator.hasNext()) + { + String key = iterator.next(); + if(keysToVirtualIds.get(key).equals(id)) + keysToVirtualIds.remove(key); + } + + boolean otherFound = false; + Class<?> type = constructor.getDeclaringClass(); + + iterator = allBaseConstructors.keySet().iterator(); + while(iterator.hasNext()) + { + String otherId = iterator.next(); + Class<?> otherType = allBaseConstructors.get(otherId).getDeclaringClass(); + if(!otherId.equals(id) && otherType.equals(type)) + { + otherFound = true; + break; + } + } + + if(!otherFound) + { + dynamicTypes.remove(type); + + virtualDynamicHookMethods.remove(type); + + beforeDynamicHookMethods.remove(type); + overrideDynamicHookMethods.remove(type); + afterDynamicHookMethods.remove(type); + } + + removeDynamicHookTypes(id, beforeDynamicHookTypes); + removeDynamicHookTypes(id, overrideDynamicHookTypes); + removeDynamicHookTypes(id, afterDynamicHookTypes); + + allBaseBeforeDynamicSuperiors.remove(id); + allBaseBeforeDynamicInferiors.remove(id); + allBaseOverrideDynamicSuperiors.remove(id); + allBaseOverrideDynamicInferiors.remove(id); + allBaseAfterDynamicSuperiors.remove(id); + allBaseAfterDynamicInferiors.remove(id); + + log("ServerPlayerAPI: unregistered id '" + id + "'"); + + return true; + } + + public static void removeDynamicHookTypes(String id, Map<String, List<String>> map) + { + Iterator<String> keys = map.keySet().iterator(); + while(keys.hasNext()) + map.get(keys.next()).remove(id); + } + + public static Set<String> getRegisteredIds() + { + return unmodifiableAllIds; + } + + private static void addSorting(String id, Map<String, String[]> map, String[] values) + { + if(values != null && values.length > 0) + map.put(id, values); + } + + private static void addDynamicSorting(String id, Map<String, Map<String, String[]>> map, Map<String, String[]> values) + { + if(values != null && values.size() > 0) + map.put(id, values); + } + + private static boolean addMethod(String id, Class<?> baseClass, List<String> list, String methodName, Class<?>... _parameterTypes) + { + try + { + Method method = baseClass.getMethod(methodName, _parameterTypes); + boolean isOverridden = method.getDeclaringClass() != ServerPlayerBase.class; + if(isOverridden) + list.add(id); + return isOverridden; + } + catch(Exception e) + { + throw new RuntimeException("Can not reflect method '" + methodName + "' of class '" + baseClass.getName() + "'", e); + } + } + + private static void addDynamicMethods(String id, Class<?> baseClass) + { + if(!dynamicTypes.add(baseClass)) + return; + + Map<String, Method> virtuals = null; + Map<String, Method> befores = null; + Map<String, Method> overrides = null; + Map<String, Method> afters = null; + + Method[] methods = baseClass.getDeclaredMethods(); + for(int i=0; i<methods.length; i++) + { + Method method = methods[i]; + if(method.getDeclaringClass() != baseClass) + continue; + + int modifiers = method.getModifiers(); + if(Modifier.isAbstract(modifiers)) + continue; + + if(Modifier.isStatic(modifiers)) + continue; + + String name = method.getName(); + if(name.length() < 7 || !name.substring(0, 7).equalsIgnoreCase("dynamic")) + continue; + else + name = name.substring(7); + + while(name.charAt(0) == '_') + name = name.substring(1); + + boolean before = false; + boolean virtual = false; + boolean override = false; + boolean after = false; + + if(name.substring(0, 7).equalsIgnoreCase("virtual")) + { + virtual = true; + name = name.substring(7); + } + else + { + if(name.length() >= 8 && name.substring(0, 8).equalsIgnoreCase("override")) + { + name = name.substring(8); + override = true; + } + else if(name.length() >= 6 && name.substring(0, 6).equalsIgnoreCase("before")) + { + before = true; + name = name.substring(6); + } + else if(name.length() >= 5 && name.substring(0, 5).equalsIgnoreCase("after")) + { + after = true; + name = name.substring(5); + } + } + + if(name.length() >= 1 && (before || virtual || override || after)) + name = name.substring(0,1).toLowerCase() + name.substring(1); + + while(name.charAt(0) == '_') + name = name.substring(1); + + if(name.length() == 0) + throw new RuntimeException("Can not process dynamic hook method with no key"); + + keys.add(name); + + if(virtual) + { + if(keysToVirtualIds.containsKey(name)) + throw new RuntimeException("Can not process more than one dynamic virtual method"); + + keysToVirtualIds.put(name, id); + virtuals = addDynamicMethod(name, method, virtuals); + } + else if(before) + befores = addDynamicMethod(name, method, befores); + else if(after) + afters = addDynamicMethod(name, method, afters); + else + overrides = addDynamicMethod(name, method, overrides); + } + + if(virtuals != null) + virtualDynamicHookMethods.put(baseClass, virtuals); + if(befores != null) + beforeDynamicHookMethods.put(baseClass, befores); + if(overrides != null) + overrideDynamicHookMethods.put(baseClass, overrides); + if(afters != null) + afterDynamicHookMethods.put(baseClass, afters); + } + + private static void addDynamicKeys(String id, Class<?> baseClass, Map<Class<?>, Map<String, Method>> dynamicHookMethods, Map<String, List<String>> dynamicHookTypes) + { + Map<String, Method> methods = dynamicHookMethods.get(baseClass); + if(methods == null || methods.size() == 0) + return; + + Iterator<String> keys = methods.keySet().iterator(); + while(keys.hasNext()) + { + String key = keys.next(); + if(!dynamicHookTypes.containsKey(key)) + dynamicHookTypes.put(key, new ArrayList<String>(1)); + dynamicHookTypes.get(key).add(id); + } + } + + private static Map<String, Method> addDynamicMethod(String key, Method method, Map<String, Method> methods) + { + if(methods == null) + methods = new HashMap<String, Method>(); + if(methods.containsKey(key)) + throw new RuntimeException("method with key '" + key + "' allready exists"); + methods.put(key, method); + return methods; + } + + public static ServerPlayerAPI create(IServerPlayerAPI serverPlayer) + { + if(allBaseConstructors.size() > 0 && !initialized) + initialize(); + return new ServerPlayerAPI(serverPlayer); + } + + private static void initialize() + { + sortBases(beforeLocalConstructingHookTypes, allBaseBeforeLocalConstructingSuperiors, allBaseBeforeLocalConstructingInferiors, "beforeLocalConstructing"); + sortBases(afterLocalConstructingHookTypes, allBaseAfterLocalConstructingSuperiors, allBaseAfterLocalConstructingInferiors, "afterLocalConstructing"); + + Iterator<String> keyIterator = keys.iterator(); + while(keyIterator.hasNext()) + { + String key = keyIterator.next(); + sortDynamicBases(beforeDynamicHookTypes, allBaseBeforeDynamicSuperiors, allBaseBeforeDynamicInferiors, key); + sortDynamicBases(overrideDynamicHookTypes, allBaseOverrideDynamicSuperiors, allBaseOverrideDynamicInferiors, key); + sortDynamicBases(afterDynamicHookTypes, allBaseAfterDynamicSuperiors, allBaseAfterDynamicInferiors, key); + } + + sortBases(beforeAddExhaustionHookTypes, allBaseBeforeAddExhaustionSuperiors, allBaseBeforeAddExhaustionInferiors, "beforeAddExhaustion"); + sortBases(overrideAddExhaustionHookTypes, allBaseOverrideAddExhaustionSuperiors, allBaseOverrideAddExhaustionInferiors, "overrideAddExhaustion"); + sortBases(afterAddExhaustionHookTypes, allBaseAfterAddExhaustionSuperiors, allBaseAfterAddExhaustionInferiors, "afterAddExhaustion"); + + sortBases(beforeAddExperienceHookTypes, allBaseBeforeAddExperienceSuperiors, allBaseBeforeAddExperienceInferiors, "beforeAddExperience"); + sortBases(overrideAddExperienceHookTypes, allBaseOverrideAddExperienceSuperiors, allBaseOverrideAddExperienceInferiors, "overrideAddExperience"); + sortBases(afterAddExperienceHookTypes, allBaseAfterAddExperienceSuperiors, allBaseAfterAddExperienceInferiors, "afterAddExperience"); + + sortBases(beforeAddExperienceLevelHookTypes, allBaseBeforeAddExperienceLevelSuperiors, allBaseBeforeAddExperienceLevelInferiors, "beforeAddExperienceLevel"); + sortBases(overrideAddExperienceLevelHookTypes, allBaseOverrideAddExperienceLevelSuperiors, allBaseOverrideAddExperienceLevelInferiors, "overrideAddExperienceLevel"); + sortBases(afterAddExperienceLevelHookTypes, allBaseAfterAddExperienceLevelSuperiors, allBaseAfterAddExperienceLevelInferiors, "afterAddExperienceLevel"); + + sortBases(beforeAddMovementStatHookTypes, allBaseBeforeAddMovementStatSuperiors, allBaseBeforeAddMovementStatInferiors, "beforeAddMovementStat"); + sortBases(overrideAddMovementStatHookTypes, allBaseOverrideAddMovementStatSuperiors, allBaseOverrideAddMovementStatInferiors, "overrideAddMovementStat"); + sortBases(afterAddMovementStatHookTypes, allBaseAfterAddMovementStatSuperiors, allBaseAfterAddMovementStatInferiors, "afterAddMovementStat"); + + sortBases(beforeAttackEntityFromHookTypes, allBaseBeforeAttackEntityFromSuperiors, allBaseBeforeAttackEntityFromInferiors, "beforeAttackEntityFrom"); + sortBases(overrideAttackEntityFromHookTypes, allBaseOverrideAttackEntityFromSuperiors, allBaseOverrideAttackEntityFromInferiors, "overrideAttackEntityFrom"); + sortBases(afterAttackEntityFromHookTypes, allBaseAfterAttackEntityFromSuperiors, allBaseAfterAttackEntityFromInferiors, "afterAttackEntityFrom"); + + sortBases(beforeAttackTargetEntityWithCurrentItemHookTypes, allBaseBeforeAttackTargetEntityWithCurrentItemSuperiors, allBaseBeforeAttackTargetEntityWithCurrentItemInferiors, "beforeAttackTargetEntityWithCurrentItem"); + sortBases(overrideAttackTargetEntityWithCurrentItemHookTypes, allBaseOverrideAttackTargetEntityWithCurrentItemSuperiors, allBaseOverrideAttackTargetEntityWithCurrentItemInferiors, "overrideAttackTargetEntityWithCurrentItem"); + sortBases(afterAttackTargetEntityWithCurrentItemHookTypes, allBaseAfterAttackTargetEntityWithCurrentItemSuperiors, allBaseAfterAttackTargetEntityWithCurrentItemInferiors, "afterAttackTargetEntityWithCurrentItem"); + + sortBases(beforeCanBreatheUnderwaterHookTypes, allBaseBeforeCanBreatheUnderwaterSuperiors, allBaseBeforeCanBreatheUnderwaterInferiors, "beforeCanBreatheUnderwater"); + sortBases(overrideCanBreatheUnderwaterHookTypes, allBaseOverrideCanBreatheUnderwaterSuperiors, allBaseOverrideCanBreatheUnderwaterInferiors, "overrideCanBreatheUnderwater"); + sortBases(afterCanBreatheUnderwaterHookTypes, allBaseAfterCanBreatheUnderwaterSuperiors, allBaseAfterCanBreatheUnderwaterInferiors, "afterCanBreatheUnderwater"); + + sortBases(beforeCanHarvestBlockHookTypes, allBaseBeforeCanHarvestBlockSuperiors, allBaseBeforeCanHarvestBlockInferiors, "beforeCanHarvestBlock"); + sortBases(overrideCanHarvestBlockHookTypes, allBaseOverrideCanHarvestBlockSuperiors, allBaseOverrideCanHarvestBlockInferiors, "overrideCanHarvestBlock"); + sortBases(afterCanHarvestBlockHookTypes, allBaseAfterCanHarvestBlockSuperiors, allBaseAfterCanHarvestBlockInferiors, "afterCanHarvestBlock"); + + sortBases(beforeCanPlayerEditHookTypes, allBaseBeforeCanPlayerEditSuperiors, allBaseBeforeCanPlayerEditInferiors, "beforeCanPlayerEdit"); + sortBases(overrideCanPlayerEditHookTypes, allBaseOverrideCanPlayerEditSuperiors, allBaseOverrideCanPlayerEditInferiors, "overrideCanPlayerEdit"); + sortBases(afterCanPlayerEditHookTypes, allBaseAfterCanPlayerEditSuperiors, allBaseAfterCanPlayerEditInferiors, "afterCanPlayerEdit"); + + sortBases(beforeCanTriggerWalkingHookTypes, allBaseBeforeCanTriggerWalkingSuperiors, allBaseBeforeCanTriggerWalkingInferiors, "beforeCanTriggerWalking"); + sortBases(overrideCanTriggerWalkingHookTypes, allBaseOverrideCanTriggerWalkingSuperiors, allBaseOverrideCanTriggerWalkingInferiors, "overrideCanTriggerWalking"); + sortBases(afterCanTriggerWalkingHookTypes, allBaseAfterCanTriggerWalkingSuperiors, allBaseAfterCanTriggerWalkingInferiors, "afterCanTriggerWalking"); + + sortBases(beforeClonePlayerHookTypes, allBaseBeforeClonePlayerSuperiors, allBaseBeforeClonePlayerInferiors, "beforeClonePlayer"); + sortBases(overrideClonePlayerHookTypes, allBaseOverrideClonePlayerSuperiors, allBaseOverrideClonePlayerInferiors, "overrideClonePlayer"); + sortBases(afterClonePlayerHookTypes, allBaseAfterClonePlayerSuperiors, allBaseAfterClonePlayerInferiors, "afterClonePlayer"); + + sortBases(beforeDamageEntityHookTypes, allBaseBeforeDamageEntitySuperiors, allBaseBeforeDamageEntityInferiors, "beforeDamageEntity"); + sortBases(overrideDamageEntityHookTypes, allBaseOverrideDamageEntitySuperiors, allBaseOverrideDamageEntityInferiors, "overrideDamageEntity"); + sortBases(afterDamageEntityHookTypes, allBaseAfterDamageEntitySuperiors, allBaseAfterDamageEntityInferiors, "afterDamageEntity"); + + sortBases(beforeDisplayGUIChestHookTypes, allBaseBeforeDisplayGUIChestSuperiors, allBaseBeforeDisplayGUIChestInferiors, "beforeDisplayGUIChest"); + sortBases(overrideDisplayGUIChestHookTypes, allBaseOverrideDisplayGUIChestSuperiors, allBaseOverrideDisplayGUIChestInferiors, "overrideDisplayGUIChest"); + sortBases(afterDisplayGUIChestHookTypes, allBaseAfterDisplayGUIChestSuperiors, allBaseAfterDisplayGUIChestInferiors, "afterDisplayGUIChest"); + + sortBases(beforeDisplayGUIDispenserHookTypes, allBaseBeforeDisplayGUIDispenserSuperiors, allBaseBeforeDisplayGUIDispenserInferiors, "beforeDisplayGUIDispenser"); + sortBases(overrideDisplayGUIDispenserHookTypes, allBaseOverrideDisplayGUIDispenserSuperiors, allBaseOverrideDisplayGUIDispenserInferiors, "overrideDisplayGUIDispenser"); + sortBases(afterDisplayGUIDispenserHookTypes, allBaseAfterDisplayGUIDispenserSuperiors, allBaseAfterDisplayGUIDispenserInferiors, "afterDisplayGUIDispenser"); + + sortBases(beforeDisplayGUIFurnaceHookTypes, allBaseBeforeDisplayGUIFurnaceSuperiors, allBaseBeforeDisplayGUIFurnaceInferiors, "beforeDisplayGUIFurnace"); + sortBases(overrideDisplayGUIFurnaceHookTypes, allBaseOverrideDisplayGUIFurnaceSuperiors, allBaseOverrideDisplayGUIFurnaceInferiors, "overrideDisplayGUIFurnace"); + sortBases(afterDisplayGUIFurnaceHookTypes, allBaseAfterDisplayGUIFurnaceSuperiors, allBaseAfterDisplayGUIFurnaceInferiors, "afterDisplayGUIFurnace"); + + sortBases(beforeDisplayGUIWorkbenchHookTypes, allBaseBeforeDisplayGUIWorkbenchSuperiors, allBaseBeforeDisplayGUIWorkbenchInferiors, "beforeDisplayGUIWorkbench"); + sortBases(overrideDisplayGUIWorkbenchHookTypes, allBaseOverrideDisplayGUIWorkbenchSuperiors, allBaseOverrideDisplayGUIWorkbenchInferiors, "overrideDisplayGUIWorkbench"); + sortBases(afterDisplayGUIWorkbenchHookTypes, allBaseAfterDisplayGUIWorkbenchSuperiors, allBaseAfterDisplayGUIWorkbenchInferiors, "afterDisplayGUIWorkbench"); + + sortBases(beforeDropOneItemHookTypes, allBaseBeforeDropOneItemSuperiors, allBaseBeforeDropOneItemInferiors, "beforeDropOneItem"); + sortBases(overrideDropOneItemHookTypes, allBaseOverrideDropOneItemSuperiors, allBaseOverrideDropOneItemInferiors, "overrideDropOneItem"); + sortBases(afterDropOneItemHookTypes, allBaseAfterDropOneItemSuperiors, allBaseAfterDropOneItemInferiors, "afterDropOneItem"); + + sortBases(beforeDropPlayerItemHookTypes, allBaseBeforeDropPlayerItemSuperiors, allBaseBeforeDropPlayerItemInferiors, "beforeDropPlayerItem"); + sortBases(overrideDropPlayerItemHookTypes, allBaseOverrideDropPlayerItemSuperiors, allBaseOverrideDropPlayerItemInferiors, "overrideDropPlayerItem"); + sortBases(afterDropPlayerItemHookTypes, allBaseAfterDropPlayerItemSuperiors, allBaseAfterDropPlayerItemInferiors, "afterDropPlayerItem"); + + sortBases(beforeFallHookTypes, allBaseBeforeFallSuperiors, allBaseBeforeFallInferiors, "beforeFall"); + sortBases(overrideFallHookTypes, allBaseOverrideFallSuperiors, allBaseOverrideFallInferiors, "overrideFall"); + sortBases(afterFallHookTypes, allBaseAfterFallSuperiors, allBaseAfterFallInferiors, "afterFall"); + + sortBases(beforeGetAIMoveSpeedHookTypes, allBaseBeforeGetAIMoveSpeedSuperiors, allBaseBeforeGetAIMoveSpeedInferiors, "beforeGetAIMoveSpeed"); + sortBases(overrideGetAIMoveSpeedHookTypes, allBaseOverrideGetAIMoveSpeedSuperiors, allBaseOverrideGetAIMoveSpeedInferiors, "overrideGetAIMoveSpeed"); + sortBases(afterGetAIMoveSpeedHookTypes, allBaseAfterGetAIMoveSpeedSuperiors, allBaseAfterGetAIMoveSpeedInferiors, "afterGetAIMoveSpeed"); + + sortBases(beforeGetCurrentPlayerStrVsBlockHookTypes, allBaseBeforeGetCurrentPlayerStrVsBlockSuperiors, allBaseBeforeGetCurrentPlayerStrVsBlockInferiors, "beforeGetCurrentPlayerStrVsBlock"); + sortBases(overrideGetCurrentPlayerStrVsBlockHookTypes, allBaseOverrideGetCurrentPlayerStrVsBlockSuperiors, allBaseOverrideGetCurrentPlayerStrVsBlockInferiors, "overrideGetCurrentPlayerStrVsBlock"); + sortBases(afterGetCurrentPlayerStrVsBlockHookTypes, allBaseAfterGetCurrentPlayerStrVsBlockSuperiors, allBaseAfterGetCurrentPlayerStrVsBlockInferiors, "afterGetCurrentPlayerStrVsBlock"); + + sortBases(beforeGetCurrentPlayerStrVsBlockForgeHookTypes, allBaseBeforeGetCurrentPlayerStrVsBlockForgeSuperiors, allBaseBeforeGetCurrentPlayerStrVsBlockForgeInferiors, "beforeGetCurrentPlayerStrVsBlockForge"); + sortBases(overrideGetCurrentPlayerStrVsBlockForgeHookTypes, allBaseOverrideGetCurrentPlayerStrVsBlockForgeSuperiors, allBaseOverrideGetCurrentPlayerStrVsBlockForgeInferiors, "overrideGetCurrentPlayerStrVsBlockForge"); + sortBases(afterGetCurrentPlayerStrVsBlockForgeHookTypes, allBaseAfterGetCurrentPlayerStrVsBlockForgeSuperiors, allBaseAfterGetCurrentPlayerStrVsBlockForgeInferiors, "afterGetCurrentPlayerStrVsBlockForge"); + + sortBases(beforeGetDistanceSqHookTypes, allBaseBeforeGetDistanceSqSuperiors, allBaseBeforeGetDistanceSqInferiors, "beforeGetDistanceSq"); + sortBases(overrideGetDistanceSqHookTypes, allBaseOverrideGetDistanceSqSuperiors, allBaseOverrideGetDistanceSqInferiors, "overrideGetDistanceSq"); + sortBases(afterGetDistanceSqHookTypes, allBaseAfterGetDistanceSqSuperiors, allBaseAfterGetDistanceSqInferiors, "afterGetDistanceSq"); + + sortBases(beforeGetBrightnessHookTypes, allBaseBeforeGetBrightnessSuperiors, allBaseBeforeGetBrightnessInferiors, "beforeGetBrightness"); + sortBases(overrideGetBrightnessHookTypes, allBaseOverrideGetBrightnessSuperiors, allBaseOverrideGetBrightnessInferiors, "overrideGetBrightness"); + sortBases(afterGetBrightnessHookTypes, allBaseAfterGetBrightnessSuperiors, allBaseAfterGetBrightnessInferiors, "afterGetBrightness"); + + sortBases(beforeGetEyeHeightHookTypes, allBaseBeforeGetEyeHeightSuperiors, allBaseBeforeGetEyeHeightInferiors, "beforeGetEyeHeight"); + sortBases(overrideGetEyeHeightHookTypes, allBaseOverrideGetEyeHeightSuperiors, allBaseOverrideGetEyeHeightInferiors, "overrideGetEyeHeight"); + sortBases(afterGetEyeHeightHookTypes, allBaseAfterGetEyeHeightSuperiors, allBaseAfterGetEyeHeightInferiors, "afterGetEyeHeight"); + + sortBases(beforeHealHookTypes, allBaseBeforeHealSuperiors, allBaseBeforeHealInferiors, "beforeHeal"); + sortBases(overrideHealHookTypes, allBaseOverrideHealSuperiors, allBaseOverrideHealInferiors, "overrideHeal"); + sortBases(afterHealHookTypes, allBaseAfterHealSuperiors, allBaseAfterHealInferiors, "afterHeal"); + + sortBases(beforeIsEntityInsideOpaqueBlockHookTypes, allBaseBeforeIsEntityInsideOpaqueBlockSuperiors, allBaseBeforeIsEntityInsideOpaqueBlockInferiors, "beforeIsEntityInsideOpaqueBlock"); + sortBases(overrideIsEntityInsideOpaqueBlockHookTypes, allBaseOverrideIsEntityInsideOpaqueBlockSuperiors, allBaseOverrideIsEntityInsideOpaqueBlockInferiors, "overrideIsEntityInsideOpaqueBlock"); + sortBases(afterIsEntityInsideOpaqueBlockHookTypes, allBaseAfterIsEntityInsideOpaqueBlockSuperiors, allBaseAfterIsEntityInsideOpaqueBlockInferiors, "afterIsEntityInsideOpaqueBlock"); + + sortBases(beforeIsInWaterHookTypes, allBaseBeforeIsInWaterSuperiors, allBaseBeforeIsInWaterInferiors, "beforeIsInWater"); + sortBases(overrideIsInWaterHookTypes, allBaseOverrideIsInWaterSuperiors, allBaseOverrideIsInWaterInferiors, "overrideIsInWater"); + sortBases(afterIsInWaterHookTypes, allBaseAfterIsInWaterSuperiors, allBaseAfterIsInWaterInferiors, "afterIsInWater"); + + sortBases(beforeIsInsideOfMaterialHookTypes, allBaseBeforeIsInsideOfMaterialSuperiors, allBaseBeforeIsInsideOfMaterialInferiors, "beforeIsInsideOfMaterial"); + sortBases(overrideIsInsideOfMaterialHookTypes, allBaseOverrideIsInsideOfMaterialSuperiors, allBaseOverrideIsInsideOfMaterialInferiors, "overrideIsInsideOfMaterial"); + sortBases(afterIsInsideOfMaterialHookTypes, allBaseAfterIsInsideOfMaterialSuperiors, allBaseAfterIsInsideOfMaterialInferiors, "afterIsInsideOfMaterial"); + + sortBases(beforeIsOnLadderHookTypes, allBaseBeforeIsOnLadderSuperiors, allBaseBeforeIsOnLadderInferiors, "beforeIsOnLadder"); + sortBases(overrideIsOnLadderHookTypes, allBaseOverrideIsOnLadderSuperiors, allBaseOverrideIsOnLadderInferiors, "overrideIsOnLadder"); + sortBases(afterIsOnLadderHookTypes, allBaseAfterIsOnLadderSuperiors, allBaseAfterIsOnLadderInferiors, "afterIsOnLadder"); + + sortBases(beforeIsPlayerSleepingHookTypes, allBaseBeforeIsPlayerSleepingSuperiors, allBaseBeforeIsPlayerSleepingInferiors, "beforeIsPlayerSleeping"); + sortBases(overrideIsPlayerSleepingHookTypes, allBaseOverrideIsPlayerSleepingSuperiors, allBaseOverrideIsPlayerSleepingInferiors, "overrideIsPlayerSleeping"); + sortBases(afterIsPlayerSleepingHookTypes, allBaseAfterIsPlayerSleepingSuperiors, allBaseAfterIsPlayerSleepingInferiors, "afterIsPlayerSleeping"); + + sortBases(beforeIsSneakingHookTypes, allBaseBeforeIsSneakingSuperiors, allBaseBeforeIsSneakingInferiors, "beforeIsSneaking"); + sortBases(overrideIsSneakingHookTypes, allBaseOverrideIsSneakingSuperiors, allBaseOverrideIsSneakingInferiors, "overrideIsSneaking"); + sortBases(afterIsSneakingHookTypes, allBaseAfterIsSneakingSuperiors, allBaseAfterIsSneakingInferiors, "afterIsSneaking"); + + sortBases(beforeJumpHookTypes, allBaseBeforeJumpSuperiors, allBaseBeforeJumpInferiors, "beforeJump"); + sortBases(overrideJumpHookTypes, allBaseOverrideJumpSuperiors, allBaseOverrideJumpInferiors, "overrideJump"); + sortBases(afterJumpHookTypes, allBaseAfterJumpSuperiors, allBaseAfterJumpInferiors, "afterJump"); + + sortBases(beforeKnockBackHookTypes, allBaseBeforeKnockBackSuperiors, allBaseBeforeKnockBackInferiors, "beforeKnockBack"); + sortBases(overrideKnockBackHookTypes, allBaseOverrideKnockBackSuperiors, allBaseOverrideKnockBackInferiors, "overrideKnockBack"); + sortBases(afterKnockBackHookTypes, allBaseAfterKnockBackSuperiors, allBaseAfterKnockBackInferiors, "afterKnockBack"); + + sortBases(beforeMountEntityHookTypes, allBaseBeforeMountEntitySuperiors, allBaseBeforeMountEntityInferiors, "beforeMountEntity"); + sortBases(overrideMountEntityHookTypes, allBaseOverrideMountEntitySuperiors, allBaseOverrideMountEntityInferiors, "overrideMountEntity"); + sortBases(afterMountEntityHookTypes, allBaseAfterMountEntitySuperiors, allBaseAfterMountEntityInferiors, "afterMountEntity"); + + sortBases(beforeMoveEntityHookTypes, allBaseBeforeMoveEntitySuperiors, allBaseBeforeMoveEntityInferiors, "beforeMoveEntity"); + sortBases(overrideMoveEntityHookTypes, allBaseOverrideMoveEntitySuperiors, allBaseOverrideMoveEntityInferiors, "overrideMoveEntity"); + sortBases(afterMoveEntityHookTypes, allBaseAfterMoveEntitySuperiors, allBaseAfterMoveEntityInferiors, "afterMoveEntity"); + + sortBases(beforeMoveEntityWithHeadingHookTypes, allBaseBeforeMoveEntityWithHeadingSuperiors, allBaseBeforeMoveEntityWithHeadingInferiors, "beforeMoveEntityWithHeading"); + sortBases(overrideMoveEntityWithHeadingHookTypes, allBaseOverrideMoveEntityWithHeadingSuperiors, allBaseOverrideMoveEntityWithHeadingInferiors, "overrideMoveEntityWithHeading"); + sortBases(afterMoveEntityWithHeadingHookTypes, allBaseAfterMoveEntityWithHeadingSuperiors, allBaseAfterMoveEntityWithHeadingInferiors, "afterMoveEntityWithHeading"); + + sortBases(beforeMoveFlyingHookTypes, allBaseBeforeMoveFlyingSuperiors, allBaseBeforeMoveFlyingInferiors, "beforeMoveFlying"); + sortBases(overrideMoveFlyingHookTypes, allBaseOverrideMoveFlyingSuperiors, allBaseOverrideMoveFlyingInferiors, "overrideMoveFlying"); + sortBases(afterMoveFlyingHookTypes, allBaseAfterMoveFlyingSuperiors, allBaseAfterMoveFlyingInferiors, "afterMoveFlying"); + + sortBases(beforeOnDeathHookTypes, allBaseBeforeOnDeathSuperiors, allBaseBeforeOnDeathInferiors, "beforeOnDeath"); + sortBases(overrideOnDeathHookTypes, allBaseOverrideOnDeathSuperiors, allBaseOverrideOnDeathInferiors, "overrideOnDeath"); + sortBases(afterOnDeathHookTypes, allBaseAfterOnDeathSuperiors, allBaseAfterOnDeathInferiors, "afterOnDeath"); + + sortBases(beforeOnLivingUpdateHookTypes, allBaseBeforeOnLivingUpdateSuperiors, allBaseBeforeOnLivingUpdateInferiors, "beforeOnLivingUpdate"); + sortBases(overrideOnLivingUpdateHookTypes, allBaseOverrideOnLivingUpdateSuperiors, allBaseOverrideOnLivingUpdateInferiors, "overrideOnLivingUpdate"); + sortBases(afterOnLivingUpdateHookTypes, allBaseAfterOnLivingUpdateSuperiors, allBaseAfterOnLivingUpdateInferiors, "afterOnLivingUpdate"); + + sortBases(beforeOnKillEntityHookTypes, allBaseBeforeOnKillEntitySuperiors, allBaseBeforeOnKillEntityInferiors, "beforeOnKillEntity"); + sortBases(overrideOnKillEntityHookTypes, allBaseOverrideOnKillEntitySuperiors, allBaseOverrideOnKillEntityInferiors, "overrideOnKillEntity"); + sortBases(afterOnKillEntityHookTypes, allBaseAfterOnKillEntitySuperiors, allBaseAfterOnKillEntityInferiors, "afterOnKillEntity"); + + sortBases(beforeOnStruckByLightningHookTypes, allBaseBeforeOnStruckByLightningSuperiors, allBaseBeforeOnStruckByLightningInferiors, "beforeOnStruckByLightning"); + sortBases(overrideOnStruckByLightningHookTypes, allBaseOverrideOnStruckByLightningSuperiors, allBaseOverrideOnStruckByLightningInferiors, "overrideOnStruckByLightning"); + sortBases(afterOnStruckByLightningHookTypes, allBaseAfterOnStruckByLightningSuperiors, allBaseAfterOnStruckByLightningInferiors, "afterOnStruckByLightning"); + + sortBases(beforeOnUpdateHookTypes, allBaseBeforeOnUpdateSuperiors, allBaseBeforeOnUpdateInferiors, "beforeOnUpdate"); + sortBases(overrideOnUpdateHookTypes, allBaseOverrideOnUpdateSuperiors, allBaseOverrideOnUpdateInferiors, "overrideOnUpdate"); + sortBases(afterOnUpdateHookTypes, allBaseAfterOnUpdateSuperiors, allBaseAfterOnUpdateInferiors, "afterOnUpdate"); + + sortBases(beforeOnUpdateEntityHookTypes, allBaseBeforeOnUpdateEntitySuperiors, allBaseBeforeOnUpdateEntityInferiors, "beforeOnUpdateEntity"); + sortBases(overrideOnUpdateEntityHookTypes, allBaseOverrideOnUpdateEntitySuperiors, allBaseOverrideOnUpdateEntityInferiors, "overrideOnUpdateEntity"); + sortBases(afterOnUpdateEntityHookTypes, allBaseAfterOnUpdateEntitySuperiors, allBaseAfterOnUpdateEntityInferiors, "afterOnUpdateEntity"); + + sortBases(beforeReadEntityFromNBTHookTypes, allBaseBeforeReadEntityFromNBTSuperiors, allBaseBeforeReadEntityFromNBTInferiors, "beforeReadEntityFromNBT"); + sortBases(overrideReadEntityFromNBTHookTypes, allBaseOverrideReadEntityFromNBTSuperiors, allBaseOverrideReadEntityFromNBTInferiors, "overrideReadEntityFromNBT"); + sortBases(afterReadEntityFromNBTHookTypes, allBaseAfterReadEntityFromNBTSuperiors, allBaseAfterReadEntityFromNBTInferiors, "afterReadEntityFromNBT"); + + sortBases(beforeSetDeadHookTypes, allBaseBeforeSetDeadSuperiors, allBaseBeforeSetDeadInferiors, "beforeSetDead"); + sortBases(overrideSetDeadHookTypes, allBaseOverrideSetDeadSuperiors, allBaseOverrideSetDeadInferiors, "overrideSetDead"); + sortBases(afterSetDeadHookTypes, allBaseAfterSetDeadSuperiors, allBaseAfterSetDeadInferiors, "afterSetDead"); + + sortBases(beforeSetEntityActionStateHookTypes, allBaseBeforeSetEntityActionStateSuperiors, allBaseBeforeSetEntityActionStateInferiors, "beforeSetEntityActionState"); + sortBases(overrideSetEntityActionStateHookTypes, allBaseOverrideSetEntityActionStateSuperiors, allBaseOverrideSetEntityActionStateInferiors, "overrideSetEntityActionState"); + sortBases(afterSetEntityActionStateHookTypes, allBaseAfterSetEntityActionStateSuperiors, allBaseAfterSetEntityActionStateInferiors, "afterSetEntityActionState"); + + sortBases(beforeSetPositionHookTypes, allBaseBeforeSetPositionSuperiors, allBaseBeforeSetPositionInferiors, "beforeSetPosition"); + sortBases(overrideSetPositionHookTypes, allBaseOverrideSetPositionSuperiors, allBaseOverrideSetPositionInferiors, "overrideSetPosition"); + sortBases(afterSetPositionHookTypes, allBaseAfterSetPositionSuperiors, allBaseAfterSetPositionInferiors, "afterSetPosition"); + + sortBases(beforeSetSneakingHookTypes, allBaseBeforeSetSneakingSuperiors, allBaseBeforeSetSneakingInferiors, "beforeSetSneaking"); + sortBases(overrideSetSneakingHookTypes, allBaseOverrideSetSneakingSuperiors, allBaseOverrideSetSneakingInferiors, "overrideSetSneaking"); + sortBases(afterSetSneakingHookTypes, allBaseAfterSetSneakingSuperiors, allBaseAfterSetSneakingInferiors, "afterSetSneaking"); + + sortBases(beforeSetSprintingHookTypes, allBaseBeforeSetSprintingSuperiors, allBaseBeforeSetSprintingInferiors, "beforeSetSprinting"); + sortBases(overrideSetSprintingHookTypes, allBaseOverrideSetSprintingSuperiors, allBaseOverrideSetSprintingInferiors, "overrideSetSprinting"); + sortBases(afterSetSprintingHookTypes, allBaseAfterSetSprintingSuperiors, allBaseAfterSetSprintingInferiors, "afterSetSprinting"); + + sortBases(beforeSwingItemHookTypes, allBaseBeforeSwingItemSuperiors, allBaseBeforeSwingItemInferiors, "beforeSwingItem"); + sortBases(overrideSwingItemHookTypes, allBaseOverrideSwingItemSuperiors, allBaseOverrideSwingItemInferiors, "overrideSwingItem"); + sortBases(afterSwingItemHookTypes, allBaseAfterSwingItemSuperiors, allBaseAfterSwingItemInferiors, "afterSwingItem"); + + sortBases(beforeUpdateEntityActionStateHookTypes, allBaseBeforeUpdateEntityActionStateSuperiors, allBaseBeforeUpdateEntityActionStateInferiors, "beforeUpdateEntityActionState"); + sortBases(overrideUpdateEntityActionStateHookTypes, allBaseOverrideUpdateEntityActionStateSuperiors, allBaseOverrideUpdateEntityActionStateInferiors, "overrideUpdateEntityActionState"); + sortBases(afterUpdateEntityActionStateHookTypes, allBaseAfterUpdateEntityActionStateSuperiors, allBaseAfterUpdateEntityActionStateInferiors, "afterUpdateEntityActionState"); + + sortBases(beforeUpdatePotionEffectsHookTypes, allBaseBeforeUpdatePotionEffectsSuperiors, allBaseBeforeUpdatePotionEffectsInferiors, "beforeUpdatePotionEffects"); + sortBases(overrideUpdatePotionEffectsHookTypes, allBaseOverrideUpdatePotionEffectsSuperiors, allBaseOverrideUpdatePotionEffectsInferiors, "overrideUpdatePotionEffects"); + sortBases(afterUpdatePotionEffectsHookTypes, allBaseAfterUpdatePotionEffectsSuperiors, allBaseAfterUpdatePotionEffectsInferiors, "afterUpdatePotionEffects"); + + sortBases(beforeUpdateRiddenHookTypes, allBaseBeforeUpdateRiddenSuperiors, allBaseBeforeUpdateRiddenInferiors, "beforeUpdateRidden"); + sortBases(overrideUpdateRiddenHookTypes, allBaseOverrideUpdateRiddenSuperiors, allBaseOverrideUpdateRiddenInferiors, "overrideUpdateRidden"); + sortBases(afterUpdateRiddenHookTypes, allBaseAfterUpdateRiddenSuperiors, allBaseAfterUpdateRiddenInferiors, "afterUpdateRidden"); + + sortBases(beforeWakeUpPlayerHookTypes, allBaseBeforeWakeUpPlayerSuperiors, allBaseBeforeWakeUpPlayerInferiors, "beforeWakeUpPlayer"); + sortBases(overrideWakeUpPlayerHookTypes, allBaseOverrideWakeUpPlayerSuperiors, allBaseOverrideWakeUpPlayerInferiors, "overrideWakeUpPlayer"); + sortBases(afterWakeUpPlayerHookTypes, allBaseAfterWakeUpPlayerSuperiors, allBaseAfterWakeUpPlayerInferiors, "afterWakeUpPlayer"); + + sortBases(beforeWriteEntityToNBTHookTypes, allBaseBeforeWriteEntityToNBTSuperiors, allBaseBeforeWriteEntityToNBTInferiors, "beforeWriteEntityToNBT"); + sortBases(overrideWriteEntityToNBTHookTypes, allBaseOverrideWriteEntityToNBTSuperiors, allBaseOverrideWriteEntityToNBTInferiors, "overrideWriteEntityToNBT"); + sortBases(afterWriteEntityToNBTHookTypes, allBaseAfterWriteEntityToNBTSuperiors, allBaseAfterWriteEntityToNBTInferiors, "afterWriteEntityToNBT"); + + initialized = true; + } + + private static List<IServerPlayerAPI> getAllInstancesList() + { + List<IServerPlayerAPI> result = new ArrayList<IServerPlayerAPI>(); + Object entityPlayerList; + try + { + Object minecraftServer = net.minecraft.server.MinecraftServer.class.getMethod("func_71276_C").invoke(null); + Object serverConfigurationManager = minecraftServer != null ? net.minecraft.server.MinecraftServer.class.getMethod("func_71203_ab").invoke(minecraftServer) : null; + entityPlayerList = serverConfigurationManager != null ? serverConfigurationManager.getClass().getField("field_72404_b").get(serverConfigurationManager) : null; + } + catch(Exception obfuscatedException) + { + try + { + Object minecraftServer = net.minecraft.server.MinecraftServer.class.getMethod("getServer").invoke(null); + Object serverConfigurationManager = minecraftServer != null ? net.minecraft.server.MinecraftServer.class.getMethod("getConfigurationManager").invoke(minecraftServer) : null; + entityPlayerList = serverConfigurationManager != null ? serverConfigurationManager.getClass().getField("playerEntityList").get(serverConfigurationManager) : null; + } + catch(Exception deobfuscatedException) + { + throw new RuntimeException("Unable to aquire list of current server players.", obfuscatedException); + } + } + if(entityPlayerList != null) + for(Object entityPlayer : (List<?>)entityPlayerList) + result.add((IServerPlayerAPI)entityPlayer); + return result; + } + + public static net.minecraft.entity.player.EntityPlayerMP[] getAllInstances() + { + List<IServerPlayerAPI> allInstances = getAllInstancesList(); + return allInstances.toArray(new net.minecraft.entity.player.EntityPlayerMP[allInstances.size()]); + } + + public static void beforeLocalConstructing(IServerPlayerAPI serverPlayer, net.minecraft.server.MinecraftServer paramMinecraftServer, net.minecraft.world.WorldServer paramWorldServer, com.mojang.authlib.GameProfile paramGameProfile, net.minecraft.server.management.ItemInWorldManager paramItemInWorldManager) + { + ServerPlayerAPI serverPlayerAPI = serverPlayer.getServerPlayerAPI(); + if(serverPlayerAPI != null) + serverPlayerAPI.load(); + + if(serverPlayerAPI != null) + serverPlayerAPI.beforeLocalConstructing(paramMinecraftServer, paramWorldServer, paramGameProfile, paramItemInWorldManager); + } + + public static void afterLocalConstructing(IServerPlayerAPI serverPlayer, net.minecraft.server.MinecraftServer paramMinecraftServer, net.minecraft.world.WorldServer paramWorldServer, com.mojang.authlib.GameProfile paramGameProfile, net.minecraft.server.management.ItemInWorldManager paramItemInWorldManager) + { + ServerPlayerAPI serverPlayerAPI = serverPlayer.getServerPlayerAPI(); + if(serverPlayerAPI != null) + serverPlayerAPI.afterLocalConstructing(paramMinecraftServer, paramWorldServer, paramGameProfile, paramItemInWorldManager); + } + + public static ServerPlayerBase getServerPlayerBase(IServerPlayerAPI serverPlayer, String baseId) + { + ServerPlayerAPI serverPlayerAPI = serverPlayer.getServerPlayerAPI(); + if(serverPlayerAPI != null) + return serverPlayerAPI.getServerPlayerBase(baseId); + return null; + } + + public static Set<String> getServerPlayerBaseIds(IServerPlayerAPI serverPlayer) + { + ServerPlayerAPI serverPlayerAPI = serverPlayer.getServerPlayerAPI(); + Set<String> result = null; + if(serverPlayerAPI != null) + result = serverPlayerAPI.getServerPlayerBaseIds(); + else + result = Collections.<String>emptySet(); + return result; + } + + public static Object dynamic(IServerPlayerAPI serverPlayer, String key, Object[] parameters) + { + ServerPlayerAPI serverPlayerAPI = serverPlayer.getServerPlayerAPI(); + if(serverPlayerAPI != null) + return serverPlayerAPI.dynamic(key, parameters); + return null; + } + + private static void sortBases(List<String> list, Map<String, String[]> allBaseSuperiors, Map<String, String[]> allBaseInferiors, String methodName) + { + new ServerPlayerBaseSorter(list, allBaseSuperiors, allBaseInferiors, methodName).Sort(); + } + + private final static Map<String, String[]> EmptySortMap = Collections.unmodifiableMap(new HashMap<String, String[]>()); + + private static void sortDynamicBases(Map<String, List<String>> lists, Map<String, Map<String, String[]>> allBaseSuperiors, Map<String, Map<String, String[]>> allBaseInferiors, String key) + { + List<String> types = lists.get(key); + if(types != null && types.size() > 1) + sortBases(types, getDynamicSorters(key, types, allBaseSuperiors), getDynamicSorters(key, types, allBaseInferiors), key); + } + + private static Map<String, String[]> getDynamicSorters(String key, List<String> toSort, Map<String, Map<String, String[]>> allBaseValues) + { + Map<String, String[]> superiors = null; + + Iterator<String> ids = toSort.iterator(); + while(ids.hasNext()) + { + String id = ids.next(); + Map<String, String[]> idSuperiors = allBaseValues.get(id); + if(idSuperiors == null) + continue; + + String[] keySuperiorIds = idSuperiors.get(key); + if(keySuperiorIds != null && keySuperiorIds.length > 0) + { + if(superiors == null) + superiors = new HashMap<String, String[]>(1); + superiors.put(id, keySuperiorIds); + } + } + + return superiors != null ? superiors : EmptySortMap; + } + + private ServerPlayerAPI(IServerPlayerAPI player) + { + this.player = player; + } + + private void load() + { + Iterator<String> iterator = allBaseConstructors.keySet().iterator(); + while(iterator.hasNext()) + { + String id = iterator.next(); + ServerPlayerBase toAttach = createServerPlayerBase(id); + toAttach.beforeBaseAttach(false); + allBaseObjects.put(id, toAttach); + baseObjectsToId.put(toAttach, id); + } + + beforeLocalConstructingHooks = create(beforeLocalConstructingHookTypes); + afterLocalConstructingHooks = create(afterLocalConstructingHookTypes); + + updateServerPlayerBases(); + + iterator = allBaseObjects.keySet().iterator(); + while(iterator.hasNext()) + allBaseObjects.get(iterator.next()).afterBaseAttach(false); + } + + private ServerPlayerBase createServerPlayerBase(String id) + { + Constructor<?> contructor = allBaseConstructors.get(id); + + ServerPlayerBase base; + try + { + if(contructor.getParameterTypes().length == 1) + base = (ServerPlayerBase)contructor.newInstance(this); + else + base = (ServerPlayerBase)contructor.newInstance(this, id); + } + catch (Exception e) + { + throw new RuntimeException("Exception while creating a ServerPlayerBase of type '" + contructor.getDeclaringClass() + "'", e); + } + return base; + } + + private void updateServerPlayerBases() + { + beforeAddExhaustionHooks = create(beforeAddExhaustionHookTypes); + overrideAddExhaustionHooks = create(overrideAddExhaustionHookTypes); + afterAddExhaustionHooks = create(afterAddExhaustionHookTypes); + isAddExhaustionModded = + beforeAddExhaustionHooks != null || + overrideAddExhaustionHooks != null || + afterAddExhaustionHooks != null; + + beforeAddExperienceHooks = create(beforeAddExperienceHookTypes); + overrideAddExperienceHooks = create(overrideAddExperienceHookTypes); + afterAddExperienceHooks = create(afterAddExperienceHookTypes); + isAddExperienceModded = + beforeAddExperienceHooks != null || + overrideAddExperienceHooks != null || + afterAddExperienceHooks != null; + + beforeAddExperienceLevelHooks = create(beforeAddExperienceLevelHookTypes); + overrideAddExperienceLevelHooks = create(overrideAddExperienceLevelHookTypes); + afterAddExperienceLevelHooks = create(afterAddExperienceLevelHookTypes); + isAddExperienceLevelModded = + beforeAddExperienceLevelHooks != null || + overrideAddExperienceLevelHooks != null || + afterAddExperienceLevelHooks != null; + + beforeAddMovementStatHooks = create(beforeAddMovementStatHookTypes); + overrideAddMovementStatHooks = create(overrideAddMovementStatHookTypes); + afterAddMovementStatHooks = create(afterAddMovementStatHookTypes); + isAddMovementStatModded = + beforeAddMovementStatHooks != null || + overrideAddMovementStatHooks != null || + afterAddMovementStatHooks != null; + + beforeAttackEntityFromHooks = create(beforeAttackEntityFromHookTypes); + overrideAttackEntityFromHooks = create(overrideAttackEntityFromHookTypes); + afterAttackEntityFromHooks = create(afterAttackEntityFromHookTypes); + isAttackEntityFromModded = + beforeAttackEntityFromHooks != null || + overrideAttackEntityFromHooks != null || + afterAttackEntityFromHooks != null; + + beforeAttackTargetEntityWithCurrentItemHooks = create(beforeAttackTargetEntityWithCurrentItemHookTypes); + overrideAttackTargetEntityWithCurrentItemHooks = create(overrideAttackTargetEntityWithCurrentItemHookTypes); + afterAttackTargetEntityWithCurrentItemHooks = create(afterAttackTargetEntityWithCurrentItemHookTypes); + isAttackTargetEntityWithCurrentItemModded = + beforeAttackTargetEntityWithCurrentItemHooks != null || + overrideAttackTargetEntityWithCurrentItemHooks != null || + afterAttackTargetEntityWithCurrentItemHooks != null; + + beforeCanBreatheUnderwaterHooks = create(beforeCanBreatheUnderwaterHookTypes); + overrideCanBreatheUnderwaterHooks = create(overrideCanBreatheUnderwaterHookTypes); + afterCanBreatheUnderwaterHooks = create(afterCanBreatheUnderwaterHookTypes); + isCanBreatheUnderwaterModded = + beforeCanBreatheUnderwaterHooks != null || + overrideCanBreatheUnderwaterHooks != null || + afterCanBreatheUnderwaterHooks != null; + + beforeCanHarvestBlockHooks = create(beforeCanHarvestBlockHookTypes); + overrideCanHarvestBlockHooks = create(overrideCanHarvestBlockHookTypes); + afterCanHarvestBlockHooks = create(afterCanHarvestBlockHookTypes); + isCanHarvestBlockModded = + beforeCanHarvestBlockHooks != null || + overrideCanHarvestBlockHooks != null || + afterCanHarvestBlockHooks != null; + + beforeCanPlayerEditHooks = create(beforeCanPlayerEditHookTypes); + overrideCanPlayerEditHooks = create(overrideCanPlayerEditHookTypes); + afterCanPlayerEditHooks = create(afterCanPlayerEditHookTypes); + isCanPlayerEditModded = + beforeCanPlayerEditHooks != null || + overrideCanPlayerEditHooks != null || + afterCanPlayerEditHooks != null; + + beforeCanTriggerWalkingHooks = create(beforeCanTriggerWalkingHookTypes); + overrideCanTriggerWalkingHooks = create(overrideCanTriggerWalkingHookTypes); + afterCanTriggerWalkingHooks = create(afterCanTriggerWalkingHookTypes); + isCanTriggerWalkingModded = + beforeCanTriggerWalkingHooks != null || + overrideCanTriggerWalkingHooks != null || + afterCanTriggerWalkingHooks != null; + + beforeClonePlayerHooks = create(beforeClonePlayerHookTypes); + overrideClonePlayerHooks = create(overrideClonePlayerHookTypes); + afterClonePlayerHooks = create(afterClonePlayerHookTypes); + isClonePlayerModded = + beforeClonePlayerHooks != null || + overrideClonePlayerHooks != null || + afterClonePlayerHooks != null; + + beforeDamageEntityHooks = create(beforeDamageEntityHookTypes); + overrideDamageEntityHooks = create(overrideDamageEntityHookTypes); + afterDamageEntityHooks = create(afterDamageEntityHookTypes); + isDamageEntityModded = + beforeDamageEntityHooks != null || + overrideDamageEntityHooks != null || + afterDamageEntityHooks != null; + + beforeDisplayGUIChestHooks = create(beforeDisplayGUIChestHookTypes); + overrideDisplayGUIChestHooks = create(overrideDisplayGUIChestHookTypes); + afterDisplayGUIChestHooks = create(afterDisplayGUIChestHookTypes); + isDisplayGUIChestModded = + beforeDisplayGUIChestHooks != null || + overrideDisplayGUIChestHooks != null || + afterDisplayGUIChestHooks != null; + + beforeDisplayGUIDispenserHooks = create(beforeDisplayGUIDispenserHookTypes); + overrideDisplayGUIDispenserHooks = create(overrideDisplayGUIDispenserHookTypes); + afterDisplayGUIDispenserHooks = create(afterDisplayGUIDispenserHookTypes); + isDisplayGUIDispenserModded = + beforeDisplayGUIDispenserHooks != null || + overrideDisplayGUIDispenserHooks != null || + afterDisplayGUIDispenserHooks != null; + + beforeDisplayGUIFurnaceHooks = create(beforeDisplayGUIFurnaceHookTypes); + overrideDisplayGUIFurnaceHooks = create(overrideDisplayGUIFurnaceHookTypes); + afterDisplayGUIFurnaceHooks = create(afterDisplayGUIFurnaceHookTypes); + isDisplayGUIFurnaceModded = + beforeDisplayGUIFurnaceHooks != null || + overrideDisplayGUIFurnaceHooks != null || + afterDisplayGUIFurnaceHooks != null; + + beforeDisplayGUIWorkbenchHooks = create(beforeDisplayGUIWorkbenchHookTypes); + overrideDisplayGUIWorkbenchHooks = create(overrideDisplayGUIWorkbenchHookTypes); + afterDisplayGUIWorkbenchHooks = create(afterDisplayGUIWorkbenchHookTypes); + isDisplayGUIWorkbenchModded = + beforeDisplayGUIWorkbenchHooks != null || + overrideDisplayGUIWorkbenchHooks != null || + afterDisplayGUIWorkbenchHooks != null; + + beforeDropOneItemHooks = create(beforeDropOneItemHookTypes); + overrideDropOneItemHooks = create(overrideDropOneItemHookTypes); + afterDropOneItemHooks = create(afterDropOneItemHookTypes); + isDropOneItemModded = + beforeDropOneItemHooks != null || + overrideDropOneItemHooks != null || + afterDropOneItemHooks != null; + + beforeDropPlayerItemHooks = create(beforeDropPlayerItemHookTypes); + overrideDropPlayerItemHooks = create(overrideDropPlayerItemHookTypes); + afterDropPlayerItemHooks = create(afterDropPlayerItemHookTypes); + isDropPlayerItemModded = + beforeDropPlayerItemHooks != null || + overrideDropPlayerItemHooks != null || + afterDropPlayerItemHooks != null; + + beforeFallHooks = create(beforeFallHookTypes); + overrideFallHooks = create(overrideFallHookTypes); + afterFallHooks = create(afterFallHookTypes); + isFallModded = + beforeFallHooks != null || + overrideFallHooks != null || + afterFallHooks != null; + + beforeGetAIMoveSpeedHooks = create(beforeGetAIMoveSpeedHookTypes); + overrideGetAIMoveSpeedHooks = create(overrideGetAIMoveSpeedHookTypes); + afterGetAIMoveSpeedHooks = create(afterGetAIMoveSpeedHookTypes); + isGetAIMoveSpeedModded = + beforeGetAIMoveSpeedHooks != null || + overrideGetAIMoveSpeedHooks != null || + afterGetAIMoveSpeedHooks != null; + + beforeGetCurrentPlayerStrVsBlockHooks = create(beforeGetCurrentPlayerStrVsBlockHookTypes); + overrideGetCurrentPlayerStrVsBlockHooks = create(overrideGetCurrentPlayerStrVsBlockHookTypes); + afterGetCurrentPlayerStrVsBlockHooks = create(afterGetCurrentPlayerStrVsBlockHookTypes); + isGetCurrentPlayerStrVsBlockModded = + beforeGetCurrentPlayerStrVsBlockHooks != null || + overrideGetCurrentPlayerStrVsBlockHooks != null || + afterGetCurrentPlayerStrVsBlockHooks != null; + + beforeGetCurrentPlayerStrVsBlockForgeHooks = create(beforeGetCurrentPlayerStrVsBlockForgeHookTypes); + overrideGetCurrentPlayerStrVsBlockForgeHooks = create(overrideGetCurrentPlayerStrVsBlockForgeHookTypes); + afterGetCurrentPlayerStrVsBlockForgeHooks = create(afterGetCurrentPlayerStrVsBlockForgeHookTypes); + isGetCurrentPlayerStrVsBlockForgeModded = + beforeGetCurrentPlayerStrVsBlockForgeHooks != null || + overrideGetCurrentPlayerStrVsBlockForgeHooks != null || + afterGetCurrentPlayerStrVsBlockForgeHooks != null; + + beforeGetDistanceSqHooks = create(beforeGetDistanceSqHookTypes); + overrideGetDistanceSqHooks = create(overrideGetDistanceSqHookTypes); + afterGetDistanceSqHooks = create(afterGetDistanceSqHookTypes); + isGetDistanceSqModded = + beforeGetDistanceSqHooks != null || + overrideGetDistanceSqHooks != null || + afterGetDistanceSqHooks != null; + + beforeGetBrightnessHooks = create(beforeGetBrightnessHookTypes); + overrideGetBrightnessHooks = create(overrideGetBrightnessHookTypes); + afterGetBrightnessHooks = create(afterGetBrightnessHookTypes); + isGetBrightnessModded = + beforeGetBrightnessHooks != null || + overrideGetBrightnessHooks != null || + afterGetBrightnessHooks != null; + + beforeGetEyeHeightHooks = create(beforeGetEyeHeightHookTypes); + overrideGetEyeHeightHooks = create(overrideGetEyeHeightHookTypes); + afterGetEyeHeightHooks = create(afterGetEyeHeightHookTypes); + isGetEyeHeightModded = + beforeGetEyeHeightHooks != null || + overrideGetEyeHeightHooks != null || + afterGetEyeHeightHooks != null; + + beforeHealHooks = create(beforeHealHookTypes); + overrideHealHooks = create(overrideHealHookTypes); + afterHealHooks = create(afterHealHookTypes); + isHealModded = + beforeHealHooks != null || + overrideHealHooks != null || + afterHealHooks != null; + + beforeIsEntityInsideOpaqueBlockHooks = create(beforeIsEntityInsideOpaqueBlockHookTypes); + overrideIsEntityInsideOpaqueBlockHooks = create(overrideIsEntityInsideOpaqueBlockHookTypes); + afterIsEntityInsideOpaqueBlockHooks = create(afterIsEntityInsideOpaqueBlockHookTypes); + isIsEntityInsideOpaqueBlockModded = + beforeIsEntityInsideOpaqueBlockHooks != null || + overrideIsEntityInsideOpaqueBlockHooks != null || + afterIsEntityInsideOpaqueBlockHooks != null; + + beforeIsInWaterHooks = create(beforeIsInWaterHookTypes); + overrideIsInWaterHooks = create(overrideIsInWaterHookTypes); + afterIsInWaterHooks = create(afterIsInWaterHookTypes); + isIsInWaterModded = + beforeIsInWaterHooks != null || + overrideIsInWaterHooks != null || + afterIsInWaterHooks != null; + + beforeIsInsideOfMaterialHooks = create(beforeIsInsideOfMaterialHookTypes); + overrideIsInsideOfMaterialHooks = create(overrideIsInsideOfMaterialHookTypes); + afterIsInsideOfMaterialHooks = create(afterIsInsideOfMaterialHookTypes); + isIsInsideOfMaterialModded = + beforeIsInsideOfMaterialHooks != null || + overrideIsInsideOfMaterialHooks != null || + afterIsInsideOfMaterialHooks != null; + + beforeIsOnLadderHooks = create(beforeIsOnLadderHookTypes); + overrideIsOnLadderHooks = create(overrideIsOnLadderHookTypes); + afterIsOnLadderHooks = create(afterIsOnLadderHookTypes); + isIsOnLadderModded = + beforeIsOnLadderHooks != null || + overrideIsOnLadderHooks != null || + afterIsOnLadderHooks != null; + + beforeIsPlayerSleepingHooks = create(beforeIsPlayerSleepingHookTypes); + overrideIsPlayerSleepingHooks = create(overrideIsPlayerSleepingHookTypes); + afterIsPlayerSleepingHooks = create(afterIsPlayerSleepingHookTypes); + isIsPlayerSleepingModded = + beforeIsPlayerSleepingHooks != null || + overrideIsPlayerSleepingHooks != null || + afterIsPlayerSleepingHooks != null; + + beforeIsSneakingHooks = create(beforeIsSneakingHookTypes); + overrideIsSneakingHooks = create(overrideIsSneakingHookTypes); + afterIsSneakingHooks = create(afterIsSneakingHookTypes); + isIsSneakingModded = + beforeIsSneakingHooks != null || + overrideIsSneakingHooks != null || + afterIsSneakingHooks != null; + + beforeJumpHooks = create(beforeJumpHookTypes); + overrideJumpHooks = create(overrideJumpHookTypes); + afterJumpHooks = create(afterJumpHookTypes); + isJumpModded = + beforeJumpHooks != null || + overrideJumpHooks != null || + afterJumpHooks != null; + + beforeKnockBackHooks = create(beforeKnockBackHookTypes); + overrideKnockBackHooks = create(overrideKnockBackHookTypes); + afterKnockBackHooks = create(afterKnockBackHookTypes); + isKnockBackModded = + beforeKnockBackHooks != null || + overrideKnockBackHooks != null || + afterKnockBackHooks != null; + + beforeMountEntityHooks = create(beforeMountEntityHookTypes); + overrideMountEntityHooks = create(overrideMountEntityHookTypes); + afterMountEntityHooks = create(afterMountEntityHookTypes); + isMountEntityModded = + beforeMountEntityHooks != null || + overrideMountEntityHooks != null || + afterMountEntityHooks != null; + + beforeMoveEntityHooks = create(beforeMoveEntityHookTypes); + overrideMoveEntityHooks = create(overrideMoveEntityHookTypes); + afterMoveEntityHooks = create(afterMoveEntityHookTypes); + isMoveEntityModded = + beforeMoveEntityHooks != null || + overrideMoveEntityHooks != null || + afterMoveEntityHooks != null; + + beforeMoveEntityWithHeadingHooks = create(beforeMoveEntityWithHeadingHookTypes); + overrideMoveEntityWithHeadingHooks = create(overrideMoveEntityWithHeadingHookTypes); + afterMoveEntityWithHeadingHooks = create(afterMoveEntityWithHeadingHookTypes); + isMoveEntityWithHeadingModded = + beforeMoveEntityWithHeadingHooks != null || + overrideMoveEntityWithHeadingHooks != null || + afterMoveEntityWithHeadingHooks != null; + + beforeMoveFlyingHooks = create(beforeMoveFlyingHookTypes); + overrideMoveFlyingHooks = create(overrideMoveFlyingHookTypes); + afterMoveFlyingHooks = create(afterMoveFlyingHookTypes); + isMoveFlyingModded = + beforeMoveFlyingHooks != null || + overrideMoveFlyingHooks != null || + afterMoveFlyingHooks != null; + + beforeOnDeathHooks = create(beforeOnDeathHookTypes); + overrideOnDeathHooks = create(overrideOnDeathHookTypes); + afterOnDeathHooks = create(afterOnDeathHookTypes); + isOnDeathModded = + beforeOnDeathHooks != null || + overrideOnDeathHooks != null || + afterOnDeathHooks != null; + + beforeOnLivingUpdateHooks = create(beforeOnLivingUpdateHookTypes); + overrideOnLivingUpdateHooks = create(overrideOnLivingUpdateHookTypes); + afterOnLivingUpdateHooks = create(afterOnLivingUpdateHookTypes); + isOnLivingUpdateModded = + beforeOnLivingUpdateHooks != null || + overrideOnLivingUpdateHooks != null || + afterOnLivingUpdateHooks != null; + + beforeOnKillEntityHooks = create(beforeOnKillEntityHookTypes); + overrideOnKillEntityHooks = create(overrideOnKillEntityHookTypes); + afterOnKillEntityHooks = create(afterOnKillEntityHookTypes); + isOnKillEntityModded = + beforeOnKillEntityHooks != null || + overrideOnKillEntityHooks != null || + afterOnKillEntityHooks != null; + + beforeOnStruckByLightningHooks = create(beforeOnStruckByLightningHookTypes); + overrideOnStruckByLightningHooks = create(overrideOnStruckByLightningHookTypes); + afterOnStruckByLightningHooks = create(afterOnStruckByLightningHookTypes); + isOnStruckByLightningModded = + beforeOnStruckByLightningHooks != null || + overrideOnStruckByLightningHooks != null || + afterOnStruckByLightningHooks != null; + + beforeOnUpdateHooks = create(beforeOnUpdateHookTypes); + overrideOnUpdateHooks = create(overrideOnUpdateHookTypes); + afterOnUpdateHooks = create(afterOnUpdateHookTypes); + isOnUpdateModded = + beforeOnUpdateHooks != null || + overrideOnUpdateHooks != null || + afterOnUpdateHooks != null; + + beforeOnUpdateEntityHooks = create(beforeOnUpdateEntityHookTypes); + overrideOnUpdateEntityHooks = create(overrideOnUpdateEntityHookTypes); + afterOnUpdateEntityHooks = create(afterOnUpdateEntityHookTypes); + isOnUpdateEntityModded = + beforeOnUpdateEntityHooks != null || + overrideOnUpdateEntityHooks != null || + afterOnUpdateEntityHooks != null; + + beforeReadEntityFromNBTHooks = create(beforeReadEntityFromNBTHookTypes); + overrideReadEntityFromNBTHooks = create(overrideReadEntityFromNBTHookTypes); + afterReadEntityFromNBTHooks = create(afterReadEntityFromNBTHookTypes); + isReadEntityFromNBTModded = + beforeReadEntityFromNBTHooks != null || + overrideReadEntityFromNBTHooks != null || + afterReadEntityFromNBTHooks != null; + + beforeSetDeadHooks = create(beforeSetDeadHookTypes); + overrideSetDeadHooks = create(overrideSetDeadHookTypes); + afterSetDeadHooks = create(afterSetDeadHookTypes); + isSetDeadModded = + beforeSetDeadHooks != null || + overrideSetDeadHooks != null || + afterSetDeadHooks != null; + + beforeSetEntityActionStateHooks = create(beforeSetEntityActionStateHookTypes); + overrideSetEntityActionStateHooks = create(overrideSetEntityActionStateHookTypes); + afterSetEntityActionStateHooks = create(afterSetEntityActionStateHookTypes); + isSetEntityActionStateModded = + beforeSetEntityActionStateHooks != null || + overrideSetEntityActionStateHooks != null || + afterSetEntityActionStateHooks != null; + + beforeSetPositionHooks = create(beforeSetPositionHookTypes); + overrideSetPositionHooks = create(overrideSetPositionHookTypes); + afterSetPositionHooks = create(afterSetPositionHookTypes); + isSetPositionModded = + beforeSetPositionHooks != null || + overrideSetPositionHooks != null || + afterSetPositionHooks != null; + + beforeSetSneakingHooks = create(beforeSetSneakingHookTypes); + overrideSetSneakingHooks = create(overrideSetSneakingHookTypes); + afterSetSneakingHooks = create(afterSetSneakingHookTypes); + isSetSneakingModded = + beforeSetSneakingHooks != null || + overrideSetSneakingHooks != null || + afterSetSneakingHooks != null; + + beforeSetSprintingHooks = create(beforeSetSprintingHookTypes); + overrideSetSprintingHooks = create(overrideSetSprintingHookTypes); + afterSetSprintingHooks = create(afterSetSprintingHookTypes); + isSetSprintingModded = + beforeSetSprintingHooks != null || + overrideSetSprintingHooks != null || + afterSetSprintingHooks != null; + + beforeSwingItemHooks = create(beforeSwingItemHookTypes); + overrideSwingItemHooks = create(overrideSwingItemHookTypes); + afterSwingItemHooks = create(afterSwingItemHookTypes); + isSwingItemModded = + beforeSwingItemHooks != null || + overrideSwingItemHooks != null || + afterSwingItemHooks != null; + + beforeUpdateEntityActionStateHooks = create(beforeUpdateEntityActionStateHookTypes); + overrideUpdateEntityActionStateHooks = create(overrideUpdateEntityActionStateHookTypes); + afterUpdateEntityActionStateHooks = create(afterUpdateEntityActionStateHookTypes); + isUpdateEntityActionStateModded = + beforeUpdateEntityActionStateHooks != null || + overrideUpdateEntityActionStateHooks != null || + afterUpdateEntityActionStateHooks != null; + + beforeUpdatePotionEffectsHooks = create(beforeUpdatePotionEffectsHookTypes); + overrideUpdatePotionEffectsHooks = create(overrideUpdatePotionEffectsHookTypes); + afterUpdatePotionEffectsHooks = create(afterUpdatePotionEffectsHookTypes); + isUpdatePotionEffectsModded = + beforeUpdatePotionEffectsHooks != null || + overrideUpdatePotionEffectsHooks != null || + afterUpdatePotionEffectsHooks != null; + + beforeUpdateRiddenHooks = create(beforeUpdateRiddenHookTypes); + overrideUpdateRiddenHooks = create(overrideUpdateRiddenHookTypes); + afterUpdateRiddenHooks = create(afterUpdateRiddenHookTypes); + isUpdateRiddenModded = + beforeUpdateRiddenHooks != null || + overrideUpdateRiddenHooks != null || + afterUpdateRiddenHooks != null; + + beforeWakeUpPlayerHooks = create(beforeWakeUpPlayerHookTypes); + overrideWakeUpPlayerHooks = create(overrideWakeUpPlayerHookTypes); + afterWakeUpPlayerHooks = create(afterWakeUpPlayerHookTypes); + isWakeUpPlayerModded = + beforeWakeUpPlayerHooks != null || + overrideWakeUpPlayerHooks != null || + afterWakeUpPlayerHooks != null; + + beforeWriteEntityToNBTHooks = create(beforeWriteEntityToNBTHookTypes); + overrideWriteEntityToNBTHooks = create(overrideWriteEntityToNBTHookTypes); + afterWriteEntityToNBTHooks = create(afterWriteEntityToNBTHookTypes); + isWriteEntityToNBTModded = + beforeWriteEntityToNBTHooks != null || + overrideWriteEntityToNBTHooks != null || + afterWriteEntityToNBTHooks != null; + + } + + private void attachServerPlayerBase(String id) + { + ServerPlayerBase toAttach = createServerPlayerBase(id); + toAttach.beforeBaseAttach(true); + allBaseObjects.put(id, toAttach); + updateServerPlayerBases(); + toAttach.afterBaseAttach(true); + } + + private void detachServerPlayerBase(String id) + { + ServerPlayerBase toDetach = allBaseObjects.get(id); + toDetach.beforeBaseDetach(true); + allBaseObjects.remove(id); + toDetach.afterBaseDetach(true); + } + + private ServerPlayerBase[] create(List<String> types) + { + if(types.isEmpty()) + return null; + + ServerPlayerBase[] result = new ServerPlayerBase[types.size()]; + for(int i = 0; i < result.length; i++) + result[i] = getServerPlayerBase(types.get(i)); + return result; + } + + private void beforeLocalConstructing(net.minecraft.server.MinecraftServer paramMinecraftServer, net.minecraft.world.WorldServer paramWorldServer, com.mojang.authlib.GameProfile paramGameProfile, net.minecraft.server.management.ItemInWorldManager paramItemInWorldManager) + { + if(beforeLocalConstructingHooks != null) + for(int i = beforeLocalConstructingHooks.length - 1; i >= 0 ; i--) + beforeLocalConstructingHooks[i].beforeLocalConstructing(paramMinecraftServer, paramWorldServer, paramGameProfile, paramItemInWorldManager); + beforeLocalConstructingHooks = null; + } + + private void afterLocalConstructing(net.minecraft.server.MinecraftServer paramMinecraftServer, net.minecraft.world.WorldServer paramWorldServer, com.mojang.authlib.GameProfile paramGameProfile, net.minecraft.server.management.ItemInWorldManager paramItemInWorldManager) + { + if(afterLocalConstructingHooks != null) + for(int i = 0; i < afterLocalConstructingHooks.length; i++) + afterLocalConstructingHooks[i].afterLocalConstructing(paramMinecraftServer, paramWorldServer, paramGameProfile, paramItemInWorldManager); + afterLocalConstructingHooks = null; + } + + public ServerPlayerBase getServerPlayerBase(String id) + { + return allBaseObjects.get(id); + } + + public Set<String> getServerPlayerBaseIds() + { + return unmodifiableAllBaseIds; + } + + public Object dynamic(String key, Object[] parameters) + { + key = key.replace('.', '_').replace(' ', '_'); + executeAll(key, parameters, beforeDynamicHookTypes, beforeDynamicHookMethods, true); + Object result = dynamicOverwritten(key, parameters, null); + executeAll(key, parameters, afterDynamicHookTypes, afterDynamicHookMethods, false); + return result; + } + + public Object dynamicOverwritten(String key, Object[] parameters, ServerPlayerBase overwriter) + { + List<String> overrideIds = overrideDynamicHookTypes.get(key); + + String id = null; + if(overrideIds != null) + if(overwriter != null) + { + id = baseObjectsToId.get(overwriter); + int index = overrideIds.indexOf(id); + if(index > 0) + id = overrideIds.get(index - 1); + else + id = null; + } + else if(overrideIds.size() > 0) + id = overrideIds.get(overrideIds.size() - 1); + + Map<Class<?>, Map<String, Method>> methodMap; + + if(id == null) + { + id = keysToVirtualIds.get(key); + if(id == null) + return null; + methodMap = virtualDynamicHookMethods; + } + else + methodMap = overrideDynamicHookMethods; + + Map<String, Method> methods = methodMap.get(allBaseConstructors.get(id).getDeclaringClass()); + if(methods == null) + return null; + + Method method = methods.get(key); + if(method == null) + return null; + + return execute(getServerPlayerBase(id), method, parameters); + } + + private void executeAll(String key, Object[] parameters, Map<String, List<String>> dynamicHookTypes, Map<Class<?>, Map<String, Method>> dynamicHookMethods, boolean reverse) + { + List<String> beforeIds = dynamicHookTypes.get(key); + if(beforeIds == null) + return; + + for(int i= reverse ? beforeIds.size() - 1 : 0; reverse ? i >= 0 : i < beforeIds.size(); i = i + (reverse ? -1 : 1)) + { + String id = beforeIds.get(i); + ServerPlayerBase base = getServerPlayerBase(id); + Class<?> type = base.getClass(); + + Map<String, Method> methods = dynamicHookMethods.get(type); + if(methods == null) + continue; + + Method method = methods.get(key); + if(method == null) + continue; + + execute(base, method, parameters); + } + } + + private Object execute(ServerPlayerBase base, Method method, Object[] parameters) + { + try + { + return method.invoke(base, parameters); + } + catch(Exception e) + { + throw new RuntimeException("Exception while invoking dynamic method", e); + } + } + + public static void addExhaustion(IServerPlayerAPI target, float paramFloat) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isAddExhaustionModded) + serverPlayerAPI.addExhaustion(paramFloat); + else + target.localAddExhaustion(paramFloat); + } + + private void addExhaustion(float paramFloat) + { + if(beforeAddExhaustionHooks != null) + for(int i = beforeAddExhaustionHooks.length - 1; i >= 0 ; i--) + beforeAddExhaustionHooks[i].beforeAddExhaustion(paramFloat); + + if(overrideAddExhaustionHooks != null) + overrideAddExhaustionHooks[overrideAddExhaustionHooks.length - 1].addExhaustion(paramFloat); + else + player.localAddExhaustion(paramFloat); + + if(afterAddExhaustionHooks != null) + for(int i = 0; i < afterAddExhaustionHooks.length; i++) + afterAddExhaustionHooks[i].afterAddExhaustion(paramFloat); + + } + + protected ServerPlayerBase GetOverwrittenAddExhaustion(ServerPlayerBase overWriter) + { + if (overrideAddExhaustionHooks == null) + return overWriter; + + for(int i = 0; i < overrideAddExhaustionHooks.length; i++) + if(overrideAddExhaustionHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideAddExhaustionHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeAddExhaustionHookTypes = new LinkedList<String>(); + private final static List<String> overrideAddExhaustionHookTypes = new LinkedList<String>(); + private final static List<String> afterAddExhaustionHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeAddExhaustionHooks; + private ServerPlayerBase[] overrideAddExhaustionHooks; + private ServerPlayerBase[] afterAddExhaustionHooks; + + public boolean isAddExhaustionModded; + + private static final Map<String, String[]> allBaseBeforeAddExhaustionSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeAddExhaustionInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideAddExhaustionSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideAddExhaustionInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterAddExhaustionSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterAddExhaustionInferiors = new Hashtable<String, String[]>(0); + + public static void addExperience(IServerPlayerAPI target, int paramInt) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isAddExperienceModded) + serverPlayerAPI.addExperience(paramInt); + else + target.localAddExperience(paramInt); + } + + private void addExperience(int paramInt) + { + if(beforeAddExperienceHooks != null) + for(int i = beforeAddExperienceHooks.length - 1; i >= 0 ; i--) + beforeAddExperienceHooks[i].beforeAddExperience(paramInt); + + if(overrideAddExperienceHooks != null) + overrideAddExperienceHooks[overrideAddExperienceHooks.length - 1].addExperience(paramInt); + else + player.localAddExperience(paramInt); + + if(afterAddExperienceHooks != null) + for(int i = 0; i < afterAddExperienceHooks.length; i++) + afterAddExperienceHooks[i].afterAddExperience(paramInt); + + } + + protected ServerPlayerBase GetOverwrittenAddExperience(ServerPlayerBase overWriter) + { + if (overrideAddExperienceHooks == null) + return overWriter; + + for(int i = 0; i < overrideAddExperienceHooks.length; i++) + if(overrideAddExperienceHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideAddExperienceHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeAddExperienceHookTypes = new LinkedList<String>(); + private final static List<String> overrideAddExperienceHookTypes = new LinkedList<String>(); + private final static List<String> afterAddExperienceHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeAddExperienceHooks; + private ServerPlayerBase[] overrideAddExperienceHooks; + private ServerPlayerBase[] afterAddExperienceHooks; + + public boolean isAddExperienceModded; + + private static final Map<String, String[]> allBaseBeforeAddExperienceSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeAddExperienceInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideAddExperienceSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideAddExperienceInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterAddExperienceSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterAddExperienceInferiors = new Hashtable<String, String[]>(0); + + public static void addExperienceLevel(IServerPlayerAPI target, int paramInt) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isAddExperienceLevelModded) + serverPlayerAPI.addExperienceLevel(paramInt); + else + target.localAddExperienceLevel(paramInt); + } + + private void addExperienceLevel(int paramInt) + { + if(beforeAddExperienceLevelHooks != null) + for(int i = beforeAddExperienceLevelHooks.length - 1; i >= 0 ; i--) + beforeAddExperienceLevelHooks[i].beforeAddExperienceLevel(paramInt); + + if(overrideAddExperienceLevelHooks != null) + overrideAddExperienceLevelHooks[overrideAddExperienceLevelHooks.length - 1].addExperienceLevel(paramInt); + else + player.localAddExperienceLevel(paramInt); + + if(afterAddExperienceLevelHooks != null) + for(int i = 0; i < afterAddExperienceLevelHooks.length; i++) + afterAddExperienceLevelHooks[i].afterAddExperienceLevel(paramInt); + + } + + protected ServerPlayerBase GetOverwrittenAddExperienceLevel(ServerPlayerBase overWriter) + { + if (overrideAddExperienceLevelHooks == null) + return overWriter; + + for(int i = 0; i < overrideAddExperienceLevelHooks.length; i++) + if(overrideAddExperienceLevelHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideAddExperienceLevelHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeAddExperienceLevelHookTypes = new LinkedList<String>(); + private final static List<String> overrideAddExperienceLevelHookTypes = new LinkedList<String>(); + private final static List<String> afterAddExperienceLevelHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeAddExperienceLevelHooks; + private ServerPlayerBase[] overrideAddExperienceLevelHooks; + private ServerPlayerBase[] afterAddExperienceLevelHooks; + + public boolean isAddExperienceLevelModded; + + private static final Map<String, String[]> allBaseBeforeAddExperienceLevelSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeAddExperienceLevelInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideAddExperienceLevelSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideAddExperienceLevelInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterAddExperienceLevelSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterAddExperienceLevelInferiors = new Hashtable<String, String[]>(0); + + public static void addMovementStat(IServerPlayerAPI target, double paramDouble1, double paramDouble2, double paramDouble3) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isAddMovementStatModded) + serverPlayerAPI.addMovementStat(paramDouble1, paramDouble2, paramDouble3); + else + target.localAddMovementStat(paramDouble1, paramDouble2, paramDouble3); + } + + private void addMovementStat(double paramDouble1, double paramDouble2, double paramDouble3) + { + if(beforeAddMovementStatHooks != null) + for(int i = beforeAddMovementStatHooks.length - 1; i >= 0 ; i--) + beforeAddMovementStatHooks[i].beforeAddMovementStat(paramDouble1, paramDouble2, paramDouble3); + + if(overrideAddMovementStatHooks != null) + overrideAddMovementStatHooks[overrideAddMovementStatHooks.length - 1].addMovementStat(paramDouble1, paramDouble2, paramDouble3); + else + player.localAddMovementStat(paramDouble1, paramDouble2, paramDouble3); + + if(afterAddMovementStatHooks != null) + for(int i = 0; i < afterAddMovementStatHooks.length; i++) + afterAddMovementStatHooks[i].afterAddMovementStat(paramDouble1, paramDouble2, paramDouble3); + + } + + protected ServerPlayerBase GetOverwrittenAddMovementStat(ServerPlayerBase overWriter) + { + if (overrideAddMovementStatHooks == null) + return overWriter; + + for(int i = 0; i < overrideAddMovementStatHooks.length; i++) + if(overrideAddMovementStatHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideAddMovementStatHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeAddMovementStatHookTypes = new LinkedList<String>(); + private final static List<String> overrideAddMovementStatHookTypes = new LinkedList<String>(); + private final static List<String> afterAddMovementStatHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeAddMovementStatHooks; + private ServerPlayerBase[] overrideAddMovementStatHooks; + private ServerPlayerBase[] afterAddMovementStatHooks; + + public boolean isAddMovementStatModded; + + private static final Map<String, String[]> allBaseBeforeAddMovementStatSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeAddMovementStatInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideAddMovementStatSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideAddMovementStatInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterAddMovementStatSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterAddMovementStatInferiors = new Hashtable<String, String[]>(0); + + public static boolean attackEntityFrom(IServerPlayerAPI target, net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + boolean _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isAttackEntityFromModded) + _result = serverPlayerAPI.attackEntityFrom(paramDamageSource, paramFloat); + else + _result = target.localAttackEntityFrom(paramDamageSource, paramFloat); + return _result; + } + + private boolean attackEntityFrom(net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + if(beforeAttackEntityFromHooks != null) + for(int i = beforeAttackEntityFromHooks.length - 1; i >= 0 ; i--) + beforeAttackEntityFromHooks[i].beforeAttackEntityFrom(paramDamageSource, paramFloat); + + boolean _result; + if(overrideAttackEntityFromHooks != null) + _result = overrideAttackEntityFromHooks[overrideAttackEntityFromHooks.length - 1].attackEntityFrom(paramDamageSource, paramFloat); + else + _result = player.localAttackEntityFrom(paramDamageSource, paramFloat); + + if(afterAttackEntityFromHooks != null) + for(int i = 0; i < afterAttackEntityFromHooks.length; i++) + afterAttackEntityFromHooks[i].afterAttackEntityFrom(paramDamageSource, paramFloat); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenAttackEntityFrom(ServerPlayerBase overWriter) + { + if (overrideAttackEntityFromHooks == null) + return overWriter; + + for(int i = 0; i < overrideAttackEntityFromHooks.length; i++) + if(overrideAttackEntityFromHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideAttackEntityFromHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeAttackEntityFromHookTypes = new LinkedList<String>(); + private final static List<String> overrideAttackEntityFromHookTypes = new LinkedList<String>(); + private final static List<String> afterAttackEntityFromHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeAttackEntityFromHooks; + private ServerPlayerBase[] overrideAttackEntityFromHooks; + private ServerPlayerBase[] afterAttackEntityFromHooks; + + public boolean isAttackEntityFromModded; + + private static final Map<String, String[]> allBaseBeforeAttackEntityFromSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeAttackEntityFromInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideAttackEntityFromSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideAttackEntityFromInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterAttackEntityFromSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterAttackEntityFromInferiors = new Hashtable<String, String[]>(0); + + public static void attackTargetEntityWithCurrentItem(IServerPlayerAPI target, net.minecraft.entity.Entity paramEntity) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isAttackTargetEntityWithCurrentItemModded) + serverPlayerAPI.attackTargetEntityWithCurrentItem(paramEntity); + else + target.localAttackTargetEntityWithCurrentItem(paramEntity); + } + + private void attackTargetEntityWithCurrentItem(net.minecraft.entity.Entity paramEntity) + { + if(beforeAttackTargetEntityWithCurrentItemHooks != null) + for(int i = beforeAttackTargetEntityWithCurrentItemHooks.length - 1; i >= 0 ; i--) + beforeAttackTargetEntityWithCurrentItemHooks[i].beforeAttackTargetEntityWithCurrentItem(paramEntity); + + if(overrideAttackTargetEntityWithCurrentItemHooks != null) + overrideAttackTargetEntityWithCurrentItemHooks[overrideAttackTargetEntityWithCurrentItemHooks.length - 1].attackTargetEntityWithCurrentItem(paramEntity); + else + player.localAttackTargetEntityWithCurrentItem(paramEntity); + + if(afterAttackTargetEntityWithCurrentItemHooks != null) + for(int i = 0; i < afterAttackTargetEntityWithCurrentItemHooks.length; i++) + afterAttackTargetEntityWithCurrentItemHooks[i].afterAttackTargetEntityWithCurrentItem(paramEntity); + + } + + protected ServerPlayerBase GetOverwrittenAttackTargetEntityWithCurrentItem(ServerPlayerBase overWriter) + { + if (overrideAttackTargetEntityWithCurrentItemHooks == null) + return overWriter; + + for(int i = 0; i < overrideAttackTargetEntityWithCurrentItemHooks.length; i++) + if(overrideAttackTargetEntityWithCurrentItemHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideAttackTargetEntityWithCurrentItemHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeAttackTargetEntityWithCurrentItemHookTypes = new LinkedList<String>(); + private final static List<String> overrideAttackTargetEntityWithCurrentItemHookTypes = new LinkedList<String>(); + private final static List<String> afterAttackTargetEntityWithCurrentItemHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeAttackTargetEntityWithCurrentItemHooks; + private ServerPlayerBase[] overrideAttackTargetEntityWithCurrentItemHooks; + private ServerPlayerBase[] afterAttackTargetEntityWithCurrentItemHooks; + + public boolean isAttackTargetEntityWithCurrentItemModded; + + private static final Map<String, String[]> allBaseBeforeAttackTargetEntityWithCurrentItemSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeAttackTargetEntityWithCurrentItemInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideAttackTargetEntityWithCurrentItemSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideAttackTargetEntityWithCurrentItemInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterAttackTargetEntityWithCurrentItemSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterAttackTargetEntityWithCurrentItemInferiors = new Hashtable<String, String[]>(0); + + public static boolean canBreatheUnderwater(IServerPlayerAPI target) + { + boolean _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isCanBreatheUnderwaterModded) + _result = serverPlayerAPI.canBreatheUnderwater(); + else + _result = target.localCanBreatheUnderwater(); + return _result; + } + + private boolean canBreatheUnderwater() + { + if(beforeCanBreatheUnderwaterHooks != null) + for(int i = beforeCanBreatheUnderwaterHooks.length - 1; i >= 0 ; i--) + beforeCanBreatheUnderwaterHooks[i].beforeCanBreatheUnderwater(); + + boolean _result; + if(overrideCanBreatheUnderwaterHooks != null) + _result = overrideCanBreatheUnderwaterHooks[overrideCanBreatheUnderwaterHooks.length - 1].canBreatheUnderwater(); + else + _result = player.localCanBreatheUnderwater(); + + if(afterCanBreatheUnderwaterHooks != null) + for(int i = 0; i < afterCanBreatheUnderwaterHooks.length; i++) + afterCanBreatheUnderwaterHooks[i].afterCanBreatheUnderwater(); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenCanBreatheUnderwater(ServerPlayerBase overWriter) + { + if (overrideCanBreatheUnderwaterHooks == null) + return overWriter; + + for(int i = 0; i < overrideCanBreatheUnderwaterHooks.length; i++) + if(overrideCanBreatheUnderwaterHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideCanBreatheUnderwaterHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeCanBreatheUnderwaterHookTypes = new LinkedList<String>(); + private final static List<String> overrideCanBreatheUnderwaterHookTypes = new LinkedList<String>(); + private final static List<String> afterCanBreatheUnderwaterHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeCanBreatheUnderwaterHooks; + private ServerPlayerBase[] overrideCanBreatheUnderwaterHooks; + private ServerPlayerBase[] afterCanBreatheUnderwaterHooks; + + public boolean isCanBreatheUnderwaterModded; + + private static final Map<String, String[]> allBaseBeforeCanBreatheUnderwaterSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeCanBreatheUnderwaterInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideCanBreatheUnderwaterSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideCanBreatheUnderwaterInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterCanBreatheUnderwaterSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterCanBreatheUnderwaterInferiors = new Hashtable<String, String[]>(0); + + public static boolean canHarvestBlock(IServerPlayerAPI target, net.minecraft.block.Block paramBlock) + { + boolean _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isCanHarvestBlockModded) + _result = serverPlayerAPI.canHarvestBlock(paramBlock); + else + _result = target.localCanHarvestBlock(paramBlock); + return _result; + } + + private boolean canHarvestBlock(net.minecraft.block.Block paramBlock) + { + if(beforeCanHarvestBlockHooks != null) + for(int i = beforeCanHarvestBlockHooks.length - 1; i >= 0 ; i--) + beforeCanHarvestBlockHooks[i].beforeCanHarvestBlock(paramBlock); + + boolean _result; + if(overrideCanHarvestBlockHooks != null) + _result = overrideCanHarvestBlockHooks[overrideCanHarvestBlockHooks.length - 1].canHarvestBlock(paramBlock); + else + _result = player.localCanHarvestBlock(paramBlock); + + if(afterCanHarvestBlockHooks != null) + for(int i = 0; i < afterCanHarvestBlockHooks.length; i++) + afterCanHarvestBlockHooks[i].afterCanHarvestBlock(paramBlock); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenCanHarvestBlock(ServerPlayerBase overWriter) + { + if (overrideCanHarvestBlockHooks == null) + return overWriter; + + for(int i = 0; i < overrideCanHarvestBlockHooks.length; i++) + if(overrideCanHarvestBlockHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideCanHarvestBlockHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeCanHarvestBlockHookTypes = new LinkedList<String>(); + private final static List<String> overrideCanHarvestBlockHookTypes = new LinkedList<String>(); + private final static List<String> afterCanHarvestBlockHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeCanHarvestBlockHooks; + private ServerPlayerBase[] overrideCanHarvestBlockHooks; + private ServerPlayerBase[] afterCanHarvestBlockHooks; + + public boolean isCanHarvestBlockModded; + + private static final Map<String, String[]> allBaseBeforeCanHarvestBlockSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeCanHarvestBlockInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideCanHarvestBlockSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideCanHarvestBlockInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterCanHarvestBlockSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterCanHarvestBlockInferiors = new Hashtable<String, String[]>(0); + + public static boolean canPlayerEdit(IServerPlayerAPI target, int paramInt1, int paramInt2, int paramInt3, int paramInt4, net.minecraft.item.ItemStack paramItemStack) + { + boolean _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isCanPlayerEditModded) + _result = serverPlayerAPI.canPlayerEdit(paramInt1, paramInt2, paramInt3, paramInt4, paramItemStack); + else + _result = target.localCanPlayerEdit(paramInt1, paramInt2, paramInt3, paramInt4, paramItemStack); + return _result; + } + + private boolean canPlayerEdit(int paramInt1, int paramInt2, int paramInt3, int paramInt4, net.minecraft.item.ItemStack paramItemStack) + { + if(beforeCanPlayerEditHooks != null) + for(int i = beforeCanPlayerEditHooks.length - 1; i >= 0 ; i--) + beforeCanPlayerEditHooks[i].beforeCanPlayerEdit(paramInt1, paramInt2, paramInt3, paramInt4, paramItemStack); + + boolean _result; + if(overrideCanPlayerEditHooks != null) + _result = overrideCanPlayerEditHooks[overrideCanPlayerEditHooks.length - 1].canPlayerEdit(paramInt1, paramInt2, paramInt3, paramInt4, paramItemStack); + else + _result = player.localCanPlayerEdit(paramInt1, paramInt2, paramInt3, paramInt4, paramItemStack); + + if(afterCanPlayerEditHooks != null) + for(int i = 0; i < afterCanPlayerEditHooks.length; i++) + afterCanPlayerEditHooks[i].afterCanPlayerEdit(paramInt1, paramInt2, paramInt3, paramInt4, paramItemStack); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenCanPlayerEdit(ServerPlayerBase overWriter) + { + if (overrideCanPlayerEditHooks == null) + return overWriter; + + for(int i = 0; i < overrideCanPlayerEditHooks.length; i++) + if(overrideCanPlayerEditHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideCanPlayerEditHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeCanPlayerEditHookTypes = new LinkedList<String>(); + private final static List<String> overrideCanPlayerEditHookTypes = new LinkedList<String>(); + private final static List<String> afterCanPlayerEditHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeCanPlayerEditHooks; + private ServerPlayerBase[] overrideCanPlayerEditHooks; + private ServerPlayerBase[] afterCanPlayerEditHooks; + + public boolean isCanPlayerEditModded; + + private static final Map<String, String[]> allBaseBeforeCanPlayerEditSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeCanPlayerEditInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideCanPlayerEditSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideCanPlayerEditInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterCanPlayerEditSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterCanPlayerEditInferiors = new Hashtable<String, String[]>(0); + + public static boolean canTriggerWalking(IServerPlayerAPI target) + { + boolean _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isCanTriggerWalkingModded) + _result = serverPlayerAPI.canTriggerWalking(); + else + _result = target.localCanTriggerWalking(); + return _result; + } + + private boolean canTriggerWalking() + { + if(beforeCanTriggerWalkingHooks != null) + for(int i = beforeCanTriggerWalkingHooks.length - 1; i >= 0 ; i--) + beforeCanTriggerWalkingHooks[i].beforeCanTriggerWalking(); + + boolean _result; + if(overrideCanTriggerWalkingHooks != null) + _result = overrideCanTriggerWalkingHooks[overrideCanTriggerWalkingHooks.length - 1].canTriggerWalking(); + else + _result = player.localCanTriggerWalking(); + + if(afterCanTriggerWalkingHooks != null) + for(int i = 0; i < afterCanTriggerWalkingHooks.length; i++) + afterCanTriggerWalkingHooks[i].afterCanTriggerWalking(); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenCanTriggerWalking(ServerPlayerBase overWriter) + { + if (overrideCanTriggerWalkingHooks == null) + return overWriter; + + for(int i = 0; i < overrideCanTriggerWalkingHooks.length; i++) + if(overrideCanTriggerWalkingHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideCanTriggerWalkingHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeCanTriggerWalkingHookTypes = new LinkedList<String>(); + private final static List<String> overrideCanTriggerWalkingHookTypes = new LinkedList<String>(); + private final static List<String> afterCanTriggerWalkingHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeCanTriggerWalkingHooks; + private ServerPlayerBase[] overrideCanTriggerWalkingHooks; + private ServerPlayerBase[] afterCanTriggerWalkingHooks; + + public boolean isCanTriggerWalkingModded; + + private static final Map<String, String[]> allBaseBeforeCanTriggerWalkingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeCanTriggerWalkingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideCanTriggerWalkingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideCanTriggerWalkingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterCanTriggerWalkingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterCanTriggerWalkingInferiors = new Hashtable<String, String[]>(0); + + public static void clonePlayer(IServerPlayerAPI target, net.minecraft.entity.player.EntityPlayer paramEntityPlayer, boolean paramBoolean) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isClonePlayerModded) + serverPlayerAPI.clonePlayer(paramEntityPlayer, paramBoolean); + else + target.localClonePlayer(paramEntityPlayer, paramBoolean); + } + + private void clonePlayer(net.minecraft.entity.player.EntityPlayer paramEntityPlayer, boolean paramBoolean) + { + if(beforeClonePlayerHooks != null) + for(int i = beforeClonePlayerHooks.length - 1; i >= 0 ; i--) + beforeClonePlayerHooks[i].beforeClonePlayer(paramEntityPlayer, paramBoolean); + + if(overrideClonePlayerHooks != null) + overrideClonePlayerHooks[overrideClonePlayerHooks.length - 1].clonePlayer(paramEntityPlayer, paramBoolean); + else + player.localClonePlayer(paramEntityPlayer, paramBoolean); + + if(afterClonePlayerHooks != null) + for(int i = 0; i < afterClonePlayerHooks.length; i++) + afterClonePlayerHooks[i].afterClonePlayer(paramEntityPlayer, paramBoolean); + + } + + protected ServerPlayerBase GetOverwrittenClonePlayer(ServerPlayerBase overWriter) + { + if (overrideClonePlayerHooks == null) + return overWriter; + + for(int i = 0; i < overrideClonePlayerHooks.length; i++) + if(overrideClonePlayerHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideClonePlayerHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeClonePlayerHookTypes = new LinkedList<String>(); + private final static List<String> overrideClonePlayerHookTypes = new LinkedList<String>(); + private final static List<String> afterClonePlayerHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeClonePlayerHooks; + private ServerPlayerBase[] overrideClonePlayerHooks; + private ServerPlayerBase[] afterClonePlayerHooks; + + public boolean isClonePlayerModded; + + private static final Map<String, String[]> allBaseBeforeClonePlayerSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeClonePlayerInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideClonePlayerSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideClonePlayerInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterClonePlayerSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterClonePlayerInferiors = new Hashtable<String, String[]>(0); + + public static void damageEntity(IServerPlayerAPI target, net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isDamageEntityModded) + serverPlayerAPI.damageEntity(paramDamageSource, paramFloat); + else + target.localDamageEntity(paramDamageSource, paramFloat); + } + + private void damageEntity(net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + if(beforeDamageEntityHooks != null) + for(int i = beforeDamageEntityHooks.length - 1; i >= 0 ; i--) + beforeDamageEntityHooks[i].beforeDamageEntity(paramDamageSource, paramFloat); + + if(overrideDamageEntityHooks != null) + overrideDamageEntityHooks[overrideDamageEntityHooks.length - 1].damageEntity(paramDamageSource, paramFloat); + else + player.localDamageEntity(paramDamageSource, paramFloat); + + if(afterDamageEntityHooks != null) + for(int i = 0; i < afterDamageEntityHooks.length; i++) + afterDamageEntityHooks[i].afterDamageEntity(paramDamageSource, paramFloat); + + } + + protected ServerPlayerBase GetOverwrittenDamageEntity(ServerPlayerBase overWriter) + { + if (overrideDamageEntityHooks == null) + return overWriter; + + for(int i = 0; i < overrideDamageEntityHooks.length; i++) + if(overrideDamageEntityHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideDamageEntityHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeDamageEntityHookTypes = new LinkedList<String>(); + private final static List<String> overrideDamageEntityHookTypes = new LinkedList<String>(); + private final static List<String> afterDamageEntityHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeDamageEntityHooks; + private ServerPlayerBase[] overrideDamageEntityHooks; + private ServerPlayerBase[] afterDamageEntityHooks; + + public boolean isDamageEntityModded; + + private static final Map<String, String[]> allBaseBeforeDamageEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeDamageEntityInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDamageEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDamageEntityInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDamageEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDamageEntityInferiors = new Hashtable<String, String[]>(0); + + public static void displayGUIChest(IServerPlayerAPI target, net.minecraft.inventory.IInventory paramIInventory) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isDisplayGUIChestModded) + serverPlayerAPI.displayGUIChest(paramIInventory); + else + target.localDisplayGUIChest(paramIInventory); + } + + private void displayGUIChest(net.minecraft.inventory.IInventory paramIInventory) + { + if(beforeDisplayGUIChestHooks != null) + for(int i = beforeDisplayGUIChestHooks.length - 1; i >= 0 ; i--) + beforeDisplayGUIChestHooks[i].beforeDisplayGUIChest(paramIInventory); + + if(overrideDisplayGUIChestHooks != null) + overrideDisplayGUIChestHooks[overrideDisplayGUIChestHooks.length - 1].displayGUIChest(paramIInventory); + else + player.localDisplayGUIChest(paramIInventory); + + if(afterDisplayGUIChestHooks != null) + for(int i = 0; i < afterDisplayGUIChestHooks.length; i++) + afterDisplayGUIChestHooks[i].afterDisplayGUIChest(paramIInventory); + + } + + protected ServerPlayerBase GetOverwrittenDisplayGUIChest(ServerPlayerBase overWriter) + { + if (overrideDisplayGUIChestHooks == null) + return overWriter; + + for(int i = 0; i < overrideDisplayGUIChestHooks.length; i++) + if(overrideDisplayGUIChestHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideDisplayGUIChestHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeDisplayGUIChestHookTypes = new LinkedList<String>(); + private final static List<String> overrideDisplayGUIChestHookTypes = new LinkedList<String>(); + private final static List<String> afterDisplayGUIChestHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeDisplayGUIChestHooks; + private ServerPlayerBase[] overrideDisplayGUIChestHooks; + private ServerPlayerBase[] afterDisplayGUIChestHooks; + + public boolean isDisplayGUIChestModded; + + private static final Map<String, String[]> allBaseBeforeDisplayGUIChestSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeDisplayGUIChestInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDisplayGUIChestSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDisplayGUIChestInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDisplayGUIChestSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDisplayGUIChestInferiors = new Hashtable<String, String[]>(0); + + public static void displayGUIDispenser(IServerPlayerAPI target, net.minecraft.tileentity.TileEntityDispenser paramTileEntityDispenser) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isDisplayGUIDispenserModded) + serverPlayerAPI.displayGUIDispenser(paramTileEntityDispenser); + else + target.localDisplayGUIDispenser(paramTileEntityDispenser); + } + + private void displayGUIDispenser(net.minecraft.tileentity.TileEntityDispenser paramTileEntityDispenser) + { + if(beforeDisplayGUIDispenserHooks != null) + for(int i = beforeDisplayGUIDispenserHooks.length - 1; i >= 0 ; i--) + beforeDisplayGUIDispenserHooks[i].beforeDisplayGUIDispenser(paramTileEntityDispenser); + + if(overrideDisplayGUIDispenserHooks != null) + overrideDisplayGUIDispenserHooks[overrideDisplayGUIDispenserHooks.length - 1].displayGUIDispenser(paramTileEntityDispenser); + else + player.localDisplayGUIDispenser(paramTileEntityDispenser); + + if(afterDisplayGUIDispenserHooks != null) + for(int i = 0; i < afterDisplayGUIDispenserHooks.length; i++) + afterDisplayGUIDispenserHooks[i].afterDisplayGUIDispenser(paramTileEntityDispenser); + + } + + protected ServerPlayerBase GetOverwrittenDisplayGUIDispenser(ServerPlayerBase overWriter) + { + if (overrideDisplayGUIDispenserHooks == null) + return overWriter; + + for(int i = 0; i < overrideDisplayGUIDispenserHooks.length; i++) + if(overrideDisplayGUIDispenserHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideDisplayGUIDispenserHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeDisplayGUIDispenserHookTypes = new LinkedList<String>(); + private final static List<String> overrideDisplayGUIDispenserHookTypes = new LinkedList<String>(); + private final static List<String> afterDisplayGUIDispenserHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeDisplayGUIDispenserHooks; + private ServerPlayerBase[] overrideDisplayGUIDispenserHooks; + private ServerPlayerBase[] afterDisplayGUIDispenserHooks; + + public boolean isDisplayGUIDispenserModded; + + private static final Map<String, String[]> allBaseBeforeDisplayGUIDispenserSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeDisplayGUIDispenserInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDisplayGUIDispenserSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDisplayGUIDispenserInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDisplayGUIDispenserSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDisplayGUIDispenserInferiors = new Hashtable<String, String[]>(0); + + public static void displayGUIFurnace(IServerPlayerAPI target, net.minecraft.tileentity.TileEntityFurnace paramTileEntityFurnace) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isDisplayGUIFurnaceModded) + serverPlayerAPI.displayGUIFurnace(paramTileEntityFurnace); + else + target.localDisplayGUIFurnace(paramTileEntityFurnace); + } + + private void displayGUIFurnace(net.minecraft.tileentity.TileEntityFurnace paramTileEntityFurnace) + { + if(beforeDisplayGUIFurnaceHooks != null) + for(int i = beforeDisplayGUIFurnaceHooks.length - 1; i >= 0 ; i--) + beforeDisplayGUIFurnaceHooks[i].beforeDisplayGUIFurnace(paramTileEntityFurnace); + + if(overrideDisplayGUIFurnaceHooks != null) + overrideDisplayGUIFurnaceHooks[overrideDisplayGUIFurnaceHooks.length - 1].displayGUIFurnace(paramTileEntityFurnace); + else + player.localDisplayGUIFurnace(paramTileEntityFurnace); + + if(afterDisplayGUIFurnaceHooks != null) + for(int i = 0; i < afterDisplayGUIFurnaceHooks.length; i++) + afterDisplayGUIFurnaceHooks[i].afterDisplayGUIFurnace(paramTileEntityFurnace); + + } + + protected ServerPlayerBase GetOverwrittenDisplayGUIFurnace(ServerPlayerBase overWriter) + { + if (overrideDisplayGUIFurnaceHooks == null) + return overWriter; + + for(int i = 0; i < overrideDisplayGUIFurnaceHooks.length; i++) + if(overrideDisplayGUIFurnaceHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideDisplayGUIFurnaceHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeDisplayGUIFurnaceHookTypes = new LinkedList<String>(); + private final static List<String> overrideDisplayGUIFurnaceHookTypes = new LinkedList<String>(); + private final static List<String> afterDisplayGUIFurnaceHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeDisplayGUIFurnaceHooks; + private ServerPlayerBase[] overrideDisplayGUIFurnaceHooks; + private ServerPlayerBase[] afterDisplayGUIFurnaceHooks; + + public boolean isDisplayGUIFurnaceModded; + + private static final Map<String, String[]> allBaseBeforeDisplayGUIFurnaceSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeDisplayGUIFurnaceInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDisplayGUIFurnaceSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDisplayGUIFurnaceInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDisplayGUIFurnaceSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDisplayGUIFurnaceInferiors = new Hashtable<String, String[]>(0); + + public static void displayGUIWorkbench(IServerPlayerAPI target, int paramInt1, int paramInt2, int paramInt3) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isDisplayGUIWorkbenchModded) + serverPlayerAPI.displayGUIWorkbench(paramInt1, paramInt2, paramInt3); + else + target.localDisplayGUIWorkbench(paramInt1, paramInt2, paramInt3); + } + + private void displayGUIWorkbench(int paramInt1, int paramInt2, int paramInt3) + { + if(beforeDisplayGUIWorkbenchHooks != null) + for(int i = beforeDisplayGUIWorkbenchHooks.length - 1; i >= 0 ; i--) + beforeDisplayGUIWorkbenchHooks[i].beforeDisplayGUIWorkbench(paramInt1, paramInt2, paramInt3); + + if(overrideDisplayGUIWorkbenchHooks != null) + overrideDisplayGUIWorkbenchHooks[overrideDisplayGUIWorkbenchHooks.length - 1].displayGUIWorkbench(paramInt1, paramInt2, paramInt3); + else + player.localDisplayGUIWorkbench(paramInt1, paramInt2, paramInt3); + + if(afterDisplayGUIWorkbenchHooks != null) + for(int i = 0; i < afterDisplayGUIWorkbenchHooks.length; i++) + afterDisplayGUIWorkbenchHooks[i].afterDisplayGUIWorkbench(paramInt1, paramInt2, paramInt3); + + } + + protected ServerPlayerBase GetOverwrittenDisplayGUIWorkbench(ServerPlayerBase overWriter) + { + if (overrideDisplayGUIWorkbenchHooks == null) + return overWriter; + + for(int i = 0; i < overrideDisplayGUIWorkbenchHooks.length; i++) + if(overrideDisplayGUIWorkbenchHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideDisplayGUIWorkbenchHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeDisplayGUIWorkbenchHookTypes = new LinkedList<String>(); + private final static List<String> overrideDisplayGUIWorkbenchHookTypes = new LinkedList<String>(); + private final static List<String> afterDisplayGUIWorkbenchHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeDisplayGUIWorkbenchHooks; + private ServerPlayerBase[] overrideDisplayGUIWorkbenchHooks; + private ServerPlayerBase[] afterDisplayGUIWorkbenchHooks; + + public boolean isDisplayGUIWorkbenchModded; + + private static final Map<String, String[]> allBaseBeforeDisplayGUIWorkbenchSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeDisplayGUIWorkbenchInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDisplayGUIWorkbenchSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDisplayGUIWorkbenchInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDisplayGUIWorkbenchSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDisplayGUIWorkbenchInferiors = new Hashtable<String, String[]>(0); + + public static net.minecraft.entity.item.EntityItem dropOneItem(IServerPlayerAPI target, boolean paramBoolean) + { + net.minecraft.entity.item.EntityItem _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isDropOneItemModded) + _result = serverPlayerAPI.dropOneItem(paramBoolean); + else + _result = target.localDropOneItem(paramBoolean); + return _result; + } + + private net.minecraft.entity.item.EntityItem dropOneItem(boolean paramBoolean) + { + if(beforeDropOneItemHooks != null) + for(int i = beforeDropOneItemHooks.length - 1; i >= 0 ; i--) + beforeDropOneItemHooks[i].beforeDropOneItem(paramBoolean); + + net.minecraft.entity.item.EntityItem _result; + if(overrideDropOneItemHooks != null) + _result = overrideDropOneItemHooks[overrideDropOneItemHooks.length - 1].dropOneItem(paramBoolean); + else + _result = player.localDropOneItem(paramBoolean); + + if(afterDropOneItemHooks != null) + for(int i = 0; i < afterDropOneItemHooks.length; i++) + afterDropOneItemHooks[i].afterDropOneItem(paramBoolean); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenDropOneItem(ServerPlayerBase overWriter) + { + if (overrideDropOneItemHooks == null) + return overWriter; + + for(int i = 0; i < overrideDropOneItemHooks.length; i++) + if(overrideDropOneItemHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideDropOneItemHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeDropOneItemHookTypes = new LinkedList<String>(); + private final static List<String> overrideDropOneItemHookTypes = new LinkedList<String>(); + private final static List<String> afterDropOneItemHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeDropOneItemHooks; + private ServerPlayerBase[] overrideDropOneItemHooks; + private ServerPlayerBase[] afterDropOneItemHooks; + + public boolean isDropOneItemModded; + + private static final Map<String, String[]> allBaseBeforeDropOneItemSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeDropOneItemInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDropOneItemSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDropOneItemInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDropOneItemSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDropOneItemInferiors = new Hashtable<String, String[]>(0); + + public static net.minecraft.entity.item.EntityItem dropPlayerItem(IServerPlayerAPI target, net.minecraft.item.ItemStack paramItemStack, boolean paramBoolean) + { + net.minecraft.entity.item.EntityItem _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isDropPlayerItemModded) + _result = serverPlayerAPI.dropPlayerItem(paramItemStack, paramBoolean); + else + _result = target.localDropPlayerItem(paramItemStack, paramBoolean); + return _result; + } + + private net.minecraft.entity.item.EntityItem dropPlayerItem(net.minecraft.item.ItemStack paramItemStack, boolean paramBoolean) + { + if(beforeDropPlayerItemHooks != null) + for(int i = beforeDropPlayerItemHooks.length - 1; i >= 0 ; i--) + beforeDropPlayerItemHooks[i].beforeDropPlayerItem(paramItemStack, paramBoolean); + + net.minecraft.entity.item.EntityItem _result; + if(overrideDropPlayerItemHooks != null) + _result = overrideDropPlayerItemHooks[overrideDropPlayerItemHooks.length - 1].dropPlayerItem(paramItemStack, paramBoolean); + else + _result = player.localDropPlayerItem(paramItemStack, paramBoolean); + + if(afterDropPlayerItemHooks != null) + for(int i = 0; i < afterDropPlayerItemHooks.length; i++) + afterDropPlayerItemHooks[i].afterDropPlayerItem(paramItemStack, paramBoolean); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenDropPlayerItem(ServerPlayerBase overWriter) + { + if (overrideDropPlayerItemHooks == null) + return overWriter; + + for(int i = 0; i < overrideDropPlayerItemHooks.length; i++) + if(overrideDropPlayerItemHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideDropPlayerItemHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeDropPlayerItemHookTypes = new LinkedList<String>(); + private final static List<String> overrideDropPlayerItemHookTypes = new LinkedList<String>(); + private final static List<String> afterDropPlayerItemHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeDropPlayerItemHooks; + private ServerPlayerBase[] overrideDropPlayerItemHooks; + private ServerPlayerBase[] afterDropPlayerItemHooks; + + public boolean isDropPlayerItemModded; + + private static final Map<String, String[]> allBaseBeforeDropPlayerItemSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeDropPlayerItemInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDropPlayerItemSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideDropPlayerItemInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDropPlayerItemSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterDropPlayerItemInferiors = new Hashtable<String, String[]>(0); + + public static void fall(IServerPlayerAPI target, float paramFloat) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isFallModded) + serverPlayerAPI.fall(paramFloat); + else + target.localFall(paramFloat); + } + + private void fall(float paramFloat) + { + if(beforeFallHooks != null) + for(int i = beforeFallHooks.length - 1; i >= 0 ; i--) + beforeFallHooks[i].beforeFall(paramFloat); + + if(overrideFallHooks != null) + overrideFallHooks[overrideFallHooks.length - 1].fall(paramFloat); + else + player.localFall(paramFloat); + + if(afterFallHooks != null) + for(int i = 0; i < afterFallHooks.length; i++) + afterFallHooks[i].afterFall(paramFloat); + + } + + protected ServerPlayerBase GetOverwrittenFall(ServerPlayerBase overWriter) + { + if (overrideFallHooks == null) + return overWriter; + + for(int i = 0; i < overrideFallHooks.length; i++) + if(overrideFallHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideFallHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeFallHookTypes = new LinkedList<String>(); + private final static List<String> overrideFallHookTypes = new LinkedList<String>(); + private final static List<String> afterFallHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeFallHooks; + private ServerPlayerBase[] overrideFallHooks; + private ServerPlayerBase[] afterFallHooks; + + public boolean isFallModded; + + private static final Map<String, String[]> allBaseBeforeFallSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeFallInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideFallSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideFallInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterFallSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterFallInferiors = new Hashtable<String, String[]>(0); + + public static float getAIMoveSpeed(IServerPlayerAPI target) + { + float _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isGetAIMoveSpeedModded) + _result = serverPlayerAPI.getAIMoveSpeed(); + else + _result = target.localGetAIMoveSpeed(); + return _result; + } + + private float getAIMoveSpeed() + { + if(beforeGetAIMoveSpeedHooks != null) + for(int i = beforeGetAIMoveSpeedHooks.length - 1; i >= 0 ; i--) + beforeGetAIMoveSpeedHooks[i].beforeGetAIMoveSpeed(); + + float _result; + if(overrideGetAIMoveSpeedHooks != null) + _result = overrideGetAIMoveSpeedHooks[overrideGetAIMoveSpeedHooks.length - 1].getAIMoveSpeed(); + else + _result = player.localGetAIMoveSpeed(); + + if(afterGetAIMoveSpeedHooks != null) + for(int i = 0; i < afterGetAIMoveSpeedHooks.length; i++) + afterGetAIMoveSpeedHooks[i].afterGetAIMoveSpeed(); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenGetAIMoveSpeed(ServerPlayerBase overWriter) + { + if (overrideGetAIMoveSpeedHooks == null) + return overWriter; + + for(int i = 0; i < overrideGetAIMoveSpeedHooks.length; i++) + if(overrideGetAIMoveSpeedHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideGetAIMoveSpeedHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeGetAIMoveSpeedHookTypes = new LinkedList<String>(); + private final static List<String> overrideGetAIMoveSpeedHookTypes = new LinkedList<String>(); + private final static List<String> afterGetAIMoveSpeedHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeGetAIMoveSpeedHooks; + private ServerPlayerBase[] overrideGetAIMoveSpeedHooks; + private ServerPlayerBase[] afterGetAIMoveSpeedHooks; + + public boolean isGetAIMoveSpeedModded; + + private static final Map<String, String[]> allBaseBeforeGetAIMoveSpeedSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeGetAIMoveSpeedInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideGetAIMoveSpeedSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideGetAIMoveSpeedInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterGetAIMoveSpeedSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterGetAIMoveSpeedInferiors = new Hashtable<String, String[]>(0); + + public static float getCurrentPlayerStrVsBlock(IServerPlayerAPI target, net.minecraft.block.Block paramBlock, boolean paramBoolean) + { + float _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isGetCurrentPlayerStrVsBlockModded) + _result = serverPlayerAPI.getCurrentPlayerStrVsBlock(paramBlock, paramBoolean); + else + _result = target.localGetCurrentPlayerStrVsBlock(paramBlock, paramBoolean); + return _result; + } + + private float getCurrentPlayerStrVsBlock(net.minecraft.block.Block paramBlock, boolean paramBoolean) + { + if(beforeGetCurrentPlayerStrVsBlockHooks != null) + for(int i = beforeGetCurrentPlayerStrVsBlockHooks.length - 1; i >= 0 ; i--) + beforeGetCurrentPlayerStrVsBlockHooks[i].beforeGetCurrentPlayerStrVsBlock(paramBlock, paramBoolean); + + float _result; + if(overrideGetCurrentPlayerStrVsBlockHooks != null) + _result = overrideGetCurrentPlayerStrVsBlockHooks[overrideGetCurrentPlayerStrVsBlockHooks.length - 1].getCurrentPlayerStrVsBlock(paramBlock, paramBoolean); + else + _result = player.localGetCurrentPlayerStrVsBlock(paramBlock, paramBoolean); + + if(afterGetCurrentPlayerStrVsBlockHooks != null) + for(int i = 0; i < afterGetCurrentPlayerStrVsBlockHooks.length; i++) + afterGetCurrentPlayerStrVsBlockHooks[i].afterGetCurrentPlayerStrVsBlock(paramBlock, paramBoolean); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenGetCurrentPlayerStrVsBlock(ServerPlayerBase overWriter) + { + if (overrideGetCurrentPlayerStrVsBlockHooks == null) + return overWriter; + + for(int i = 0; i < overrideGetCurrentPlayerStrVsBlockHooks.length; i++) + if(overrideGetCurrentPlayerStrVsBlockHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideGetCurrentPlayerStrVsBlockHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeGetCurrentPlayerStrVsBlockHookTypes = new LinkedList<String>(); + private final static List<String> overrideGetCurrentPlayerStrVsBlockHookTypes = new LinkedList<String>(); + private final static List<String> afterGetCurrentPlayerStrVsBlockHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeGetCurrentPlayerStrVsBlockHooks; + private ServerPlayerBase[] overrideGetCurrentPlayerStrVsBlockHooks; + private ServerPlayerBase[] afterGetCurrentPlayerStrVsBlockHooks; + + public boolean isGetCurrentPlayerStrVsBlockModded; + + private static final Map<String, String[]> allBaseBeforeGetCurrentPlayerStrVsBlockSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeGetCurrentPlayerStrVsBlockInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideGetCurrentPlayerStrVsBlockSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideGetCurrentPlayerStrVsBlockInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterGetCurrentPlayerStrVsBlockSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterGetCurrentPlayerStrVsBlockInferiors = new Hashtable<String, String[]>(0); + + public static float getCurrentPlayerStrVsBlockForge(IServerPlayerAPI target, net.minecraft.block.Block paramBlock, boolean paramBoolean, int paramInt) + { + float _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isGetCurrentPlayerStrVsBlockForgeModded) + _result = serverPlayerAPI.getCurrentPlayerStrVsBlockForge(paramBlock, paramBoolean, paramInt); + else + _result = target.localGetCurrentPlayerStrVsBlockForge(paramBlock, paramBoolean, paramInt); + return _result; + } + + private float getCurrentPlayerStrVsBlockForge(net.minecraft.block.Block paramBlock, boolean paramBoolean, int paramInt) + { + if(beforeGetCurrentPlayerStrVsBlockForgeHooks != null) + for(int i = beforeGetCurrentPlayerStrVsBlockForgeHooks.length - 1; i >= 0 ; i--) + beforeGetCurrentPlayerStrVsBlockForgeHooks[i].beforeGetCurrentPlayerStrVsBlockForge(paramBlock, paramBoolean, paramInt); + + float _result; + if(overrideGetCurrentPlayerStrVsBlockForgeHooks != null) + _result = overrideGetCurrentPlayerStrVsBlockForgeHooks[overrideGetCurrentPlayerStrVsBlockForgeHooks.length - 1].getCurrentPlayerStrVsBlockForge(paramBlock, paramBoolean, paramInt); + else + _result = player.localGetCurrentPlayerStrVsBlockForge(paramBlock, paramBoolean, paramInt); + + if(afterGetCurrentPlayerStrVsBlockForgeHooks != null) + for(int i = 0; i < afterGetCurrentPlayerStrVsBlockForgeHooks.length; i++) + afterGetCurrentPlayerStrVsBlockForgeHooks[i].afterGetCurrentPlayerStrVsBlockForge(paramBlock, paramBoolean, paramInt); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenGetCurrentPlayerStrVsBlockForge(ServerPlayerBase overWriter) + { + if (overrideGetCurrentPlayerStrVsBlockForgeHooks == null) + return overWriter; + + for(int i = 0; i < overrideGetCurrentPlayerStrVsBlockForgeHooks.length; i++) + if(overrideGetCurrentPlayerStrVsBlockForgeHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideGetCurrentPlayerStrVsBlockForgeHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeGetCurrentPlayerStrVsBlockForgeHookTypes = new LinkedList<String>(); + private final static List<String> overrideGetCurrentPlayerStrVsBlockForgeHookTypes = new LinkedList<String>(); + private final static List<String> afterGetCurrentPlayerStrVsBlockForgeHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeGetCurrentPlayerStrVsBlockForgeHooks; + private ServerPlayerBase[] overrideGetCurrentPlayerStrVsBlockForgeHooks; + private ServerPlayerBase[] afterGetCurrentPlayerStrVsBlockForgeHooks; + + public boolean isGetCurrentPlayerStrVsBlockForgeModded; + + private static final Map<String, String[]> allBaseBeforeGetCurrentPlayerStrVsBlockForgeSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeGetCurrentPlayerStrVsBlockForgeInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideGetCurrentPlayerStrVsBlockForgeSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideGetCurrentPlayerStrVsBlockForgeInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterGetCurrentPlayerStrVsBlockForgeSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterGetCurrentPlayerStrVsBlockForgeInferiors = new Hashtable<String, String[]>(0); + + public static double getDistanceSq(IServerPlayerAPI target, double paramDouble1, double paramDouble2, double paramDouble3) + { + double _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isGetDistanceSqModded) + _result = serverPlayerAPI.getDistanceSq(paramDouble1, paramDouble2, paramDouble3); + else + _result = target.localGetDistanceSq(paramDouble1, paramDouble2, paramDouble3); + return _result; + } + + private double getDistanceSq(double paramDouble1, double paramDouble2, double paramDouble3) + { + if(beforeGetDistanceSqHooks != null) + for(int i = beforeGetDistanceSqHooks.length - 1; i >= 0 ; i--) + beforeGetDistanceSqHooks[i].beforeGetDistanceSq(paramDouble1, paramDouble2, paramDouble3); + + double _result; + if(overrideGetDistanceSqHooks != null) + _result = overrideGetDistanceSqHooks[overrideGetDistanceSqHooks.length - 1].getDistanceSq(paramDouble1, paramDouble2, paramDouble3); + else + _result = player.localGetDistanceSq(paramDouble1, paramDouble2, paramDouble3); + + if(afterGetDistanceSqHooks != null) + for(int i = 0; i < afterGetDistanceSqHooks.length; i++) + afterGetDistanceSqHooks[i].afterGetDistanceSq(paramDouble1, paramDouble2, paramDouble3); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenGetDistanceSq(ServerPlayerBase overWriter) + { + if (overrideGetDistanceSqHooks == null) + return overWriter; + + for(int i = 0; i < overrideGetDistanceSqHooks.length; i++) + if(overrideGetDistanceSqHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideGetDistanceSqHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeGetDistanceSqHookTypes = new LinkedList<String>(); + private final static List<String> overrideGetDistanceSqHookTypes = new LinkedList<String>(); + private final static List<String> afterGetDistanceSqHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeGetDistanceSqHooks; + private ServerPlayerBase[] overrideGetDistanceSqHooks; + private ServerPlayerBase[] afterGetDistanceSqHooks; + + public boolean isGetDistanceSqModded; + + private static final Map<String, String[]> allBaseBeforeGetDistanceSqSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeGetDistanceSqInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideGetDistanceSqSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideGetDistanceSqInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterGetDistanceSqSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterGetDistanceSqInferiors = new Hashtable<String, String[]>(0); + + public static float getBrightness(IServerPlayerAPI target, float paramFloat) + { + float _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isGetBrightnessModded) + _result = serverPlayerAPI.getBrightness(paramFloat); + else + _result = target.localGetBrightness(paramFloat); + return _result; + } + + private float getBrightness(float paramFloat) + { + if(beforeGetBrightnessHooks != null) + for(int i = beforeGetBrightnessHooks.length - 1; i >= 0 ; i--) + beforeGetBrightnessHooks[i].beforeGetBrightness(paramFloat); + + float _result; + if(overrideGetBrightnessHooks != null) + _result = overrideGetBrightnessHooks[overrideGetBrightnessHooks.length - 1].getBrightness(paramFloat); + else + _result = player.localGetBrightness(paramFloat); + + if(afterGetBrightnessHooks != null) + for(int i = 0; i < afterGetBrightnessHooks.length; i++) + afterGetBrightnessHooks[i].afterGetBrightness(paramFloat); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenGetBrightness(ServerPlayerBase overWriter) + { + if (overrideGetBrightnessHooks == null) + return overWriter; + + for(int i = 0; i < overrideGetBrightnessHooks.length; i++) + if(overrideGetBrightnessHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideGetBrightnessHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeGetBrightnessHookTypes = new LinkedList<String>(); + private final static List<String> overrideGetBrightnessHookTypes = new LinkedList<String>(); + private final static List<String> afterGetBrightnessHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeGetBrightnessHooks; + private ServerPlayerBase[] overrideGetBrightnessHooks; + private ServerPlayerBase[] afterGetBrightnessHooks; + + public boolean isGetBrightnessModded; + + private static final Map<String, String[]> allBaseBeforeGetBrightnessSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeGetBrightnessInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideGetBrightnessSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideGetBrightnessInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterGetBrightnessSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterGetBrightnessInferiors = new Hashtable<String, String[]>(0); + + public static float getEyeHeight(IServerPlayerAPI target) + { + float _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isGetEyeHeightModded) + _result = serverPlayerAPI.getEyeHeight(); + else + _result = target.localGetEyeHeight(); + return _result; + } + + private float getEyeHeight() + { + if(beforeGetEyeHeightHooks != null) + for(int i = beforeGetEyeHeightHooks.length - 1; i >= 0 ; i--) + beforeGetEyeHeightHooks[i].beforeGetEyeHeight(); + + float _result; + if(overrideGetEyeHeightHooks != null) + _result = overrideGetEyeHeightHooks[overrideGetEyeHeightHooks.length - 1].getEyeHeight(); + else + _result = player.localGetEyeHeight(); + + if(afterGetEyeHeightHooks != null) + for(int i = 0; i < afterGetEyeHeightHooks.length; i++) + afterGetEyeHeightHooks[i].afterGetEyeHeight(); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenGetEyeHeight(ServerPlayerBase overWriter) + { + if (overrideGetEyeHeightHooks == null) + return overWriter; + + for(int i = 0; i < overrideGetEyeHeightHooks.length; i++) + if(overrideGetEyeHeightHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideGetEyeHeightHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeGetEyeHeightHookTypes = new LinkedList<String>(); + private final static List<String> overrideGetEyeHeightHookTypes = new LinkedList<String>(); + private final static List<String> afterGetEyeHeightHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeGetEyeHeightHooks; + private ServerPlayerBase[] overrideGetEyeHeightHooks; + private ServerPlayerBase[] afterGetEyeHeightHooks; + + public boolean isGetEyeHeightModded; + + private static final Map<String, String[]> allBaseBeforeGetEyeHeightSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeGetEyeHeightInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideGetEyeHeightSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideGetEyeHeightInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterGetEyeHeightSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterGetEyeHeightInferiors = new Hashtable<String, String[]>(0); + + public static void heal(IServerPlayerAPI target, float paramFloat) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isHealModded) + serverPlayerAPI.heal(paramFloat); + else + target.localHeal(paramFloat); + } + + private void heal(float paramFloat) + { + if(beforeHealHooks != null) + for(int i = beforeHealHooks.length - 1; i >= 0 ; i--) + beforeHealHooks[i].beforeHeal(paramFloat); + + if(overrideHealHooks != null) + overrideHealHooks[overrideHealHooks.length - 1].heal(paramFloat); + else + player.localHeal(paramFloat); + + if(afterHealHooks != null) + for(int i = 0; i < afterHealHooks.length; i++) + afterHealHooks[i].afterHeal(paramFloat); + + } + + protected ServerPlayerBase GetOverwrittenHeal(ServerPlayerBase overWriter) + { + if (overrideHealHooks == null) + return overWriter; + + for(int i = 0; i < overrideHealHooks.length; i++) + if(overrideHealHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideHealHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeHealHookTypes = new LinkedList<String>(); + private final static List<String> overrideHealHookTypes = new LinkedList<String>(); + private final static List<String> afterHealHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeHealHooks; + private ServerPlayerBase[] overrideHealHooks; + private ServerPlayerBase[] afterHealHooks; + + public boolean isHealModded; + + private static final Map<String, String[]> allBaseBeforeHealSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeHealInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideHealSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideHealInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterHealSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterHealInferiors = new Hashtable<String, String[]>(0); + + public static boolean isEntityInsideOpaqueBlock(IServerPlayerAPI target) + { + boolean _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isIsEntityInsideOpaqueBlockModded) + _result = serverPlayerAPI.isEntityInsideOpaqueBlock(); + else + _result = target.localIsEntityInsideOpaqueBlock(); + return _result; + } + + private boolean isEntityInsideOpaqueBlock() + { + if(beforeIsEntityInsideOpaqueBlockHooks != null) + for(int i = beforeIsEntityInsideOpaqueBlockHooks.length - 1; i >= 0 ; i--) + beforeIsEntityInsideOpaqueBlockHooks[i].beforeIsEntityInsideOpaqueBlock(); + + boolean _result; + if(overrideIsEntityInsideOpaqueBlockHooks != null) + _result = overrideIsEntityInsideOpaqueBlockHooks[overrideIsEntityInsideOpaqueBlockHooks.length - 1].isEntityInsideOpaqueBlock(); + else + _result = player.localIsEntityInsideOpaqueBlock(); + + if(afterIsEntityInsideOpaqueBlockHooks != null) + for(int i = 0; i < afterIsEntityInsideOpaqueBlockHooks.length; i++) + afterIsEntityInsideOpaqueBlockHooks[i].afterIsEntityInsideOpaqueBlock(); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenIsEntityInsideOpaqueBlock(ServerPlayerBase overWriter) + { + if (overrideIsEntityInsideOpaqueBlockHooks == null) + return overWriter; + + for(int i = 0; i < overrideIsEntityInsideOpaqueBlockHooks.length; i++) + if(overrideIsEntityInsideOpaqueBlockHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideIsEntityInsideOpaqueBlockHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeIsEntityInsideOpaqueBlockHookTypes = new LinkedList<String>(); + private final static List<String> overrideIsEntityInsideOpaqueBlockHookTypes = new LinkedList<String>(); + private final static List<String> afterIsEntityInsideOpaqueBlockHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeIsEntityInsideOpaqueBlockHooks; + private ServerPlayerBase[] overrideIsEntityInsideOpaqueBlockHooks; + private ServerPlayerBase[] afterIsEntityInsideOpaqueBlockHooks; + + public boolean isIsEntityInsideOpaqueBlockModded; + + private static final Map<String, String[]> allBaseBeforeIsEntityInsideOpaqueBlockSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeIsEntityInsideOpaqueBlockInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideIsEntityInsideOpaqueBlockSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideIsEntityInsideOpaqueBlockInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterIsEntityInsideOpaqueBlockSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterIsEntityInsideOpaqueBlockInferiors = new Hashtable<String, String[]>(0); + + public static boolean isInWater(IServerPlayerAPI target) + { + boolean _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isIsInWaterModded) + _result = serverPlayerAPI.isInWater(); + else + _result = target.localIsInWater(); + return _result; + } + + private boolean isInWater() + { + if(beforeIsInWaterHooks != null) + for(int i = beforeIsInWaterHooks.length - 1; i >= 0 ; i--) + beforeIsInWaterHooks[i].beforeIsInWater(); + + boolean _result; + if(overrideIsInWaterHooks != null) + _result = overrideIsInWaterHooks[overrideIsInWaterHooks.length - 1].isInWater(); + else + _result = player.localIsInWater(); + + if(afterIsInWaterHooks != null) + for(int i = 0; i < afterIsInWaterHooks.length; i++) + afterIsInWaterHooks[i].afterIsInWater(); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenIsInWater(ServerPlayerBase overWriter) + { + if (overrideIsInWaterHooks == null) + return overWriter; + + for(int i = 0; i < overrideIsInWaterHooks.length; i++) + if(overrideIsInWaterHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideIsInWaterHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeIsInWaterHookTypes = new LinkedList<String>(); + private final static List<String> overrideIsInWaterHookTypes = new LinkedList<String>(); + private final static List<String> afterIsInWaterHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeIsInWaterHooks; + private ServerPlayerBase[] overrideIsInWaterHooks; + private ServerPlayerBase[] afterIsInWaterHooks; + + public boolean isIsInWaterModded; + + private static final Map<String, String[]> allBaseBeforeIsInWaterSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeIsInWaterInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideIsInWaterSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideIsInWaterInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterIsInWaterSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterIsInWaterInferiors = new Hashtable<String, String[]>(0); + + public static boolean isInsideOfMaterial(IServerPlayerAPI target, net.minecraft.block.material.Material paramMaterial) + { + boolean _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isIsInsideOfMaterialModded) + _result = serverPlayerAPI.isInsideOfMaterial(paramMaterial); + else + _result = target.localIsInsideOfMaterial(paramMaterial); + return _result; + } + + private boolean isInsideOfMaterial(net.minecraft.block.material.Material paramMaterial) + { + if(beforeIsInsideOfMaterialHooks != null) + for(int i = beforeIsInsideOfMaterialHooks.length - 1; i >= 0 ; i--) + beforeIsInsideOfMaterialHooks[i].beforeIsInsideOfMaterial(paramMaterial); + + boolean _result; + if(overrideIsInsideOfMaterialHooks != null) + _result = overrideIsInsideOfMaterialHooks[overrideIsInsideOfMaterialHooks.length - 1].isInsideOfMaterial(paramMaterial); + else + _result = player.localIsInsideOfMaterial(paramMaterial); + + if(afterIsInsideOfMaterialHooks != null) + for(int i = 0; i < afterIsInsideOfMaterialHooks.length; i++) + afterIsInsideOfMaterialHooks[i].afterIsInsideOfMaterial(paramMaterial); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenIsInsideOfMaterial(ServerPlayerBase overWriter) + { + if (overrideIsInsideOfMaterialHooks == null) + return overWriter; + + for(int i = 0; i < overrideIsInsideOfMaterialHooks.length; i++) + if(overrideIsInsideOfMaterialHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideIsInsideOfMaterialHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeIsInsideOfMaterialHookTypes = new LinkedList<String>(); + private final static List<String> overrideIsInsideOfMaterialHookTypes = new LinkedList<String>(); + private final static List<String> afterIsInsideOfMaterialHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeIsInsideOfMaterialHooks; + private ServerPlayerBase[] overrideIsInsideOfMaterialHooks; + private ServerPlayerBase[] afterIsInsideOfMaterialHooks; + + public boolean isIsInsideOfMaterialModded; + + private static final Map<String, String[]> allBaseBeforeIsInsideOfMaterialSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeIsInsideOfMaterialInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideIsInsideOfMaterialSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideIsInsideOfMaterialInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterIsInsideOfMaterialSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterIsInsideOfMaterialInferiors = new Hashtable<String, String[]>(0); + + public static boolean isOnLadder(IServerPlayerAPI target) + { + boolean _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isIsOnLadderModded) + _result = serverPlayerAPI.isOnLadder(); + else + _result = target.localIsOnLadder(); + return _result; + } + + private boolean isOnLadder() + { + if(beforeIsOnLadderHooks != null) + for(int i = beforeIsOnLadderHooks.length - 1; i >= 0 ; i--) + beforeIsOnLadderHooks[i].beforeIsOnLadder(); + + boolean _result; + if(overrideIsOnLadderHooks != null) + _result = overrideIsOnLadderHooks[overrideIsOnLadderHooks.length - 1].isOnLadder(); + else + _result = player.localIsOnLadder(); + + if(afterIsOnLadderHooks != null) + for(int i = 0; i < afterIsOnLadderHooks.length; i++) + afterIsOnLadderHooks[i].afterIsOnLadder(); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenIsOnLadder(ServerPlayerBase overWriter) + { + if (overrideIsOnLadderHooks == null) + return overWriter; + + for(int i = 0; i < overrideIsOnLadderHooks.length; i++) + if(overrideIsOnLadderHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideIsOnLadderHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeIsOnLadderHookTypes = new LinkedList<String>(); + private final static List<String> overrideIsOnLadderHookTypes = new LinkedList<String>(); + private final static List<String> afterIsOnLadderHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeIsOnLadderHooks; + private ServerPlayerBase[] overrideIsOnLadderHooks; + private ServerPlayerBase[] afterIsOnLadderHooks; + + public boolean isIsOnLadderModded; + + private static final Map<String, String[]> allBaseBeforeIsOnLadderSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeIsOnLadderInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideIsOnLadderSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideIsOnLadderInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterIsOnLadderSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterIsOnLadderInferiors = new Hashtable<String, String[]>(0); + + public static boolean isPlayerSleeping(IServerPlayerAPI target) + { + boolean _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isIsPlayerSleepingModded) + _result = serverPlayerAPI.isPlayerSleeping(); + else + _result = target.localIsPlayerSleeping(); + return _result; + } + + private boolean isPlayerSleeping() + { + if(beforeIsPlayerSleepingHooks != null) + for(int i = beforeIsPlayerSleepingHooks.length - 1; i >= 0 ; i--) + beforeIsPlayerSleepingHooks[i].beforeIsPlayerSleeping(); + + boolean _result; + if(overrideIsPlayerSleepingHooks != null) + _result = overrideIsPlayerSleepingHooks[overrideIsPlayerSleepingHooks.length - 1].isPlayerSleeping(); + else + _result = player.localIsPlayerSleeping(); + + if(afterIsPlayerSleepingHooks != null) + for(int i = 0; i < afterIsPlayerSleepingHooks.length; i++) + afterIsPlayerSleepingHooks[i].afterIsPlayerSleeping(); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenIsPlayerSleeping(ServerPlayerBase overWriter) + { + if (overrideIsPlayerSleepingHooks == null) + return overWriter; + + for(int i = 0; i < overrideIsPlayerSleepingHooks.length; i++) + if(overrideIsPlayerSleepingHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideIsPlayerSleepingHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeIsPlayerSleepingHookTypes = new LinkedList<String>(); + private final static List<String> overrideIsPlayerSleepingHookTypes = new LinkedList<String>(); + private final static List<String> afterIsPlayerSleepingHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeIsPlayerSleepingHooks; + private ServerPlayerBase[] overrideIsPlayerSleepingHooks; + private ServerPlayerBase[] afterIsPlayerSleepingHooks; + + public boolean isIsPlayerSleepingModded; + + private static final Map<String, String[]> allBaseBeforeIsPlayerSleepingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeIsPlayerSleepingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideIsPlayerSleepingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideIsPlayerSleepingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterIsPlayerSleepingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterIsPlayerSleepingInferiors = new Hashtable<String, String[]>(0); + + public static boolean isSneaking(IServerPlayerAPI target) + { + boolean _result; + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isIsSneakingModded) + _result = serverPlayerAPI.isSneaking(); + else + _result = target.localIsSneaking(); + return _result; + } + + private boolean isSneaking() + { + if(beforeIsSneakingHooks != null) + for(int i = beforeIsSneakingHooks.length - 1; i >= 0 ; i--) + beforeIsSneakingHooks[i].beforeIsSneaking(); + + boolean _result; + if(overrideIsSneakingHooks != null) + _result = overrideIsSneakingHooks[overrideIsSneakingHooks.length - 1].isSneaking(); + else + _result = player.localIsSneaking(); + + if(afterIsSneakingHooks != null) + for(int i = 0; i < afterIsSneakingHooks.length; i++) + afterIsSneakingHooks[i].afterIsSneaking(); + + return _result; + } + + protected ServerPlayerBase GetOverwrittenIsSneaking(ServerPlayerBase overWriter) + { + if (overrideIsSneakingHooks == null) + return overWriter; + + for(int i = 0; i < overrideIsSneakingHooks.length; i++) + if(overrideIsSneakingHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideIsSneakingHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeIsSneakingHookTypes = new LinkedList<String>(); + private final static List<String> overrideIsSneakingHookTypes = new LinkedList<String>(); + private final static List<String> afterIsSneakingHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeIsSneakingHooks; + private ServerPlayerBase[] overrideIsSneakingHooks; + private ServerPlayerBase[] afterIsSneakingHooks; + + public boolean isIsSneakingModded; + + private static final Map<String, String[]> allBaseBeforeIsSneakingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeIsSneakingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideIsSneakingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideIsSneakingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterIsSneakingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterIsSneakingInferiors = new Hashtable<String, String[]>(0); + + public static void jump(IServerPlayerAPI target) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isJumpModded) + serverPlayerAPI.jump(); + else + target.localJump(); + } + + private void jump() + { + if(beforeJumpHooks != null) + for(int i = beforeJumpHooks.length - 1; i >= 0 ; i--) + beforeJumpHooks[i].beforeJump(); + + if(overrideJumpHooks != null) + overrideJumpHooks[overrideJumpHooks.length - 1].jump(); + else + player.localJump(); + + if(afterJumpHooks != null) + for(int i = 0; i < afterJumpHooks.length; i++) + afterJumpHooks[i].afterJump(); + + } + + protected ServerPlayerBase GetOverwrittenJump(ServerPlayerBase overWriter) + { + if (overrideJumpHooks == null) + return overWriter; + + for(int i = 0; i < overrideJumpHooks.length; i++) + if(overrideJumpHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideJumpHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeJumpHookTypes = new LinkedList<String>(); + private final static List<String> overrideJumpHookTypes = new LinkedList<String>(); + private final static List<String> afterJumpHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeJumpHooks; + private ServerPlayerBase[] overrideJumpHooks; + private ServerPlayerBase[] afterJumpHooks; + + public boolean isJumpModded; + + private static final Map<String, String[]> allBaseBeforeJumpSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeJumpInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideJumpSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideJumpInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterJumpSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterJumpInferiors = new Hashtable<String, String[]>(0); + + public static void knockBack(IServerPlayerAPI target, net.minecraft.entity.Entity paramEntity, float paramFloat, double paramDouble1, double paramDouble2) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isKnockBackModded) + serverPlayerAPI.knockBack(paramEntity, paramFloat, paramDouble1, paramDouble2); + else + target.localKnockBack(paramEntity, paramFloat, paramDouble1, paramDouble2); + } + + private void knockBack(net.minecraft.entity.Entity paramEntity, float paramFloat, double paramDouble1, double paramDouble2) + { + if(beforeKnockBackHooks != null) + for(int i = beforeKnockBackHooks.length - 1; i >= 0 ; i--) + beforeKnockBackHooks[i].beforeKnockBack(paramEntity, paramFloat, paramDouble1, paramDouble2); + + if(overrideKnockBackHooks != null) + overrideKnockBackHooks[overrideKnockBackHooks.length - 1].knockBack(paramEntity, paramFloat, paramDouble1, paramDouble2); + else + player.localKnockBack(paramEntity, paramFloat, paramDouble1, paramDouble2); + + if(afterKnockBackHooks != null) + for(int i = 0; i < afterKnockBackHooks.length; i++) + afterKnockBackHooks[i].afterKnockBack(paramEntity, paramFloat, paramDouble1, paramDouble2); + + } + + protected ServerPlayerBase GetOverwrittenKnockBack(ServerPlayerBase overWriter) + { + if (overrideKnockBackHooks == null) + return overWriter; + + for(int i = 0; i < overrideKnockBackHooks.length; i++) + if(overrideKnockBackHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideKnockBackHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeKnockBackHookTypes = new LinkedList<String>(); + private final static List<String> overrideKnockBackHookTypes = new LinkedList<String>(); + private final static List<String> afterKnockBackHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeKnockBackHooks; + private ServerPlayerBase[] overrideKnockBackHooks; + private ServerPlayerBase[] afterKnockBackHooks; + + public boolean isKnockBackModded; + + private static final Map<String, String[]> allBaseBeforeKnockBackSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeKnockBackInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideKnockBackSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideKnockBackInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterKnockBackSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterKnockBackInferiors = new Hashtable<String, String[]>(0); + + public static void mountEntity(IServerPlayerAPI target, net.minecraft.entity.Entity paramEntity) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isMountEntityModded) + serverPlayerAPI.mountEntity(paramEntity); + else + target.localMountEntity(paramEntity); + } + + private void mountEntity(net.minecraft.entity.Entity paramEntity) + { + if(beforeMountEntityHooks != null) + for(int i = beforeMountEntityHooks.length - 1; i >= 0 ; i--) + beforeMountEntityHooks[i].beforeMountEntity(paramEntity); + + if(overrideMountEntityHooks != null) + overrideMountEntityHooks[overrideMountEntityHooks.length - 1].mountEntity(paramEntity); + else + player.localMountEntity(paramEntity); + + if(afterMountEntityHooks != null) + for(int i = 0; i < afterMountEntityHooks.length; i++) + afterMountEntityHooks[i].afterMountEntity(paramEntity); + + } + + protected ServerPlayerBase GetOverwrittenMountEntity(ServerPlayerBase overWriter) + { + if (overrideMountEntityHooks == null) + return overWriter; + + for(int i = 0; i < overrideMountEntityHooks.length; i++) + if(overrideMountEntityHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideMountEntityHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeMountEntityHookTypes = new LinkedList<String>(); + private final static List<String> overrideMountEntityHookTypes = new LinkedList<String>(); + private final static List<String> afterMountEntityHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeMountEntityHooks; + private ServerPlayerBase[] overrideMountEntityHooks; + private ServerPlayerBase[] afterMountEntityHooks; + + public boolean isMountEntityModded; + + private static final Map<String, String[]> allBaseBeforeMountEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeMountEntityInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideMountEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideMountEntityInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterMountEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterMountEntityInferiors = new Hashtable<String, String[]>(0); + + public static void moveEntity(IServerPlayerAPI target, double paramDouble1, double paramDouble2, double paramDouble3) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isMoveEntityModded) + serverPlayerAPI.moveEntity(paramDouble1, paramDouble2, paramDouble3); + else + target.localMoveEntity(paramDouble1, paramDouble2, paramDouble3); + } + + private void moveEntity(double paramDouble1, double paramDouble2, double paramDouble3) + { + if(beforeMoveEntityHooks != null) + for(int i = beforeMoveEntityHooks.length - 1; i >= 0 ; i--) + beforeMoveEntityHooks[i].beforeMoveEntity(paramDouble1, paramDouble2, paramDouble3); + + if(overrideMoveEntityHooks != null) + overrideMoveEntityHooks[overrideMoveEntityHooks.length - 1].moveEntity(paramDouble1, paramDouble2, paramDouble3); + else + player.localMoveEntity(paramDouble1, paramDouble2, paramDouble3); + + if(afterMoveEntityHooks != null) + for(int i = 0; i < afterMoveEntityHooks.length; i++) + afterMoveEntityHooks[i].afterMoveEntity(paramDouble1, paramDouble2, paramDouble3); + + } + + protected ServerPlayerBase GetOverwrittenMoveEntity(ServerPlayerBase overWriter) + { + if (overrideMoveEntityHooks == null) + return overWriter; + + for(int i = 0; i < overrideMoveEntityHooks.length; i++) + if(overrideMoveEntityHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideMoveEntityHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeMoveEntityHookTypes = new LinkedList<String>(); + private final static List<String> overrideMoveEntityHookTypes = new LinkedList<String>(); + private final static List<String> afterMoveEntityHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeMoveEntityHooks; + private ServerPlayerBase[] overrideMoveEntityHooks; + private ServerPlayerBase[] afterMoveEntityHooks; + + public boolean isMoveEntityModded; + + private static final Map<String, String[]> allBaseBeforeMoveEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeMoveEntityInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideMoveEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideMoveEntityInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterMoveEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterMoveEntityInferiors = new Hashtable<String, String[]>(0); + + public static void moveEntityWithHeading(IServerPlayerAPI target, float paramFloat1, float paramFloat2) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isMoveEntityWithHeadingModded) + serverPlayerAPI.moveEntityWithHeading(paramFloat1, paramFloat2); + else + target.localMoveEntityWithHeading(paramFloat1, paramFloat2); + } + + private void moveEntityWithHeading(float paramFloat1, float paramFloat2) + { + if(beforeMoveEntityWithHeadingHooks != null) + for(int i = beforeMoveEntityWithHeadingHooks.length - 1; i >= 0 ; i--) + beforeMoveEntityWithHeadingHooks[i].beforeMoveEntityWithHeading(paramFloat1, paramFloat2); + + if(overrideMoveEntityWithHeadingHooks != null) + overrideMoveEntityWithHeadingHooks[overrideMoveEntityWithHeadingHooks.length - 1].moveEntityWithHeading(paramFloat1, paramFloat2); + else + player.localMoveEntityWithHeading(paramFloat1, paramFloat2); + + if(afterMoveEntityWithHeadingHooks != null) + for(int i = 0; i < afterMoveEntityWithHeadingHooks.length; i++) + afterMoveEntityWithHeadingHooks[i].afterMoveEntityWithHeading(paramFloat1, paramFloat2); + + } + + protected ServerPlayerBase GetOverwrittenMoveEntityWithHeading(ServerPlayerBase overWriter) + { + if (overrideMoveEntityWithHeadingHooks == null) + return overWriter; + + for(int i = 0; i < overrideMoveEntityWithHeadingHooks.length; i++) + if(overrideMoveEntityWithHeadingHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideMoveEntityWithHeadingHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeMoveEntityWithHeadingHookTypes = new LinkedList<String>(); + private final static List<String> overrideMoveEntityWithHeadingHookTypes = new LinkedList<String>(); + private final static List<String> afterMoveEntityWithHeadingHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeMoveEntityWithHeadingHooks; + private ServerPlayerBase[] overrideMoveEntityWithHeadingHooks; + private ServerPlayerBase[] afterMoveEntityWithHeadingHooks; + + public boolean isMoveEntityWithHeadingModded; + + private static final Map<String, String[]> allBaseBeforeMoveEntityWithHeadingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeMoveEntityWithHeadingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideMoveEntityWithHeadingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideMoveEntityWithHeadingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterMoveEntityWithHeadingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterMoveEntityWithHeadingInferiors = new Hashtable<String, String[]>(0); + + public static void moveFlying(IServerPlayerAPI target, float paramFloat1, float paramFloat2, float paramFloat3) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isMoveFlyingModded) + serverPlayerAPI.moveFlying(paramFloat1, paramFloat2, paramFloat3); + else + target.localMoveFlying(paramFloat1, paramFloat2, paramFloat3); + } + + private void moveFlying(float paramFloat1, float paramFloat2, float paramFloat3) + { + if(beforeMoveFlyingHooks != null) + for(int i = beforeMoveFlyingHooks.length - 1; i >= 0 ; i--) + beforeMoveFlyingHooks[i].beforeMoveFlying(paramFloat1, paramFloat2, paramFloat3); + + if(overrideMoveFlyingHooks != null) + overrideMoveFlyingHooks[overrideMoveFlyingHooks.length - 1].moveFlying(paramFloat1, paramFloat2, paramFloat3); + else + player.localMoveFlying(paramFloat1, paramFloat2, paramFloat3); + + if(afterMoveFlyingHooks != null) + for(int i = 0; i < afterMoveFlyingHooks.length; i++) + afterMoveFlyingHooks[i].afterMoveFlying(paramFloat1, paramFloat2, paramFloat3); + + } + + protected ServerPlayerBase GetOverwrittenMoveFlying(ServerPlayerBase overWriter) + { + if (overrideMoveFlyingHooks == null) + return overWriter; + + for(int i = 0; i < overrideMoveFlyingHooks.length; i++) + if(overrideMoveFlyingHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideMoveFlyingHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeMoveFlyingHookTypes = new LinkedList<String>(); + private final static List<String> overrideMoveFlyingHookTypes = new LinkedList<String>(); + private final static List<String> afterMoveFlyingHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeMoveFlyingHooks; + private ServerPlayerBase[] overrideMoveFlyingHooks; + private ServerPlayerBase[] afterMoveFlyingHooks; + + public boolean isMoveFlyingModded; + + private static final Map<String, String[]> allBaseBeforeMoveFlyingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeMoveFlyingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideMoveFlyingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideMoveFlyingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterMoveFlyingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterMoveFlyingInferiors = new Hashtable<String, String[]>(0); + + public static void onDeath(IServerPlayerAPI target, net.minecraft.util.DamageSource paramDamageSource) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isOnDeathModded) + serverPlayerAPI.onDeath(paramDamageSource); + else + target.localOnDeath(paramDamageSource); + } + + private void onDeath(net.minecraft.util.DamageSource paramDamageSource) + { + if(beforeOnDeathHooks != null) + for(int i = beforeOnDeathHooks.length - 1; i >= 0 ; i--) + beforeOnDeathHooks[i].beforeOnDeath(paramDamageSource); + + if(overrideOnDeathHooks != null) + overrideOnDeathHooks[overrideOnDeathHooks.length - 1].onDeath(paramDamageSource); + else + player.localOnDeath(paramDamageSource); + + if(afterOnDeathHooks != null) + for(int i = 0; i < afterOnDeathHooks.length; i++) + afterOnDeathHooks[i].afterOnDeath(paramDamageSource); + + } + + protected ServerPlayerBase GetOverwrittenOnDeath(ServerPlayerBase overWriter) + { + if (overrideOnDeathHooks == null) + return overWriter; + + for(int i = 0; i < overrideOnDeathHooks.length; i++) + if(overrideOnDeathHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideOnDeathHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeOnDeathHookTypes = new LinkedList<String>(); + private final static List<String> overrideOnDeathHookTypes = new LinkedList<String>(); + private final static List<String> afterOnDeathHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeOnDeathHooks; + private ServerPlayerBase[] overrideOnDeathHooks; + private ServerPlayerBase[] afterOnDeathHooks; + + public boolean isOnDeathModded; + + private static final Map<String, String[]> allBaseBeforeOnDeathSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeOnDeathInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideOnDeathSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideOnDeathInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterOnDeathSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterOnDeathInferiors = new Hashtable<String, String[]>(0); + + public static void onLivingUpdate(IServerPlayerAPI target) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isOnLivingUpdateModded) + serverPlayerAPI.onLivingUpdate(); + else + target.localOnLivingUpdate(); + } + + private void onLivingUpdate() + { + if(beforeOnLivingUpdateHooks != null) + for(int i = beforeOnLivingUpdateHooks.length - 1; i >= 0 ; i--) + beforeOnLivingUpdateHooks[i].beforeOnLivingUpdate(); + + if(overrideOnLivingUpdateHooks != null) + overrideOnLivingUpdateHooks[overrideOnLivingUpdateHooks.length - 1].onLivingUpdate(); + else + player.localOnLivingUpdate(); + + if(afterOnLivingUpdateHooks != null) + for(int i = 0; i < afterOnLivingUpdateHooks.length; i++) + afterOnLivingUpdateHooks[i].afterOnLivingUpdate(); + + } + + protected ServerPlayerBase GetOverwrittenOnLivingUpdate(ServerPlayerBase overWriter) + { + if (overrideOnLivingUpdateHooks == null) + return overWriter; + + for(int i = 0; i < overrideOnLivingUpdateHooks.length; i++) + if(overrideOnLivingUpdateHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideOnLivingUpdateHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeOnLivingUpdateHookTypes = new LinkedList<String>(); + private final static List<String> overrideOnLivingUpdateHookTypes = new LinkedList<String>(); + private final static List<String> afterOnLivingUpdateHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeOnLivingUpdateHooks; + private ServerPlayerBase[] overrideOnLivingUpdateHooks; + private ServerPlayerBase[] afterOnLivingUpdateHooks; + + public boolean isOnLivingUpdateModded; + + private static final Map<String, String[]> allBaseBeforeOnLivingUpdateSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeOnLivingUpdateInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideOnLivingUpdateSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideOnLivingUpdateInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterOnLivingUpdateSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterOnLivingUpdateInferiors = new Hashtable<String, String[]>(0); + + public static void onKillEntity(IServerPlayerAPI target, net.minecraft.entity.EntityLivingBase paramEntityLivingBase) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isOnKillEntityModded) + serverPlayerAPI.onKillEntity(paramEntityLivingBase); + else + target.localOnKillEntity(paramEntityLivingBase); + } + + private void onKillEntity(net.minecraft.entity.EntityLivingBase paramEntityLivingBase) + { + if(beforeOnKillEntityHooks != null) + for(int i = beforeOnKillEntityHooks.length - 1; i >= 0 ; i--) + beforeOnKillEntityHooks[i].beforeOnKillEntity(paramEntityLivingBase); + + if(overrideOnKillEntityHooks != null) + overrideOnKillEntityHooks[overrideOnKillEntityHooks.length - 1].onKillEntity(paramEntityLivingBase); + else + player.localOnKillEntity(paramEntityLivingBase); + + if(afterOnKillEntityHooks != null) + for(int i = 0; i < afterOnKillEntityHooks.length; i++) + afterOnKillEntityHooks[i].afterOnKillEntity(paramEntityLivingBase); + + } + + protected ServerPlayerBase GetOverwrittenOnKillEntity(ServerPlayerBase overWriter) + { + if (overrideOnKillEntityHooks == null) + return overWriter; + + for(int i = 0; i < overrideOnKillEntityHooks.length; i++) + if(overrideOnKillEntityHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideOnKillEntityHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeOnKillEntityHookTypes = new LinkedList<String>(); + private final static List<String> overrideOnKillEntityHookTypes = new LinkedList<String>(); + private final static List<String> afterOnKillEntityHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeOnKillEntityHooks; + private ServerPlayerBase[] overrideOnKillEntityHooks; + private ServerPlayerBase[] afterOnKillEntityHooks; + + public boolean isOnKillEntityModded; + + private static final Map<String, String[]> allBaseBeforeOnKillEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeOnKillEntityInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideOnKillEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideOnKillEntityInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterOnKillEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterOnKillEntityInferiors = new Hashtable<String, String[]>(0); + + public static void onStruckByLightning(IServerPlayerAPI target, net.minecraft.entity.effect.EntityLightningBolt paramEntityLightningBolt) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isOnStruckByLightningModded) + serverPlayerAPI.onStruckByLightning(paramEntityLightningBolt); + else + target.localOnStruckByLightning(paramEntityLightningBolt); + } + + private void onStruckByLightning(net.minecraft.entity.effect.EntityLightningBolt paramEntityLightningBolt) + { + if(beforeOnStruckByLightningHooks != null) + for(int i = beforeOnStruckByLightningHooks.length - 1; i >= 0 ; i--) + beforeOnStruckByLightningHooks[i].beforeOnStruckByLightning(paramEntityLightningBolt); + + if(overrideOnStruckByLightningHooks != null) + overrideOnStruckByLightningHooks[overrideOnStruckByLightningHooks.length - 1].onStruckByLightning(paramEntityLightningBolt); + else + player.localOnStruckByLightning(paramEntityLightningBolt); + + if(afterOnStruckByLightningHooks != null) + for(int i = 0; i < afterOnStruckByLightningHooks.length; i++) + afterOnStruckByLightningHooks[i].afterOnStruckByLightning(paramEntityLightningBolt); + + } + + protected ServerPlayerBase GetOverwrittenOnStruckByLightning(ServerPlayerBase overWriter) + { + if (overrideOnStruckByLightningHooks == null) + return overWriter; + + for(int i = 0; i < overrideOnStruckByLightningHooks.length; i++) + if(overrideOnStruckByLightningHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideOnStruckByLightningHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeOnStruckByLightningHookTypes = new LinkedList<String>(); + private final static List<String> overrideOnStruckByLightningHookTypes = new LinkedList<String>(); + private final static List<String> afterOnStruckByLightningHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeOnStruckByLightningHooks; + private ServerPlayerBase[] overrideOnStruckByLightningHooks; + private ServerPlayerBase[] afterOnStruckByLightningHooks; + + public boolean isOnStruckByLightningModded; + + private static final Map<String, String[]> allBaseBeforeOnStruckByLightningSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeOnStruckByLightningInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideOnStruckByLightningSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideOnStruckByLightningInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterOnStruckByLightningSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterOnStruckByLightningInferiors = new Hashtable<String, String[]>(0); + + public static void onUpdate(IServerPlayerAPI target) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isOnUpdateModded) + serverPlayerAPI.onUpdate(); + else + target.localOnUpdate(); + } + + private void onUpdate() + { + if(beforeOnUpdateHooks != null) + for(int i = beforeOnUpdateHooks.length - 1; i >= 0 ; i--) + beforeOnUpdateHooks[i].beforeOnUpdate(); + + if(overrideOnUpdateHooks != null) + overrideOnUpdateHooks[overrideOnUpdateHooks.length - 1].onUpdate(); + else + player.localOnUpdate(); + + if(afterOnUpdateHooks != null) + for(int i = 0; i < afterOnUpdateHooks.length; i++) + afterOnUpdateHooks[i].afterOnUpdate(); + + } + + protected ServerPlayerBase GetOverwrittenOnUpdate(ServerPlayerBase overWriter) + { + if (overrideOnUpdateHooks == null) + return overWriter; + + for(int i = 0; i < overrideOnUpdateHooks.length; i++) + if(overrideOnUpdateHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideOnUpdateHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeOnUpdateHookTypes = new LinkedList<String>(); + private final static List<String> overrideOnUpdateHookTypes = new LinkedList<String>(); + private final static List<String> afterOnUpdateHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeOnUpdateHooks; + private ServerPlayerBase[] overrideOnUpdateHooks; + private ServerPlayerBase[] afterOnUpdateHooks; + + public boolean isOnUpdateModded; + + private static final Map<String, String[]> allBaseBeforeOnUpdateSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeOnUpdateInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideOnUpdateSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideOnUpdateInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterOnUpdateSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterOnUpdateInferiors = new Hashtable<String, String[]>(0); + + public static void onUpdateEntity(IServerPlayerAPI target) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isOnUpdateEntityModded) + serverPlayerAPI.onUpdateEntity(); + else + target.localOnUpdateEntity(); + } + + private void onUpdateEntity() + { + if(beforeOnUpdateEntityHooks != null) + for(int i = beforeOnUpdateEntityHooks.length - 1; i >= 0 ; i--) + beforeOnUpdateEntityHooks[i].beforeOnUpdateEntity(); + + if(overrideOnUpdateEntityHooks != null) + overrideOnUpdateEntityHooks[overrideOnUpdateEntityHooks.length - 1].onUpdateEntity(); + else + player.localOnUpdateEntity(); + + if(afterOnUpdateEntityHooks != null) + for(int i = 0; i < afterOnUpdateEntityHooks.length; i++) + afterOnUpdateEntityHooks[i].afterOnUpdateEntity(); + + } + + protected ServerPlayerBase GetOverwrittenOnUpdateEntity(ServerPlayerBase overWriter) + { + if (overrideOnUpdateEntityHooks == null) + return overWriter; + + for(int i = 0; i < overrideOnUpdateEntityHooks.length; i++) + if(overrideOnUpdateEntityHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideOnUpdateEntityHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeOnUpdateEntityHookTypes = new LinkedList<String>(); + private final static List<String> overrideOnUpdateEntityHookTypes = new LinkedList<String>(); + private final static List<String> afterOnUpdateEntityHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeOnUpdateEntityHooks; + private ServerPlayerBase[] overrideOnUpdateEntityHooks; + private ServerPlayerBase[] afterOnUpdateEntityHooks; + + public boolean isOnUpdateEntityModded; + + private static final Map<String, String[]> allBaseBeforeOnUpdateEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeOnUpdateEntityInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideOnUpdateEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideOnUpdateEntityInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterOnUpdateEntitySuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterOnUpdateEntityInferiors = new Hashtable<String, String[]>(0); + + public static void readEntityFromNBT(IServerPlayerAPI target, net.minecraft.nbt.NBTTagCompound paramNBTTagCompound) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isReadEntityFromNBTModded) + serverPlayerAPI.readEntityFromNBT(paramNBTTagCompound); + else + target.localReadEntityFromNBT(paramNBTTagCompound); + } + + private void readEntityFromNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound) + { + if(beforeReadEntityFromNBTHooks != null) + for(int i = beforeReadEntityFromNBTHooks.length - 1; i >= 0 ; i--) + beforeReadEntityFromNBTHooks[i].beforeReadEntityFromNBT(paramNBTTagCompound); + + if(overrideReadEntityFromNBTHooks != null) + overrideReadEntityFromNBTHooks[overrideReadEntityFromNBTHooks.length - 1].readEntityFromNBT(paramNBTTagCompound); + else + player.localReadEntityFromNBT(paramNBTTagCompound); + + if(afterReadEntityFromNBTHooks != null) + for(int i = 0; i < afterReadEntityFromNBTHooks.length; i++) + afterReadEntityFromNBTHooks[i].afterReadEntityFromNBT(paramNBTTagCompound); + + } + + protected ServerPlayerBase GetOverwrittenReadEntityFromNBT(ServerPlayerBase overWriter) + { + if (overrideReadEntityFromNBTHooks == null) + return overWriter; + + for(int i = 0; i < overrideReadEntityFromNBTHooks.length; i++) + if(overrideReadEntityFromNBTHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideReadEntityFromNBTHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeReadEntityFromNBTHookTypes = new LinkedList<String>(); + private final static List<String> overrideReadEntityFromNBTHookTypes = new LinkedList<String>(); + private final static List<String> afterReadEntityFromNBTHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeReadEntityFromNBTHooks; + private ServerPlayerBase[] overrideReadEntityFromNBTHooks; + private ServerPlayerBase[] afterReadEntityFromNBTHooks; + + public boolean isReadEntityFromNBTModded; + + private static final Map<String, String[]> allBaseBeforeReadEntityFromNBTSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeReadEntityFromNBTInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideReadEntityFromNBTSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideReadEntityFromNBTInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterReadEntityFromNBTSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterReadEntityFromNBTInferiors = new Hashtable<String, String[]>(0); + + public static void setDead(IServerPlayerAPI target) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isSetDeadModded) + serverPlayerAPI.setDead(); + else + target.localSetDead(); + } + + private void setDead() + { + if(beforeSetDeadHooks != null) + for(int i = beforeSetDeadHooks.length - 1; i >= 0 ; i--) + beforeSetDeadHooks[i].beforeSetDead(); + + if(overrideSetDeadHooks != null) + overrideSetDeadHooks[overrideSetDeadHooks.length - 1].setDead(); + else + player.localSetDead(); + + if(afterSetDeadHooks != null) + for(int i = 0; i < afterSetDeadHooks.length; i++) + afterSetDeadHooks[i].afterSetDead(); + + } + + protected ServerPlayerBase GetOverwrittenSetDead(ServerPlayerBase overWriter) + { + if (overrideSetDeadHooks == null) + return overWriter; + + for(int i = 0; i < overrideSetDeadHooks.length; i++) + if(overrideSetDeadHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideSetDeadHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeSetDeadHookTypes = new LinkedList<String>(); + private final static List<String> overrideSetDeadHookTypes = new LinkedList<String>(); + private final static List<String> afterSetDeadHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeSetDeadHooks; + private ServerPlayerBase[] overrideSetDeadHooks; + private ServerPlayerBase[] afterSetDeadHooks; + + public boolean isSetDeadModded; + + private static final Map<String, String[]> allBaseBeforeSetDeadSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeSetDeadInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideSetDeadSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideSetDeadInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterSetDeadSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterSetDeadInferiors = new Hashtable<String, String[]>(0); + + public static void setEntityActionState(IServerPlayerAPI target, float paramFloat1, float paramFloat2, boolean paramBoolean1, boolean paramBoolean2) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isSetEntityActionStateModded) + serverPlayerAPI.setEntityActionState(paramFloat1, paramFloat2, paramBoolean1, paramBoolean2); + else + target.localSetEntityActionState(paramFloat1, paramFloat2, paramBoolean1, paramBoolean2); + } + + private void setEntityActionState(float paramFloat1, float paramFloat2, boolean paramBoolean1, boolean paramBoolean2) + { + if(beforeSetEntityActionStateHooks != null) + for(int i = beforeSetEntityActionStateHooks.length - 1; i >= 0 ; i--) + beforeSetEntityActionStateHooks[i].beforeSetEntityActionState(paramFloat1, paramFloat2, paramBoolean1, paramBoolean2); + + if(overrideSetEntityActionStateHooks != null) + overrideSetEntityActionStateHooks[overrideSetEntityActionStateHooks.length - 1].setEntityActionState(paramFloat1, paramFloat2, paramBoolean1, paramBoolean2); + else + player.localSetEntityActionState(paramFloat1, paramFloat2, paramBoolean1, paramBoolean2); + + if(afterSetEntityActionStateHooks != null) + for(int i = 0; i < afterSetEntityActionStateHooks.length; i++) + afterSetEntityActionStateHooks[i].afterSetEntityActionState(paramFloat1, paramFloat2, paramBoolean1, paramBoolean2); + + } + + protected ServerPlayerBase GetOverwrittenSetEntityActionState(ServerPlayerBase overWriter) + { + if (overrideSetEntityActionStateHooks == null) + return overWriter; + + for(int i = 0; i < overrideSetEntityActionStateHooks.length; i++) + if(overrideSetEntityActionStateHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideSetEntityActionStateHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeSetEntityActionStateHookTypes = new LinkedList<String>(); + private final static List<String> overrideSetEntityActionStateHookTypes = new LinkedList<String>(); + private final static List<String> afterSetEntityActionStateHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeSetEntityActionStateHooks; + private ServerPlayerBase[] overrideSetEntityActionStateHooks; + private ServerPlayerBase[] afterSetEntityActionStateHooks; + + public boolean isSetEntityActionStateModded; + + private static final Map<String, String[]> allBaseBeforeSetEntityActionStateSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeSetEntityActionStateInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideSetEntityActionStateSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideSetEntityActionStateInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterSetEntityActionStateSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterSetEntityActionStateInferiors = new Hashtable<String, String[]>(0); + + public static void setPosition(IServerPlayerAPI target, double paramDouble1, double paramDouble2, double paramDouble3) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isSetPositionModded) + serverPlayerAPI.setPosition(paramDouble1, paramDouble2, paramDouble3); + else + target.localSetPosition(paramDouble1, paramDouble2, paramDouble3); + } + + private void setPosition(double paramDouble1, double paramDouble2, double paramDouble3) + { + if(beforeSetPositionHooks != null) + for(int i = beforeSetPositionHooks.length - 1; i >= 0 ; i--) + beforeSetPositionHooks[i].beforeSetPosition(paramDouble1, paramDouble2, paramDouble3); + + if(overrideSetPositionHooks != null) + overrideSetPositionHooks[overrideSetPositionHooks.length - 1].setPosition(paramDouble1, paramDouble2, paramDouble3); + else + player.localSetPosition(paramDouble1, paramDouble2, paramDouble3); + + if(afterSetPositionHooks != null) + for(int i = 0; i < afterSetPositionHooks.length; i++) + afterSetPositionHooks[i].afterSetPosition(paramDouble1, paramDouble2, paramDouble3); + + } + + protected ServerPlayerBase GetOverwrittenSetPosition(ServerPlayerBase overWriter) + { + if (overrideSetPositionHooks == null) + return overWriter; + + for(int i = 0; i < overrideSetPositionHooks.length; i++) + if(overrideSetPositionHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideSetPositionHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeSetPositionHookTypes = new LinkedList<String>(); + private final static List<String> overrideSetPositionHookTypes = new LinkedList<String>(); + private final static List<String> afterSetPositionHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeSetPositionHooks; + private ServerPlayerBase[] overrideSetPositionHooks; + private ServerPlayerBase[] afterSetPositionHooks; + + public boolean isSetPositionModded; + + private static final Map<String, String[]> allBaseBeforeSetPositionSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeSetPositionInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideSetPositionSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideSetPositionInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterSetPositionSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterSetPositionInferiors = new Hashtable<String, String[]>(0); + + public static void setSneaking(IServerPlayerAPI target, boolean paramBoolean) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isSetSneakingModded) + serverPlayerAPI.setSneaking(paramBoolean); + else + target.localSetSneaking(paramBoolean); + } + + private void setSneaking(boolean paramBoolean) + { + if(beforeSetSneakingHooks != null) + for(int i = beforeSetSneakingHooks.length - 1; i >= 0 ; i--) + beforeSetSneakingHooks[i].beforeSetSneaking(paramBoolean); + + if(overrideSetSneakingHooks != null) + overrideSetSneakingHooks[overrideSetSneakingHooks.length - 1].setSneaking(paramBoolean); + else + player.localSetSneaking(paramBoolean); + + if(afterSetSneakingHooks != null) + for(int i = 0; i < afterSetSneakingHooks.length; i++) + afterSetSneakingHooks[i].afterSetSneaking(paramBoolean); + + } + + protected ServerPlayerBase GetOverwrittenSetSneaking(ServerPlayerBase overWriter) + { + if (overrideSetSneakingHooks == null) + return overWriter; + + for(int i = 0; i < overrideSetSneakingHooks.length; i++) + if(overrideSetSneakingHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideSetSneakingHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeSetSneakingHookTypes = new LinkedList<String>(); + private final static List<String> overrideSetSneakingHookTypes = new LinkedList<String>(); + private final static List<String> afterSetSneakingHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeSetSneakingHooks; + private ServerPlayerBase[] overrideSetSneakingHooks; + private ServerPlayerBase[] afterSetSneakingHooks; + + public boolean isSetSneakingModded; + + private static final Map<String, String[]> allBaseBeforeSetSneakingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeSetSneakingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideSetSneakingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideSetSneakingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterSetSneakingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterSetSneakingInferiors = new Hashtable<String, String[]>(0); + + public static void setSprinting(IServerPlayerAPI target, boolean paramBoolean) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isSetSprintingModded) + serverPlayerAPI.setSprinting(paramBoolean); + else + target.localSetSprinting(paramBoolean); + } + + private void setSprinting(boolean paramBoolean) + { + if(beforeSetSprintingHooks != null) + for(int i = beforeSetSprintingHooks.length - 1; i >= 0 ; i--) + beforeSetSprintingHooks[i].beforeSetSprinting(paramBoolean); + + if(overrideSetSprintingHooks != null) + overrideSetSprintingHooks[overrideSetSprintingHooks.length - 1].setSprinting(paramBoolean); + else + player.localSetSprinting(paramBoolean); + + if(afterSetSprintingHooks != null) + for(int i = 0; i < afterSetSprintingHooks.length; i++) + afterSetSprintingHooks[i].afterSetSprinting(paramBoolean); + + } + + protected ServerPlayerBase GetOverwrittenSetSprinting(ServerPlayerBase overWriter) + { + if (overrideSetSprintingHooks == null) + return overWriter; + + for(int i = 0; i < overrideSetSprintingHooks.length; i++) + if(overrideSetSprintingHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideSetSprintingHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeSetSprintingHookTypes = new LinkedList<String>(); + private final static List<String> overrideSetSprintingHookTypes = new LinkedList<String>(); + private final static List<String> afterSetSprintingHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeSetSprintingHooks; + private ServerPlayerBase[] overrideSetSprintingHooks; + private ServerPlayerBase[] afterSetSprintingHooks; + + public boolean isSetSprintingModded; + + private static final Map<String, String[]> allBaseBeforeSetSprintingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeSetSprintingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideSetSprintingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideSetSprintingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterSetSprintingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterSetSprintingInferiors = new Hashtable<String, String[]>(0); + + public static void swingItem(IServerPlayerAPI target) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isSwingItemModded) + serverPlayerAPI.swingItem(); + else + target.localSwingItem(); + } + + private void swingItem() + { + if(beforeSwingItemHooks != null) + for(int i = beforeSwingItemHooks.length - 1; i >= 0 ; i--) + beforeSwingItemHooks[i].beforeSwingItem(); + + if(overrideSwingItemHooks != null) + overrideSwingItemHooks[overrideSwingItemHooks.length - 1].swingItem(); + else + player.localSwingItem(); + + if(afterSwingItemHooks != null) + for(int i = 0; i < afterSwingItemHooks.length; i++) + afterSwingItemHooks[i].afterSwingItem(); + + } + + protected ServerPlayerBase GetOverwrittenSwingItem(ServerPlayerBase overWriter) + { + if (overrideSwingItemHooks == null) + return overWriter; + + for(int i = 0; i < overrideSwingItemHooks.length; i++) + if(overrideSwingItemHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideSwingItemHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeSwingItemHookTypes = new LinkedList<String>(); + private final static List<String> overrideSwingItemHookTypes = new LinkedList<String>(); + private final static List<String> afterSwingItemHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeSwingItemHooks; + private ServerPlayerBase[] overrideSwingItemHooks; + private ServerPlayerBase[] afterSwingItemHooks; + + public boolean isSwingItemModded; + + private static final Map<String, String[]> allBaseBeforeSwingItemSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeSwingItemInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideSwingItemSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideSwingItemInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterSwingItemSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterSwingItemInferiors = new Hashtable<String, String[]>(0); + + public static void updateEntityActionState(IServerPlayerAPI target) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isUpdateEntityActionStateModded) + serverPlayerAPI.updateEntityActionState(); + else + target.localUpdateEntityActionState(); + } + + private void updateEntityActionState() + { + if(beforeUpdateEntityActionStateHooks != null) + for(int i = beforeUpdateEntityActionStateHooks.length - 1; i >= 0 ; i--) + beforeUpdateEntityActionStateHooks[i].beforeUpdateEntityActionState(); + + if(overrideUpdateEntityActionStateHooks != null) + overrideUpdateEntityActionStateHooks[overrideUpdateEntityActionStateHooks.length - 1].updateEntityActionState(); + else + player.localUpdateEntityActionState(); + + if(afterUpdateEntityActionStateHooks != null) + for(int i = 0; i < afterUpdateEntityActionStateHooks.length; i++) + afterUpdateEntityActionStateHooks[i].afterUpdateEntityActionState(); + + } + + protected ServerPlayerBase GetOverwrittenUpdateEntityActionState(ServerPlayerBase overWriter) + { + if (overrideUpdateEntityActionStateHooks == null) + return overWriter; + + for(int i = 0; i < overrideUpdateEntityActionStateHooks.length; i++) + if(overrideUpdateEntityActionStateHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideUpdateEntityActionStateHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeUpdateEntityActionStateHookTypes = new LinkedList<String>(); + private final static List<String> overrideUpdateEntityActionStateHookTypes = new LinkedList<String>(); + private final static List<String> afterUpdateEntityActionStateHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeUpdateEntityActionStateHooks; + private ServerPlayerBase[] overrideUpdateEntityActionStateHooks; + private ServerPlayerBase[] afterUpdateEntityActionStateHooks; + + public boolean isUpdateEntityActionStateModded; + + private static final Map<String, String[]> allBaseBeforeUpdateEntityActionStateSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeUpdateEntityActionStateInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideUpdateEntityActionStateSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideUpdateEntityActionStateInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterUpdateEntityActionStateSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterUpdateEntityActionStateInferiors = new Hashtable<String, String[]>(0); + + public static void updatePotionEffects(IServerPlayerAPI target) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isUpdatePotionEffectsModded) + serverPlayerAPI.updatePotionEffects(); + else + target.localUpdatePotionEffects(); + } + + private void updatePotionEffects() + { + if(beforeUpdatePotionEffectsHooks != null) + for(int i = beforeUpdatePotionEffectsHooks.length - 1; i >= 0 ; i--) + beforeUpdatePotionEffectsHooks[i].beforeUpdatePotionEffects(); + + if(overrideUpdatePotionEffectsHooks != null) + overrideUpdatePotionEffectsHooks[overrideUpdatePotionEffectsHooks.length - 1].updatePotionEffects(); + else + player.localUpdatePotionEffects(); + + if(afterUpdatePotionEffectsHooks != null) + for(int i = 0; i < afterUpdatePotionEffectsHooks.length; i++) + afterUpdatePotionEffectsHooks[i].afterUpdatePotionEffects(); + + } + + protected ServerPlayerBase GetOverwrittenUpdatePotionEffects(ServerPlayerBase overWriter) + { + if (overrideUpdatePotionEffectsHooks == null) + return overWriter; + + for(int i = 0; i < overrideUpdatePotionEffectsHooks.length; i++) + if(overrideUpdatePotionEffectsHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideUpdatePotionEffectsHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeUpdatePotionEffectsHookTypes = new LinkedList<String>(); + private final static List<String> overrideUpdatePotionEffectsHookTypes = new LinkedList<String>(); + private final static List<String> afterUpdatePotionEffectsHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeUpdatePotionEffectsHooks; + private ServerPlayerBase[] overrideUpdatePotionEffectsHooks; + private ServerPlayerBase[] afterUpdatePotionEffectsHooks; + + public boolean isUpdatePotionEffectsModded; + + private static final Map<String, String[]> allBaseBeforeUpdatePotionEffectsSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeUpdatePotionEffectsInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideUpdatePotionEffectsSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideUpdatePotionEffectsInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterUpdatePotionEffectsSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterUpdatePotionEffectsInferiors = new Hashtable<String, String[]>(0); + + public static void updateRidden(IServerPlayerAPI target) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isUpdateRiddenModded) + serverPlayerAPI.updateRidden(); + else + target.localUpdateRidden(); + } + + private void updateRidden() + { + if(beforeUpdateRiddenHooks != null) + for(int i = beforeUpdateRiddenHooks.length - 1; i >= 0 ; i--) + beforeUpdateRiddenHooks[i].beforeUpdateRidden(); + + if(overrideUpdateRiddenHooks != null) + overrideUpdateRiddenHooks[overrideUpdateRiddenHooks.length - 1].updateRidden(); + else + player.localUpdateRidden(); + + if(afterUpdateRiddenHooks != null) + for(int i = 0; i < afterUpdateRiddenHooks.length; i++) + afterUpdateRiddenHooks[i].afterUpdateRidden(); + + } + + protected ServerPlayerBase GetOverwrittenUpdateRidden(ServerPlayerBase overWriter) + { + if (overrideUpdateRiddenHooks == null) + return overWriter; + + for(int i = 0; i < overrideUpdateRiddenHooks.length; i++) + if(overrideUpdateRiddenHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideUpdateRiddenHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeUpdateRiddenHookTypes = new LinkedList<String>(); + private final static List<String> overrideUpdateRiddenHookTypes = new LinkedList<String>(); + private final static List<String> afterUpdateRiddenHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeUpdateRiddenHooks; + private ServerPlayerBase[] overrideUpdateRiddenHooks; + private ServerPlayerBase[] afterUpdateRiddenHooks; + + public boolean isUpdateRiddenModded; + + private static final Map<String, String[]> allBaseBeforeUpdateRiddenSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeUpdateRiddenInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideUpdateRiddenSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideUpdateRiddenInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterUpdateRiddenSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterUpdateRiddenInferiors = new Hashtable<String, String[]>(0); + + public static void wakeUpPlayer(IServerPlayerAPI target, boolean paramBoolean1, boolean paramBoolean2, boolean paramBoolean3) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isWakeUpPlayerModded) + serverPlayerAPI.wakeUpPlayer(paramBoolean1, paramBoolean2, paramBoolean3); + else + target.localWakeUpPlayer(paramBoolean1, paramBoolean2, paramBoolean3); + } + + private void wakeUpPlayer(boolean paramBoolean1, boolean paramBoolean2, boolean paramBoolean3) + { + if(beforeWakeUpPlayerHooks != null) + for(int i = beforeWakeUpPlayerHooks.length - 1; i >= 0 ; i--) + beforeWakeUpPlayerHooks[i].beforeWakeUpPlayer(paramBoolean1, paramBoolean2, paramBoolean3); + + if(overrideWakeUpPlayerHooks != null) + overrideWakeUpPlayerHooks[overrideWakeUpPlayerHooks.length - 1].wakeUpPlayer(paramBoolean1, paramBoolean2, paramBoolean3); + else + player.localWakeUpPlayer(paramBoolean1, paramBoolean2, paramBoolean3); + + if(afterWakeUpPlayerHooks != null) + for(int i = 0; i < afterWakeUpPlayerHooks.length; i++) + afterWakeUpPlayerHooks[i].afterWakeUpPlayer(paramBoolean1, paramBoolean2, paramBoolean3); + + } + + protected ServerPlayerBase GetOverwrittenWakeUpPlayer(ServerPlayerBase overWriter) + { + if (overrideWakeUpPlayerHooks == null) + return overWriter; + + for(int i = 0; i < overrideWakeUpPlayerHooks.length; i++) + if(overrideWakeUpPlayerHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideWakeUpPlayerHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeWakeUpPlayerHookTypes = new LinkedList<String>(); + private final static List<String> overrideWakeUpPlayerHookTypes = new LinkedList<String>(); + private final static List<String> afterWakeUpPlayerHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeWakeUpPlayerHooks; + private ServerPlayerBase[] overrideWakeUpPlayerHooks; + private ServerPlayerBase[] afterWakeUpPlayerHooks; + + public boolean isWakeUpPlayerModded; + + private static final Map<String, String[]> allBaseBeforeWakeUpPlayerSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeWakeUpPlayerInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideWakeUpPlayerSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideWakeUpPlayerInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterWakeUpPlayerSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterWakeUpPlayerInferiors = new Hashtable<String, String[]>(0); + + public static void writeEntityToNBT(IServerPlayerAPI target, net.minecraft.nbt.NBTTagCompound paramNBTTagCompound) + { + ServerPlayerAPI serverPlayerAPI = target.getServerPlayerAPI(); + if(serverPlayerAPI != null && serverPlayerAPI.isWriteEntityToNBTModded) + serverPlayerAPI.writeEntityToNBT(paramNBTTagCompound); + else + target.localWriteEntityToNBT(paramNBTTagCompound); + } + + private void writeEntityToNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound) + { + if(beforeWriteEntityToNBTHooks != null) + for(int i = beforeWriteEntityToNBTHooks.length - 1; i >= 0 ; i--) + beforeWriteEntityToNBTHooks[i].beforeWriteEntityToNBT(paramNBTTagCompound); + + if(overrideWriteEntityToNBTHooks != null) + overrideWriteEntityToNBTHooks[overrideWriteEntityToNBTHooks.length - 1].writeEntityToNBT(paramNBTTagCompound); + else + player.localWriteEntityToNBT(paramNBTTagCompound); + + if(afterWriteEntityToNBTHooks != null) + for(int i = 0; i < afterWriteEntityToNBTHooks.length; i++) + afterWriteEntityToNBTHooks[i].afterWriteEntityToNBT(paramNBTTagCompound); + + } + + protected ServerPlayerBase GetOverwrittenWriteEntityToNBT(ServerPlayerBase overWriter) + { + if (overrideWriteEntityToNBTHooks == null) + return overWriter; + + for(int i = 0; i < overrideWriteEntityToNBTHooks.length; i++) + if(overrideWriteEntityToNBTHooks[i] == overWriter) + if(i == 0) + return null; + else + return overrideWriteEntityToNBTHooks[i - 1]; + + return overWriter; + } + + private final static List<String> beforeWriteEntityToNBTHookTypes = new LinkedList<String>(); + private final static List<String> overrideWriteEntityToNBTHookTypes = new LinkedList<String>(); + private final static List<String> afterWriteEntityToNBTHookTypes = new LinkedList<String>(); + + private ServerPlayerBase[] beforeWriteEntityToNBTHooks; + private ServerPlayerBase[] overrideWriteEntityToNBTHooks; + private ServerPlayerBase[] afterWriteEntityToNBTHooks; + + public boolean isWriteEntityToNBTModded; + + private static final Map<String, String[]> allBaseBeforeWriteEntityToNBTSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeWriteEntityToNBTInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideWriteEntityToNBTSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseOverrideWriteEntityToNBTInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterWriteEntityToNBTSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterWriteEntityToNBTInferiors = new Hashtable<String, String[]>(0); + + + protected final IServerPlayerAPI player; + + private final static Set<String> keys = new HashSet<String>(); + private final static Map<String, String> keysToVirtualIds = new HashMap<String, String>(); + private final static Set<Class<?>> dynamicTypes = new HashSet<Class<?>>(); + + private final static Map<Class<?>, Map<String, Method>> virtualDynamicHookMethods = new HashMap<Class<?>, Map<String, Method>>(); + + private final static Map<Class<?>, Map<String, Method>> beforeDynamicHookMethods = new HashMap<Class<?>, Map<String, Method>>(); + private final static Map<Class<?>, Map<String, Method>> overrideDynamicHookMethods = new HashMap<Class<?>, Map<String, Method>>(); + private final static Map<Class<?>, Map<String, Method>> afterDynamicHookMethods = new HashMap<Class<?>, Map<String, Method>>(); + + private final static List<String> beforeLocalConstructingHookTypes = new LinkedList<String>(); + private final static List<String> afterLocalConstructingHookTypes = new LinkedList<String>(); + + private static final Map<String, List<String>> beforeDynamicHookTypes = new Hashtable<String, List<String>>(0); + private static final Map<String, List<String>> overrideDynamicHookTypes = new Hashtable<String, List<String>>(0); + private static final Map<String, List<String>> afterDynamicHookTypes = new Hashtable<String, List<String>>(0); + + private ServerPlayerBase[] beforeLocalConstructingHooks; + private ServerPlayerBase[] afterLocalConstructingHooks; + + private final Map<ServerPlayerBase, String> baseObjectsToId = new Hashtable<ServerPlayerBase, String>(); + private final Map<String, ServerPlayerBase> allBaseObjects = new Hashtable<String, ServerPlayerBase>(); + private final Set<String> unmodifiableAllBaseIds = Collections.unmodifiableSet(allBaseObjects.keySet()); + + private static final Map<String, Constructor<?>> allBaseConstructors = new Hashtable<String, Constructor<?>>(); + private static final Set<String> unmodifiableAllIds = Collections.unmodifiableSet(allBaseConstructors.keySet()); + + private static final Map<String, String[]> allBaseBeforeLocalConstructingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseBeforeLocalConstructingInferiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterLocalConstructingSuperiors = new Hashtable<String, String[]>(0); + private static final Map<String, String[]> allBaseAfterLocalConstructingInferiors = new Hashtable<String, String[]>(0); + + private static final Map<String, Map<String, String[]>> allBaseBeforeDynamicSuperiors = new Hashtable<String, Map<String, String[]>>(0); + private static final Map<String, Map<String, String[]>> allBaseBeforeDynamicInferiors = new Hashtable<String, Map<String, String[]>>(0); + private static final Map<String, Map<String, String[]>> allBaseOverrideDynamicSuperiors = new Hashtable<String, Map<String, String[]>>(0); + private static final Map<String, Map<String, String[]>> allBaseOverrideDynamicInferiors = new Hashtable<String, Map<String, String[]>>(0); + private static final Map<String, Map<String, String[]>> allBaseAfterDynamicSuperiors = new Hashtable<String, Map<String, String[]>>(0); + private static final Map<String, Map<String, String[]>> allBaseAfterDynamicInferiors = new Hashtable<String, Map<String, String[]>>(0); + + private static boolean initialized = false; +} diff --git a/src/Java/api/player/server/ServerPlayerBase.java b/src/Java/api/player/server/ServerPlayerBase.java new file mode 100644 index 0000000000..cb54faddb0 --- /dev/null +++ b/src/Java/api/player/server/ServerPlayerBase.java @@ -0,0 +1,1207 @@ +// ================================================================== +// This file is part of Player API. +// +// Player API is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// Player API is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and the GNU General Public License along with Player API. +// If not, see <http://www.gnu.org/licenses/>. +// ================================================================== + +package api.player.server; + +public abstract class ServerPlayerBase +{ + public ServerPlayerBase(ServerPlayerAPI playerAPI) + { + this.internalServerPlayerAPI = playerAPI; + this.playerAPI = playerAPI.player; + this.player = playerAPI.player.getEntityPlayerMP(); + } + + public void beforeBaseAttach(boolean onTheFly) + { + } + + public void afterBaseAttach(boolean onTheFly) + { + } + + public void beforeLocalConstructing(net.minecraft.server.MinecraftServer paramMinecraftServer, net.minecraft.world.WorldServer paramWorldServer, com.mojang.authlib.GameProfile paramGameProfile, net.minecraft.server.management.ItemInWorldManager paramItemInWorldManager) + { + } + + public void afterLocalConstructing(net.minecraft.server.MinecraftServer paramMinecraftServer, net.minecraft.world.WorldServer paramWorldServer, com.mojang.authlib.GameProfile paramGameProfile, net.minecraft.server.management.ItemInWorldManager paramItemInWorldManager) + { + } + + public void beforeBaseDetach(boolean onTheFly) + { + } + + public void afterBaseDetach(boolean onTheFly) + { + } + + public Object dynamic(String key, Object[] parameters) + { + return internalServerPlayerAPI.dynamicOverwritten(key, parameters, this); + } + + public final int hashCode() + { + return super.hashCode(); + } + + public void beforeAddExhaustion(float paramFloat) + { + } + + public void addExhaustion(float paramFloat) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenAddExhaustion(this); + + if(overwritten == null) + playerAPI.localAddExhaustion(paramFloat); + else if(overwritten != this) + overwritten.addExhaustion(paramFloat); + + } + + public void afterAddExhaustion(float paramFloat) + { + } + + public void beforeAddExperience(int paramInt) + { + } + + public void addExperience(int paramInt) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenAddExperience(this); + + if(overwritten == null) + playerAPI.localAddExperience(paramInt); + else if(overwritten != this) + overwritten.addExperience(paramInt); + + } + + public void afterAddExperience(int paramInt) + { + } + + public void beforeAddExperienceLevel(int paramInt) + { + } + + public void addExperienceLevel(int paramInt) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenAddExperienceLevel(this); + + if(overwritten == null) + playerAPI.localAddExperienceLevel(paramInt); + else if(overwritten != this) + overwritten.addExperienceLevel(paramInt); + + } + + public void afterAddExperienceLevel(int paramInt) + { + } + + public void beforeAddMovementStat(double paramDouble1, double paramDouble2, double paramDouble3) + { + } + + public void addMovementStat(double paramDouble1, double paramDouble2, double paramDouble3) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenAddMovementStat(this); + + if(overwritten == null) + playerAPI.localAddMovementStat(paramDouble1, paramDouble2, paramDouble3); + else if(overwritten != this) + overwritten.addMovementStat(paramDouble1, paramDouble2, paramDouble3); + + } + + public void afterAddMovementStat(double paramDouble1, double paramDouble2, double paramDouble3) + { + } + + public void beforeAttackEntityFrom(net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + } + + public boolean attackEntityFrom(net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenAttackEntityFrom(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localAttackEntityFrom(paramDamageSource, paramFloat); + else if(overwritten != this) + _result = overwritten.attackEntityFrom(paramDamageSource, paramFloat); + else + _result = false; + + return _result; + } + + public void afterAttackEntityFrom(net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + } + + public void beforeAttackTargetEntityWithCurrentItem(net.minecraft.entity.Entity paramEntity) + { + } + + public void attackTargetEntityWithCurrentItem(net.minecraft.entity.Entity paramEntity) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenAttackTargetEntityWithCurrentItem(this); + + if(overwritten == null) + playerAPI.localAttackTargetEntityWithCurrentItem(paramEntity); + else if(overwritten != this) + overwritten.attackTargetEntityWithCurrentItem(paramEntity); + + } + + public void afterAttackTargetEntityWithCurrentItem(net.minecraft.entity.Entity paramEntity) + { + } + + public void beforeCanBreatheUnderwater() + { + } + + public boolean canBreatheUnderwater() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenCanBreatheUnderwater(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localCanBreatheUnderwater(); + else if(overwritten != this) + _result = overwritten.canBreatheUnderwater(); + else + _result = false; + + return _result; + } + + public void afterCanBreatheUnderwater() + { + } + + public void beforeCanHarvestBlock(net.minecraft.block.Block paramBlock) + { + } + + public boolean canHarvestBlock(net.minecraft.block.Block paramBlock) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenCanHarvestBlock(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localCanHarvestBlock(paramBlock); + else if(overwritten != this) + _result = overwritten.canHarvestBlock(paramBlock); + else + _result = false; + + return _result; + } + + public void afterCanHarvestBlock(net.minecraft.block.Block paramBlock) + { + } + + public void beforeCanPlayerEdit(int paramInt1, int paramInt2, int paramInt3, int paramInt4, net.minecraft.item.ItemStack paramItemStack) + { + } + + public boolean canPlayerEdit(int paramInt1, int paramInt2, int paramInt3, int paramInt4, net.minecraft.item.ItemStack paramItemStack) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenCanPlayerEdit(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localCanPlayerEdit(paramInt1, paramInt2, paramInt3, paramInt4, paramItemStack); + else if(overwritten != this) + _result = overwritten.canPlayerEdit(paramInt1, paramInt2, paramInt3, paramInt4, paramItemStack); + else + _result = false; + + return _result; + } + + public void afterCanPlayerEdit(int paramInt1, int paramInt2, int paramInt3, int paramInt4, net.minecraft.item.ItemStack paramItemStack) + { + } + + public void beforeCanTriggerWalking() + { + } + + public boolean canTriggerWalking() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenCanTriggerWalking(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localCanTriggerWalking(); + else if(overwritten != this) + _result = overwritten.canTriggerWalking(); + else + _result = false; + + return _result; + } + + public void afterCanTriggerWalking() + { + } + + public void beforeClonePlayer(net.minecraft.entity.player.EntityPlayer paramEntityPlayer, boolean paramBoolean) + { + } + + public void clonePlayer(net.minecraft.entity.player.EntityPlayer paramEntityPlayer, boolean paramBoolean) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenClonePlayer(this); + + if(overwritten == null) + playerAPI.localClonePlayer(paramEntityPlayer, paramBoolean); + else if(overwritten != this) + overwritten.clonePlayer(paramEntityPlayer, paramBoolean); + + } + + public void afterClonePlayer(net.minecraft.entity.player.EntityPlayer paramEntityPlayer, boolean paramBoolean) + { + } + + public void beforeDamageEntity(net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + } + + public void damageEntity(net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenDamageEntity(this); + + if(overwritten == null) + playerAPI.localDamageEntity(paramDamageSource, paramFloat); + else if(overwritten != this) + overwritten.damageEntity(paramDamageSource, paramFloat); + + } + + public void afterDamageEntity(net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + } + + public void beforeDisplayGUIChest(net.minecraft.inventory.IInventory paramIInventory) + { + } + + public void displayGUIChest(net.minecraft.inventory.IInventory paramIInventory) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenDisplayGUIChest(this); + + if(overwritten == null) + playerAPI.localDisplayGUIChest(paramIInventory); + else if(overwritten != this) + overwritten.displayGUIChest(paramIInventory); + + } + + public void afterDisplayGUIChest(net.minecraft.inventory.IInventory paramIInventory) + { + } + + public void beforeDisplayGUIDispenser(net.minecraft.tileentity.TileEntityDispenser paramTileEntityDispenser) + { + } + + public void displayGUIDispenser(net.minecraft.tileentity.TileEntityDispenser paramTileEntityDispenser) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenDisplayGUIDispenser(this); + + if(overwritten == null) + playerAPI.localDisplayGUIDispenser(paramTileEntityDispenser); + else if(overwritten != this) + overwritten.displayGUIDispenser(paramTileEntityDispenser); + + } + + public void afterDisplayGUIDispenser(net.minecraft.tileentity.TileEntityDispenser paramTileEntityDispenser) + { + } + + public void beforeDisplayGUIFurnace(net.minecraft.tileentity.TileEntityFurnace paramTileEntityFurnace) + { + } + + public void displayGUIFurnace(net.minecraft.tileentity.TileEntityFurnace paramTileEntityFurnace) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenDisplayGUIFurnace(this); + + if(overwritten == null) + playerAPI.localDisplayGUIFurnace(paramTileEntityFurnace); + else if(overwritten != this) + overwritten.displayGUIFurnace(paramTileEntityFurnace); + + } + + public void afterDisplayGUIFurnace(net.minecraft.tileentity.TileEntityFurnace paramTileEntityFurnace) + { + } + + public void beforeDisplayGUIWorkbench(int paramInt1, int paramInt2, int paramInt3) + { + } + + public void displayGUIWorkbench(int paramInt1, int paramInt2, int paramInt3) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenDisplayGUIWorkbench(this); + + if(overwritten == null) + playerAPI.localDisplayGUIWorkbench(paramInt1, paramInt2, paramInt3); + else if(overwritten != this) + overwritten.displayGUIWorkbench(paramInt1, paramInt2, paramInt3); + + } + + public void afterDisplayGUIWorkbench(int paramInt1, int paramInt2, int paramInt3) + { + } + + public void beforeDropOneItem(boolean paramBoolean) + { + } + + public net.minecraft.entity.item.EntityItem dropOneItem(boolean paramBoolean) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenDropOneItem(this); + + net.minecraft.entity.item.EntityItem _result; + if(overwritten == null) + _result = playerAPI.localDropOneItem(paramBoolean); + else if(overwritten != this) + _result = overwritten.dropOneItem(paramBoolean); + else + _result = null; + + return _result; + } + + public void afterDropOneItem(boolean paramBoolean) + { + } + + public void beforeDropPlayerItem(net.minecraft.item.ItemStack paramItemStack, boolean paramBoolean) + { + } + + public net.minecraft.entity.item.EntityItem dropPlayerItem(net.minecraft.item.ItemStack paramItemStack, boolean paramBoolean) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenDropPlayerItem(this); + + net.minecraft.entity.item.EntityItem _result; + if(overwritten == null) + _result = playerAPI.localDropPlayerItem(paramItemStack, paramBoolean); + else if(overwritten != this) + _result = overwritten.dropPlayerItem(paramItemStack, paramBoolean); + else + _result = null; + + return _result; + } + + public void afterDropPlayerItem(net.minecraft.item.ItemStack paramItemStack, boolean paramBoolean) + { + } + + public void beforeFall(float paramFloat) + { + } + + public void fall(float paramFloat) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenFall(this); + + if(overwritten == null) + playerAPI.localFall(paramFloat); + else if(overwritten != this) + overwritten.fall(paramFloat); + + } + + public void afterFall(float paramFloat) + { + } + + public void beforeGetAIMoveSpeed() + { + } + + public float getAIMoveSpeed() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenGetAIMoveSpeed(this); + + float _result; + if(overwritten == null) + _result = playerAPI.localGetAIMoveSpeed(); + else if(overwritten != this) + _result = overwritten.getAIMoveSpeed(); + else + _result = 0; + + return _result; + } + + public void afterGetAIMoveSpeed() + { + } + + public void beforeGetCurrentPlayerStrVsBlock(net.minecraft.block.Block paramBlock, boolean paramBoolean) + { + } + + public float getCurrentPlayerStrVsBlock(net.minecraft.block.Block paramBlock, boolean paramBoolean) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenGetCurrentPlayerStrVsBlock(this); + + float _result; + if(overwritten == null) + _result = playerAPI.localGetCurrentPlayerStrVsBlock(paramBlock, paramBoolean); + else if(overwritten != this) + _result = overwritten.getCurrentPlayerStrVsBlock(paramBlock, paramBoolean); + else + _result = 0; + + return _result; + } + + public void afterGetCurrentPlayerStrVsBlock(net.minecraft.block.Block paramBlock, boolean paramBoolean) + { + } + + public void beforeGetCurrentPlayerStrVsBlockForge(net.minecraft.block.Block paramBlock, boolean paramBoolean, int paramInt) + { + } + + public float getCurrentPlayerStrVsBlockForge(net.minecraft.block.Block paramBlock, boolean paramBoolean, int paramInt) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenGetCurrentPlayerStrVsBlockForge(this); + + float _result; + if(overwritten == null) + _result = playerAPI.localGetCurrentPlayerStrVsBlockForge(paramBlock, paramBoolean, paramInt); + else if(overwritten != this) + _result = overwritten.getCurrentPlayerStrVsBlockForge(paramBlock, paramBoolean, paramInt); + else + _result = 0; + + return _result; + } + + public void afterGetCurrentPlayerStrVsBlockForge(net.minecraft.block.Block paramBlock, boolean paramBoolean, int paramInt) + { + } + + public void beforeGetDistanceSq(double paramDouble1, double paramDouble2, double paramDouble3) + { + } + + public double getDistanceSq(double paramDouble1, double paramDouble2, double paramDouble3) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenGetDistanceSq(this); + + double _result; + if(overwritten == null) + _result = playerAPI.localGetDistanceSq(paramDouble1, paramDouble2, paramDouble3); + else if(overwritten != this) + _result = overwritten.getDistanceSq(paramDouble1, paramDouble2, paramDouble3); + else + _result = 0; + + return _result; + } + + public void afterGetDistanceSq(double paramDouble1, double paramDouble2, double paramDouble3) + { + } + + public void beforeGetBrightness(float paramFloat) + { + } + + public float getBrightness(float paramFloat) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenGetBrightness(this); + + float _result; + if(overwritten == null) + _result = playerAPI.localGetBrightness(paramFloat); + else if(overwritten != this) + _result = overwritten.getBrightness(paramFloat); + else + _result = 0; + + return _result; + } + + public void afterGetBrightness(float paramFloat) + { + } + + public void beforeGetEyeHeight() + { + } + + public float getEyeHeight() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenGetEyeHeight(this); + + float _result; + if(overwritten == null) + _result = playerAPI.localGetEyeHeight(); + else if(overwritten != this) + _result = overwritten.getEyeHeight(); + else + _result = 0; + + return _result; + } + + public void afterGetEyeHeight() + { + } + + public void beforeHeal(float paramFloat) + { + } + + public void heal(float paramFloat) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenHeal(this); + + if(overwritten == null) + playerAPI.localHeal(paramFloat); + else if(overwritten != this) + overwritten.heal(paramFloat); + + } + + public void afterHeal(float paramFloat) + { + } + + public void beforeIsEntityInsideOpaqueBlock() + { + } + + public boolean isEntityInsideOpaqueBlock() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenIsEntityInsideOpaqueBlock(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localIsEntityInsideOpaqueBlock(); + else if(overwritten != this) + _result = overwritten.isEntityInsideOpaqueBlock(); + else + _result = false; + + return _result; + } + + public void afterIsEntityInsideOpaqueBlock() + { + } + + public void beforeIsInWater() + { + } + + public boolean isInWater() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenIsInWater(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localIsInWater(); + else if(overwritten != this) + _result = overwritten.isInWater(); + else + _result = false; + + return _result; + } + + public void afterIsInWater() + { + } + + public void beforeIsInsideOfMaterial(net.minecraft.block.material.Material paramMaterial) + { + } + + public boolean isInsideOfMaterial(net.minecraft.block.material.Material paramMaterial) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenIsInsideOfMaterial(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localIsInsideOfMaterial(paramMaterial); + else if(overwritten != this) + _result = overwritten.isInsideOfMaterial(paramMaterial); + else + _result = false; + + return _result; + } + + public void afterIsInsideOfMaterial(net.minecraft.block.material.Material paramMaterial) + { + } + + public void beforeIsOnLadder() + { + } + + public boolean isOnLadder() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenIsOnLadder(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localIsOnLadder(); + else if(overwritten != this) + _result = overwritten.isOnLadder(); + else + _result = false; + + return _result; + } + + public void afterIsOnLadder() + { + } + + public void beforeIsPlayerSleeping() + { + } + + public boolean isPlayerSleeping() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenIsPlayerSleeping(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localIsPlayerSleeping(); + else if(overwritten != this) + _result = overwritten.isPlayerSleeping(); + else + _result = false; + + return _result; + } + + public void afterIsPlayerSleeping() + { + } + + public void beforeIsSneaking() + { + } + + public boolean isSneaking() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenIsSneaking(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localIsSneaking(); + else if(overwritten != this) + _result = overwritten.isSneaking(); + else + _result = false; + + return _result; + } + + public void afterIsSneaking() + { + } + + public void beforeJump() + { + } + + public void jump() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenJump(this); + + if(overwritten == null) + playerAPI.localJump(); + else if(overwritten != this) + overwritten.jump(); + + } + + public void afterJump() + { + } + + public void beforeKnockBack(net.minecraft.entity.Entity paramEntity, float paramFloat, double paramDouble1, double paramDouble2) + { + } + + public void knockBack(net.minecraft.entity.Entity paramEntity, float paramFloat, double paramDouble1, double paramDouble2) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenKnockBack(this); + + if(overwritten == null) + playerAPI.localKnockBack(paramEntity, paramFloat, paramDouble1, paramDouble2); + else if(overwritten != this) + overwritten.knockBack(paramEntity, paramFloat, paramDouble1, paramDouble2); + + } + + public void afterKnockBack(net.minecraft.entity.Entity paramEntity, float paramFloat, double paramDouble1, double paramDouble2) + { + } + + public void beforeMountEntity(net.minecraft.entity.Entity paramEntity) + { + } + + public void mountEntity(net.minecraft.entity.Entity paramEntity) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenMountEntity(this); + + if(overwritten == null) + playerAPI.localMountEntity(paramEntity); + else if(overwritten != this) + overwritten.mountEntity(paramEntity); + + } + + public void afterMountEntity(net.minecraft.entity.Entity paramEntity) + { + } + + public void beforeMoveEntity(double paramDouble1, double paramDouble2, double paramDouble3) + { + } + + public void moveEntity(double paramDouble1, double paramDouble2, double paramDouble3) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenMoveEntity(this); + + if(overwritten == null) + playerAPI.localMoveEntity(paramDouble1, paramDouble2, paramDouble3); + else if(overwritten != this) + overwritten.moveEntity(paramDouble1, paramDouble2, paramDouble3); + + } + + public void afterMoveEntity(double paramDouble1, double paramDouble2, double paramDouble3) + { + } + + public void beforeMoveEntityWithHeading(float paramFloat1, float paramFloat2) + { + } + + public void moveEntityWithHeading(float paramFloat1, float paramFloat2) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenMoveEntityWithHeading(this); + + if(overwritten == null) + playerAPI.localMoveEntityWithHeading(paramFloat1, paramFloat2); + else if(overwritten != this) + overwritten.moveEntityWithHeading(paramFloat1, paramFloat2); + + } + + public void afterMoveEntityWithHeading(float paramFloat1, float paramFloat2) + { + } + + public void beforeMoveFlying(float paramFloat1, float paramFloat2, float paramFloat3) + { + } + + public void moveFlying(float paramFloat1, float paramFloat2, float paramFloat3) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenMoveFlying(this); + + if(overwritten == null) + playerAPI.localMoveFlying(paramFloat1, paramFloat2, paramFloat3); + else if(overwritten != this) + overwritten.moveFlying(paramFloat1, paramFloat2, paramFloat3); + + } + + public void afterMoveFlying(float paramFloat1, float paramFloat2, float paramFloat3) + { + } + + public void beforeOnDeath(net.minecraft.util.DamageSource paramDamageSource) + { + } + + public void onDeath(net.minecraft.util.DamageSource paramDamageSource) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenOnDeath(this); + + if(overwritten == null) + playerAPI.localOnDeath(paramDamageSource); + else if(overwritten != this) + overwritten.onDeath(paramDamageSource); + + } + + public void afterOnDeath(net.minecraft.util.DamageSource paramDamageSource) + { + } + + public void beforeOnLivingUpdate() + { + } + + public void onLivingUpdate() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenOnLivingUpdate(this); + + if(overwritten == null) + playerAPI.localOnLivingUpdate(); + else if(overwritten != this) + overwritten.onLivingUpdate(); + + } + + public void afterOnLivingUpdate() + { + } + + public void beforeOnKillEntity(net.minecraft.entity.EntityLivingBase paramEntityLivingBase) + { + } + + public void onKillEntity(net.minecraft.entity.EntityLivingBase paramEntityLivingBase) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenOnKillEntity(this); + + if(overwritten == null) + playerAPI.localOnKillEntity(paramEntityLivingBase); + else if(overwritten != this) + overwritten.onKillEntity(paramEntityLivingBase); + + } + + public void afterOnKillEntity(net.minecraft.entity.EntityLivingBase paramEntityLivingBase) + { + } + + public void beforeOnStruckByLightning(net.minecraft.entity.effect.EntityLightningBolt paramEntityLightningBolt) + { + } + + public void onStruckByLightning(net.minecraft.entity.effect.EntityLightningBolt paramEntityLightningBolt) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenOnStruckByLightning(this); + + if(overwritten == null) + playerAPI.localOnStruckByLightning(paramEntityLightningBolt); + else if(overwritten != this) + overwritten.onStruckByLightning(paramEntityLightningBolt); + + } + + public void afterOnStruckByLightning(net.minecraft.entity.effect.EntityLightningBolt paramEntityLightningBolt) + { + } + + public void beforeOnUpdate() + { + } + + public void onUpdate() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenOnUpdate(this); + + if(overwritten == null) + playerAPI.localOnUpdate(); + else if(overwritten != this) + overwritten.onUpdate(); + + } + + public void afterOnUpdate() + { + } + + public void beforeOnUpdateEntity() + { + } + + public void onUpdateEntity() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenOnUpdateEntity(this); + + if(overwritten == null) + playerAPI.localOnUpdateEntity(); + else if(overwritten != this) + overwritten.onUpdateEntity(); + + } + + public void afterOnUpdateEntity() + { + } + + public void beforeReadEntityFromNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound) + { + } + + public void readEntityFromNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenReadEntityFromNBT(this); + + if(overwritten == null) + playerAPI.localReadEntityFromNBT(paramNBTTagCompound); + else if(overwritten != this) + overwritten.readEntityFromNBT(paramNBTTagCompound); + + } + + public void afterReadEntityFromNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound) + { + } + + public void beforeSetDead() + { + } + + public void setDead() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenSetDead(this); + + if(overwritten == null) + playerAPI.localSetDead(); + else if(overwritten != this) + overwritten.setDead(); + + } + + public void afterSetDead() + { + } + + public void beforeSetEntityActionState(float paramFloat1, float paramFloat2, boolean paramBoolean1, boolean paramBoolean2) + { + } + + public void setEntityActionState(float paramFloat1, float paramFloat2, boolean paramBoolean1, boolean paramBoolean2) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenSetEntityActionState(this); + + if(overwritten == null) + playerAPI.localSetEntityActionState(paramFloat1, paramFloat2, paramBoolean1, paramBoolean2); + else if(overwritten != this) + overwritten.setEntityActionState(paramFloat1, paramFloat2, paramBoolean1, paramBoolean2); + + } + + public void afterSetEntityActionState(float paramFloat1, float paramFloat2, boolean paramBoolean1, boolean paramBoolean2) + { + } + + public void beforeSetPosition(double paramDouble1, double paramDouble2, double paramDouble3) + { + } + + public void setPosition(double paramDouble1, double paramDouble2, double paramDouble3) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenSetPosition(this); + + if(overwritten == null) + playerAPI.localSetPosition(paramDouble1, paramDouble2, paramDouble3); + else if(overwritten != this) + overwritten.setPosition(paramDouble1, paramDouble2, paramDouble3); + + } + + public void afterSetPosition(double paramDouble1, double paramDouble2, double paramDouble3) + { + } + + public void beforeSetSneaking(boolean paramBoolean) + { + } + + public void setSneaking(boolean paramBoolean) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenSetSneaking(this); + + if(overwritten == null) + playerAPI.localSetSneaking(paramBoolean); + else if(overwritten != this) + overwritten.setSneaking(paramBoolean); + + } + + public void afterSetSneaking(boolean paramBoolean) + { + } + + public void beforeSetSprinting(boolean paramBoolean) + { + } + + public void setSprinting(boolean paramBoolean) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenSetSprinting(this); + + if(overwritten == null) + playerAPI.localSetSprinting(paramBoolean); + else if(overwritten != this) + overwritten.setSprinting(paramBoolean); + + } + + public void afterSetSprinting(boolean paramBoolean) + { + } + + public void beforeSwingItem() + { + } + + public void swingItem() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenSwingItem(this); + + if(overwritten == null) + playerAPI.localSwingItem(); + else if(overwritten != this) + overwritten.swingItem(); + + } + + public void afterSwingItem() + { + } + + public void beforeUpdateEntityActionState() + { + } + + public void updateEntityActionState() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenUpdateEntityActionState(this); + + if(overwritten == null) + playerAPI.localUpdateEntityActionState(); + else if(overwritten != this) + overwritten.updateEntityActionState(); + + } + + public void afterUpdateEntityActionState() + { + } + + public void beforeUpdatePotionEffects() + { + } + + public void updatePotionEffects() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenUpdatePotionEffects(this); + + if(overwritten == null) + playerAPI.localUpdatePotionEffects(); + else if(overwritten != this) + overwritten.updatePotionEffects(); + + } + + public void afterUpdatePotionEffects() + { + } + + public void beforeUpdateRidden() + { + } + + public void updateRidden() + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenUpdateRidden(this); + + if(overwritten == null) + playerAPI.localUpdateRidden(); + else if(overwritten != this) + overwritten.updateRidden(); + + } + + public void afterUpdateRidden() + { + } + + public void beforeWakeUpPlayer(boolean paramBoolean1, boolean paramBoolean2, boolean paramBoolean3) + { + } + + public void wakeUpPlayer(boolean paramBoolean1, boolean paramBoolean2, boolean paramBoolean3) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenWakeUpPlayer(this); + + if(overwritten == null) + playerAPI.localWakeUpPlayer(paramBoolean1, paramBoolean2, paramBoolean3); + else if(overwritten != this) + overwritten.wakeUpPlayer(paramBoolean1, paramBoolean2, paramBoolean3); + + } + + public void afterWakeUpPlayer(boolean paramBoolean1, boolean paramBoolean2, boolean paramBoolean3) + { + } + + public void beforeWriteEntityToNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound) + { + } + + public void writeEntityToNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound) + { + ServerPlayerBase overwritten = internalServerPlayerAPI.GetOverwrittenWriteEntityToNBT(this); + + if(overwritten == null) + playerAPI.localWriteEntityToNBT(paramNBTTagCompound); + else if(overwritten != this) + overwritten.writeEntityToNBT(paramNBTTagCompound); + + } + + public void afterWriteEntityToNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound) + { + } + + protected final net.minecraft.entity.player.EntityPlayerMP player; + protected final IServerPlayer playerAPI; + private final ServerPlayerAPI internalServerPlayerAPI; +} diff --git a/src/Java/api/player/server/ServerPlayerBaseSorter.java b/src/Java/api/player/server/ServerPlayerBaseSorter.java new file mode 100644 index 0000000000..551d760564 --- /dev/null +++ b/src/Java/api/player/server/ServerPlayerBaseSorter.java @@ -0,0 +1,259 @@ +// ================================================================== +// This file is part of Player API. +// +// Player API is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// Player API is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and the GNU General Public License along with Player API. +// If not, see <http://www.gnu.org/licenses/>. +// ================================================================== + +package api.player.server; + +import java.util.*; + +public final class ServerPlayerBaseSorter +{ + public ServerPlayerBaseSorter(List<String> list, Map<String, String[]> allBaseSuperiors, Map<String, String[]> allBaseInferiors, String methodName) + { + this.list = list; + this.allBaseSuperiors = allBaseSuperiors; + this.allBaseInferiors = allBaseInferiors; + this.methodName = methodName; + } + + public void Sort() + { + if(list.size() <= 1) + return; + + if(explicitInferiors != null) + explicitInferiors.clear(); + + if(explicitSuperiors != null) + explicitSuperiors.clear(); + + if(directInferiorsMap != null) + directInferiorsMap.clear(); + + if(allInferiors != null) + allInferiors.clear(); + + for(int i = 0; i < list.size(); i++) + { + String baseId = list.get(i); + + String[] inferiorNames = allBaseInferiors.get(baseId); + boolean hasInferiors = inferiorNames != null && inferiorNames.length > 0; + + String[] superiorNames = allBaseSuperiors.get(baseId); + boolean hasSuperiors = superiorNames != null && superiorNames.length > 0; + + if((hasInferiors || hasSuperiors) && directInferiorsMap == null) + directInferiorsMap = new Hashtable<String, Set<String>>(); + + if(hasInferiors) + explicitInferiors = build(baseId, explicitInferiors, directInferiorsMap, null, inferiorNames); + + if(hasSuperiors) + explicitSuperiors = build(baseId, explicitSuperiors, null, directInferiorsMap, superiorNames); + } + if(directInferiorsMap != null) + { + for(int i = 0; i < list.size() - 1; i++) + for(int n = i + 1; n < list.size(); n++) + { + String left = list.get(i); + String right = list.get(n); + + Set<String> leftInferiors = null, rightInferiors = null; + if(explicitInferiors != null) + { + leftInferiors = explicitInferiors.get(left); + rightInferiors = explicitInferiors.get(right); + } + + Set<String> leftSuperiors = null, rightSuperiors = null; + if(explicitSuperiors != null) + { + leftSuperiors = explicitSuperiors.get(left); + rightSuperiors = explicitSuperiors.get(right); + } + + boolean leftWantsToBeInferiorToRight = leftSuperiors != null && leftSuperiors.contains(right); + boolean leftWantsToBeSuperiorToRight = leftInferiors != null && leftInferiors.contains(right); + + boolean rightWantsToBeInferiorToLeft = rightSuperiors != null && rightSuperiors.contains(left); + boolean rightWantsToBeSuperiorToLeft = rightInferiors != null && rightInferiors.contains(left); + + if(leftWantsToBeInferiorToRight && rightWantsToBeInferiorToLeft) + throw new UnsupportedOperationException("Can not sort ServerPlayerBase classes for method '" + methodName + "'. '" + left + "' wants to be inferior to '" + right + "' and '" + right + "' wants to be inferior to '" + left + "'"); + if(leftWantsToBeSuperiorToRight && rightWantsToBeSuperiorToLeft) + throw new UnsupportedOperationException("Can not sort ServerPlayerBase classes for method '" + methodName + "'. '" + left + "' wants to be superior to '" + right + "' and '" + right + "' wants to be superior to '" + left + "'"); + + if(leftWantsToBeInferiorToRight && leftWantsToBeSuperiorToRight) + throw new UnsupportedOperationException("Can not sort ServerPlayerBase classes for method '" + methodName + "'. '" + left + "' wants to be superior and inferior to '" + right + "'"); + if(rightWantsToBeInferiorToLeft && rightWantsToBeSuperiorToLeft) + throw new UnsupportedOperationException("Can not sort ServerPlayerBase classes for method '" + methodName + "'. '" + right + "' wants to be superior and inferior to '" + left + "'"); + } + + if(allInferiors == null) + allInferiors = new Hashtable<String, Set<String>>(); + + for(int i = 0; i < list.size(); i++) + build(list.get(i), null); + } + + if (withoutSuperiors == null) + withoutSuperiors = new LinkedList<String>(); + + int offset = 0; + int size = list.size(); + + while(size > 1) + { + withoutSuperiors.clear(); + for(int i = offset; i < offset + size; i++) + withoutSuperiors.add(list.get(i)); + + if(allInferiors != null) + for(int i = offset; i < offset + size; i++) + { + Set<String> inferiors = allInferiors.get(list.get(i)); + if (inferiors != null) + withoutSuperiors.removeAll(inferiors); + } + + boolean initial = true; + for(int i = offset; i < offset + size; i++) + { + String key = list.get(i); + if(withoutSuperiors.contains(key)) + { + if(initial) + { + Set<String> inferiors = null; + if(allInferiors != null) + inferiors = allInferiors.get(key); + if(inferiors == null || inferiors.isEmpty()) + { + withoutSuperiors.remove(key); + size--; + offset++; + continue; + } + } + list.remove(i--); + size--; + } + initial = false; + } + list.addAll(offset + size, withoutSuperiors); + } + } + + private Set<String> build(String type, String startType) + { + Set<String> inferiors = allInferiors.get(type); + if(inferiors == null) + { + inferiors = build(type, null, startType != null ? startType : type); + if(inferiors == null) + inferiors = Empty; + allInferiors.put(type, inferiors); + } + return inferiors; + } + + private Set<String> build(String type, Set<String> inferiors, String startType) + { + Set<String> directInferiors = directInferiorsMap.get(type); + if(directInferiors == null) + return inferiors; + + if(inferiors == null) + inferiors = new HashSet<String>(); + + Iterator<String> iter = directInferiors.iterator(); + while(iter.hasNext()) + { + String inferiorType = iter.next(); + if(inferiorType == startType) + throw new UnsupportedOperationException("Can not sort ServerPlayerBase classes for method '" + methodName + "'. Circular superiosity found including '" + startType + "'"); + if(list.contains(inferiorType)) + inferiors.add(inferiorType); + + Set<String> inferiorSet; + try + { + inferiorSet = build(inferiorType, startType); + } + catch(UnsupportedOperationException uoe) + { + throw new UnsupportedOperationException("Can not sort ServerPlayerBase classes for method '" + methodName + "'. Circular superiosity found including '" + inferiorType + "'", uoe); + } + + if(inferiorSet != Empty) + inferiors.addAll(inferiorSet); + } + return inferiors; + } + + private static Map<String, Set<String>> build(String baseId, Map<String, Set<String>> map, Map<String, Set<String>> directMap, Map<String, Set<String>> otherDirectMap, String[] names) + { + if(map == null) + map = new Hashtable<String, Set<String>>(); + + Set<String> types = new HashSet<String>(); + for(int n = 0; n < names.length; n++) + { + if(names[n] != null) + types.add(names[n]); + } + + if(directMap != null) + getOrCreateSet(directMap, baseId).addAll(types); + + if(otherDirectMap != null) + { + Iterator<String> iter = types.iterator(); + while(iter.hasNext()) + getOrCreateSet(otherDirectMap, iter.next()).add(baseId); + } + + map.put(baseId, types); + return map; + } + + private static Set<String> getOrCreateSet(Map<String, Set<String>> map, String key) + { + Set<String> value = map.get(key); + if(value != null) + return value; + + value = new HashSet<String>(); + map.put(key, value); + return value; + } + + private Map<String, Set<String>> explicitInferiors; + private Map<String, Set<String>> explicitSuperiors; + private Map<String, Set<String>> directInferiorsMap; + private Map<String, Set<String>> allInferiors; + private List<String> withoutSuperiors; + + private final List<String> list; + private final Map<String, String[]> allBaseSuperiors; + private final Map<String, String[]> allBaseInferiors; + private final String methodName; + + private static final Set<String> Empty = new HashSet<String>(); +} diff --git a/src/Java/api/player/server/ServerPlayerBaseSorting.java b/src/Java/api/player/server/ServerPlayerBaseSorting.java new file mode 100644 index 0000000000..44ceec35df --- /dev/null +++ b/src/Java/api/player/server/ServerPlayerBaseSorting.java @@ -0,0 +1,3909 @@ +// ================================================================== +// This file is part of Player API. +// +// Player API is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// Player API is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and the GNU General Public License along with Player API. +// If not, see <http://www.gnu.org/licenses/>. +// ================================================================== + +package api.player.server; + +import java.util.*; + +public final class ServerPlayerBaseSorting +{ + private String[] beforeLocalConstructingSuperiors = null; + private String[] beforeLocalConstructingInferiors = null; + private String[] afterLocalConstructingSuperiors = null; + private String[] afterLocalConstructingInferiors = null; + + private Map<String, String[]> dynamicBeforeSuperiors = null; + private Map<String, String[]> dynamicBeforeInferiors = null; + private Map<String, String[]> dynamicOverrideSuperiors = null; + private Map<String, String[]> dynamicOverrideInferiors = null; + private Map<String, String[]> dynamicAfterSuperiors = null; + private Map<String, String[]> dynamicAfterInferiors = null; + + private String[] beforeAddExhaustionSuperiors = null; + private String[] beforeAddExhaustionInferiors = null; + private String[] overrideAddExhaustionSuperiors = null; + private String[] overrideAddExhaustionInferiors = null; + private String[] afterAddExhaustionSuperiors = null; + private String[] afterAddExhaustionInferiors = null; + + private String[] beforeAddExperienceSuperiors = null; + private String[] beforeAddExperienceInferiors = null; + private String[] overrideAddExperienceSuperiors = null; + private String[] overrideAddExperienceInferiors = null; + private String[] afterAddExperienceSuperiors = null; + private String[] afterAddExperienceInferiors = null; + + private String[] beforeAddExperienceLevelSuperiors = null; + private String[] beforeAddExperienceLevelInferiors = null; + private String[] overrideAddExperienceLevelSuperiors = null; + private String[] overrideAddExperienceLevelInferiors = null; + private String[] afterAddExperienceLevelSuperiors = null; + private String[] afterAddExperienceLevelInferiors = null; + + private String[] beforeAddMovementStatSuperiors = null; + private String[] beforeAddMovementStatInferiors = null; + private String[] overrideAddMovementStatSuperiors = null; + private String[] overrideAddMovementStatInferiors = null; + private String[] afterAddMovementStatSuperiors = null; + private String[] afterAddMovementStatInferiors = null; + + private String[] beforeAttackEntityFromSuperiors = null; + private String[] beforeAttackEntityFromInferiors = null; + private String[] overrideAttackEntityFromSuperiors = null; + private String[] overrideAttackEntityFromInferiors = null; + private String[] afterAttackEntityFromSuperiors = null; + private String[] afterAttackEntityFromInferiors = null; + + private String[] beforeAttackTargetEntityWithCurrentItemSuperiors = null; + private String[] beforeAttackTargetEntityWithCurrentItemInferiors = null; + private String[] overrideAttackTargetEntityWithCurrentItemSuperiors = null; + private String[] overrideAttackTargetEntityWithCurrentItemInferiors = null; + private String[] afterAttackTargetEntityWithCurrentItemSuperiors = null; + private String[] afterAttackTargetEntityWithCurrentItemInferiors = null; + + private String[] beforeCanBreatheUnderwaterSuperiors = null; + private String[] beforeCanBreatheUnderwaterInferiors = null; + private String[] overrideCanBreatheUnderwaterSuperiors = null; + private String[] overrideCanBreatheUnderwaterInferiors = null; + private String[] afterCanBreatheUnderwaterSuperiors = null; + private String[] afterCanBreatheUnderwaterInferiors = null; + + private String[] beforeCanHarvestBlockSuperiors = null; + private String[] beforeCanHarvestBlockInferiors = null; + private String[] overrideCanHarvestBlockSuperiors = null; + private String[] overrideCanHarvestBlockInferiors = null; + private String[] afterCanHarvestBlockSuperiors = null; + private String[] afterCanHarvestBlockInferiors = null; + + private String[] beforeCanPlayerEditSuperiors = null; + private String[] beforeCanPlayerEditInferiors = null; + private String[] overrideCanPlayerEditSuperiors = null; + private String[] overrideCanPlayerEditInferiors = null; + private String[] afterCanPlayerEditSuperiors = null; + private String[] afterCanPlayerEditInferiors = null; + + private String[] beforeCanTriggerWalkingSuperiors = null; + private String[] beforeCanTriggerWalkingInferiors = null; + private String[] overrideCanTriggerWalkingSuperiors = null; + private String[] overrideCanTriggerWalkingInferiors = null; + private String[] afterCanTriggerWalkingSuperiors = null; + private String[] afterCanTriggerWalkingInferiors = null; + + private String[] beforeClonePlayerSuperiors = null; + private String[] beforeClonePlayerInferiors = null; + private String[] overrideClonePlayerSuperiors = null; + private String[] overrideClonePlayerInferiors = null; + private String[] afterClonePlayerSuperiors = null; + private String[] afterClonePlayerInferiors = null; + + private String[] beforeDamageEntitySuperiors = null; + private String[] beforeDamageEntityInferiors = null; + private String[] overrideDamageEntitySuperiors = null; + private String[] overrideDamageEntityInferiors = null; + private String[] afterDamageEntitySuperiors = null; + private String[] afterDamageEntityInferiors = null; + + private String[] beforeDisplayGUIChestSuperiors = null; + private String[] beforeDisplayGUIChestInferiors = null; + private String[] overrideDisplayGUIChestSuperiors = null; + private String[] overrideDisplayGUIChestInferiors = null; + private String[] afterDisplayGUIChestSuperiors = null; + private String[] afterDisplayGUIChestInferiors = null; + + private String[] beforeDisplayGUIDispenserSuperiors = null; + private String[] beforeDisplayGUIDispenserInferiors = null; + private String[] overrideDisplayGUIDispenserSuperiors = null; + private String[] overrideDisplayGUIDispenserInferiors = null; + private String[] afterDisplayGUIDispenserSuperiors = null; + private String[] afterDisplayGUIDispenserInferiors = null; + + private String[] beforeDisplayGUIFurnaceSuperiors = null; + private String[] beforeDisplayGUIFurnaceInferiors = null; + private String[] overrideDisplayGUIFurnaceSuperiors = null; + private String[] overrideDisplayGUIFurnaceInferiors = null; + private String[] afterDisplayGUIFurnaceSuperiors = null; + private String[] afterDisplayGUIFurnaceInferiors = null; + + private String[] beforeDisplayGUIWorkbenchSuperiors = null; + private String[] beforeDisplayGUIWorkbenchInferiors = null; + private String[] overrideDisplayGUIWorkbenchSuperiors = null; + private String[] overrideDisplayGUIWorkbenchInferiors = null; + private String[] afterDisplayGUIWorkbenchSuperiors = null; + private String[] afterDisplayGUIWorkbenchInferiors = null; + + private String[] beforeDropOneItemSuperiors = null; + private String[] beforeDropOneItemInferiors = null; + private String[] overrideDropOneItemSuperiors = null; + private String[] overrideDropOneItemInferiors = null; + private String[] afterDropOneItemSuperiors = null; + private String[] afterDropOneItemInferiors = null; + + private String[] beforeDropPlayerItemSuperiors = null; + private String[] beforeDropPlayerItemInferiors = null; + private String[] overrideDropPlayerItemSuperiors = null; + private String[] overrideDropPlayerItemInferiors = null; + private String[] afterDropPlayerItemSuperiors = null; + private String[] afterDropPlayerItemInferiors = null; + + private String[] beforeFallSuperiors = null; + private String[] beforeFallInferiors = null; + private String[] overrideFallSuperiors = null; + private String[] overrideFallInferiors = null; + private String[] afterFallSuperiors = null; + private String[] afterFallInferiors = null; + + private String[] beforeGetAIMoveSpeedSuperiors = null; + private String[] beforeGetAIMoveSpeedInferiors = null; + private String[] overrideGetAIMoveSpeedSuperiors = null; + private String[] overrideGetAIMoveSpeedInferiors = null; + private String[] afterGetAIMoveSpeedSuperiors = null; + private String[] afterGetAIMoveSpeedInferiors = null; + + private String[] beforeGetCurrentPlayerStrVsBlockSuperiors = null; + private String[] beforeGetCurrentPlayerStrVsBlockInferiors = null; + private String[] overrideGetCurrentPlayerStrVsBlockSuperiors = null; + private String[] overrideGetCurrentPlayerStrVsBlockInferiors = null; + private String[] afterGetCurrentPlayerStrVsBlockSuperiors = null; + private String[] afterGetCurrentPlayerStrVsBlockInferiors = null; + + private String[] beforeGetCurrentPlayerStrVsBlockForgeSuperiors = null; + private String[] beforeGetCurrentPlayerStrVsBlockForgeInferiors = null; + private String[] overrideGetCurrentPlayerStrVsBlockForgeSuperiors = null; + private String[] overrideGetCurrentPlayerStrVsBlockForgeInferiors = null; + private String[] afterGetCurrentPlayerStrVsBlockForgeSuperiors = null; + private String[] afterGetCurrentPlayerStrVsBlockForgeInferiors = null; + + private String[] beforeGetDistanceSqSuperiors = null; + private String[] beforeGetDistanceSqInferiors = null; + private String[] overrideGetDistanceSqSuperiors = null; + private String[] overrideGetDistanceSqInferiors = null; + private String[] afterGetDistanceSqSuperiors = null; + private String[] afterGetDistanceSqInferiors = null; + + private String[] beforeGetBrightnessSuperiors = null; + private String[] beforeGetBrightnessInferiors = null; + private String[] overrideGetBrightnessSuperiors = null; + private String[] overrideGetBrightnessInferiors = null; + private String[] afterGetBrightnessSuperiors = null; + private String[] afterGetBrightnessInferiors = null; + + private String[] beforeGetEyeHeightSuperiors = null; + private String[] beforeGetEyeHeightInferiors = null; + private String[] overrideGetEyeHeightSuperiors = null; + private String[] overrideGetEyeHeightInferiors = null; + private String[] afterGetEyeHeightSuperiors = null; + private String[] afterGetEyeHeightInferiors = null; + + private String[] beforeHealSuperiors = null; + private String[] beforeHealInferiors = null; + private String[] overrideHealSuperiors = null; + private String[] overrideHealInferiors = null; + private String[] afterHealSuperiors = null; + private String[] afterHealInferiors = null; + + private String[] beforeIsEntityInsideOpaqueBlockSuperiors = null; + private String[] beforeIsEntityInsideOpaqueBlockInferiors = null; + private String[] overrideIsEntityInsideOpaqueBlockSuperiors = null; + private String[] overrideIsEntityInsideOpaqueBlockInferiors = null; + private String[] afterIsEntityInsideOpaqueBlockSuperiors = null; + private String[] afterIsEntityInsideOpaqueBlockInferiors = null; + + private String[] beforeIsInWaterSuperiors = null; + private String[] beforeIsInWaterInferiors = null; + private String[] overrideIsInWaterSuperiors = null; + private String[] overrideIsInWaterInferiors = null; + private String[] afterIsInWaterSuperiors = null; + private String[] afterIsInWaterInferiors = null; + + private String[] beforeIsInsideOfMaterialSuperiors = null; + private String[] beforeIsInsideOfMaterialInferiors = null; + private String[] overrideIsInsideOfMaterialSuperiors = null; + private String[] overrideIsInsideOfMaterialInferiors = null; + private String[] afterIsInsideOfMaterialSuperiors = null; + private String[] afterIsInsideOfMaterialInferiors = null; + + private String[] beforeIsOnLadderSuperiors = null; + private String[] beforeIsOnLadderInferiors = null; + private String[] overrideIsOnLadderSuperiors = null; + private String[] overrideIsOnLadderInferiors = null; + private String[] afterIsOnLadderSuperiors = null; + private String[] afterIsOnLadderInferiors = null; + + private String[] beforeIsPlayerSleepingSuperiors = null; + private String[] beforeIsPlayerSleepingInferiors = null; + private String[] overrideIsPlayerSleepingSuperiors = null; + private String[] overrideIsPlayerSleepingInferiors = null; + private String[] afterIsPlayerSleepingSuperiors = null; + private String[] afterIsPlayerSleepingInferiors = null; + + private String[] beforeIsSneakingSuperiors = null; + private String[] beforeIsSneakingInferiors = null; + private String[] overrideIsSneakingSuperiors = null; + private String[] overrideIsSneakingInferiors = null; + private String[] afterIsSneakingSuperiors = null; + private String[] afterIsSneakingInferiors = null; + + private String[] beforeJumpSuperiors = null; + private String[] beforeJumpInferiors = null; + private String[] overrideJumpSuperiors = null; + private String[] overrideJumpInferiors = null; + private String[] afterJumpSuperiors = null; + private String[] afterJumpInferiors = null; + + private String[] beforeKnockBackSuperiors = null; + private String[] beforeKnockBackInferiors = null; + private String[] overrideKnockBackSuperiors = null; + private String[] overrideKnockBackInferiors = null; + private String[] afterKnockBackSuperiors = null; + private String[] afterKnockBackInferiors = null; + + private String[] beforeMountEntitySuperiors = null; + private String[] beforeMountEntityInferiors = null; + private String[] overrideMountEntitySuperiors = null; + private String[] overrideMountEntityInferiors = null; + private String[] afterMountEntitySuperiors = null; + private String[] afterMountEntityInferiors = null; + + private String[] beforeMoveEntitySuperiors = null; + private String[] beforeMoveEntityInferiors = null; + private String[] overrideMoveEntitySuperiors = null; + private String[] overrideMoveEntityInferiors = null; + private String[] afterMoveEntitySuperiors = null; + private String[] afterMoveEntityInferiors = null; + + private String[] beforeMoveEntityWithHeadingSuperiors = null; + private String[] beforeMoveEntityWithHeadingInferiors = null; + private String[] overrideMoveEntityWithHeadingSuperiors = null; + private String[] overrideMoveEntityWithHeadingInferiors = null; + private String[] afterMoveEntityWithHeadingSuperiors = null; + private String[] afterMoveEntityWithHeadingInferiors = null; + + private String[] beforeMoveFlyingSuperiors = null; + private String[] beforeMoveFlyingInferiors = null; + private String[] overrideMoveFlyingSuperiors = null; + private String[] overrideMoveFlyingInferiors = null; + private String[] afterMoveFlyingSuperiors = null; + private String[] afterMoveFlyingInferiors = null; + + private String[] beforeOnDeathSuperiors = null; + private String[] beforeOnDeathInferiors = null; + private String[] overrideOnDeathSuperiors = null; + private String[] overrideOnDeathInferiors = null; + private String[] afterOnDeathSuperiors = null; + private String[] afterOnDeathInferiors = null; + + private String[] beforeOnLivingUpdateSuperiors = null; + private String[] beforeOnLivingUpdateInferiors = null; + private String[] overrideOnLivingUpdateSuperiors = null; + private String[] overrideOnLivingUpdateInferiors = null; + private String[] afterOnLivingUpdateSuperiors = null; + private String[] afterOnLivingUpdateInferiors = null; + + private String[] beforeOnKillEntitySuperiors = null; + private String[] beforeOnKillEntityInferiors = null; + private String[] overrideOnKillEntitySuperiors = null; + private String[] overrideOnKillEntityInferiors = null; + private String[] afterOnKillEntitySuperiors = null; + private String[] afterOnKillEntityInferiors = null; + + private String[] beforeOnStruckByLightningSuperiors = null; + private String[] beforeOnStruckByLightningInferiors = null; + private String[] overrideOnStruckByLightningSuperiors = null; + private String[] overrideOnStruckByLightningInferiors = null; + private String[] afterOnStruckByLightningSuperiors = null; + private String[] afterOnStruckByLightningInferiors = null; + + private String[] beforeOnUpdateSuperiors = null; + private String[] beforeOnUpdateInferiors = null; + private String[] overrideOnUpdateSuperiors = null; + private String[] overrideOnUpdateInferiors = null; + private String[] afterOnUpdateSuperiors = null; + private String[] afterOnUpdateInferiors = null; + + private String[] beforeOnUpdateEntitySuperiors = null; + private String[] beforeOnUpdateEntityInferiors = null; + private String[] overrideOnUpdateEntitySuperiors = null; + private String[] overrideOnUpdateEntityInferiors = null; + private String[] afterOnUpdateEntitySuperiors = null; + private String[] afterOnUpdateEntityInferiors = null; + + private String[] beforeReadEntityFromNBTSuperiors = null; + private String[] beforeReadEntityFromNBTInferiors = null; + private String[] overrideReadEntityFromNBTSuperiors = null; + private String[] overrideReadEntityFromNBTInferiors = null; + private String[] afterReadEntityFromNBTSuperiors = null; + private String[] afterReadEntityFromNBTInferiors = null; + + private String[] beforeSetDeadSuperiors = null; + private String[] beforeSetDeadInferiors = null; + private String[] overrideSetDeadSuperiors = null; + private String[] overrideSetDeadInferiors = null; + private String[] afterSetDeadSuperiors = null; + private String[] afterSetDeadInferiors = null; + + private String[] beforeSetEntityActionStateSuperiors = null; + private String[] beforeSetEntityActionStateInferiors = null; + private String[] overrideSetEntityActionStateSuperiors = null; + private String[] overrideSetEntityActionStateInferiors = null; + private String[] afterSetEntityActionStateSuperiors = null; + private String[] afterSetEntityActionStateInferiors = null; + + private String[] beforeSetPositionSuperiors = null; + private String[] beforeSetPositionInferiors = null; + private String[] overrideSetPositionSuperiors = null; + private String[] overrideSetPositionInferiors = null; + private String[] afterSetPositionSuperiors = null; + private String[] afterSetPositionInferiors = null; + + private String[] beforeSetSneakingSuperiors = null; + private String[] beforeSetSneakingInferiors = null; + private String[] overrideSetSneakingSuperiors = null; + private String[] overrideSetSneakingInferiors = null; + private String[] afterSetSneakingSuperiors = null; + private String[] afterSetSneakingInferiors = null; + + private String[] beforeSetSprintingSuperiors = null; + private String[] beforeSetSprintingInferiors = null; + private String[] overrideSetSprintingSuperiors = null; + private String[] overrideSetSprintingInferiors = null; + private String[] afterSetSprintingSuperiors = null; + private String[] afterSetSprintingInferiors = null; + + private String[] beforeSwingItemSuperiors = null; + private String[] beforeSwingItemInferiors = null; + private String[] overrideSwingItemSuperiors = null; + private String[] overrideSwingItemInferiors = null; + private String[] afterSwingItemSuperiors = null; + private String[] afterSwingItemInferiors = null; + + private String[] beforeUpdateEntityActionStateSuperiors = null; + private String[] beforeUpdateEntityActionStateInferiors = null; + private String[] overrideUpdateEntityActionStateSuperiors = null; + private String[] overrideUpdateEntityActionStateInferiors = null; + private String[] afterUpdateEntityActionStateSuperiors = null; + private String[] afterUpdateEntityActionStateInferiors = null; + + private String[] beforeUpdatePotionEffectsSuperiors = null; + private String[] beforeUpdatePotionEffectsInferiors = null; + private String[] overrideUpdatePotionEffectsSuperiors = null; + private String[] overrideUpdatePotionEffectsInferiors = null; + private String[] afterUpdatePotionEffectsSuperiors = null; + private String[] afterUpdatePotionEffectsInferiors = null; + + private String[] beforeUpdateRiddenSuperiors = null; + private String[] beforeUpdateRiddenInferiors = null; + private String[] overrideUpdateRiddenSuperiors = null; + private String[] overrideUpdateRiddenInferiors = null; + private String[] afterUpdateRiddenSuperiors = null; + private String[] afterUpdateRiddenInferiors = null; + + private String[] beforeWakeUpPlayerSuperiors = null; + private String[] beforeWakeUpPlayerInferiors = null; + private String[] overrideWakeUpPlayerSuperiors = null; + private String[] overrideWakeUpPlayerInferiors = null; + private String[] afterWakeUpPlayerSuperiors = null; + private String[] afterWakeUpPlayerInferiors = null; + + private String[] beforeWriteEntityToNBTSuperiors = null; + private String[] beforeWriteEntityToNBTInferiors = null; + private String[] overrideWriteEntityToNBTSuperiors = null; + private String[] overrideWriteEntityToNBTInferiors = null; + private String[] afterWriteEntityToNBTSuperiors = null; + private String[] afterWriteEntityToNBTInferiors = null; + + + public String[] getBeforeLocalConstructingSuperiors() + { + return beforeLocalConstructingSuperiors; + } + + public String[] getBeforeLocalConstructingInferiors() + { + return beforeLocalConstructingInferiors; + } + + public String[] getAfterLocalConstructingSuperiors() + { + return afterLocalConstructingSuperiors; + } + + public String[] getAfterLocalConstructingInferiors() + { + return afterLocalConstructingInferiors; + } + + public void setBeforeLocalConstructingSuperiors(String[] value) + { + beforeLocalConstructingSuperiors = value; + } + + public void setBeforeLocalConstructingInferiors(String[] value) + { + beforeLocalConstructingInferiors = value; + } + + public void setAfterLocalConstructingSuperiors(String[] value) + { + afterLocalConstructingSuperiors = value; + } + + public void setAfterLocalConstructingInferiors(String[] value) + { + afterLocalConstructingInferiors = value; + } + + public Map<String, String[]> getDynamicBeforeSuperiors() + { + return dynamicBeforeSuperiors; + } + + public Map<String, String[]> getDynamicBeforeInferiors() + { + return dynamicBeforeInferiors; + } + + public Map<String, String[]> getDynamicOverrideSuperiors() + { + return dynamicOverrideSuperiors; + } + + public Map<String, String[]> getDynamicOverrideInferiors() + { + return dynamicOverrideInferiors; + } + + public Map<String, String[]> getDynamicAfterSuperiors() + { + return dynamicAfterSuperiors; + } + + public Map<String, String[]> getDynamicAfterInferiors() + { + return dynamicAfterInferiors; + } + + public void setDynamicBeforeSuperiors(String name, String[] superiors) + { + dynamicBeforeSuperiors = setDynamic(name, superiors, dynamicBeforeSuperiors); + } + + public void setDynamicBeforeInferiors(String name, String[] inferiors) + { + dynamicBeforeInferiors = setDynamic(name, inferiors, dynamicBeforeInferiors); + } + + public void setDynamicOverrideSuperiors(String name, String[] superiors) + { + dynamicOverrideSuperiors = setDynamic(name, superiors, dynamicOverrideSuperiors); + } + + public void setDynamicOverrideInferiors(String name, String[] inferiors) + { + dynamicOverrideInferiors = setDynamic(name, inferiors, dynamicOverrideInferiors); + } + + public void setDynamicAfterSuperiors(String name, String[] superiors) + { + dynamicAfterSuperiors = setDynamic(name, superiors, dynamicAfterSuperiors); + } + + public void setDynamicAfterInferiors(String name, String[] inferiors) + { + dynamicAfterInferiors = setDynamic(name, inferiors, dynamicAfterInferiors); + } + + private Map<String, String[]> setDynamic(String name, String[] names, Map<String, String[]> map) + { + if(name == null) + throw new IllegalArgumentException("Parameter 'name' may not be null"); + + if(names == null) + { + if(map != null) + map.remove(name); + return map; + } + + if(map == null) + map = new HashMap<String, String[]>(); + map.put(name, names); + + return map; + } + + public String[] getBeforeAddExhaustionSuperiors() + { + return beforeAddExhaustionSuperiors; + } + + public String[] getBeforeAddExhaustionInferiors() + { + return beforeAddExhaustionInferiors; + } + + public String[] getOverrideAddExhaustionSuperiors() + { + return overrideAddExhaustionSuperiors; + } + + public String[] getOverrideAddExhaustionInferiors() + { + return overrideAddExhaustionInferiors; + } + + public String[] getAfterAddExhaustionSuperiors() + { + return afterAddExhaustionSuperiors; + } + + public String[] getAfterAddExhaustionInferiors() + { + return afterAddExhaustionInferiors; + } + + public void setBeforeAddExhaustionSuperiors(String[] value) + { + beforeAddExhaustionSuperiors = value; + } + + public void setBeforeAddExhaustionInferiors(String[] value) + { + beforeAddExhaustionInferiors = value; + } + + public void setOverrideAddExhaustionSuperiors(String[] value) + { + overrideAddExhaustionSuperiors = value; + } + + public void setOverrideAddExhaustionInferiors(String[] value) + { + overrideAddExhaustionInferiors = value; + } + + public void setAfterAddExhaustionSuperiors(String[] value) + { + afterAddExhaustionSuperiors = value; + } + + public void setAfterAddExhaustionInferiors(String[] value) + { + afterAddExhaustionInferiors = value; + } + + public String[] getBeforeAddExperienceSuperiors() + { + return beforeAddExperienceSuperiors; + } + + public String[] getBeforeAddExperienceInferiors() + { + return beforeAddExperienceInferiors; + } + + public String[] getOverrideAddExperienceSuperiors() + { + return overrideAddExperienceSuperiors; + } + + public String[] getOverrideAddExperienceInferiors() + { + return overrideAddExperienceInferiors; + } + + public String[] getAfterAddExperienceSuperiors() + { + return afterAddExperienceSuperiors; + } + + public String[] getAfterAddExperienceInferiors() + { + return afterAddExperienceInferiors; + } + + public void setBeforeAddExperienceSuperiors(String[] value) + { + beforeAddExperienceSuperiors = value; + } + + public void setBeforeAddExperienceInferiors(String[] value) + { + beforeAddExperienceInferiors = value; + } + + public void setOverrideAddExperienceSuperiors(String[] value) + { + overrideAddExperienceSuperiors = value; + } + + public void setOverrideAddExperienceInferiors(String[] value) + { + overrideAddExperienceInferiors = value; + } + + public void setAfterAddExperienceSuperiors(String[] value) + { + afterAddExperienceSuperiors = value; + } + + public void setAfterAddExperienceInferiors(String[] value) + { + afterAddExperienceInferiors = value; + } + + public String[] getBeforeAddExperienceLevelSuperiors() + { + return beforeAddExperienceLevelSuperiors; + } + + public String[] getBeforeAddExperienceLevelInferiors() + { + return beforeAddExperienceLevelInferiors; + } + + public String[] getOverrideAddExperienceLevelSuperiors() + { + return overrideAddExperienceLevelSuperiors; + } + + public String[] getOverrideAddExperienceLevelInferiors() + { + return overrideAddExperienceLevelInferiors; + } + + public String[] getAfterAddExperienceLevelSuperiors() + { + return afterAddExperienceLevelSuperiors; + } + + public String[] getAfterAddExperienceLevelInferiors() + { + return afterAddExperienceLevelInferiors; + } + + public void setBeforeAddExperienceLevelSuperiors(String[] value) + { + beforeAddExperienceLevelSuperiors = value; + } + + public void setBeforeAddExperienceLevelInferiors(String[] value) + { + beforeAddExperienceLevelInferiors = value; + } + + public void setOverrideAddExperienceLevelSuperiors(String[] value) + { + overrideAddExperienceLevelSuperiors = value; + } + + public void setOverrideAddExperienceLevelInferiors(String[] value) + { + overrideAddExperienceLevelInferiors = value; + } + + public void setAfterAddExperienceLevelSuperiors(String[] value) + { + afterAddExperienceLevelSuperiors = value; + } + + public void setAfterAddExperienceLevelInferiors(String[] value) + { + afterAddExperienceLevelInferiors = value; + } + + public String[] getBeforeAddMovementStatSuperiors() + { + return beforeAddMovementStatSuperiors; + } + + public String[] getBeforeAddMovementStatInferiors() + { + return beforeAddMovementStatInferiors; + } + + public String[] getOverrideAddMovementStatSuperiors() + { + return overrideAddMovementStatSuperiors; + } + + public String[] getOverrideAddMovementStatInferiors() + { + return overrideAddMovementStatInferiors; + } + + public String[] getAfterAddMovementStatSuperiors() + { + return afterAddMovementStatSuperiors; + } + + public String[] getAfterAddMovementStatInferiors() + { + return afterAddMovementStatInferiors; + } + + public void setBeforeAddMovementStatSuperiors(String[] value) + { + beforeAddMovementStatSuperiors = value; + } + + public void setBeforeAddMovementStatInferiors(String[] value) + { + beforeAddMovementStatInferiors = value; + } + + public void setOverrideAddMovementStatSuperiors(String[] value) + { + overrideAddMovementStatSuperiors = value; + } + + public void setOverrideAddMovementStatInferiors(String[] value) + { + overrideAddMovementStatInferiors = value; + } + + public void setAfterAddMovementStatSuperiors(String[] value) + { + afterAddMovementStatSuperiors = value; + } + + public void setAfterAddMovementStatInferiors(String[] value) + { + afterAddMovementStatInferiors = value; + } + + public String[] getBeforeAttackEntityFromSuperiors() + { + return beforeAttackEntityFromSuperiors; + } + + public String[] getBeforeAttackEntityFromInferiors() + { + return beforeAttackEntityFromInferiors; + } + + public String[] getOverrideAttackEntityFromSuperiors() + { + return overrideAttackEntityFromSuperiors; + } + + public String[] getOverrideAttackEntityFromInferiors() + { + return overrideAttackEntityFromInferiors; + } + + public String[] getAfterAttackEntityFromSuperiors() + { + return afterAttackEntityFromSuperiors; + } + + public String[] getAfterAttackEntityFromInferiors() + { + return afterAttackEntityFromInferiors; + } + + public void setBeforeAttackEntityFromSuperiors(String[] value) + { + beforeAttackEntityFromSuperiors = value; + } + + public void setBeforeAttackEntityFromInferiors(String[] value) + { + beforeAttackEntityFromInferiors = value; + } + + public void setOverrideAttackEntityFromSuperiors(String[] value) + { + overrideAttackEntityFromSuperiors = value; + } + + public void setOverrideAttackEntityFromInferiors(String[] value) + { + overrideAttackEntityFromInferiors = value; + } + + public void setAfterAttackEntityFromSuperiors(String[] value) + { + afterAttackEntityFromSuperiors = value; + } + + public void setAfterAttackEntityFromInferiors(String[] value) + { + afterAttackEntityFromInferiors = value; + } + + public String[] getBeforeAttackTargetEntityWithCurrentItemSuperiors() + { + return beforeAttackTargetEntityWithCurrentItemSuperiors; + } + + public String[] getBeforeAttackTargetEntityWithCurrentItemInferiors() + { + return beforeAttackTargetEntityWithCurrentItemInferiors; + } + + public String[] getOverrideAttackTargetEntityWithCurrentItemSuperiors() + { + return overrideAttackTargetEntityWithCurrentItemSuperiors; + } + + public String[] getOverrideAttackTargetEntityWithCurrentItemInferiors() + { + return overrideAttackTargetEntityWithCurrentItemInferiors; + } + + public String[] getAfterAttackTargetEntityWithCurrentItemSuperiors() + { + return afterAttackTargetEntityWithCurrentItemSuperiors; + } + + public String[] getAfterAttackTargetEntityWithCurrentItemInferiors() + { + return afterAttackTargetEntityWithCurrentItemInferiors; + } + + public void setBeforeAttackTargetEntityWithCurrentItemSuperiors(String[] value) + { + beforeAttackTargetEntityWithCurrentItemSuperiors = value; + } + + public void setBeforeAttackTargetEntityWithCurrentItemInferiors(String[] value) + { + beforeAttackTargetEntityWithCurrentItemInferiors = value; + } + + public void setOverrideAttackTargetEntityWithCurrentItemSuperiors(String[] value) + { + overrideAttackTargetEntityWithCurrentItemSuperiors = value; + } + + public void setOverrideAttackTargetEntityWithCurrentItemInferiors(String[] value) + { + overrideAttackTargetEntityWithCurrentItemInferiors = value; + } + + public void setAfterAttackTargetEntityWithCurrentItemSuperiors(String[] value) + { + afterAttackTargetEntityWithCurrentItemSuperiors = value; + } + + public void setAfterAttackTargetEntityWithCurrentItemInferiors(String[] value) + { + afterAttackTargetEntityWithCurrentItemInferiors = value; + } + + public String[] getBeforeCanBreatheUnderwaterSuperiors() + { + return beforeCanBreatheUnderwaterSuperiors; + } + + public String[] getBeforeCanBreatheUnderwaterInferiors() + { + return beforeCanBreatheUnderwaterInferiors; + } + + public String[] getOverrideCanBreatheUnderwaterSuperiors() + { + return overrideCanBreatheUnderwaterSuperiors; + } + + public String[] getOverrideCanBreatheUnderwaterInferiors() + { + return overrideCanBreatheUnderwaterInferiors; + } + + public String[] getAfterCanBreatheUnderwaterSuperiors() + { + return afterCanBreatheUnderwaterSuperiors; + } + + public String[] getAfterCanBreatheUnderwaterInferiors() + { + return afterCanBreatheUnderwaterInferiors; + } + + public void setBeforeCanBreatheUnderwaterSuperiors(String[] value) + { + beforeCanBreatheUnderwaterSuperiors = value; + } + + public void setBeforeCanBreatheUnderwaterInferiors(String[] value) + { + beforeCanBreatheUnderwaterInferiors = value; + } + + public void setOverrideCanBreatheUnderwaterSuperiors(String[] value) + { + overrideCanBreatheUnderwaterSuperiors = value; + } + + public void setOverrideCanBreatheUnderwaterInferiors(String[] value) + { + overrideCanBreatheUnderwaterInferiors = value; + } + + public void setAfterCanBreatheUnderwaterSuperiors(String[] value) + { + afterCanBreatheUnderwaterSuperiors = value; + } + + public void setAfterCanBreatheUnderwaterInferiors(String[] value) + { + afterCanBreatheUnderwaterInferiors = value; + } + + public String[] getBeforeCanHarvestBlockSuperiors() + { + return beforeCanHarvestBlockSuperiors; + } + + public String[] getBeforeCanHarvestBlockInferiors() + { + return beforeCanHarvestBlockInferiors; + } + + public String[] getOverrideCanHarvestBlockSuperiors() + { + return overrideCanHarvestBlockSuperiors; + } + + public String[] getOverrideCanHarvestBlockInferiors() + { + return overrideCanHarvestBlockInferiors; + } + + public String[] getAfterCanHarvestBlockSuperiors() + { + return afterCanHarvestBlockSuperiors; + } + + public String[] getAfterCanHarvestBlockInferiors() + { + return afterCanHarvestBlockInferiors; + } + + public void setBeforeCanHarvestBlockSuperiors(String[] value) + { + beforeCanHarvestBlockSuperiors = value; + } + + public void setBeforeCanHarvestBlockInferiors(String[] value) + { + beforeCanHarvestBlockInferiors = value; + } + + public void setOverrideCanHarvestBlockSuperiors(String[] value) + { + overrideCanHarvestBlockSuperiors = value; + } + + public void setOverrideCanHarvestBlockInferiors(String[] value) + { + overrideCanHarvestBlockInferiors = value; + } + + public void setAfterCanHarvestBlockSuperiors(String[] value) + { + afterCanHarvestBlockSuperiors = value; + } + + public void setAfterCanHarvestBlockInferiors(String[] value) + { + afterCanHarvestBlockInferiors = value; + } + + public String[] getBeforeCanPlayerEditSuperiors() + { + return beforeCanPlayerEditSuperiors; + } + + public String[] getBeforeCanPlayerEditInferiors() + { + return beforeCanPlayerEditInferiors; + } + + public String[] getOverrideCanPlayerEditSuperiors() + { + return overrideCanPlayerEditSuperiors; + } + + public String[] getOverrideCanPlayerEditInferiors() + { + return overrideCanPlayerEditInferiors; + } + + public String[] getAfterCanPlayerEditSuperiors() + { + return afterCanPlayerEditSuperiors; + } + + public String[] getAfterCanPlayerEditInferiors() + { + return afterCanPlayerEditInferiors; + } + + public void setBeforeCanPlayerEditSuperiors(String[] value) + { + beforeCanPlayerEditSuperiors = value; + } + + public void setBeforeCanPlayerEditInferiors(String[] value) + { + beforeCanPlayerEditInferiors = value; + } + + public void setOverrideCanPlayerEditSuperiors(String[] value) + { + overrideCanPlayerEditSuperiors = value; + } + + public void setOverrideCanPlayerEditInferiors(String[] value) + { + overrideCanPlayerEditInferiors = value; + } + + public void setAfterCanPlayerEditSuperiors(String[] value) + { + afterCanPlayerEditSuperiors = value; + } + + public void setAfterCanPlayerEditInferiors(String[] value) + { + afterCanPlayerEditInferiors = value; + } + + public String[] getBeforeCanTriggerWalkingSuperiors() + { + return beforeCanTriggerWalkingSuperiors; + } + + public String[] getBeforeCanTriggerWalkingInferiors() + { + return beforeCanTriggerWalkingInferiors; + } + + public String[] getOverrideCanTriggerWalkingSuperiors() + { + return overrideCanTriggerWalkingSuperiors; + } + + public String[] getOverrideCanTriggerWalkingInferiors() + { + return overrideCanTriggerWalkingInferiors; + } + + public String[] getAfterCanTriggerWalkingSuperiors() + { + return afterCanTriggerWalkingSuperiors; + } + + public String[] getAfterCanTriggerWalkingInferiors() + { + return afterCanTriggerWalkingInferiors; + } + + public void setBeforeCanTriggerWalkingSuperiors(String[] value) + { + beforeCanTriggerWalkingSuperiors = value; + } + + public void setBeforeCanTriggerWalkingInferiors(String[] value) + { + beforeCanTriggerWalkingInferiors = value; + } + + public void setOverrideCanTriggerWalkingSuperiors(String[] value) + { + overrideCanTriggerWalkingSuperiors = value; + } + + public void setOverrideCanTriggerWalkingInferiors(String[] value) + { + overrideCanTriggerWalkingInferiors = value; + } + + public void setAfterCanTriggerWalkingSuperiors(String[] value) + { + afterCanTriggerWalkingSuperiors = value; + } + + public void setAfterCanTriggerWalkingInferiors(String[] value) + { + afterCanTriggerWalkingInferiors = value; + } + + public String[] getBeforeClonePlayerSuperiors() + { + return beforeClonePlayerSuperiors; + } + + public String[] getBeforeClonePlayerInferiors() + { + return beforeClonePlayerInferiors; + } + + public String[] getOverrideClonePlayerSuperiors() + { + return overrideClonePlayerSuperiors; + } + + public String[] getOverrideClonePlayerInferiors() + { + return overrideClonePlayerInferiors; + } + + public String[] getAfterClonePlayerSuperiors() + { + return afterClonePlayerSuperiors; + } + + public String[] getAfterClonePlayerInferiors() + { + return afterClonePlayerInferiors; + } + + public void setBeforeClonePlayerSuperiors(String[] value) + { + beforeClonePlayerSuperiors = value; + } + + public void setBeforeClonePlayerInferiors(String[] value) + { + beforeClonePlayerInferiors = value; + } + + public void setOverrideClonePlayerSuperiors(String[] value) + { + overrideClonePlayerSuperiors = value; + } + + public void setOverrideClonePlayerInferiors(String[] value) + { + overrideClonePlayerInferiors = value; + } + + public void setAfterClonePlayerSuperiors(String[] value) + { + afterClonePlayerSuperiors = value; + } + + public void setAfterClonePlayerInferiors(String[] value) + { + afterClonePlayerInferiors = value; + } + + public String[] getBeforeDamageEntitySuperiors() + { + return beforeDamageEntitySuperiors; + } + + public String[] getBeforeDamageEntityInferiors() + { + return beforeDamageEntityInferiors; + } + + public String[] getOverrideDamageEntitySuperiors() + { + return overrideDamageEntitySuperiors; + } + + public String[] getOverrideDamageEntityInferiors() + { + return overrideDamageEntityInferiors; + } + + public String[] getAfterDamageEntitySuperiors() + { + return afterDamageEntitySuperiors; + } + + public String[] getAfterDamageEntityInferiors() + { + return afterDamageEntityInferiors; + } + + public void setBeforeDamageEntitySuperiors(String[] value) + { + beforeDamageEntitySuperiors = value; + } + + public void setBeforeDamageEntityInferiors(String[] value) + { + beforeDamageEntityInferiors = value; + } + + public void setOverrideDamageEntitySuperiors(String[] value) + { + overrideDamageEntitySuperiors = value; + } + + public void setOverrideDamageEntityInferiors(String[] value) + { + overrideDamageEntityInferiors = value; + } + + public void setAfterDamageEntitySuperiors(String[] value) + { + afterDamageEntitySuperiors = value; + } + + public void setAfterDamageEntityInferiors(String[] value) + { + afterDamageEntityInferiors = value; + } + + public String[] getBeforeDisplayGUIChestSuperiors() + { + return beforeDisplayGUIChestSuperiors; + } + + public String[] getBeforeDisplayGUIChestInferiors() + { + return beforeDisplayGUIChestInferiors; + } + + public String[] getOverrideDisplayGUIChestSuperiors() + { + return overrideDisplayGUIChestSuperiors; + } + + public String[] getOverrideDisplayGUIChestInferiors() + { + return overrideDisplayGUIChestInferiors; + } + + public String[] getAfterDisplayGUIChestSuperiors() + { + return afterDisplayGUIChestSuperiors; + } + + public String[] getAfterDisplayGUIChestInferiors() + { + return afterDisplayGUIChestInferiors; + } + + public void setBeforeDisplayGUIChestSuperiors(String[] value) + { + beforeDisplayGUIChestSuperiors = value; + } + + public void setBeforeDisplayGUIChestInferiors(String[] value) + { + beforeDisplayGUIChestInferiors = value; + } + + public void setOverrideDisplayGUIChestSuperiors(String[] value) + { + overrideDisplayGUIChestSuperiors = value; + } + + public void setOverrideDisplayGUIChestInferiors(String[] value) + { + overrideDisplayGUIChestInferiors = value; + } + + public void setAfterDisplayGUIChestSuperiors(String[] value) + { + afterDisplayGUIChestSuperiors = value; + } + + public void setAfterDisplayGUIChestInferiors(String[] value) + { + afterDisplayGUIChestInferiors = value; + } + + public String[] getBeforeDisplayGUIDispenserSuperiors() + { + return beforeDisplayGUIDispenserSuperiors; + } + + public String[] getBeforeDisplayGUIDispenserInferiors() + { + return beforeDisplayGUIDispenserInferiors; + } + + public String[] getOverrideDisplayGUIDispenserSuperiors() + { + return overrideDisplayGUIDispenserSuperiors; + } + + public String[] getOverrideDisplayGUIDispenserInferiors() + { + return overrideDisplayGUIDispenserInferiors; + } + + public String[] getAfterDisplayGUIDispenserSuperiors() + { + return afterDisplayGUIDispenserSuperiors; + } + + public String[] getAfterDisplayGUIDispenserInferiors() + { + return afterDisplayGUIDispenserInferiors; + } + + public void setBeforeDisplayGUIDispenserSuperiors(String[] value) + { + beforeDisplayGUIDispenserSuperiors = value; + } + + public void setBeforeDisplayGUIDispenserInferiors(String[] value) + { + beforeDisplayGUIDispenserInferiors = value; + } + + public void setOverrideDisplayGUIDispenserSuperiors(String[] value) + { + overrideDisplayGUIDispenserSuperiors = value; + } + + public void setOverrideDisplayGUIDispenserInferiors(String[] value) + { + overrideDisplayGUIDispenserInferiors = value; + } + + public void setAfterDisplayGUIDispenserSuperiors(String[] value) + { + afterDisplayGUIDispenserSuperiors = value; + } + + public void setAfterDisplayGUIDispenserInferiors(String[] value) + { + afterDisplayGUIDispenserInferiors = value; + } + + public String[] getBeforeDisplayGUIFurnaceSuperiors() + { + return beforeDisplayGUIFurnaceSuperiors; + } + + public String[] getBeforeDisplayGUIFurnaceInferiors() + { + return beforeDisplayGUIFurnaceInferiors; + } + + public String[] getOverrideDisplayGUIFurnaceSuperiors() + { + return overrideDisplayGUIFurnaceSuperiors; + } + + public String[] getOverrideDisplayGUIFurnaceInferiors() + { + return overrideDisplayGUIFurnaceInferiors; + } + + public String[] getAfterDisplayGUIFurnaceSuperiors() + { + return afterDisplayGUIFurnaceSuperiors; + } + + public String[] getAfterDisplayGUIFurnaceInferiors() + { + return afterDisplayGUIFurnaceInferiors; + } + + public void setBeforeDisplayGUIFurnaceSuperiors(String[] value) + { + beforeDisplayGUIFurnaceSuperiors = value; + } + + public void setBeforeDisplayGUIFurnaceInferiors(String[] value) + { + beforeDisplayGUIFurnaceInferiors = value; + } + + public void setOverrideDisplayGUIFurnaceSuperiors(String[] value) + { + overrideDisplayGUIFurnaceSuperiors = value; + } + + public void setOverrideDisplayGUIFurnaceInferiors(String[] value) + { + overrideDisplayGUIFurnaceInferiors = value; + } + + public void setAfterDisplayGUIFurnaceSuperiors(String[] value) + { + afterDisplayGUIFurnaceSuperiors = value; + } + + public void setAfterDisplayGUIFurnaceInferiors(String[] value) + { + afterDisplayGUIFurnaceInferiors = value; + } + + public String[] getBeforeDisplayGUIWorkbenchSuperiors() + { + return beforeDisplayGUIWorkbenchSuperiors; + } + + public String[] getBeforeDisplayGUIWorkbenchInferiors() + { + return beforeDisplayGUIWorkbenchInferiors; + } + + public String[] getOverrideDisplayGUIWorkbenchSuperiors() + { + return overrideDisplayGUIWorkbenchSuperiors; + } + + public String[] getOverrideDisplayGUIWorkbenchInferiors() + { + return overrideDisplayGUIWorkbenchInferiors; + } + + public String[] getAfterDisplayGUIWorkbenchSuperiors() + { + return afterDisplayGUIWorkbenchSuperiors; + } + + public String[] getAfterDisplayGUIWorkbenchInferiors() + { + return afterDisplayGUIWorkbenchInferiors; + } + + public void setBeforeDisplayGUIWorkbenchSuperiors(String[] value) + { + beforeDisplayGUIWorkbenchSuperiors = value; + } + + public void setBeforeDisplayGUIWorkbenchInferiors(String[] value) + { + beforeDisplayGUIWorkbenchInferiors = value; + } + + public void setOverrideDisplayGUIWorkbenchSuperiors(String[] value) + { + overrideDisplayGUIWorkbenchSuperiors = value; + } + + public void setOverrideDisplayGUIWorkbenchInferiors(String[] value) + { + overrideDisplayGUIWorkbenchInferiors = value; + } + + public void setAfterDisplayGUIWorkbenchSuperiors(String[] value) + { + afterDisplayGUIWorkbenchSuperiors = value; + } + + public void setAfterDisplayGUIWorkbenchInferiors(String[] value) + { + afterDisplayGUIWorkbenchInferiors = value; + } + + public String[] getBeforeDropOneItemSuperiors() + { + return beforeDropOneItemSuperiors; + } + + public String[] getBeforeDropOneItemInferiors() + { + return beforeDropOneItemInferiors; + } + + public String[] getOverrideDropOneItemSuperiors() + { + return overrideDropOneItemSuperiors; + } + + public String[] getOverrideDropOneItemInferiors() + { + return overrideDropOneItemInferiors; + } + + public String[] getAfterDropOneItemSuperiors() + { + return afterDropOneItemSuperiors; + } + + public String[] getAfterDropOneItemInferiors() + { + return afterDropOneItemInferiors; + } + + public void setBeforeDropOneItemSuperiors(String[] value) + { + beforeDropOneItemSuperiors = value; + } + + public void setBeforeDropOneItemInferiors(String[] value) + { + beforeDropOneItemInferiors = value; + } + + public void setOverrideDropOneItemSuperiors(String[] value) + { + overrideDropOneItemSuperiors = value; + } + + public void setOverrideDropOneItemInferiors(String[] value) + { + overrideDropOneItemInferiors = value; + } + + public void setAfterDropOneItemSuperiors(String[] value) + { + afterDropOneItemSuperiors = value; + } + + public void setAfterDropOneItemInferiors(String[] value) + { + afterDropOneItemInferiors = value; + } + + public String[] getBeforeDropPlayerItemSuperiors() + { + return beforeDropPlayerItemSuperiors; + } + + public String[] getBeforeDropPlayerItemInferiors() + { + return beforeDropPlayerItemInferiors; + } + + public String[] getOverrideDropPlayerItemSuperiors() + { + return overrideDropPlayerItemSuperiors; + } + + public String[] getOverrideDropPlayerItemInferiors() + { + return overrideDropPlayerItemInferiors; + } + + public String[] getAfterDropPlayerItemSuperiors() + { + return afterDropPlayerItemSuperiors; + } + + public String[] getAfterDropPlayerItemInferiors() + { + return afterDropPlayerItemInferiors; + } + + public void setBeforeDropPlayerItemSuperiors(String[] value) + { + beforeDropPlayerItemSuperiors = value; + } + + public void setBeforeDropPlayerItemInferiors(String[] value) + { + beforeDropPlayerItemInferiors = value; + } + + public void setOverrideDropPlayerItemSuperiors(String[] value) + { + overrideDropPlayerItemSuperiors = value; + } + + public void setOverrideDropPlayerItemInferiors(String[] value) + { + overrideDropPlayerItemInferiors = value; + } + + public void setAfterDropPlayerItemSuperiors(String[] value) + { + afterDropPlayerItemSuperiors = value; + } + + public void setAfterDropPlayerItemInferiors(String[] value) + { + afterDropPlayerItemInferiors = value; + } + + public String[] getBeforeFallSuperiors() + { + return beforeFallSuperiors; + } + + public String[] getBeforeFallInferiors() + { + return beforeFallInferiors; + } + + public String[] getOverrideFallSuperiors() + { + return overrideFallSuperiors; + } + + public String[] getOverrideFallInferiors() + { + return overrideFallInferiors; + } + + public String[] getAfterFallSuperiors() + { + return afterFallSuperiors; + } + + public String[] getAfterFallInferiors() + { + return afterFallInferiors; + } + + public void setBeforeFallSuperiors(String[] value) + { + beforeFallSuperiors = value; + } + + public void setBeforeFallInferiors(String[] value) + { + beforeFallInferiors = value; + } + + public void setOverrideFallSuperiors(String[] value) + { + overrideFallSuperiors = value; + } + + public void setOverrideFallInferiors(String[] value) + { + overrideFallInferiors = value; + } + + public void setAfterFallSuperiors(String[] value) + { + afterFallSuperiors = value; + } + + public void setAfterFallInferiors(String[] value) + { + afterFallInferiors = value; + } + + public String[] getBeforeGetAIMoveSpeedSuperiors() + { + return beforeGetAIMoveSpeedSuperiors; + } + + public String[] getBeforeGetAIMoveSpeedInferiors() + { + return beforeGetAIMoveSpeedInferiors; + } + + public String[] getOverrideGetAIMoveSpeedSuperiors() + { + return overrideGetAIMoveSpeedSuperiors; + } + + public String[] getOverrideGetAIMoveSpeedInferiors() + { + return overrideGetAIMoveSpeedInferiors; + } + + public String[] getAfterGetAIMoveSpeedSuperiors() + { + return afterGetAIMoveSpeedSuperiors; + } + + public String[] getAfterGetAIMoveSpeedInferiors() + { + return afterGetAIMoveSpeedInferiors; + } + + public void setBeforeGetAIMoveSpeedSuperiors(String[] value) + { + beforeGetAIMoveSpeedSuperiors = value; + } + + public void setBeforeGetAIMoveSpeedInferiors(String[] value) + { + beforeGetAIMoveSpeedInferiors = value; + } + + public void setOverrideGetAIMoveSpeedSuperiors(String[] value) + { + overrideGetAIMoveSpeedSuperiors = value; + } + + public void setOverrideGetAIMoveSpeedInferiors(String[] value) + { + overrideGetAIMoveSpeedInferiors = value; + } + + public void setAfterGetAIMoveSpeedSuperiors(String[] value) + { + afterGetAIMoveSpeedSuperiors = value; + } + + public void setAfterGetAIMoveSpeedInferiors(String[] value) + { + afterGetAIMoveSpeedInferiors = value; + } + + public String[] getBeforeGetCurrentPlayerStrVsBlockSuperiors() + { + return beforeGetCurrentPlayerStrVsBlockSuperiors; + } + + public String[] getBeforeGetCurrentPlayerStrVsBlockInferiors() + { + return beforeGetCurrentPlayerStrVsBlockInferiors; + } + + public String[] getOverrideGetCurrentPlayerStrVsBlockSuperiors() + { + return overrideGetCurrentPlayerStrVsBlockSuperiors; + } + + public String[] getOverrideGetCurrentPlayerStrVsBlockInferiors() + { + return overrideGetCurrentPlayerStrVsBlockInferiors; + } + + public String[] getAfterGetCurrentPlayerStrVsBlockSuperiors() + { + return afterGetCurrentPlayerStrVsBlockSuperiors; + } + + public String[] getAfterGetCurrentPlayerStrVsBlockInferiors() + { + return afterGetCurrentPlayerStrVsBlockInferiors; + } + + public void setBeforeGetCurrentPlayerStrVsBlockSuperiors(String[] value) + { + beforeGetCurrentPlayerStrVsBlockSuperiors = value; + } + + public void setBeforeGetCurrentPlayerStrVsBlockInferiors(String[] value) + { + beforeGetCurrentPlayerStrVsBlockInferiors = value; + } + + public void setOverrideGetCurrentPlayerStrVsBlockSuperiors(String[] value) + { + overrideGetCurrentPlayerStrVsBlockSuperiors = value; + } + + public void setOverrideGetCurrentPlayerStrVsBlockInferiors(String[] value) + { + overrideGetCurrentPlayerStrVsBlockInferiors = value; + } + + public void setAfterGetCurrentPlayerStrVsBlockSuperiors(String[] value) + { + afterGetCurrentPlayerStrVsBlockSuperiors = value; + } + + public void setAfterGetCurrentPlayerStrVsBlockInferiors(String[] value) + { + afterGetCurrentPlayerStrVsBlockInferiors = value; + } + + public String[] getBeforeGetCurrentPlayerStrVsBlockForgeSuperiors() + { + return beforeGetCurrentPlayerStrVsBlockForgeSuperiors; + } + + public String[] getBeforeGetCurrentPlayerStrVsBlockForgeInferiors() + { + return beforeGetCurrentPlayerStrVsBlockForgeInferiors; + } + + public String[] getOverrideGetCurrentPlayerStrVsBlockForgeSuperiors() + { + return overrideGetCurrentPlayerStrVsBlockForgeSuperiors; + } + + public String[] getOverrideGetCurrentPlayerStrVsBlockForgeInferiors() + { + return overrideGetCurrentPlayerStrVsBlockForgeInferiors; + } + + public String[] getAfterGetCurrentPlayerStrVsBlockForgeSuperiors() + { + return afterGetCurrentPlayerStrVsBlockForgeSuperiors; + } + + public String[] getAfterGetCurrentPlayerStrVsBlockForgeInferiors() + { + return afterGetCurrentPlayerStrVsBlockForgeInferiors; + } + + public void setBeforeGetCurrentPlayerStrVsBlockForgeSuperiors(String[] value) + { + beforeGetCurrentPlayerStrVsBlockForgeSuperiors = value; + } + + public void setBeforeGetCurrentPlayerStrVsBlockForgeInferiors(String[] value) + { + beforeGetCurrentPlayerStrVsBlockForgeInferiors = value; + } + + public void setOverrideGetCurrentPlayerStrVsBlockForgeSuperiors(String[] value) + { + overrideGetCurrentPlayerStrVsBlockForgeSuperiors = value; + } + + public void setOverrideGetCurrentPlayerStrVsBlockForgeInferiors(String[] value) + { + overrideGetCurrentPlayerStrVsBlockForgeInferiors = value; + } + + public void setAfterGetCurrentPlayerStrVsBlockForgeSuperiors(String[] value) + { + afterGetCurrentPlayerStrVsBlockForgeSuperiors = value; + } + + public void setAfterGetCurrentPlayerStrVsBlockForgeInferiors(String[] value) + { + afterGetCurrentPlayerStrVsBlockForgeInferiors = value; + } + + public String[] getBeforeGetDistanceSqSuperiors() + { + return beforeGetDistanceSqSuperiors; + } + + public String[] getBeforeGetDistanceSqInferiors() + { + return beforeGetDistanceSqInferiors; + } + + public String[] getOverrideGetDistanceSqSuperiors() + { + return overrideGetDistanceSqSuperiors; + } + + public String[] getOverrideGetDistanceSqInferiors() + { + return overrideGetDistanceSqInferiors; + } + + public String[] getAfterGetDistanceSqSuperiors() + { + return afterGetDistanceSqSuperiors; + } + + public String[] getAfterGetDistanceSqInferiors() + { + return afterGetDistanceSqInferiors; + } + + public void setBeforeGetDistanceSqSuperiors(String[] value) + { + beforeGetDistanceSqSuperiors = value; + } + + public void setBeforeGetDistanceSqInferiors(String[] value) + { + beforeGetDistanceSqInferiors = value; + } + + public void setOverrideGetDistanceSqSuperiors(String[] value) + { + overrideGetDistanceSqSuperiors = value; + } + + public void setOverrideGetDistanceSqInferiors(String[] value) + { + overrideGetDistanceSqInferiors = value; + } + + public void setAfterGetDistanceSqSuperiors(String[] value) + { + afterGetDistanceSqSuperiors = value; + } + + public void setAfterGetDistanceSqInferiors(String[] value) + { + afterGetDistanceSqInferiors = value; + } + + public String[] getBeforeGetBrightnessSuperiors() + { + return beforeGetBrightnessSuperiors; + } + + public String[] getBeforeGetBrightnessInferiors() + { + return beforeGetBrightnessInferiors; + } + + public String[] getOverrideGetBrightnessSuperiors() + { + return overrideGetBrightnessSuperiors; + } + + public String[] getOverrideGetBrightnessInferiors() + { + return overrideGetBrightnessInferiors; + } + + public String[] getAfterGetBrightnessSuperiors() + { + return afterGetBrightnessSuperiors; + } + + public String[] getAfterGetBrightnessInferiors() + { + return afterGetBrightnessInferiors; + } + + public void setBeforeGetBrightnessSuperiors(String[] value) + { + beforeGetBrightnessSuperiors = value; + } + + public void setBeforeGetBrightnessInferiors(String[] value) + { + beforeGetBrightnessInferiors = value; + } + + public void setOverrideGetBrightnessSuperiors(String[] value) + { + overrideGetBrightnessSuperiors = value; + } + + public void setOverrideGetBrightnessInferiors(String[] value) + { + overrideGetBrightnessInferiors = value; + } + + public void setAfterGetBrightnessSuperiors(String[] value) + { + afterGetBrightnessSuperiors = value; + } + + public void setAfterGetBrightnessInferiors(String[] value) + { + afterGetBrightnessInferiors = value; + } + + public String[] getBeforeGetEyeHeightSuperiors() + { + return beforeGetEyeHeightSuperiors; + } + + public String[] getBeforeGetEyeHeightInferiors() + { + return beforeGetEyeHeightInferiors; + } + + public String[] getOverrideGetEyeHeightSuperiors() + { + return overrideGetEyeHeightSuperiors; + } + + public String[] getOverrideGetEyeHeightInferiors() + { + return overrideGetEyeHeightInferiors; + } + + public String[] getAfterGetEyeHeightSuperiors() + { + return afterGetEyeHeightSuperiors; + } + + public String[] getAfterGetEyeHeightInferiors() + { + return afterGetEyeHeightInferiors; + } + + public void setBeforeGetEyeHeightSuperiors(String[] value) + { + beforeGetEyeHeightSuperiors = value; + } + + public void setBeforeGetEyeHeightInferiors(String[] value) + { + beforeGetEyeHeightInferiors = value; + } + + public void setOverrideGetEyeHeightSuperiors(String[] value) + { + overrideGetEyeHeightSuperiors = value; + } + + public void setOverrideGetEyeHeightInferiors(String[] value) + { + overrideGetEyeHeightInferiors = value; + } + + public void setAfterGetEyeHeightSuperiors(String[] value) + { + afterGetEyeHeightSuperiors = value; + } + + public void setAfterGetEyeHeightInferiors(String[] value) + { + afterGetEyeHeightInferiors = value; + } + + public String[] getBeforeHealSuperiors() + { + return beforeHealSuperiors; + } + + public String[] getBeforeHealInferiors() + { + return beforeHealInferiors; + } + + public String[] getOverrideHealSuperiors() + { + return overrideHealSuperiors; + } + + public String[] getOverrideHealInferiors() + { + return overrideHealInferiors; + } + + public String[] getAfterHealSuperiors() + { + return afterHealSuperiors; + } + + public String[] getAfterHealInferiors() + { + return afterHealInferiors; + } + + public void setBeforeHealSuperiors(String[] value) + { + beforeHealSuperiors = value; + } + + public void setBeforeHealInferiors(String[] value) + { + beforeHealInferiors = value; + } + + public void setOverrideHealSuperiors(String[] value) + { + overrideHealSuperiors = value; + } + + public void setOverrideHealInferiors(String[] value) + { + overrideHealInferiors = value; + } + + public void setAfterHealSuperiors(String[] value) + { + afterHealSuperiors = value; + } + + public void setAfterHealInferiors(String[] value) + { + afterHealInferiors = value; + } + + public String[] getBeforeIsEntityInsideOpaqueBlockSuperiors() + { + return beforeIsEntityInsideOpaqueBlockSuperiors; + } + + public String[] getBeforeIsEntityInsideOpaqueBlockInferiors() + { + return beforeIsEntityInsideOpaqueBlockInferiors; + } + + public String[] getOverrideIsEntityInsideOpaqueBlockSuperiors() + { + return overrideIsEntityInsideOpaqueBlockSuperiors; + } + + public String[] getOverrideIsEntityInsideOpaqueBlockInferiors() + { + return overrideIsEntityInsideOpaqueBlockInferiors; + } + + public String[] getAfterIsEntityInsideOpaqueBlockSuperiors() + { + return afterIsEntityInsideOpaqueBlockSuperiors; + } + + public String[] getAfterIsEntityInsideOpaqueBlockInferiors() + { + return afterIsEntityInsideOpaqueBlockInferiors; + } + + public void setBeforeIsEntityInsideOpaqueBlockSuperiors(String[] value) + { + beforeIsEntityInsideOpaqueBlockSuperiors = value; + } + + public void setBeforeIsEntityInsideOpaqueBlockInferiors(String[] value) + { + beforeIsEntityInsideOpaqueBlockInferiors = value; + } + + public void setOverrideIsEntityInsideOpaqueBlockSuperiors(String[] value) + { + overrideIsEntityInsideOpaqueBlockSuperiors = value; + } + + public void setOverrideIsEntityInsideOpaqueBlockInferiors(String[] value) + { + overrideIsEntityInsideOpaqueBlockInferiors = value; + } + + public void setAfterIsEntityInsideOpaqueBlockSuperiors(String[] value) + { + afterIsEntityInsideOpaqueBlockSuperiors = value; + } + + public void setAfterIsEntityInsideOpaqueBlockInferiors(String[] value) + { + afterIsEntityInsideOpaqueBlockInferiors = value; + } + + public String[] getBeforeIsInWaterSuperiors() + { + return beforeIsInWaterSuperiors; + } + + public String[] getBeforeIsInWaterInferiors() + { + return beforeIsInWaterInferiors; + } + + public String[] getOverrideIsInWaterSuperiors() + { + return overrideIsInWaterSuperiors; + } + + public String[] getOverrideIsInWaterInferiors() + { + return overrideIsInWaterInferiors; + } + + public String[] getAfterIsInWaterSuperiors() + { + return afterIsInWaterSuperiors; + } + + public String[] getAfterIsInWaterInferiors() + { + return afterIsInWaterInferiors; + } + + public void setBeforeIsInWaterSuperiors(String[] value) + { + beforeIsInWaterSuperiors = value; + } + + public void setBeforeIsInWaterInferiors(String[] value) + { + beforeIsInWaterInferiors = value; + } + + public void setOverrideIsInWaterSuperiors(String[] value) + { + overrideIsInWaterSuperiors = value; + } + + public void setOverrideIsInWaterInferiors(String[] value) + { + overrideIsInWaterInferiors = value; + } + + public void setAfterIsInWaterSuperiors(String[] value) + { + afterIsInWaterSuperiors = value; + } + + public void setAfterIsInWaterInferiors(String[] value) + { + afterIsInWaterInferiors = value; + } + + public String[] getBeforeIsInsideOfMaterialSuperiors() + { + return beforeIsInsideOfMaterialSuperiors; + } + + public String[] getBeforeIsInsideOfMaterialInferiors() + { + return beforeIsInsideOfMaterialInferiors; + } + + public String[] getOverrideIsInsideOfMaterialSuperiors() + { + return overrideIsInsideOfMaterialSuperiors; + } + + public String[] getOverrideIsInsideOfMaterialInferiors() + { + return overrideIsInsideOfMaterialInferiors; + } + + public String[] getAfterIsInsideOfMaterialSuperiors() + { + return afterIsInsideOfMaterialSuperiors; + } + + public String[] getAfterIsInsideOfMaterialInferiors() + { + return afterIsInsideOfMaterialInferiors; + } + + public void setBeforeIsInsideOfMaterialSuperiors(String[] value) + { + beforeIsInsideOfMaterialSuperiors = value; + } + + public void setBeforeIsInsideOfMaterialInferiors(String[] value) + { + beforeIsInsideOfMaterialInferiors = value; + } + + public void setOverrideIsInsideOfMaterialSuperiors(String[] value) + { + overrideIsInsideOfMaterialSuperiors = value; + } + + public void setOverrideIsInsideOfMaterialInferiors(String[] value) + { + overrideIsInsideOfMaterialInferiors = value; + } + + public void setAfterIsInsideOfMaterialSuperiors(String[] value) + { + afterIsInsideOfMaterialSuperiors = value; + } + + public void setAfterIsInsideOfMaterialInferiors(String[] value) + { + afterIsInsideOfMaterialInferiors = value; + } + + public String[] getBeforeIsOnLadderSuperiors() + { + return beforeIsOnLadderSuperiors; + } + + public String[] getBeforeIsOnLadderInferiors() + { + return beforeIsOnLadderInferiors; + } + + public String[] getOverrideIsOnLadderSuperiors() + { + return overrideIsOnLadderSuperiors; + } + + public String[] getOverrideIsOnLadderInferiors() + { + return overrideIsOnLadderInferiors; + } + + public String[] getAfterIsOnLadderSuperiors() + { + return afterIsOnLadderSuperiors; + } + + public String[] getAfterIsOnLadderInferiors() + { + return afterIsOnLadderInferiors; + } + + public void setBeforeIsOnLadderSuperiors(String[] value) + { + beforeIsOnLadderSuperiors = value; + } + + public void setBeforeIsOnLadderInferiors(String[] value) + { + beforeIsOnLadderInferiors = value; + } + + public void setOverrideIsOnLadderSuperiors(String[] value) + { + overrideIsOnLadderSuperiors = value; + } + + public void setOverrideIsOnLadderInferiors(String[] value) + { + overrideIsOnLadderInferiors = value; + } + + public void setAfterIsOnLadderSuperiors(String[] value) + { + afterIsOnLadderSuperiors = value; + } + + public void setAfterIsOnLadderInferiors(String[] value) + { + afterIsOnLadderInferiors = value; + } + + public String[] getBeforeIsPlayerSleepingSuperiors() + { + return beforeIsPlayerSleepingSuperiors; + } + + public String[] getBeforeIsPlayerSleepingInferiors() + { + return beforeIsPlayerSleepingInferiors; + } + + public String[] getOverrideIsPlayerSleepingSuperiors() + { + return overrideIsPlayerSleepingSuperiors; + } + + public String[] getOverrideIsPlayerSleepingInferiors() + { + return overrideIsPlayerSleepingInferiors; + } + + public String[] getAfterIsPlayerSleepingSuperiors() + { + return afterIsPlayerSleepingSuperiors; + } + + public String[] getAfterIsPlayerSleepingInferiors() + { + return afterIsPlayerSleepingInferiors; + } + + public void setBeforeIsPlayerSleepingSuperiors(String[] value) + { + beforeIsPlayerSleepingSuperiors = value; + } + + public void setBeforeIsPlayerSleepingInferiors(String[] value) + { + beforeIsPlayerSleepingInferiors = value; + } + + public void setOverrideIsPlayerSleepingSuperiors(String[] value) + { + overrideIsPlayerSleepingSuperiors = value; + } + + public void setOverrideIsPlayerSleepingInferiors(String[] value) + { + overrideIsPlayerSleepingInferiors = value; + } + + public void setAfterIsPlayerSleepingSuperiors(String[] value) + { + afterIsPlayerSleepingSuperiors = value; + } + + public void setAfterIsPlayerSleepingInferiors(String[] value) + { + afterIsPlayerSleepingInferiors = value; + } + + public String[] getBeforeIsSneakingSuperiors() + { + return beforeIsSneakingSuperiors; + } + + public String[] getBeforeIsSneakingInferiors() + { + return beforeIsSneakingInferiors; + } + + public String[] getOverrideIsSneakingSuperiors() + { + return overrideIsSneakingSuperiors; + } + + public String[] getOverrideIsSneakingInferiors() + { + return overrideIsSneakingInferiors; + } + + public String[] getAfterIsSneakingSuperiors() + { + return afterIsSneakingSuperiors; + } + + public String[] getAfterIsSneakingInferiors() + { + return afterIsSneakingInferiors; + } + + public void setBeforeIsSneakingSuperiors(String[] value) + { + beforeIsSneakingSuperiors = value; + } + + public void setBeforeIsSneakingInferiors(String[] value) + { + beforeIsSneakingInferiors = value; + } + + public void setOverrideIsSneakingSuperiors(String[] value) + { + overrideIsSneakingSuperiors = value; + } + + public void setOverrideIsSneakingInferiors(String[] value) + { + overrideIsSneakingInferiors = value; + } + + public void setAfterIsSneakingSuperiors(String[] value) + { + afterIsSneakingSuperiors = value; + } + + public void setAfterIsSneakingInferiors(String[] value) + { + afterIsSneakingInferiors = value; + } + + public String[] getBeforeJumpSuperiors() + { + return beforeJumpSuperiors; + } + + public String[] getBeforeJumpInferiors() + { + return beforeJumpInferiors; + } + + public String[] getOverrideJumpSuperiors() + { + return overrideJumpSuperiors; + } + + public String[] getOverrideJumpInferiors() + { + return overrideJumpInferiors; + } + + public String[] getAfterJumpSuperiors() + { + return afterJumpSuperiors; + } + + public String[] getAfterJumpInferiors() + { + return afterJumpInferiors; + } + + public void setBeforeJumpSuperiors(String[] value) + { + beforeJumpSuperiors = value; + } + + public void setBeforeJumpInferiors(String[] value) + { + beforeJumpInferiors = value; + } + + public void setOverrideJumpSuperiors(String[] value) + { + overrideJumpSuperiors = value; + } + + public void setOverrideJumpInferiors(String[] value) + { + overrideJumpInferiors = value; + } + + public void setAfterJumpSuperiors(String[] value) + { + afterJumpSuperiors = value; + } + + public void setAfterJumpInferiors(String[] value) + { + afterJumpInferiors = value; + } + + public String[] getBeforeKnockBackSuperiors() + { + return beforeKnockBackSuperiors; + } + + public String[] getBeforeKnockBackInferiors() + { + return beforeKnockBackInferiors; + } + + public String[] getOverrideKnockBackSuperiors() + { + return overrideKnockBackSuperiors; + } + + public String[] getOverrideKnockBackInferiors() + { + return overrideKnockBackInferiors; + } + + public String[] getAfterKnockBackSuperiors() + { + return afterKnockBackSuperiors; + } + + public String[] getAfterKnockBackInferiors() + { + return afterKnockBackInferiors; + } + + public void setBeforeKnockBackSuperiors(String[] value) + { + beforeKnockBackSuperiors = value; + } + + public void setBeforeKnockBackInferiors(String[] value) + { + beforeKnockBackInferiors = value; + } + + public void setOverrideKnockBackSuperiors(String[] value) + { + overrideKnockBackSuperiors = value; + } + + public void setOverrideKnockBackInferiors(String[] value) + { + overrideKnockBackInferiors = value; + } + + public void setAfterKnockBackSuperiors(String[] value) + { + afterKnockBackSuperiors = value; + } + + public void setAfterKnockBackInferiors(String[] value) + { + afterKnockBackInferiors = value; + } + + public String[] getBeforeMountEntitySuperiors() + { + return beforeMountEntitySuperiors; + } + + public String[] getBeforeMountEntityInferiors() + { + return beforeMountEntityInferiors; + } + + public String[] getOverrideMountEntitySuperiors() + { + return overrideMountEntitySuperiors; + } + + public String[] getOverrideMountEntityInferiors() + { + return overrideMountEntityInferiors; + } + + public String[] getAfterMountEntitySuperiors() + { + return afterMountEntitySuperiors; + } + + public String[] getAfterMountEntityInferiors() + { + return afterMountEntityInferiors; + } + + public void setBeforeMountEntitySuperiors(String[] value) + { + beforeMountEntitySuperiors = value; + } + + public void setBeforeMountEntityInferiors(String[] value) + { + beforeMountEntityInferiors = value; + } + + public void setOverrideMountEntitySuperiors(String[] value) + { + overrideMountEntitySuperiors = value; + } + + public void setOverrideMountEntityInferiors(String[] value) + { + overrideMountEntityInferiors = value; + } + + public void setAfterMountEntitySuperiors(String[] value) + { + afterMountEntitySuperiors = value; + } + + public void setAfterMountEntityInferiors(String[] value) + { + afterMountEntityInferiors = value; + } + + public String[] getBeforeMoveEntitySuperiors() + { + return beforeMoveEntitySuperiors; + } + + public String[] getBeforeMoveEntityInferiors() + { + return beforeMoveEntityInferiors; + } + + public String[] getOverrideMoveEntitySuperiors() + { + return overrideMoveEntitySuperiors; + } + + public String[] getOverrideMoveEntityInferiors() + { + return overrideMoveEntityInferiors; + } + + public String[] getAfterMoveEntitySuperiors() + { + return afterMoveEntitySuperiors; + } + + public String[] getAfterMoveEntityInferiors() + { + return afterMoveEntityInferiors; + } + + public void setBeforeMoveEntitySuperiors(String[] value) + { + beforeMoveEntitySuperiors = value; + } + + public void setBeforeMoveEntityInferiors(String[] value) + { + beforeMoveEntityInferiors = value; + } + + public void setOverrideMoveEntitySuperiors(String[] value) + { + overrideMoveEntitySuperiors = value; + } + + public void setOverrideMoveEntityInferiors(String[] value) + { + overrideMoveEntityInferiors = value; + } + + public void setAfterMoveEntitySuperiors(String[] value) + { + afterMoveEntitySuperiors = value; + } + + public void setAfterMoveEntityInferiors(String[] value) + { + afterMoveEntityInferiors = value; + } + + public String[] getBeforeMoveEntityWithHeadingSuperiors() + { + return beforeMoveEntityWithHeadingSuperiors; + } + + public String[] getBeforeMoveEntityWithHeadingInferiors() + { + return beforeMoveEntityWithHeadingInferiors; + } + + public String[] getOverrideMoveEntityWithHeadingSuperiors() + { + return overrideMoveEntityWithHeadingSuperiors; + } + + public String[] getOverrideMoveEntityWithHeadingInferiors() + { + return overrideMoveEntityWithHeadingInferiors; + } + + public String[] getAfterMoveEntityWithHeadingSuperiors() + { + return afterMoveEntityWithHeadingSuperiors; + } + + public String[] getAfterMoveEntityWithHeadingInferiors() + { + return afterMoveEntityWithHeadingInferiors; + } + + public void setBeforeMoveEntityWithHeadingSuperiors(String[] value) + { + beforeMoveEntityWithHeadingSuperiors = value; + } + + public void setBeforeMoveEntityWithHeadingInferiors(String[] value) + { + beforeMoveEntityWithHeadingInferiors = value; + } + + public void setOverrideMoveEntityWithHeadingSuperiors(String[] value) + { + overrideMoveEntityWithHeadingSuperiors = value; + } + + public void setOverrideMoveEntityWithHeadingInferiors(String[] value) + { + overrideMoveEntityWithHeadingInferiors = value; + } + + public void setAfterMoveEntityWithHeadingSuperiors(String[] value) + { + afterMoveEntityWithHeadingSuperiors = value; + } + + public void setAfterMoveEntityWithHeadingInferiors(String[] value) + { + afterMoveEntityWithHeadingInferiors = value; + } + + public String[] getBeforeMoveFlyingSuperiors() + { + return beforeMoveFlyingSuperiors; + } + + public String[] getBeforeMoveFlyingInferiors() + { + return beforeMoveFlyingInferiors; + } + + public String[] getOverrideMoveFlyingSuperiors() + { + return overrideMoveFlyingSuperiors; + } + + public String[] getOverrideMoveFlyingInferiors() + { + return overrideMoveFlyingInferiors; + } + + public String[] getAfterMoveFlyingSuperiors() + { + return afterMoveFlyingSuperiors; + } + + public String[] getAfterMoveFlyingInferiors() + { + return afterMoveFlyingInferiors; + } + + public void setBeforeMoveFlyingSuperiors(String[] value) + { + beforeMoveFlyingSuperiors = value; + } + + public void setBeforeMoveFlyingInferiors(String[] value) + { + beforeMoveFlyingInferiors = value; + } + + public void setOverrideMoveFlyingSuperiors(String[] value) + { + overrideMoveFlyingSuperiors = value; + } + + public void setOverrideMoveFlyingInferiors(String[] value) + { + overrideMoveFlyingInferiors = value; + } + + public void setAfterMoveFlyingSuperiors(String[] value) + { + afterMoveFlyingSuperiors = value; + } + + public void setAfterMoveFlyingInferiors(String[] value) + { + afterMoveFlyingInferiors = value; + } + + public String[] getBeforeOnDeathSuperiors() + { + return beforeOnDeathSuperiors; + } + + public String[] getBeforeOnDeathInferiors() + { + return beforeOnDeathInferiors; + } + + public String[] getOverrideOnDeathSuperiors() + { + return overrideOnDeathSuperiors; + } + + public String[] getOverrideOnDeathInferiors() + { + return overrideOnDeathInferiors; + } + + public String[] getAfterOnDeathSuperiors() + { + return afterOnDeathSuperiors; + } + + public String[] getAfterOnDeathInferiors() + { + return afterOnDeathInferiors; + } + + public void setBeforeOnDeathSuperiors(String[] value) + { + beforeOnDeathSuperiors = value; + } + + public void setBeforeOnDeathInferiors(String[] value) + { + beforeOnDeathInferiors = value; + } + + public void setOverrideOnDeathSuperiors(String[] value) + { + overrideOnDeathSuperiors = value; + } + + public void setOverrideOnDeathInferiors(String[] value) + { + overrideOnDeathInferiors = value; + } + + public void setAfterOnDeathSuperiors(String[] value) + { + afterOnDeathSuperiors = value; + } + + public void setAfterOnDeathInferiors(String[] value) + { + afterOnDeathInferiors = value; + } + + public String[] getBeforeOnLivingUpdateSuperiors() + { + return beforeOnLivingUpdateSuperiors; + } + + public String[] getBeforeOnLivingUpdateInferiors() + { + return beforeOnLivingUpdateInferiors; + } + + public String[] getOverrideOnLivingUpdateSuperiors() + { + return overrideOnLivingUpdateSuperiors; + } + + public String[] getOverrideOnLivingUpdateInferiors() + { + return overrideOnLivingUpdateInferiors; + } + + public String[] getAfterOnLivingUpdateSuperiors() + { + return afterOnLivingUpdateSuperiors; + } + + public String[] getAfterOnLivingUpdateInferiors() + { + return afterOnLivingUpdateInferiors; + } + + public void setBeforeOnLivingUpdateSuperiors(String[] value) + { + beforeOnLivingUpdateSuperiors = value; + } + + public void setBeforeOnLivingUpdateInferiors(String[] value) + { + beforeOnLivingUpdateInferiors = value; + } + + public void setOverrideOnLivingUpdateSuperiors(String[] value) + { + overrideOnLivingUpdateSuperiors = value; + } + + public void setOverrideOnLivingUpdateInferiors(String[] value) + { + overrideOnLivingUpdateInferiors = value; + } + + public void setAfterOnLivingUpdateSuperiors(String[] value) + { + afterOnLivingUpdateSuperiors = value; + } + + public void setAfterOnLivingUpdateInferiors(String[] value) + { + afterOnLivingUpdateInferiors = value; + } + + public String[] getBeforeOnKillEntitySuperiors() + { + return beforeOnKillEntitySuperiors; + } + + public String[] getBeforeOnKillEntityInferiors() + { + return beforeOnKillEntityInferiors; + } + + public String[] getOverrideOnKillEntitySuperiors() + { + return overrideOnKillEntitySuperiors; + } + + public String[] getOverrideOnKillEntityInferiors() + { + return overrideOnKillEntityInferiors; + } + + public String[] getAfterOnKillEntitySuperiors() + { + return afterOnKillEntitySuperiors; + } + + public String[] getAfterOnKillEntityInferiors() + { + return afterOnKillEntityInferiors; + } + + public void setBeforeOnKillEntitySuperiors(String[] value) + { + beforeOnKillEntitySuperiors = value; + } + + public void setBeforeOnKillEntityInferiors(String[] value) + { + beforeOnKillEntityInferiors = value; + } + + public void setOverrideOnKillEntitySuperiors(String[] value) + { + overrideOnKillEntitySuperiors = value; + } + + public void setOverrideOnKillEntityInferiors(String[] value) + { + overrideOnKillEntityInferiors = value; + } + + public void setAfterOnKillEntitySuperiors(String[] value) + { + afterOnKillEntitySuperiors = value; + } + + public void setAfterOnKillEntityInferiors(String[] value) + { + afterOnKillEntityInferiors = value; + } + + public String[] getBeforeOnStruckByLightningSuperiors() + { + return beforeOnStruckByLightningSuperiors; + } + + public String[] getBeforeOnStruckByLightningInferiors() + { + return beforeOnStruckByLightningInferiors; + } + + public String[] getOverrideOnStruckByLightningSuperiors() + { + return overrideOnStruckByLightningSuperiors; + } + + public String[] getOverrideOnStruckByLightningInferiors() + { + return overrideOnStruckByLightningInferiors; + } + + public String[] getAfterOnStruckByLightningSuperiors() + { + return afterOnStruckByLightningSuperiors; + } + + public String[] getAfterOnStruckByLightningInferiors() + { + return afterOnStruckByLightningInferiors; + } + + public void setBeforeOnStruckByLightningSuperiors(String[] value) + { + beforeOnStruckByLightningSuperiors = value; + } + + public void setBeforeOnStruckByLightningInferiors(String[] value) + { + beforeOnStruckByLightningInferiors = value; + } + + public void setOverrideOnStruckByLightningSuperiors(String[] value) + { + overrideOnStruckByLightningSuperiors = value; + } + + public void setOverrideOnStruckByLightningInferiors(String[] value) + { + overrideOnStruckByLightningInferiors = value; + } + + public void setAfterOnStruckByLightningSuperiors(String[] value) + { + afterOnStruckByLightningSuperiors = value; + } + + public void setAfterOnStruckByLightningInferiors(String[] value) + { + afterOnStruckByLightningInferiors = value; + } + + public String[] getBeforeOnUpdateSuperiors() + { + return beforeOnUpdateSuperiors; + } + + public String[] getBeforeOnUpdateInferiors() + { + return beforeOnUpdateInferiors; + } + + public String[] getOverrideOnUpdateSuperiors() + { + return overrideOnUpdateSuperiors; + } + + public String[] getOverrideOnUpdateInferiors() + { + return overrideOnUpdateInferiors; + } + + public String[] getAfterOnUpdateSuperiors() + { + return afterOnUpdateSuperiors; + } + + public String[] getAfterOnUpdateInferiors() + { + return afterOnUpdateInferiors; + } + + public void setBeforeOnUpdateSuperiors(String[] value) + { + beforeOnUpdateSuperiors = value; + } + + public void setBeforeOnUpdateInferiors(String[] value) + { + beforeOnUpdateInferiors = value; + } + + public void setOverrideOnUpdateSuperiors(String[] value) + { + overrideOnUpdateSuperiors = value; + } + + public void setOverrideOnUpdateInferiors(String[] value) + { + overrideOnUpdateInferiors = value; + } + + public void setAfterOnUpdateSuperiors(String[] value) + { + afterOnUpdateSuperiors = value; + } + + public void setAfterOnUpdateInferiors(String[] value) + { + afterOnUpdateInferiors = value; + } + + public String[] getBeforeOnUpdateEntitySuperiors() + { + return beforeOnUpdateEntitySuperiors; + } + + public String[] getBeforeOnUpdateEntityInferiors() + { + return beforeOnUpdateEntityInferiors; + } + + public String[] getOverrideOnUpdateEntitySuperiors() + { + return overrideOnUpdateEntitySuperiors; + } + + public String[] getOverrideOnUpdateEntityInferiors() + { + return overrideOnUpdateEntityInferiors; + } + + public String[] getAfterOnUpdateEntitySuperiors() + { + return afterOnUpdateEntitySuperiors; + } + + public String[] getAfterOnUpdateEntityInferiors() + { + return afterOnUpdateEntityInferiors; + } + + public void setBeforeOnUpdateEntitySuperiors(String[] value) + { + beforeOnUpdateEntitySuperiors = value; + } + + public void setBeforeOnUpdateEntityInferiors(String[] value) + { + beforeOnUpdateEntityInferiors = value; + } + + public void setOverrideOnUpdateEntitySuperiors(String[] value) + { + overrideOnUpdateEntitySuperiors = value; + } + + public void setOverrideOnUpdateEntityInferiors(String[] value) + { + overrideOnUpdateEntityInferiors = value; + } + + public void setAfterOnUpdateEntitySuperiors(String[] value) + { + afterOnUpdateEntitySuperiors = value; + } + + public void setAfterOnUpdateEntityInferiors(String[] value) + { + afterOnUpdateEntityInferiors = value; + } + + public String[] getBeforeReadEntityFromNBTSuperiors() + { + return beforeReadEntityFromNBTSuperiors; + } + + public String[] getBeforeReadEntityFromNBTInferiors() + { + return beforeReadEntityFromNBTInferiors; + } + + public String[] getOverrideReadEntityFromNBTSuperiors() + { + return overrideReadEntityFromNBTSuperiors; + } + + public String[] getOverrideReadEntityFromNBTInferiors() + { + return overrideReadEntityFromNBTInferiors; + } + + public String[] getAfterReadEntityFromNBTSuperiors() + { + return afterReadEntityFromNBTSuperiors; + } + + public String[] getAfterReadEntityFromNBTInferiors() + { + return afterReadEntityFromNBTInferiors; + } + + public void setBeforeReadEntityFromNBTSuperiors(String[] value) + { + beforeReadEntityFromNBTSuperiors = value; + } + + public void setBeforeReadEntityFromNBTInferiors(String[] value) + { + beforeReadEntityFromNBTInferiors = value; + } + + public void setOverrideReadEntityFromNBTSuperiors(String[] value) + { + overrideReadEntityFromNBTSuperiors = value; + } + + public void setOverrideReadEntityFromNBTInferiors(String[] value) + { + overrideReadEntityFromNBTInferiors = value; + } + + public void setAfterReadEntityFromNBTSuperiors(String[] value) + { + afterReadEntityFromNBTSuperiors = value; + } + + public void setAfterReadEntityFromNBTInferiors(String[] value) + { + afterReadEntityFromNBTInferiors = value; + } + + public String[] getBeforeSetDeadSuperiors() + { + return beforeSetDeadSuperiors; + } + + public String[] getBeforeSetDeadInferiors() + { + return beforeSetDeadInferiors; + } + + public String[] getOverrideSetDeadSuperiors() + { + return overrideSetDeadSuperiors; + } + + public String[] getOverrideSetDeadInferiors() + { + return overrideSetDeadInferiors; + } + + public String[] getAfterSetDeadSuperiors() + { + return afterSetDeadSuperiors; + } + + public String[] getAfterSetDeadInferiors() + { + return afterSetDeadInferiors; + } + + public void setBeforeSetDeadSuperiors(String[] value) + { + beforeSetDeadSuperiors = value; + } + + public void setBeforeSetDeadInferiors(String[] value) + { + beforeSetDeadInferiors = value; + } + + public void setOverrideSetDeadSuperiors(String[] value) + { + overrideSetDeadSuperiors = value; + } + + public void setOverrideSetDeadInferiors(String[] value) + { + overrideSetDeadInferiors = value; + } + + public void setAfterSetDeadSuperiors(String[] value) + { + afterSetDeadSuperiors = value; + } + + public void setAfterSetDeadInferiors(String[] value) + { + afterSetDeadInferiors = value; + } + + public String[] getBeforeSetEntityActionStateSuperiors() + { + return beforeSetEntityActionStateSuperiors; + } + + public String[] getBeforeSetEntityActionStateInferiors() + { + return beforeSetEntityActionStateInferiors; + } + + public String[] getOverrideSetEntityActionStateSuperiors() + { + return overrideSetEntityActionStateSuperiors; + } + + public String[] getOverrideSetEntityActionStateInferiors() + { + return overrideSetEntityActionStateInferiors; + } + + public String[] getAfterSetEntityActionStateSuperiors() + { + return afterSetEntityActionStateSuperiors; + } + + public String[] getAfterSetEntityActionStateInferiors() + { + return afterSetEntityActionStateInferiors; + } + + public void setBeforeSetEntityActionStateSuperiors(String[] value) + { + beforeSetEntityActionStateSuperiors = value; + } + + public void setBeforeSetEntityActionStateInferiors(String[] value) + { + beforeSetEntityActionStateInferiors = value; + } + + public void setOverrideSetEntityActionStateSuperiors(String[] value) + { + overrideSetEntityActionStateSuperiors = value; + } + + public void setOverrideSetEntityActionStateInferiors(String[] value) + { + overrideSetEntityActionStateInferiors = value; + } + + public void setAfterSetEntityActionStateSuperiors(String[] value) + { + afterSetEntityActionStateSuperiors = value; + } + + public void setAfterSetEntityActionStateInferiors(String[] value) + { + afterSetEntityActionStateInferiors = value; + } + + public String[] getBeforeSetPositionSuperiors() + { + return beforeSetPositionSuperiors; + } + + public String[] getBeforeSetPositionInferiors() + { + return beforeSetPositionInferiors; + } + + public String[] getOverrideSetPositionSuperiors() + { + return overrideSetPositionSuperiors; + } + + public String[] getOverrideSetPositionInferiors() + { + return overrideSetPositionInferiors; + } + + public String[] getAfterSetPositionSuperiors() + { + return afterSetPositionSuperiors; + } + + public String[] getAfterSetPositionInferiors() + { + return afterSetPositionInferiors; + } + + public void setBeforeSetPositionSuperiors(String[] value) + { + beforeSetPositionSuperiors = value; + } + + public void setBeforeSetPositionInferiors(String[] value) + { + beforeSetPositionInferiors = value; + } + + public void setOverrideSetPositionSuperiors(String[] value) + { + overrideSetPositionSuperiors = value; + } + + public void setOverrideSetPositionInferiors(String[] value) + { + overrideSetPositionInferiors = value; + } + + public void setAfterSetPositionSuperiors(String[] value) + { + afterSetPositionSuperiors = value; + } + + public void setAfterSetPositionInferiors(String[] value) + { + afterSetPositionInferiors = value; + } + + public String[] getBeforeSetSneakingSuperiors() + { + return beforeSetSneakingSuperiors; + } + + public String[] getBeforeSetSneakingInferiors() + { + return beforeSetSneakingInferiors; + } + + public String[] getOverrideSetSneakingSuperiors() + { + return overrideSetSneakingSuperiors; + } + + public String[] getOverrideSetSneakingInferiors() + { + return overrideSetSneakingInferiors; + } + + public String[] getAfterSetSneakingSuperiors() + { + return afterSetSneakingSuperiors; + } + + public String[] getAfterSetSneakingInferiors() + { + return afterSetSneakingInferiors; + } + + public void setBeforeSetSneakingSuperiors(String[] value) + { + beforeSetSneakingSuperiors = value; + } + + public void setBeforeSetSneakingInferiors(String[] value) + { + beforeSetSneakingInferiors = value; + } + + public void setOverrideSetSneakingSuperiors(String[] value) + { + overrideSetSneakingSuperiors = value; + } + + public void setOverrideSetSneakingInferiors(String[] value) + { + overrideSetSneakingInferiors = value; + } + + public void setAfterSetSneakingSuperiors(String[] value) + { + afterSetSneakingSuperiors = value; + } + + public void setAfterSetSneakingInferiors(String[] value) + { + afterSetSneakingInferiors = value; + } + + public String[] getBeforeSetSprintingSuperiors() + { + return beforeSetSprintingSuperiors; + } + + public String[] getBeforeSetSprintingInferiors() + { + return beforeSetSprintingInferiors; + } + + public String[] getOverrideSetSprintingSuperiors() + { + return overrideSetSprintingSuperiors; + } + + public String[] getOverrideSetSprintingInferiors() + { + return overrideSetSprintingInferiors; + } + + public String[] getAfterSetSprintingSuperiors() + { + return afterSetSprintingSuperiors; + } + + public String[] getAfterSetSprintingInferiors() + { + return afterSetSprintingInferiors; + } + + public void setBeforeSetSprintingSuperiors(String[] value) + { + beforeSetSprintingSuperiors = value; + } + + public void setBeforeSetSprintingInferiors(String[] value) + { + beforeSetSprintingInferiors = value; + } + + public void setOverrideSetSprintingSuperiors(String[] value) + { + overrideSetSprintingSuperiors = value; + } + + public void setOverrideSetSprintingInferiors(String[] value) + { + overrideSetSprintingInferiors = value; + } + + public void setAfterSetSprintingSuperiors(String[] value) + { + afterSetSprintingSuperiors = value; + } + + public void setAfterSetSprintingInferiors(String[] value) + { + afterSetSprintingInferiors = value; + } + + public String[] getBeforeSwingItemSuperiors() + { + return beforeSwingItemSuperiors; + } + + public String[] getBeforeSwingItemInferiors() + { + return beforeSwingItemInferiors; + } + + public String[] getOverrideSwingItemSuperiors() + { + return overrideSwingItemSuperiors; + } + + public String[] getOverrideSwingItemInferiors() + { + return overrideSwingItemInferiors; + } + + public String[] getAfterSwingItemSuperiors() + { + return afterSwingItemSuperiors; + } + + public String[] getAfterSwingItemInferiors() + { + return afterSwingItemInferiors; + } + + public void setBeforeSwingItemSuperiors(String[] value) + { + beforeSwingItemSuperiors = value; + } + + public void setBeforeSwingItemInferiors(String[] value) + { + beforeSwingItemInferiors = value; + } + + public void setOverrideSwingItemSuperiors(String[] value) + { + overrideSwingItemSuperiors = value; + } + + public void setOverrideSwingItemInferiors(String[] value) + { + overrideSwingItemInferiors = value; + } + + public void setAfterSwingItemSuperiors(String[] value) + { + afterSwingItemSuperiors = value; + } + + public void setAfterSwingItemInferiors(String[] value) + { + afterSwingItemInferiors = value; + } + + public String[] getBeforeUpdateEntityActionStateSuperiors() + { + return beforeUpdateEntityActionStateSuperiors; + } + + public String[] getBeforeUpdateEntityActionStateInferiors() + { + return beforeUpdateEntityActionStateInferiors; + } + + public String[] getOverrideUpdateEntityActionStateSuperiors() + { + return overrideUpdateEntityActionStateSuperiors; + } + + public String[] getOverrideUpdateEntityActionStateInferiors() + { + return overrideUpdateEntityActionStateInferiors; + } + + public String[] getAfterUpdateEntityActionStateSuperiors() + { + return afterUpdateEntityActionStateSuperiors; + } + + public String[] getAfterUpdateEntityActionStateInferiors() + { + return afterUpdateEntityActionStateInferiors; + } + + public void setBeforeUpdateEntityActionStateSuperiors(String[] value) + { + beforeUpdateEntityActionStateSuperiors = value; + } + + public void setBeforeUpdateEntityActionStateInferiors(String[] value) + { + beforeUpdateEntityActionStateInferiors = value; + } + + public void setOverrideUpdateEntityActionStateSuperiors(String[] value) + { + overrideUpdateEntityActionStateSuperiors = value; + } + + public void setOverrideUpdateEntityActionStateInferiors(String[] value) + { + overrideUpdateEntityActionStateInferiors = value; + } + + public void setAfterUpdateEntityActionStateSuperiors(String[] value) + { + afterUpdateEntityActionStateSuperiors = value; + } + + public void setAfterUpdateEntityActionStateInferiors(String[] value) + { + afterUpdateEntityActionStateInferiors = value; + } + + public String[] getBeforeUpdatePotionEffectsSuperiors() + { + return beforeUpdatePotionEffectsSuperiors; + } + + public String[] getBeforeUpdatePotionEffectsInferiors() + { + return beforeUpdatePotionEffectsInferiors; + } + + public String[] getOverrideUpdatePotionEffectsSuperiors() + { + return overrideUpdatePotionEffectsSuperiors; + } + + public String[] getOverrideUpdatePotionEffectsInferiors() + { + return overrideUpdatePotionEffectsInferiors; + } + + public String[] getAfterUpdatePotionEffectsSuperiors() + { + return afterUpdatePotionEffectsSuperiors; + } + + public String[] getAfterUpdatePotionEffectsInferiors() + { + return afterUpdatePotionEffectsInferiors; + } + + public void setBeforeUpdatePotionEffectsSuperiors(String[] value) + { + beforeUpdatePotionEffectsSuperiors = value; + } + + public void setBeforeUpdatePotionEffectsInferiors(String[] value) + { + beforeUpdatePotionEffectsInferiors = value; + } + + public void setOverrideUpdatePotionEffectsSuperiors(String[] value) + { + overrideUpdatePotionEffectsSuperiors = value; + } + + public void setOverrideUpdatePotionEffectsInferiors(String[] value) + { + overrideUpdatePotionEffectsInferiors = value; + } + + public void setAfterUpdatePotionEffectsSuperiors(String[] value) + { + afterUpdatePotionEffectsSuperiors = value; + } + + public void setAfterUpdatePotionEffectsInferiors(String[] value) + { + afterUpdatePotionEffectsInferiors = value; + } + + public String[] getBeforeUpdateRiddenSuperiors() + { + return beforeUpdateRiddenSuperiors; + } + + public String[] getBeforeUpdateRiddenInferiors() + { + return beforeUpdateRiddenInferiors; + } + + public String[] getOverrideUpdateRiddenSuperiors() + { + return overrideUpdateRiddenSuperiors; + } + + public String[] getOverrideUpdateRiddenInferiors() + { + return overrideUpdateRiddenInferiors; + } + + public String[] getAfterUpdateRiddenSuperiors() + { + return afterUpdateRiddenSuperiors; + } + + public String[] getAfterUpdateRiddenInferiors() + { + return afterUpdateRiddenInferiors; + } + + public void setBeforeUpdateRiddenSuperiors(String[] value) + { + beforeUpdateRiddenSuperiors = value; + } + + public void setBeforeUpdateRiddenInferiors(String[] value) + { + beforeUpdateRiddenInferiors = value; + } + + public void setOverrideUpdateRiddenSuperiors(String[] value) + { + overrideUpdateRiddenSuperiors = value; + } + + public void setOverrideUpdateRiddenInferiors(String[] value) + { + overrideUpdateRiddenInferiors = value; + } + + public void setAfterUpdateRiddenSuperiors(String[] value) + { + afterUpdateRiddenSuperiors = value; + } + + public void setAfterUpdateRiddenInferiors(String[] value) + { + afterUpdateRiddenInferiors = value; + } + + public String[] getBeforeWakeUpPlayerSuperiors() + { + return beforeWakeUpPlayerSuperiors; + } + + public String[] getBeforeWakeUpPlayerInferiors() + { + return beforeWakeUpPlayerInferiors; + } + + public String[] getOverrideWakeUpPlayerSuperiors() + { + return overrideWakeUpPlayerSuperiors; + } + + public String[] getOverrideWakeUpPlayerInferiors() + { + return overrideWakeUpPlayerInferiors; + } + + public String[] getAfterWakeUpPlayerSuperiors() + { + return afterWakeUpPlayerSuperiors; + } + + public String[] getAfterWakeUpPlayerInferiors() + { + return afterWakeUpPlayerInferiors; + } + + public void setBeforeWakeUpPlayerSuperiors(String[] value) + { + beforeWakeUpPlayerSuperiors = value; + } + + public void setBeforeWakeUpPlayerInferiors(String[] value) + { + beforeWakeUpPlayerInferiors = value; + } + + public void setOverrideWakeUpPlayerSuperiors(String[] value) + { + overrideWakeUpPlayerSuperiors = value; + } + + public void setOverrideWakeUpPlayerInferiors(String[] value) + { + overrideWakeUpPlayerInferiors = value; + } + + public void setAfterWakeUpPlayerSuperiors(String[] value) + { + afterWakeUpPlayerSuperiors = value; + } + + public void setAfterWakeUpPlayerInferiors(String[] value) + { + afterWakeUpPlayerInferiors = value; + } + + public String[] getBeforeWriteEntityToNBTSuperiors() + { + return beforeWriteEntityToNBTSuperiors; + } + + public String[] getBeforeWriteEntityToNBTInferiors() + { + return beforeWriteEntityToNBTInferiors; + } + + public String[] getOverrideWriteEntityToNBTSuperiors() + { + return overrideWriteEntityToNBTSuperiors; + } + + public String[] getOverrideWriteEntityToNBTInferiors() + { + return overrideWriteEntityToNBTInferiors; + } + + public String[] getAfterWriteEntityToNBTSuperiors() + { + return afterWriteEntityToNBTSuperiors; + } + + public String[] getAfterWriteEntityToNBTInferiors() + { + return afterWriteEntityToNBTInferiors; + } + + public void setBeforeWriteEntityToNBTSuperiors(String[] value) + { + beforeWriteEntityToNBTSuperiors = value; + } + + public void setBeforeWriteEntityToNBTInferiors(String[] value) + { + beforeWriteEntityToNBTInferiors = value; + } + + public void setOverrideWriteEntityToNBTSuperiors(String[] value) + { + overrideWriteEntityToNBTSuperiors = value; + } + + public void setOverrideWriteEntityToNBTInferiors(String[] value) + { + overrideWriteEntityToNBTInferiors = value; + } + + public void setAfterWriteEntityToNBTSuperiors(String[] value) + { + afterWriteEntityToNBTSuperiors = value; + } + + public void setAfterWriteEntityToNBTInferiors(String[] value) + { + afterWriteEntityToNBTInferiors = value; + } + +} diff --git a/src/Java/api/player/server/ServerPlayerClassVisitor.java b/src/Java/api/player/server/ServerPlayerClassVisitor.java new file mode 100644 index 0000000000..30581106d4 --- /dev/null +++ b/src/Java/api/player/server/ServerPlayerClassVisitor.java @@ -0,0 +1,4856 @@ +// ================================================================== +// This file is part of Player API. +// +// Player API is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// Player API is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and the GNU General Public License along with Player API. +// If not, see <http://www.gnu.org/licenses/>. +// ================================================================== + +package api.player.server; + +import java.io.*; + +import org.objectweb.asm.*; + +public final class ServerPlayerClassVisitor extends ClassVisitor +{ + public static final String targetClassName = "net.minecraft.entity.player.EntityPlayerMP"; + + private boolean hadLocalAddExhaustion; + private boolean hadLocalAddExperience; + private boolean hadLocalAddExperienceLevel; + private boolean hadLocalAddMovementStat; + private boolean hadLocalAttackEntityFrom; + private boolean hadLocalAttackTargetEntityWithCurrentItem; + private boolean hadLocalCanBreatheUnderwater; + private boolean hadLocalCanHarvestBlock; + private boolean hadLocalCanPlayerEdit; + private boolean hadLocalCanTriggerWalking; + private boolean hadLocalClonePlayer; + private boolean hadLocalDamageEntity; + private boolean hadLocalDisplayGUIChest; + private boolean hadLocalDisplayGUIDispenser; + private boolean hadLocalDisplayGUIFurnace; + private boolean hadLocalDisplayGUIWorkbench; + private boolean hadLocalDropOneItem; + private boolean hadLocalDropPlayerItem; + private boolean hadLocalFall; + private boolean hadLocalGetAIMoveSpeed; + private boolean hadLocalGetCurrentPlayerStrVsBlock; + private boolean hadLocalGetCurrentPlayerStrVsBlockForge; + private boolean hadLocalGetDistanceSq; + private boolean hadLocalGetBrightness; + private boolean hadLocalGetEyeHeight; + private boolean hadLocalHeal; + private boolean hadLocalIsEntityInsideOpaqueBlock; + private boolean hadLocalIsInWater; + private boolean hadLocalIsInsideOfMaterial; + private boolean hadLocalIsOnLadder; + private boolean hadLocalIsPlayerSleeping; + private boolean hadLocalIsSneaking; + private boolean hadLocalJump; + private boolean hadLocalKnockBack; + private boolean hadLocalMountEntity; + private boolean hadLocalMoveEntity; + private boolean hadLocalMoveEntityWithHeading; + private boolean hadLocalMoveFlying; + private boolean hadLocalOnDeath; + private boolean hadLocalOnLivingUpdate; + private boolean hadLocalOnKillEntity; + private boolean hadLocalOnStruckByLightning; + private boolean hadLocalOnUpdate; + private boolean hadLocalOnUpdateEntity; + private boolean hadLocalReadEntityFromNBT; + private boolean hadLocalSetDead; + private boolean hadLocalSetEntityActionState; + private boolean hadLocalSetPosition; + private boolean hadLocalSetSneaking; + private boolean hadLocalSetSprinting; + private boolean hadLocalSwingItem; + private boolean hadLocalUpdateEntityActionState; + private boolean hadLocalUpdatePotionEffects; + private boolean hadLocalUpdateRidden; + private boolean hadLocalWakeUpPlayer; + private boolean hadLocalWriteEntityToNBT; + + public static byte[] transform(byte[] bytes, boolean isObfuscated) + { + try + { + ByteArrayInputStream in = new ByteArrayInputStream(bytes); + ClassReader cr = new ClassReader(in); + ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); + ServerPlayerClassVisitor p = new ServerPlayerClassVisitor(cw, isObfuscated); + + cr.accept(p, 0); + + byte[] result = cw.toByteArray(); + in.close(); + return result; + } + catch(IOException ioe) + { + throw new RuntimeException(ioe); + } + } + + private final boolean isObfuscated; + + public ServerPlayerClassVisitor(ClassVisitor classVisitor, boolean isObfuscated) + { + super(262144, classVisitor); + this.isObfuscated = isObfuscated; + } + + public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) + { + String[] newInterfaces = new String[interfaces.length + 1]; + for(int i=0; i<interfaces.length; i++) + newInterfaces[i] = interfaces[i]; + newInterfaces[interfaces.length] = "api/player/server/IServerPlayerAPI"; + super.visit(version, access, name, signature, superName, newInterfaces); + } + + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) + { + if(name.equals("<init>")) + return new ServerPlayerConstructorVisitor(super.visitMethod(access, name, desc, signature, exceptions), isObfuscated); + + if(name.equals(isObfuscated ? "a" : "addExhaustion") && desc.equals("(F)V")) + { + hadLocalAddExhaustion = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localAddExhaustion", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "v" : "addExperience") && desc.equals("(I)V")) + { + hadLocalAddExperience = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localAddExperience", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "addExperienceLevel") && desc.equals("(I)V")) + { + hadLocalAddExperienceLevel = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localAddExperienceLevel", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "k" : "addMovementStat") && desc.equals("(DDD)V")) + { + hadLocalAddMovementStat = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localAddMovementStat", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "attackEntityFrom") && desc.equals(isObfuscated ? "(Lro;F)Z" : "(Lnet/minecraft/util/DamageSource;F)Z")) + { + hadLocalAttackEntityFrom = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localAttackEntityFrom", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "r" : "attackEntityPlayerMPEntityWithCurrentItem") && desc.equals(isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V")) + { + hadLocalAttackTargetEntityWithCurrentItem = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localAttackTargetEntityWithCurrentItem", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "aE" : "canBreatheUnderwater") && desc.equals("()Z")) + { + hadLocalCanBreatheUnderwater = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localCanBreatheUnderwater", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "canHarvestBlock") && desc.equals(isObfuscated ? "(Laji;)Z" : "(Lnet/minecraft/block/Block;)Z")) + { + hadLocalCanHarvestBlock = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localCanHarvestBlock", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "canPlayerEdit") && desc.equals(isObfuscated ? "(IIIILadd;)Z" : "(IIIILnet/minecraft/item/ItemStack;)Z")) + { + hadLocalCanPlayerEdit = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localCanPlayerEdit", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "g_" : "canTriggerWalking") && desc.equals("()Z")) + { + hadLocalCanTriggerWalking = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localCanTriggerWalking", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "clonePlayer") && desc.equals(isObfuscated ? "(Lyz;Z)V" : "(Lnet/minecraft/entity/player/EntityPlayer;Z)V")) + { + hadLocalClonePlayer = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localClonePlayer", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "d" : "damageEntity") && desc.equals(isObfuscated ? "(Lro;F)V" : "(Lnet/minecraft/util/DamageSource;F)V")) + { + hadLocalDamageEntity = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDamageEntity", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "displayGUIChest") && desc.equals(isObfuscated ? "(Lrb;)V" : "(Lnet/minecraft/inventory/IInventory;)V")) + { + hadLocalDisplayGUIChest = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDisplayGUIChest", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "func_146102_a") && desc.equals(isObfuscated ? "(Lapb;)V" : "(Lnet/minecraft/tileentity/TileEntityDispenser;)V")) + { + hadLocalDisplayGUIDispenser = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDisplayGUIDispenser", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "func_146101_a") && desc.equals(isObfuscated ? "(Lapg;)V" : "(Lnet/minecraft/tileentity/TileEntityFurnace;)V")) + { + hadLocalDisplayGUIFurnace = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDisplayGUIFurnace", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "b" : "displayGUIWorkbench") && desc.equals("(III)V")) + { + hadLocalDisplayGUIWorkbench = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDisplayGUIWorkbench", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "dropOneItem") && desc.equals(isObfuscated ? "(Z)Lxk;" : "(Z)Lnet/minecraft/entity/item/EntityItem;")) + { + hadLocalDropOneItem = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDropOneItem", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "dropPlayerItemWithRandomChoice") && desc.equals(isObfuscated ? "(Ladd;Z)Lxk;" : "(Lnet/minecraft/item/ItemStack;Z)Lnet/minecraft/entity/item/EntityItem;")) + { + hadLocalDropPlayerItem = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDropPlayerItem", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "b" : "fall") && desc.equals("(F)V")) + { + hadLocalFall = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localFall", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "bl" : "getAIMoveSpeed") && desc.equals("()F")) + { + hadLocalGetAIMoveSpeed = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localGetAIMoveSpeed", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "getCurrentPlayerStrVsBlock") && desc.equals(isObfuscated ? "(Laji;Z)F" : "(Lnet/minecraft/block/Block;Z)F")) + { + hadLocalGetCurrentPlayerStrVsBlock = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localGetCurrentPlayerStrVsBlock", desc, signature, exceptions); + } + + if(name.equals("getBreakSpeed") && desc.equals(isObfuscated ? "(Laji;ZI)F" : "(Lnet/minecraft/block/Block;ZI)F")) + { + hadLocalGetCurrentPlayerStrVsBlockForge = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localGetCurrentPlayerStrVsBlockForge", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "e" : "getDistanceSq") && desc.equals("(DDD)D")) + { + hadLocalGetDistanceSq = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localGetDistanceSq", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "d" : "getBrightness") && desc.equals("(F)F")) + { + hadLocalGetBrightness = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localGetBrightness", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "g" : "getEyeHeight") && desc.equals("()F")) + { + hadLocalGetEyeHeight = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localGetEyeHeight", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "f" : "heal") && desc.equals("(F)V")) + { + hadLocalHeal = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localHeal", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "aa" : "isEntityInsideOpaqueBlock") && desc.equals("()Z")) + { + hadLocalIsEntityInsideOpaqueBlock = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localIsEntityInsideOpaqueBlock", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "M" : "isInWater") && desc.equals("()Z")) + { + hadLocalIsInWater = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localIsInWater", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "isInsideOfMaterial") && desc.equals(isObfuscated ? "(Lawt;)Z" : "(Lnet/minecraft/block/material/Material;)Z")) + { + hadLocalIsInsideOfMaterial = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localIsInsideOfMaterial", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "h_" : "isOnLadder") && desc.equals("()Z")) + { + hadLocalIsOnLadder = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localIsOnLadder", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "bm" : "isPlayerSleeping") && desc.equals("()Z")) + { + hadLocalIsPlayerSleeping = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localIsPlayerSleeping", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "an" : "isSneaking") && desc.equals("()Z")) + { + hadLocalIsSneaking = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localIsSneaking", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "bj" : "jump") && desc.equals("()V")) + { + hadLocalJump = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localJump", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "knockBack") && desc.equals(isObfuscated ? "(Lsa;FDD)V" : "(Lnet/minecraft/entity/Entity;FDD)V")) + { + hadLocalKnockBack = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localKnockBack", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "mountEntity") && desc.equals(isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V")) + { + hadLocalMountEntity = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localMountEntity", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "d" : "moveEntity") && desc.equals("(DDD)V")) + { + hadLocalMoveEntity = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localMoveEntity", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "e" : "moveEntityWithHeading") && desc.equals("(FF)V")) + { + hadLocalMoveEntityWithHeading = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localMoveEntityWithHeading", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "moveFlying") && desc.equals("(FFF)V")) + { + hadLocalMoveFlying = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localMoveFlying", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "onDeath") && desc.equals(isObfuscated ? "(Lro;)V" : "(Lnet/minecraft/util/DamageSource;)V")) + { + hadLocalOnDeath = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localOnDeath", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "e" : "onLivingUpdate") && desc.equals("()V")) + { + hadLocalOnLivingUpdate = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localOnLivingUpdate", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "onKillEntity") && desc.equals(isObfuscated ? "(Lsv;)V" : "(Lnet/minecraft/entity/EntityLivingBase;)V")) + { + hadLocalOnKillEntity = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localOnKillEntity", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "onStruckByLightning") && desc.equals(isObfuscated ? "(Lxh;)V" : "(Lnet/minecraft/entity/effect/EntityLightningBolt;)V")) + { + hadLocalOnStruckByLightning = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localOnStruckByLightning", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "h" : "onUpdate") && desc.equals("()V")) + { + hadLocalOnUpdate = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localOnUpdate", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "i" : "onUpdateEntity") && desc.equals("()V")) + { + hadLocalOnUpdateEntity = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localOnUpdateEntity", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "readEntityFromNBT") && desc.equals(isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V")) + { + hadLocalReadEntityFromNBT = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localReadEntityFromNBT", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "B" : "setDead") && desc.equals("()V")) + { + hadLocalSetDead = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localSetDead", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "setEntityActionState") && desc.equals("(FFZZ)V")) + { + hadLocalSetEntityActionState = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localSetEntityActionState", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "b" : "setPosition") && desc.equals("(DDD)V")) + { + hadLocalSetPosition = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localSetPosition", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "b" : "setSneaking") && desc.equals("(Z)V")) + { + hadLocalSetSneaking = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localSetSneaking", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "c" : "setSprinting") && desc.equals("(Z)V")) + { + hadLocalSetSprinting = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localSetSprinting", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "ba" : "swingItem") && desc.equals("()V")) + { + hadLocalSwingItem = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localSwingItem", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "bq" : "updateEntityActionState") && desc.equals("()V")) + { + hadLocalUpdateEntityActionState = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localUpdateEntityActionState", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "aO" : "updatePotionEffects") && desc.equals("()V")) + { + hadLocalUpdatePotionEffects = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localUpdatePotionEffects", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "ab" : "updateRidden") && desc.equals("()V")) + { + hadLocalUpdateRidden = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localUpdateRidden", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "a" : "wakeUpPlayer") && desc.equals("(ZZZ)V")) + { + hadLocalWakeUpPlayer = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localWakeUpPlayer", desc, signature, exceptions); + } + + if(name.equals(isObfuscated ? "b" : "writeEntityToNBT") && desc.equals(isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V")) + { + hadLocalWriteEntityToNBT = true; + return super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localWriteEntityToNBT", desc, signature, exceptions); + } + + return super.visitMethod(access, name, desc, signature, exceptions); + } + + public void visitEnd() + { + MethodVisitor mv; + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "addExhaustion", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "addExhaustion", "(Lapi/player/server/IServerPlayerAPI;F)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realAddExhaustion", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "addExhaustion", "(F)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superAddExhaustion", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "addExhaustion", "(F)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalAddExhaustion) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localAddExhaustion", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "addExhaustion", "(F)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "v" : "addExperience", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "addExperience", "(Lapi/player/server/IServerPlayerAPI;I)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realAddExperience", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "v" : "addExperience", "(I)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superAddExperience", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "v" : "addExperience", "(I)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalAddExperience) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localAddExperience", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "v" : "addExperience", "(I)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "addExperienceLevel", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "addExperienceLevel", "(Lapi/player/server/IServerPlayerAPI;I)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realAddExperienceLevel", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "addExperienceLevel", "(I)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superAddExperienceLevel", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "addExperienceLevel", "(I)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalAddExperienceLevel) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localAddExperienceLevel", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "addExperienceLevel", "(I)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "k" : "addMovementStat", "(DDD)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "addMovementStat", "(Lapi/player/server/IServerPlayerAPI;DDD)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realAddMovementStat", "(DDD)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "k" : "addMovementStat", "(DDD)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superAddMovementStat", "(DDD)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "k" : "addMovementStat", "(DDD)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalAddMovementStat) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localAddMovementStat", "(DDD)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "k" : "addMovementStat", "(DDD)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "attackEntityFrom", "" + (isObfuscated ? "(Lro;F)Z" : "(Lnet/minecraft/util/DamageSource;F)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "attackEntityFrom", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Lro;F" : "Lnet/minecraft/util/DamageSource;F") + ")Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realAttackEntityFrom", "" + (isObfuscated ? "(Lro;F)Z" : "(Lnet/minecraft/util/DamageSource;F)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "attackEntityFrom", "" + (isObfuscated ? "(Lro;F)Z" : "(Lnet/minecraft/util/DamageSource;F)Z") + ""); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superAttackEntityFrom", "" + (isObfuscated ? "(Lro;F)Z" : "(Lnet/minecraft/util/DamageSource;F)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "attackEntityFrom", "" + (isObfuscated ? "(Lro;F)Z" : "(Lnet/minecraft/util/DamageSource;F)Z") + ""); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalAttackEntityFrom) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localAttackEntityFrom", "" + (isObfuscated ? "(Lro;F)Z" : "(Lnet/minecraft/util/DamageSource;F)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "attackEntityFrom", "" + (isObfuscated ? "(Lro;F)Z" : "(Lnet/minecraft/util/DamageSource;F)Z") + ""); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "r" : "attackEntityPlayerMPEntityWithCurrentItem", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "attackTargetEntityWithCurrentItem", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Lsa;" : "Lnet/minecraft/entity/Entity;") + ")V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realAttackTargetEntityWithCurrentItem", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "r" : "attackEntityPlayerMPEntityWithCurrentItem", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superAttackTargetEntityWithCurrentItem", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "r" : "attackEntityPlayerMPEntityWithCurrentItem", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalAttackTargetEntityWithCurrentItem) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localAttackTargetEntityWithCurrentItem", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "r" : "attackEntityPlayerMPEntityWithCurrentItem", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "aE" : "canBreatheUnderwater", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "canBreatheUnderwater", "(Lapi/player/server/IServerPlayerAPI;)Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realCanBreatheUnderwater", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aE" : "canBreatheUnderwater", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superCanBreatheUnderwater", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "aE" : "canBreatheUnderwater", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalCanBreatheUnderwater) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localCanBreatheUnderwater", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "aE" : "canBreatheUnderwater", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "canHarvestBlock", "" + (isObfuscated ? "(Laji;)Z" : "(Lnet/minecraft/block/Block;)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "canHarvestBlock", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Laji;" : "Lnet/minecraft/block/Block;") + ")Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realCanHarvestBlock", "" + (isObfuscated ? "(Laji;)Z" : "(Lnet/minecraft/block/Block;)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "canHarvestBlock", "" + (isObfuscated ? "(Laji;)Z" : "(Lnet/minecraft/block/Block;)Z") + ""); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superCanHarvestBlock", "" + (isObfuscated ? "(Laji;)Z" : "(Lnet/minecraft/block/Block;)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "canHarvestBlock", "" + (isObfuscated ? "(Laji;)Z" : "(Lnet/minecraft/block/Block;)Z") + ""); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalCanHarvestBlock) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localCanHarvestBlock", "" + (isObfuscated ? "(Laji;)Z" : "(Lnet/minecraft/block/Block;)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "canHarvestBlock", "" + (isObfuscated ? "(Laji;)Z" : "(Lnet/minecraft/block/Block;)Z") + ""); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "canPlayerEdit", "" + (isObfuscated ? "(IIIILadd;)Z" : "(IIIILnet/minecraft/item/ItemStack;)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitVarInsn(Opcodes.ILOAD, 4); + mv.visitVarInsn(Opcodes.ALOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "canPlayerEdit", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "IIIILadd;" : "IIIILnet/minecraft/item/ItemStack;") + ")Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realCanPlayerEdit", "" + (isObfuscated ? "(IIIILadd;)Z" : "(IIIILnet/minecraft/item/ItemStack;)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitVarInsn(Opcodes.ILOAD, 4); + mv.visitVarInsn(Opcodes.ALOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "canPlayerEdit", "" + (isObfuscated ? "(IIIILadd;)Z" : "(IIIILnet/minecraft/item/ItemStack;)Z") + ""); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superCanPlayerEdit", "" + (isObfuscated ? "(IIIILadd;)Z" : "(IIIILnet/minecraft/item/ItemStack;)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitVarInsn(Opcodes.ILOAD, 4); + mv.visitVarInsn(Opcodes.ALOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "canPlayerEdit", "" + (isObfuscated ? "(IIIILadd;)Z" : "(IIIILnet/minecraft/item/ItemStack;)Z") + ""); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalCanPlayerEdit) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localCanPlayerEdit", "" + (isObfuscated ? "(IIIILadd;)Z" : "(IIIILnet/minecraft/item/ItemStack;)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitVarInsn(Opcodes.ILOAD, 4); + mv.visitVarInsn(Opcodes.ALOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "canPlayerEdit", "" + (isObfuscated ? "(IIIILadd;)Z" : "(IIIILnet/minecraft/item/ItemStack;)Z") + ""); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "g_" : "canTriggerWalking", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "canTriggerWalking", "(Lapi/player/server/IServerPlayerAPI;)Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realCanTriggerWalking", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "g_" : "canTriggerWalking", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superCanTriggerWalking", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "g_" : "canTriggerWalking", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalCanTriggerWalking) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localCanTriggerWalking", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "g_" : "canTriggerWalking", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "clonePlayer", "" + (isObfuscated ? "(Lyz;Z)V" : "(Lnet/minecraft/entity/player/EntityPlayer;Z)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "clonePlayer", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Lyz;Z" : "Lnet/minecraft/entity/player/EntityPlayer;Z") + ")V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realClonePlayer", "" + (isObfuscated ? "(Lyz;Z)V" : "(Lnet/minecraft/entity/player/EntityPlayer;Z)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "clonePlayer", "" + (isObfuscated ? "(Lyz;Z)V" : "(Lnet/minecraft/entity/player/EntityPlayer;Z)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superClonePlayer", "" + (isObfuscated ? "(Lyz;Z)V" : "(Lnet/minecraft/entity/player/EntityPlayer;Z)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "clonePlayer", "" + (isObfuscated ? "(Lyz;Z)V" : "(Lnet/minecraft/entity/player/EntityPlayer;Z)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalClonePlayer) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localClonePlayer", "" + (isObfuscated ? "(Lyz;Z)V" : "(Lnet/minecraft/entity/player/EntityPlayer;Z)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "clonePlayer", "" + (isObfuscated ? "(Lyz;Z)V" : "(Lnet/minecraft/entity/player/EntityPlayer;Z)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "d" : "damageEntity", "" + (isObfuscated ? "(Lro;F)V" : "(Lnet/minecraft/util/DamageSource;F)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "damageEntity", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Lro;F" : "Lnet/minecraft/util/DamageSource;F") + ")V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realDamageEntity", "" + (isObfuscated ? "(Lro;F)V" : "(Lnet/minecraft/util/DamageSource;F)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "d" : "damageEntity", "" + (isObfuscated ? "(Lro;F)V" : "(Lnet/minecraft/util/DamageSource;F)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superDamageEntity", "" + (isObfuscated ? "(Lro;F)V" : "(Lnet/minecraft/util/DamageSource;F)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "d" : "damageEntity", "" + (isObfuscated ? "(Lro;F)V" : "(Lnet/minecraft/util/DamageSource;F)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalDamageEntity) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDamageEntity", "" + (isObfuscated ? "(Lro;F)V" : "(Lnet/minecraft/util/DamageSource;F)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "d" : "damageEntity", "" + (isObfuscated ? "(Lro;F)V" : "(Lnet/minecraft/util/DamageSource;F)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "displayGUIChest", "" + (isObfuscated ? "(Lrb;)V" : "(Lnet/minecraft/inventory/IInventory;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "displayGUIChest", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Lrb;" : "Lnet/minecraft/inventory/IInventory;") + ")V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realDisplayGUIChest", "" + (isObfuscated ? "(Lrb;)V" : "(Lnet/minecraft/inventory/IInventory;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "displayGUIChest", "" + (isObfuscated ? "(Lrb;)V" : "(Lnet/minecraft/inventory/IInventory;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superDisplayGUIChest", "" + (isObfuscated ? "(Lrb;)V" : "(Lnet/minecraft/inventory/IInventory;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "displayGUIChest", "" + (isObfuscated ? "(Lrb;)V" : "(Lnet/minecraft/inventory/IInventory;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalDisplayGUIChest) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDisplayGUIChest", "" + (isObfuscated ? "(Lrb;)V" : "(Lnet/minecraft/inventory/IInventory;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "displayGUIChest", "" + (isObfuscated ? "(Lrb;)V" : "(Lnet/minecraft/inventory/IInventory;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "func_146102_a", "" + (isObfuscated ? "(Lapb;)V" : "(Lnet/minecraft/tileentity/TileEntityDispenser;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "displayGUIDispenser", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Lapb;" : "Lnet/minecraft/tileentity/TileEntityDispenser;") + ")V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realDisplayGUIDispenser", "" + (isObfuscated ? "(Lapb;)V" : "(Lnet/minecraft/tileentity/TileEntityDispenser;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "func_146102_a", "" + (isObfuscated ? "(Lapb;)V" : "(Lnet/minecraft/tileentity/TileEntityDispenser;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superDisplayGUIDispenser", "" + (isObfuscated ? "(Lapb;)V" : "(Lnet/minecraft/tileentity/TileEntityDispenser;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "func_146102_a", "" + (isObfuscated ? "(Lapb;)V" : "(Lnet/minecraft/tileentity/TileEntityDispenser;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalDisplayGUIDispenser) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDisplayGUIDispenser", "" + (isObfuscated ? "(Lapb;)V" : "(Lnet/minecraft/tileentity/TileEntityDispenser;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "func_146102_a", "" + (isObfuscated ? "(Lapb;)V" : "(Lnet/minecraft/tileentity/TileEntityDispenser;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "func_146101_a", "" + (isObfuscated ? "(Lapg;)V" : "(Lnet/minecraft/tileentity/TileEntityFurnace;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "displayGUIFurnace", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Lapg;" : "Lnet/minecraft/tileentity/TileEntityFurnace;") + ")V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realDisplayGUIFurnace", "" + (isObfuscated ? "(Lapg;)V" : "(Lnet/minecraft/tileentity/TileEntityFurnace;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "func_146101_a", "" + (isObfuscated ? "(Lapg;)V" : "(Lnet/minecraft/tileentity/TileEntityFurnace;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superDisplayGUIFurnace", "" + (isObfuscated ? "(Lapg;)V" : "(Lnet/minecraft/tileentity/TileEntityFurnace;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "func_146101_a", "" + (isObfuscated ? "(Lapg;)V" : "(Lnet/minecraft/tileentity/TileEntityFurnace;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalDisplayGUIFurnace) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDisplayGUIFurnace", "" + (isObfuscated ? "(Lapg;)V" : "(Lnet/minecraft/tileentity/TileEntityFurnace;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "func_146101_a", "" + (isObfuscated ? "(Lapg;)V" : "(Lnet/minecraft/tileentity/TileEntityFurnace;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "b" : "displayGUIWorkbench", "(III)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "displayGUIWorkbench", "(Lapi/player/server/IServerPlayerAPI;III)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realDisplayGUIWorkbench", "(III)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "b" : "displayGUIWorkbench", "(III)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superDisplayGUIWorkbench", "(III)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "b" : "displayGUIWorkbench", "(III)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalDisplayGUIWorkbench) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDisplayGUIWorkbench", "(III)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "b" : "displayGUIWorkbench", "(III)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "dropOneItem", "" + (isObfuscated ? "(Z)Lxk;" : "(Z)Lnet/minecraft/entity/item/EntityItem;") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "dropOneItem", "(Lapi/player/server/IServerPlayerAPI;Z)" + (isObfuscated ? "Lxk;" : "Lnet/minecraft/entity/item/EntityItem;") + ""); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realDropOneItem", "" + (isObfuscated ? "(Z)Lxk;" : "(Z)Lnet/minecraft/entity/item/EntityItem;") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "dropOneItem", "" + (isObfuscated ? "(Z)Lxk;" : "(Z)Lnet/minecraft/entity/item/EntityItem;") + ""); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superDropOneItem", "" + (isObfuscated ? "(Z)Lxk;" : "(Z)Lnet/minecraft/entity/item/EntityItem;") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "dropOneItem", "" + (isObfuscated ? "(Z)Lxk;" : "(Z)Lnet/minecraft/entity/item/EntityItem;") + ""); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalDropOneItem) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDropOneItem", "" + (isObfuscated ? "(Z)Lxk;" : "(Z)Lnet/minecraft/entity/item/EntityItem;") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "dropOneItem", "" + (isObfuscated ? "(Z)Lxk;" : "(Z)Lnet/minecraft/entity/item/EntityItem;") + ""); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "dropPlayerItemWithRandomChoice", "" + (isObfuscated ? "(Ladd;Z)Lxk;" : "(Lnet/minecraft/item/ItemStack;Z)Lnet/minecraft/entity/item/EntityItem;") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "dropPlayerItem", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Ladd;Z" : "Lnet/minecraft/item/ItemStack;Z") + ")" + (isObfuscated ? "Lxk;" : "Lnet/minecraft/entity/item/EntityItem;") + ""); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realDropPlayerItem", "" + (isObfuscated ? "(Ladd;Z)Lxk;" : "(Lnet/minecraft/item/ItemStack;Z)Lnet/minecraft/entity/item/EntityItem;") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "dropPlayerItemWithRandomChoice", "" + (isObfuscated ? "(Ladd;Z)Lxk;" : "(Lnet/minecraft/item/ItemStack;Z)Lnet/minecraft/entity/item/EntityItem;") + ""); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superDropPlayerItem", "" + (isObfuscated ? "(Ladd;Z)Lxk;" : "(Lnet/minecraft/item/ItemStack;Z)Lnet/minecraft/entity/item/EntityItem;") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "dropPlayerItemWithRandomChoice", "" + (isObfuscated ? "(Ladd;Z)Lxk;" : "(Lnet/minecraft/item/ItemStack;Z)Lnet/minecraft/entity/item/EntityItem;") + ""); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalDropPlayerItem) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localDropPlayerItem", "" + (isObfuscated ? "(Ladd;Z)Lxk;" : "(Lnet/minecraft/item/ItemStack;Z)Lnet/minecraft/entity/item/EntityItem;") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "dropPlayerItemWithRandomChoice", "" + (isObfuscated ? "(Ladd;Z)Lxk;" : "(Lnet/minecraft/item/ItemStack;Z)Lnet/minecraft/entity/item/EntityItem;") + ""); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "b" : "fall", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "fall", "(Lapi/player/server/IServerPlayerAPI;F)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realFall", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "b" : "fall", "(F)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superFall", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "b" : "fall", "(F)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalFall) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localFall", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "b" : "fall", "(F)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "bl" : "getAIMoveSpeed", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "getAIMoveSpeed", "(Lapi/player/server/IServerPlayerAPI;)F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realGetAIMoveSpeed", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bl" : "getAIMoveSpeed", "()F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superGetAIMoveSpeed", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "bl" : "getAIMoveSpeed", "()F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalGetAIMoveSpeed) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localGetAIMoveSpeed", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "bl" : "getAIMoveSpeed", "()F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "getCurrentPlayerStrVsBlock", "" + (isObfuscated ? "(Laji;Z)F" : "(Lnet/minecraft/block/Block;Z)F") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "getCurrentPlayerStrVsBlock", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Laji;Z" : "Lnet/minecraft/block/Block;Z") + ")F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realGetCurrentPlayerStrVsBlock", "" + (isObfuscated ? "(Laji;Z)F" : "(Lnet/minecraft/block/Block;Z)F") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "getCurrentPlayerStrVsBlock", "" + (isObfuscated ? "(Laji;Z)F" : "(Lnet/minecraft/block/Block;Z)F") + ""); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superGetCurrentPlayerStrVsBlock", "" + (isObfuscated ? "(Laji;Z)F" : "(Lnet/minecraft/block/Block;Z)F") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "getCurrentPlayerStrVsBlock", "" + (isObfuscated ? "(Laji;Z)F" : "(Lnet/minecraft/block/Block;Z)F") + ""); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalGetCurrentPlayerStrVsBlock) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localGetCurrentPlayerStrVsBlock", "" + (isObfuscated ? "(Laji;Z)F" : "(Lnet/minecraft/block/Block;Z)F") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "getCurrentPlayerStrVsBlock", "" + (isObfuscated ? "(Laji;Z)F" : "(Lnet/minecraft/block/Block;Z)F") + ""); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, "getBreakSpeed", "" + (isObfuscated ? "(Laji;ZI)F" : "(Lnet/minecraft/block/Block;ZI)F") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "getCurrentPlayerStrVsBlockForge", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Laji;ZI" : "Lnet/minecraft/block/Block;ZI") + ")F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realGetCurrentPlayerStrVsBlockForge", "" + (isObfuscated ? "(Laji;ZI)F" : "(Lnet/minecraft/block/Block;ZI)F") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", "getBreakSpeed", "" + (isObfuscated ? "(Laji;ZI)F" : "(Lnet/minecraft/block/Block;ZI)F") + ""); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superGetCurrentPlayerStrVsBlockForge", "" + (isObfuscated ? "(Laji;ZI)F" : "(Lnet/minecraft/block/Block;ZI)F") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", "getBreakSpeed", "" + (isObfuscated ? "(Laji;ZI)F" : "(Lnet/minecraft/block/Block;ZI)F") + ""); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalGetCurrentPlayerStrVsBlockForge) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localGetCurrentPlayerStrVsBlockForge", "" + (isObfuscated ? "(Laji;ZI)F" : "(Lnet/minecraft/block/Block;ZI)F") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", "getBreakSpeed", "" + (isObfuscated ? "(Laji;ZI)F" : "(Lnet/minecraft/block/Block;ZI)F") + ""); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "e" : "getDistanceSq", "(DDD)D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "getDistanceSq", "(Lapi/player/server/IServerPlayerAPI;DDD)D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realGetDistanceSq", "(DDD)D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "e" : "getDistanceSq", "(DDD)D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superGetDistanceSq", "(DDD)D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "e" : "getDistanceSq", "(DDD)D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalGetDistanceSq) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localGetDistanceSq", "(DDD)D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "e" : "getDistanceSq", "(DDD)D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "d" : "getBrightness", "(F)F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "getBrightness", "(Lapi/player/server/IServerPlayerAPI;F)F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realGetBrightness", "(F)F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "d" : "getBrightness", "(F)F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superGetBrightness", "(F)F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "d" : "getBrightness", "(F)F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalGetBrightness) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localGetBrightness", "(F)F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "d" : "getBrightness", "(F)F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "g" : "getEyeHeight", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "getEyeHeight", "(Lapi/player/server/IServerPlayerAPI;)F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realGetEyeHeight", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "g" : "getEyeHeight", "()F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superGetEyeHeight", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "g" : "getEyeHeight", "()F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalGetEyeHeight) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localGetEyeHeight", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "g" : "getEyeHeight", "()F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "f" : "heal", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "heal", "(Lapi/player/server/IServerPlayerAPI;F)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realHeal", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "f" : "heal", "(F)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superHeal", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "f" : "heal", "(F)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalHeal) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localHeal", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "f" : "heal", "(F)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "aa" : "isEntityInsideOpaqueBlock", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "isEntityInsideOpaqueBlock", "(Lapi/player/server/IServerPlayerAPI;)Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realIsEntityInsideOpaqueBlock", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aa" : "isEntityInsideOpaqueBlock", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superIsEntityInsideOpaqueBlock", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "aa" : "isEntityInsideOpaqueBlock", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalIsEntityInsideOpaqueBlock) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localIsEntityInsideOpaqueBlock", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "aa" : "isEntityInsideOpaqueBlock", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "M" : "isInWater", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "isInWater", "(Lapi/player/server/IServerPlayerAPI;)Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realIsInWater", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "M" : "isInWater", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superIsInWater", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "M" : "isInWater", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalIsInWater) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localIsInWater", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "M" : "isInWater", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "isInsideOfMaterial", "" + (isObfuscated ? "(Lawt;)Z" : "(Lnet/minecraft/block/material/Material;)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "isInsideOfMaterial", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Lawt;" : "Lnet/minecraft/block/material/Material;") + ")Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realIsInsideOfMaterial", "" + (isObfuscated ? "(Lawt;)Z" : "(Lnet/minecraft/block/material/Material;)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "isInsideOfMaterial", "" + (isObfuscated ? "(Lawt;)Z" : "(Lnet/minecraft/block/material/Material;)Z") + ""); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superIsInsideOfMaterial", "" + (isObfuscated ? "(Lawt;)Z" : "(Lnet/minecraft/block/material/Material;)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "isInsideOfMaterial", "" + (isObfuscated ? "(Lawt;)Z" : "(Lnet/minecraft/block/material/Material;)Z") + ""); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalIsInsideOfMaterial) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localIsInsideOfMaterial", "" + (isObfuscated ? "(Lawt;)Z" : "(Lnet/minecraft/block/material/Material;)Z") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "isInsideOfMaterial", "" + (isObfuscated ? "(Lawt;)Z" : "(Lnet/minecraft/block/material/Material;)Z") + ""); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "h_" : "isOnLadder", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "isOnLadder", "(Lapi/player/server/IServerPlayerAPI;)Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realIsOnLadder", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "h_" : "isOnLadder", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superIsOnLadder", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "h_" : "isOnLadder", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalIsOnLadder) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localIsOnLadder", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "h_" : "isOnLadder", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "bm" : "isPlayerSleeping", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "isPlayerSleeping", "(Lapi/player/server/IServerPlayerAPI;)Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realIsPlayerSleeping", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bm" : "isPlayerSleeping", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superIsPlayerSleeping", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "bm" : "isPlayerSleeping", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalIsPlayerSleeping) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localIsPlayerSleeping", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "bm" : "isPlayerSleeping", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "an" : "isSneaking", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "isSneaking", "(Lapi/player/server/IServerPlayerAPI;)Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realIsSneaking", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "an" : "isSneaking", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superIsSneaking", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "an" : "isSneaking", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalIsSneaking) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localIsSneaking", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "an" : "isSneaking", "()Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "bj" : "jump", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "jump", "(Lapi/player/server/IServerPlayerAPI;)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realJump", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bj" : "jump", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superJump", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "bj" : "jump", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalJump) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localJump", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "bj" : "jump", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "knockBack", "" + (isObfuscated ? "(Lsa;FDD)V" : "(Lnet/minecraft/entity/Entity;FDD)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "knockBack", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Lsa;FDD" : "Lnet/minecraft/entity/Entity;FDD") + ")V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realKnockBack", "" + (isObfuscated ? "(Lsa;FDD)V" : "(Lnet/minecraft/entity/Entity;FDD)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "knockBack", "" + (isObfuscated ? "(Lsa;FDD)V" : "(Lnet/minecraft/entity/Entity;FDD)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superKnockBack", "" + (isObfuscated ? "(Lsa;FDD)V" : "(Lnet/minecraft/entity/Entity;FDD)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "knockBack", "" + (isObfuscated ? "(Lsa;FDD)V" : "(Lnet/minecraft/entity/Entity;FDD)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalKnockBack) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localKnockBack", "" + (isObfuscated ? "(Lsa;FDD)V" : "(Lnet/minecraft/entity/Entity;FDD)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "knockBack", "" + (isObfuscated ? "(Lsa;FDD)V" : "(Lnet/minecraft/entity/Entity;FDD)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "mountEntity", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "mountEntity", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Lsa;" : "Lnet/minecraft/entity/Entity;") + ")V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realMountEntity", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "mountEntity", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superMountEntity", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "mountEntity", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalMountEntity) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localMountEntity", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "mountEntity", "" + (isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "d" : "moveEntity", "(DDD)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "moveEntity", "(Lapi/player/server/IServerPlayerAPI;DDD)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realMoveEntity", "(DDD)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "d" : "moveEntity", "(DDD)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superMoveEntity", "(DDD)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "d" : "moveEntity", "(DDD)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalMoveEntity) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localMoveEntity", "(DDD)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "d" : "moveEntity", "(DDD)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "e" : "moveEntityWithHeading", "(FF)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "moveEntityWithHeading", "(Lapi/player/server/IServerPlayerAPI;FF)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realMoveEntityWithHeading", "(FF)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "e" : "moveEntityWithHeading", "(FF)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superMoveEntityWithHeading", "(FF)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "e" : "moveEntityWithHeading", "(FF)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalMoveEntityWithHeading) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localMoveEntityWithHeading", "(FF)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "e" : "moveEntityWithHeading", "(FF)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "moveFlying", "(FFF)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitVarInsn(Opcodes.FLOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "moveFlying", "(Lapi/player/server/IServerPlayerAPI;FFF)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realMoveFlying", "(FFF)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitVarInsn(Opcodes.FLOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "moveFlying", "(FFF)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superMoveFlying", "(FFF)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitVarInsn(Opcodes.FLOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "moveFlying", "(FFF)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalMoveFlying) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localMoveFlying", "(FFF)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitVarInsn(Opcodes.FLOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "moveFlying", "(FFF)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "onDeath", "" + (isObfuscated ? "(Lro;)V" : "(Lnet/minecraft/util/DamageSource;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "onDeath", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Lro;" : "Lnet/minecraft/util/DamageSource;") + ")V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realOnDeath", "" + (isObfuscated ? "(Lro;)V" : "(Lnet/minecraft/util/DamageSource;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "onDeath", "" + (isObfuscated ? "(Lro;)V" : "(Lnet/minecraft/util/DamageSource;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superOnDeath", "" + (isObfuscated ? "(Lro;)V" : "(Lnet/minecraft/util/DamageSource;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "onDeath", "" + (isObfuscated ? "(Lro;)V" : "(Lnet/minecraft/util/DamageSource;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalOnDeath) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localOnDeath", "" + (isObfuscated ? "(Lro;)V" : "(Lnet/minecraft/util/DamageSource;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "onDeath", "" + (isObfuscated ? "(Lro;)V" : "(Lnet/minecraft/util/DamageSource;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "e" : "onLivingUpdate", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "onLivingUpdate", "(Lapi/player/server/IServerPlayerAPI;)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realOnLivingUpdate", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "e" : "onLivingUpdate", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superOnLivingUpdate", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "e" : "onLivingUpdate", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalOnLivingUpdate) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localOnLivingUpdate", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "e" : "onLivingUpdate", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "onKillEntity", "" + (isObfuscated ? "(Lsv;)V" : "(Lnet/minecraft/entity/EntityLivingBase;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "onKillEntity", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Lsv;" : "Lnet/minecraft/entity/EntityLivingBase;") + ")V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realOnKillEntity", "" + (isObfuscated ? "(Lsv;)V" : "(Lnet/minecraft/entity/EntityLivingBase;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "onKillEntity", "" + (isObfuscated ? "(Lsv;)V" : "(Lnet/minecraft/entity/EntityLivingBase;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superOnKillEntity", "" + (isObfuscated ? "(Lsv;)V" : "(Lnet/minecraft/entity/EntityLivingBase;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "onKillEntity", "" + (isObfuscated ? "(Lsv;)V" : "(Lnet/minecraft/entity/EntityLivingBase;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalOnKillEntity) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localOnKillEntity", "" + (isObfuscated ? "(Lsv;)V" : "(Lnet/minecraft/entity/EntityLivingBase;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "onKillEntity", "" + (isObfuscated ? "(Lsv;)V" : "(Lnet/minecraft/entity/EntityLivingBase;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "onStruckByLightning", "" + (isObfuscated ? "(Lxh;)V" : "(Lnet/minecraft/entity/effect/EntityLightningBolt;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "onStruckByLightning", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Lxh;" : "Lnet/minecraft/entity/effect/EntityLightningBolt;") + ")V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realOnStruckByLightning", "" + (isObfuscated ? "(Lxh;)V" : "(Lnet/minecraft/entity/effect/EntityLightningBolt;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "onStruckByLightning", "" + (isObfuscated ? "(Lxh;)V" : "(Lnet/minecraft/entity/effect/EntityLightningBolt;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superOnStruckByLightning", "" + (isObfuscated ? "(Lxh;)V" : "(Lnet/minecraft/entity/effect/EntityLightningBolt;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "onStruckByLightning", "" + (isObfuscated ? "(Lxh;)V" : "(Lnet/minecraft/entity/effect/EntityLightningBolt;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalOnStruckByLightning) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localOnStruckByLightning", "" + (isObfuscated ? "(Lxh;)V" : "(Lnet/minecraft/entity/effect/EntityLightningBolt;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "onStruckByLightning", "" + (isObfuscated ? "(Lxh;)V" : "(Lnet/minecraft/entity/effect/EntityLightningBolt;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "h" : "onUpdate", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "onUpdate", "(Lapi/player/server/IServerPlayerAPI;)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realOnUpdate", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "h" : "onUpdate", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superOnUpdate", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "h" : "onUpdate", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalOnUpdate) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localOnUpdate", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "h" : "onUpdate", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "i" : "onUpdateEntity", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "onUpdateEntity", "(Lapi/player/server/IServerPlayerAPI;)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realOnUpdateEntity", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "i" : "onUpdateEntity", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superOnUpdateEntity", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "i" : "onUpdateEntity", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalOnUpdateEntity) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localOnUpdateEntity", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "i" : "onUpdateEntity", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "readEntityFromNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "readEntityFromNBT", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Ldh;" : "Lnet/minecraft/nbt/NBTTagCompound;") + ")V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realReadEntityFromNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "readEntityFromNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superReadEntityFromNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "readEntityFromNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalReadEntityFromNBT) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localReadEntityFromNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "readEntityFromNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "B" : "setDead", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "setDead", "(Lapi/player/server/IServerPlayerAPI;)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realSetDead", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "B" : "setDead", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superSetDead", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "B" : "setDead", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalSetDead) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localSetDead", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "B" : "setDead", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "setEntityActionState", "(FFZZ)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitVarInsn(Opcodes.ILOAD, 4); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "setEntityActionState", "(Lapi/player/server/IServerPlayerAPI;FFZZ)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realSetEntityActionState", "(FFZZ)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitVarInsn(Opcodes.ILOAD, 4); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "setEntityActionState", "(FFZZ)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superSetEntityActionState", "(FFZZ)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitVarInsn(Opcodes.ILOAD, 4); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "setEntityActionState", "(FFZZ)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalSetEntityActionState) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localSetEntityActionState", "(FFZZ)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitVarInsn(Opcodes.FLOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitVarInsn(Opcodes.ILOAD, 4); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "setEntityActionState", "(FFZZ)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "b" : "setPosition", "(DDD)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "setPosition", "(Lapi/player/server/IServerPlayerAPI;DDD)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realSetPosition", "(DDD)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "b" : "setPosition", "(DDD)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superSetPosition", "(DDD)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "b" : "setPosition", "(DDD)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalSetPosition) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localSetPosition", "(DDD)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitVarInsn(Opcodes.DLOAD, 3); + mv.visitVarInsn(Opcodes.DLOAD, 5); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "b" : "setPosition", "(DDD)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "b" : "setSneaking", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "setSneaking", "(Lapi/player/server/IServerPlayerAPI;Z)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realSetSneaking", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "b" : "setSneaking", "(Z)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superSetSneaking", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "b" : "setSneaking", "(Z)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalSetSneaking) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localSetSneaking", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "b" : "setSneaking", "(Z)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "c" : "setSprinting", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "setSprinting", "(Lapi/player/server/IServerPlayerAPI;Z)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realSetSprinting", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "c" : "setSprinting", "(Z)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superSetSprinting", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "c" : "setSprinting", "(Z)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalSetSprinting) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localSetSprinting", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "c" : "setSprinting", "(Z)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "ba" : "swingItem", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "swingItem", "(Lapi/player/server/IServerPlayerAPI;)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realSwingItem", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ba" : "swingItem", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superSwingItem", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "ba" : "swingItem", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalSwingItem) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localSwingItem", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "ba" : "swingItem", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "bq" : "updateEntityActionState", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "updateEntityActionState", "(Lapi/player/server/IServerPlayerAPI;)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realUpdateEntityActionState", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bq" : "updateEntityActionState", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superUpdateEntityActionState", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "bq" : "updateEntityActionState", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalUpdateEntityActionState) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localUpdateEntityActionState", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "bq" : "updateEntityActionState", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "aO" : "updatePotionEffects", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "updatePotionEffects", "(Lapi/player/server/IServerPlayerAPI;)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realUpdatePotionEffects", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aO" : "updatePotionEffects", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superUpdatePotionEffects", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "aO" : "updatePotionEffects", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalUpdatePotionEffects) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localUpdatePotionEffects", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "aO" : "updatePotionEffects", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "ab" : "updateRidden", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "updateRidden", "(Lapi/player/server/IServerPlayerAPI;)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realUpdateRidden", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ab" : "updateRidden", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superUpdateRidden", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "ab" : "updateRidden", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalUpdateRidden) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localUpdateRidden", "()V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "ab" : "updateRidden", "()V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "a" : "wakeUpPlayer", "(ZZZ)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "wakeUpPlayer", "(Lapi/player/server/IServerPlayerAPI;ZZZ)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realWakeUpPlayer", "(ZZZ)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "wakeUpPlayer", "(ZZZ)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superWakeUpPlayer", "(ZZZ)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "wakeUpPlayer", "(ZZZ)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalWakeUpPlayer) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localWakeUpPlayer", "(ZZZ)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitVarInsn(Opcodes.ILOAD, 2); + mv.visitVarInsn(Opcodes.ILOAD, 3); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "a" : "wakeUpPlayer", "(ZZZ)V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC, isObfuscated ? "b" : "writeEntityToNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "writeEntityToNBT", "(Lapi/player/server/IServerPlayerAPI;" + (isObfuscated ? "Ldh;" : "Lnet/minecraft/nbt/NBTTagCompound;") + ")V"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "realWriteEntityToNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "b" : "writeEntityToNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "superWriteEntityToNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "b" : "writeEntityToNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + if(!hadLocalWriteEntityToNBT) + { + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "localWriteEntityToNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + "", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer", isObfuscated ? "b" : "writeEntityToNBT", "" + (isObfuscated ? "(Ldh;)V" : "(Lnet/minecraft/nbt/NBTTagCompound;)V") + ""); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getAddedToChunkField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ag" : "addedToChunk", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setAddedToChunkField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ag" : "addedToChunk", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getArrowHitTimerField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "av" : "arrowHitTimer", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setArrowHitTimerField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "av" : "arrowHitTimer", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getAttackTimeField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aB" : "attackTime", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setAttackTimeField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aB" : "attackTime", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getAttackedAtYawField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "az" : "attackedAtYaw", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setAttackedAtYawField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "az" : "attackedAtYaw", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getAttackingPlayerField", isObfuscated ? "()Lyz;" : "()Lnet/minecraft/entity/player/EntityPlayer;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aR" : "attackingPlayer", isObfuscated ? "Lyz;" : "Lnet/minecraft/entity/player/EntityPlayer;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setAttackingPlayerField", isObfuscated ? "(Lyz;)V" : "(Lnet/minecraft/entity/player/EntityPlayer;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aR" : "attackingPlayer", isObfuscated ? "Lyz;" : "Lnet/minecraft/entity/player/EntityPlayer;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getBoundingBoxField", isObfuscated ? "()Lazt;" : "()Lnet/minecraft/util/AxisAlignedBB;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "C" : "boundingBox", isObfuscated ? "Lazt;" : "Lnet/minecraft/util/AxisAlignedBB;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getCameraPitchField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aJ" : "cameraPitch", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setCameraPitchField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aJ" : "cameraPitch", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getCameraYawField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bs" : "cameraYaw", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setCameraYawField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bs" : "cameraYaw", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getCapabilitiesField", isObfuscated ? "()Lyw;" : "()Lnet/minecraft/entity/player/PlayerCapabilities;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bE" : "capabilities", isObfuscated ? "Lyw;" : "Lnet/minecraft/entity/player/PlayerCapabilities;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setCapabilitiesField", isObfuscated ? "(Lyw;)V" : "(Lnet/minecraft/entity/player/PlayerCapabilities;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bE" : "capabilities", isObfuscated ? "Lyw;" : "Lnet/minecraft/entity/player/PlayerCapabilities;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getChatColoursField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bW" : "chatColours", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setChatColoursField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bW" : "chatColours", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getChatVisibilityField", isObfuscated ? "()Lzb;" : "()Lnet/minecraft/entity/player/EntityPlayer$EnumChatVisibility;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bV" : "chatVisibility", isObfuscated ? "Lzb;" : "Lnet/minecraft/entity/player/EntityPlayer$EnumChatVisibility;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setChatVisibilityField", isObfuscated ? "(Lzb;)V" : "(Lnet/minecraft/entity/player/EntityPlayer$EnumChatVisibility;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bV" : "chatVisibility", isObfuscated ? "Lzb;" : "Lnet/minecraft/entity/player/EntityPlayer$EnumChatVisibility;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getChunkCoordXField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ah" : "chunkCoordX", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setChunkCoordXField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ah" : "chunkCoordX", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getChunkCoordYField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ai" : "chunkCoordY", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setChunkCoordYField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ai" : "chunkCoordY", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getChunkCoordZField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aj" : "chunkCoordZ", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setChunkCoordZField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aj" : "chunkCoordZ", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getCurrentWindowIdField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bY" : "currentWindowId", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setCurrentWindowIdField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bY" : "currentWindowId", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getDataWatcherField", isObfuscated ? "()Lte;" : "()Lnet/minecraft/entity/DataWatcher;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "af" : "dataWatcher", isObfuscated ? "Lte;" : "Lnet/minecraft/entity/DataWatcher;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setDataWatcherField", isObfuscated ? "(Lte;)V" : "(Lnet/minecraft/entity/DataWatcher;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "af" : "dataWatcher", isObfuscated ? "Lte;" : "Lnet/minecraft/entity/DataWatcher;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getDeadField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aT" : "dead", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setDeadField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aT" : "dead", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getDeathTimeField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aA" : "deathTime", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setDeathTimeField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aA" : "deathTime", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getDestroyedItemsNetCacheField", "()Ljava/util/List;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bN" : "destroyedItemsNetCache", "Ljava/util/List;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getDimensionField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ap" : "dimension", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setDimensionField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ap" : "dimension", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getDistanceWalkedModifiedField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "P" : "distanceWalkedModified", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setDistanceWalkedModifiedField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "P" : "distanceWalkedModified", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getDistanceWalkedOnStepModifiedField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "Q" : "distanceWalkedOnStepModified", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setDistanceWalkedOnStepModifiedField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "Q" : "distanceWalkedOnStepModified", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getEntityAgeField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aU" : "entityAge", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setEntityAgeField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aU" : "entityAge", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getEntityCollisionReductionField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "Y" : "entityCollisionReduction", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setEntityCollisionReductionField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "Y" : "entityCollisionReduction", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getEntityUniqueIDField", "()Ljava/util/UUID;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ar" : "entityUniqueID", "Ljava/util/UUID;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setEntityUniqueIDField", "(Ljava/util/UUID;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ar" : "entityUniqueID", "Ljava/util/UUID;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getExperienceField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bH" : "experience", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setExperienceField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bH" : "experience", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getExperienceLevelField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bF" : "experienceLevel", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setExperienceLevelField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bF" : "experienceLevel", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getExperienceTotalField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bG" : "experienceTotal", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setExperienceTotalField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bG" : "experienceTotal", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getFallDistanceField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "R" : "fallDistance", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setFallDistanceField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "R" : "fallDistance", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_110154_aXField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aW" : "field_110154_aX", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_110154_aXField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aW" : "field_110154_aX", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_130068_bOField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bP" : "field_130068_bO", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_130068_bOField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bP" : "field_130068_bO", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_143005_bXField", "()J", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bX" : "field_143005_bX", "J"); + mv.visitInsn(Opcodes.LRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_143005_bXField", "(J)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.LLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bX" : "field_143005_bX", "J"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_147101_bUField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bU" : "field_147101_bU", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_147101_bUField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bU" : "field_147101_bU", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_147103_bOField", isObfuscated ? "()Lpg;" : "()Lnet/minecraft/stats/StatisticsFile;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bO" : "field_147103_bO", isObfuscated ? "Lpg;" : "Lnet/minecraft/stats/StatisticsFile;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_70135_KField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "J" : "field_70135_K", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_70135_KField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "J" : "field_70135_K", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_70741_aBField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aZ" : "field_70741_aB", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_70741_aBField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aZ" : "field_70741_aB", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_70763_axField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aY" : "field_70763_ax", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_70763_axField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aY" : "field_70763_ax", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_70764_awField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aX" : "field_70764_aw", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_70764_awField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aX" : "field_70764_aw", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_70768_auField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aV" : "field_70768_au", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_70768_auField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aV" : "field_70768_au", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_70769_aoField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aK" : "field_70769_ao", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_70769_aoField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aK" : "field_70769_ao", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_70770_apField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aL" : "field_70770_ap", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_70770_apField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aL" : "field_70770_ap", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_71079_bUField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bC" : "field_71079_bU", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_71079_bUField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bC" : "field_71079_bU", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_71082_cxField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "cc" : "field_71082_cx", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_71082_cxField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "cc" : "field_71082_cx", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_71085_bRField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bz" : "field_71085_bR", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_71085_bRField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bz" : "field_71085_bR", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_71089_bVField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bD" : "field_71089_bV", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_71089_bVField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bD" : "field_71089_bV", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_71091_bMField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bu" : "field_71091_bM", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_71091_bMField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bu" : "field_71091_bM", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_71094_bPField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bx" : "field_71094_bP", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_71094_bPField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bx" : "field_71094_bP", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_71095_bQField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "by" : "field_71095_bQ", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_71095_bQField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "by" : "field_71095_bQ", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_71096_bNField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bv" : "field_71096_bN", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_71096_bNField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bv" : "field_71096_bN", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getField_71097_bOField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bw" : "field_71097_bO", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setField_71097_bOField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bw" : "field_71097_bO", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getFireResistanceField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ab" : "fireResistance", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setFireResistanceField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ab" : "fireResistance", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getFishEntityField", isObfuscated ? "()Lxe;" : "()Lnet/minecraft/entity/projectile/EntityFishHook;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bK" : "fishEntity", isObfuscated ? "Lxe;" : "Lnet/minecraft/entity/projectile/EntityFishHook;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setFishEntityField", isObfuscated ? "(Lxe;)V" : "(Lnet/minecraft/entity/projectile/EntityFishHook;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bK" : "fishEntity", isObfuscated ? "Lxe;" : "Lnet/minecraft/entity/projectile/EntityFishHook;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getFlyToggleTimerField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bq" : "flyToggleTimer", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setFlyToggleTimerField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bq" : "flyToggleTimer", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getFoodStatsField", isObfuscated ? "()Lzr;" : "()Lnet/minecraft/util/FoodStats;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bp" : "foodStats", isObfuscated ? "Lzr;" : "Lnet/minecraft/util/FoodStats;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setFoodStatsField", isObfuscated ? "(Lzr;)V" : "(Lnet/minecraft/util/FoodStats;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bp" : "foodStats", isObfuscated ? "Lzr;" : "Lnet/minecraft/util/FoodStats;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getForceSpawnField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "n" : "forceSpawn", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setForceSpawnField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "n" : "forceSpawn", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getHeightField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "N" : "height", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setHeightField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "N" : "height", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getHurtResistantTimeField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ad" : "hurtResistantTime", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setHurtResistantTimeField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ad" : "hurtResistantTime", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getHurtTimeField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ax" : "hurtTime", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setHurtTimeField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ax" : "hurtTime", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getIgnoreFrustumCheckField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ak" : "ignoreFrustumCheck", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setIgnoreFrustumCheckField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ak" : "ignoreFrustumCheck", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getInPortalField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "an" : "inPortal", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setInPortalField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "an" : "inPortal", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getInWaterField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ac" : "inWater", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setInWaterField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ac" : "inWater", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getInventoryField", isObfuscated ? "()Lyx;" : "()Lnet/minecraft/entity/player/InventoryPlayer;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bm" : "inventory", isObfuscated ? "Lyx;" : "Lnet/minecraft/entity/player/InventoryPlayer;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setInventoryField", isObfuscated ? "(Lyx;)V" : "(Lnet/minecraft/entity/player/InventoryPlayer;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bm" : "inventory", isObfuscated ? "Lyx;" : "Lnet/minecraft/entity/player/InventoryPlayer;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getInventoryContainerField", isObfuscated ? "()Lzs;" : "()Lnet/minecraft/inventory/Container;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bn" : "inventoryContainer", isObfuscated ? "Lzs;" : "Lnet/minecraft/inventory/Container;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setInventoryContainerField", isObfuscated ? "(Lzs;)V" : "(Lnet/minecraft/inventory/Container;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bn" : "inventoryContainer", isObfuscated ? "Lzs;" : "Lnet/minecraft/inventory/Container;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getIsAirBorneField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "al" : "isAirBorne", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setIsAirBorneField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "al" : "isAirBorne", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getIsChangingQuantityOnlyField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "g" : "isChangingQuantityOnly", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setIsChangingQuantityOnlyField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "g" : "isChangingQuantityOnly", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getIsCollidedField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "G" : "isCollided", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setIsCollidedField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "G" : "isCollided", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getIsCollidedHorizontallyField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "E" : "isCollidedHorizontally", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setIsCollidedHorizontallyField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "E" : "isCollidedHorizontally", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getIsCollidedVerticallyField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "F" : "isCollidedVertically", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setIsCollidedVerticallyField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "F" : "isCollidedVertically", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getIsDeadField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "K" : "isDead", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setIsDeadField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "K" : "isDead", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getIsImmuneToFireField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ae" : "isImmuneToFire", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setIsImmuneToFireField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ae" : "isImmuneToFire", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getIsInWebField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "I" : "isInWeb", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setIsInWebField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "I" : "isInWeb", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getIsJumpingField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bc" : "isJumping", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setIsJumpingField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bc" : "isJumping", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getIsSwingInProgressField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "at" : "isSwingInProgress", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setIsSwingInProgressField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "at" : "isSwingInProgress", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getJumpMovementFactorField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aQ" : "jumpMovementFactor", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setJumpMovementFactorField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aQ" : "jumpMovementFactor", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getLastDamageField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bb" : "lastDamage", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setLastDamageField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bb" : "lastDamage", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getLastExperienceField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bT" : "lastExperience", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setLastExperienceField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bT" : "lastExperience", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getLastFoodLevelField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bR" : "lastFoodLevel", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setLastFoodLevelField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bR" : "lastFoodLevel", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getLastHealthField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bQ" : "lastHealth", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setLastHealthField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bQ" : "lastHealth", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getLastTickPosXField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "S" : "lastTickPosX", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setLastTickPosXField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "S" : "lastTickPosX", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getLastTickPosYField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "T" : "lastTickPosY", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setLastTickPosYField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "T" : "lastTickPosY", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getLastTickPosZField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "U" : "lastTickPosZ", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setLastTickPosZField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "U" : "lastTickPosZ", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getLimbSwingField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aG" : "limbSwing", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setLimbSwingField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aG" : "limbSwing", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getLimbSwingAmountField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aF" : "limbSwingAmount", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setLimbSwingAmountField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aF" : "limbSwingAmount", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getLoadedChunksField", "()Ljava/util/List;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "f" : "loadedChunks", "Ljava/util/List;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getLoggerField", "()Lorg/apache/logging/log4j/Logger;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bL" : "logger", "Lorg/apache/logging/log4j/Logger;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getManagedPosXField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "d" : "managedPosX", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setManagedPosXField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "d" : "managedPosX", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getManagedPosZField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "e" : "managedPosZ", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setManagedPosZField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "e" : "managedPosZ", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getMaxHurtResistantTimeField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aH" : "maxHurtResistantTime", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setMaxHurtResistantTimeField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aH" : "maxHurtResistantTime", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getMaxHurtTimeField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ay" : "maxHurtTime", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setMaxHurtTimeField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ay" : "maxHurtTime", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getMcServerField", "()Lnet/minecraft/server/MinecraftServer;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "b" : "mcServer", "Lnet/minecraft/server/MinecraftServer;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getMotionXField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "v" : "motionX", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setMotionXField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "v" : "motionX", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getMotionYField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "w" : "motionY", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setMotionYField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "w" : "motionY", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getMotionZField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "x" : "motionZ", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setMotionZField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "x" : "motionZ", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getMoveForwardField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "be" : "moveForward", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setMoveForwardField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "be" : "moveForward", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getMoveStrafingField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bd" : "moveStrafing", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setMoveStrafingField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bd" : "moveStrafing", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getMyEntitySizeField", isObfuscated ? "()Lse;" : "()Lnet/minecraft/entity/Entity$EnumEntitySize;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "as" : "myEntitySize", isObfuscated ? "Lse;" : "Lnet/minecraft/entity/Entity$EnumEntitySize;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setMyEntitySizeField", isObfuscated ? "(Lse;)V" : "(Lnet/minecraft/entity/Entity$EnumEntitySize;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "as" : "myEntitySize", isObfuscated ? "Lse;" : "Lnet/minecraft/entity/Entity$EnumEntitySize;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getNewPosRotationIncrementsField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bg" : "newPosRotationIncrements", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setNewPosRotationIncrementsField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bg" : "newPosRotationIncrements", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getNewPosXField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bh" : "newPosX", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setNewPosXField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bh" : "newPosX", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getNewPosYField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bi" : "newPosY", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setNewPosYField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bi" : "newPosY", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getNewPosZField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bj" : "newPosZ", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setNewPosZField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bj" : "newPosZ", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getNewRotationPitchField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bl" : "newRotationPitch", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setNewRotationPitchField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bl" : "newRotationPitch", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getNewRotationYawField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bk" : "newRotationYaw", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setNewRotationYawField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bk" : "newRotationYaw", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getNoClipField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "X" : "noClip", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setNoClipField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "X" : "noClip", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getOnGroundField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "D" : "onGround", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setOnGroundField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "D" : "onGround", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getOpenContainerField", isObfuscated ? "()Lzs;" : "()Lnet/minecraft/inventory/Container;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bo" : "openContainer", isObfuscated ? "Lzs;" : "Lnet/minecraft/inventory/Container;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setOpenContainerField", isObfuscated ? "(Lzs;)V" : "(Lnet/minecraft/inventory/Container;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bo" : "openContainer", isObfuscated ? "Lzs;" : "Lnet/minecraft/inventory/Container;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPingField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "h" : "ping", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPingField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "h" : "ping", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPlayerConqueredTheEndField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "i" : "playerConqueredTheEnd", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPlayerConqueredTheEndField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "i" : "playerConqueredTheEnd", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPlayerLocationField", isObfuscated ? "()Lr;" : "()Lnet/minecraft/util/ChunkCoordinates;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bB" : "playerLocation", isObfuscated ? "Lr;" : "Lnet/minecraft/util/ChunkCoordinates;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPlayerLocationField", isObfuscated ? "(Lr;)V" : "(Lnet/minecraft/util/ChunkCoordinates;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bB" : "playerLocation", isObfuscated ? "Lr;" : "Lnet/minecraft/util/ChunkCoordinates;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPlayerNetServerHandlerField", isObfuscated ? "()Lnh;" : "()Lnet/minecraft/network/NetHandlerPlayServer;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "playerNetServerHandler", isObfuscated ? "Lnh;" : "Lnet/minecraft/network/NetHandlerPlayServer;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPlayerNetServerHandlerField", isObfuscated ? "(Lnh;)V" : "(Lnet/minecraft/network/NetHandlerPlayServer;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "a" : "playerNetServerHandler", isObfuscated ? "Lnh;" : "Lnet/minecraft/network/NetHandlerPlayServer;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPortalCounterField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ao" : "portalCounter", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPortalCounterField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ao" : "portalCounter", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPosXField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "s" : "posX", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPosXField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "s" : "posX", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPosYField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "t" : "posY", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPosYField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "t" : "posY", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPosZField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "u" : "posZ", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPosZField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "u" : "posZ", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPrevCameraPitchField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aI" : "prevCameraPitch", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPrevCameraPitchField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aI" : "prevCameraPitch", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPrevCameraYawField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "br" : "prevCameraYaw", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPrevCameraYawField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "br" : "prevCameraYaw", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPrevDistanceWalkedModifiedField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "O" : "prevDistanceWalkedModified", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPrevDistanceWalkedModifiedField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "O" : "prevDistanceWalkedModified", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPrevHealthField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aw" : "prevHealth", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPrevHealthField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aw" : "prevHealth", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPrevLimbSwingAmountField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aE" : "prevLimbSwingAmount", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPrevLimbSwingAmountField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aE" : "prevLimbSwingAmount", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPrevPosXField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "p" : "prevPosX", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPrevPosXField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "p" : "prevPosX", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPrevPosYField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "q" : "prevPosY", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPrevPosYField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "q" : "prevPosY", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPrevPosZField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "r" : "prevPosZ", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPrevPosZField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "r" : "prevPosZ", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPrevRenderYawOffsetField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aN" : "prevRenderYawOffset", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPrevRenderYawOffsetField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aN" : "prevRenderYawOffset", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPrevRotationPitchField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "B" : "prevRotationPitch", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPrevRotationPitchField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "B" : "prevRotationPitch", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPrevRotationYawField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "A" : "prevRotationYaw", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPrevRotationYawField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "A" : "prevRotationYaw", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPrevRotationYawHeadField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aP" : "prevRotationYawHead", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPrevRotationYawHeadField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aP" : "prevRotationYawHead", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPrevSwingProgressField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aC" : "prevSwingProgress", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPrevSwingProgressField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aC" : "prevSwingProgress", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getPreventEntitySpawningField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "k" : "preventEntitySpawning", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setPreventEntitySpawningField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "k" : "preventEntitySpawning", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getRandField", "()Ljava/util/Random;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "Z" : "rand", "Ljava/util/Random;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setRandField", "(Ljava/util/Random;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "Z" : "rand", "Ljava/util/Random;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getRandomYawVelocityField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bf" : "randomYawVelocity", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setRandomYawVelocityField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bf" : "randomYawVelocity", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getRecentlyHitField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aS" : "recentlyHit", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setRecentlyHitField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aS" : "recentlyHit", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getRenderDistanceWeightField", "()D", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "j" : "renderDistanceWeight", "D"); + mv.visitInsn(Opcodes.DRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setRenderDistanceWeightField", "(D)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.DLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "j" : "renderDistanceWeight", "D"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getRenderYawOffsetField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aM" : "renderYawOffset", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setRenderYawOffsetField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aM" : "renderYawOffset", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getRiddenByEntityField", isObfuscated ? "()Lsa;" : "()Lnet/minecraft/entity/Entity;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "l" : "riddenByEntity", isObfuscated ? "Lsa;" : "Lnet/minecraft/entity/Entity;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setRiddenByEntityField", isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "l" : "riddenByEntity", isObfuscated ? "Lsa;" : "Lnet/minecraft/entity/Entity;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getRidingEntityField", isObfuscated ? "()Lsa;" : "()Lnet/minecraft/entity/Entity;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "m" : "ridingEntity", isObfuscated ? "Lsa;" : "Lnet/minecraft/entity/Entity;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setRidingEntityField", isObfuscated ? "(Lsa;)V" : "(Lnet/minecraft/entity/Entity;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "m" : "ridingEntity", isObfuscated ? "Lsa;" : "Lnet/minecraft/entity/Entity;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getRotationPitchField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "z" : "rotationPitch", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setRotationPitchField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "z" : "rotationPitch", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getRotationYawField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "y" : "rotationYaw", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setRotationYawField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "y" : "rotationYaw", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getRotationYawHeadField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aO" : "rotationYawHead", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setRotationYawHeadField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aO" : "rotationYawHead", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getScoreValueField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ba" : "scoreValue", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setScoreValueField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ba" : "scoreValue", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getServerPosXField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bZ" : "serverPosX", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setServerPosXField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bZ" : "serverPosX", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getServerPosYField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ca" : "serverPosY", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setServerPosYField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "ca" : "serverPosY", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getServerPosZField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "cb" : "serverPosZ", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setServerPosZField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "cb" : "serverPosZ", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getSleepingField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bA" : "sleeping", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setSleepingField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bA" : "sleeping", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getSpeedInAirField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bJ" : "speedInAir", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setSpeedInAirField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bJ" : "speedInAir", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getSpeedOnGroundField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bI" : "speedOnGround", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setSpeedOnGroundField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bI" : "speedOnGround", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getStepHeightField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "W" : "stepHeight", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setStepHeightField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "W" : "stepHeight", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getSwingProgressField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aD" : "swingProgress", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setSwingProgressField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aD" : "swingProgress", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getSwingProgressIntField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "au" : "swingProgressInt", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setSwingProgressIntField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "au" : "swingProgressInt", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getTeleportDirectionField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aq" : "teleportDirection", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setTeleportDirectionField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aq" : "teleportDirection", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getTheItemInWorldManagerField", isObfuscated ? "()Lmx;" : "()Lnet/minecraft/server/management/ItemInWorldManager;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "c" : "theItemInWorldManager", isObfuscated ? "Lmx;" : "Lnet/minecraft/server/management/ItemInWorldManager;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getTicksExistedField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aa" : "ticksExisted", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setTicksExistedField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "aa" : "ticksExisted", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getTimeUntilPortalField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "am" : "timeUntilPortal", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setTimeUntilPortalField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "am" : "timeUntilPortal", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getTranslatorField", "()Ljava/lang/String;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bM" : "translator", "Ljava/lang/String;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setTranslatorField", "(Ljava/lang/String;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bM" : "translator", "Ljava/lang/String;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getVelocityChangedField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "H" : "velocityChanged", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setVelocityChangedField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "H" : "velocityChanged", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getWasHungryField", "()Z", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bS" : "wasHungry", "Z"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setWasHungryField", "(Z)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bS" : "wasHungry", "Z"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getWidthField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "M" : "width", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setWidthField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "M" : "width", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getWorldObjField", isObfuscated ? "()Lahb;" : "()Lnet/minecraft/world/World;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "o" : "worldObj", isObfuscated ? "Lahb;" : "Lnet/minecraft/world/World;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setWorldObjField", isObfuscated ? "(Lahb;)V" : "(Lnet/minecraft/world/World;)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "o" : "worldObj", isObfuscated ? "Lahb;" : "Lnet/minecraft/world/World;"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getXpCooldownField", "()I", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bt" : "xpCooldown", "I"); + mv.visitInsn(Opcodes.IRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setXpCooldownField", "(I)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ILOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "bt" : "xpCooldown", "I"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getYOffsetField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "L" : "yOffset", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setYOffsetField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "L" : "yOffset", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getYSizeField", "()F", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "V" : "ySize", "F"); + mv.visitInsn(Opcodes.FRETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "setYSizeField", "(F)V", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.FLOAD, 1); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", isObfuscated ? "V" : "ySize", "F"); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getServerPlayerBase", "(Ljava/lang/String;)Lapi/player/server/ServerPlayerBase;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "getServerPlayerBase", "(Lapi/player/server/IServerPlayerAPI;Ljava/lang/String;)Lapi/player/server/ServerPlayerBase;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getServerPlayerBaseIds", "()Ljava/util/Set;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "getServerPlayerBaseIds", "(Lapi/player/server/IServerPlayerAPI;)Ljava/util/Set;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "dynamic", "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/Object;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 1); + mv.visitVarInsn(Opcodes.ALOAD, 2); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "dynamic", "(Lapi/player/server/IServerPlayerAPI;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/Object;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getServerPlayerAPI", "()Lapi/player/server/ServerPlayerAPI;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitFieldInsn(Opcodes.GETFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", "serverPlayerAPI", "Lapi/player/server/ServerPlayerAPI;"); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL, "getEntityPlayerMP", isObfuscated ? "()Lmw;" : "()Lnet/minecraft/entity/player/EntityPlayerMP;", null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitInsn(Opcodes.ARETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + + cv.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL, "serverPlayerAPI", "Lapi/player/server/ServerPlayerAPI;", null, null); + } +} diff --git a/src/Java/api/player/server/ServerPlayerConstructorVisitor.java b/src/Java/api/player/server/ServerPlayerConstructorVisitor.java new file mode 100644 index 0000000000..7b5085c96d --- /dev/null +++ b/src/Java/api/player/server/ServerPlayerConstructorVisitor.java @@ -0,0 +1,65 @@ +// ================================================================== +// This file is part of Player API. +// +// Player API is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// Player API is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and the GNU General Public License along with Player API. +// If not, see <http://www.gnu.org/licenses/>. +// ================================================================== + +package api.player.server; + +import org.objectweb.asm.*; + +public final class ServerPlayerConstructorVisitor extends MethodVisitor +{ + private final boolean isObfuscated; + + public ServerPlayerConstructorVisitor(MethodVisitor paramMethodVisitor, boolean isObfuscated) + { + super(262144, paramMethodVisitor); + this.isObfuscated = isObfuscated; + } + + public void visitMethodInsn(int opcode, String owner, String name, String desc) + { + super.visitMethodInsn(opcode, owner, name, desc); + if(name.equals("<init>") && owner.equals(isObfuscated ? "yz" : "net/minecraft/entity/player/EntityPlayer")) + { + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "create", "(Lapi/player/server/IServerPlayerAPI;)Lapi/player/server/ServerPlayerAPI;"); + mv.visitFieldInsn(Opcodes.PUTFIELD, isObfuscated ? "mw" : "net/minecraft/entity/player/EntityPlayerMP", "serverPlayerAPI", "Lapi/player/server/ServerPlayerAPI;"); + + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitIntInsn(Opcodes.ALOAD, 1); + mv.visitIntInsn(Opcodes.ALOAD, 2); + mv.visitIntInsn(Opcodes.ALOAD, 3); + mv.visitIntInsn(Opcodes.ALOAD, 4); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "beforeLocalConstructing", "(Lapi/player/server/IServerPlayerAPI;Lnet/minecraft/server/MinecraftServer;Lnet/minecraft/world/WorldServer;Lcom/mojang/authlib/GameProfile;Lnet/minecraft/server/management/ItemInWorldManager;)V"); + } + } + + public void visitInsn(int opcode) + { + if(opcode == Opcodes.RETURN) + { + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitIntInsn(Opcodes.ALOAD, 1); + mv.visitIntInsn(Opcodes.ALOAD, 2); + mv.visitIntInsn(Opcodes.ALOAD, 3); + mv.visitIntInsn(Opcodes.ALOAD, 4); + mv.visitMethodInsn(Opcodes.INVOKESTATIC, "api/player/server/ServerPlayerAPI", "afterLocalConstructing", "(Lapi/player/server/IServerPlayerAPI;Lnet/minecraft/server/MinecraftServer;Lnet/minecraft/world/WorldServer;Lcom/mojang/authlib/GameProfile;Lnet/minecraft/server/management/ItemInWorldManager;)V"); + } + super.visitInsn(opcode); + } +} |