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