From f66fb1526fa85554842db425652545448495a2a0 Mon Sep 17 00:00:00 2001 From: Draknyte1 Date: Wed, 28 Dec 2016 16:00:53 +1000 Subject: + Added framework based on opensource works for player movement modification. + Added support for the builders ring to toggle Sneak on and Sprinting off while worn. + Added PlayerAPI. % Moved COFH api files into the same package as PlayerAPI. --- src/Java/api/player/client/ClientPlayerBase.java | 1525 ++++++++++++++++++++++ 1 file changed, 1525 insertions(+) create mode 100644 src/Java/api/player/client/ClientPlayerBase.java (limited to 'src/Java/api/player/client/ClientPlayerBase.java') diff --git a/src/Java/api/player/client/ClientPlayerBase.java b/src/Java/api/player/client/ClientPlayerBase.java new file mode 100644 index 0000000000..30f2a58643 --- /dev/null +++ b/src/Java/api/player/client/ClientPlayerBase.java @@ -0,0 +1,1525 @@ +// ================================================================== +// 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 . +// ================================================================== + +package api.player.client; + +public abstract class ClientPlayerBase +{ + public ClientPlayerBase(ClientPlayerAPI playerAPI) + { + this.internalClientPlayerAPI = playerAPI; + this.playerAPI = playerAPI.player; + this.player = playerAPI.player.getEntityPlayerSP(); + } + + public void beforeBaseAttach(boolean onTheFly) + { + } + + public void afterBaseAttach(boolean onTheFly) + { + } + + public void beforeLocalConstructing(net.minecraft.client.Minecraft paramMinecraft, net.minecraft.world.World paramWorld, net.minecraft.util.Session paramSession, int paramInt) + { + } + + public void afterLocalConstructing(net.minecraft.client.Minecraft paramMinecraft, net.minecraft.world.World paramWorld, net.minecraft.util.Session paramSession, int paramInt) + { + } + + public void beforeBaseDetach(boolean onTheFly) + { + } + + public void afterBaseDetach(boolean onTheFly) + { + } + + public Object dynamic(String key, Object[] parameters) + { + return internalClientPlayerAPI.dynamicOverwritten(key, parameters, this); + } + + public final int hashCode() + { + return super.hashCode(); + } + + public void beforeAddExhaustion(float paramFloat) + { + } + + public void addExhaustion(float paramFloat) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenAddExhaustion(this); + + if(overwritten == null) + playerAPI.localAddExhaustion(paramFloat); + else if(overwritten != this) + overwritten.addExhaustion(paramFloat); + + } + + public void afterAddExhaustion(float paramFloat) + { + } + + public void beforeAddMovementStat(double paramDouble1, double paramDouble2, double paramDouble3) + { + } + + public void addMovementStat(double paramDouble1, double paramDouble2, double paramDouble3) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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 beforeAddStat(net.minecraft.stats.StatBase paramStatBase, int paramInt) + { + } + + public void addStat(net.minecraft.stats.StatBase paramStatBase, int paramInt) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenAddStat(this); + + if(overwritten == null) + playerAPI.localAddStat(paramStatBase, paramInt); + else if(overwritten != this) + overwritten.addStat(paramStatBase, paramInt); + + } + + public void afterAddStat(net.minecraft.stats.StatBase paramStatBase, int paramInt) + { + } + + public void beforeAttackEntityFrom(net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + } + + public boolean attackEntityFrom(net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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 beforeCloseScreen() + { + } + + public void closeScreen() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenCloseScreen(this); + + if(overwritten == null) + playerAPI.localCloseScreen(); + else if(overwritten != this) + overwritten.closeScreen(); + + } + + public void afterCloseScreen() + { + } + + public void beforeDamageEntity(net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + } + + public void damageEntity(net.minecraft.util.DamageSource paramDamageSource, float paramFloat) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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 beforeDisplayGUIBrewingStand(net.minecraft.tileentity.TileEntityBrewingStand paramTileEntityBrewingStand) + { + } + + public void displayGUIBrewingStand(net.minecraft.tileentity.TileEntityBrewingStand paramTileEntityBrewingStand) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenDisplayGUIBrewingStand(this); + + if(overwritten == null) + playerAPI.localDisplayGUIBrewingStand(paramTileEntityBrewingStand); + else if(overwritten != this) + overwritten.displayGUIBrewingStand(paramTileEntityBrewingStand); + + } + + public void afterDisplayGUIBrewingStand(net.minecraft.tileentity.TileEntityBrewingStand paramTileEntityBrewingStand) + { + } + + public void beforeDisplayGUIChest(net.minecraft.inventory.IInventory paramIInventory) + { + } + + public void displayGUIChest(net.minecraft.inventory.IInventory paramIInventory) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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 beforeDisplayGUIEditSign(net.minecraft.tileentity.TileEntity paramTileEntity) + { + } + + public void displayGUIEditSign(net.minecraft.tileentity.TileEntity paramTileEntity) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenDisplayGUIEditSign(this); + + if(overwritten == null) + playerAPI.localDisplayGUIEditSign(paramTileEntity); + else if(overwritten != this) + overwritten.displayGUIEditSign(paramTileEntity); + + } + + public void afterDisplayGUIEditSign(net.minecraft.tileentity.TileEntity paramTileEntity) + { + } + + public void beforeDisplayGUIEnchantment(int paramInt1, int paramInt2, int paramInt3, String paramString) + { + } + + public void displayGUIEnchantment(int paramInt1, int paramInt2, int paramInt3, String paramString) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenDisplayGUIEnchantment(this); + + if(overwritten == null) + playerAPI.localDisplayGUIEnchantment(paramInt1, paramInt2, paramInt3, paramString); + else if(overwritten != this) + overwritten.displayGUIEnchantment(paramInt1, paramInt2, paramInt3, paramString); + + } + + public void afterDisplayGUIEnchantment(int paramInt1, int paramInt2, int paramInt3, String paramString) + { + } + + public void beforeDisplayGUIFurnace(net.minecraft.tileentity.TileEntityFurnace paramTileEntityFurnace) + { + } + + public void displayGUIFurnace(net.minecraft.tileentity.TileEntityFurnace paramTileEntityFurnace) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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 beforeDropPlayerItemWithRandomChoice(net.minecraft.item.ItemStack paramItemStack, boolean paramBoolean1, boolean paramBoolean2) + { + } + + public net.minecraft.entity.item.EntityItem dropPlayerItemWithRandomChoice(net.minecraft.item.ItemStack paramItemStack, boolean paramBoolean1, boolean paramBoolean2) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenDropPlayerItemWithRandomChoice(this); + + net.minecraft.entity.item.EntityItem _result; + if(overwritten == null) + _result = playerAPI.localDropPlayerItemWithRandomChoice(paramItemStack, paramBoolean1, paramBoolean2); + else if(overwritten != this) + _result = overwritten.dropPlayerItemWithRandomChoice(paramItemStack, paramBoolean1, paramBoolean2); + else + _result = null; + + return _result; + } + + public void afterDropPlayerItemWithRandomChoice(net.minecraft.item.ItemStack paramItemStack, boolean paramBoolean1, boolean paramBoolean2) + { + } + + public void beforeFall(float paramFloat) + { + } + + public void fall(float paramFloat) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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 beforeGetBedOrientationInDegrees() + { + } + + public float getBedOrientationInDegrees() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenGetBedOrientationInDegrees(this); + + float _result; + if(overwritten == null) + _result = playerAPI.localGetBedOrientationInDegrees(); + else if(overwritten != this) + _result = overwritten.getBedOrientationInDegrees(); + else + _result = 0; + + return _result; + } + + public void afterGetBedOrientationInDegrees() + { + } + + public void beforeGetBrightness(float paramFloat) + { + } + + public float getBrightness(float paramFloat) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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 beforeGetBrightnessForRender(float paramFloat) + { + } + + public int getBrightnessForRender(float paramFloat) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenGetBrightnessForRender(this); + + int _result; + if(overwritten == null) + _result = playerAPI.localGetBrightnessForRender(paramFloat); + else if(overwritten != this) + _result = overwritten.getBrightnessForRender(paramFloat); + else + _result = 0; + + return _result; + } + + public void afterGetBrightnessForRender(float paramFloat) + { + } + + public void beforeGetCurrentPlayerStrVsBlock(net.minecraft.block.Block paramBlock, boolean paramBoolean) + { + } + + public float getCurrentPlayerStrVsBlock(net.minecraft.block.Block paramBlock, boolean paramBoolean) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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 beforeGetDistanceSqToEntity(net.minecraft.entity.Entity paramEntity) + { + } + + public double getDistanceSqToEntity(net.minecraft.entity.Entity paramEntity) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenGetDistanceSqToEntity(this); + + double _result; + if(overwritten == null) + _result = playerAPI.localGetDistanceSqToEntity(paramEntity); + else if(overwritten != this) + _result = overwritten.getDistanceSqToEntity(paramEntity); + else + _result = 0; + + return _result; + } + + public void afterGetDistanceSqToEntity(net.minecraft.entity.Entity paramEntity) + { + } + + public void beforeGetFOVMultiplier() + { + } + + public float getFOVMultiplier() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenGetFOVMultiplier(this); + + float _result; + if(overwritten == null) + _result = playerAPI.localGetFOVMultiplier(); + else if(overwritten != this) + _result = overwritten.getFOVMultiplier(); + else + _result = 0; + + return _result; + } + + public void afterGetFOVMultiplier() + { + } + + public void beforeGetHurtSound() + { + } + + public java.lang.String getHurtSound() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenGetHurtSound(this); + + java.lang.String _result; + if(overwritten == null) + _result = playerAPI.localGetHurtSound(); + else if(overwritten != this) + _result = overwritten.getHurtSound(); + else + _result = null; + + return _result; + } + + public void afterGetHurtSound() + { + } + + public void beforeGetItemIcon(net.minecraft.item.ItemStack paramItemStack, int paramInt) + { + } + + public net.minecraft.util.IIcon getItemIcon(net.minecraft.item.ItemStack paramItemStack, int paramInt) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenGetItemIcon(this); + + net.minecraft.util.IIcon _result; + if(overwritten == null) + _result = playerAPI.localGetItemIcon(paramItemStack, paramInt); + else if(overwritten != this) + _result = overwritten.getItemIcon(paramItemStack, paramInt); + else + _result = null; + + return _result; + } + + public void afterGetItemIcon(net.minecraft.item.ItemStack paramItemStack, int paramInt) + { + } + + public void beforeGetSleepTimer() + { + } + + public int getSleepTimer() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenGetSleepTimer(this); + + int _result; + if(overwritten == null) + _result = playerAPI.localGetSleepTimer(); + else if(overwritten != this) + _result = overwritten.getSleepTimer(); + else + _result = 0; + + return _result; + } + + public void afterGetSleepTimer() + { + } + + public void beforeHandleLavaMovement() + { + } + + public boolean handleLavaMovement() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenHandleLavaMovement(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localHandleLavaMovement(); + else if(overwritten != this) + _result = overwritten.handleLavaMovement(); + else + _result = false; + + return _result; + } + + public void afterHandleLavaMovement() + { + } + + public void beforeHandleWaterMovement() + { + } + + public boolean handleWaterMovement() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenHandleWaterMovement(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localHandleWaterMovement(); + else if(overwritten != this) + _result = overwritten.handleWaterMovement(); + else + _result = false; + + return _result; + } + + public void afterHandleWaterMovement() + { + } + + public void beforeHeal(float paramFloat) + { + } + + public void heal(float paramFloat) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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 beforeIsSprinting() + { + } + + public boolean isSprinting() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenIsSprinting(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localIsSprinting(); + else if(overwritten != this) + _result = overwritten.isSprinting(); + else + _result = false; + + return _result; + } + + public void afterIsSprinting() + { + } + + public void beforeJump() + { + } + + public void jump() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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 beforeMoveEntity(double paramDouble1, double paramDouble2, double paramDouble3) + { + } + + public void moveEntity(double paramDouble1, double paramDouble2, double paramDouble3) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenOnUpdate(this); + + if(overwritten == null) + playerAPI.localOnUpdate(); + else if(overwritten != this) + overwritten.onUpdate(); + + } + + public void afterOnUpdate() + { + } + + public void beforePlayStepSound(int paramInt1, int paramInt2, int paramInt3, net.minecraft.block.Block paramBlock) + { + } + + public void playStepSound(int paramInt1, int paramInt2, int paramInt3, net.minecraft.block.Block paramBlock) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenPlayStepSound(this); + + if(overwritten == null) + playerAPI.localPlayStepSound(paramInt1, paramInt2, paramInt3, paramBlock); + else if(overwritten != this) + overwritten.playStepSound(paramInt1, paramInt2, paramInt3, paramBlock); + + } + + public void afterPlayStepSound(int paramInt1, int paramInt2, int paramInt3, net.minecraft.block.Block paramBlock) + { + } + + public void beforePushOutOfBlocks(double paramDouble1, double paramDouble2, double paramDouble3) + { + } + + public boolean pushOutOfBlocks(double paramDouble1, double paramDouble2, double paramDouble3) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenPushOutOfBlocks(this); + + boolean _result; + if(overwritten == null) + _result = playerAPI.localPushOutOfBlocks(paramDouble1, paramDouble2, paramDouble3); + else if(overwritten != this) + _result = overwritten.pushOutOfBlocks(paramDouble1, paramDouble2, paramDouble3); + else + _result = false; + + return _result; + } + + public void afterPushOutOfBlocks(double paramDouble1, double paramDouble2, double paramDouble3) + { + } + + public void beforeRayTrace(double paramDouble, float paramFloat) + { + } + + public net.minecraft.util.MovingObjectPosition rayTrace(double paramDouble, float paramFloat) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenRayTrace(this); + + net.minecraft.util.MovingObjectPosition _result; + if(overwritten == null) + _result = playerAPI.localRayTrace(paramDouble, paramFloat); + else if(overwritten != this) + _result = overwritten.rayTrace(paramDouble, paramFloat); + else + _result = null; + + return _result; + } + + public void afterRayTrace(double paramDouble, float paramFloat) + { + } + + public void beforeReadEntityFromNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound) + { + } + + public void readEntityFromNBT(net.minecraft.nbt.NBTTagCompound paramNBTTagCompound) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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 beforeRespawnPlayer() + { + } + + public void respawnPlayer() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenRespawnPlayer(this); + + if(overwritten == null) + playerAPI.localRespawnPlayer(); + else if(overwritten != this) + overwritten.respawnPlayer(); + + } + + public void afterRespawnPlayer() + { + } + + public void beforeSetDead() + { + } + + public void setDead() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenSetDead(this); + + if(overwritten == null) + playerAPI.localSetDead(); + else if(overwritten != this) + overwritten.setDead(); + + } + + public void afterSetDead() + { + } + + public void beforeSetPlayerSPHealth(float paramFloat) + { + } + + public void setPlayerSPHealth(float paramFloat) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenSetPlayerSPHealth(this); + + if(overwritten == null) + playerAPI.localSetPlayerSPHealth(paramFloat); + else if(overwritten != this) + overwritten.setPlayerSPHealth(paramFloat); + + } + + public void afterSetPlayerSPHealth(float paramFloat) + { + } + + public void beforeSetPositionAndRotation(double paramDouble1, double paramDouble2, double paramDouble3, float paramFloat1, float paramFloat2) + { + } + + public void setPositionAndRotation(double paramDouble1, double paramDouble2, double paramDouble3, float paramFloat1, float paramFloat2) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenSetPositionAndRotation(this); + + if(overwritten == null) + playerAPI.localSetPositionAndRotation(paramDouble1, paramDouble2, paramDouble3, paramFloat1, paramFloat2); + else if(overwritten != this) + overwritten.setPositionAndRotation(paramDouble1, paramDouble2, paramDouble3, paramFloat1, paramFloat2); + + } + + public void afterSetPositionAndRotation(double paramDouble1, double paramDouble2, double paramDouble3, float paramFloat1, float paramFloat2) + { + } + + public void beforeSetSneaking(boolean paramBoolean) + { + } + + public void setSneaking(boolean paramBoolean) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenSetSprinting(this); + + if(overwritten == null) + playerAPI.localSetSprinting(paramBoolean); + else if(overwritten != this) + overwritten.setSprinting(paramBoolean); + + } + + public void afterSetSprinting(boolean paramBoolean) + { + } + + public void beforeSleepInBedAt(int paramInt1, int paramInt2, int paramInt3) + { + } + + public net.minecraft.entity.player.EntityPlayer.EnumStatus sleepInBedAt(int paramInt1, int paramInt2, int paramInt3) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenSleepInBedAt(this); + + net.minecraft.entity.player.EntityPlayer.EnumStatus _result; + if(overwritten == null) + _result = playerAPI.localSleepInBedAt(paramInt1, paramInt2, paramInt3); + else if(overwritten != this) + _result = overwritten.sleepInBedAt(paramInt1, paramInt2, paramInt3); + else + _result = null; + + return _result; + } + + public void afterSleepInBedAt(int paramInt1, int paramInt2, int paramInt3) + { + } + + public void beforeSwingItem() + { + } + + public void swingItem() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenSwingItem(this); + + if(overwritten == null) + playerAPI.localSwingItem(); + else if(overwritten != this) + overwritten.swingItem(); + + } + + public void afterSwingItem() + { + } + + public void beforeUpdateEntityActionState() + { + } + + public void updateEntityActionState() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.GetOverwrittenUpdateEntityActionState(this); + + if(overwritten == null) + playerAPI.localUpdateEntityActionState(); + else if(overwritten != this) + overwritten.updateEntityActionState(); + + } + + public void afterUpdateEntityActionState() + { + } + + public void beforeUpdateRidden() + { + } + + public void updateRidden() + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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) + { + ClientPlayerBase overwritten = internalClientPlayerAPI.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.client.entity.EntityPlayerSP player; + protected final IClientPlayer playerAPI; + private final ClientPlayerAPI internalClientPlayerAPI; +} -- cgit