🙃 🏀 👨‍🏭 एडवेंचर कैसे लिखें? 💄 🕊️ 🔸

अपनी खोज लिखने के हिस्से के रूप में, मुझे साहसिक खेलों में खेल यांत्रिकी पर एक अद्भुत लेख मिला, और मैं इसे आपके ध्यान में लाता हूं।

एडवेंचर कैसे लिखें

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

एडवेंचर गेम क्या है?

नब्बे के दशक की शुरुआत में साहसिक खेल एक लोकप्रिय शैली थी और हाल ही में लोकप्रियता हासिल करना शुरू कर दिया है। सबसे प्रसिद्ध खोज शायद बंदर द्वीप श्रृंखला है, जहां आप एक महत्वाकांक्षी समुद्री डाकू के रूप में खेलते हैं।

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

"देखें" चुनें, "ओपन" पर क्लिक करें और गाइब्रश महल की अपनी छाप को फुसफुसाएंगे (गेम के पात्रों में से कोई भी इस तथ्य पर टिप्पणी नहीं करता है कि गायब्रश वस्तुओं के साथ बोलता है, ठीक है, मुझे लगता है कि उन्हें लगता है कि वह पागल है: डी) ।

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

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

मैं सबसिस्टम में रोमांच को कैसे तोड़ सकता हूं?

साहसिक एक लंबे समय से स्थापित शैली है, जिसका अर्थ है कि खेल को आसानी से उन उप-प्रणालियों में विभाजित किया जा सकता है जिन्हें भविष्य में प्रोग्राम किया जाएगा।

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

कार्यक्रम का सबसे कठिन हिस्सा नेविगेशन सिस्टम है, और अधिकांश लेख इसके लिए समर्पित होंगे।

नेविगेशन

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

अधिकांश भाग के लिए, quests चरित्र को खेल के स्थान पर प्रदर्शित करता है, और कभी-कभी यह महत्वपूर्ण होता है कि नायक को एक निश्चित प्रकार की समस्या को हल करना है।

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

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

उपरोक्त ग्राफ "स्टोर डोर" नोड के माध्यम से स्टोर के लिए "बाहर से सड़क" के बीच का रास्ता दिखाता है। यह चरित्र को स्क्रीन के चारों ओर भटकने से रोकता है। आप सिस्टम में कई चीजों को देख सकते हैं:
"चरित्र में बहुत कम स्वतंत्रता नहीं है, लेकिन क्या होगा अगर वह स्टोर के बीच में रुकना चाहता है?" गिनती उसे ऐसा करने की अनुमति नहीं देगी।

यह एक बिल्कुल सही सवाल है और हम इसे नेविगेशन सिस्टम की मदद से हल कर सकते हैं जो ग्राफ के नोड्स के साथ अनुमेय आंदोलन के क्षेत्र को जोड़ता है।

ग्राफ का निर्माण कैसे किया जाता है?

हम इसे एक हिम्मत से बाहर कर देंगे, जिसे हम थोड़ी देर बाद विचार करेंगे।

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

ए * का यह संस्करण मेरे गूगल कोड रिपॉजिटरी पर उपलब्ध है। बेशक, यह बहुत बुनियादी और सरल है, लेकिन यह काम करता है और सबसे छोटा रास्ता ढूंढता है। यहाँ कार्यान्वयन के लिए एक कड़ी है। (अगर दो चोटियों के बीच का रास्ता नहीं मिल सकता है तो कार्यक्रम दुर्घटनाग्रस्त हो जाएगा - निश्चित रूप से, मैं निकट भविष्य में इसे समाप्त कर दूंगा: डी)

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

बेल्ट के पीछे ए * के साथ, हम ग्राफ पर सबसे छोटे रास्ते पा सकते हैं, लेकिन अभी तक हमने इसे नहीं बनाया है।

नवमेश एल्गोरिथम का उपयोग करना

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

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

हम माउस क्लिक के बिंदु पर खिलाड़ी की स्थिति से पथ का निर्माण करेंगे। इसका मतलब है कि नेविगेशन मेष का दिया गया बिंदु (x, y) यह निर्धारित करने में सक्षम होना चाहिए कि वह किस बहुभुज में है।

Polygon FindPolygonPointIsIn(Point point) { foreach(Polygon polygon in _polygons) { if ( polygon.IntersectsWith(p) ) { return polygon; } } return null; }

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

अवतल बहुभुज की परिभाषा अत्यंत सरल है। यदि कोई एक कोने बहुभुज के अंदर है, तो यह अवतल है। चीन और जापान में, कांजी का उपयोग विचारों का प्रतिनिधित्व करने के लिए किया जाता है - अगले दो कांजी को देखें;
यह निर्धारित करने का प्रयास करें कि कौन से आंकड़े उत्तल हैं और कौन सा अवतल शांत है, है ना?

