diff options
Diffstat (limited to 'Runtime/Export/Networking.txt')
| -rw-r--r-- | Runtime/Export/Networking.txt | 921 |
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 + |