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