कैसे एक खेल में यात्रा के समय को लागू करने के लिए?

Question

मैं सोच रहा था कि खेल में समय यात्रा को कैसे लागू किया जाए। सुपर कॉम्प्लेक्स कुछ भी नहीं, बस टाइम-रिवर्सल जैसा कि ब्रैड में है, जहां उपयोगकर्ता 30 सेकंड या जो भी हो उससे आगे के समय को तेजी से आगे / पीछे कर सकता है।

मैंने वेब पर बहुत खोज की, लेकिन मेरे परिणाम आमतौर पर "3:00" या टाइमर और जैसे जैसे समय का उपयोग करने के लिए संदर्भित होते हैं।

केवल एक चीज जिसके बारे में मैं सोच सकता था कि 2 सरणियों का उपयोग कर रहा था, एक खिलाड़ी की x स्थिति के लिए और दूसरा खिलाड़ी की y स्थिति के लिए, और फिर उन सरणियों के माध्यम से पुनरावृत्ति करना और चरित्र को उस स्थिति में रखना जैसा कि वे आगे / तेजी से आगे पीछे करते हैं। क्या वह काम कर सकता है? यदि यह काम करता है, तो सरणी को कितना बड़ा होना चाहिए और मुझे खिलाड़ी के x और y को कितनी बार स्टोर करना चाहिए? अगर यह काम नहीं करता है, तो मैं और क्या कोशिश कर सकता हूं?

अग्रिम में धन्यवाद!

Comments

क्या आप समाचार ( ust.hk/eng/news/press_20110719-893.html ) नहीं पढ़ते हैं ? उन्होंने सिर्फ यह दिखाया है कि समय यात्रा संभव नहीं है। इसलिए, कोड करना असंभव है।

आपको समय-यात्रा के लिए एक संभावित शब्दार्थ सोचने की जरूरत है, उसके बाद ही आप कार्यान्वयन के बारे में सोचना शुरू कर सकते हैं।

— पाओलो एबरमन जू

en.wikipedia.org/wiki/Time_travel

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

— doppelgreener

import universal.back2future.FluxCapacitor;

— झूकिंग

Answer 1

सरणी विचार बहुत अधिक है कि इसे ब्रैड में कैसे लागू किया गया था। जब चरित्र पर काम करने वाली एकमात्र चीजें गुरुत्वाकर्षण, कीबोर्ड / हैप्पीपैड इनपुट और अन्य वर्ण हैं, तो आपको उस चरित्र के बारे में सब कुछ महत्वपूर्ण जानने के लिए प्रत्येक चरण पर स्थिति और वेग को संग्रहीत करने की बहुत आवश्यकता है। यदि आप प्रति वर्ण प्रति सेकंड 10 स्नैपशॉट संग्रहीत करते हैं तो यह अभी भी एक चरित्र के इतिहास के एक मिनट के लिए 50K से कम है - आसानी से अधिकांश प्रणालियों पर प्रबंधनीय है, और आप उन तरीकों को पा सकते हैं जो इससे भी अधिक कुशल हैं।

Comments

यह सही ट्रैक है। उदाहरण के लिए सक्रिय कमांड स्टोर करें: टाइमस्टैम्प के साथ कुंजी। यदि सिस्टम नियतात्मक है, तो आप अधिकांश अन्य व्यवहार को एक्सट्रपलेशन कर सकते हैं। 10 एफपीएस ट्रैकर एक रिवाइंड सिस्टम के लिए ठीक है, यहां तक ​​कि कम स्वीकार्य हो सकता है, जब तक कि वास्तविक कमांड को बनाए रखा जाता है, प्रभाव में वस्तुओं की स्थिति या स्थिति।

— कर्मिंगटन

Answer 2

कमांड पैटर्न पर पढ़ें । यह पूर्ववत कार्रवाई के लिए प्रदान करता है (और बाद में उन्हें फिर से करने के लिए।) जो एक जहाज की सिर्फ स्थिति से अधिक संभाल सकता है, लेकिन खिलाड़ी जो सभी कार्रवाई करता है।

