चार्ट के बजाय गणित चार्ट का उपयोग कर खेल

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

स्थानों में जमीन राहत एक साइन लहर जैसा दिखता है, और गोलियां एक्स की जड़ के दो सममित ग्राफ़ के समान हैं।

वास्तव में, आप जो कुछ भी स्क्रीन पर एक तरह से या किसी अन्य रूप में देखते हैं वह सब कुछ गणित, गणितीय घटता और ग्राफ़ से संबंधित है।

प्रागितिहास

एक बार, चैनल "नंबरफाइल" के वीडियो को देखने के दौरान, मुझे "द फॉर्मूला ऑफ एवरीथिंग" नामक एक बहुत ही दिलचस्प वीडियो सामग्री मिली।

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

$$

$$\ frac {1} {2} <\ lfloor mod (\ lfloor \ frac {y} {17} \ rfloor 2 ^ {-17 \ lfloor x \ rfloor - mod (\ lfloor y \ rfloor, 17)}, 2 ) \ rfloor$$

इस सूत्र ने मुझे वास्तव में दिलचस्पी दी, और मुझे एक विचार आया:

"और क्या होगा अगर आप एक गेम बनाते हैं, जहां साधारण बनावट के बजाय .png और .jpg प्रारूप की विभिन्न फाइलों में संग्रहीत किया जाता है, गणितीय ग्राफ़ और घटता का उपयोग किया जाएगा?

यह विचार मुझे दिलचस्प लग रहा था और इसे लागू करना मुश्किल था।

कार्य

मैंने निम्नलिखित कार्यों का सामना किया:

• खेल, गेमप्ले के अर्थ के साथ आओ
• व्युत्पन्न फ़ार्मुलों, जिनमें से ग्राफ़ वर्णों, गोलियों, सतहों की सिल्हूट होंगे जो मुझे चाहिए
• खेल में यह सब लागू करें

गेमप्ले और खेल का अर्थ

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

खेल में सूत्र और उनके बाद का कार्यान्वयन

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

गेम बनाने के लिए, c ++ प्रोग्रामिंग लैंग्वेज और SFML लाइब्रेरी को विंडोज़ बनाने और उन पर कुछ आकर्षित करने के लिए चुना गया था।

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

लेख के अंत में GitHub का लिंक होगा, जहां सभी कोड पोस्ट किए गए हैं। लेख में, कोड के केवल छोटे टुकड़े दिए जाएंगे ताकि इसे लिटाना न जाए।

ग्रह की सतह

ग्रह की सतह के लिए, मैंने निम्नलिखित सूत्र निकाले:

$$

$$f (x) = | sin (x) |$$

एक काफी सरल सूत्र, लेकिन जब लागू किया जाता है, तो किसी दिए गए साइनसॉइड की ऊंचाई और लंबाई को नियंत्रित करने की आवश्यकता होती है। इसके अलावा, राहत की वक्रता से बचने के लिए, x को avoid से गुणा किया जाता है। इसलिए, अंतिम कोड इस तरह दिखता है:

int groundC = ceil(abs(sin(((i+1)*groundScale*M_PI)))*groundHeight); 

अंतरिक्ष में ग्रह की बनावट

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

गोलियों

खेल से एक गोली की छवि। गोली चालू है।

गोलियों के लिए, एक बहुत ही सरल सूत्र चुना गया था:

$$

$$\ sqrt {x}$$

इस फॉर्मूले का कथानक एब्सिस्सा पर दिखाया गया है।

नायक

इसलिए हम सबसे जटिल फॉर्मूले के लिए तैयार हो गए।

मैंने बड़ी मुश्किल से नायक के सूत्र को काटा। यह इस तरह दिखता है:

$$

$$\ sqrt {x ^ {\ frac {1} {2.8}} + x ^ {10.9-x ^ {9.3-x}}} - 0.3$$

हां, बहुत कुटिल, बहुत बदसूरत सूत्र। लेकिन मुख्य बात सूत्र नहीं है, मुख्य परिणाम है।

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



अगला, हमें अंतरिक्ष में नायक की बनावट की आवश्यकता थी। यह इस तरह दिखता है:



यह एक सर्कल पर आधारित था। मुख्य केबिन निम्नलिखित सूत्र का उपयोग करके बनाया गया है:

$$

$$(x ^ {7-x}) ^ {\ frac {0.8} {x}}$$

इस फॉर्मूले का ग्राफ ऑर्डिनेट एक्सिस के साथ मिरर किया गया है।

