    001    package net.minecraft.network.packet;
    002
    003    import cpw.mods.fml.common.Side;
    004    import cpw.mods.fml.common.asm.SideOnly;
    005    import java.io.DataInputStream;
    006    import java.io.DataOutputStream;
    007    import java.io.IOException;
    008    import net.minecraft.entity.player.PlayerCapabilities;
    009
    010    public class Packet202PlayerAbilities extends Packet
    011    {
    012        /** Disables player damage. */
    013        private boolean disableDamage = false;
    014
    015        /** Indicates whether the player is flying or not. */
    016        private boolean isFlying = false;
    017
    018        /** Whether or not to allow the player to fly when they double jump. */
    019        private boolean allowFlying = false;
    020
    021        /**
    022         * Used to determine if creative mode is enabled, and therefore if items should be depleted on usage
    023         */
    024        private boolean isCreativeMode = false;
    025        private float flySpeed;
    026        private float walkSpeed;
    027
    028        public Packet202PlayerAbilities() {}
    029
    030        public Packet202PlayerAbilities(PlayerCapabilities par1PlayerCapabilities)
    031        {
    032            this.setDisableDamage(par1PlayerCapabilities.disableDamage);
    033            this.setFlying(par1PlayerCapabilities.isFlying);
    034            this.setAllowFlying(par1PlayerCapabilities.allowFlying);
    035            this.setCreativeMode(par1PlayerCapabilities.isCreativeMode);
    036            this.setFlySpeed(par1PlayerCapabilities.getFlySpeed());
    037            this.setWalkSpeed(par1PlayerCapabilities.getWalkSpeed());
    038        }
    039
    040        /**
    041         * Abstract. Reads the raw packet data from the data stream.
    042         */
    043        public void readPacketData(DataInputStream par1DataInputStream) throws IOException
    044        {
    045            byte var2 = par1DataInputStream.readByte();
    046            this.setDisableDamage((var2 & 1) > 0);
    047            this.setFlying((var2 & 2) > 0);
    048            this.setAllowFlying((var2 & 4) > 0);
    049            this.setCreativeMode((var2 & 8) > 0);
    050            this.setFlySpeed((float)par1DataInputStream.readByte() / 255.0F);
    051            this.setWalkSpeed((float)par1DataInputStream.readByte() / 255.0F);
    052        }
    053
    054        /**
    055         * Abstract. Writes the raw packet data to the data stream.
    056         */
    057        public void writePacketData(DataOutputStream par1DataOutputStream) throws IOException
    058        {
    059            byte var2 = 0;
    060
    061            if (this.getDisableDamage())
    062            {
    063                var2 = (byte)(var2 | 1);
    064            }
    065
    066            if (this.getFlying())
    067            {
    068                var2 = (byte)(var2 | 2);
    069            }
    070
    071            if (this.getAllowFlying())
    072            {
    073                var2 = (byte)(var2 | 4);
    074            }
    075
    076            if (this.isCreativeMode())
    077            {
    078                var2 = (byte)(var2 | 8);
    079            }
    080
    081            par1DataOutputStream.writeByte(var2);
    082            par1DataOutputStream.writeByte((int)(this.flySpeed * 255.0F));
    083            par1DataOutputStream.writeByte((int)(this.walkSpeed * 255.0F));
    084        }
    085
    086        /**
    087         * Passes this Packet on to the NetHandler for processing.
    088         */
    089        public void processPacket(NetHandler par1NetHandler)
    090        {
    091            par1NetHandler.handlePlayerAbilities(this);
    092        }
    093
    094        /**
    095         * Abstract. Return the size of the packet (not counting the header).
    096         */
    097        public int getPacketSize()
    098        {
    099            return 2;
    100        }
    101
    102        public boolean getDisableDamage()
    103        {
    104            return this.disableDamage;
    105        }
    106
    107        /**
    108         * Sets whether damage is disabled or not.
    109         */
    110        public void setDisableDamage(boolean par1)
    111        {
    112            this.disableDamage = par1;
    113        }
    114
    115        public boolean getFlying()
    116        {
    117            return this.isFlying;
    118        }
    119
    120        /**
    121         * Sets whether we're currently flying or not.
    122         */
    123        public void setFlying(boolean par1)
    124        {
    125            this.isFlying = par1;
    126        }
    127
    128        public boolean getAllowFlying()
    129        {
    130            return this.allowFlying;
    131        }
    132
    133        public void setAllowFlying(boolean par1)
    134        {
    135            this.allowFlying = par1;
    136        }
    137
    138        public boolean isCreativeMode()
    139        {
    140            return this.isCreativeMode;
    141        }
    142
    143        public void setCreativeMode(boolean par1)
    144        {
    145            this.isCreativeMode = par1;
    146        }
    147
    148        @SideOnly(Side.CLIENT)
    149        public float getFlySpeed()
    150        {
    151            return this.flySpeed;
    152        }
    153
    154        /**
    155         * Sets the flying speed.
    156         */
    157        public void setFlySpeed(float par1)
    158        {
    159            this.flySpeed = par1;
    160        }
    161
    162        @SideOnly(Side.CLIENT)
    163        public float func_82558_j()
    164        {
    165            return this.walkSpeed;
    166        }
    167
    168        /**
    169         * Sets the walking speed.
    170         */
    171        public void setWalkSpeed(float par1)
    172        {
    173            this.walkSpeed = par1;
    174        }
    175
    176        /**
    177         * only false for the abstract Packet class, all real packets return true
    178         */
    179        public boolean isRealPacket()
    180        {
    181            return true;
    182        }
    183
    184        /**
    185         * eg return packet30entity.entityId == entityId; WARNING : will throw if you compare a packet to a different packet
    186         * class
    187         */
    188        public boolean containsSameEntityIDAs(Packet par1Packet)
    189        {
    190            return true;
    191        }
    192    }