+Unity Runtime codeHEADmaster

1 files changed, 921 insertions, 0 deletions

diff --git a/Runtime/Export/Networking.txt b/Runtime/Export/Networking.txt
new file mode 100644
index 0000000..8779122
--- /dev/null
+++ b/Runtime/Export/Networking.txt
@@ -0,0 +1,921 @@
+C++RAW
+
+#include "UnityPrefix.h"
+#include "Configuration/UnityConfigure.h"
+#include "Runtime/Math/Quaternion.h"
+#include "Runtime/Utilities/Utility.h"
+#include "Runtime/Network/NetworkManager.h"
+#include "Runtime/Network/NetworkUtility.h"
+#include "Runtime/Network/BitStreamPacker.h"
+#include "Runtime/Network/MasterServerInterface.h"
+#include "Runtime/Mono/MonoBehaviour.h"
+#include "Runtime/Scripting/Scripting.h"
+
+CSRAW
+
+#if ENABLE_NETWORK
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using UnityEngineInternal;
+
+namespace UnityEngine
+{
+
+// Option for who will receive an [[RPC]], used by NetworkView.RPC.
+CONDITIONAL ENABLE_NETWORK
+ENUM RPCMode
+	// Sends to the server only
+	Server = 0,
+
+	// Sends to everyone except the sender
+	Others = 1,
+
+	// Sends to everyone except the sender and adds to the buffer
+	OthersBuffered = 5,
+
+	// Sends to everyone
+	All = 2,
+
+	// Sends to everyone and adds to the buffer
+	AllBuffered = 6
+END
+
+// The various test results the connection tester may return with.
+CONDITIONAL ENABLE_NETWORK
+ENUM ConnectionTesterStatus
+	// Some unknown error occurred.
+	Error = -2,
+	// Test result undetermined, still in progress.
+	Undetermined = -1,
+	OBSOLETE warning No longer returned, use newer connection tester enums instead.
+	PrivateIPNoNATPunchthrough = 0,
+	OBSOLETE warning No longer returned, use newer connection tester enums instead.
+	PrivateIPHasNATPunchThrough = 1,
+	// Public IP address detected and game listen port is accessible to the internet.
+	PublicIPIsConnectable = 2,
+	// Public IP address detected but the port is not connectable from the internet.
+	PublicIPPortBlocked = 3,
+	// Public IP address detected but server is not initialized and no port is listening.
+	PublicIPNoServerStarted = 4,
+	// Port-restricted NAT type, can do NAT punchthrough to everyone except symmetric.
+	LimitedNATPunchthroughPortRestricted = 5,
+	// Symmetric NAT type, cannot do NAT punchthrough to other symmetric types nor port restricted type.
+	LimitedNATPunchthroughSymmetric = 6,
+	// Full cone type, NAT punchthrough fully supported.
+	NATpunchthroughFullCone = 7,
+	// Address-restricted cone type, NAT punchthrough fully supported.
+	NATpunchthroughAddressRestrictedCone = 8
+END
+
+// Possible status messages returned by Network.Connect and in [[MonoBehaviour.OnFailedToConnect|OnFailedToConnect]]
+CONDITIONAL ENABLE_NETWORK
+ENUM NetworkConnectionError
+	// No error occurred.
+	NoError = 0,
+
+	// We presented an RSA public key which does not match what the system we connected to is using.
+	RSAPublicKeyMismatch = 21,
+
+	// The server is using a password and has refused our connection because we did not set the correct password.
+	InvalidPassword = 23,
+
+	// Connection attempt failed, possibly because of internal connectivity problems.
+	ConnectionFailed = 15,
+
+	// The server is at full capacity, failed to connect.
+	TooManyConnectedPlayers = 18,
+
+	// We are banned from the system we attempted to connect to (likely temporarily).
+	ConnectionBanned = 22,
+
+	// We are already connected to this particular server (can happen after fast disconnect/reconnect).
+	AlreadyConnectedToServer = 16,
+
+	// Cannot connect to two servers at once. Close the connection before connecting again.
+	AlreadyConnectedToAnotherServer = -1,
+
+	// Internal error while attempting to initialize network interface. Socket possibly already in use.
+	CreateSocketOrThreadFailure = -2,
+
+	// Incorrect parameters given to Connect function.
+	IncorrectParameters = -3,
+
+	// No host target given in Connect.
+	EmptyConnectTarget = -4,
+
+	// Client could not connect internally to same network NAT enabled server.
+	InternalDirectConnectFailed = -5,
+
+	// The NAT target we are trying to connect to is not connected to the facilitator server.
+	NATTargetNotConnected = 69,
+
+	// Connection lost while attempting to connect to NAT target.
+	NATTargetConnectionLost = 71,
+
+	// NAT punchthrough attempt has failed. The cause could be a too restrictive NAT implementation on either endpoints.
+	NATPunchthroughFailed = 73
+END
+
+// The reason a disconnect event occured, like in [[MonoBehaviour.OnDisconnectedFromServer|OnDisconnectedFromServer]].
+CONDITIONAL ENABLE_NETWORK
+ENUM NetworkDisconnection
+	// The connection to the system has been lost, no reliable packets could be delivered.
+	LostConnection = 20,
+
+	// The connection to the system has been closed.
+	Disconnected = 19
+END
+
+// Describes status messages from the master server as returned in [[MonoBehaviour.OnMasterServerEvent|OnMasterServerEvent]].
+CONDITIONAL ENABLE_NETWORK
+ENUM MasterServerEvent
+	// Registration failed because an empty game name was given.
+	RegistrationFailedGameName = 0,
+
+	// Registration failed because an empty game type was given.
+	RegistrationFailedGameType = 1,
+
+	// Registration failed because no server is running.
+	RegistrationFailedNoServer = 2,
+
+	// Registration to master server succeeded, received confirmation.
+	RegistrationSucceeded = 3,
+
+	// Received a host list from the master server.
+	HostListReceived = 4
+END
+
+// Different types of synchronization for the [[NetworkView]] component.
+CONDITIONAL ENABLE_NETWORK
+ENUM NetworkStateSynchronization
+
+	// No state data will be synchronized
+	Off = 0,
+
+	// All packets are sent reliable and ordered.
+	ReliableDeltaCompressed = 1,
+
+	// Brute force unreliable state sending
+	Unreliable = 2
+END
+
+// Describes the status of the network interface peer type as returned by Network.peerType.
+CONDITIONAL ENABLE_NETWORK
+ENUM NetworkPeerType
+	// No client connection running. Server not initialized.
+	Disconnected = 0,
+	// Running as server.
+	Server = 1,
+	// Running as client.
+	Client = 2,
+	// Attempting to connect to a server.
+	Connecting = 3
+END
+
+// Describes different levels of log information the network layer supports.
+CONDITIONAL ENABLE_NETWORK
+ENUM NetworkLogLevel
+	// Only report errors, otherwise silent.
+	Off = 0,
+	// Report informational messages like connectivity events.
+	Informational = 1,
+	// Full debug level logging down to each individual message being reported.
+	Full = 3
+END
+
+
+// The NetworkPlayer is a data structure with which you can locate another player over the network.
+CONDITIONAL ENABLE_NETWORK
+STRUCT NetworkPlayer
+	CSRAW internal int index;
+
+	CUSTOM private static string Internal_GetIPAddress(int index) { return scripting_string_new(GetNetworkManager().GetIPAddress(index));  }
+	CUSTOM private static int Internal_GetPort(int index) { return GetNetworkManager().GetPort(index); }
+	CUSTOM private static string Internal_GetExternalIP() { return scripting_string_new(GetNetworkManager().GetExternalIP()); }
+	CUSTOM private static int Internal_GetExternalPort() { return GetNetworkManager().GetExternalPort(); }
+	CUSTOM private static string Internal_GetLocalIP() { return scripting_string_new(GetLocalIP()); }
+	CUSTOM private static int Internal_GetLocalPort() { return GetNetworkManager().GetPort(); }
+	CUSTOM private static int Internal_GetPlayerIndex ()  { return GetNetworkManager().GetPlayerID(); }
+	CUSTOM private static string Internal_GetGUID(int index) { return scripting_string_new(GetNetworkManager().GetGUID(index)); }
+	CUSTOM private static string Internal_GetLocalGUID ()  { return scripting_string_new(GetNetworkManager().GetGUID()); }
+
+	// *undocumented*
+	CSRAW public NetworkPlayer (string ip, int port)
+	{
+		Debug.LogError("Not yet implemented");
+		index = 0;
+	}
+
+	// Returns true if two NetworkPlayers are the same player.
+	CSRAW public static bool operator == (NetworkPlayer lhs, NetworkPlayer rhs)
+	{
+		return lhs.index == rhs.index;
+	}
+
+	// Returns true if two NetworkPlayers are not the same player.
+	CSRAW public static bool operator != (NetworkPlayer lhs, NetworkPlayer rhs)
+	{
+		return lhs.index != rhs.index;
+	}
+
+	// *undocumented* Used to allow NetworkPlayer to be used as keys in hash tables. Also triggers warning for == and != operators if not present
+	CSRAW public override int GetHashCode() {
+		return index.GetHashCode();
+	}
+
+	// *undocumented* Required for being able to use NetworkPlayer as keys in hash tables
+	CSRAW public override bool Equals(object other) {
+		if(!(other is NetworkPlayer)) return false;
+
+		NetworkPlayer rhs=(NetworkPlayer)other;
+		return rhs.index == index;
+	}
+
+	// The IP address of this player.
+	CSRAW public string ipAddress { get { if (index == Internal_GetPlayerIndex()) return Internal_GetLocalIP(); else return Internal_GetIPAddress(index); } }
+
+	// The port of this player.
+	CSRAW public int port { get { if (index == Internal_GetPlayerIndex()) return Internal_GetLocalPort(); else return Internal_GetPort(index); } }
+
+	// The GUID for this player, used when connecting with NAT punchthrough.
+	CSRAW public string guid { get { if (index == Internal_GetPlayerIndex()) return Internal_GetLocalGUID(); else return Internal_GetGUID(index); } }
+
+	// Returns the index number for this network player.
+	CSRAW override public string ToString() { return index.ToString(); }
+
+	// Returns the external IP address of the network interface.
+	CSRAW public string externalIP { get { return Internal_GetExternalIP(); } }
+
+	// Returns the external port of the network interface.
+	CSRAW public int externalPort { get { return Internal_GetExternalPort(); } }
+
+	CSRAW static internal NetworkPlayer unassigned { get { NetworkPlayer val; val.index = -1; return val; } }
+
+END
+
+// The NetworkViewID is a unique identifier for a network view instance in a multiplayer game.
+CONDITIONAL ENABLE_NETWORK
+STRUCT NetworkViewID
+	CSRAW int a;
+	CSRAW int b;
+	CSRAW int c;
+
+	// Represents an invalid network view ID.
+	CUSTOM_PROP static NetworkViewID unassigned { return NetworkViewID::GetUnassignedViewID(); }
+
+	CUSTOM static internal bool Internal_IsMine(NetworkViewID value) { return GetNetworkManager().WasViewIdAllocatedByMe(value); }
+	CUSTOM static internal void Internal_GetOwner(NetworkViewID value, out NetworkPlayer player) { *player = GetNetworkManager().GetNetworkViewIDOwner(value); }
+	CUSTOM static internal string Internal_GetString(NetworkViewID value) { return scripting_string_new(value.ToString()); }
+	CUSTOM static internal bool Internal_Compare(NetworkViewID lhs, NetworkViewID rhs) { return rhs == lhs; }
+
+	// Returns true if two NetworkViewIDs are identical
+	CSRAW public static bool operator == (NetworkViewID lhs, NetworkViewID rhs)
+	{
+		return Internal_Compare(lhs, rhs);
+	}
+
+	// Returns true if two NetworkViewIDs are not identical
+	CSRAW public static bool operator != (NetworkViewID lhs, NetworkViewID rhs)
+	{
+		return !Internal_Compare(lhs, rhs);
+	}
+
+	// *undocumented* Used to allow NetworkViewIDs to be used as keys in hash tables. Also triggers warning for == and != operators if not present
+	CSRAW public override int GetHashCode() {
+		return a ^ b ^ c;
+	}
+
+	// *undocumented* Required for being able to use NetworkViewIDs as keys in hash tables
+	CSRAW public override bool Equals(object other) {
+		if(!(other is NetworkViewID)) return false;
+
+		NetworkViewID rhs=(NetworkViewID)other;
+		return Internal_Compare(this, rhs);
+	}
+
+	// True if instantiated by me
+	CSRAW public bool isMine { get
+	 { return Internal_IsMine(this); } }
+
+	// The [[NetworkPlayer]] who owns the [[NetworkView]]. Could be the server.
+	CSRAW public NetworkPlayer owner  { get { NetworkPlayer p; Internal_GetOwner(this, out p); return p;} }
+
+	// Returns a formatted string with details on this NetworkViewID.
+	CSRAW override public string ToString()  { return Internal_GetString(this); }
+
+END
+
+
+// Ping any given IP address (given in dot notation).
+CONDITIONAL ENABLE_NETWORK
+CLASS Ping
+
+	// We are matching the Ping class here so we can directly access it.
+	CSRAW private IntPtr pingWrapper;
+
+	// this is needed only for batched android build due to bug in txt parser
+	// screwing up iphone_input.txt to have cpp line emited in wrong place
+	C++RAW #undef GET
+	C++RAW #define GET ExtractMonoObjectData<Ping*> (self)
+
+	// Perform a ping to the supplied target IP address.
+	CUSTOM Ping(string address)
+	{
+		GET = new Ping(address);
+		GetNetworkManager().PingWrapper(GET);
+	}
+
+	//*undocumented*
+	THREAD_SAFE
+	CUSTOM void DestroyPing()
+	{
+		if (GET)
+		{
+			GET->Release();
+			GET = 0;
+		}
+	}
+
+	CSRAW ~Ping()
+	{
+		DestroyPing();
+	}
+
+	// Has the ping function completed?
+	CUSTOM_PROP public bool isDone
+	{
+		if (GET) return (short)GET->GetIsDone();
+		else return false;
+	}
+
+	// This property contains the ping time result after isDone returns true.
+	CUSTOM_PROP public int time
+	{
+		return GET->GetTime();
+	}
+
+	// The IP target of the ping.
+	CUSTOM_PROP public string ip
+	{
+		return scripting_string_new(GET->GetIP());
+	}
+
+	C++RAW
+ #undef GET
+
+END
+
+
+// The network view is the binding material of multiplayer games.
+CONDITIONAL ENABLE_NETWORK
+CLASS NetworkView : Behaviour
+
+	CUSTOM private static void Internal_RPC (NetworkView view, string name, RPCMode mode, object[] args)
+	{
+		view->RPCCall(name, mode, args);
+	}
+
+	CUSTOM private static void Internal_RPC_Target (NetworkView view, string name, NetworkPlayer target, object[] args)
+	{
+		view->RPCCallSpecificTarget(name, target, args);
+	}
+
+	// Call a [[RPC]] function on all connected peers.
+	CSRAW public void RPC (string name, RPCMode mode, params object[] args) { Internal_RPC(this, name, mode, args); }
+
+	// Call a RPC function on a specific player
+	CSRAW public void RPC (string name, NetworkPlayer target, params object[] args) { Internal_RPC_Target(this, name, target, args); }
+
+	// The component the network view is observing.
+	AUTO_PTR_PROP Component observed GetObserved SetObserved
+
+	// The type of [[NetworkStateSynchronization]] set for this network view.
+	CUSTOM_PROP NetworkStateSynchronization stateSynchronization  { return self->GetStateSynchronization(); } { self->SetStateSynchronization(value); }
+
+	CUSTOM private void Internal_GetViewID (out NetworkViewID viewID)
+	{
+		*viewID = self->GetViewID();
+	}
+	CUSTOM private void  Internal_SetViewID (NetworkViewID viewID) { self->SetViewID(viewID); }
+
+	// The ViewID of this network view.
+	CSRAW public NetworkViewID viewID { get { NetworkViewID val; Internal_GetViewID(out val); return val; } set  { Internal_SetViewID(value); } }
+
+	// The network group number of this network view.
+	AUTO_PROP int group GetGroup SetGroup
+
+	// Is the network view controlled by this object?
+	CSRAW public bool isMine { get { return viewID.isMine; } }
+
+	// The [[NetworkPlayer]] who owns this network view.
+	CSRAW public NetworkPlayer owner { get { return viewID.owner; } }
+
+	// Set the scope of the network view in relation to a specific network player.
+	CUSTOM bool SetScope(NetworkPlayer player, bool relevancy)
+	{
+		return self->SetPlayerScope(player, relevancy);
+	}
+
+	// Find a network view based on a [[NetworkViewID]].
+	CUSTOM static NetworkView Find (NetworkViewID viewID) { return Scripting::ScriptingWrapperFor(GetNetworkManager().ViewIDToNetworkView (viewID)); }
+
+END
+
+// The network class is at the heart of the network implementation and provides the core functions.
+CONDITIONAL ENABLE_NETWORK
+CLASS Network
+
+	// Initialize the server.
+	CUSTOM static NetworkConnectionError InitializeServer (int connections, int listenPort, bool useNat) { return GetNetworkManager().InitializeServer(connections, listenPort, useNat); }
+
+	CUSTOM private static NetworkConnectionError Internal_InitializeServerDeprecated (int connections, int listenPort) { return GetNetworkManager().InitializeServer(connections, listenPort, false); }
+
+	OBSOLETE warning Use the IntializeServer(connections, listenPort, useNat) function instead
+	CSRAW public static NetworkConnectionError InitializeServer (int connections, int listenPort) { return Internal_InitializeServerDeprecated(connections, listenPort); }
+
+	// Set the password for the server (for incoming connections).
+	CUSTOM_PROP static string incomingPassword { return scripting_string_new(GetNetworkManager().GetIncomingPassword());} { GetNetworkManager().SetIncomingPassword(value);}
+
+	// Set the log level for network messages (default is Off).
+	CUSTOM_PROP static NetworkLogLevel logLevel  { return GetNetworkManager().GetDebugLevel(); } { GetNetworkManager().SetDebugLevel(value); }
+
+	// Initializes security layer.
+	CUSTOM static void InitializeSecurity() { GetNetworkManager().InitializeSecurity(); }
+
+	CUSTOM private static NetworkConnectionError Internal_ConnectToSingleIP (string IP, int remotePort, int localPort, string password = "")
+	{
+		return GetNetworkManager().Connect(IP, remotePort, localPort, password);
+	}
+
+	CUSTOM private static NetworkConnectionError Internal_ConnectToGuid (string guid, string password)
+	{
+		RakNetGUID remoteGuid;
+		remoteGuid.FromString(guid.AsUTF8().c_str());
+		return GetNetworkManager().Connect(remoteGuid, 0, password);
+	}
+
+	CUSTOM private static NetworkConnectionError Internal_ConnectToIPs (string[] IP, int remotePort, int localPort, string password = "")
+	{
+		std::vector<string> ipvector;
+		for (int i=0; i < mono_array_length_safe(IP); i++)
+		{
+			ipvector.push_back(scripting_cpp_string_for(GetMonoArrayElement<MonoString*> (IP, i)));
+		}
+		return GetNetworkManager().Connect(ipvector, remotePort, localPort, password);
+	}
+
+	// Connect to the specified host (ip or domain name) and server port.
+	CSRAW public static NetworkConnectionError Connect (string IP, int remotePort, string password = "") { return Internal_ConnectToSingleIP(IP, remotePort, 0, password); }
+
+	// This function is exactly like Network.Connect but can accept an array of IP addresses.
+	CSRAW public static NetworkConnectionError Connect (string[] IPs, int remotePort, string password = ""){
+		return Internal_ConnectToIPs(IPs, remotePort, 0, password); }
+
+	// Connect to a server GUID. NAT punchthrough can only be performed this way.
+	CSRAW public static NetworkConnectionError Connect (string GUID, string password = "") {
+		return Internal_ConnectToGuid(GUID, password);
+	}
+
+	// Connect to the host represented by a [[HostData]] structure returned by the Master Server.
+	CSRAW public static NetworkConnectionError Connect (HostData hostData, string password = "") {
+		if(hostData == null)
+			throw new NullReferenceException();
+		if (hostData.guid.Length > 0 && hostData.useNat)
+			return Connect(hostData.guid, password);
+		else
+			return Connect(hostData.ip, hostData.port, password);
+	}
+
+	// Close all open connections and shuts down the network interface.
+	CUSTOM static void Disconnect(int timeout = 200) { GetNetworkManager().Disconnect(timeout); }
+
+	// Close the connection to another system.
+	CUSTOM static void CloseConnection (NetworkPlayer target, bool sendDisconnectionNotification) { GetNetworkManager().CloseConnection(target, sendDisconnectionNotification); }
+
+	// All connected players.
+	CUSTOM_PROP static NetworkPlayer[] connections {
+		MonoArray* array = mono_array_new (mono_domain_get (), MONO_COMMON.networkPlayer, GetNetworkManager().GetConnectionCount());
+		GetNetworkManager().GetConnections(&GetMonoArrayElement<int> (array,0));
+		return array;
+	}
+
+	CUSTOM private static int Internal_GetPlayer ()  { return GetNetworkManager().GetPlayerID(); }
+
+	// Get the local [[NetworkPlayer]] instance
+	CSRAW public static NetworkPlayer player { get { NetworkPlayer np; np.index = Internal_GetPlayer(); return np; } }
+
+	CUSTOM private static void Internal_AllocateViewID(out NetworkViewID viewID)
+	{ *viewID = GetNetworkManager().AllocateViewID(); }
+
+	// Query for the next available network view ID number and allocate it (reserve).
+	CSRAW public static NetworkViewID AllocateViewID() { NetworkViewID val; Internal_AllocateViewID (out val); return val; }
+
+	// Network instantiate a prefab.
+	CSRAW
+	[TypeInferenceRule(TypeInferenceRules.TypeOfFirstArgument)]
+	CUSTOM public static Object Instantiate (Object prefab, Vector3 position, Quaternion rotation, int group) { return Scripting::ScriptingWrapperFor(GetNetworkManager().Instantiate (*prefab, position, rotation, group)); }
+
+	// Destroy the object associated with this view ID across the network.
+	CUSTOM static void Destroy (NetworkViewID viewID) { GetNetworkManager().DestroyDelayed(viewID); }
+
+	// Destroy the object across the network.
+	CSRAW public static void Destroy (GameObject gameObject) {
+		if (gameObject != null)
+		{
+			NetworkView view = gameObject.networkView;
+			if (view != null)
+				Destroy(view.viewID);
+			else
+				Debug.LogError("Couldn't destroy game object because no network view is attached to it.", gameObject);
+		}
+	}
+
+	// Destroy all the objects based on view IDs belonging to this player.
+	CUSTOM static void DestroyPlayerObjects(NetworkPlayer playerID) { GetNetworkManager().DestroyPlayerObjects(playerID); }
+
+	CUSTOM private static void Internal_RemoveRPCs(NetworkPlayer playerID, NetworkViewID viewID, uint channelMask) { GetNetworkManager().RemoveRPCs(playerID, viewID, channelMask); }
+
+	// Remove all [[RPC]] functions which belong to this player ID.
+	CSRAW public static void RemoveRPCs(NetworkPlayer playerID) { Internal_RemoveRPCs(playerID, NetworkViewID.unassigned, 0xFFFFFFFF); }
+	// Remove all [[RPC]] functions which belong to this player ID and were sent based on the given group.
+	CSRAW public static void RemoveRPCs(NetworkPlayer playerID, int group) { Internal_RemoveRPCs(playerID, NetworkViewID.unassigned, (uint)(1 << group)); }
+	// Remove the [[RPC]] function calls accociated with this view ID number.
+	CSRAW public static void RemoveRPCs(NetworkViewID viewID) { Internal_RemoveRPCs(NetworkPlayer.unassigned, viewID, 0xFFFFFFFF); }
+	// Remove all [[RPC]] functions which belong to given group number.
+	CSRAW public static  void RemoveRPCsInGroup (int group) { Internal_RemoveRPCs(NetworkPlayer.unassigned, NetworkViewID.unassigned, (uint)(1 << group)); }
+
+	// Returns true if your peer type is client.
+	CUSTOM_PROP static bool isClient { return GetNetworkManager().IsClient(); }
+
+	// Returns true if your peer type is server.
+	CUSTOM_PROP static bool isServer { return GetNetworkManager().IsServer(); }
+
+	// The status of the peer type, i.e. if it is disconnected, connecting, server or client.
+	CUSTOM_PROP static NetworkPeerType peerType { return GetNetworkManager().GetPeerType(); }
+
+	// Set the level prefix which will then be prefixed to all network ViewID numbers.
+	CUSTOM static void SetLevelPrefix (int prefix) { return GetNetworkManager().SetLevelPrefix(prefix); }
+
+
+	// The last ping time to the given /player/ in milliseconds.
+	CUSTOM static int GetLastPing (NetworkPlayer player) { return GetNetworkManager().GetLastPing(player); }
+
+	// The last average ping time to the given /player/ in milliseconds.
+	CUSTOM static int GetAveragePing (NetworkPlayer player) { return GetNetworkManager().GetAveragePing(player); }
+
+	// The default send rate of network updates for all Network Views.
+	CUSTOM_PROP static float sendRate { return GetNetworkManager().GetSendRate(); } { GetNetworkManager().SetSendRate(value); }
+
+	// Enable or disable the processing of network messages.
+	CUSTOM_PROP static bool isMessageQueueRunning { return GetNetworkManager().GetMessageQueueRunning(); } { GetNetworkManager().SetMessageQueueRunning(value); }
+
+	// Enable or disables the reception of messages in a specific group number from a specific player.
+	CUSTOM static void SetReceivingEnabled (NetworkPlayer player, int group, bool enabled)  { GetNetworkManager().SetReceivingGroupEnabled(player, group, enabled); }
+
+	CUSTOM private static void Internal_SetSendingGlobal(int group, bool enabled) { GetNetworkManager().SetSendingGroupEnabled(group, enabled); }
+
+	CUSTOM private static void Internal_SetSendingSpecific (NetworkPlayer player, int group, bool enabled) { GetNetworkManager().SetSendingGroupEnabled(player, group, enabled); }
+
+	// Enables or disables transmission of messages and [[RPC]] calls on a specific network group number.
+	CSRAW public static void SetSendingEnabled (int group, bool enabled) { Internal_SetSendingGlobal(group, enabled); }
+
+	// Enable or disable transmission of messages and [[RPC]] calls based on target network player as well as the network group.
+	CSRAW public static void SetSendingEnabled (NetworkPlayer player, int group, bool enabled) { Internal_SetSendingSpecific(player, group, enabled); }
+
+	CUSTOM private static void Internal_GetTime(out double t) { *t = GetNetworkManager().GetTime();}
+
+	// Get the current network time (seconds).
+	CSRAW public static double time {  get { double t; Internal_GetTime(out t); return t; } }
+
+	// Called on the server whenever a new player has successfully connected.
+	CSNONE void OnPlayerConnected (NetworkPlayer player);
+
+	// Called on the server whenever a Network.InitializeServer was invoked and has completed.
+	CSNONE void OnServerInitialized ();
+
+	// Called on the client when you have successfully connected to a server
+	CSNONE void OnConnectedToServer ();
+
+	// Called on the server whenever a player is disconnected from the server
+	CSNONE void OnPlayerDisconnected (NetworkPlayer player);
+
+	// Called on client during disconnection from server, but also on the server when the connection has disconnected.
+	CSNONE void OnDisconnectedFromServer (NetworkDisconnection mode);
+
+	// Called on the client when a connection attempt fails for some reason.
+	CSNONE void OnFailedToConnect (NetworkConnectionError error);
+
+	// Called on objects which have been network instantiated with Network.Instantiate
+	CSNONE void OnNetworkInstantiate (NetworkMessageInfo info);
+
+	// Used to customize synchronization of variables in a script watched by a network view.
+	CSNONE void OnSerializeNetworkView (BitStream stream, NetworkMessageInfo info);
+
+	// Get or set the minimum number of ViewID numbers in the ViewID pool given to clients by the server.
+	CUSTOM_PROP static int minimumAllocatableViewIDs { return GetNetworkManager().GetMinimumAllocatableViewIDs(); } { GetNetworkManager().SetMinimumAllocatableViewIDs(value); }
+
+	OBSOLETE warning No longer needed. This is now explicitly set in the InitializeServer function call. It is implicitly set when calling Connect depending on if an IP/port combination is used (useNat=false) or a GUID is used(useNat=true).
+	CUSTOM_PROP static bool useNat { return GetNetworkManager().GetUseNat(); } { GetNetworkManager().SetUseNat(value); }
+
+	// The IP address of the NAT punchthrough facilitator.
+	CUSTOM_PROP static string natFacilitatorIP { return scripting_string_new(GetNetworkManager().GetFacilitatorAddress().ToString());} { GetNetworkManager().GetFacilitatorAddress(false).SetBinaryAddress(value.AsUTF8().c_str());}
+	// The port of the NAT punchthrough facilitator.
+	CUSTOM_PROP static int natFacilitatorPort { return GetNetworkManager().GetFacilitatorAddress().port;} {
+	#ifdef _XBOX	// mircea@XBOX: for some reason, the xbox compiler chokes on the "simple" assign
+		SystemAddress& sa = GetNetworkManager().GetFacilitatorAddress(false); sa.port = value;
+	#else
+		GetNetworkManager().GetFacilitatorAddress(false).port = value;
+	#endif
+}
+
+	// Test this machines network connection.
+	CUSTOM static ConnectionTesterStatus TestConnection(bool forceTest = false) { return GetNetworkManager().TestConnection(false, forceTest); }
+
+	// Test the connecction specifically for NAT punchthrough connectivity.
+	CUSTOM static ConnectionTesterStatus TestConnectionNAT(bool forceTest = false) { return GetNetworkManager().TestConnection(true, forceTest); }
+
+	// The IP address of the connection tester used in Network.TestConnection.
+	CUSTOM_PROP static string connectionTesterIP { return scripting_string_new(GetNetworkManager().GetConnTesterAddress().ToString(false));} { SystemAddress address = GetNetworkManager().GetConnTesterAddress(); address.SetBinaryAddress(value.AsUTF8().c_str()); GetNetworkManager().SetConnTesterAddress(address);}
+	// The port of the connection tester used in Network.TestConnection.
+	CUSTOM_PROP static int connectionTesterPort { return GetNetworkManager().GetConnTesterAddress().port;} { SystemAddress address = GetNetworkManager().GetConnTesterAddress(); address.port = value; GetNetworkManager().SetConnTesterAddress(address);}
+
+	// Check if this machine has a public IP address.
+	CUSTOM static bool HavePublicAddress() { return CheckForPublicAddress(); }
+
+	// Set the maximum amount of connections/players allowed.
+	CUSTOM_PROP static int maxConnections {return GetNetworkManager().GetMaxConnections(); } { GetNetworkManager().SetMaxConnections(value); }
+
+	// The IP address of the proxy server.
+	CUSTOM_PROP static string proxyIP { return scripting_string_new(GetNetworkManager().GetProxyIP());} { GetNetworkManager().SetProxyIP(value);}
+
+	// The port of the proxy server.
+	CUSTOM_PROP static int proxyPort { return GetNetworkManager().GetProxyPort();} { GetNetworkManager().SetProxyPort(value);}
+
+	// Indicate if proxy support is needed, in which case traffic is relayed through the proxy server.
+	CUSTOM_PROP static bool useProxy { return GetNetworkManager().GetUseProxy(); } { GetNetworkManager().SetUseProxy(value); }
+
+	// Set the proxy server password.
+	CUSTOM_PROP static string proxyPassword
+	{
+		return scripting_string_new(GetNetworkManager().GetProxyPassword());
+	}
+	{
+		GetNetworkManager().SetProxyPassword(value);
+	}
+END
+
+// The BitStream class represents seralized variables, packed into a stream.
+CONDITIONAL ENABLE_NETWORK
+CLASS BitStream
+	CSRAW internal IntPtr m_Ptr;
+
+
+	C++RAW
+ #define GET ExtractMonoObjectData<BitstreamPacker*> (self)
+
+	C++RAW
+ #define CHECK_PTR if (ExtractMonoObjectData<BitstreamPacker*> (self) == NULL) Scripting::RaiseNullException("");
+
+	CUSTOM private void Serializeb (ref int value) { CHECK_PTR bool temp = value; GET->Serialize(temp); value = temp; }
+	CUSTOM private void Serializec (ref char value) {
+		// pre-Unity 2.5 serialized .NET chars as single bytes. Let's keep it backwards compatible for now.
+		// on big endian the lower order bits of the 2 byte .NET Char value contains the actual bits we need to send
+		#if UNITY_BIG_ENDIAN
+		char* hack = reinterpret_cast<char*>(&value)+1;
+		#else
+		char* hack = reinterpret_cast<char*>(&value);
+		#endif
+		CHECK_PTR GET->Serialize(*hack);
+	}
+	CUSTOM private void Serializes (ref short value) { CHECK_PTR GET->Serialize(value); }
+	CUSTOM private void Serializei (ref int value) { CHECK_PTR GET->Serialize(reinterpret_cast<SInt32&>(value)); }
+	CUSTOM private void Serializef (ref float value, float maximumDelta) { CHECK_PTR GET->Serialize(value, maximumDelta); }
+	CUSTOM private void Serializeq (ref Quaternion value, float maximumDelta) { CHECK_PTR GET->Serialize(value, maximumDelta); }
+	CUSTOM private void Serializev (ref Vector3 value, float maximumDelta)  { CHECK_PTR GET->Serialize(value, maximumDelta); }
+	CUSTOM private void Serializen (ref NetworkViewID viewID) { CHECK_PTR GET->Serialize(viewID); }
+
+	///*listonly*
+	CSRAW public void Serialize(ref bool value) { int cross = value ? 1 : 0; Serializeb( ref cross ); value = cross == 0 ? false : true; }
+	///*listonly*
+	CSRAW public void Serialize(ref char value) { Serializec( ref value ); }
+	///*listonly*
+	CSRAW public void Serialize(ref short value) { Serializes( ref value); }
+	///*listonly*
+	CSRAW public void Serialize(ref int value) { Serializei( ref value); }
+	///*listonly*
+	CSRAW public void Serialize(ref float value, float maxDelta = 0.00001F) { Serializef( ref value, maxDelta); }
+	///*listonly*
+	CSRAW public void Serialize(ref Quaternion value, float maxDelta = 0.00001F) { Serializeq( ref value, maxDelta); }
+	///*listonly*
+	CSRAW public void Serialize(ref Vector3 value, float maxDelta = 0.00001F) { Serializev( ref value, maxDelta); }
+	///*listonly*
+	CSRAW public void Serialize(ref NetworkPlayer value) { int index = value.index; Serializei( ref index ); value.index = index;}
+	// Serializes different types of variables.
+	CSRAW public void Serialize(ref NetworkViewID viewID) { Serializen(ref viewID); }
+
+	// Is the BitStream currently being read? (RO)
+	CUSTOM_PROP bool isReading { CHECK_PTR return GET->IsReading(); }
+	// Is the BitStream currently being written? (RO)
+	CUSTOM_PROP bool isWriting { CHECK_PTR return GET->IsWriting(); }
+
+	CUSTOM private void Serialize (ref string value)
+	{
+		CHECK_PTR
+		std::string cppValue;
+		if (GET->IsWriting())
+			cppValue = value;
+
+		GET->Serialize(cppValue);
+
+		if (GET->IsReading())
+			value.str = scripting_string_new(cppValue);
+	}
+
+	C++RAW
+ #undef GET
+
+	C++RAW
+ #undef CHECK
+
+END
+
+
+// Attribute for setting up RPC functions.
+CONDITIONAL ENABLE_NETWORK
+CSRAW [AttributeUsage(AttributeTargets.Method, AllowMultiple=true)]
+CLASS RPC : Attribute
+END
+
+// This is the data structure for holding individual host information.
+CONDITIONAL ENABLE_NETWORK
+CSRAW [StructLayout (LayoutKind.Sequential)]
+CLASS HostData
+		CSRAW private int    m_Nat;
+        CSRAW private string m_GameType;
+        CSRAW private string m_GameName;
+        CSRAW private int    m_ConnectedPlayers;
+        CSRAW private int    m_PlayerLimit;
+        CSRAW private string[] m_IP;
+        CSRAW private int    m_Port;
+        CSRAW private int    m_PasswordProtected;
+		CSRAW private string m_Comment;
+		CSRAW private string m_GUID;
+
+	// Does this server require NAT punchthrough?
+
+	CSRAW public bool   useNat   { get { return m_Nat != 0; } set { m_Nat = value ? 1 : 0; } }
+	// The type of the game (like "MyUniqueGameType")
+        CSRAW public string gameType { get { return m_GameType; } set { m_GameType = value; } }
+
+	// The name of the game (like John Doe's Game)
+        CSRAW public string gameName { get { return m_GameName; } set { m_GameName = value; } }
+
+	// Currently connected players
+	CSRAW public int    connectedPlayers { get { return m_ConnectedPlayers; } set { m_ConnectedPlayers = value; } }
+
+	// Maximum players limit
+	CSRAW public int    playerLimit { get { return m_PlayerLimit; } set { m_PlayerLimit = value; } }
+	// Server IP address
+	CSRAW public string[] ip { get { return m_IP; } set { m_IP = value; } }
+
+	// Server port
+	CSRAW public int    port  { get { return m_Port; } set { m_Port = value; } }
+
+	// Does the server require a password?
+	CSRAW public bool   passwordProtected { get { return m_PasswordProtected != 0; } set { m_PasswordProtected = value ? 1 : 0; } }
+
+	// A miscellaneous comment (can hold data)
+	CSRAW public string comment { get { return m_Comment; } set { m_Comment = value; } }
+
+	// The GUID of the host, needed when connecting with NAT punchthrough.
+	CSRAW public string guid { get { return m_GUID; } set { m_GUID = value; } }
+END
+
+C++RAW
+
+struct HostDataCpp
+{
+		int			useNat;
+        MonoString* gameType;
+        MonoString* gameName;
+        int			connectedPlayers;
+        int			playerLimit;
+        MonoArray*	IP;
+        int			port;
+        int			passwordProtected;
+		MonoString* comment;
+		MonoString* guid;
+};
+
+
+// The Master Server is used to make matchmaking between servers and clients easy.
+CONDITIONAL ENABLE_NETWORK
+CLASS MasterServer
+
+	// Called on clients or servers when there is a problem connecting to the master server.
+	CSNONE void OnFailedToConnectToMasterServer (NetworkConnectionError error);
+
+	// Called on clients or servers when reporting events from the MasterServer.
+	CSNONE void OnMasterServerEvent (MasterServerEvent msEvent);
+
+	// The IP address of the master server.
+	CUSTOM_PROP static string ipAddress { return scripting_string_new(GetMasterServerInterface().GetIPAddress());} { GetMasterServerInterface().SetIPAddress(value);}
+
+	// The connection port of the master server.
+	CUSTOM_PROP static int port { return GetMasterServerInterface().GetPort();} { GetMasterServerInterface().SetPort(value);}
+
+	// Request a host list from the master server.
+	CUSTOM static void RequestHostList(string gameTypeName) { GetMasterServerInterface().QueryHostList(gameTypeName); }
+
+	// Check for the latest host list received by using MasterServer.RequestHostList.
+	CUSTOM static HostData[] PollHostList()
+	{
+		const std::vector<HostData>& data = GetMasterServerInterface().PollHostList();
+		MonoClass* hostType = GetMonoManager ().GetCommonClasses ().hostData;
+
+		//if (data == NULL) return NULL;
+
+		//count = 0;
+
+		MonoArray* array = mono_array_new (mono_domain_get (), hostType, data.size());
+		for (int i = 0; i < data.size(); i++)
+		{
+				MonoObject* element = mono_object_new(mono_domain_get(), hostType);
+				GetMonoArrayElement<MonoObject*> (array, i) = element;
+				HostDataCpp& dst = ExtractMonoObjectData<HostDataCpp> (element);
+				HostData src = data[i];
+
+				dst.useNat = src.useNat;
+				dst.gameType = scripting_string_new(src.gameType);
+				dst.gameName = scripting_string_new(src.gameName);
+				dst.connectedPlayers = src.connectedPlayers;
+				dst.playerLimit = src.playerLimit;
+				MonoArray* ips = mono_array_new (mono_domain_get (), mono_get_string_class(), src.IP.size());
+				for (int i = 0; i < src.IP.size(); i++)
+				{
+					GetMonoArrayElement<MonoString*> (ips, i) = scripting_string_new(src.IP[i]);
+				}
+				dst.IP = ips;
+				dst.port = src.port;
+				dst.passwordProtected = src.passwordProtected;
+				dst.comment = scripting_string_new(src.comment);
+				dst.guid = scripting_string_new(src.guid);
+		}
+
+		return array;
+	}
+
+	// Register this server on the master server.
+	CUSTOM static void RegisterHost(string gameTypeName, string gameName, string comment = "") { GetMasterServerInterface().RegisterHost(gameTypeName, gameName, comment); }
+
+	// Unregister this server from the master server.
+	CUSTOM static void UnregisterHost() { GetMasterServerInterface().UnregisterHost(); }
+
+	// Clear the host list which was received by MasterServer.PollHostList.
+	CUSTOM static void ClearHostList() { GetMasterServerInterface().ClearHostList(); }
+
+	// Set the minimum update rate for master server host information update.
+	CUSTOM_PROP static int updateRate { return GetMasterServerInterface().GetUpdateRate();} { GetMasterServerInterface().SetUpdateRate(value);}
+
+	// Report this machine as a dedicated server.
+	CUSTOM_PROP static bool dedicatedServer { return GetMasterServerInterface().GetDedicatedServer(); } { GetMasterServerInterface().SetDedicatedServer(value); }
+END
+
+// This data structure contains information on a message just received from the network.
+CONDITIONAL ENABLE_NETWORK
+STRUCT NetworkMessageInfo
+	CSRAW
+	double        m_TimeStamp;
+	NetworkPlayer m_Sender;
+	NetworkViewID m_ViewID;
+
+	// The time stamp when the Message was sent in seconds.
+	CSRAW public double timestamp { get { return m_TimeStamp; }  }
+
+	// The player who sent this network message (owner)
+	CSRAW public NetworkPlayer sender { get { return m_Sender; }  }
+
+	// The [[NetworkView]] who sent this message
+	CSRAW public NetworkView networkView
+	{
+		get
+		{
+			if (m_ViewID == NetworkViewID.unassigned)
+			{
+				Debug.LogError("No NetworkView is assigned to this NetworkMessageInfo object. Note that this is expected in OnNetworkInstantiate().");
+				return NullNetworkView();
+			}
+			return NetworkView.Find(m_ViewID);
+		}
+	}
+
+	CUSTOM internal NetworkView NullNetworkView() { return Scripting::ScriptingObjectNULL (ScriptingClassFor (NetworkView)); }
+
+END
+
+
+CSRAW }
+#endif
+