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