लेकिन मुझे लगता है कि आपका सरणी विचार ध्वनि के साथ-साथ है।

Comments

शायद एक महान विचार नहीं है - अधिक मेमोरी-इंटेंसिव होने के अलावा (हर बार जब आप किसी इकाई के वेग को अपनी स्थिति में जोड़ते हैं, तो आपको इसे "एक्शन" के रूप में संग्रहीत करने की आवश्यकता है) , इसके लिए निश्चित-बिंदु गणित की आवश्यकता होती है, क्योंकि आप फ्लोटिंग का उपयोग करते हैं अपने पदों / गति के लिए बिंदु, के (x+v)-vबराबर नहीं हो सकता है x।

— ब्लूराजा - डैनी पफ्लुगुएफ्ट

@BlueRaja - यह न देखें कि वह दृष्टिकोण स्मृति-गहन कहां होगा। 100 एफपीएस पर और अंतिम 10 सेकंड को स्टोर करने के लिए, आपको 1000 n-tupels कमांड को स्टोर करने की आवश्यकता है, जहां n अधिकतम 5 या तो है। या, और भी बेहतर, आप प्रत्येक फ़्रेम में केवल पूर्ण स्थिति संग्रहीत करते हैं, और रिवाइंड के लिए, आप बस उस पथ के साथ चरित्र को पीछे की ओर चेतन करते हैं। यह भी किसी भी संभव फ़्लोटिंग पॉइंट मुद्दों को समाप्त कर देगा और आपको वही वापस लाएगा जहाँ आपने शुरू किया था।

— हैकवर्थ

Answer 3

दो अलग-अलग सरणियों के बजाय, आपके पास शायद एक वर्ग होना चाहिए जो खिलाड़ी की स्थिति का वर्णन करता है (शायद जावा में पहले से ही एक प्वाइंट क्लास है ... मैं हाल ही में एक सी # लड़का हूं) और पिछले पदों को धारण करने के लिए एक एकल सरणी का उपयोग करता हूं।

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

यदि आप पिछले डेटा के 30 सेकंड का मूल्य पकड़ना चाहते हैं, तो आपको अपने फ्रेम दर को जानना होगा यदि आप अंतरिक्ष को पूर्व-आवंटित करना चाहते हैं और एक निश्चित आकार के सरणी का उपयोग करना चाहते हैं। यदि आप गेम को 10 फ्रेम / सेकंड में, 30 सेकंड में रेंडर करते हैं, तो यह 300 तत्व है।

Answer 4

जीडीसी वॉल्ट का अपनी साइट पर जॉन ब्लो ( ब्रैड के निर्माता ) द्वारा व्याख्यान दिया गया है, जिसे $ 3.95 में ब्रैड में रिविंडेशन ऑफ रिवाइंड कहा जाता है । मुझे यकीन है कि यह जानकारी आप चाहते हैं;)

संपादित करें: संभवतः जावा में नहीं होगा, लेकिन विचारों को धारण करना चाहिए।

Comments

क्या आपको पता है कि वे ट्रांसक्रिप्ट भी बेचते हैं, या केवल ऑडियो?

— ओ ० '।

मुझे साइट की त्वरित खोज के माध्यम से कुछ भी नहीं मिला। शायद आप कुछ प्रतिलेखन सॉफ्टवेयर का उपयोग कर सकते हैं ?

— NoobsArePeople2

Answer 5

जैसे एरिक जे ने कहा , रिंग-बफर में बिंदु वस्तुओं के संग्रह के रूप में खिलाड़ी के पिछले पदों को संग्रहीत करना उचित लगता है।

हालांकि, मैं बफर को लागू करने के लिए एक कतार का उपयोग करने का सुझाव दूंगा। यह एक सरणी से अपडेट करने के लिए बहुत सस्ता है और आपको अपनी फ्रेम दर को पहले से जानना नहीं है:

update():
   time_queue.push(player.positions)
   if current_time() - start_time > n:
       queue.pop()

