एक आरपीजी खेल में कई कहानी धागे को कैसे संभालना है?


26

मैंने एक आरपीजी गेम तैयार किया है जिसमें कई कहानी सूत्र हैं, जिसका अर्थ है कि उपयोगकर्ता की पसंद के आधार पर कुछ चीजें हो सकती हैं या नहीं हो सकती हैं, आप एक ही चीज को कई तरीकों से प्राप्त कर सकते हैं, अंत अलग हो सकता है और इसी तरह।

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

मैंने बहुत सारे खेल देखे जिनमें जटिल निर्णय इंजन हैं, और मुझे आश्चर्य है, कि वे कैसे बने हैं? क्या कोई विशेष डिज़ाइन है जो चीजों को वास्तव में आसान बनाता है? क्या किसी ने भी कुछ ऐसा ही किया है और मुझे इससे निपटने का संकेत दे सकता है?

अद्यतन 1:

एक महत्वपूर्ण पहलू यह है कि किसी तरह कहानी कोड को स्वतंत्र रखा जाए, ताकि इसे किसी बाहरी फ़ाइल से जोड़ दिया जा सके। मैं इसे एक इंजन के रूप में उपयोग करने की योजना बनाता हूं, यहां तक ​​कि संभव विकल्प बाहरी फ़ाइल से आना है। कोड को पूरी तरह से अमूर्त होना चाहिए।

इसके अलावा, मुझे डिजाइन समाधान में दिलचस्पी है, इसे करने का एक अच्छा तरीका है, दूसरे इसे कैसे करते हैं या यह करते हैं।


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

हाँ, यह वही है जो मैं शुरू में यद्यपि, हालांकि, मुझे यह कोड स्वतंत्र होने की आवश्यकता है। इसका मतलब है कि, कहानी को एक बाहरी फ़ाइल से पूरी तरह से जोड़-तोड़ किया जा सकता है। इसलिए, मुझे आपके द्वारा कहे गए कार्यों को सामान्य बनाने और इसे इस तरह से करने का एक तरीका खोजना होगा ताकि मैं परियोजना पर नियंत्रण नहीं रख पाऊं (काफी कुछ निर्णय हैं)। सवाल अपडेट करेंगे। धन्यवाद!
वैलेंटाइन रादु

इसलिए अधिक विशिष्ट होने के लिए, मैं if (isTree)एक isTreeवैश्विक संस्करण की जांच या रख नहीं कर सकता क्योंकि कहानी में यह विकल्प हो सकता है या नहीं। पता है क्या मेरा मतलब है? यह एक पसंद इंजन की तरह है जो कई कहानियों की सेवा करेगा।
वैलेन्टिन राडू

इसके अलावा यह एक और समस्या है, मान लीजिए कि यदि उपयोगकर्ता ने एक पेड़ लगाने का फैसला किया है isTree=true, हालांकि, बाद में, वह कुछ और करता है, जैसे, एक स्कूल साथी से लड़ना, जो बदले में जाता है और अपने पेड़ को काट देता है जबकि पेड़ अभी भी युवा है क्योंकि उसने अपने गधे को लात मारी। अब, हमारे पास 2 चर हैं जो पेड़ के अस्तित्व को प्रभावित करते isTree==true' and हैंफाइटब्रैट == असत्य`। पता है क्या मेरा मतलब है? और श्रृंखला हमेशा के लिए चल सकती है, पेड़ के अस्तित्व को अज्ञात कारकों से प्रभावित किया जा सकता है। पता है क्या मेरा मतलब है?
वैलेंटाइन रादु

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

जवाबों:


18

आप कतार को एक निर्देशित चक्रीय ग्राफ (DAG) में भी सामान्यीकृत कर सकते हैं। आप विकिपीडिया पर इनके बारे में पढ़ सकते हैं। मूल रूप से, प्रत्येक नोड में एक या अधिक मूल नोड्स हो सकते हैं जो इसे "पर निर्भर करता है"। चक्रों की अनुमति नहीं है, अर्थात यदि A B पर निर्भर करता है, B A (सीधे या किसी अन्य नोड की अप्रत्यक्ष श्रृंखला के माध्यम से) पर निर्भर नहीं हो सकता है।

प्रत्येक नोड एक "सक्रिय" या "निष्क्रिय" स्थिति में है, और केवल तभी सक्रिय होने की अनुमति है यदि उसके सभी माता-पिता पहले से ही सक्रिय हैं। ग्राफ़ की संरचना (क्या नोड्स हैं और वे कैसे जुड़े हैं) गेम डेटा का हिस्सा है, लेकिन सक्रिय / निष्क्रिय स्थिति खिलाड़ी के डेटा को बचाने का हिस्सा है।

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

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


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

