UE4 | मल्टीप्लेयर के लिए उपकरण # 5 | सर्वर और क्लाइंट के बीच सूचना हस्तांतरण

इस लेख में हम C ++ में लागू किए गए अवास्तविक इंजन 4 में सर्वर और क्लाइंट के बीच डेटा ट्रांसफर पर विचार करेंगे। बहुत शुरुआत में, एक ऐसे व्यक्ति के लिए, जिसके पास एक विशेष शिक्षा नहीं है, यह प्रतीत होता है कि कुछ गलत तरीके से जटिल है। बड़ी संख्या में उदाहरण और विश्लेषण के बावजूद, इस प्रक्रिया की पूरी तस्वीर को एक साथ रखना मेरे लिए व्यक्तिगत रूप से बहुत मुश्किल था। लेकिन, जब पढ़ने और परीक्षण के माध्यम से प्राप्त जानकारी की महत्वपूर्ण मात्रा तक पहुँच गया, तो यह समझ में आया कि यह सब कैसे काम करता है।

सबसे पहले, आपको स्पष्ट रूप से यह समझने की आवश्यकता है कि खेल में सभी वस्तुओं (दुर्लभ अपवादों के साथ) की कई प्रतियां हो सकती हैं। मूल ऑब्जेक्ट सर्वर पर स्थित है। मूल हमेशा है। प्रतियां ग्राहकों पर मौजूद हो सकती हैं, लेकिन बिल्कुल नहीं, यानी। वे नहीं हो सकते हैं सर्वर पर सभी महत्वपूर्ण घटनाएं होती हैं, और यह वह है जो यह तय करता है कि इसके बारे में कौन जानता है और कौन नहीं।

अब जब गेम के मूल नियम स्पष्ट हैं, तो हम इस पर विचार कर सकते हैं कि सर्वर और क्लाइंट के बीच सूचना प्रसारित करने के लिए कौन से विकल्प हमारे पास उपलब्ध हैं। मैं 3 तरीके जानता हूं, लेकिन हम केवल पहले दो पर विचार करेंगे, क्योंकि तीसरा आपको कुछ भी और कहीं भी स्थानांतरित करने की अनुमति देता है, और केवल तभी लागू होता है जब आप पहले दो की सीमाओं से सीमित होते हैं।

1. प्रतिकृति (प्रतिकृति)।
2. RPC ( दूरस्थ प्रक्रिया कॉल )।
3. टीसीपी।
   

   ---

   
   

   प्रतिकृति

बिना शर्त स्वीकार करने की पहली बात:

सबसे पहले, वस्तु प्रतिकृति पर विचार करें।
कंस्ट्रक्टर में, हम लिखते हैं:

bReplicates = true; 

यदि हम आंदोलन को दोहराना चाहते हैं:

 bReplicateMovement = true; 

यदि आपको जुड़े घटक को दोहराने की आवश्यकता है:

 Component->SetReplicates(true); 

इसका पूरा विवरण यहां पाया जा सकता है ।

चर प्रतिकृति के साथ, चीजें थोड़ी अधिक दिलचस्प हैं।
चलिए .h हेडर फ़ाइल से शुरुआत करते हैं।
आप बस चर को दोहरा सकते हैं:

 UPROPERTY(Replicated) bool bMyReplicatedVariable; 

या आप क्लाइंट फ़ंक्शन पर कुछ फ़ंक्शन चला सकते हैं यदि चर दोहराया गया है। इससे कोई फर्क नहीं पड़ता कि चर क्या मूल्य लेता है। इसके परिवर्तन का तथ्य महत्वपूर्ण है।

 UPROPERTY(ReplicatedUsing = OnRep_MySomeFunction) TArray<float> MyReplicatedArray; UFUNCTION() void OnRep_MySomeFunction(); 

फ़ंक्शन चलाना सर्वर से कमांड भेजने का एक तरीका है। यह जानना बहुत महत्वपूर्ण है कि सरणियों की प्रतिकृति पूरी तरह से नहीं होती है, लेकिन केवल परिवर्तित भाग है। इस प्रकार, केवल एक चर के साथ, आप सर्वर से कई कमांड भेज सकते हैं, सरणी को तत्वों में और तत्वों को बिट्स में पार्स कर सकते हैं।

अब हम .cpp पर चलते हैं
हम प्रतिकृति स्थिति लिखते हैं:

 void AMySuperActor::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const { Super::GetLifetimeReplicatedProps(OutLifetimeProps); DOREPLIFETIME(AMySuperActor, bMyReplicatedVariable); DOREPLIFETIME_CONDITION(AMySuperActor, MyReplicatedArray, COND_OwnerOnly); } 

पहला चर bMyReplicatedVariable एक बार में सभी ग्राहकों को बिना शर्त के दोहराया गया था, जबकि दूसरा, MyReplicatedArray , केवल क्लाइंट के लिए अपडेट किया गया था जो AMySuperActor ऑब्जेक्ट का मालिक है, जब तक कि, ज़ाहिर है, यह एक घोषित नहीं किया गया था।