यह अभी तक अलग-अलग फ्रेम दरों पर विचार नहीं करता है या यदि आप वास्तव में किसी भी समय-यात्रा करते हैं तो क्या होना चाहिए, इसलिए मेरा सुझाव है कि आप प्रत्येक प्रविष्टि के साथ एक समय टिकट स्टोर करें और इसके बजाय जांच करें:

update():
    time_queue.push({
        'pos': player.positions,
        'time': current_time()
    })
    first_entry = queue.peek()
    while current_time() - first_entry['time'] > n:
       queue.pop()
       first_entry = queue.peek()

उम्मीद है की यह मदद करेगा!

Answer 6

मेमेंटो नामक एक डिज़ाइन पैटर्न है , मुझे लगता है कि यह ब्रैड जैसे खेल के लिए एक प्रारंभिक बिंदु है

स्मृति चिन्ह पैटर्न एक सॉफ्टवेयर डिज़ाइन पैटर्न है जो अपने पिछले राज्य में एक वस्तु को पुनर्स्थापित करने की क्षमता प्रदान करता है (रोलबैक के माध्यम से पूर्ववत करें)।

स्मृति चिन्ह पैटर्न का उपयोग दो वस्तुओं द्वारा किया जाता है: प्रवर्तक और एक केयरटेकर। प्रवर्तक कुछ ऐसी वस्तु है जिसकी आंतरिक स्थिति होती है। कार्यवाहक प्रवर्तक के लिए कुछ करने जा रहा है, लेकिन परिवर्तन को पूर्ववत करने में सक्षम होना चाहता है। कार्यवाहक पहले प्रवर्तक को स्मृति चिन्ह वस्तु के लिए पूछता है। फिर यह जो भी ऑपरेशन (या संचालन का अनुक्रम) करता है वह करने जा रहा था। परिचालन से पहले राज्य में वापस आने के लिए, यह प्रवर्तक को स्मृति चिन्ह वस्तु लौटाता है। स्मृति चिन्ह वस्तु अपने आप में एक अपारदर्शी वस्तु है (एक जिसे केयरटेकर नहीं कर सकता है, या नहीं बदलना चाहिए)। इस पैटर्न का उपयोग करते समय, देखभाल की जानी चाहिए यदि प्रवर्तक अन्य वस्तुओं या संसाधनों को बदल सकता है - स्मृति पैटर्न एक ही वस्तु पर काम करता है।

http://en.wikipedia.org/wiki/Memento_pattern

यहाँ विज्ञापन संबंधी जानकारी: http://dofactory.com/Patterns/PatternMemento.aspx

Comments

मैं यह देखने में विफल हूं कि यह कैसे मदद करनी चाहिए। ऐसा लगता है कि यह एक "तत्काल-रोलबैक" है, जबकि ओपी ने ब्रैड की तरह चिकनी कुछ के लिए पूछा। शायद मैं कुछ गलत करूं?

— ओ ० '।

यह पैटर्न एकल रोलबैक पर नहीं है, आप उदाहरण के लिए, क्रियाओं की "टाइमलाइन" बना सकते हैं। यहाँ इस पैटर्न के उपयोग के बारे में एक ब्रेज़िलियन का ब्लॉग पोस्ट है: abrindoojogo.com.br/padroes-de-projeto-memento यहाँ एक उदाहरण दिया गया है Flash: abrindoojogo.com.br/fasteriles.swf Move: Arrows | शूट: स्पेस | रिवाइंड एक्शन: बैकस्पेस

— मार्सेलो असिस

Answer 7

XBox360 के लिए एक गेम जारी किया गया था जिसमें समय-हेरफेर शामिल था। यह औसत दर्जे का था, इसलिए मुझे इस समय शीर्षक याद नहीं आ रहा था। वैसे भी, इसके लिए एक डेवलपर के साथ एक साक्षात्कार में, उन्होंने बताया कि कैसे वे समय में हेरफेर करते हैं:

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

खेल के माध्यम से सामान्य रूप से, समय-समय पर खेलते हुए, हर इनपुट प्रतिक्रिया भविष्य में किसी समय स्नैपशॉट सेट में योगदान देता है।

