    001    package net.minecraft.network;
    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.IOException;
    008    import java.net.InetSocketAddress;
    009    import java.net.SocketAddress;
    010    import java.util.ArrayList;
    011    import java.util.Collections;
    012    import java.util.List;
    013    import net.minecraft.network.packet.NetHandler;
    014    import net.minecraft.network.packet.Packet;
    015
    016    public class MemoryConnection implements INetworkManager
    017    {
    018        private static final SocketAddress mySocketAddress = new InetSocketAddress("127.0.0.1", 0);
    019        private final List readPacketCache = Collections.synchronizedList(new ArrayList());
    020        private MemoryConnection pairedConnection;
    021        private NetHandler myNetHandler;
    022
    023        /** set to true by {server,network}Shutdown */
    024        private boolean shuttingDown = false;
    025        private String shutdownReason = "";
    026        private Object[] field_74439_g;
    027        private boolean gamePaused = false;
    028
    029        public MemoryConnection(NetHandler par1NetHandler) throws IOException
    030        {
    031            this.myNetHandler = par1NetHandler;
    032        }
    033
    034        /**
    035         * Sets the NetHandler for this NetworkManager. Server-only.
    036         */
    037        public void setNetHandler(NetHandler par1NetHandler)
    038        {
    039            this.myNetHandler = par1NetHandler;
    040        }
    041
    042        /**
    043         * Adds the packet to the correct send queue (chunk data packets go to a separate queue).
    044         */
    045        public void addToSendQueue(Packet par1Packet)
    046        {
    047            if (!this.shuttingDown)
    048            {
    049                this.pairedConnection.processOrCachePacket(par1Packet);
    050            }
    051        }
    052
    053        /**
    054         * Wakes reader and writer threads
    055         */
    056        public void wakeThreads() {}
    057
    058        @SideOnly(Side.CLIENT)
    059        public void closeConnections()
    060        {
    061            this.pairedConnection = null;
    062            this.myNetHandler = null;
    063        }
    064
    065        @SideOnly(Side.CLIENT)
    066        public boolean isConnectionActive()
    067        {
    068            return !this.shuttingDown && this.pairedConnection != null;
    069        }
    070
    071        /**
    072         * Checks timeouts and processes all pending read packets.
    073         */
    074        public void processReadPackets()
    075        {
    076            int var1 = 2500;
    077
    078            while (var1-- >= 0 && !this.readPacketCache.isEmpty())
    079            {
    080                Packet var2 = (Packet)this.readPacketCache.remove(0);
    081                var2.processPacket(this.myNetHandler);
    082            }
    083
    084            if (this.readPacketCache.size() > var1)
    085            {
    086                System.out.println("Memory connection overburdened; after processing 2500 packets, we still have " + this.readPacketCache.size() + " to go!");
    087            }
    088
    089            if (this.shuttingDown && this.readPacketCache.isEmpty())
    090            {
    091                this.myNetHandler.handleErrorMessage(this.shutdownReason, this.field_74439_g);
    092                FMLNetworkHandler.onConnectionClosed(this, this.myNetHandler.getPlayer());
    093            }
    094        }
    095
    096        /**
    097         * Return the InetSocketAddress of the remote endpoint
    098         */
    099        public SocketAddress getSocketAddress()
    100        {
    101            return mySocketAddress;
    102        }
    103
    104        /**
    105         * Shuts down the server. (Only actually used on the server)
    106         */
    107        public void serverShutdown()
    108        {
    109            this.shuttingDown = true;
    110        }
    111
    112        /**
    113         * Shuts down the network with the specified reason. Closes all streams and sockets, spawns NetworkMasterThread to
    114         * stop reading and writing threads.
    115         */
    116        public void networkShutdown(String par1Str, Object ... par2ArrayOfObj)
    117        {
    118            this.shuttingDown = true;
    119            this.shutdownReason = par1Str;
    120            this.field_74439_g = par2ArrayOfObj;
    121        }
    122
    123        /**
    124         * returns 0 for memoryConnections
    125         */
    126        public int packetSize()
    127        {
    128            return 0;
    129        }
    130
    131        @SideOnly(Side.CLIENT)
    132        public void pairWith(MemoryConnection par1MemoryConnection)
    133        {
    134            this.pairedConnection = par1MemoryConnection;
    135            par1MemoryConnection.pairedConnection = this;
    136        }
    137
    138        @SideOnly(Side.CLIENT)
    139        public boolean isGamePaused()
    140        {
    141            return this.gamePaused;
    142        }
    143
    144        @SideOnly(Side.CLIENT)
    145        public void setGamePaused(boolean par1)
    146        {
    147            this.gamePaused = par1;
    148        }
    149
    150        @SideOnly(Side.CLIENT)
    151        public MemoryConnection getPairedConnection()
    152        {
    153            return this.pairedConnection;
    154        }
    155
    156        /**
    157         * acts immiditally if isWritePacket, otherwise adds it to the readCache to be processed next tick
    158         */
    159        public void processOrCachePacket(Packet par1Packet)
    160        {
    161            String var2 = this.myNetHandler.isServerHandler() ? ">" : "<";
    162
    163            if (par1Packet.isWritePacket() && this.myNetHandler.canProcessPackets())
    164            {
    165                par1Packet.processPacket(this.myNetHandler);
    166            }
    167            else
    168            {
    169                this.readPacketCache.add(par1Packet);
    170            }
    171        }
    172    }