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