इस तरह से यह सूत्र c ++ में दिखता है:

 int x = round(pow(pow(i, 7 - i), 0.8 / i)); 

दुश्मन और उनके साथी

छवि में दाईं ओर एक नीला स्पॉनर है, लाल वस्तुएं दुश्मन हैं।

Spauner एक साधारण ग्रह है जिसमें एक असामान्य पैटर्न है। यह पैटर्न सूत्र का एक ग्राफ है:

$$

$$पाप (x) * x ^ {0.8}$$

शत्रु बनावट फॉर्मूला:

$$

$$(x ^ {3-x}) ^ {\ frac {1} {x}}$$

पेड़

मैं स्वीकार करता हूं, मैं पेड़ों के सिल्हूट बनाने के लिए एक फार्मूला नहीं बना सका या चुन नहीं सका। लेकिन, पूरे गेम की मूल अवधारणा और नियमों का उल्लंघन न करने के लिए। किसी भी .png और .jpg प्रारूप फ़ाइलों का उपयोग न करने के लिए, मैंने एक चाल का उपयोग किया। मैंने पेड़ बनाने के लिए भग्न का उपयोग किया।


भग्न वृक्ष का उदाहरण

सबसे अधिक संभावना है कि आप सहमत होंगे कि भग्न पेड़ खुद को काफी उबाऊ लगते हैं। यदि आप यादृच्छिकता के कुछ तत्वों को जोड़ते हैं, उदाहरण के लिए, 2 शाखाएं जरूरी नहीं बढ़ सकती हैं, लेकिन 3 या 1 भी, या बिल्कुल भी नहीं। इसके अलावा, हर जगह झुकाव का एक ही कोण बनाना संभव नहीं है।

बेशक, कोई एक साधारण मशीन छद्म बना सकता है, जो कंप्यूटर टिक पर आधारित था, लेकिन निम्नलिखित विचार मुझे बहुत अच्छा लगता था:

"और क्या होगा यदि प्रत्येक पेड़ को एक विशिष्ट संख्या (बीज) दी जाए जिससे छद्म यादृच्छिक संख्याओं की गणना की जाएगी जो पेड़ के मापदंडों को प्रभावित करते हैं?"

सौभाग्य से, c ++ में एक अलग स्यूडोरैंडम लाइब्रेरी है।

नतीजतन, उत्पन्न पेड़ इस तरह दिखते हैं:



बाईं ओर एक पेड़ है जिसमें बीज 13, और दाईं ओर 22 है

