    001package net.minecraft.network;
    002
    003import java.io.ByteArrayInputStream;
    004import java.io.DataInputStream;
    005import java.io.IOException;
    006import java.util.ArrayList;
    007import java.util.Iterator;
    008import java.util.Random;
    009
    010import cpw.mods.fml.common.network.FMLNetworkHandler;
    011import net.minecraft.crash.CrashReport;
    012import net.minecraft.crash.CrashReportCategory;
    013import net.minecraft.entity.Entity;
    014import net.minecraft.entity.item.EntityItem;
    015import net.minecraft.entity.player.EntityPlayerMP;
    016import net.minecraft.entity.player.InventoryPlayer;
    017import net.minecraft.inventory.Container;
    018import net.minecraft.inventory.ContainerBeacon;
    019import net.minecraft.inventory.ContainerMerchant;
    020import net.minecraft.inventory.ContainerRepair;
    021import net.minecraft.inventory.Slot;
    022import net.minecraft.item.Item;
    023import net.minecraft.item.ItemEditableBook;
    024import net.minecraft.item.ItemStack;
    025import net.minecraft.item.ItemWritableBook;
    026import net.minecraft.nbt.NBTTagString;
    027import net.minecraft.network.packet.NetHandler;
    028import net.minecraft.network.packet.Packet;
    029import net.minecraft.network.packet.Packet0KeepAlive;
    030import net.minecraft.network.packet.Packet101CloseWindow;
    031import net.minecraft.network.packet.Packet102WindowClick;
    032import net.minecraft.network.packet.Packet103SetSlot;
    033import net.minecraft.network.packet.Packet106Transaction;
    034import net.minecraft.network.packet.Packet107CreativeSetSlot;
    035import net.minecraft.network.packet.Packet108EnchantItem;
    036import net.minecraft.network.packet.Packet10Flying;
    037import net.minecraft.network.packet.Packet130UpdateSign;
    038import net.minecraft.network.packet.Packet131MapData;
    039import net.minecraft.network.packet.Packet13PlayerLookMove;
    040import net.minecraft.network.packet.Packet14BlockDig;
    041import net.minecraft.network.packet.Packet15Place;
    042import net.minecraft.network.packet.Packet16BlockItemSwitch;
    043import net.minecraft.network.packet.Packet18Animation;
    044import net.minecraft.network.packet.Packet19EntityAction;
    045import net.minecraft.network.packet.Packet202PlayerAbilities;
    046import net.minecraft.network.packet.Packet203AutoComplete;
    047import net.minecraft.network.packet.Packet204ClientInfo;
    048import net.minecraft.network.packet.Packet205ClientCommand;
    049import net.minecraft.network.packet.Packet250CustomPayload;
    050import net.minecraft.network.packet.Packet255KickDisconnect;
    051import net.minecraft.network.packet.Packet3Chat;
    052import net.minecraft.network.packet.Packet53BlockChange;
    053import net.minecraft.network.packet.Packet7UseEntity;
    054import net.minecraft.network.packet.Packet9Respawn;
    055import net.minecraft.server.MinecraftServer;
    056import net.minecraft.server.management.BanEntry;
    057import net.minecraft.tileentity.TileEntity;
    058import net.minecraft.tileentity.TileEntityBeacon;
    059import net.minecraft.tileentity.TileEntityCommandBlock;
    060import net.minecraft.tileentity.TileEntitySign;
    061import net.minecraft.util.AxisAlignedBB;
    062import net.minecraft.util.ChatAllowedCharacters;
    063import net.minecraft.util.EnumChatFormatting;
    064import net.minecraft.util.IntHashMap;
    065import net.minecraft.util.ReportedException;
    066import net.minecraft.world.WorldServer;
    067
    068import net.minecraftforge.common.MinecraftForge;
    069import net.minecraftforge.event.Event;
    070import net.minecraftforge.event.ForgeEventFactory;
    071import net.minecraftforge.event.ServerChatEvent;
    072import net.minecraftforge.event.entity.player.PlayerInteractEvent;
    073import net.minecraftforge.event.entity.player.PlayerInteractEvent.Action;
    074
    075public class NetServerHandler extends NetHandler
    076{
    077    /** The underlying network manager for this server handler. */
    078    public final INetworkManager netManager;
    079
    080    /** Reference to the MinecraftServer object. */
    081    private final MinecraftServer mcServer;
    082
    083    /** This is set to true whenever a player disconnects from the server. */
    084    public boolean connectionClosed = false;
    085
    086    /** Reference to the EntityPlayerMP object. */
    087    public EntityPlayerMP playerEntity;
    088
    089    /** incremented each tick */
    090    private int currentTicks;
    091
    092    /**
    093     * player is kicked if they float for over 80 ticks without flying enabled
    094     */
    095    public int ticksForFloatKick;
    096    private boolean field_72584_h;
    097    private int keepAliveRandomID;
    098    private long keepAliveTimeSent;
    099    private static Random randomGenerator = new Random();
    100    private long ticksOfLastKeepAlive;
    101    private int chatSpamThresholdCount = 0;
    102    private int creativeItemCreationSpamThresholdTally = 0;
    103
    104    /** The last known x position for this connection. */
    105    private double lastPosX;
    106
    107    /** The last known y position for this connection. */
    108    private double lastPosY;
    109
    110    /** The last known z position for this connection. */
    111    private double lastPosZ;
    112
    113    /** is true when the player has moved since his last movement packet */
    114    private boolean hasMoved = true;
    115    private IntHashMap field_72586_s = new IntHashMap();
    116
    117    public NetServerHandler(MinecraftServer par1, INetworkManager par2, EntityPlayerMP par3)
    118    {
    119        this.mcServer = par1;
    120        this.netManager = par2;
    121        par2.setNetHandler(this);
    122        this.playerEntity = par3;
    123        par3.playerNetServerHandler = this;
    124    }
    125
    126    /**
    127     * run once each game tick
    128     */
    129    public void networkTick()
    130    {
    131        this.field_72584_h = false;
    132        ++this.currentTicks;
    133        this.mcServer.theProfiler.startSection("packetflow");
    134        this.netManager.processReadPackets();
    135        this.mcServer.theProfiler.endStartSection("keepAlive");
    136
    137        if ((long)this.currentTicks - this.ticksOfLastKeepAlive > 20L)
    138        {
    139            this.ticksOfLastKeepAlive = (long)this.currentTicks;
    140            this.keepAliveTimeSent = System.nanoTime() / 1000000L;
    141            this.keepAliveRandomID = randomGenerator.nextInt();
    142            this.sendPacketToPlayer(new Packet0KeepAlive(this.keepAliveRandomID));
    143        }
    144
    145        if (this.chatSpamThresholdCount > 0)
    146        {
    147            --this.chatSpamThresholdCount;
    148        }
    149
    150        if (this.creativeItemCreationSpamThresholdTally > 0)
    151        {
    152            --this.creativeItemCreationSpamThresholdTally;
    153        }
    154
    155        this.mcServer.theProfiler.endStartSection("playerTick");
    156        this.mcServer.theProfiler.endSection();
    157    }
    158
    159    public void kickPlayerFromServer(String par1Str)
    160    {
    161        if (!this.connectionClosed)
    162        {
    163            this.playerEntity.mountEntityAndWakeUp();
    164            this.sendPacketToPlayer(new Packet255KickDisconnect(par1Str));
    165            this.netManager.serverShutdown();
    166            this.mcServer.getConfigurationManager().sendPacketToAllPlayers(new Packet3Chat(EnumChatFormatting.YELLOW + this.playerEntity.username + " left the game."));
    167            this.mcServer.getConfigurationManager().playerLoggedOut(this.playerEntity);
    168            this.connectionClosed = true;
    169        }
    170    }
    171
    172    public void handleFlying(Packet10Flying par1Packet10Flying)
    173    {
    174        WorldServer worldserver = this.mcServer.worldServerForDimension(this.playerEntity.dimension);
    175        this.field_72584_h = true;
    176
    177        if (!this.playerEntity.playerConqueredTheEnd)
    178        {
    179            double d0;
    180
    181            if (!this.hasMoved)
    182            {
    183                d0 = par1Packet10Flying.yPosition - this.lastPosY;
    184
    185                if (par1Packet10Flying.xPosition == this.lastPosX && d0 * d0 < 0.01D && par1Packet10Flying.zPosition == this.lastPosZ)
    186                {
    187                    this.hasMoved = true;
    188                }
    189            }
    190
    191            if (this.hasMoved)
    192            {
    193                double d1;
    194                double d2;
    195                double d3;
    196                double d4;
    197
    198                if (this.playerEntity.ridingEntity != null)
    199                {
    200                    float f = this.playerEntity.rotationYaw;
    201                    float f1 = this.playerEntity.rotationPitch;
    202                    this.playerEntity.ridingEntity.updateRiderPosition();
    203                    d1 = this.playerEntity.posX;
    204                    d2 = this.playerEntity.posY;
    205                    d3 = this.playerEntity.posZ;
    206                    double d5 = 0.0D;
    207                    d4 = 0.0D;
    208
    209                    if (par1Packet10Flying.rotating)
    210                    {
    211                        f = par1Packet10Flying.yaw;
    212                        f1 = par1Packet10Flying.pitch;
    213                    }
    214
    215                    if (par1Packet10Flying.moving && par1Packet10Flying.yPosition == -999.0D && par1Packet10Flying.stance == -999.0D)
    216                    {
    217                        if (Math.abs(par1Packet10Flying.xPosition) > 1.0D || Math.abs(par1Packet10Flying.zPosition) > 1.0D)
    218                        {
    219                            System.err.println(this.playerEntity.username + " was caught trying to crash the server with an invalid position.");
    220                            this.kickPlayerFromServer("Nope!");
    221                            return;
    222                        }
    223
    224                        d5 = par1Packet10Flying.xPosition;
    225                        d4 = par1Packet10Flying.zPosition;
    226                    }
    227
    228                    this.playerEntity.onGround = par1Packet10Flying.onGround;
    229                    this.playerEntity.onUpdateEntity();
    230                    this.playerEntity.moveEntity(d5, 0.0D, d4);
    231                    this.playerEntity.setPositionAndRotation(d1, d2, d3, f, f1);
    232                    this.playerEntity.motionX = d5;
    233                    this.playerEntity.motionZ = d4;
    234
    235                    if (this.playerEntity.ridingEntity != null)
    236                    {
    237                        worldserver.uncheckedUpdateEntity(this.playerEntity.ridingEntity, true);
    238                    }
    239
    240                    if (this.playerEntity.ridingEntity != null)
    241                    {
    242                        this.playerEntity.ridingEntity.updateRiderPosition();
    243                    }
    244
    245                    if (!this.hasMoved) //Fixes teleportation kick while riding entities
    246                    {
    247                        return;
    248                    }
    249
    250                    this.mcServer.getConfigurationManager().serverUpdateMountedMovingPlayer(this.playerEntity);
    251                    this.lastPosX = this.playerEntity.posX;
    252                    this.lastPosY = this.playerEntity.posY;
    253                    this.lastPosZ = this.playerEntity.posZ;
    254                    worldserver.updateEntity(this.playerEntity);
    255                    return;
    256                }
    257
    258                if (this.playerEntity.isPlayerSleeping())
    259                {
    260                    this.playerEntity.onUpdateEntity();
    261                    this.playerEntity.setPositionAndRotation(this.lastPosX, this.lastPosY, this.lastPosZ, this.playerEntity.rotationYaw, this.playerEntity.rotationPitch);
    262                    worldserver.updateEntity(this.playerEntity);
    263                    return;
    264                }
    265
    266                d0 = this.playerEntity.posY;
    267                this.lastPosX = this.playerEntity.posX;
    268                this.lastPosY = this.playerEntity.posY;
    269                this.lastPosZ = this.playerEntity.posZ;
    270                d1 = this.playerEntity.posX;
    271                d2 = this.playerEntity.posY;
    272                d3 = this.playerEntity.posZ;
    273                float f2 = this.playerEntity.rotationYaw;
    274                float f3 = this.playerEntity.rotationPitch;
    275
    276                if (par1Packet10Flying.moving && par1Packet10Flying.yPosition == -999.0D && par1Packet10Flying.stance == -999.0D)
    277                {
    278                    par1Packet10Flying.moving = false;
    279                }
    280
    281                if (par1Packet10Flying.moving)
    282                {
    283                    d1 = par1Packet10Flying.xPosition;
    284                    d2 = par1Packet10Flying.yPosition;
    285                    d3 = par1Packet10Flying.zPosition;
    286                    d4 = par1Packet10Flying.stance - par1Packet10Flying.yPosition;
    287
    288                    if (!this.playerEntity.isPlayerSleeping() && (d4 > 1.65D || d4 < 0.1D))
    289                    {
    290                        this.kickPlayerFromServer("Illegal stance");
    291                        this.mcServer.getLogAgent().logWarning(this.playerEntity.username + " had an illegal stance: " + d4);
    292                        return;
    293                    }
    294
    295                    if (Math.abs(par1Packet10Flying.xPosition) > 3.2E7D || Math.abs(par1Packet10Flying.zPosition) > 3.2E7D)
    296                    {
    297                        this.kickPlayerFromServer("Illegal position");
    298                        return;
    299                    }
    300                }
    301
    302                if (par1Packet10Flying.rotating)
    303                {
    304                    f2 = par1Packet10Flying.yaw;
    305                    f3 = par1Packet10Flying.pitch;
    306                }
    307
    308                this.playerEntity.onUpdateEntity();
    309                this.playerEntity.ySize = 0.0F;
    310                this.playerEntity.setPositionAndRotation(this.lastPosX, this.lastPosY, this.lastPosZ, f2, f3);
    311
    312                if (!this.hasMoved)
    313                {
    314                    return;
    315                }
    316
    317                d4 = d1 - this.playerEntity.posX;
    318                double d6 = d2 - this.playerEntity.posY;
    319                double d7 = d3 - this.playerEntity.posZ;
    320                double d8 = Math.max(Math.abs(d4), Math.abs(this.playerEntity.motionX));
    321                double d9 = Math.max(Math.abs(d6), Math.abs(this.playerEntity.motionY));
    322                double d10 = Math.max(Math.abs(d7), Math.abs(this.playerEntity.motionZ));
    323                double d11 = d8 * d8 + d9 * d9 + d10 * d10;
    324
    325                if (d11 > 100.0D && (!this.mcServer.isSinglePlayer() || !this.mcServer.getServerOwner().equals(this.playerEntity.username)))
    326                {
    327                    this.mcServer.getLogAgent().logWarning(this.playerEntity.username + " moved too quickly! " + d4 + "," + d6 + "," + d7 + " (" + d8 + ", " + d9 + ", " + d10 + ")");
    328                    this.setPlayerLocation(this.lastPosX, this.lastPosY, this.lastPosZ, this.playerEntity.rotationYaw, this.playerEntity.rotationPitch);
    329                    return;
    330                }
    331
    332                float f4 = 0.0625F;
    333                boolean flag = worldserver.getCollidingBoundingBoxes(this.playerEntity, this.playerEntity.boundingBox.copy().contract((double)f4, (double)f4, (double)f4)).isEmpty();
    334
    335                if (this.playerEntity.onGround && !par1Packet10Flying.onGround && d6 > 0.0D)
    336                {
    337                    this.playerEntity.addExhaustion(0.2F);
    338                }
    339
    340                if (!this.hasMoved) //Fixes "Moved Too Fast" kick when being teleported while moving
    341                {
    342                    return;
    343                }
    344
    345                this.playerEntity.moveEntity(d4, d6, d7);
    346                this.playerEntity.onGround = par1Packet10Flying.onGround;
    347                this.playerEntity.addMovementStat(d4, d6, d7);
    348                double d12 = d6;
    349                d4 = d1 - this.playerEntity.posX;
    350                d6 = d2 - this.playerEntity.posY;
    351
    352                if (d6 > -0.5D || d6 < 0.5D)
    353                {
    354                    d6 = 0.0D;
    355                }
    356
    357                d7 = d3 - this.playerEntity.posZ;
    358                d11 = d4 * d4 + d6 * d6 + d7 * d7;
    359                boolean flag1 = false;
    360
    361                if (d11 > 0.0625D && !this.playerEntity.isPlayerSleeping() && !this.playerEntity.theItemInWorldManager.isCreative())
    362                {
    363                    flag1 = true;
    364                    this.mcServer.getLogAgent().logWarning(this.playerEntity.username + " moved wrongly!");
    365                }
    366
    367                if (!this.hasMoved) //Fixes "Moved Too Fast" kick when being teleported while moving
    368                {
    369                    return;
    370                }
    371
    372                this.playerEntity.setPositionAndRotation(d1, d2, d3, f2, f3);
    373                boolean flag2 = worldserver.getCollidingBoundingBoxes(this.playerEntity, this.playerEntity.boundingBox.copy().contract((double)f4, (double)f4, (double)f4)).isEmpty();
    374
    375                if (flag && (flag1 || !flag2) && !this.playerEntity.isPlayerSleeping() && !this.playerEntity.noClip)
    376                {
    377                    this.setPlayerLocation(this.lastPosX, this.lastPosY, this.lastPosZ, f2, f3);
    378                    return;
    379                }
    380
    381                AxisAlignedBB axisalignedbb = this.playerEntity.boundingBox.copy().expand((double)f4, (double)f4, (double)f4).addCoord(0.0D, -0.55D, 0.0D);
    382
    383                if (!this.mcServer.isFlightAllowed() && !this.playerEntity.theItemInWorldManager.isCreative() && !worldserver.checkBlockCollision(axisalignedbb)  && !this.playerEntity.capabilities.allowFlying)
    384                {
    385                    if (d12 >= -0.03125D)
    386                    {
    387                        ++this.ticksForFloatKick;
    388
    389                        if (this.ticksForFloatKick > 80)
    390                        {
    391                            this.mcServer.getLogAgent().logWarning(this.playerEntity.username + " was kicked for floating too long!");
    392                            this.kickPlayerFromServer("Flying is not enabled on this server");
    393                            return;
    394                        }
    395                    }
    396                }
    397                else
    398                {
    399                    this.ticksForFloatKick = 0;
    400                }
    401
    402                if (!this.hasMoved) //Fixes "Moved Too Fast" kick when being teleported while moving
    403                {
    404                    return;
    405                }
    406
    407                this.playerEntity.onGround = par1Packet10Flying.onGround;
    408                this.mcServer.getConfigurationManager().serverUpdateMountedMovingPlayer(this.playerEntity);
    409                this.playerEntity.updateFlyingState(this.playerEntity.posY - d0, par1Packet10Flying.onGround);
    410            }
    411        }
    412    }
    413
    414    /**
    415     * Moves the player to the specified destination and rotation
    416     */
    417    public void setPlayerLocation(double par1, double par3, double par5, float par7, float par8)
    418    {
    419        this.hasMoved = false;
    420        this.lastPosX = par1;
    421        this.lastPosY = par3;
    422        this.lastPosZ = par5;
    423        this.playerEntity.setPositionAndRotation(par1, par3, par5, par7, par8);
    424        this.playerEntity.playerNetServerHandler.sendPacketToPlayer(new Packet13PlayerLookMove(par1, par3 + 1.6200000047683716D, par3, par5, par7, par8, false));
    425    }
    426
    427    public void handleBlockDig(Packet14BlockDig par1Packet14BlockDig)
    428    {
    429        WorldServer worldserver = this.mcServer.worldServerForDimension(this.playerEntity.dimension);
    430
    431        if (par1Packet14BlockDig.status == 4)
    432        {
    433            this.playerEntity.dropOneItem(false);
    434        }
    435        else if (par1Packet14BlockDig.status == 3)
    436        {
    437            this.playerEntity.dropOneItem(true);
    438        }
    439        else if (par1Packet14BlockDig.status == 5)
    440        {
    441            this.playerEntity.stopUsingItem();
    442        }
    443        else
    444        {
    445            boolean flag = false;
    446
    447            if (par1Packet14BlockDig.status == 0)
    448            {
    449                flag = true;
    450            }
    451
    452            if (par1Packet14BlockDig.status == 1)
    453            {
    454                flag = true;
    455            }
    456
    457            if (par1Packet14BlockDig.status == 2)
    458            {
    459                flag = true;
    460            }
    461
    462            int i = par1Packet14BlockDig.xPosition;
    463            int j = par1Packet14BlockDig.yPosition;
    464            int k = par1Packet14BlockDig.zPosition;
    465
    466            if (flag)
    467            {
    468                double d0 = this.playerEntity.posX - ((double)i + 0.5D);
    469                double d1 = this.playerEntity.posY - ((double)j + 0.5D) + 1.5D;
    470                double d2 = this.playerEntity.posZ - ((double)k + 0.5D);
    471                double d3 = d0 * d0 + d1 * d1 + d2 * d2;
    472
    473                double dist = playerEntity.theItemInWorldManager.getBlockReachDistance() + 1;
    474                dist *= dist;
    475
    476                if (d3 > dist)
    477                {
    478                    return;
    479                }
    480
    481                if (j >= this.mcServer.getBuildLimit())
    482                {
    483                    return;
    484                }
    485            }
    486
    487            if (par1Packet14BlockDig.status == 0)
    488            {
    489                if (!this.mcServer.func_96290_a(worldserver, i, j, k, this.playerEntity))
    490                {
    491                    this.playerEntity.theItemInWorldManager.onBlockClicked(i, j, k, par1Packet14BlockDig.face);
    492                }
    493                else
    494                {
    495                    this.playerEntity.playerNetServerHandler.sendPacketToPlayer(new Packet53BlockChange(i, j, k, worldserver));
    496                }
    497            }
    498            else if (par1Packet14BlockDig.status == 2)
    499            {
    500                this.playerEntity.theItemInWorldManager.uncheckedTryHarvestBlock(i, j, k);
    501
    502                if (worldserver.getBlockId(i, j, k) != 0)
    503                {
    504                    this.playerEntity.playerNetServerHandler.sendPacketToPlayer(new Packet53BlockChange(i, j, k, worldserver));
    505                }
    506            }
    507            else if (par1Packet14BlockDig.status == 1)
    508            {
    509                this.playerEntity.theItemInWorldManager.cancelDestroyingBlock(i, j, k);
    510
    511                if (worldserver.getBlockId(i, j, k) != 0)
    512                {
    513                    this.playerEntity.playerNetServerHandler.sendPacketToPlayer(new Packet53BlockChange(i, j, k, worldserver));
    514                }
    515            }
    516        }
    517    }
    518
    519    public void handlePlace(Packet15Place par1Packet15Place)
    520    {
    521        WorldServer worldserver = this.mcServer.worldServerForDimension(this.playerEntity.dimension);
    522        ItemStack itemstack = this.playerEntity.inventory.getCurrentItem();
    523        boolean flag = false;
    524        int i = par1Packet15Place.getXPosition();
    525        int j = par1Packet15Place.getYPosition();
    526        int k = par1Packet15Place.getZPosition();
    527        int l = par1Packet15Place.getDirection();
    528
    529        if (par1Packet15Place.getDirection() == 255)
    530        {
    531            if (itemstack == null)
    532            {
    533                return;
    534            }
    535
    536            PlayerInteractEvent event = ForgeEventFactory.onPlayerInteract(playerEntity, PlayerInteractEvent.Action.RIGHT_CLICK_AIR, 0, 0, 0, -1);
    537            if (event.useItem != Event.Result.DENY)
    538            {
    539                this.playerEntity.theItemInWorldManager.tryUseItem(this.playerEntity, worldserver, itemstack);
    540            }
    541        }
    542        else if (par1Packet15Place.getYPosition() >= this.mcServer.getBuildLimit() - 1 && (par1Packet15Place.getDirection() == 1 || par1Packet15Place.getYPosition() >= this.mcServer.getBuildLimit()))
    543        {
    544            this.playerEntity.playerNetServerHandler.sendPacketToPlayer(new Packet3Chat("" + EnumChatFormatting.GRAY + "Height limit for building is " + this.mcServer.getBuildLimit()));
    545            flag = true;
    546        }
    547        else
    548        {
    549            double dist = playerEntity.theItemInWorldManager.getBlockReachDistance() + 1;
    550            dist *= dist;
    551            if (this.hasMoved && this.playerEntity.getDistanceSq((double)i + 0.5D, (double)j + 0.5D, (double)k + 0.5D) < dist && !this.mcServer.func_96290_a(worldserver, i, j, k, this.playerEntity))
    552            {
    553                this.playerEntity.theItemInWorldManager.activateBlockOrUseItem(this.playerEntity, worldserver, itemstack, i, j, k, l, par1Packet15Place.getXOffset(), par1Packet15Place.getYOffset(), par1Packet15Place.getZOffset());
    554            }
    555
    556            flag = true;
    557        }
    558
    559        if (flag)
    560        {
    561            this.playerEntity.playerNetServerHandler.sendPacketToPlayer(new Packet53BlockChange(i, j, k, worldserver));
    562
    563            if (l == 0)
    564            {
    565                --j;
    566            }
    567
    568            if (l == 1)
    569            {
    570                ++j;
    571            }
    572
    573            if (l == 2)
    574            {
    575                --k;
    576            }
    577
    578            if (l == 3)
    579            {
    580                ++k;
    581            }
    582
    583            if (l == 4)
    584            {
    585                --i;
    586            }
    587
    588            if (l == 5)
    589            {
    590                ++i;
    591            }
    592
    593            this.playerEntity.playerNetServerHandler.sendPacketToPlayer(new Packet53BlockChange(i, j, k, worldserver));
    594        }
    595
    596        itemstack = this.playerEntity.inventory.getCurrentItem();
    597
    598        if (itemstack != null && itemstack.stackSize == 0)
    599        {
    600            this.playerEntity.inventory.mainInventory[this.playerEntity.inventory.currentItem] = null;
    601            itemstack = null;
    602        }
    603
    604        if (itemstack == null || itemstack.getMaxItemUseDuration() == 0)
    605        {
    606            this.playerEntity.playerInventoryBeingManipulated = true;
    607            this.playerEntity.inventory.mainInventory[this.playerEntity.inventory.currentItem] = ItemStack.copyItemStack(this.playerEntity.inventory.mainInventory[this.playerEntity.inventory.currentItem]);
    608            Slot slot = this.playerEntity.openContainer.getSlotFromInventory(this.playerEntity.inventory, this.playerEntity.inventory.currentItem);
    609            this.playerEntity.openContainer.detectAndSendChanges();
    610            this.playerEntity.playerInventoryBeingManipulated = false;
    611
    612            if (!ItemStack.areItemStacksEqual(this.playerEntity.inventory.getCurrentItem(), par1Packet15Place.getItemStack()))
    613            {
    614                this.sendPacketToPlayer(new Packet103SetSlot(this.playerEntity.openContainer.windowId, slot.slotNumber, this.playerEntity.inventory.getCurrentItem()));
    615            }
    616        }
    617    }
    618
    619    public void handleErrorMessage(String par1Str, Object[] par2ArrayOfObj)
    620    {
    621        this.mcServer.getLogAgent().logInfo(this.playerEntity.username + " lost connection: " + par1Str);
    622        this.mcServer.getConfigurationManager().sendPacketToAllPlayers(new Packet3Chat(EnumChatFormatting.YELLOW + this.playerEntity.func_96090_ax() + " left the game."));
    623        this.mcServer.getConfigurationManager().playerLoggedOut(this.playerEntity);
    624        this.connectionClosed = true;
    625
    626        if (this.mcServer.isSinglePlayer() && this.playerEntity.username.equals(this.mcServer.getServerOwner()))
    627        {
    628            this.mcServer.getLogAgent().logInfo("Stopping singleplayer server as player logged out");
    629            this.mcServer.initiateShutdown();
    630        }
    631    }
    632
    633    /**
    634     * Default handler called for packets that don't have their own handlers in NetClientHandler; currentlly does
    635     * nothing.
    636     */
    637    public void unexpectedPacket(Packet par1Packet)
    638    {
    639        this.mcServer.getLogAgent().logWarning(this.getClass() + " wasn\'t prepared to deal with a " + par1Packet.getClass());
    640        this.kickPlayerFromServer("Protocol error, unexpected packet");
    641    }
    642
    643    /**
    644     * addToSendQueue. if it is a chat packet, check before sending it
    645     */
    646    public void sendPacketToPlayer(Packet par1Packet)
    647    {
    648        if (par1Packet instanceof Packet3Chat)
    649        {
    650            Packet3Chat packet3chat = (Packet3Chat)par1Packet;
    651            int i = this.playerEntity.getChatVisibility();
    652
    653            if (i == 2)
    654            {
    655                return;
    656            }
    657
    658            if (i == 1 && !packet3chat.getIsServer())
    659            {
    660                return;
    661            }
    662        }
    663
    664        try
    665        {
    666            this.netManager.addToSendQueue(par1Packet);
    667        }
    668        catch (Throwable throwable)
    669        {
    670            CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Sending packet");
    671            CrashReportCategory crashreportcategory = crashreport.makeCategory("Packet being sent");
    672            crashreportcategory.addCrashSectionCallable("Packet ID", new CallablePacketID(this, par1Packet));
    673            crashreportcategory.addCrashSectionCallable("Packet class", new CallablePacketClass(this, par1Packet));
    674            throw new ReportedException(crashreport);
    675        }
    676    }
    677
    678    public void handleBlockItemSwitch(Packet16BlockItemSwitch par1Packet16BlockItemSwitch)
    679    {
    680        if (par1Packet16BlockItemSwitch.id >= 0 && par1Packet16BlockItemSwitch.id < InventoryPlayer.getHotbarSize())
    681        {
    682            this.playerEntity.inventory.currentItem = par1Packet16BlockItemSwitch.id;
    683        }
    684        else
    685        {
    686            this.mcServer.getLogAgent().logWarning(this.playerEntity.username + " tried to set an invalid carried item");
    687        }
    688    }
    689
    690    public void handleChat(Packet3Chat par1Packet3Chat)
    691    {
    692        par1Packet3Chat = FMLNetworkHandler.handleChatMessage(this, par1Packet3Chat);
    693        if (this.playerEntity.getChatVisibility() == 2)
    694        {
    695            this.sendPacketToPlayer(new Packet3Chat("Cannot send chat message."));
    696        }
    697        else
    698        {
    699            String s = par1Packet3Chat.message;
    700
    701            if (s.length() > 100)
    702            {
    703                this.kickPlayerFromServer("Chat message too long");
    704            }
    705            else
    706            {
    707                s = s.trim();
    708
    709                for (int i = 0; i < s.length(); ++i)
    710                {
    711                    if (!ChatAllowedCharacters.isAllowedCharacter(s.charAt(i)))
    712                    {
    713                        this.kickPlayerFromServer("Illegal characters in chat");
    714                        return;
    715                    }
    716                }
    717
    718                if (s.startsWith("/"))
    719                {
    720                    this.handleSlashCommand(s);
    721                }
    722                else
    723                {
    724                    if (this.playerEntity.getChatVisibility() == 1)
    725                    {
    726                        this.sendPacketToPlayer(new Packet3Chat("Cannot send chat message."));
    727                        return;
    728                    }
    729
    730                    String old = s;
    731                    s = "<" + this.playerEntity.func_96090_ax() + "> " + s;
    732                    ServerChatEvent event = new ServerChatEvent(this.playerEntity, old, s);
    733                    if (MinecraftForge.EVENT_BUS.post(event))
    734                    {
    735                        return;
    736                    }
    737                    s = event.line;
    738                    this.mcServer.getLogAgent().logInfo(s);
    739                    this.mcServer.getConfigurationManager().sendPacketToAllPlayers(new Packet3Chat(s, false));
    740                }
    741
    742                this.chatSpamThresholdCount += 20;
    743
    744                if (this.chatSpamThresholdCount > 200 && !this.mcServer.getConfigurationManager().areCommandsAllowed(this.playerEntity.username))
    745                {
    746                    this.kickPlayerFromServer("disconnect.spam");
    747                }
    748            }
    749        }
    750    }
    751
    752    /**
    753     * Processes a / command
    754     */
    755    private void handleSlashCommand(String par1Str)
    756    {
    757        this.mcServer.getCommandManager().executeCommand(this.playerEntity, par1Str);
    758    }
    759
    760    public void handleAnimation(Packet18Animation par1Packet18Animation)
    761    {
    762        if (par1Packet18Animation.animate == 1)
    763        {
    764            this.playerEntity.swingItem();
    765        }
    766    }
    767
    768    /**
    769     * runs registerPacket on the given Packet19EntityAction
    770     */
    771    public void handleEntityAction(Packet19EntityAction par1Packet19EntityAction)
    772    {
    773        if (par1Packet19EntityAction.state == 1)
    774        {
    775            this.playerEntity.setSneaking(true);
    776        }
    777        else if (par1Packet19EntityAction.state == 2)
    778        {
    779            this.playerEntity.setSneaking(false);
    780        }
    781        else if (par1Packet19EntityAction.state == 4)
    782        {
    783            this.playerEntity.setSprinting(true);
    784        }
    785        else if (par1Packet19EntityAction.state == 5)
    786        {
    787            this.playerEntity.setSprinting(false);
    788        }
    789        else if (par1Packet19EntityAction.state == 3)
    790        {
    791            this.playerEntity.wakeUpPlayer(false, true, true);
    792            this.hasMoved = false;
    793        }
    794    }
    795
    796    public void handleKickDisconnect(Packet255KickDisconnect par1Packet255KickDisconnect)
    797    {
    798        this.netManager.networkShutdown("disconnect.quitting", new Object[0]);
    799    }
    800
    801    /**
    802     * returns 0 for memoryMapped connections
    803     */
    804    public int packetSize()
    805    {
    806        return this.netManager.packetSize();
    807    }
    808
    809    public void handleUseEntity(Packet7UseEntity par1Packet7UseEntity)
    810    {
    811        WorldServer worldserver = this.mcServer.worldServerForDimension(this.playerEntity.dimension);
    812        Entity entity = worldserver.getEntityByID(par1Packet7UseEntity.targetEntity);
    813
    814        if (entity != null)
    815        {
    816            boolean flag = this.playerEntity.canEntityBeSeen(entity);
    817            double d0 = 36.0D;
    818
    819            if (!flag)
    820            {
    821                d0 = 9.0D;
    822            }
    823
    824            if (this.playerEntity.getDistanceSqToEntity(entity) < d0)
    825            {
    826                if (par1Packet7UseEntity.isLeftClick == 0)
    827                {
    828                    this.playerEntity.interactWith(entity);
    829                }
    830                else if (par1Packet7UseEntity.isLeftClick == 1)
    831                {
    832                    this.playerEntity.attackTargetEntityWithCurrentItem(entity);
    833                }
    834            }
    835        }
    836    }
    837
    838    public void handleClientCommand(Packet205ClientCommand par1Packet205ClientCommand)
    839    {
    840        if (par1Packet205ClientCommand.forceRespawn == 1)
    841        {
    842            if (this.playerEntity.playerConqueredTheEnd)
    843            {
    844                this.playerEntity = this.mcServer.getConfigurationManager().respawnPlayer(this.playerEntity, 0, true);
    845            }
    846            else if (this.playerEntity.getServerForPlayer().getWorldInfo().isHardcoreModeEnabled())
    847            {
    848                if (this.mcServer.isSinglePlayer() && this.playerEntity.username.equals(this.mcServer.getServerOwner()))
    849                {
    850                    this.playerEntity.playerNetServerHandler.kickPlayerFromServer("You have died. Game over, man, it\'s game over!");
    851                    this.mcServer.deleteWorldAndStopServer();
    852                }
    853                else
    854                {
    855                    BanEntry banentry = new BanEntry(this.playerEntity.username);
    856                    banentry.setBanReason("Death in Hardcore");
    857                    this.mcServer.getConfigurationManager().getBannedPlayers().put(banentry);
    858                    this.playerEntity.playerNetServerHandler.kickPlayerFromServer("You have died. Game over, man, it\'s game over!");
    859                }
    860            }
    861            else
    862            {
    863                if (this.playerEntity.getHealth() > 0)
    864                {
    865                    return;
    866                }
    867
    868                this.playerEntity = this.mcServer.getConfigurationManager().respawnPlayer(this.playerEntity, playerEntity.dimension, false);
    869            }
    870        }
    871    }
    872
    873    /**
    874     * If this returns false, all packets will be queued for the main thread to handle, even if they would otherwise be
    875     * processed asynchronously. Used to avoid processing packets on the client before the world has been downloaded
    876     * (which happens on the main thread)
    877     */
    878    public boolean canProcessPacketsAsync()
    879    {
    880        return true;
    881    }
    882
    883    /**
    884     * respawns the player
    885     */
    886    public void handleRespawn(Packet9Respawn par1Packet9Respawn) {}
    887
    888    public void handleCloseWindow(Packet101CloseWindow par1Packet101CloseWindow)
    889    {
    890        this.playerEntity.closeInventory();
    891    }
    892
    893    public void handleWindowClick(Packet102WindowClick par1Packet102WindowClick)
    894    {
    895        if (this.playerEntity.openContainer.windowId == par1Packet102WindowClick.window_Id && this.playerEntity.openContainer.isPlayerNotUsingContainer(this.playerEntity))
    896        {
    897            ItemStack itemstack = this.playerEntity.openContainer.slotClick(par1Packet102WindowClick.inventorySlot, par1Packet102WindowClick.mouseClick, par1Packet102WindowClick.holdingShift, this.playerEntity);
    898
    899            if (ItemStack.areItemStacksEqual(par1Packet102WindowClick.itemStack, itemstack))
    900            {
    901                this.playerEntity.playerNetServerHandler.sendPacketToPlayer(new Packet106Transaction(par1Packet102WindowClick.window_Id, par1Packet102WindowClick.action, true));
    902                this.playerEntity.playerInventoryBeingManipulated = true;
    903                this.playerEntity.openContainer.detectAndSendChanges();
    904                this.playerEntity.updateHeldItem();
    905                this.playerEntity.playerInventoryBeingManipulated = false;
    906            }
    907            else
    908            {
    909                this.field_72586_s.addKey(this.playerEntity.openContainer.windowId, Short.valueOf(par1Packet102WindowClick.action));
    910                this.playerEntity.playerNetServerHandler.sendPacketToPlayer(new Packet106Transaction(par1Packet102WindowClick.window_Id, par1Packet102WindowClick.action, false));
    911                this.playerEntity.openContainer.setPlayerIsPresent(this.playerEntity, false);
    912                ArrayList arraylist = new ArrayList();
    913
    914                for (int i = 0; i < this.playerEntity.openContainer.inventorySlots.size(); ++i)
    915                {
    916                    arraylist.add(((Slot)this.playerEntity.openContainer.inventorySlots.get(i)).getStack());
    917                }
    918
    919                this.playerEntity.sendContainerAndContentsToPlayer(this.playerEntity.openContainer, arraylist);
    920            }
    921        }
    922    }
    923
    924    public void handleEnchantItem(Packet108EnchantItem par1Packet108EnchantItem)
    925    {
    926        if (this.playerEntity.openContainer.windowId == par1Packet108EnchantItem.windowId && this.playerEntity.openContainer.isPlayerNotUsingContainer(this.playerEntity))
    927        {
    928            this.playerEntity.openContainer.enchantItem(this.playerEntity, par1Packet108EnchantItem.enchantment);
    929            this.playerEntity.openContainer.detectAndSendChanges();
    930        }
    931    }
    932
    933    /**
    934     * Handle a creative slot packet.
    935     */
    936    public void handleCreativeSetSlot(Packet107CreativeSetSlot par1Packet107CreativeSetSlot)
    937    {
    938        if (this.playerEntity.theItemInWorldManager.isCreative())
    939        {
    940            boolean flag = par1Packet107CreativeSetSlot.slot < 0;
    941            ItemStack itemstack = par1Packet107CreativeSetSlot.itemStack;
    942            boolean flag1 = par1Packet107CreativeSetSlot.slot >= 1 && par1Packet107CreativeSetSlot.slot < 36 + InventoryPlayer.getHotbarSize();
    943            boolean flag2 = itemstack == null || itemstack.itemID < Item.itemsList.length && itemstack.itemID >= 0 && Item.itemsList[itemstack.itemID] != null;
    944            boolean flag3 = itemstack == null || itemstack.getItemDamage() >= 0 && itemstack.getItemDamage() >= 0 && itemstack.stackSize <= 64 && itemstack.stackSize > 0;
    945
    946            if (flag1 && flag2 && flag3)
    947            {
    948                if (itemstack == null)
    949                {
    950                    this.playerEntity.inventoryContainer.putStackInSlot(par1Packet107CreativeSetSlot.slot, (ItemStack)null);
    951                }
    952                else
    953                {
    954                    this.playerEntity.inventoryContainer.putStackInSlot(par1Packet107CreativeSetSlot.slot, itemstack);
    955                }
    956
    957                this.playerEntity.inventoryContainer.setPlayerIsPresent(this.playerEntity, true);
    958            }
    959            else if (flag && flag2 && flag3 && this.creativeItemCreationSpamThresholdTally < 200)
    960            {
    961                this.creativeItemCreationSpamThresholdTally += 20;
    962                EntityItem entityitem = this.playerEntity.dropPlayerItem(itemstack);
    963
    964                if (entityitem != null)
    965                {
    966                    entityitem.setAgeToCreativeDespawnTime();
    967                }
    968            }
    969        }
    970    }
    971
    972    public void handleTransaction(Packet106Transaction par1Packet106Transaction)
    973    {
    974        Short oshort = (Short)this.field_72586_s.lookup(this.playerEntity.openContainer.windowId);
    975
    976        if (oshort != null && par1Packet106Transaction.shortWindowId == oshort.shortValue() && this.playerEntity.openContainer.windowId == par1Packet106Transaction.windowId && !this.playerEntity.openContainer.isPlayerNotUsingContainer(this.playerEntity))
    977        {
    978            this.playerEntity.openContainer.setPlayerIsPresent(this.playerEntity, true);
    979        }
    980    }
    981
    982    /**
    983     * Updates Client side signs
    984     */
    985    public void handleUpdateSign(Packet130UpdateSign par1Packet130UpdateSign)
    986    {
    987        WorldServer worldserver = this.mcServer.worldServerForDimension(this.playerEntity.dimension);
    988
    989        if (worldserver.blockExists(par1Packet130UpdateSign.xPosition, par1Packet130UpdateSign.yPosition, par1Packet130UpdateSign.zPosition))
    990        {
    991            TileEntity tileentity = worldserver.getBlockTileEntity(par1Packet130UpdateSign.xPosition, par1Packet130UpdateSign.yPosition, par1Packet130UpdateSign.zPosition);
    992
    993            if (tileentity instanceof TileEntitySign)
    994            {
    995                TileEntitySign tileentitysign = (TileEntitySign)tileentity;
    996
    997                if (!tileentitysign.isEditable())
    998                {
    999                    this.mcServer.logWarning("Player " + this.playerEntity.username + " just tried to change non-editable sign");
    1000                    return;
    1001                }
    1002            }
    1003
    1004            int i;
    1005            int j;
    1006
    1007            for (j = 0; j < 4; ++j)
    1008            {
    1009                boolean flag = true;
    1010
    1011                if (par1Packet130UpdateSign.signLines[j].length() > 15)
    1012                {
    1013                    flag = false;
    1014                }
    1015                else
    1016                {
    1017                    for (i = 0; i < par1Packet130UpdateSign.signLines[j].length(); ++i)
    1018                    {
    1019                        if (ChatAllowedCharacters.allowedCharacters.indexOf(par1Packet130UpdateSign.signLines[j].charAt(i)) < 0)
    1020                        {
    1021                            flag = false;
    1022                        }
    1023                    }
    1024                }
    1025
    1026                if (!flag)
    1027                {
    1028                    par1Packet130UpdateSign.signLines[j] = "!?";
    1029                }
    1030            }
    1031
    1032            if (tileentity instanceof TileEntitySign)
    1033            {
    1034                j = par1Packet130UpdateSign.xPosition;
    1035                int k = par1Packet130UpdateSign.yPosition;
    1036                i = par1Packet130UpdateSign.zPosition;
    1037                TileEntitySign tileentitysign1 = (TileEntitySign)tileentity;
    1038                System.arraycopy(par1Packet130UpdateSign.signLines, 0, tileentitysign1.signText, 0, 4);
    1039                tileentitysign1.onInventoryChanged();
    1040                worldserver.markBlockForUpdate(j, k, i);
    1041            }
    1042        }
    1043    }
    1044
    1045    /**
    1046     * Handle a keep alive packet.
    1047     */
    1048    public void handleKeepAlive(Packet0KeepAlive par1Packet0KeepAlive)
    1049    {
    1050        if (par1Packet0KeepAlive.randomId == this.keepAliveRandomID)
    1051        {
    1052            int i = (int)(System.nanoTime() / 1000000L - this.keepAliveTimeSent);
    1053            this.playerEntity.ping = (this.playerEntity.ping * 3 + i) / 4;
    1054        }
    1055    }
    1056
    1057    /**
    1058     * determine if it is a server handler
    1059     */
    1060    public boolean isServerHandler()
    1061    {
    1062        return true;
    1063    }
    1064
    1065    /**
    1066     * Handle a player abilities packet.
    1067     */
    1068    public void handlePlayerAbilities(Packet202PlayerAbilities par1Packet202PlayerAbilities)
    1069    {
    1070        this.playerEntity.capabilities.isFlying = par1Packet202PlayerAbilities.getFlying() && this.playerEntity.capabilities.allowFlying;
    1071    }
    1072
    1073    public void handleAutoComplete(Packet203AutoComplete par1Packet203AutoComplete)
    1074    {
    1075        StringBuilder stringbuilder = new StringBuilder();
    1076        String s;
    1077
    1078        for (Iterator iterator = this.mcServer.getPossibleCompletions(this.playerEntity, par1Packet203AutoComplete.getText()).iterator(); iterator.hasNext(); stringbuilder.append(s))
    1079        {
    1080            s = (String)iterator.next();
    1081
    1082            if (stringbuilder.length() > 0)
    1083            {
    1084                stringbuilder.append("\u0000");
    1085            }
    1086        }
    1087
    1088        this.playerEntity.playerNetServerHandler.sendPacketToPlayer(new Packet203AutoComplete(stringbuilder.toString()));
    1089    }
    1090
    1091    public void handleClientInfo(Packet204ClientInfo par1Packet204ClientInfo)
    1092    {
    1093        this.playerEntity.updateClientInfo(par1Packet204ClientInfo);
    1094    }
    1095
    1096    public void handleCustomPayload(Packet250CustomPayload par1Packet250CustomPayload)
    1097    {
    1098        FMLNetworkHandler.handlePacket250Packet(par1Packet250CustomPayload, netManager, this);
    1099    }
    1100
    1101    public void handleVanilla250Packet(Packet250CustomPayload par1Packet250CustomPayload)
    1102    {
    1103        DataInputStream datainputstream;
    1104        ItemStack itemstack;
    1105        ItemStack itemstack1;
    1106
    1107        if ("MC|BEdit".equals(par1Packet250CustomPayload.channel))
    1108        {
    1109            try
    1110            {
    1111                datainputstream = new DataInputStream(new ByteArrayInputStream(par1Packet250CustomPayload.data));
    1112                itemstack = Packet.readItemStack(datainputstream);
    1113
    1114                if (!ItemWritableBook.validBookTagPages(itemstack.getTagCompound()))
    1115                {
    1116                    throw new IOException("Invalid book tag!");
    1117                }
    1118
    1119                itemstack1 = this.playerEntity.inventory.getCurrentItem();
    1120
    1121                if (itemstack != null && itemstack.itemID == Item.writableBook.itemID && itemstack.itemID == itemstack1.itemID)
    1122                {
    1123                    itemstack1.setTagInfo("pages", itemstack.getTagCompound().getTagList("pages"));
    1124                }
    1125            }
    1126            catch (Exception exception)
    1127            {
    1128                exception.printStackTrace();
    1129            }
    1130        }
    1131        else if ("MC|BSign".equals(par1Packet250CustomPayload.channel))
    1132        {
    1133            try
    1134            {
    1135                datainputstream = new DataInputStream(new ByteArrayInputStream(par1Packet250CustomPayload.data));
    1136                itemstack = Packet.readItemStack(datainputstream);
    1137
    1138                if (!ItemEditableBook.validBookTagContents(itemstack.getTagCompound()))
    1139                {
    1140                    throw new IOException("Invalid book tag!");
    1141                }
    1142
    1143                itemstack1 = this.playerEntity.inventory.getCurrentItem();
    1144
    1145                if (itemstack != null && itemstack.itemID == Item.writtenBook.itemID && itemstack1.itemID == Item.writableBook.itemID)
    1146                {
    1147                    itemstack1.setTagInfo("author", new NBTTagString("author", this.playerEntity.username));
    1148                    itemstack1.setTagInfo("title", new NBTTagString("title", itemstack.getTagCompound().getString("title")));
    1149                    itemstack1.setTagInfo("pages", itemstack.getTagCompound().getTagList("pages"));
    1150                    itemstack1.itemID = Item.writtenBook.itemID;
    1151                }
    1152            }
    1153            catch (Exception exception1)
    1154            {
    1155                exception1.printStackTrace();
    1156            }
    1157        }
    1158        else
    1159        {
    1160            int i;
    1161
    1162            if ("MC|TrSel".equals(par1Packet250CustomPayload.channel))
    1163            {
    1164                try
    1165                {
    1166                    datainputstream = new DataInputStream(new ByteArrayInputStream(par1Packet250CustomPayload.data));
    1167                    i = datainputstream.readInt();
    1168                    Container container = this.playerEntity.openContainer;
    1169
    1170                    if (container instanceof ContainerMerchant)
    1171                    {
    1172                        ((ContainerMerchant)container).setCurrentRecipeIndex(i);
    1173                    }
    1174                }
    1175                catch (Exception exception2)
    1176                {
    1177                    exception2.printStackTrace();
    1178                }
    1179            }
    1180            else
    1181            {
    1182                int j;
    1183
    1184                if ("MC|AdvCdm".equals(par1Packet250CustomPayload.channel))
    1185                {
    1186                    if (!this.mcServer.isCommandBlockEnabled())
    1187                    {
    1188                        this.playerEntity.sendChatToPlayer(this.playerEntity.translateString("advMode.notEnabled", new Object[0]));
    1189                    }
    1190                    else if (this.playerEntity.canCommandSenderUseCommand(2, "") && this.playerEntity.capabilities.isCreativeMode)
    1191                    {
    1192                        try
    1193                        {
    1194                            datainputstream = new DataInputStream(new ByteArrayInputStream(par1Packet250CustomPayload.data));
    1195                            i = datainputstream.readInt();
    1196                            j = datainputstream.readInt();
    1197                            int k = datainputstream.readInt();
    1198                            String s = Packet.readString(datainputstream, 256);
    1199                            TileEntity tileentity = this.playerEntity.worldObj.getBlockTileEntity(i, j, k);
    1200
    1201                            if (tileentity != null && tileentity instanceof TileEntityCommandBlock)
    1202                            {
    1203                                ((TileEntityCommandBlock)tileentity).setCommand(s);
    1204                                this.playerEntity.worldObj.markBlockForUpdate(i, j, k);
    1205                                this.playerEntity.sendChatToPlayer("Command set: " + s);
    1206                            }
    1207                        }
    1208                        catch (Exception exception3)
    1209                        {
    1210                            exception3.printStackTrace();
    1211                        }
    1212                    }
    1213                    else
    1214                    {
    1215                        this.playerEntity.sendChatToPlayer(this.playerEntity.translateString("advMode.notAllowed", new Object[0]));
    1216                    }
    1217                }
    1218                else if ("MC|Beacon".equals(par1Packet250CustomPayload.channel))
    1219                {
    1220                    if (this.playerEntity.openContainer instanceof ContainerBeacon)
    1221                    {
    1222                        try
    1223                        {
    1224                            datainputstream = new DataInputStream(new ByteArrayInputStream(par1Packet250CustomPayload.data));
    1225                            i = datainputstream.readInt();
    1226                            j = datainputstream.readInt();
    1227                            ContainerBeacon containerbeacon = (ContainerBeacon)this.playerEntity.openContainer;
    1228                            Slot slot = containerbeacon.getSlot(0);
    1229
    1230                            if (slot.getHasStack())
    1231                            {
    1232                                slot.decrStackSize(1);
    1233                                TileEntityBeacon tileentitybeacon = containerbeacon.getBeacon();
    1234                                tileentitybeacon.setPrimaryEffect(i);
    1235                                tileentitybeacon.setSecondaryEffect(j);
    1236                                tileentitybeacon.onInventoryChanged();
    1237                            }
    1238                        }
    1239                        catch (Exception exception4)
    1240                        {
    1241                            exception4.printStackTrace();
    1242                        }
    1243                    }
    1244                }
    1245                else if ("MC|ItemName".equals(par1Packet250CustomPayload.channel) && this.playerEntity.openContainer instanceof ContainerRepair)
    1246                {
    1247                    ContainerRepair containerrepair = (ContainerRepair)this.playerEntity.openContainer;
    1248
    1249                    if (par1Packet250CustomPayload.data != null && par1Packet250CustomPayload.data.length >= 1)
    1250                    {
    1251                        String s1 = ChatAllowedCharacters.filerAllowedCharacters(new String(par1Packet250CustomPayload.data));
    1252
    1253                        if (s1.length() <= 30)
    1254                        {
    1255                            containerrepair.updateItemName(s1);
    1256                        }
    1257                    }
    1258                    else
    1259                    {
    1260                        containerrepair.updateItemName("");
    1261                    }
    1262                }
    1263            }
    1264        }
    1265    }
    1266
    1267
    1268    @Override
    1269
    1270    /**
    1271     * Contains logic for handling packets containing arbitrary unique item data. Currently this is only for maps.
    1272     */
    1273    public void handleMapData(Packet131MapData par1Packet131MapData)
    1274    {
    1275        FMLNetworkHandler.handlePacket131Packet(this, par1Packet131MapData);
    1276    }
    1277
    1278    // modloader compat -- yuk!
    1279    @Override
    1280    public EntityPlayerMP getPlayer()
    1281    {
    1282        return playerEntity;
    1283    }
    1284}