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 }