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