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            ClientChatReceivedEvent event = new ClientChatReceivedEvent(par1Packet3Chat.message);
664            if (!MinecraftForge.EVENT_BUS.post(event) && event.message != null)
665            {
666                this.mc.ingameGUI.getChatGUI().printChatMessage(par1Packet3Chat.message);
667            }
668        }
669    
670        public void handleAnimation(Packet18Animation par1Packet18Animation)
671        {
672            Entity var2 = this.getEntityByID(par1Packet18Animation.entityId);
673    
674            if (var2 != null)
675            {
676                EntityPlayer var3;
677    
678                if (par1Packet18Animation.animate == 1)
679                {
680                    var3 = (EntityPlayer)var2;
681                    var3.swingItem();
682                }
683                else if (par1Packet18Animation.animate == 2)
684                {
685                    var2.performHurtAnimation();
686                }
687                else if (par1Packet18Animation.animate == 3)
688                {
689                    var3 = (EntityPlayer)var2;
690                    var3.wakeUpPlayer(false, false, false);
691                }
692                else if (par1Packet18Animation.animate != 4)
693                {
694                    if (par1Packet18Animation.animate == 6)
695                    {
696                        this.mc.effectRenderer.addEffect(new EntityCrit2FX(this.mc.theWorld, var2));
697                    }
698                    else if (par1Packet18Animation.animate == 7)
699                    {
700                        EntityCrit2FX var4 = new EntityCrit2FX(this.mc.theWorld, var2, "magicCrit");
701                        this.mc.effectRenderer.addEffect(var4);
702                    }
703                    else if (par1Packet18Animation.animate == 5 && var2 instanceof EntityOtherPlayerMP)
704                    {
705                        ;
706                    }
707                }
708            }
709        }
710    
711        public void handleSleep(Packet17Sleep par1Packet17Sleep)
712        {
713            Entity var2 = this.getEntityByID(par1Packet17Sleep.entityID);
714    
715            if (var2 != null)
716            {
717                if (par1Packet17Sleep.field_73622_e == 0)
718                {
719                    EntityPlayer var3 = (EntityPlayer)var2;
720                    var3.sleepInBedAt(par1Packet17Sleep.bedX, par1Packet17Sleep.bedY, par1Packet17Sleep.bedZ);
721                }
722            }
723        }
724    
725        /**
726         * Disconnects the network connection.
727         */
728        public void disconnect()
729        {
730            this.field_72554_f = true;
731            this.netManager.wakeThreads();
732            this.netManager.networkShutdown("disconnect.closed", new Object[0]);
733        }
734    
735        public void handleMobSpawn(Packet24MobSpawn par1Packet24MobSpawn)
736        {
737            double var2 = (double)par1Packet24MobSpawn.xPosition / 32.0D;
738            double var4 = (double)par1Packet24MobSpawn.yPosition / 32.0D;
739            double var6 = (double)par1Packet24MobSpawn.zPosition / 32.0D;
740            float var8 = (float)(par1Packet24MobSpawn.yaw * 360) / 256.0F;
741            float var9 = (float)(par1Packet24MobSpawn.pitch * 360) / 256.0F;
742            EntityLiving var10 = (EntityLiving)EntityList.createEntityByID(par1Packet24MobSpawn.type, this.mc.theWorld);
743            var10.serverPosX = par1Packet24MobSpawn.xPosition;
744            var10.serverPosY = par1Packet24MobSpawn.yPosition;
745            var10.serverPosZ = par1Packet24MobSpawn.zPosition;
746            var10.rotationYawHead = (float)(par1Packet24MobSpawn.headYaw * 360) / 256.0F;
747            Entity[] var11 = var10.getParts();
748    
749            if (var11 != null)
750            {
751                int var12 = par1Packet24MobSpawn.entityId - var10.entityId;
752                Entity[] var13 = var11;
753                int var14 = var11.length;
754    
755                for (int var15 = 0; var15 < var14; ++var15)
756                {
757                    Entity var16 = var13[var15];
758                    var16.entityId += var12;
759                }
760            }
761    
762            var10.entityId = par1Packet24MobSpawn.entityId;
763            var10.setPositionAndRotation(var2, var4, var6, var8, var9);
764            var10.motionX = (double)((float)par1Packet24MobSpawn.velocityX / 8000.0F);
765            var10.motionY = (double)((float)par1Packet24MobSpawn.velocityY / 8000.0F);
766            var10.motionZ = (double)((float)par1Packet24MobSpawn.velocityZ / 8000.0F);
767            this.worldClient.addEntityToWorld(par1Packet24MobSpawn.entityId, var10);
768            List var17 = par1Packet24MobSpawn.getMetadata();
769    
770            if (var17 != null)
771            {
772                var10.getDataWatcher().updateWatchedObjectsFromList(var17);
773            }
774        }
775    
776        public void handleUpdateTime(Packet4UpdateTime par1Packet4UpdateTime)
777        {
778            this.mc.theWorld.setWorldTime(par1Packet4UpdateTime.time);
779        }
780    
781        public void handleSpawnPosition(Packet6SpawnPosition par1Packet6SpawnPosition)
782        {
783            this.mc.thePlayer.setSpawnChunk(new ChunkCoordinates(par1Packet6SpawnPosition.xPosition, par1Packet6SpawnPosition.yPosition, par1Packet6SpawnPosition.zPosition));
784            this.mc.theWorld.getWorldInfo().setSpawnPosition(par1Packet6SpawnPosition.xPosition, par1Packet6SpawnPosition.yPosition, par1Packet6SpawnPosition.zPosition);
785        }
786    
787        /**
788         * Packet handler
789         */
790        public void handleAttachEntity(Packet39AttachEntity par1Packet39AttachEntity)
791        {
792            Object var2 = this.getEntityByID(par1Packet39AttachEntity.entityId);
793            Entity var3 = this.getEntityByID(par1Packet39AttachEntity.vehicleEntityId);
794    
795            if (par1Packet39AttachEntity.entityId == this.mc.thePlayer.entityId)
796            {
797                var2 = this.mc.thePlayer;
798    
799                if (var3 instanceof EntityBoat)
800                {
801                    ((EntityBoat)var3).func_70270_d(false);
802                }
803            }
804            else if (var3 instanceof EntityBoat)
805            {
806                ((EntityBoat)var3).func_70270_d(true);
807            }
808    
809            if (var2 != null)
810            {
811                ((Entity)var2).mountEntity(var3);
812            }
813        }
814    
815        /**
816         * Packet handler
817         */
818        public void handleEntityStatus(Packet38EntityStatus par1Packet38EntityStatus)
819        {
820            Entity var2 = this.getEntityByID(par1Packet38EntityStatus.entityId);
821    
822            if (var2 != null)
823            {
824                var2.handleHealthUpdate(par1Packet38EntityStatus.entityStatus);
825            }
826        }
827    
828        private Entity getEntityByID(int par1)
829        {
830            return (Entity)(par1 == this.mc.thePlayer.entityId ? this.mc.thePlayer : this.worldClient.getEntityByID(par1));
831        }
832    
833        /**
834         * Recieves player health from the server and then proceeds to set it locally on the client.
835         */
836        public void handleUpdateHealth(Packet8UpdateHealth par1Packet8UpdateHealth)
837        {
838            this.mc.thePlayer.setHealth(par1Packet8UpdateHealth.healthMP);
839            this.mc.thePlayer.getFoodStats().setFoodLevel(par1Packet8UpdateHealth.food);
840            this.mc.thePlayer.getFoodStats().setFoodSaturationLevel(par1Packet8UpdateHealth.foodSaturation);
841        }
842    
843        /**
844         * Handle an experience packet.
845         */
846        public void handleExperience(Packet43Experience par1Packet43Experience)
847        {
848            this.mc.thePlayer.setXPStats(par1Packet43Experience.experience, par1Packet43Experience.experienceTotal, par1Packet43Experience.experienceLevel);
849        }
850    
851        /**
852         * respawns the player
853         */
854        public void handleRespawn(Packet9Respawn par1Packet9Respawn)
855        {
856            if (par1Packet9Respawn.respawnDimension != this.mc.thePlayer.dimension)
857            {
858                this.doneLoadingTerrain = false;
859                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);
860                this.worldClient.isRemote = true;
861                this.mc.loadWorld(this.worldClient);
862                this.mc.thePlayer.dimension = par1Packet9Respawn.respawnDimension;
863                this.mc.displayGuiScreen(new GuiDownloadTerrain(this));
864            }
865    
866            this.mc.setDimensionAndSpawnPlayer(par1Packet9Respawn.respawnDimension);
867            this.mc.playerController.setGameType(par1Packet9Respawn.gameType);
868        }
869    
870        public void handleExplosion(Packet60Explosion par1Packet60Explosion)
871        {
872            Explosion var2 = new Explosion(this.mc.theWorld, (Entity)null, par1Packet60Explosion.explosionX, par1Packet60Explosion.explosionY, par1Packet60Explosion.explosionZ, par1Packet60Explosion.explosionSize);
873            var2.field_77281_g = par1Packet60Explosion.field_73613_e;
874            var2.doExplosionB(true);
875            this.mc.thePlayer.motionX += (double)par1Packet60Explosion.func_73607_d();
876            this.mc.thePlayer.motionY += (double)par1Packet60Explosion.func_73609_f();
877            this.mc.thePlayer.motionZ += (double)par1Packet60Explosion.func_73608_g();
878        }
879    
880        public void handleOpenWindow(Packet100OpenWindow par1Packet100OpenWindow)
881        {
882            EntityClientPlayerMP var2 = this.mc.thePlayer;
883    
884            switch (par1Packet100OpenWindow.inventoryType)
885            {
886                case 0:
887                    var2.displayGUIChest(new InventoryBasic(par1Packet100OpenWindow.windowTitle, par1Packet100OpenWindow.slotsCount));
888                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
889                    break;
890                case 1:
891                    var2.displayGUIWorkbench(MathHelper.floor_double(var2.posX), MathHelper.floor_double(var2.posY), MathHelper.floor_double(var2.posZ));
892                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
893                    break;
894                case 2:
895                    var2.displayGUIFurnace(new TileEntityFurnace());
896                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
897                    break;
898                case 3:
899                    var2.displayGUIDispenser(new TileEntityDispenser());
900                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
901                    break;
902                case 4:
903                    var2.displayGUIEnchantment(MathHelper.floor_double(var2.posX), MathHelper.floor_double(var2.posY), MathHelper.floor_double(var2.posZ));
904                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
905                    break;
906                case 5:
907                    var2.displayGUIBrewingStand(new TileEntityBrewingStand());
908                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
909                    break;
910                case 6:
911                    var2.displayGUIMerchant(new NpcMerchant(var2));
912                    var2.craftingInventory.windowId = par1Packet100OpenWindow.windowId;
913            }
914        }
915    
916        public void handleSetSlot(Packet103SetSlot par1Packet103SetSlot)
917        {
918            EntityClientPlayerMP var2 = this.mc.thePlayer;
919    
920            if (par1Packet103SetSlot.windowId == -1)
921            {
922                var2.inventory.setItemStack(par1Packet103SetSlot.myItemStack);
923            }
924            else
925            {
926                boolean var3 = false;
927    
928                if (this.mc.currentScreen instanceof GuiContainerCreative)
929                {
930                    GuiContainerCreative var4 = (GuiContainerCreative)this.mc.currentScreen;
931                    var3 = var4.func_74230_h() != CreativeTabs.tabInventory.getTabIndex();
932                }
933    
934                if (par1Packet103SetSlot.windowId == 0 && par1Packet103SetSlot.itemSlot >= 36 && par1Packet103SetSlot.itemSlot < 45)
935                {
936                    ItemStack var5 = var2.inventorySlots.getSlot(par1Packet103SetSlot.itemSlot).getStack();
937    
938                    if (par1Packet103SetSlot.myItemStack != null && (var5 == null || var5.stackSize < par1Packet103SetSlot.myItemStack.stackSize))
939                    {
940                        par1Packet103SetSlot.myItemStack.animationsToGo = 5;
941                    }
942    
943                    var2.inventorySlots.putStackInSlot(par1Packet103SetSlot.itemSlot, par1Packet103SetSlot.myItemStack);
944                }
945                else if (par1Packet103SetSlot.windowId == var2.craftingInventory.windowId && (par1Packet103SetSlot.windowId != 0 || !var3))
946                {
947                    var2.craftingInventory.putStackInSlot(par1Packet103SetSlot.itemSlot, par1Packet103SetSlot.myItemStack);
948                }
949            }
950        }
951    
952        public void handleTransaction(Packet106Transaction par1Packet106Transaction)
953        {
954            Container var2 = null;
955            EntityClientPlayerMP var3 = this.mc.thePlayer;
956    
957            if (par1Packet106Transaction.windowId == 0)
958            {
959                var2 = var3.inventorySlots;
960            }
961            else if (par1Packet106Transaction.windowId == var3.craftingInventory.windowId)
962            {
963                var2 = var3.craftingInventory;
964            }
965    
966            if (var2 != null && !par1Packet106Transaction.accepted)
967            {
968                this.addToSendQueue(new Packet106Transaction(par1Packet106Transaction.windowId, par1Packet106Transaction.shortWindowId, true));
969            }
970        }
971    
972        public void handleWindowItems(Packet104WindowItems par1Packet104WindowItems)
973        {
974            EntityClientPlayerMP var2 = this.mc.thePlayer;
975    
976            if (par1Packet104WindowItems.windowId == 0)
977            {
978                var2.inventorySlots.putStacksInSlots(par1Packet104WindowItems.itemStack);
979            }
980            else if (par1Packet104WindowItems.windowId == var2.craftingInventory.windowId)
981            {
982                var2.craftingInventory.putStacksInSlots(par1Packet104WindowItems.itemStack);
983            }
984        }
985    
986        /**
987         * Updates Client side signs
988         */
989        public void handleUpdateSign(Packet130UpdateSign par1Packet130UpdateSign)
990        {
991            if (this.mc.theWorld.blockExists(par1Packet130UpdateSign.xPosition, par1Packet130UpdateSign.yPosition, par1Packet130UpdateSign.zPosition))
992            {
993                TileEntity var2 = this.mc.theWorld.getBlockTileEntity(par1Packet130UpdateSign.xPosition, par1Packet130UpdateSign.yPosition, par1Packet130UpdateSign.zPosition);
994    
995                if (var2 instanceof TileEntitySign)
996                {
997                    TileEntitySign var3 = (TileEntitySign)var2;
998    
999                    if (var3.isEditable())
1000                    {
1001                        for (int var4 = 0; var4 < 4; ++var4)
1002                        {
1003                            var3.signText[var4] = par1Packet130UpdateSign.signLines[var4];
1004                        }
1005    
1006                        var3.onInventoryChanged();
1007                    }
1008                }
1009            }
1010        }
1011    
1012        public void handleTileEntityData(Packet132TileEntityData par1Packet132TileEntityData)
1013        {
1014            if (this.mc.theWorld.blockExists(par1Packet132TileEntityData.xPosition, par1Packet132TileEntityData.yPosition, par1Packet132TileEntityData.zPosition))
1015            {
1016                TileEntity var2 = this.mc.theWorld.getBlockTileEntity(par1Packet132TileEntityData.xPosition, par1Packet132TileEntityData.yPosition, par1Packet132TileEntityData.zPosition);
1017    
1018                if (var2 != null && par1Packet132TileEntityData.actionType == 1 && var2 instanceof TileEntityMobSpawner)
1019                {
1020                    ((TileEntityMobSpawner)var2).readFromNBT(par1Packet132TileEntityData.customParam1);
1021                }
1022                else if (var2 != null)
1023                {
1024                    var2.onDataPacket(netManager,  par1Packet132TileEntityData);
1025                }
1026                else 
1027                {
1028                    /*Packet132TileEntityData pkt = par1Packet132TileEntityData;
1029                    ModLoader.getLogger().log(Level.WARNING, String.format(
1030                            "Received a TileEntityData packet for a location that did not have a TileEntity: (%d, %d, %d) %d: %d, %d, %d", 
1031                            pkt.xPosition, pkt.yPosition, pkt.zPosition,
1032                            pkt.actionType, 
1033                            pkt.customParam1, pkt.customParam2, pkt.customParam3));*/
1034                }
1035            }
1036        }
1037    
1038        public void handleUpdateProgressbar(Packet105UpdateProgressbar par1Packet105UpdateProgressbar)
1039        {
1040            EntityClientPlayerMP var2 = this.mc.thePlayer;
1041            this.registerPacket(par1Packet105UpdateProgressbar);
1042    
1043            if (var2.craftingInventory != null && var2.craftingInventory.windowId == par1Packet105UpdateProgressbar.windowId)
1044            {
1045                var2.craftingInventory.updateProgressBar(par1Packet105UpdateProgressbar.progressBar, par1Packet105UpdateProgressbar.progressBarValue);
1046            }
1047        }
1048    
1049        public void handlePlayerInventory(Packet5PlayerInventory par1Packet5PlayerInventory)
1050        {
1051            Entity var2 = this.getEntityByID(par1Packet5PlayerInventory.entityID);
1052    
1053            if (var2 != null)
1054            {
1055                var2.func_70062_b(par1Packet5PlayerInventory.slot, par1Packet5PlayerInventory.func_73397_d());
1056            }
1057        }
1058    
1059        public void handleCloseWindow(Packet101CloseWindow par1Packet101CloseWindow)
1060        {
1061            this.mc.thePlayer.closeScreen();
1062        }
1063    
1064        public void handleBlockEvent(Packet54PlayNoteBlock par1Packet54PlayNoteBlock)
1065        {
1066            this.mc.theWorld.addBlockEvent(par1Packet54PlayNoteBlock.xLocation, par1Packet54PlayNoteBlock.yLocation, par1Packet54PlayNoteBlock.zLocation, par1Packet54PlayNoteBlock.blockId, par1Packet54PlayNoteBlock.instrumentType, par1Packet54PlayNoteBlock.pitch);
1067        }
1068    
1069        public void handleBlockDestroy(Packet55BlockDestroy par1Packet55BlockDestroy)
1070        {
1071            this.mc.theWorld.destroyBlockInWorldPartially(par1Packet55BlockDestroy.func_73322_d(), par1Packet55BlockDestroy.func_73321_f(), par1Packet55BlockDestroy.func_73324_g(), par1Packet55BlockDestroy.func_73320_h(), par1Packet55BlockDestroy.func_73323_i());
1072        }
1073    
1074        public void handleMapChunks(Packet56MapChunks par1Packet56MapChunks)
1075        {
1076            for (int var2 = 0; var2 < par1Packet56MapChunks.func_73581_d(); ++var2)
1077            {
1078                int var3 = par1Packet56MapChunks.func_73582_a(var2);
1079                int var4 = par1Packet56MapChunks.func_73580_b(var2);
1080                this.worldClient.doPreChunk(var3, var4, true);
1081                this.worldClient.invalidateBlockReceiveRegion(var3 << 4, 0, var4 << 4, (var3 << 4) + 15, 256, (var4 << 4) + 15);
1082                Chunk var5 = this.worldClient.getChunkFromChunkCoords(var3, var4);
1083    
1084                if (var5 == null)
1085                {
1086                    this.worldClient.doPreChunk(var3, var4, true);
1087                    var5 = this.worldClient.getChunkFromChunkCoords(var3, var4);
1088                }
1089    
1090                if (var5 != null)
1091                {
1092                    var5.fillChunk(par1Packet56MapChunks.func_73583_c(var2), par1Packet56MapChunks.field_73590_a[var2], par1Packet56MapChunks.field_73588_b[var2], true);
1093                    this.worldClient.markBlocksDirty(var3 << 4, 0, var4 << 4, (var3 << 4) + 15, 256, (var4 << 4) + 15);
1094    
1095                    if (!(this.worldClient.provider instanceof WorldProviderSurface))
1096                    {
1097                        var5.resetRelightChecks();
1098                    }
1099                }
1100            }
1101        }
1102    
1103        /**
1104         * packet.processPacket is only called if this returns true
1105         */
1106        public boolean canProcessPackets()
1107        {
1108            return this.mc != null && this.mc.theWorld != null && this.mc.thePlayer != null && this.worldClient != null;
1109        }
1110    
1111        public void handleBed(Packet70GameEvent par1Packet70GameEvent)
1112        {
1113            EntityClientPlayerMP var2 = this.mc.thePlayer;
1114            int var3 = par1Packet70GameEvent.bedState;
1115            int var4 = par1Packet70GameEvent.gameMode;
1116    
1117            if (var3 >= 0 && var3 < Packet70GameEvent.bedChat.length && Packet70GameEvent.bedChat[var3] != null)
1118            {
1119                var2.addChatMessage(Packet70GameEvent.bedChat[var3]);
1120            }
1121    
1122            if (var3 == 1)
1123            {
1124                this.worldClient.getWorldInfo().setRaining(true);
1125                this.worldClient.setRainStrength(0.0F);
1126            }
1127            else if (var3 == 2)
1128            {
1129                this.worldClient.getWorldInfo().setRaining(false);
1130                this.worldClient.setRainStrength(1.0F);
1131            }
1132            else if (var3 == 3)
1133            {
1134                this.mc.playerController.setGameType(EnumGameType.getByID(var4));
1135            }
1136            else if (var3 == 4)
1137            {
1138                this.mc.displayGuiScreen(new GuiWinGame());
1139            }
1140            else if (var3 == 5)
1141            {
1142                GameSettings var5 = this.mc.gameSettings;
1143    
1144                if (var4 == 0)
1145                {
1146                    this.mc.displayGuiScreen(new GuiScreenDemo());
1147                }
1148                else if (var4 == 101)
1149                {
1150                    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)});
1151                }
1152                else if (var4 == 102)
1153                {
1154                    this.mc.ingameGUI.getChatGUI().func_73757_a("demo.help.jump", new Object[] {Keyboard.getKeyName(var5.keyBindJump.keyCode)});
1155                }
1156                else if (var4 == 103)
1157                {
1158                    this.mc.ingameGUI.getChatGUI().func_73757_a("demo.help.inventory", new Object[] {Keyboard.getKeyName(var5.keyBindInventory.keyCode)});
1159                }
1160            }
1161        }
1162    
1163        /**
1164         * Contains logic for handling packets containing arbitrary unique item data. Currently this is only for maps.
1165         */
1166        public void handleMapData(Packet131MapData par1Packet131MapData)
1167        {
1168            if (par1Packet131MapData.itemID == Item.map.shiftedIndex)
1169            {
1170                ItemMap.getMPMapData(par1Packet131MapData.uniqueID, this.mc.theWorld).updateMPMapData(par1Packet131MapData.itemData);
1171            }
1172            else
1173            {
1174                System.out.println("Unknown itemid: " + par1Packet131MapData.uniqueID);
1175            }
1176        }
1177    
1178        public void handleDoorChange(Packet61DoorChange par1Packet61DoorChange)
1179        {
1180            this.mc.theWorld.playAuxSFX(par1Packet61DoorChange.sfxID, par1Packet61DoorChange.posX, par1Packet61DoorChange.posY, par1Packet61DoorChange.posZ, par1Packet61DoorChange.auxData);
1181        }
1182    
1183        /**
1184         * runs registerPacket on the given Packet200Statistic
1185         */
1186        public void handleStatistic(Packet200Statistic par1Packet200Statistic)
1187        {
1188            this.mc.thePlayer.incrementStat(StatList.getOneShotStat(par1Packet200Statistic.statisticId), par1Packet200Statistic.amount);
1189        }
1190    
1191        /**
1192         * Handle an entity effect packet.
1193         */
1194        public void handleEntityEffect(Packet41EntityEffect par1Packet41EntityEffect)
1195        {
1196            Entity var2 = this.getEntityByID(par1Packet41EntityEffect.entityId);
1197    
1198            if (var2 instanceof EntityLiving)
1199            {
1200                ((EntityLiving)var2).addPotionEffect(new PotionEffect(par1Packet41EntityEffect.effectId, par1Packet41EntityEffect.duration, par1Packet41EntityEffect.effectAmplifier));
1201            }
1202        }
1203    
1204        /**
1205         * Handle a remove entity effect packet.
1206         */
1207        public void handleRemoveEntityEffect(Packet42RemoveEntityEffect par1Packet42RemoveEntityEffect)
1208        {
1209            Entity var2 = this.getEntityByID(par1Packet42RemoveEntityEffect.entityId);
1210    
1211            if (var2 instanceof EntityLiving)
1212            {
1213                ((EntityLiving)var2).removePotionEffect(par1Packet42RemoveEntityEffect.effectId);
1214            }
1215        }
1216    
1217        /**
1218         * determine if it is a server handler
1219         */
1220        public boolean isServerHandler()
1221        {
1222            return false;
1223        }
1224    
1225        /**
1226         * Handle a player information packet.
1227         */
1228        public void handlePlayerInfo(Packet201PlayerInfo par1Packet201PlayerInfo)
1229        {
1230            GuiPlayerInfo var2 = (GuiPlayerInfo)this.playerInfoMap.get(par1Packet201PlayerInfo.playerName);
1231    
1232            if (var2 == null && par1Packet201PlayerInfo.isConnected)
1233            {
1234                var2 = new GuiPlayerInfo(par1Packet201PlayerInfo.playerName);
1235                this.playerInfoMap.put(par1Packet201PlayerInfo.playerName, var2);
1236                this.playerInfoList.add(var2);
1237            }
1238    
1239            if (var2 != null && !par1Packet201PlayerInfo.isConnected)
1240            {
1241                this.playerInfoMap.remove(par1Packet201PlayerInfo.playerName);
1242                this.playerInfoList.remove(var2);
1243            }
1244    
1245            if (par1Packet201PlayerInfo.isConnected && var2 != null)
1246            {
1247                var2.responseTime = par1Packet201PlayerInfo.ping;
1248            }
1249        }
1250    
1251        /**
1252         * Handle a keep alive packet.
1253         */
1254        public void handleKeepAlive(Packet0KeepAlive par1Packet0KeepAlive)
1255        {
1256            this.addToSendQueue(new Packet0KeepAlive(par1Packet0KeepAlive.randomId));
1257        }
1258    
1259        /**
1260         * Handle a player abilities packet.
1261         */
1262        public void handlePlayerAbilities(Packet202PlayerAbilities par1Packet202PlayerAbilities)
1263        {
1264            EntityClientPlayerMP var2 = this.mc.thePlayer;
1265            var2.capabilities.isFlying = par1Packet202PlayerAbilities.getIsFlying();
1266            var2.capabilities.isCreativeMode = par1Packet202PlayerAbilities.isCreativeMode();
1267            var2.capabilities.disableDamage = par1Packet202PlayerAbilities.getDisableDamage();
1268            var2.capabilities.allowFlying = par1Packet202PlayerAbilities.getAllowFlying();
1269            var2.capabilities.setFlySpeed(par1Packet202PlayerAbilities.getFlySpeed());
1270        }
1271    
1272        public void handleAutoComplete(Packet203AutoComplete par1Packet203AutoComplete)
1273        {
1274            String[] var2 = par1Packet203AutoComplete.func_73473_d().split("\u0000");
1275    
1276            if (this.mc.currentScreen instanceof GuiChat)
1277            {
1278                GuiChat var3 = (GuiChat)this.mc.currentScreen;
1279                var3.func_73894_a(var2);
1280            }
1281        }
1282    
1283        public void handleLevelSound(Packet62LevelSound par1Packet62LevelSound)
1284        {
1285            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());
1286        }
1287    
1288        public void handleCustomPayload(Packet250CustomPayload par1Packet250CustomPayload)
1289        {
1290            FMLNetworkHandler.handlePacket250Packet(par1Packet250CustomPayload, netManager, this);
1291        }
1292    
1293        public void handleVanilla250Packet(Packet250CustomPayload par1Packet250CustomPayload)
1294        {
1295            if ("MC|TPack".equals(par1Packet250CustomPayload.channel))
1296            {
1297                String[] var2 = (new String(par1Packet250CustomPayload.data)).split("\u0000");
1298                String var3 = var2[0];
1299    
1300                if (var2[1].equals("16"))
1301                {
1302                    if (this.mc.texturePackList.getAcceptsTextures())
1303                    {
1304                        this.mc.texturePackList.requestDownloadOfTexture(var3);
1305                    }
1306                    else if (this.mc.texturePackList.func_77300_f())
1307                    {
1308                        this.mc.displayGuiScreen(new GuiYesNo(new NetClientWebTextures(this, var3), StringTranslate.getInstance().translateKey("multiplayer.texturePrompt.line1"), StringTranslate.getInstance().translateKey("multiplayer.texturePrompt.line2"), 0));
1309                    }
1310                }
1311            }
1312            else if ("MC|TrList".equals(par1Packet250CustomPayload.channel))
1313            {
1314                DataInputStream var8 = new DataInputStream(new ByteArrayInputStream(par1Packet250CustomPayload.data));
1315    
1316                try
1317                {
1318                    int var9 = var8.readInt();
1319                    GuiScreen var4 = this.mc.currentScreen;
1320    
1321                    if (var4 != null && var4 instanceof GuiMerchant && var9 == this.mc.thePlayer.craftingInventory.windowId)
1322                    {
1323                        IMerchant var5 = ((GuiMerchant)var4).func_74199_h();
1324                        MerchantRecipeList var6 = MerchantRecipeList.readRecipiesFromStream(var8);
1325                        var5.setRecipes(var6);
1326                    }
1327                }
1328                catch (IOException var7)
1329                {
1330                    var7.printStackTrace();
1331                }
1332            }
1333        }
1334    
1335        /**
1336         * Return the NetworkManager instance used by this NetClientHandler
1337         */
1338        public NetworkManager getNetManager()
1339        {
1340            return this.netManager;
1341        }
1342    
1343        @Override
1344        public EntityPlayer getPlayer()
1345        {
1346            return mc.thePlayer;
1347        }
1348    }