Unity3D मल्टीप्लेयर गेम बेसिक्स

हाय, हब्बर!

मैं, आप में से कई की तरह, मल्टीप्लेयर गेम्स का बहुत बड़ा प्रशंसक हूं। उनमें, मैं मुख्य रूप से प्रतिस्पर्धा की भावना और सुधार प्राप्त करने की क्षमता से आकर्षित हूं, उपलब्धियों को जमा करना। और इस प्रकार के अधिक से अधिक खेलों को प्रकाशित करने का बहुत ही विचार कार्रवाई का संकेत दे रहा है।
हाल ही में, मैंने खुद अपना प्रोजेक्ट विकसित करना शुरू किया। और जब से मुझे इस विषय पर कोई लेख नहीं मिला है, हबराब्रिज पर, मैंने यूनिटी 3 डी इंजन पर एक मल्टीप्लेयर गेम लिखने में अपने अनुभव को साझा करने का निर्णय लिया। मैं नेटवर्क और नेटवर्क व्यू घटकों , आरपीसी विशेषता और अंतर्निहित ईवेंट विधियों के बारे में भी बात करना चाहता हूं। लेख के अंत में, खेल का एक उदाहरण और निश्चित रूप से, एकता के लिए परियोजना दी गई है। इसलिए ...

नेटवर्क क्लास

क्लाइंट-सर्वर कनेक्शन को व्यवस्थित करने के लिए इस वर्ग की आवश्यकता होती है। मुख्य विशेषताएं: एक सर्वर बनाना, एक सर्वर से कनेक्ट करना, एक प्रीफैब का नेटवर्क उदाहरण बनाना।

मुख्य विधियाँ:

Network.Connect (स्ट्रिंग होस्ट, इंट रिमोटपोर्ट, स्ट्रिंग पासवर्ड = "") - होस्ट सर्वर को रिमोटपोर्ट पोर्ट और पासवर्ड पासवर्ड से जोड़ता है। विधि NetworkConnectionError गणन लौटाता है।

Network.InitializeServer (int कनेक्शन, int ListenPort, bool useNat) - कनेक्शन कनेक्शन की अधिकतम अनुमत संख्या के साथ एक सर्वर बनाता है; ListenPort इनबाउंड पोर्ट, साथ ही उपयोगनैट : NAT का उपयोग करें या नहीं। NetworkConnectionError गणना को भी लौटाता है।

Network.InitializeSecurity () - धोखा देने से बचाने के लिए Network.InitializeServer () से पहले कॉल किया जाता है। आधिकारिक दस्तावेज में विवरण। ग्राहक को मत बुलाओ!

Network.Instantiate (ऑब्जेक्ट प्रीफ़ैब, वेक्टर 3 स्थिति, क्वाटरन रोटेशन, इंट ग्रुप) - रोटेशन रोटेशन और समूह समूह के साथ स्थिति की स्थिति में नेटवर्क पर प्रीफ़ैब प्रीफ़ैब का एक उदाहरण बनाता है। संपूर्ण बनाई गई वस्तु लौटाता है जिसके साथ निर्माण के बाद अतिरिक्त क्रियाएं की जा सकती हैं। विवरण बाद में लेख में हैं।

मुख्य गुण:

bool Network.isClient और bool Network.isServer - निर्धारित करें कि क्या आपका गेम सर्वर या क्लाइंट है। यदि सर्वर बनाया नहीं गया था या सर्वर से कोई संबंध नहीं था, तो दोनों गुण झूठे हैं।

string Network.incomingPassword - संपत्ति आने वाले कनेक्शन के लिए पासवर्ड सेट करती है।

NetworkPlayer Network.player - स्थानीय NetworkPlayer प्लेयर का एक उदाहरण देता है।

NetworkPeerType Network.peerType - वर्तमान कनेक्शन स्थिति लौटाता है: डिस्कनेक्ट किया गया (डिस्कनेक्ट किया गया), सर्वर (सर्वर के रूप में चल रहा है), क्लाइंट (सर्वर से जुड़ा हुआ), कनेक्टिंग (प्रयास, कनेक्शन के दौरान)।

NetworkPlayer [] Network.connections - सभी जुड़े हुए खिलाड़ियों को लौटाता है। क्लाइंट पर केवल सर्वर प्लेयर देता है।

मुख्य कार्यक्रम (मोनोबेहेवियर से विरासत में मिले):

OnConnectedToServer () - क्लाइंट से उस समय कॉल किया जाता है जब सर्वर से कनेक्शन सफल होता है।

