001    package net.minecraft.src;
002    
003    import cpw.mods.fml.common.Side;
004    import cpw.mods.fml.common.asm.SideOnly;
005    import cpw.mods.fml.common.network.FMLNetworkHandler;
006    
007    import java.io.BufferedReader;
008    import java.io.ByteArrayInputStream;
009    import java.io.DataInputStream;
010    import java.io.IOException;
011    import java.io.InputStreamReader;
012    import java.math.BigInteger;
013    import java.net.InetAddress;
014    import java.net.Socket;
015    import java.net.URL;
016    import java.net.URLEncoder;
017    import java.security.PublicKey;
018    import java.util.ArrayList;
019    import java.util.HashMap;
020    import java.util.List;
021    import java.util.Map;
022    import java.util.Random;
023    import javax.crypto.SecretKey;
024    import net.minecraft.client.Minecraft;
025    import net.minecraftforge.client.ForgeHooksClient;
026    import net.minecraftforge.client.event.ClientChatReceivedEvent;
027    import net.minecraftforge.common.ForgeHooks;
028    import net.minecraftforge.common.MinecraftForge;
029    
030    import org.lwjgl.input.Keyboard;
031    
032    @SideOnly(Side.CLIENT)
033    public class NetClientHandler extends NetHandler
034    {
035        private boolean field_72554_f = false;
036    
037        /** Reference to the NetworkManager object. */
038        private NetworkManager netManager;
039        public String field_72560_a;
040    
041        /** Reference to the Minecraft object. */
042        private Minecraft mc;
043        private WorldClient worldClient;
044    
045        /**
046         * True if the client has finished downloading terrain and may spawn. Set upon receipt of a player position packet,
047         * reset upon respawning.
048         */
049        private boolean doneLoadingTerrain = false;
050        public MapStorage mapStorage = new MapStorage((ISaveHandler)null);
051    
052        /** A HashMap of all player names and their player information objects */
053        private Map playerInfoMap = new HashMap();
054    
055        /**
056         * An ArrayList of GuiPlayerInfo (includes all the players' GuiPlayerInfo on the current server)
057         */
058        public List playerInfoList = new ArrayList();
059        public int currentServerMaxPlayers = 20;
060    
061        /** RNG. */
062        Random rand = new Random();
063    
064        private static byte connectionCompatibilityLevel;
065    
066        public NetClientHandler(Minecraft par1Minecraft, String par2Str, int par3) throws IOException
067        {
068            this.mc = par1Minecraft;
069            Socket var4 = new Socket(InetAddress.getByName(par2Str), par3);
070            this.netManager = new TcpConnection(var4, "Client", this);
071            FMLNetworkHandler.onClientConnectionToRemoteServer(this, par2Str, par3, this.netManager);
072        }
073    
074        public NetClientHandler(Minecraft par1Minecraft, IntegratedServer par2IntegratedServer) throws IOException
075        {
076            this.mc = par1Minecraft;
077            this.netManager = new MemoryConnection(this);
078            par2IntegratedServer.func_71343_a().func_71754_a((MemoryConnection)this.netManager, par1Minecraft.session.username);
079            FMLNetworkHandler.onClientConnectionToIntegratedServer(this, par2IntegratedServer, this.netManager);
080        }
081    
082        /**
083         * sets netManager and worldClient to null
084         */
085        public void cleanup()
086        {
087            if (this.netManager != null)
088            {
089                this.netManager.wakeThreads();
090            }
091    
092            this.netManager = null;
093            this.worldClient = null;
094        }
095    
096        /**
097         * Processes the packets that have been read since the last call to this function.
098         */
099        public void processReadPackets()
100        {
101            if (!this.field_72554_f && this.netManager != null)
102            {
103                this.netManager.processReadPackets();
104            }
105    
106            if (this.netManager != null)
107            {
108                this.netManager.wakeThreads();
109            }
110        }
111    
112        public void handleServerAuthData(Packet253ServerAuthData par1Packet253ServerAuthData)
113        {
114            String var2 = par1Packet253ServerAuthData.getServerId().trim();
115            PublicKey var3 = par1Packet253ServerAuthData.getPublicKey();
116            SecretKey var4 = CryptManager.func_75890_a();
117    
118            if (!"-".equals(var2))
119            {
120                String var5 = (new BigInteger(CryptManager.func_75895_a(var2, var3, var4))).toString(16);
121                String var6 = this.func_72550_a(this.mc.session.username, this.mc.session.sessionId, var5);
122    
123                if (!"ok".equalsIgnoreCase(var6))
124                {
125                    this.netManager.networkShutdown("disconnect.loginFailedInfo", new Object[] {var6});
126                    return;
127                }
128            }
129    
130            this.addToSendQueue(new Packet252SharedKey(var4, var3, par1Packet253ServerAuthData.getVerifyToken()));
131        }
132    
133        private String func_72550_a(String par1Str, String par2Str, String par3Str)
134        {
135            try
136            {
137                URL var4 = new URL("http://session.minecraft.net/game/joinserver.jsp?user=" + func_72549_a(par1Str) + "&sessionId=" + func_72549_a(par2Str) + "&serverId=" + func_72549_a(par3Str));
138                BufferedReader var5 = new BufferedReader(new InputStreamReader(var4.openStream()));
139                String var6 = var5.readLine();
140                var5.close();
141                return var6;
142            }
143            catch (IOException var7)
144            {
145                return var7.toString();
146            }
147        }
148    
149        private static String func_72549_a(String par0Str) throws IOException
150        {
151            return URLEncoder.encode(par0Str, "UTF-8");
152        }
153    
154        public void handleSharedKey(Packet252SharedKey par1Packet252SharedKey)
155        {
156            this.addToSendQueue(FMLNetworkHandler.getFMLFakeLoginPacket());
157            this.addToSendQueue(new Packet205ClientCommand(0));
158        }
159    
160        public void handleLogin(Packet1Login par1Packet1Login)
161        {
162            this.mc.playerController = new PlayerControllerMP(this.mc, this);
163            this.mc.statFileWriter.readStat(StatList.joinMultiplayerStat, 1);
164            this.worldClient = new WorldClient(this, new WorldSettings(0L, par1Packet1Login.gameType, false, par1Packet1Login.field_73560_c, par1Packet1Login.terrainType), par1Packet1Login.dimension, par1Packet1Login.difficultySetting, this.mc.mcProfiler);
165            this.worldClient.isRemote = true;
166            this.mc.loadWorld(this.worldClient);
167            this.mc.thePlayer.dimension = par1Packet1Login.dimension;
168            this.mc.displayGuiScreen(new GuiDownloadTerrain(this));
169            this.mc.thePlayer.entityId = par1Packet1Login.clientEntityId;
170            this.currentServerMaxPlayers = par1Packet1Login.maxPlayers;
171            this.mc.playerController.setGameType(par1Packet1Login.gameType);
172            FMLNetworkHandler.onConnectionEstablishedToServer(this, netManager, par1Packet1Login);
173            this.addToSendQueue(new Packet204ClientInfo(this.mc.gameSettings.language, this.mc.gameSettings.renderDistance, this.mc.gameSettings.chatVisibility, this.mc.gameSettings.chatColours, this.mc.gameSettings.difficulty));
174        }
175    
176        public void handlePickupSpawn(Packet21PickupSpawn par1Packet21PickupSpawn)
177        {
178            double var2 = (double)par1Packet21PickupSpawn.xPosition / 32.0D;
179            double var4 = (double)par1Packet21PickupSpawn.yPosition / 32.0D;
180            double var6 = (double)par1Packet21PickupSpawn.zPosition / 32.0D;
181            EntityItem var8 = new EntityItem(this.worldClient, var2, var4, var6, new ItemStack(par1Packet21PickupSpawn.itemID, par1Packet21PickupSpawn.count, par1Packet21PickupSpawn.itemDamage));
182            var8.motionX = (double)par1Packet21PickupSpawn.rotation / 128.0D;
183            var8.motionY = (double)par1Packet21PickupSpawn.pitch / 128.0D;
184            var8.motionZ = (double)par1Packet21PickupSpawn.roll / 128.0D;
185            var8.serverPosX = par1Packet21PickupSpawn.xPosition;
186            var8.serverPosY = par1Packet21PickupSpawn.yPosition;
187            var8.serverPosZ = par1Packet21PickupSpawn.zPosition;
188            this.worldClient.addEntityToWorld(par1Packet21PickupSpawn.entityId, var8);
189        }
190    
191        public void handleVehicleSpawn(Packet23VehicleSpawn par1Packet23VehicleSpawn)
192        {
193            double var2 = (double)par1Packet23VehicleSpawn.xPosition / 32.0D;
194            double var4 = (double)par1Packet23VehicleSpawn.yPosition / 32.0D;
195            double var6 = (double)par1Packet23VehicleSpawn.zPosition / 32.0D;
196            Object var8 = null;
197    
198            if (par1Packet23VehicleSpawn.type == 10)
199            {
200                var8 = new EntityMinecart(this.worldClient, var2, var4, var6, 0);
201            }
202            else if (par1Packet23VehicleSpawn.type == 11)
203            {
204                var8 = new EntityMinecart(this.worldClient, var2, var4, var6, 1);
205            }
206            else if (par1Packet23VehicleSpawn.type == 12)
207            {
208                var8 = new EntityMinecart(this.worldClient, var2, var4, var6, 2);
209            }
210            else if (par1Packet23VehicleSpawn.type == 90)
211            {
212                Entity var9 = this.getEntityByID(par1Packet23VehicleSpawn.throwerEntityId);
213    
214                if (var9 instanceof EntityPlayer)
215                {
216                    var8 = new EntityFishHook(this.worldClient, var2, var4, var6, (EntityPlayer)var9);
217                }
218    
219                par1Packet23VehicleSpawn.throwerEntityId = 0;
220            }
221            else if (par1Packet23VehicleSpawn.type == 60)
222            {
223                var8 = new EntityArrow(this.worldClient, var2, var4, var6);
224            }
225            else if (par1Packet23VehicleSpawn.type == 61)
226            {
227                var8 = new EntitySnowball(this.worldClient, var2, var4, var6);
228            }
229            else if (par1Packet23VehicleSpawn.type == 65)
230            {
231                var8 = new EntityEnderPearl(this.worldClient, var2, var4, var6);
232            }
233            else if (par1Packet23VehicleSpawn.type == 72)
234            {
235                var8 = new EntityEnderEye(this.worldClient, var2, var4, var6);
236            }
237            else if (par1Packet23VehicleSpawn.type == 63)
238            {
239                var8 = new EntityFireball(this.worldClient, var2, var4, var6, (double)par1Packet23VehicleSpawn.speedX / 8000.0D, (double)par1Packet23VehicleSpawn.speedY / 8000.0D, (double)par1Packet23VehicleSpawn.speedZ / 8000.0D);
240                par1Packet23VehicleSpawn.throwerEntityId = 0;
241            }
242            else if (par1Packet23VehicleSpawn.type == 64)
243            {
244                var8 = new EntitySmallFireball(this.worldClient, var2, var4, var6, (double)par1Packet23VehicleSpawn.speedX / 8000.0D, (double)par1Packet23VehicleSpawn.speedY / 8000.0D, (double)par1Packet23VehicleSpawn.speedZ / 8000.0D);
245                par1Packet23VehicleSpawn.throwerEntityId = 0;
246            }
247            else if (par1Packet23VehicleSpawn.type == 62)
248            {
249                var8 = new EntityEgg(this.worldClient, var2, var4, var6);
250            }
251            else if (par1Packet23VehicleSpawn.type == 73)
252            {
253                var8 = new EntityPotion(this.worldClient, var2, var4, var6, par1Packet23VehicleSpawn.throwerEntityId);
254                par1Packet23VehicleSpawn.throwerEntityId = 0;
255            }
256            else if (par1Packet23VehicleSpawn.type == 75)
257            {
258                var8 = new EntityExpBottle(this.worldClient, var2, var4, var6);
259                par1Packet23VehicleSpawn.throwerEntityId = 0;
260            }
261            else if (par1Packet23VehicleSpawn.type == 1)
262            {
263                var8 = new EntityBoat(this.worldClient, var2, var4, var6);
264            }
265            else if (par1Packet23VehicleSpawn.type == 50)
266            {
267                var8 = new EntityTNTPrimed(this.worldClient, var2, var4, var6);
268            }
269            else if (par1Packet23VehicleSpawn.type == 51)
270            {
271                var8 = new EntityEnderCrystal(this.worldClient, var2, var4, var6);
272            }
273            else if (par1Packet23VehicleSpawn.type == 70)
274            {
275                var8 = new EntityFallingSand(this.worldClient, var2, var4, var6, par1Packet23VehicleSpawn.throwerEntityId & 65535, par1Packet23VehicleSpawn.throwerEntityId >> 16);
276                par1Packet23VehicleSpawn.throwerEntityId = 0;
277            }
278    
279            if (var8 != null)
280            {
281                ((Entity)var8).serverPosX = par1Packet23VehicleSpawn.xPosition;
282                ((Entity)var8).serverPosY = par1Packet23VehicleSpawn.yPosition;
283                ((Entity)var8).serverPosZ = par1Packet23VehicleSpawn.zPosition;
284                ((Entity)var8).rotationYaw = 0.0F;
285                ((Entity)var8).rotationPitch = 0.0F;
286                Entity[] var15 = ((Entity)var8).getParts();
287    
288                if (var15 != null)
289                {
290                    int var10 = par1Packet23VehicleSpawn.entityId - ((Entity)var8).entityId;
291                    Entity[] var11 = var15;
292                    int var12 = var15.length;
293    
294                    for (int var13 = 0; var13 < var12; ++var13)
295                    {
296                        Entity var14 = var11[var13];
297                        var14.entityId += var10;
298                    }
299                }
300    
301                ((Entity)var8).entityId = par1Packet23VehicleSpawn.entityId;
302                this.worldClient.addEntityToWorld(par1Packet23VehicleSpawn.entityId, (Entity)var8);
303    
304                if (par1Packet23VehicleSpawn.throwerEntityId > 0)
305                {
306                    if (par1Packet23VehicleSpawn.type == 60)
307                    {
308                        Entity var17 = this.getEntityByID(par1Packet23VehicleSpawn.throwerEntityId);
309    
310                        if (var17 instanceof EntityLiving)
311                        {
312                            EntityArrow var16 = (EntityArrow)var8;
313                            var16.shootingEntity = var17;
314                        }
315                    }
316    
317                    ((Entity)var8).setVelocity((double)par1Packet23VehicleSpawn.speedX / 8000.0D, (double)par1Packet23VehicleSpawn.speedY / 8000.0D, (double)par1Packet23VehicleSpawn.speedZ / 8000.0D);
318                }
319            }
320        }
321    
322        /**
323         * Handle a entity experience orb packet.
324         */
325        public void handleEntityExpOrb(Packet26EntityExpOrb par1Packet26EntityExpOrb)
326        {
327            EntityXPOrb var2 = new EntityXPOrb(this.worldClient, (double)par1Packet26EntityExpOrb.posX, (double)par1Packet26EntityExpOrb.posY, (double)par1Packet26EntityExpOrb.posZ, par1Packet26EntityExpOrb.xpValue);
328            var2.serverPosX = par1Packet26EntityExpOrb.posX;
329            var2.serverPosY = par1Packet26EntityExpOrb.posY;
330            var2.serverPosZ = par1Packet26EntityExpOrb.posZ;
331            var2.rotationYaw = 0.0F;
332            var2.rotationPitch = 0.0F;
333            var2.entityId = par1Packet26EntityExpOrb.entityId;
334            this.worldClient.addEntityToWorld(par1Packet26EntityExpOrb.entityId, var2);
335        }
336    
337        /**
338         * Handles weather packet
339         */
340        public void handleWeather(Packet71Weather par1Packet71Weather)
341        {
342            double var2 = (double)par1Packet71Weather.posX / 32.0D;
343            double var4 = (double)par1Packet71Weather.posY / 32.0D;
344            double var6 = (double)par1Packet71Weather.posZ / 32.0D;
345            EntityLightningBolt var8 = null;
346    
347            if (par1Packet71Weather.isLightningBolt == 1)
348            {
349                var8 = new EntityLightningBolt(this.worldClient, var2, var4, var6);
350            }
351    
352            if (var8 != null)
353            {
354                var8.serverPosX = par1Packet71Weather.posX;
355                var8.serverPosY = par1Packet71Weather.posY;
356                var8.serverPosZ = par1Packet71Weather.posZ;
357                var8.rotationYaw = 0.0F;
358                var8.rotationPitch = 0.0F;
359                var8.entityId = par1Packet71Weather.entityID;
360                this.worldClient.addWeatherEffect(var8);
361            }
362        }
363    
364        /**
365         * Packet handler
366         */
367        public void handleEntityPainting(Packet25EntityPainting par1Packet25EntityPainting)
368        {
369            EntityPainting var2 = new EntityPainting(this.worldClient, par1Packet25EntityPainting.xPosition, par1Packet25EntityPainting.yPosition, par1Packet25EntityPainting.zPosition, par1Packet25EntityPainting.direction, par1Packet25EntityPainting.title);
370            this.worldClient.addEntityToWorld(par1Packet25EntityPainting.entityId, var2);
371        }
372    
373        /**
374         * Packet handler
375         */
376        public void handleEntityVelocity(Packet28EntityVelocity par1Packet28EntityVelocity)
377        {
378            Entity var2 = this.getEntityByID(par1Packet28EntityVelocity.entityId);
379    
380            if (var2 != null)
381            {
382                var2.setVelocity((double)par1Packet28EntityVelocity.motionX / 8000.0D, (double)par1Packet28EntityVelocity.motionY / 8000.0D, (double)par1Packet28EntityVelocity.motionZ / 8000.0D);
383            }
384        }
385    
386        /**
387         * Packet handler
388         */
389        public void handleEntityMetadata(Packet40EntityMetadata par1Packet40EntityMetadata)
390        {
391            Entity var2 = this.getEntityByID(par1Packet40EntityMetadata.entityId);
392    
393            if (var2 != null && par1Packet40EntityMetadata.getMetadata() != null)
394            {
395                var2.getDataWatcher().updateWatchedObjectsFromList(par1Packet40EntityMetadata.getMetadata());
396            }
397        }
398    
399        public void handleNamedEntitySpawn(Packet20NamedEntitySpawn par1Packet20NamedEntitySpawn)
400        {
401            double var2 = (double)par1Packet20NamedEntitySpawn.xPosition / 32.0D;
402            double var4 = (double)par1Packet20NamedEntitySpawn.yPosition / 32.0D;
403            double var6 = (double)par1Packet20NamedEntitySpawn.zPosition / 32.0D;
404            float var8 = (float)(par1Packet20NamedEntitySpawn.rotation * 360) / 256.0F;
405            float var9 = (float)(par1Packet20NamedEntitySpawn.pitch * 360) / 256.0F;
406            EntityOtherPlayerMP var10 = new EntityOtherPlayerMP(this.mc.theWorld, par1Packet20NamedEntitySpawn.name);
407            var10.prevPosX = var10.lastTickPosX = (double)(var10.serverPosX = par1Packet20NamedEntitySpawn.xPosition);
408            var10.prevPosY = var10.lastTickPosY = (double)(var10.serverPosY = par1Packet20NamedEntitySpawn.yPosition);
409            var10.prevPosZ = var10.lastTickPosZ = (double)(var10.serverPosZ = par1Packet20NamedEntitySpawn.zPosition);
410            int var11 = par1Packet20NamedEntitySpawn.currentItem;
411    
412            if (var11 == 0)
413            {
414                var10.inventory.mainInventory[var10.inventory.currentItem] = null;
415            }
416            else
417            {
418                var10.inventory.mainInventory[var10.inventory.currentItem] = new ItemStack(var11, 1, 0);
419            }
420    
421            var10.setPositionAndRotation(var2, var4, var6, var8, var9);
422            this.worldClient.addEntityToWorld(par1Packet20NamedEntitySpawn.entityId, var10);
423            List var12 = par1Packet20NamedEntitySpawn.func_73509_c();
424    
425            if (var12 != null)
426            {
427                var10.getDataWatcher().updateWatchedObjectsFromList(var12);
428            }
429        }
430    
431        public void handleEntityTeleport(Packet34EntityTeleport par1Packet34EntityTeleport)
432        {
433            Entity var2 = this.getEntityByID(par1Packet34EntityTeleport.entityId);
434    
435            if (var2 != null)
436            {
437                var2.serverPosX = par1Packet34EntityTeleport.xPosition;
438                var2.serverPosY = par1Packet34EntityTeleport.yPosition;
439                var2.serverPosZ = par1Packet34EntityTeleport.zPosition;
440                double var3 = (double)var2.serverPosX / 32.0D;
441                double var5 = (double)var2.serverPosY / 32.0D + 0.015625D;
442                double var7 = (double)var2.serverPosZ / 32.0D;
443                float var9 = (float)(par1Packet34EntityTeleport.yaw * 360) / 256.0F;
444                float var10 = (float)(par1Packet34EntityTeleport.pitch * 360) / 256.0F;
445                var2.setPositionAndRotation2(var3, var5, var7, var9, var10, 3);
446            }
447        }
448    
449        public void handleEntity(Packet30Entity par1Packet30Entity)
450        {
451            Entity var2 = this.getEntityByID(par1Packet30Entity.entityId);
452    
453            if (var2 != null)
454            {
455                var2.serverPosX += par1Packet30Entity.xPosition;
456                var2.serverPosY += par1Packet30Entity.yPosition;
457                var2.serverPosZ += par1Packet30Entity.zPosition;
458                double var3 = (double)var2.serverPosX / 32.0D;
459                double var5 = (double)var2.serverPosY / 32.0D;
460                double var7 = (double)var2.serverPosZ / 32.0D;
461                float var9 = par1Packet30Entity.rotating ? (float)(par1Packet30Entity.yaw * 360) / 256.0F : var2.rotationYaw;
462                float var10 = par1Packet30Entity.rotating ? (float)(par1Packet30Entity.pitch * 360) / 256.0F : var2.rotationPitch;
463                var2.setPositionAndRotation2(var3, var5, var7, var9, var10, 3);
464            }
465        }
466    
467        public void handleEntityHeadRotation(Packet35EntityHeadRotation par1Packet35EntityHeadRotation)
468        {
469            Entity var2 = this.getEntityByID(par1Packet35EntityHeadRotation.entityId);
470    
471            if (var2 != null)
472            {
473                float var3 = (float)(par1Packet35EntityHeadRotation.headRotationYaw * 360) / 256.0F;
474                var2.setHeadRotationYaw(var3);
475            }
476        }
477    
478        public void handleDestroyEntity(Packet29DestroyEntity par1Packet29DestroyEntity)
479        {
480            for (int var2 = 0; var2 < par1Packet29DestroyEntity.entityId.length; ++var2)
481            {
482                this.worldClient.removeEntityFromWorld(par1Packet29DestroyEntity.entityId[var2]);
483            }
484        }
485    
486        public void handleFlying(Packet10Flying par1Packet10Flying)
487        {
488            EntityClientPlayerMP var2 = this.mc.thePlayer;
489            double var3 = var2.posX;
490            double var5 = var2.posY;
491            double var7 = var2.posZ;
492            float var9 = var2.rotationYaw;
493            float var10 = var2.rotationPitch;
494    
495            if (par1Packet10Flying.moving)
496            {
497                var3 = par1Packet10Flying.xPosition;
498                var5 = par1Packet10Flying.yPosition;
499                var7 = par1Packet10Flying.zPosition;
500            }
501    
502            if (par1Packet10Flying.rotating)
503            {
504                var9 = par1Packet10Flying.yaw;
505                var10 = par1Packet10Flying.pitch;
506            }
507    
508            var2.ySize = 0.0F;
509            var2.motionX = var2.motionY = var2.motionZ = 0.0D;
510            var2.setPositionAndRotation(var3, var5, var7, var9, var10);
511            par1Packet10Flying.xPosition = var2.posX;
512            par1Packet10Flying.yPosition = var2.boundingBox.minY;
513            par1Packet10Flying.zPosition = var2.posZ;
514            par1Packet10Flying.stance = var2.posY;
515            this.netManager.addToSendQueue(par1Packet10Flying);
516    
517            if (!this.doneLoadingTerrain)
518            {
519                this.mc.thePlayer.prevPosX = this.mc.thePlayer.posX;
520                this.mc.thePlayer.prevPosY = this.mc.thePlayer.posY;
521                this.mc.thePlayer.prevPosZ = this.mc.thePlayer.posZ;
522                this.doneLoadingTerrain = true;
523                this.mc.displayGuiScreen((GuiScreen)null);
524            }
525        }
526    
527        public void handleMultiBlockChange(Packet52MultiBlockChange par1Packet52MultiBlockChange)
528        {
529            int var2 = par1Packet52MultiBlockChange.xPosition * 16;
530            int var3 = par1Packet52MultiBlockChange.zPosition * 16;
531    
532            if (par1Packet52MultiBlockChange.metadataArray != null)
533            {
534                DataInputStream var4 = new DataInputStream(new ByteArrayInputStream(par1Packet52MultiBlockChange.metadataArray));
535    
536                try
537                {
538                    for (int var5 = 0; var5 < par1Packet52MultiBlockChange.size; ++var5)
539                    {
540                        short var6 = var4.readShort();
541                        short var7 = var4.readShort();
542                        int var8 = var7 >> 4 & 4095;
543                        int var9 = var7 & 15;
544                        int var10 = var6 >> 12 & 15;
545                        int var11 = var6 >> 8 & 15;
546                        int var12 = var6 & 255;
547                        this.worldClient.setBlockAndMetadataAndInvalidate(var10 + var2, var12, var11 + var3, var8, var9);
548                    }
549                }
550                catch (IOException var13)
551                {
552                    ;
553                }
554            }
555        }
556    
557        /**
558         * Handle Packet51MapChunk (full chunk update of blocks, metadata, light levels, and optionally biome data)
559         */
560        public void handleMapChunk(Packet51MapChunk par1Packet51MapChunk)
561        {
562            if (par1Packet51MapChunk.includeInitialize)
563            {
564                if (par1Packet51MapChunk.yChMin == 0)
565                {
566                    this.worldClient.doPreChunk(par1Packet51MapChunk.xCh, par1Packet51MapChunk.zCh, false);
567                    return;
568                }
569    
570                this.worldClient.doPreChunk(par1Packet51MapChunk.xCh, par1Packet51MapChunk.zCh, true);
571            }
572    
573            this.worldClient.invalidateBlockReceiveRegion(par1Packet51MapChunk.xCh << 4, 0, par1Packet51MapChunk.zCh << 4, (par1Packet51MapChunk.xCh << 4) + 15, 256, (par1Packet51MapChunk.zCh << 4) + 15);
574            Chunk var2 = this.worldClient.getChunkFromChunkCoords(par1Packet51MapChunk.xCh, par1Packet51MapChunk.zCh);
575    
576            if (par1Packet51MapChunk.includeInitialize && var2 == null)
577            {
578                this.worldClient.doPreChunk(par1Packet51MapChunk.xCh, par1Packet51MapChunk.zCh, true);
579                var2 = this.worldClient.getChunkFromChunkCoords(par1Packet51MapChunk.xCh, par1Packet51MapChunk.zCh);
580            }
581    
582            if (var2 != null)
583            {
584                var2.fillChunk(par1Packet51MapChunk.func_73593_d(), par1Packet51MapChunk.yChMin, par1Packet51MapChunk.yChMax, par1Packet51MapChunk.includeInitialize);
585                this.worldClient.markBlocksDirty(par1Packet51MapChunk.xCh << 4, 0, par1Packet51MapChunk.zCh << 4, (par1Packet51MapChunk.xCh << 4) + 15, 256, (par1Packet51MapChunk.zCh << 4) + 15);
586    
587                if (!par1Packet51MapChunk.includeInitialize || !(this.worldClient.provider instanceof WorldProviderSurface))
588                {
589                    var2.resetRelightChecks();
590                }
591            }
592        }
593    
594        public void handleBlockChange(Packet53BlockChange par1Packet53BlockChange)
595        {
596            this.worldClient.setBlockAndMetadataAndInvalidate(par1Packet53BlockChange.xPosition, par1Packet53BlockChange.yPosition, par1Packet53BlockChange.zPosition, par1Packet53BlockChange.type, par1Packet53BlockChange.metadata);
597        }
598    
599        public void handleKickDisconnect(Packet255KickDisconnect par1Packet255KickDisconnect)
600        {
601            this.netManager.networkShutdown("disconnect.kicked", par1Packet255KickDisconnect.reason);
602            this.field_72554_f = true;
603            this.mc.loadWorld((WorldClient)null);
604            this.mc.displayGuiScreen(new GuiDisconnected("disconnect.disconnected", "disconnect.genericReason", new Object[] {par1Packet255KickDisconnect.reason}));
605        }
606    
607        public void handleErrorMessage(String par1Str, Object[] par2ArrayOfObj)
608        {
609            if (!this.field_72554_f)
610            {
611                this.field_72554_f = true;
612                this.mc.loadWorld((WorldClient)null);
613                this.mc.displayGuiScreen(new GuiDisconnected("disconnect.lost", par1Str, par2ArrayOfObj));
614            }
615        }
616    
617        public void quitWithPacket(Packet par1Packet)
618        {
619            if (!this.field_72554_f)
620            {
621                this.netManager.addToSendQueue(par1Packet);
622                this.netManager.serverShutdown();
623                FMLNetworkHandler.onConnectionClosed(this.netManager);
624            }
625        }
626    
627        /**
628         * Adds the packet to the send queue
629         */
630        public void addToSendQueue(Packet par1Packet)
631        {
632            if (!this.field_72554_f)
633            {
634                this.netManager.addToSendQueue(par1Packet);
635            }
636        }
637    
638        public void handleCollect(Packet22Collect par1Packet22Collect)
639        {
640            Entity var2 = this.getEntityByID(par1Packet22Collect.collectedEntityId);
641            Object var3 = (EntityLiving)this.getEntityByID(par1Packet22Collect.collectorEntityId);
642    
643            if (var3 == null)
644            {
645                var3 = this.mc.thePlayer;
646            }
647    
648            if (var2 != null)
649            {
650                if (var2 instanceof EntityXPOrb)
651                {
652                    this.worldClient.playSoundAtEntity(var2, "random.orb", 0.2F, ((this.rand.nextFloat() - this.rand.nextFloat()) * 0.7F + 1.0F) * 2.0F);
653                }
654                else
655                {
656                    this.worldClient.playSoundAtEntity(var2, "random.pop", 0.2F, ((this.rand.nextFloat() - this.rand.nextFloat()) * 0.7F + 1.0F) * 2.0F);
657                }
658    
659                this.mc.effectRenderer.addEffect(new EntityPickupFX(this.mc.theWorld, var2, (Entity)var3, -0.5F));
660                this.worldClient.removeEntityFromWorld(par1Packet22Collect.collectedEntityId);
661            }
662        }
663    
664        public void handleChat(Packet3Chat par1Packet3Chat)
665        {
666            par1Packet3Chat = FMLNetworkHandler.handleChatMessage(this, par1Packet3Chat);
667            ClientChatReceivedEvent event = new ClientChatReceivedEvent(par1Packet3Chat.message);
668            if (!MinecraftForge.EVENT_BUS.post(event) && event.message != null)
669            {
670                this.mc.ingameGUI.getChatGUI().printChatMessage(par1Packet3Chat.message);
671            }
672        }
673    
674        public void handleAnimation(Packet18Animation par1Packet18Animation)
675        {
676            Entity var2 = this.getEntityByID(par1Packet18Animation.entityId);
677    
678            if (var2 != null)
679            {
680                EntityPlayer var3;
681    
682                if (par1Packet18Animation.animate == 1)
683                {
684                    var3 = (EntityPlayer)var2;
685                    var3.swingItem();
686                }
687                else if (par1Packet18Animation.animate == 2)
688                {
689                    var2.performHurtAnimation();
690                }
691                else if (par1Packet18Animation.animate == 3)
692                {
693                    var3 = (EntityPlayer)var2;
694                    var3.wakeUpPlayer(false, false, false);
695                }
696                else if (par1Packet18Animation.animate != 4)
697                {
698                    if (par1Packet18Animation.animate == 6)
699                    {
700                        this.mc.effectRenderer.addEffect(new EntityCrit2FX(this.mc.theWorld, var2));
701                    }
702                    else if (par1Packet18Animation.animate == 7)
703                    {
704                        EntityCrit2FX var4 = new EntityCrit2FX(this.mc.theWorld, var2, "magicCrit");
705                        this.mc.effectRenderer.addEffect(var4);
706                    }
707                    else if (par1Packet18Animation.animate == 5 && var2 instanceof EntityOtherPlayerMP)
708                    {
709                        ;
710                    }
711                }
712            }
713        }
714    
715        public void handleSleep(Packet17Sleep par1Packet17Sleep)
716        {
717            Entity var2 = this.getEntityByID(par1Packet17Sleep.entityID);
718    
719            if (var2 != null)
720            {
721                if (par1Packet17Sleep.field_73622_e == 0)
722                {
723                    EntityPlayer var3 = (EntityPlayer)var2;
724                    var3.sleepInBedAt(par1Packet17Sleep.bedX, par1Packet17Sleep.bedY, par1Packet17Sleep.bedZ);
725                }
726            }
727        }
728    
729        /**
730         * Disconnects the network connection.
731         */
732        public void disconnect()
733        {
734            this.field_72554_f = true;
735            this.netManager.wakeThreads();
736            this.netManager.networkShutdown("disconnect.closed", new Object[0]);
737        }
738    
739        public void handleMobSpawn(Packet24MobSpawn par1Packet24MobSpawn)
740        {
741            double var2 = (double)par1Packet24MobSpawn.xPosition / 32.0D;
742            double var4 = (double)par1Packet24MobSpawn.yPosition / 32.0D;
743            double var6 = (double)par1Packet24MobSpawn.zPosition / 32.0D;
744            float var8 = (float)(par1Packet24MobSpawn.yaw * 360) / 256.0F;
745            float var9 = (float)(par1Packet24MobSpawn.pitch * 360) / 256.0F;
746            EntityLiving var10 = (EntityLiving)EntityList.createEntityByID(par1Packet24MobSpawn.type, this.mc.theWorld);
747            var10.serverPosX = par1Packet24MobSpawn.xPosition;
748            var10.serverPosY = par1Packet24MobSpawn.yPosition;
749            var10.serverPosZ = par1Packet24MobSpawn.zPosition;
750            var10.rotationYawHead = (float)(par1Packet24MobSpawn.headYaw * 360) / 256.0F;
751            Entity[] var11 = var10.getParts();
752    
753            if (var11 != null)
754            {
755                int var12 = par1Packet24MobSpawn.entityId - var10.entityId;
756                Entity[] var13 = var11;
757                int var14 = var11.length;
758    
759                for (int var15 = 0; var15 < var14; ++var15)
760                {
761                    Entity var16 = var13[var15];
762                    var16.entityId += var12;
763                }
764            }
765    
766            var10.entityId = par1Packet24MobSpawn.entityId;
767            var10.setPositionAndRotation(var2, var4, var6, var8, var9);
768            var10.motionX = (double)((float)par1Packet24MobSpawn.velocityX / 8000.0F);
769            var10.motionY = (double)((float)par1Packet24MobSpawn.velocityY / 8000.0F);
770            var10.motionZ = (double)((float)par1Packet24MobSpawn.velocityZ / 8000.0F);
771            this.worldClient.addEntityToWorld(par1Packet24MobSpawn.entityId, var10);
772            List var17 = par1Packet24MobSpawn.getMetadata();
773    
774            if (var17 != null)
775            {
776                var10.getDataWatcher().updateWatchedObjectsFromList(var17);
777            }
778        }
779    
780        public void handleUpdateTime(Packet4UpdateTime par1Packet4UpdateTime)
781        {
782            this.mc.theWorld.setWorldTime(par1Packet4UpdateTime.time);
783        }
784    
785        public void handleSpawnPosition(Packet6SpawnPosition par1Packet6SpawnPosition)
786        {
787            this.mc.thePlayer.setSpawnChunk(new ChunkCoordinates(par1Packet6SpawnPosition.xPosition, par1Packet6SpawnPosition.yPosition, par1Packet6SpawnPosition.zPosition));
788            this.mc.theWorld.getWorldInfo().setSpawnPosition(par1Packet6SpawnPosition.xPosition, par1Packet6SpawnPosition.yPosition, par1Packet6SpawnPosition.zPosition);
789        }
790    
791        /**
792         * Packet handler
793         */
794        public void handleAttachEntity(Packet39AttachEntity par1Packet39AttachEntity)
795        {
796            Object var2 = this.getEntityByID(par1Packet39AttachEntity.entityId);
797            Entity var3 = this.getEntityByID(par1Packet39AttachEntity.vehicleEntityId);
798    
799            if (par1Packet39AttachEntity.entityId == this.mc.thePlayer.entityId)
800            {
801                var2 = this.mc.thePlayer;
802    
803                if (var3 instanceof EntityBoat)
804                {
805                    ((EntityBoat)var3).func_70270_d(false);
806                }
807            }
808            else if (var3 instanceof EntityBoat)
809            {
810                ((EntityBoat)var3).func_70270_d(true);
811            }
812    
813            if (var2 != null)
814            {
815                ((Entity)var2).mountEntity(var3);
816            }
817        }
818    
819        /**
820         * Packet handler
821         */
822        public void handleEntityStatus(Packet38EntityStatus par1Packet38EntityStatus)
823        {
824            Entity var2 = this.getEntityByID(par1Packet38EntityStatus.entityId);
825    
826            if (var2 != null)
827            {
828                var2.handleHealthUpdate(par1Packet38EntityStatus.entityStatus);
829            }
830        }
831    
832        private Entity getEntityByID(int par1)
833        {
834            return (Entity)(par1 == this.mc.thePlayer.entityId ? this.mc.thePlayer : this.worldClient.getEntityByID(par1));
835        }
836    
837        /**
838         * Recieves player health from the server and then proceeds to set it locally on the client.
839         */
840        public void handleUpdateHealth(Packet8UpdateHealth par1Packet8UpdateHealth)
841        {
842            this.mc.thePlayer.setHealth(par1Packet8UpdateHealth.healthMP);
843            this.mc.thePlayer.getFoodStats().setFoodLevel(par1Packet8UpdateHealth.food);
844            this.mc.thePlayer.getFoodStats().setFoodSaturationLevel(par1Packet8UpdateHealth.foodSaturation);
845        }
846    
847        /**
848         * Handle an experience packet.
849         */
850        public void handleExperience(Packet43Experience par1Packet43Experience)
851        {
852            this.mc.thePlayer.setXPStats(par1Packet43Experience.experience, par1Packet43Experience.experienceTotal, par1Packet43Experience.experienceLevel);
853        }
854    
855        /**
856         * respawns the player
857         */
858        public void handleRespawn(Packet9Respawn par1Packet9Respawn)
859        {
860            if (par1Packet9Respawn.respawnDimension != this.mc.thePlayer.dimension)
861            {
862                this.doneLoadingTerrain = false;
863                this.worldClient = new WorldClient(this, new WorldSettings(0L, par1Packet9Respawn.gameType, false, this.mc.theWorld.getWorldInfo().isHardcoreModeEnabled(), par1Packet9Respawn.terrainType), par1Packet9Respawn.respawnDimension, par1Packet9Respawn.difficulty, this.mc.mcProfiler);
864                this.worldClient.isRemote = true;
865                this.mc.loadWorld(this.worldClient);
866                this.mc.thePlayer.dimension = par1Packet9Respawn.respawnDimension;
867                this.mc.displayGuiScreen(new GuiDownloadTerrain(this));
868            }
869    
870            this.mc.setDimensionAndSpawnPlayer(par1Packet9Respawn.respawnDimension);
871            this.mc.playerController.setGameType(par1Packet9Respawn.gameType);
872        }
873    
874        public void handleExplosion(Packet60Explosion par1Packet60Explosion)
875        {
876            Explosion var2 = new Explosion(this.mc.theWorld, (Entity)null, par1Packet60Explosion.explosionX, par1Packet60Explosion.explosionY, par1Packet60Explosion.explosionZ, par1Packet60Explosion.explosionSize);
877            var2.field_77281_g = par1Packet60Explosion.field_73613_e;
878            var2.doExplosionB(true);
879            this.mc.thePlayer.motionX += (double)par1Packet60Explosion.func_73607_d();
880            this.mc.thePlayer.motionY += (double)par1Packet60Explosion.func_73609_f();
881            this.mc.thePlayer.motionZ += (double)par1Packet60Explosion.func_73608_g();
882        }
883    
884        public void handleOpenWindow(Packet100OpenWindow par1Packet100OpenWindow)
885        {
886            EntityClientPlayerMP var2 = this.mc.thePlayer;
887    
888            switch (par1Packet100OpenWindow.inventoryType)
889            {
890                case 0:
891                    var2.displayGUIChest(new InventoryBasic(par1Packet100OpenWindow.windowTitle, par1Packet100OpenWindow.slotsCount));
892                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
893                    break;
894                case 1:
895                    var2.displayGUIWorkbench(MathHelper.floor_double(var2.posX), MathHelper.floor_double(var2.posY), MathHelper.floor_double(var2.posZ));
896                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
897                    break;
898                case 2:
899                    var2.displayGUIFurnace(new TileEntityFurnace());
900                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
901                    break;
902                case 3:
903                    var2.displayGUIDispenser(new TileEntityDispenser());
904                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
905                    break;
906                case 4:
907                    var2.displayGUIEnchantment(MathHelper.floor_double(var2.posX), MathHelper.floor_double(var2.posY), MathHelper.floor_double(var2.posZ));
908                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
909                    break;
910                case 5:
911                    var2.displayGUIBrewingStand(new TileEntityBrewingStand());
912                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
913                    break;
914                case 6:
915                    var2.displayGUIMerchant(new NpcMerchant(var2));
916                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
917            }
918        }
919    
920        public void handleSetSlot(Packet103SetSlot par1Packet103SetSlot)
921        {
922            EntityClientPlayerMP var2 = this.mc.thePlayer;
923    
924            if (par1Packet103SetSlot.windowId == -1)
925            {
926                var2.inventory.setItemStack(par1Packet103SetSlot.myItemStack);
927            }
928            else
929            {
930                boolean var3 = false;
931    
932                if (this.mc.currentScreen instanceof GuiContainerCreative)
933                {
934                    GuiContainerCreative var4 = (GuiContainerCreative)this.mc.currentScreen;
935                    var3 = var4.func_74230_h() != CreativeTabs.tabInventory.getTabIndex();
936                }
937    
938                if (par1Packet103SetSlot.windowId == 0 && par1Packet103SetSlot.itemSlot >= 36 && par1Packet103SetSlot.itemSlot < 45)
939                {
940                    ItemStack var5 = var2.inventorySlots.getSlot(par1Packet103SetSlot.itemSlot).getStack();
941    
942                    if (par1Packet103SetSlot.myItemStack != null && (var5 == null || var5.stackSize < par1Packet103SetSlot.myItemStack.stackSize))
943                    {
944                        par1Packet103SetSlot.myItemStack.animationsToGo = 5;
945                    }
946    
947                    var2.inventorySlots.putStackInSlot(par1Packet103SetSlot.itemSlot, par1Packet103SetSlot.myItemStack);
948                }
949                else if (par1Packet103SetSlot.windowId == var2.craftingInventory.windowId && (par1Packet103SetSlot.windowId != 0 || !var3))
950                {
951                    var2.craftingInventory.putStackInSlot(par1Packet103SetSlot.itemSlot, par1Packet103SetSlot.myItemStack);
952                }
953            }
954        }
955    
956        public void handleTransaction(Packet106Transaction par1Packet106Transaction)
957        {
958            Container var2 = null;
959            EntityClientPlayerMP var3 = this.mc.thePlayer;
960    
961            if (par1Packet106Transaction.windowId == 0)
962            {
963                var2 = var3.inventorySlots;
964            }
965            else if (par1Packet106Transaction.windowId == var3.craftingInventory.windowId)
966            {
967                var2 = var3.craftingInventory;
968            }
969    
970            if (var2 != null && !par1Packet106Transaction.accepted)
971            {
972                this.addToSendQueue(new Packet106Transaction(par1Packet106Transaction.windowId, par1Packet106Transaction.shortWindowId, true));
973            }
974        }
975    
976        public void handleWindowItems(Packet104WindowItems par1Packet104WindowItems)
977        {
978            EntityClientPlayerMP var2 = this.mc.thePlayer;
979    
980            if (par1Packet104WindowItems.windowId == 0)
981            {
982                var2.inventorySlots.putStacksInSlots(par1Packet104WindowItems.itemStack);
983            }
984            else if (par1Packet104WindowItems.windowId == var2.craftingInventory.windowId)
985            {
986                var2.craftingInventory.putStacksInSlots(par1Packet104WindowItems.itemStack);
987            }
988        }
989    
990        /**
991         * Updates Client side signs
992         */
993        public void handleUpdateSign(Packet130UpdateSign par1Packet130UpdateSign)
994        {
995            if (this.mc.theWorld.blockExists(par1Packet130UpdateSign.xPosition, par1Packet130UpdateSign.yPosition, par1Packet130UpdateSign.zPosition))
996            {
997                TileEntity var2 = this.mc.theWorld.getBlockTileEntity(par1Packet130UpdateSign.xPosition, par1Packet130UpdateSign.yPosition, par1Packet130UpdateSign.zPosition);
998    
999                if (var2 instanceof TileEntitySign)
1000                {
1001                    TileEntitySign var3 = (TileEntitySign)var2;
1002    
1003                    if (var3.isEditable())
1004                    {
1005                        for (int var4 = 0; var4 < 4; ++var4)
1006                        {
1007                            var3.signText[var4] = par1Packet130UpdateSign.signLines[var4];
1008                        }
1009    
1010                        var3.onInventoryChanged();
1011                    }
1012                }
1013            }
1014        }
1015    
1016        public void handleTileEntityData(Packet132TileEntityData par1Packet132TileEntityData)
1017        {
1018            if (this.mc.theWorld.blockExists(par1Packet132TileEntityData.xPosition, par1Packet132TileEntityData.yPosition, par1Packet132TileEntityData.zPosition))
1019            {
1020                TileEntity var2 = this.mc.theWorld.getBlockTileEntity(par1Packet132TileEntityData.xPosition, par1Packet132TileEntityData.yPosition, par1Packet132TileEntityData.zPosition);
1021    
1022                if (var2 != null && par1Packet132TileEntityData.actionType == 1 && var2 instanceof TileEntityMobSpawner)
1023                {
1024                    ((TileEntityMobSpawner)var2).readFromNBT(par1Packet132TileEntityData.customParam1);
1025                }
1026                else if (var2 != null)
1027                {
1028                    var2.onDataPacket(netManager,  par1Packet132TileEntityData);
1029                }
1030                else
1031                {
1032                    /*Packet132TileEntityData pkt = par1Packet132TileEntityData;
1033                    ModLoader.getLogger().log(Level.WARNING, String.format(
1034                            "Received a TileEntityData packet for a location that did not have a TileEntity: (%d, %d, %d) %d: %d, %d, %d",
1035                            pkt.xPosition, pkt.yPosition, pkt.zPosition,
1036                            pkt.actionType,
1037                            pkt.customParam1, pkt.customParam2, pkt.customParam3));*/
1038                }
1039            }
1040        }
1041    
1042        public void handleUpdateProgressbar(Packet105UpdateProgressbar par1Packet105UpdateProgressbar)
1043        {
1044            EntityClientPlayerMP var2 = this.mc.thePlayer;
1045            this.registerPacket(par1Packet105UpdateProgressbar);
1046    
1047            if (var2.craftingInventory != null && var2.craftingInventory.windowId == par1Packet105UpdateProgressbar.windowId)
1048            {
1049                var2.craftingInventory.updateProgressBar(par1Packet105UpdateProgressbar.progressBar, par1Packet105UpdateProgressbar.progressBarValue);
1050            }
1051        }
1052    
1053        public void handlePlayerInventory(Packet5PlayerInventory par1Packet5PlayerInventory)
1054        {
1055            Entity var2 = this.getEntityByID(par1Packet5PlayerInventory.entityID);
1056    
1057            if (var2 != null)
1058            {
1059                var2.func_70062_b(par1Packet5PlayerInventory.slot, par1Packet5PlayerInventory.func_73397_d());
1060            }
1061        }
1062    
1063        public void handleCloseWindow(Packet101CloseWindow par1Packet101CloseWindow)
1064        {
1065            this.mc.thePlayer.closeScreen();
1066        }
1067    
1068        public void handleBlockEvent(Packet54PlayNoteBlock par1Packet54PlayNoteBlock)
1069        {
1070            this.mc.theWorld.addBlockEvent(par1Packet54PlayNoteBlock.xLocation, par1Packet54PlayNoteBlock.yLocation, par1Packet54PlayNoteBlock.zLocation, par1Packet54PlayNoteBlock.blockId, par1Packet54PlayNoteBlock.instrumentType, par1Packet54PlayNoteBlock.pitch);
1071        }
1072    
1073        public void handleBlockDestroy(Packet55BlockDestroy par1Packet55BlockDestroy)
1074        {
1075            this.mc.theWorld.destroyBlockInWorldPartially(par1Packet55BlockDestroy.func_73322_d(), par1Packet55BlockDestroy.func_73321_f(), par1Packet55BlockDestroy.func_73324_g(), par1Packet55BlockDestroy.func_73320_h(), par1Packet55BlockDestroy.func_73323_i());
1076        }
1077    
1078        public void handleMapChunks(Packet56MapChunks par1Packet56MapChunks)
1079        {
1080            for (int var2 = 0; var2 < par1Packet56MapChunks.func_73581_d(); ++var2)
1081            {
1082                int var3 = par1Packet56MapChunks.func_73582_a(var2);
1083                int var4 = par1Packet56MapChunks.func_73580_b(var2);
1084                this.worldClient.doPreChunk(var3, var4, true);
1085                this.worldClient.invalidateBlockReceiveRegion(var3 << 4, 0, var4 << 4, (var3 << 4) + 15, 256, (var4 << 4) + 15);
1086                Chunk var5 = this.worldClient.getChunkFromChunkCoords(var3, var4);
1087    
1088                if (var5 == null)
1089                {
1090                    this.worldClient.doPreChunk(var3, var4, true);
1091                    var5 = this.worldClient.getChunkFromChunkCoords(var3, var4);
1092                }
1093    
1094                if (var5 != null)
1095                {
1096                    var5.fillChunk(par1Packet56MapChunks.func_73583_c(var2), par1Packet56MapChunks.field_73590_a[var2], par1Packet56MapChunks.field_73588_b[var2], true);
1097                    this.worldClient.markBlocksDirty(var3 << 4, 0, var4 << 4, (var3 << 4) + 15, 256, (var4 << 4) + 15);
1098    
1099                    if (!(this.worldClient.provider instanceof WorldProviderSurface))
1100                    {
1101                        var5.resetRelightChecks();
1102                    }
1103                }
1104            }
1105        }
1106    
1107        /**
1108         * packet.processPacket is only called if this returns true
1109         */
1110        public boolean canProcessPackets()
1111        {
1112            return this.mc != null && this.mc.theWorld != null && this.mc.thePlayer != null && this.worldClient != null;
1113        }
1114    
1115        public void handleBed(Packet70GameEvent par1Packet70GameEvent)
1116        {
1117            EntityClientPlayerMP var2 = this.mc.thePlayer;
1118            int var3 = par1Packet70GameEvent.bedState;
1119            int var4 = par1Packet70GameEvent.gameMode;
1120    
1121            if (var3 >= 0 && var3 < Packet70GameEvent.bedChat.length && Packet70GameEvent.bedChat[var3] != null)
1122            {
1123                var2.addChatMessage(Packet70GameEvent.bedChat[var3]);
1124            }
1125    
1126            if (var3 == 1)
1127            {
1128                this.worldClient.getWorldInfo().setRaining(true);
1129                this.worldClient.setRainStrength(0.0F);
1130            }
1131            else if (var3 == 2)
1132            {
1133                this.worldClient.getWorldInfo().setRaining(false);
1134                this.worldClient.setRainStrength(1.0F);
1135            }
1136            else if (var3 == 3)
1137            {
1138                this.mc.playerController.setGameType(EnumGameType.getByID(var4));
1139            }
1140            else if (var3 == 4)
1141            {
1142                this.mc.displayGuiScreen(new GuiWinGame());
1143            }
1144            else if (var3 == 5)
1145            {
1146                GameSettings var5 = this.mc.gameSettings;
1147    
1148                if (var4 == 0)
1149                {
1150                    this.mc.displayGuiScreen(new GuiScreenDemo());
1151                }
1152                else if (var4 == 101)
1153                {
1154                    this.mc.ingameGUI.getChatGUI().func_73757_a("demo.help.movement", new Object[] {Keyboard.getKeyName(var5.keyBindForward.keyCode), Keyboard.getKeyName(var5.keyBindLeft.keyCode), Keyboard.getKeyName(var5.keyBindBack.keyCode), Keyboard.getKeyName(var5.keyBindRight.keyCode)});
1155                }
1156                else if (var4 == 102)
1157                {
1158                    this.mc.ingameGUI.getChatGUI().func_73757_a("demo.help.jump", new Object[] {Keyboard.getKeyName(var5.keyBindJump.keyCode)});
1159                }
1160                else if (var4 == 103)
1161                {
1162                    this.mc.ingameGUI.getChatGUI().func_73757_a("demo.help.inventory", new Object[] {Keyboard.getKeyName(var5.keyBindInventory.keyCode)});
1163                }
1164            }
1165        }
1166    
1167        /**
1168         * Contains logic for handling packets containing arbitrary unique item data. Currently this is only for maps.
1169         */
1170        public void handleMapData(Packet131MapData par1Packet131MapData)
1171        {
1172            FMLNetworkHandler.handlePacket131Packet(this, par1Packet131MapData);
1173        }
1174    
1175        public void fmlPacket131Callback(Packet131MapData par1Packet131MapData)
1176        {
1177            if (par1Packet131MapData.itemID == Item.map.shiftedIndex)
1178            {
1179                ItemMap.getMPMapData(par1Packet131MapData.uniqueID, this.mc.theWorld).updateMPMapData(par1Packet131MapData.itemData);
1180            }
1181            else
1182            {
1183                System.out.println("Unknown itemid: " + par1Packet131MapData.uniqueID);
1184            }
1185        }
1186    
1187        public void handleDoorChange(Packet61DoorChange par1Packet61DoorChange)
1188        {
1189            this.mc.theWorld.playAuxSFX(par1Packet61DoorChange.sfxID, par1Packet61DoorChange.posX, par1Packet61DoorChange.posY, par1Packet61DoorChange.posZ, par1Packet61DoorChange.auxData);
1190        }
1191    
1192        /**
1193         * runs registerPacket on the given Packet200Statistic
1194         */
1195        public void handleStatistic(Packet200Statistic par1Packet200Statistic)
1196        {
1197            this.mc.thePlayer.incrementStat(StatList.getOneShotStat(par1Packet200Statistic.statisticId), par1Packet200Statistic.amount);
1198        }
1199    
1200        /**
1201         * Handle an entity effect packet.
1202         */
1203        public void handleEntityEffect(Packet41EntityEffect par1Packet41EntityEffect)
1204        {
1205            Entity var2 = this.getEntityByID(par1Packet41EntityEffect.entityId);
1206    
1207            if (var2 instanceof EntityLiving)
1208            {
1209                ((EntityLiving)var2).addPotionEffect(new PotionEffect(par1Packet41EntityEffect.effectId, par1Packet41EntityEffect.duration, par1Packet41EntityEffect.effectAmplifier));
1210            }
1211        }
1212    
1213        /**
1214         * Handle a remove entity effect packet.
1215         */
1216        public void handleRemoveEntityEffect(Packet42RemoveEntityEffect par1Packet42RemoveEntityEffect)
1217        {
1218            Entity var2 = this.getEntityByID(par1Packet42RemoveEntityEffect.entityId);
1219    
1220            if (var2 instanceof EntityLiving)
1221            {
1222                ((EntityLiving)var2).removePotionEffect(par1Packet42RemoveEntityEffect.effectId);
1223            }
1224        }
1225    
1226        /**
1227         * determine if it is a server handler
1228         */
1229        public boolean isServerHandler()
1230        {
1231            return false;
1232        }
1233    
1234        /**
1235         * Handle a player information packet.
1236         */
1237        public void handlePlayerInfo(Packet201PlayerInfo par1Packet201PlayerInfo)
1238        {
1239            GuiPlayerInfo var2 = (GuiPlayerInfo)this.playerInfoMap.get(par1Packet201PlayerInfo.playerName);
1240    
1241            if (var2 == null && par1Packet201PlayerInfo.isConnected)
1242            {
1243                var2 = new GuiPlayerInfo(par1Packet201PlayerInfo.playerName);
1244                this.playerInfoMap.put(par1Packet201PlayerInfo.playerName, var2);
1245                this.playerInfoList.add(var2);
1246            }
1247    
1248            if (var2 != null && !par1Packet201PlayerInfo.isConnected)
1249            {
1250                this.playerInfoMap.remove(par1Packet201PlayerInfo.playerName);
1251                this.playerInfoList.remove(var2);
1252            }
1253    
1254            if (par1Packet201PlayerInfo.isConnected && var2 != null)
1255            {
1256                var2.responseTime = par1Packet201PlayerInfo.ping;
1257            }
1258        }
1259    
1260        /**
1261         * Handle a keep alive packet.
1262         */
1263        public void handleKeepAlive(Packet0KeepAlive par1Packet0KeepAlive)
1264        {
1265            this.addToSendQueue(new Packet0KeepAlive(par1Packet0KeepAlive.randomId));
1266        }
1267    
1268        /**
1269         * Handle a player abilities packet.
1270         */
1271        public void handlePlayerAbilities(Packet202PlayerAbilities par1Packet202PlayerAbilities)
1272        {
1273            EntityClientPlayerMP var2 = this.mc.thePlayer;
1274            var2.capabilities.isFlying = par1Packet202PlayerAbilities.getIsFlying();
1275            var2.capabilities.isCreativeMode = par1Packet202PlayerAbilities.isCreativeMode();
1276            var2.capabilities.disableDamage = par1Packet202PlayerAbilities.getDisableDamage();
1277            var2.capabilities.allowFlying = par1Packet202PlayerAbilities.getAllowFlying();
1278            var2.capabilities.setFlySpeed(par1Packet202PlayerAbilities.getFlySpeed());
1279        }
1280    
1281        public void handleAutoComplete(Packet203AutoComplete par1Packet203AutoComplete)
1282        {
1283            String[] var2 = par1Packet203AutoComplete.func_73473_d().split("\u0000");
1284    
1285            if (this.mc.currentScreen instanceof GuiChat)
1286            {
1287                GuiChat var3 = (GuiChat)this.mc.currentScreen;
1288                var3.func_73894_a(var2);
1289            }
1290        }
1291    
1292        public void handleLevelSound(Packet62LevelSound par1Packet62LevelSound)
1293        {
1294            this.mc.theWorld.playSound(par1Packet62LevelSound.func_73572_f(), par1Packet62LevelSound.func_73568_g(), par1Packet62LevelSound.func_73569_h(), par1Packet62LevelSound.func_73570_d(), par1Packet62LevelSound.func_73571_i(), par1Packet62LevelSound.func_73573_j());
1295        }
1296    
1297        public void handleCustomPayload(Packet250CustomPayload par1Packet250CustomPayload)
1298        {
1299            FMLNetworkHandler.handlePacket250Packet(par1Packet250CustomPayload, netManager, this);
1300        }
1301    
1302        public void handleVanilla250Packet(Packet250CustomPayload par1Packet250CustomPayload)
1303        {
1304            if ("MC|TPack".equals(par1Packet250CustomPayload.channel))
1305            {
1306                String[] var2 = (new String(par1Packet250CustomPayload.data)).split("\u0000");
1307                String var3 = var2[0];
1308    
1309                if (var2[1].equals("16"))
1310                {
1311                    if (this.mc.texturePackList.getAcceptsTextures())
1312                    {
1313                        this.mc.texturePackList.requestDownloadOfTexture(var3);
1314                    }
1315                    else if (this.mc.texturePackList.func_77300_f())
1316                    {
1317                        this.mc.displayGuiScreen(new GuiYesNo(new NetClientWebTextures(this, var3), StringTranslate.getInstance().translateKey("multiplayer.texturePrompt.line1"), StringTranslate.getInstance().translateKey("multiplayer.texturePrompt.line2"), 0));
1318                    }
1319                }
1320            }
1321            else if ("MC|TrList".equals(par1Packet250CustomPayload.channel))
1322            {
1323                DataInputStream var8 = new DataInputStream(new ByteArrayInputStream(par1Packet250CustomPayload.data));
1324    
1325                try
1326                {
1327                    int var9 = var8.readInt();
1328                    GuiScreen var4 = this.mc.currentScreen;
1329    
1330                    if (var4 != null && var4 instanceof GuiMerchant && var9 == this.mc.thePlayer.craftingInventory.windowId)
1331                    {
1332                        IMerchant var5 = ((GuiMerchant)var4).func_74199_h();
1333                        MerchantRecipeList var6 = MerchantRecipeList.readRecipiesFromStream(var8);
1334                        var5.setRecipes(var6);
1335                    }
1336                }
1337                catch (IOException var7)
1338                {
1339                    var7.printStackTrace();
1340                }
1341            }
1342        }
1343    
1344        /**
1345         * Return the NetworkManager instance used by this NetClientHandler
1346         */
1347        public NetworkManager getNetManager()
1348        {
1349            return this.netManager;
1350        }
1351    
1352        @Override
1353        public EntityPlayer getPlayer()
1354        {
1355            return mc.thePlayer;
1356        }
1357    
1358        public static void setConnectionCompatibilityLevel(byte connectionCompatibilityLevel)
1359        {
1360            NetClientHandler.connectionCompatibilityLevel = connectionCompatibilityLevel;
1361        }
1362    
1363        public static byte getConnectionCompatibilityLevel()
1364        {
1365            return connectionCompatibilityLevel;
1366        }
1367    }