और इन पेड़ों को उत्पन्न करने वाला कोड है:

 Branch Branch::createNewBranch(Branch cur, Tree* parent, float angleMultiplier, int level) { Vector2f sp(cur.startPoint.x, cur.startPoint.y); float randomAngle = ((*parent).getRand() * 15) - 5; float t = cur.thickness * 0.75; float l = cur.length * 0.67; float a = cur.angle + 30*angleMultiplier + randomAngle; sp.y -= (cos((cur.angle-180)*3.1415926 / 180) * cur.length); sp.x += (sin((cur.angle-180)*3.1415926 / 180) * cur.length); Branch gen(sp, t, l, a, level); if (level > 0) { int count = 100 * (*parent).getRand(); if (count >= 25 && count < 80) { //     ,      && count < 80,        ,  . , -          20%  10%,  ,    count<90 (*parent).addBranch(gen.createNewBranch(gen, parent, 1, level - 1)); (*parent).addBranch(gen.createNewBranch(gen, parent, -1, level - 1)); } if (count >= 80) { //    ,    count >= 90 if (count % 2 == 0) { (*parent).addBranch(gen.createNewBranch(gen, parent, -1, level - 1)); } else { (*parent).addBranch(gen.createNewBranch(gen, parent, 1, level - 1)); } } } return gen; } 

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

कुछ और कोड

ऊपर, मैंने केवल बनावट उत्पन्न करने के लिए कोड प्रदान किया। इस उपशीर्षक में, मैं खेल के कोड का वर्णन करूंगा। सभी कोड GitHub पर है, परियोजना का लिंक निष्कर्ष पर है।

खिलाड़ी

खिलाड़ी के पास दो अलग-अलग अपडेट विधियाँ हैं - स्पेसअप और प्लैनेटअप। तदनुसार, spaceUpdate खिलाड़ी को अपडेट करता है जब वह अंतरिक्ष में होता है, PlanetUpdate - जब ग्रह पर। ग्रह पर, खिलाड़ी के त्वरण और गति की गणना की जाती है। क्षैतिज त्वरण के आधार पर, प्लेट के झुकाव का कोण 30 डिग्री से -30 तक बदल जाता है। बाधाओं को स्वीकार करते हुए, खिलाड़ी की गति कम हो जाती है। एक्स अक्ष (0; mapSize.x) और y अक्ष के लिए इस तरह के अवरोध मौजूद हैं। Y अक्ष के लिए, चीजें थोड़ी अधिक जटिल हैं। एक न्यूनतम ऊंचाई होती है, जिसकी गणना निम्न प्रकार से की जाती है: पृथ्वी की न्यूनतम ऊंचाई को लिया जाता है, साइन वेव की ऊंचाई में जोड़ा जाता है और पेड़ों की ऊंचाई को जोड़ा जाता है। पेड़ों की ऊंचाई की गणना बहुत सरल तरीके से की जाती है - शाखा की प्रारंभिक लंबाई पेड़ की पीढ़ी के दौरान किए गए चक्रों की संख्या से गुणा होती है। कोई ऊपरी सीमा नहीं है - ऊपर से नक्शे से बाहर उड़ते हुए, खिलाड़ी को स्विचअप स्पेस और अंतरिक्ष खींचा जाता है।

SpaceUpdate निम्नानुसार संचालित होता है: खिलाड़ी के त्वरण और गति की गणना की जाती है। इसके बाद, खिलाड़ी के रोटेशन कोण की गणना की जाती है। कोण की गणना निम्नानुसार की जाती है: यदि त्वरण शून्य है, तो कोण की गणना खिलाड़ी की गति के सापेक्ष की जाती है, यदि त्वरण के सापेक्ष नहीं है। इसके अलावा, अंतरिक्ष में, खिलाड़ी को शूटिंग की संभावना है। शूटिंग निम्नानुसार होती है - एक बुलेट को एक खिलाड़ी की तरह रोटेशन के साथ बनाया जाता है और सूची में जोड़ा जाता है। किसी खिलाड़ी को अंतरिक्ष में अपडेट करते समय, इस सूची में प्रत्येक बुलेट को भी अपडेट किया जाता है। एक खिलाड़ी को प्रस्तुत करते समय, गोलियां भी खींची जाती हैं। इसके अलावा, अंतरिक्ष में, चीजें बाधाओं के साथ थोड़ी अधिक जटिल हैं। अंतरिक्ष को सेक्टरों में विभाजित किया गया है, प्रत्येक सेक्टर 4 ग्रहों में, कुल मिलाकर - 1 000 000 ग्रह और 25 000 क्षेत्र। प्रत्येक क्षेत्र में एक विशिष्ट आईडी है। यदि शेष को 500 से विभाजित करने पर 0 के बराबर है - एक बाया अवरोध है, यदि शेष 499 सही है, यदि 500 ​​से विभाजित होने पर परिणाम 0 है - ऊपरी बाधा मौजूद है, यदि 499 ऊपरी एक है। यदि कोई बाधाएं नहीं हैं, तो फ्रेम से बाहर उड़ते समय खिलाड़ी संबंधित क्षेत्र में चला जाता है।

अंतरिक्ष

मैंने पहले से ही इसे रेखांकित किया है, लेकिन अभी भी कुछ चीजें बनी हुई हैं। अंतरिक्ष के प्रत्येक क्षेत्र में 4 ग्रह हैं। जब कोई खिलाड़ी ई कुंजी दबाता है, अगर वह इस ग्रह से दूर त्रिज्या है, तो खिलाड़ी ग्रह पर चला जाता है।

दुश्मनों

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

Spauner

अंतरिक्ष के प्रत्येक क्षेत्र में 1 स्पॉनर होता है। Spauners विभिन्न आकारों के हो सकते हैं। आकार खिलाड़ी की दृश्यता को प्रभावित करता है। यदि खिलाड़ी दृश्यता के अपने क्षेत्र में है, तो स्पावर हर 5 सेकंड में दुश्मन बनाता है, लेकिन दुश्मनों की संख्या 10 से अधिक नहीं हो सकती है।

निष्कर्ष

लगभग एक सप्ताह बिताने के बाद, मैंने एक गेम बनाया जो किसी भी .png या .jpg फ़ाइलों का उपयोग नहीं करता है।

GitHub पर परियोजना के लिए लिंक

उन लोगों के लिए जो परियोजना को डाउनलोड करने और गेम चलाने के लिए बहुत आलसी हैं, गेमप्ले पर एक छोटा वीडियो: