सरल ऑनलाइन पोंग गेम नेटवर्क सिंक्रनाइज़ेशन

Question

मैं नेटवर्क पर खेलने वाले दो खिलाड़ियों के लिए एक साधारण ऑनलाइन पोंग गेम लिख रहा हूं। यह एक सर्वर-सर्वर अनुप्रयोग है, सर्वर पक्ष पर एक गेम तर्क के साथ। मुझे क्लाइंट साइड पर गेम सिंक्रनाइज़ेशन के साथ कुछ समस्याएं हैं, और परिणाम बहुत असंतुष्ट है। यह वर्तमान में कैसे काम करता है:

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

यह विधि बहुत अच्छी तरह से काम नहीं करती है क्योंकि यह क्लाइंट साइड पर गेम ऑब्जेक्ट्स को आगे और आगे ले जाती है। कोई विचार यह कैसे सुधारने के लिए?

Answer 1

प्रवेश करें कि आपके पास क्लाइंट और सर्वर के बीच 30ms की विलंबता है। ग्राहक भेज "मैं अपने रैकेट नीचे ले जाने चाहता हूँ" और उसके रैकेट 0.1px/एमएस के वेग

30ms सेकंड बाद साथ y = 100px पर है:

• ग्राहक रैकेट y = 100 पर है + 30 * 0.1 = 103px
• सर्वर क्लाइंट से आदेश प्राप्त करता है और

20ms सेकंड बाद रैकेट (जो सर्वर साइड पर y = 100px पर अभी भी वर्तमान में है) चलना शुरू:

• ग्राहक रैकेट y पर है = 103 + 20 * 0.1 = 105px
• सर्वर साइड ग्राहक रैकेट y पर है = 100 + 20 * 0.1 = 102px
• सर्वर क्लाइंट के लिए भेजता है नई स्थिति (102px)

30ms सेकंड बाद:

• ग्राहक rarcket y पर है = 105 + 30 * 0.1 = 108px
• क्लाइंट सर्वर से रैकेट के नए पद प्राप्त करता है : 102px

इस बिंदु पर, ग्राहक रैकेट 102px करने के लिए 108 से "कूदता" पिछड़े ...

कैसे नेटवर्क विलंबता से निपटने के लिए? दो पूरक तरीके:

• एक कार्रवाई
• भविष्यवाणी कार्यों का परिणाम (क्लाइंट और सर्वर पक्षों पर)

कर पहले aproach जब प्रभाव पर प्रयोग किया जाता है से पहले सर्वर acknowlegment का इंतजार ग्राहक शायद ही परिणाम से जुड़ा हुआ है और "रोलबैक" नहीं हो सकता है। उदाहरण: जब कोई क्लाइंट मिसाइल को गोली मारता है, तो यह एडमिट करने योग्य नहीं है कि इस मिसाइल को अगले अपडेट पर सर्वर द्वारा दबाया जा रहा है क्योंकि क्लाइंट वास्तव में मिसाइल स्टॉक नहीं था। तो इस मामले में, क्लाइंट एप्लिकेशन मिसाइल लॉन्च करेगा जब सर्वर ने एक स्वीकृति भेजी थी।

दूसरा सर्वर हमेशा सिंक होने पर इन "कूदता" से बचने के लिए उपयोग किया जाता है। आपको अपने गेम तत्वों की गति की भविष्यवाणी करने के लिए नेटवर्क विलंबता की निगरानी करनी होगी। यहां दो तरीके: पिंग की गणना करें या स्टार्टअप (सबसे आसान और अधिक मजबूत तरीका) पर सर्वर और क्लाइंट समय सिंक्रनाइज़ करें। सामान्य विचार है:

• ग्राहक भेजता है और

30ms बाद में चलना शुरू "मैं समय मेरे रैकेट नीचे ले जाने के = 1,265,871 चाहता हूँ": y = 100 पर

• ग्राहक रैकेट + 30 * 0.1 = 103 पीएक्स
• सर्वर 30 एमएम विलंबता (पिंग या समय सिंक अंतर द्वारा) को स्थानांतरित करता है और गणना करता है और रैकेट स्थिति y = 100 + विलंबता * 0.1 = 100 + 30 * 0.1 = 103px
पर सेट करता है

बिल्कुल सही! वे सिंक्रनाइज़ हैं। बाद में

20ms:

• सर्वर और ग्राहक दोनों y पर रैकेट = 103 + 20 * 0.1 = 105px
• सर्वर नई स्थिति और दिशा

30ms बाद में भेजता है:

• y = 105 + 30 * 0.1 = 108px
• क्लाइंट आर पर क्लाइंट रैकेट नई स्थिति और दिशा (105px नीचे जा) eceives, 30ms विलंबता की गणना करता है और y = 105 + विलंबता * 0.1 = 105 * 30 * 0.1 = 108px

फिर, क्लाइंट और सर्वर सिंक्रनाइज़ किए जाते हैं पर रैकेट स्थिति सेट!

जब ग्राहक पहले क्लाइंट को आगे बढ़ता है तो दूसरे ग्राहक पर Desync हो सकता है। इस मामले में खिलाड़ी रैकेट थोड़ा "कूद" जाएगा। जब यह महत्वपूर्ण नहीं है, तो इस संक्रमण को सुचारू बनाना संभव है।

आशा है कि इससे मदद मिलेगी।