खेल की दुनिया तब मौजूदा समय में स्नैपशॉट के बीच प्रसारित होती है, और भविष्य में स्नैपशॉट एक्स फ्रेम करता है।

फिर, जब आप समय को उलटना चाहते हैं, तो समय की दिशा को पीछे की ओर सेट करें, ताकि यह वर्तमान और स्नैपशॉट एक्स फ्रेम के बीच अतीत में पुनरावृत्ति कर रहा हो (जबकि भविष्य के स्नैपशॉट बनाने की क्षमता को अक्षम करते हुए)।

Comments

स्नैपशॉट के दाने के बारे में बिंदु के लिए +1।

— उमर कूहे जी

Answer 8

आप बस खेल के आभासी समय को एक और अंतरिक्ष जैसे आयाम के रूप में मान सकते हैं। तो क्या समय बाहर से यात्रा खेल के आभासी ब्रह्मांड में एक सरल n + 1 आयामी आंदोलन है।

कुछ उपयोगकर्ता इंटरैक्शन और कुछ प्रकार की भौतिकी प्रणाली को मानते हैं जो आपके ब्रह्मांड के व्यवहार को निर्धारित करते हैं जब कोई उपयोगकर्ता इनपुट नहीं होता है, तो आपको केवल रिकॉर्ड करने की आवश्यकता होती है उपयोगकर्ता इंटरैक्शन का प्रभाव (उदाहरण के लिए, n + 1 आयाम गति / त्वरण वैक्टर में परिवर्तन) , जैसा कि आपका भौतिकी समय-प्रतिवर्ती होना चाहिए।

इस तरह से आपको किसी भी समय समन्वय में खेल ब्रह्मांड की स्थिति की गणना करने के लिए बहुत कम मेमोरी की आवश्यकता होगी।

Comments

जैसा कि मैंने एक अन्य टिप्पणी में उल्लेख किया है, वीडियो गेम में भौतिकी आमतौर पर समय-प्रतिवर्ती नहीं है, क्योंकि फ्लोटिंग-पॉइंट संख्याओं का उपयोग करते समय, इसके (x+v)-vबराबर नहीं हो सकता हैx

— ब्लूराजा - डैनी पफ्लुगुएफ्ट

Answer 9

मान लें कि एक इकाई में एक वेग, रोटेशन, x और y स्थिति है। ये त्वरण के साथ हैं, मूल आंदोलन बताता है, मूल्यों, जो भी आप इसे कहते हैं। आप डेटा को दो तरीकों से बचा सकते हैं:
1. रोटेशन, x और y पोजीशन को
सेव करें 2. रोटेशन, x वेलोसिटी और y वेलोसिटी को सेव करें

यदि आपके पास एक निश्चित वेग है, तो आप केवल रोटेशन को भी बचा सकते हैं, या दोनों अक्ष के लिए केवल एक ही वेग को बचा सकते हैं।

खेलों में रोटेशन को सहेजना आवश्यक है, जब तक कि आपकी इकाई में एक स्थिर रोटेशन नहीं होता है, यह ज्यादातर मामलों में नहीं होता है।

कहा, कई मूल्यों के लिए वस्तुओं की एक सूची का उपयोग करना आवश्यक है। यदि आपके पास एक अच्छा टाइमर सिस्टम है, जो उदाहरण के लिए, एक सेकंड में 20 बार अपडेट विधियों को कॉल करता है, और इसलिए एफपीएस स्वतंत्र है, तो आप पिछले 30 सेकंड के लिए आवश्यक मूवमेंट मूल्यों को संग्रहीत करने के लिए 20 * 30 ऑब्जेक्ट की एक सरणी बना सकते हैं। । एक सरल सरणी का उपयोग करने की अनुशंसा नहीं की जाती है, क्योंकि आपको प्रत्येक तत्व को स्थानांतरित करना होगा ताकि प्रत्येक अपडेट कॉल पर एक इंडेक्स शेष हो।

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

यदि आप वस्तुओं को नष्ट करते हैं, तो उन्हें पूल करने के लिए याद रखें, यह सुनिश्चित करने के लिए कि आप अपने करीबी दोस्त श्री कचरा को तनाव न दें;)