OnDisconnectedFromServer (NetworkDisconnection जानकारी) - जब क्लाइंट से डिस्कनेक्ट हो रहा होता है और नेटवर्क पर सर्वर पर नेटवर्कडिसकनेक्ट () कनेक्शन पूरा होने पर क्लाइंट को कॉल किया जाता है। जानकारी में वियोग का कारण होता है: लॉस्टकनेक्शन (कनेक्शन का खोना ) और डिस्कनेक्टेड (सफल वियोग पर)।

OnFailedToConnect (NetworkConnectionError error) - कनेक्शन त्रुटि होने पर क्लाइंट को कॉल किया जाता है । त्रुटि में NetworkConnectionError प्रकार की त्रुटि है।

OnNetworkInstantiate (NetworkMessageInfo जानकारी) - क्लाइंट और सर्वर पर कॉल किया जाता है यदि Network.Instantiate () विधि का उपयोग करके एक नया उदाहरण बनाया गया था। प्रकार NetworkMessageInfo की जानकारी शामिल है।

OnPlayerConnected (NetworkPlayer player) - क्लाइंट को सफलतापूर्वक कनेक्ट होने पर सर्वर पर कॉल किया जाता है और इसमें NetworkPlayer प्रकार का खिलाड़ी होता है।

OnPlayerDisconnected (NetworkPlayer player) - क्लाइंट के डिस्कनेक्ट होने पर सर्वर पर कॉल किया जाता है और इसमें NetworkPlayer प्रकार का प्लेयर होता है।

OnServerInitialized () - सर्वर सफलतापूर्वक बनने के बाद सर्वर पर कॉल किया जाता है।

OnSerializeNetworkView (BitStream स्ट्रीम, NetworkMessageInfo जानकारी) - एक नेटवर्क के साथ एक घटक को सिंक्रनाइज़ करने के लिए एक महत्वपूर्ण घटना। विवरण बाद में लेख में हैं।

कक्षा का नेटवोकव्यू

यह वर्ग एकता के लिए एक घटक के रूप में भी मौजूद है, और इसे नेटवर्क पर घटकों को सिंक्रनाइज़ करने और आरपीसी को कॉल करने के लिए डिज़ाइन किया गया है।
इसमें निम्नलिखित NetworkStateSynchronization सिंक्रोनाइज़ेशन गुण हैं:

• बंद - वस्तु को सिंक्रनाइज़ नहीं करता है, लेकिन आपको दूरस्थ प्रक्रियाओं को कॉल करने की अनुमति देता है।
• TrustableDeltaCompressed - एक समय में एक पैकेट पहुंचाता है और यह देखने के लिए जांच करता है कि क्या पैकेट वितरित किया गया है ( जैसे कि टीसीपी )।
• अविश्वसनीय - डिलीवरी की गारंटी के बिना तेजी से पैकेट भेजने का काम करता है ( जैसे यूडीपी )।

मुख्य विधियाँ:

networkView.RPC (स्ट्रिंग नाम, RPCMode मोड, params ऑब्जेक्ट [] args) - दूरस्थ प्रक्रिया नाम को कॉल करता है, मोड प्राप्तकर्ताओं को निर्धारित करता है, प्रक्रिया के लिए पास करने के लिए तर्क - तर्क देता है।

networkView.RPC (string name, NetworkPlayer target, params object [] args) - पिछली विधि के समान, हालांकि, यह एक विशिष्ट NetworkPlayer प्लेयर को भेजता है।

मुख्य गुण:

bool networkView.isMine - एक संपत्ति जो यह निर्धारित करती है कि ऑब्जेक्ट स्थानीय है या नहीं। अक्सर किसी वस्तु के मालिक को सत्यापित करने के लिए उपयोग किया जाता है।

घटक networkView.observed - घटक जो सिंक्रनाइज़ किया जाएगा। यदि यह एक स्क्रिप्ट है, तो इसमें ऊपर उल्लेखित OnSerializeNetworkView (BitStream स्ट्रीम, NetworkMessageInfo जानकारी) विधि होनी चाहिए।

NetworkPlayer networkView.owner - एक संपत्ति जो वस्तु का मालिक लौटाता है।

NetworkStateSynchronization networkView.stateSynchronization - सिंक्रोनाइज़ेशन का प्रकार: बंद , रिलाएबलडेलकंप्रेस्ड , अविश्वसनीय ।

