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 INetworkManager 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 String var2 = this.myNetHandler.isServerHandler() ? ">" : "<"; 155 156 if (par1Packet.isWritePacket() && this.myNetHandler.canProcessPackets()) 157 { 158 par1Packet.processPacket(this.myNetHandler); 159 } 160 else 161 { 162 this.readPacketCache.add(par1Packet); 163 } 164 } 165 }