संभावित स्थितियों की एक पूरी सूची यहां पाई जा सकती है ।

RPC ( दूरस्थ प्रक्रिया कॉल )

प्रतिकृति के विपरीत, डेटा ट्रांसफर का यह तरीका दोनों तरीकों से काम करता है, लेकिन अधिक महंगा है। इसका उपयोग करने के लिए, आपको बस "UnrealNetwork.h" कनेक्ट करना होगा।

इसलिए, क्लाइंट से हमारे पैकेज को सर्वर पर भेजने के लिए, आपको तीन कार्यों को पंजीकृत करना होगा:

 UFUNCTION(Reliable, Server, WithValidation) void ServerTestFunction(float MyVariable); void ServerTestFunction_Implementation(float MyVariable); bool ServerTestFunction_Validate(float MyVariable); 

विश्वसनीय - रसीद की प्राप्ति के साथ एक पार्सल।
सर्वर - क्लाइंट से सर्वर पर भेज रहा है।
WithValidation - पैकेज केवल प्राप्तकर्ता द्वारा खोला जाता है यदि बूल ServerTestFunction_Validate (फ्लोट MyVariable) फ़ंक्शन में वर्णित शर्तों को पूरा किया जाता है । यही है, अगर फ़ंक्शन सही है । यह पैरामीटर केवल उन फ़ंक्शन के लिए आवश्यक है जो सर्वर पर निष्पादित किए जाते हैं।
ServerTestFunction (MyVariable फ्लोट) - यह फ़ंक्शन क्लाइंट द्वारा कॉल किया जाता है यदि वह सर्वर को कुछ भेजना चाहता है। सामान्य तौर पर, इसे .cpp में वर्णित करने की आवश्यकता नहीं होती है।
ServerTestFunction_I कार्यान्वयन (फ़्लोट MyVariable) - इस फ़ंक्शन को केवल सर्वर पर सीधे कॉल किया जाएगा यदि ...
ServerTestFunction_Validate (फ़्लोट MyVariable) - इस फ़ंक्शन को सर्वर पर निष्पादित किया जाता है, और यदि सही है , तो ServerTestFunction_Im कार्यान्वयन (फ़्लोट MyVariable) कहा जाएगा।

सर्वर से क्लाइंट को एक पैकेज भेजने के लिए, अगर हम स्पष्ट रूप से प्रतिकृति के उपयोग से खुश नहीं हैं, तो संक्षेप में केवल सर्वर क्लाइंट में बदलता है:

 UFUNCTION(Reliable, Client, WithValidation) 

फ़ंक्शंस के नाम, सिद्धांत रूप में, मनमाने ढंग से हो सकते हैं, लेकिन आमतौर पर उन्हें प्रतिबिंबित करना चाहिए कि पैकेज कहाँ जा रहा है। हमारी सुविधा के लिए।

 UFUNCTION(Reliable, Client, WithValidation) void ClientTestFunction(float MyVariable); void ClientTestFunction_Implementation(float MyVariable); bool ClientTestFunction_Validate(float MyVariable); 

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

सर्वर से भेजने के लिए एक और विकल्प है, जब पैकेज एक ही बार में सभी क्लाइंट के पास जाता है।

 UFUNCTION(Reliable, NetMulticast, WithValidation) void NetMulticastTestFunction(); void NetMulticastTestFunction_Implementation(); bool NetMulticastTestFunction_Validate(); 

इस विकल्प का दुरुपयोग न करें। इस बारे में सोचें कि आप प्रतिकृति का प्रबंधन कैसे कर सकते हैं।

 /*       ,     */ void ADreampaxActor::DoSomethingWithOtherActor(ADreampaxOtherActor * SomeOtherActor) { /*  ,      */ if (Role < ROLE_Authority) { /*    ,    ,      */ ServerDoSomethingWithOtherActor(SomeOtherActor); /*   ,        */ return; } /*         */ SomeOtherActor->Destroy(true); } /*      ,    ServerDoSomethingWithOtherActor(SomeOtherActor)     */ void ADreampaxCharacter::ServerDoSomethingWithOtherActor_Implementation(ADreampaxOtherActor * SomeOtherActor) { /*   ,       */ DoSomethingWithOtherActor(SomeOtherActor); } /*     ,    ServerDoSomethingWithOtherActor_Implementation(ADreampaxOtherActor * SomeOtherActor) */ bool ADreampaxCharacter::ServerDoSomethingWithOtherActor_Validate(ADreampaxOtherActor * SomeOtherActor) { /*      true,   ,   -    fasle.       */ return true; } 

और अंत में, मैनुअल का एक लिंक, जिसे पढ़ा जाना चाहिए।
'अवास्तविक इंजन 4' नेटवर्क कम्पेंडियम

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

पुनश्च यदि आपको कोई अशुद्धि या त्रुटि नज़र आती है, तो कृपया टिप्पणियों में लिखें।