NetworkViewID networkView.viewID NetworkView के लिए नेटवर्क पर विशिष्ट पहचानकर्ता है।

RPC विशेषता

विकिपीडिया के अनुसार, आरपीसी प्रौद्योगिकियों का एक वर्ग है जो कंप्यूटर प्रोग्राम को किसी अन्य पता स्थान (आमतौर पर दूरस्थ कंप्यूटर पर) में फ़ंक्शन या प्रक्रियाओं को कॉल करने की अनुमति देता है।
विशेषता का उपयोग नेटवर्क से एक विधि को निर्दिष्ट करने के लिए किया जाता है। इसके कामकाज के लिए NetworkView घटक जोड़ना आवश्यक है।

OnSerializeNetworkView विधि (BitStream स्ट्रीम, NetworkMessageInfo जानकारी)

इस विधि का उपयोग नेटवर्क पर एक घटक को सिंक्रनाइज़ करने के लिए किया जाता है। जब भी डेटा प्राप्त होता है या नेटवर्क पर भेजा जाता है तो इसे कहा जाता है।
यहाँ डेटा के प्रकार हैं जिन्हें Serialize पद्धति का उपयोग करके प्राप्त / भेजा जा सकता है : bool, char, short, int, float, Quaternion, Vector3, NetworkPlayer, NetworkViewID।
यह जांचने के लिए कि रिसेप्शन या ट्रांसमिशन प्रगति पर है, आइसरडिंग या आइसग्रीटिंग गुणों का उपयोग किया जाता है।

मैं उपयोग का एक उदाहरण देता हूं:

