unity3d
नेटवर्किंग

टिप्पणियों

एक सर्वर, एक क्लाइंट बनाना, और एक संदेश भेजना।

एकता नेटवर्किंग निम्न स्तर के कार्यान्वयन से नेटवर्क संचार को संभालने के लिए उच्च स्तरीय एपीआई (HLA) प्रदान करता है।

इस उदाहरण में हम देखेंगे कि एक सर्वर कैसे बनाया जाए जो एक या कई क्लाइंट्स के साथ संवाद कर सके।

एचएलए हमें एक वर्ग को आसानी से अनुक्रमित करने और नेटवर्क पर इस वर्ग की वस्तुओं को भेजने की अनुमति देता है।

हम जिस क्लास को क्रमबद्ध करने के लिए उपयोग कर रहे हैं

इस वर्ग को MessageBase से विरासत में मिला है, इस उदाहरण में हम इस वर्ग के अंदर एक स्ट्रिंग भेजेंगे।

using System;
using UnityEngine.Networking;

public class MyNetworkMessage : MessageBase
{
    public string message;
}

एक सर्वर बनाना

हम एक सर्वर बनाते हैं जो पोर्ट 9999 को सुनता है, अधिकतम 10 कनेक्शन की अनुमति देता है, और हमारे कस्टम वर्ग के नेटवर्क से ऑब्जेक्ट्स को पढ़ता है।

HLA एक आईडी में विभिन्न प्रकार के संदेश को जोड़ता है। एकता नेटवर्किंग से MsgType वर्ग में डिफ़ॉल्ट संदेश प्रकार परिभाषित होते हैं। उदाहरण के लिए कनेक्ट प्रकार में आईडी 32 है और इसे सर्वर में उस समय कहा जाता है जब कोई क्लाइंट इसे कनेक्ट करता है, या क्लाइंट में जब यह सर्वर से कनेक्ट होता है। आप विभिन्न प्रकार के संदेश को प्रबंधित करने के लिए हैंडलर पंजीकृत कर सकते हैं।

जब आप एक कस्टम क्लास भेज रहे होते हैं, तो हमारे मामले की तरह, हम एक हैंडलर को उस नई आईडी से परिभाषित करते हैं, जिसे हम नेटवर्क पर भेज रहे हैं।

using UnityEngine;
using System.Collections;
using UnityEngine.Networking;

public class Server : MonoBehaviour {

    int port = 9999;
    int maxConnections = 10;

    // The id we use to identify our messages and register the handler
    short messageID = 1000;

    // Use this for initialization
    void Start () {
        // Usually the server doesn't need to draw anything on the screen
        Application.runInBackground = true;
        CreateServer();
    }    

    void CreateServer() {
        // Register handlers for the types of messages we can receive
        RegisterHandlers ();

        var config = new ConnectionConfig ();
        // There are different types of channels you can use, check the official documentation
        config.AddChannel (QosType.ReliableFragmented);
        config.AddChannel (QosType.UnreliableFragmented);

        var ht = new HostTopology (config, maxConnections);

        if (!NetworkServer.Configure (ht)) {
            Debug.Log ("No server created, error on the configuration definition");
            return;
        } else {
            // Start listening on the defined port
            if(NetworkServer.Listen (port))
                Debug.Log ("Server created, listening on port: " + port);   
            else
                Debug.Log ("No server created, could not listen to the port: " + port);    
        }
    }

    void OnApplicationQuit() {
        NetworkServer.Shutdown ();
    }

    private void RegisterHandlers () {
        // Unity have different Messages types defined in MsgType
        NetworkServer.RegisterHandler (MsgType.Connect, OnClientConnected);
        NetworkServer.RegisterHandler (MsgType.Disconnect, OnClientDisconnected);

        // Our message use his own message type.
        NetworkServer.RegisterHandler (messageID, OnMessageReceived);
    }

    private void RegisterHandler(short t, NetworkMessageDelegate handler) {
        NetworkServer.RegisterHandler (t, handler);
    }

    void OnClientConnected(NetworkMessage netMessage)
    {
        // Do stuff when a client connects to this server

        // Send a thank you message to the client that just connected
        MyNetworkMessage messageContainer = new MyNetworkMessage();
        messageContainer.message = "Thanks for joining!";

        // This sends a message to a specific client, using the connectionId
        NetworkServer.SendToClient(netMessage.conn.connectionId,messageID,messageContainer);

        // Send a message to all the clients connected
        messageContainer = new MyNetworkMessage();
        messageContainer.message = "A new player has conencted to the server";

        // Broadcast a message a to everyone connected
        NetworkServer.SendToAll(messageID,messageContainer);
    }

    void OnClientDisconnected(NetworkMessage netMessage)
    {
        // Do stuff when a client dissconnects
    }

    void OnMessageReceived(NetworkMessage netMessage)
    {
        // You can send any object that inherence from MessageBase
        // The client and server can be on different projects, as long as the MyNetworkMessage or the class you are using have the same implementation on both projects
        // The first thing we do is deserialize the message to our custom type
        var objectMessage = netMessage.ReadMessage<MyNetworkMessage>();
        Debug.Log("Message received: " + objectMessage.message);

    }
}

ग्राहक

अब हम एक ग्राहक बनाते हैं

using System;
using UnityEngine;
using UnityEngine.Networking;


public class Client : MonoBehaviour
{
    int port = 9999;
    string ip = "localhost";

    // The id we use to identify our messages and register the handler
    short messageID = 1000;

    // The network client
    NetworkClient client;

    public Client ()
    {
        CreateClient();
    }

    void CreateClient()
    {
        var config = new ConnectionConfig ();

        // Config the Channels we will use
        config.AddChannel (QosType.ReliableFragmented);
        config.AddChannel (QosType.UnreliableFragmented);

        // Create the client ant attach the configuration
        client = new NetworkClient ();
        client.Configure (config,1);

        // Register the handlers for the different network messages
        RegisterHandlers();

        // Connect to the server
        client.Connect (ip, port);
    }

    // Register the handlers for the different message types
    void RegisterHandlers () {
    
        // Unity have different Messages types defined in MsgType
        client.RegisterHandler (messageID, OnMessageReceived);
        client.RegisterHandler(MsgType.Connect, OnConnected);
        client.RegisterHandler(MsgType.Disconnect, OnDisconnected);
    }

    void OnConnected(NetworkMessage message) {        
        // Do stuff when connected to the server

        MyNetworkMessage messageContainer = new MyNetworkMessage();
        messageContainer.message = "Hello server!";

        // Say hi to the server when connected
        client.Send(messageID,messageContainer);
    }

    void OnDisconnected(NetworkMessage message) {
        // Do stuff when disconnected to the server
    }

    // Message received from the server
    void OnMessageReceived(NetworkMessage netMessage)
    {
        // You can send any object that inherence from MessageBase
        // The client and server can be on different projects, as long as the MyNetworkMessage or the class you are using have the same implementation on both projects
        // The first thing we do is deserialize the message to our custom type
        var objectMessage = netMessage.ReadMessage<MyNetworkMessage>();

        Debug.Log("Message received: " + objectMessage.message);
    }
}