@NathanReed यह चक्रीय क्यों नहीं हो सकता है? एसाइक्लिक होना आम तौर पर एक विशेषता नहीं है, लेकिन ग्राफ डिजाइन का एक बायप्रोडक्ट है। मैं इसे उस इरादे से नहीं बनाऊंगा। उदाहरण के लिए, कल्पना करें कि क्या आप चाहते थे कि आपका वृक्ष ऋतुओं को पहचान सके। वे प्रकृति चक्रीय हैं, और आपकी कहानी चाप एक सीज़न के दौरान उपलब्ध विकल्पों के आधार पर समान हो सकती है।

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

@NathanReed आह, क्षमा करें, मैं पुनरावर्ती भाग को याद किया।

3

जो मैं समझता हूं, आप जो चाहते हैं, वह सिर्फ एक निर्णय इंजन नहीं है, बल्कि एक नियम इंजन भी है। प्रत्येक निर्णय के लिए आप उस निर्णय द्वारा परिभाषित नियमों का एक सबसेट निष्पादित करते हैं। उन नियमों का निष्पादन अक्सर आपके पेड़ के उदाहरण जैसी कुछ संस्थाओं की स्थिति पर निर्भर करता है।

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

विकिपीडिया पर कुछ और ।

उनके जब से उपयोग करने के लिए नियम इंजन अधीन (जोर मेरा है):

  • समस्या सिर्फ पारंपरिक कोड के लिए बहुत जटिल है।
  • समस्या जटिल नहीं हो सकती है, लेकिन आप इसे बनाने का एक मजबूत तरीका नहीं देख सकते हैं।
  • समस्या किसी भी स्पष्ट एल्गोरिथ्म आधारित समाधान से परे है।
  • इसे हल करना एक जटिल समस्या है। कोई स्पष्ट पारंपरिक समाधान नहीं हैं या समस्या पूरी तरह से समझ में नहीं आती है।
  • तर्क अक्सर बदलता है
  • तर्क स्वयं सरल हो सकता है लेकिन नियम अक्सर बदलते रहते हैं। कई संगठनों में सॉफ़्टवेयर रिलीज़ दुर्लभ हैं और नियम "चपलता" प्रदान करने में मदद कर सकते हैं जो एक उचित रूप से सुरक्षित तरीके से आवश्यक और अपेक्षित हैं।
  • डोमेन विशेषज्ञ और व्यापार विश्लेषक आसानी से उपलब्ध हैं, लेकिन गैर-तकनीकी हैं।
  • डोमेन विशेषज्ञ अक्सर व्यावसायिक नियमों और प्रक्रियाओं के बारे में ज्ञान के धन होते हैं। वे आम तौर पर गैर-तकनीकी होते हैं, लेकिन बहुत तार्किक हो सकते हैं। नियम उन्हें अपनी शर्तों में तर्क व्यक्त करने की अनुमति दे सकते हैं। बेशक, उन्हें अभी भी गंभीर रूप से सोचना होगा और तार्किक सोच के लिए सक्षम होना चाहिए। गैर-तकनीकी पदों पर कई लोगों के पास औपचारिक तर्क में प्रशिक्षण नहीं है, इसलिए सावधान रहें और उनके साथ काम करें। नियमों में व्यावसायिक ज्ञान को संहिताबद्ध करके, आप अक्सर व्यापार के नियमों और प्रक्रियाओं को समझने के तरीके में छेद को उजागर करेंगे।

ध्यान देने वाली एक बात यह है कि कभी-कभी एक सरलीकृत डोमेन विशिष्ट "भाषा", या YAML जैसी किसी चीज़ का उपयोग करके एक नियम इंजन को सर्वोत्तम रूप से लागू किया जाता है। मैं XML का सुझाव नहीं दूंगा।


1

आपको यह विचार करना होगा कि कोई घटना विशुद्ध रूप से उपयोगकर्ता के निर्णय पर आधारित नहीं है। जैसा कि आपने उल्लेख किया है कि यदि किसी निर्णय के अनुक्रमों को लिया जाता है तो कुछ घटनाओं को जोड़ना होता है और फिर कुछ और होता है (जैसे दो दिन बाद)।

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

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

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

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

यह सभी बुनियादी ढाँचा एक मानव कालकोठरी मास्टर के व्यवहार की नकल करने के उद्देश्य से कार्य करता है: वह आमतौर पर खिलाड़ी के फैसले और पर्यावरणीय परिस्थितियों के कारण वर्तमान स्थिति (एचएमएस ["बाहरी"]) का मानसिक रिकॉर्ड लेता है; जब कुछ अपील करता है तो वह अपने मानसिक रिकॉर्ड का उपयोग करके निर्णय ले सकता है और कुछ आंतरिक रणनीति की स्थिति भी दर्ज कर सकता है (एचएसएम ["आंतरिक"]) ताकि कुछ स्थिति उदाहरण के लिए संलग्न हो तो इसी तरह से प्रतिक्रिया करने से बच सकें।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.