void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info) { Vector3 syncPosition = Vector3.zero; //       if (stream.isWriting) { syncPosition = rigidbody.position; //    stream.Serialize(ref syncPosition); //    } else { stream.Serialize(ref syncPosition); //     rigidbody.position = syncPosition; //     . } } 

यह उदाहरण आदर्श नहीं है, क्योंकि इसके संचालन के दौरान हमारी वस्तुएँ "चिकोटी" करेंगी। इससे बचने के लिए, आपको प्रक्षेप का उपयोग करने की आवश्यकता है। अधिक विवरण बाद में लेख में हैं।

प्रक्षेप

प्रक्षेप का सार यह है कि नेटवर्क से स्थिति को पढ़ने के बीच, हम स्क्रीन अपडेट के दौरान Lerp फ़ंक्शन के माध्यम से अपनी वस्तु को आसानी से स्थानांतरित करते हैं।
हम वर्तमान स्थिति को शुरुआत और सिंक्रनाइज़ के रूप में लेते हैं - अंत के रूप में, और जैसे ही फ्रेम अपडेट होते हैं, हम अपनी वस्तु को स्थानांतरित करते हैं।

नेटवर्क सिंक्रनाइज़ेशन को अनुकूलित करने के तरीकों के बारे में अधिक जानकारी के लिए, डेवलपर वेबसाइट देखें: वाल्व डेवलपर समुदाय - स्रोत मल्टीप्लेयर नेटवर्किंग

मल्टीप्लेयर गेम उदाहरण

इसलिए, मूल बातों का एक विचार होने पर, आप एक छोटे से मल्टीप्लेयर गेम लिखना शुरू कर सकते हैं। उदाहरण के लिए, मैं NetworkView का उपयोग करने के लिए विभिन्न तरीकों का उपयोग करता हूं । आपको बस अपने लिए सबसे सुविधाजनक तरीका चुनना होगा।

हम ServerSide.cs स्क्रिप्ट बनाते हैं और वहां निम्नलिखित लिखते हैं:

 using UnityEngine; using System.Collections; [RequireComponent( typeof( NetworkView ) )] //  Unity  ,     NetworkView.   NetworkStateSynchronization   Off. public class ServerSide : MonoBehaviour { private int playerCount = 0; //     public int PlayersCount { get { return playerCount; } } //           void OnServerInitialized() { SendMessage( "SpawnPlayer", "Player Server" ); //     } void OnPlayerConnected( NetworkPlayer player ) { ++playerCount; //          networkView.RPC( "SpawnPlayer", player, "Player " + playerCount.ToString() ); //        } void OnPlayerDisconnected( NetworkPlayer player ) { --playerCount; //    Network.RemoveRPCs( player ); //     Network.DestroyPlayerObjects( player ); //     } } 

अब क्लाइंट स्क्रिप्ट बनाएँ ClientSide.cs :

 using UnityEngine; using System.Collections; [RequireComponent( typeof( NetworkView ) )] //  Unity  ,     NetworkView.   NetworkStateSynchronization   Off. public class ClientSide : MonoBehaviour { public GameObject playerPrefab; //  ,       public Vector2 spawnArea = new Vector2( 8.0f, 8.0f ); //   private Vector3 RandomPosition { //      get { return transform.position + transform.right * ( Random.Range( 0.0f, spawnArea.x ) - spawnArea.x * 0.5f ) + transform.forward * ( Random.Range( 0.0f, spawnArea.y ) - spawnArea.y * 0.5f ); } } [RPC] //  Unity  ,        private void SpawnPlayer( string playerName ) { Vector3 position = RandomPosition; //      GameObject newPlayer = Network.Instantiate( playerPrefab, position, Quaternion.LookRotation( transform.position - position, Vector3.up ), 0 ) as GameObject; //      newPlayer.BroadcastMessage( "SetPlayerName", playerName ); //     (     ) } void OnDisconnectedFromServer( NetworkDisconnection info ) { Network.DestroyPlayerObjects( Network.player ); //    } } 

इस प्रकार, क्लाइंट और सर्वर लॉजिक हैं, अब आपको इसके लिए MainMenu.cs को प्रबंधित करने की आवश्यकता है:

 using UnityEngine; using System.Collections; public class MultiplayerMenu : MonoBehaviour { const int NETWORK_PORT = 4585; //   const int MAX_CONNECTIONS = 20; //     const bool USE_NAT = false; //  NAT? private string remoteServer = "127.0.0.1"; //   (  localhost) void OnGUI() { if ( Network.peerType == NetworkPeerType.Disconnected ) { //    if ( GUILayout.Button( "Start Server" ) ) { //  « » Network.InitializeSecurity(); //   Network.InitializeServer( MAX_CONNECTIONS, NETWORK_PORT, USE_NAT ); //   } GUILayout.Space(30f); //  remoteServer = GUILayout.TextField( remoteServer ); //    if ( GUILayout.Button( "Connect to server" ) ) { //  «» Network.Connect( remoteServer, NETWORK_PORT ); //    } } else if ( Network.peerType == NetworkPeerType.Connecting ) { //    GUILayout.Label( "Trying to connect to server" ); //   } else { //    ( NetworkPeerType.Server, NetworkPeerType.Client) if ( GUILayout.Button( "Disconnect" ) ) { //  «» Network.Disconnect(); //        } } } void OnFailedToConnect( NetworkConnectionError error ) { Debug.Log( "Failed to connect: " + error.ToString() ); //         } void OnDisconnectedFromServer( NetworkDisconnection info ) { if ( Network.isClient ) { Debug.Log( "Disconnected from server: " + info.ToString() ); //        } else { Debug.Log( "Connections closed" ); //      Network.Disconnect() } } void OnConnectedToServer() { Debug.Log( "Connected to server" ); //        } } 

नेटवर्क प्रबंधन बनाया गया। इसके बाद, प्लेयर नियंत्रण PlayerControls.cs लिखें । इस उदाहरण में, मैं NetworkView घटक का उपयोग करने के लिए एक अलग तरीके का उपयोग करता हूं :

 using UnityEngine; using System.Collections; [RequireComponent( typeof( Rigidbody ) )] //      Rigidbody public class PlayerControls : MonoBehaviour { /*   */ private float lastSynchronizationTime; //    private float syncDelay = 0f; //        private float syncTime = 0f; //   private Vector3 syncStartPosition = Vector3.zero; //   private Vector3 syncEndPosition = Vector3.zero; //    private Quaternion syncStartRotation = Quaternion.identity; //    private Quaternion syncEndRotation = Quaternion.identity; //    private NetworkView netView; //  NetworkView private string myName = ""; //   ( ,    ) public string MyName { get { return myName; } } //     public float power = 20f; void Awake () { netView = gameObject.AddComponent( typeof( NetworkView ) ) as NetworkView; //   NetworkView    netView.viewID = Network.AllocateViewID(); //      netView.observed = this; //    ()   netView.stateSynchronization = NetworkStateSynchronization.Unreliable; //       ,     lastSynchronizationTime = Time.time; //    } void FixedUpdate () { if ( netView.isMine ) { //    ,    ,       float inputX = Input.GetAxis( "Horizontal" ); float inputY = Input.GetAxis( "Vertical" ); if ( inputX != 0.0f ) { rigidbody.AddTorque( Vector3.forward * -inputX * power, ForceMode.Impulse ); } if ( inputY != 0.0f ) { rigidbody.AddTorque( Vector3.right * inputY * power, ForceMode.Impulse ); } } else { syncTime += Time.fixedDeltaTime; rigidbody.position = Vector3.Lerp( syncStartPosition, syncEndPosition, syncTime / syncDelay ); //   rigidbody.rotation = Quaternion.Lerp( syncStartRotation, syncEndRotation, syncTime / syncDelay ); //   } } void OnSerializeNetworkView( BitStream stream, NetworkMessageInfo info ) { Vector3 syncPosition = Vector3.zero; //    Vector3 syncVelocity = Vector3.zero; //     Quaternion syncRotation = Quaternion.identity; //    if ( stream.isWriting ) { //    ,       syncPosition = rigidbody.position; stream.Serialize( ref syncPosition ); syncPosition = rigidbody.velocity; stream.Serialize( ref syncVelocity ); syncRotation = rigidbody.rotation; stream.Serialize( ref syncRotation ); } else { //       stream.Serialize( ref syncPosition ); stream.Serialize( ref syncVelocity ); stream.Serialize( ref syncRotation ); syncTime = 0f; //    syncDelay = Time.time - lastSynchronizationTime; //     lastSynchronizationTime = Time.time; //      syncEndPosition = syncPosition + syncVelocity * syncDelay; //  ,     syncStartPosition = rigidbody.position; //      syncEndRotation = syncRotation; //   syncStartRotation = rigidbody.rotation; //   } } void SetPlayerName( string name ) { myName = name; //    } } 

मुझे पता है कि सिंक्रनाइज़ेशन और नियंत्रण अलग होना चाहिए, लेकिन एक उदाहरण के रूप में, मैंने उन्हें संयोजित करने का फैसला किया। जैसा कि आपने देखा है, यहाँ NetworkView को स्क्रिप्ट इनिशियलाइज़ेशन के दौरान बनाया गया है। मेरी राय में, यह एक संभावित "जोड़ने के लिए भूल गया" (निश्चित रूप से, यदि आवश्यक हो तो आवश्यक नहीं है) के खिलाफ रक्षा करने के लिए एक अधिक सुविधाजनक तरीका है (टाइपोफ़ (रिगिडो)) नहीं लिखा गया है), और निरीक्षक में ऑब्जेक्ट पर घटकों की संख्या भी कम कर देता है।
उदाहरण के लिए, मेरे पास एक मामला था: जब, पहली नज़र में, सब कुछ सही ढंग से किया गया था, लेकिन मेरी स्क्रिप्ट ने हस्तक्षेप नहीं किया, और सिंक्रनाइज़ेशन में मेरे सभी कार्यों को अनदेखा कर दिया। तो त्रुटि यह निकली कि अवलोकित करना मेरी लिपि नहीं थी, बल्कि वस्तु रूपांतरित हो गई।

तो, अब हमारे पास एक मिनी-गेम लिखने के लिए सभी आवश्यक स्क्रिप्ट हैं।
एक खाली ऑब्जेक्ट बनाएं और उस पर मल्टीप्लेयर मीनू , सर्वरसाइड , क्लाइंटसाइड स्क्रिप्ट असाइन करें।
एक विमान बनाएं और इसे थोड़ा कम करें।
एक खिलाड़ी प्रीफ़ैब बनाएं (मेरे उदाहरण में, ये गेंद होंगे)। हम गोले ऑब्जेक्ट बनाते हैं, इसे करने के लिए प्लेयरकंट्रोल स्क्रिप्ट असाइन करें और इसे प्रीफैब में जोड़ें। प्रीफैब प्लेयर प्रीफैब क्षेत्र में क्लाइंटसाइड पर खींचें।
यह सब है, परियोजना को संकलित करें (खिलाड़ी की सेटिंग में पृष्ठभूमि में रन को सक्षम करने के लिए मत भूलना) और इसे कई बार चलाएं। किसी एक विंडो में, सर्वर पर, बाकी - क्लाइंट पर क्लिक करें और परिणाम देखें।

प्रोजेक्ट का लिंक ।
* परियोजना में तार्किक त्रुटियां हो सकती हैं, लेकिन वे इस लेख के सार को प्रभावित नहीं करते हैं।

आपका ध्यान देने के लिए आप सभी का धन्यवाद!
मैं आपको मल्टीप्लेयर गेम बनाने में सफलता की कामना करता हूं!