निम्नलिखित एक कार्यक्रम सूची है जो यह निर्धारित करती है कि बहुभुज उत्तल है या नहीं। इस मामले में, बहुभुज सिर्फ एक वर्ग (सूची _vertices) है जिसमें अंकों का एक सेट है।

 bool IsConcave() { int positive = 0; int negative = 0; int length = _vertices.Count; for (int i = 0; i < length; i++) { Point p0 = _vertices[i]; Point p1 = _vertices[(i + 1) % length]; Point p2 = _vertices[(i + 2) % length]; // Subtract to get vectors Point v0 = new Point(p0.X - p1.X, p0.Y - p1.Y); Point v1 = new Point(p1.X - p2.X, p1.Y - p2.Y); float cross = (v0.X * v1.Y) - (v0.Y * v1.X); if (cross < 0) { negative++; } else { positive++; } } return (negative != 0 && positive != 0); }

चौराहों की जांच के लिए हमें निम्नलिखित सूची की आवश्यकता है।

 /// /// ,      . ///   <a href="http://local.wasp.uwa.edu.au/%7Epbourke/geometry/insidepoly/">http://local.wasp.uwa.edu.au/~pbourke/geometry/insidepoly/</a> /// /// X   /// Y   ///     ? public bool Intersects(float x, float y) { bool intersects = false; for (int i = 0, j = _vertices.Count - 1; i < _vertices.Count; j = i++) { if ((((_vertices[i].Y <= y) && (y < _vertices[j].Y)) || ((_vertices[j].Y <= y) && (y < _vertices[i].Y))) && (x < (_vertices[j].X - _vertices[i].X) * (y - _vertices[i].Y) / (_vertices[j].Y - _vertices[i].Y) + _vertices[i].X)) intersects = !intersects; } return intersects; }

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

चरण का अंतिम चरण चरित्र के शुरुआती और समाप्त होने वाले पदों को लेने के लिए है, बहुभुज के केंद्र, नोडल बिंदुओं को जोड़ते हैं और एक ग्राफ बनाते हैं जिस पर आप ए * एल्गोरिथ्म चला सकते हैं।

एल्गोरिदम का परिणाम उन बिंदुओं की एक सूची होगी जिनके साथ चरित्र स्थानांतरित हो सकता है। नीचे चरित्र को पथ के साथ ले जाने के लिए एल्गोरिथ्म का छद्म कोड है।

चरित्र स्थिति प्राप्त करें -> PC_position
पथ पर वर्तमान बिंदु की स्थिति प्राप्त करें-> लक्ष्य
लक्ष्य के लिए PC_position दिशा प्राप्त करें -> दिशा
Pc_postion में * walkkspeed दिशा जोड़ें
जांचें कि पीसी रास्ते में वर्तमान स्थिति के पास है या नहीं
यदि सही है, तो वर्तमान बिंदु को पथ के साथ ले जाएं
यदि पथ पर वर्तमान बिंदु अंतिम है, तो वर्ण की गति रोकें

मैं जिस वास्तविक कोड का उपयोग करता हूं वह अपडेटपाथ फ़ंक्शन में है।

एनीमेशन

अंतिम चरण चरित्र के स्प्राइट को प्रस्तुत करना और आंदोलन की दिशा के अनुसार एनीमेशन का संचालन करना है। कार्यान्वित कोड पहले से ही सुनिश्चित करता है कि चरित्र चयनित वेक्टर की दिशा में आगे बढ़ता है, यह केवल इस दिशा की तुलना एनीमेशन के ड्राइंग के साथ करने के लिए रहता है।

यह कला का एक उदाहरण है जो मुझे kafkaskoff.com पर मिला (मैंने उपयोग किए गए संस्करण में हरी सीमा हटा दी):

तो, हमारे पास आराम करने के लिए तीन और एनीमेशन के लिए तीन विकल्प हैं। साधारण परिवर्तनों के माध्यम से "बाएं", "सही", "ऊपर" और "नीचे" की दिशा में आंदोलन को प्रोग्रामेटिक रूप से लागू किया जा सकता है।

इनमें से एक एनिमेशन के मोशन वेक्टर की तुलना करने के लिए, मैंने निम्नलिखित परिवर्तन किए। प्रत्येक दिशा के लिए चार वैक्टर पेश किए गए: (-1, 0), (1, 0), (0, 1), (0, -1)। अगला, मैंने स्केलर उत्पाद की गणना की और गति वेक्टर के करीब दिशा वैक्टर में से किस पर ध्यान दिया, नतीजतन, मैंने वांछित एनीमेशन का चयन किया।

 private Direction VectorToDirection(Vector direction) { Vector up = new Vector(0, 1, 0); Vector down = new Vector(0, -1, 0); Vector left = new Vector(-1, 0, 0); Vector right = new Vector(1, 0, 0); double upDiff = Math.Acos(direction.DotProduct(up)); double downDiff = Math.Acos(direction.DotProduct(down)); double leftDiff = Math.Acos(direction.DotProduct(left)); double rightDiff = Math.Acos(direction.DotProduct(right)); double smallest = Math.Min(Math.Min(upDiff, downDiff), Math.Min(leftDiff, rightDiff)); // yes there's a precidence if they're the same value, it doesn't matter if (smallest == upDiff) { return Direction.Up; } else if (smallest == downDiff) { return Direction.Down; } else if (smallest == leftDiff) { return Direction.Left; } else { return Direction.Right; } }

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

यह सब एक साथ रखना

पीएस लेखक ने अनुवाद को मंजूरी दी और कहा कि आंकड़े वास्तव में दोनों अवतल हैं, लेकिन कांजी में से एक का अनुवाद उत्तल है, दूसरा अवतल है

एडवेंचर कैसे लिखें?