रेकलेस रेसर Arduino OLED गेम, AdafruitGFX और बिटमैप्स बेसिक्स: 6 स्टेप्स

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:19

इस ट्यूटोरियल में हम देखेंगे कि गेम में स्प्राइट्स के रूप में Adafruit_GFX.c लाइब्रेरी का उपयोग करके बिटमैप्स का उपयोग कैसे करें। सबसे सरल गेम जिसके बारे में हम सोच सकते हैं, एक साइड स्क्रॉलिंग लेन चेंजिंग कार गेम है, अंत में हमारे बीटा टेस्टर और सहायक कोडर ने "रेकलेस रेसर" को एक नाम के रूप में तय किया, क्योंकि यह मोटरवे के नीचे गलत तरीके से ड्राइव करने के लिए बहुत लापरवाह है !!।

हमारे सर्किट का डिज़ाइन ऊपर शामिल चित्रों में है और हमारे अंतिम प्रोजेक्ट / ट्यूटोरियल में यहाँ स्नेक इंस्ट्रक्शंस में विस्तृत है जो बताता है कि सर्किट कैसे काम करता है।

हमें आवश्यकता होगी

एडफ्रूट_जीएफएक्स

पेंट.नेट

Arduino IDE windowslinux

और कृपया बाकी उपकरणों के लिए स्नेक ट्यूटोरियल देखें।

आपूर्ति

सांप का खेल

चरण 1: पेंट.नेट स्थापित करना

हम पेंट.नेट का उपयोग कर रहे हैं क्योंकि सॉफ्टवेयर मुफ्त है इसलिए आप यहां पेंट.नेट डाउनलोड कर सकते हैं।

पेंट.नेट स्थापित करने के लिए डाउनलोड किए गए प्रोग्राम पर डबल क्लिक करें और सकारात्मक उत्तर दें जैसे कि, हां, ठीक है, मैं सहमत हूं और ऊपर दिए गए चित्र आपको एक निर्देश देंगे।

चरण 2: एक साधारण स्पलैश स्क्रीन बनाना

जब आप पेंट.नेट में हों तो फ़ाइल पर क्लिक करके एक नई छवि बनाएं, फिर नया, छवि का आकार 1260x620 पर सेट करें (पहली तस्वीर देखें) जब आपके पास नया पृष्ठ हो तो ठीक क्लिक करें पेंसिल का उपयोग करके केवल 2 रंगों काले और सफेद का उपयोग करके स्प्लैश स्क्रीन बनाएं उपकरण (तस्वीर 2), जब आपने अपनी स्प्लैश स्क्रीन छवि को ड्रा (या चिपकाया) किया है, तो छवि पर क्लिक करें फिर आकार बदलें (छवि 4), पॉप अप में आकार को 1260x620 से 126x62 (आपके प्रदर्शन से 2 पिक्सेल छोटा) में बदलें (pic5) ठीक क्लिक करें।

अगला फ़ाइल मेनू पर क्लिक करें और फिर (pic6) के रूप में सहेजें।

जब फ़ाइल प्रकार ड्रॉप डाउन मेनू में पॉप अप दिखाई देता है, तो बीएमपी (बिटमैप) चुनें। (pic7), एक फ़ाइल नाम टाइप करें और सहेजें पर क्लिक करें, जब पॉप अप 0 पर सेट होता है और 8 बिट पर सेट होता है, तो ठीक पर क्लिक करें (pic8)

चरण 3: बीएमपी को सी बिटमैप फ़ाइल में कनवर्ट करना

अब हमें अपनी छवि को एक ऐसे प्रारूप में बदलने की आवश्यकता है जिसे आर्डिनो समझ सके कि ऐसा करने के लिए बहुत सारे उपकरण उपलब्ध हैं, लेकिन मेरा "गो टू प्लेस" मार्लिन वेब साइट बिटमैप कन्वर्टर टूल है …

marlinfw.org/tools/u8glib/converter.html

इसलिए हम उपरोक्त लिंक का उपयोग करके वेबसाइट को खोलने के लिए इस अनुभाग को शुरू करते हैं जो कि pic1. में दिखाया गया है

फ़ाइल चुनें पर क्लिक करें और आपके द्वारा पहले बनाए गए बिटमैप का चयन करें (pic2)

मार्लिन बिटमैप कनवर्टर स्वचालित रूप से आपकी छवि को सी कोड में परिवर्तित कर देगा बाएं कोड को डबल क्लिक करें जो कोड को हाइलाइट करना चाहिए, फिर राइट क्लिक करें और कॉपी पर क्लिक करें (pic3)

अगला हम राइट क्लिक बनाते हैं और एक नया टेक्स्ट डॉक्यूमेंट बनाते हैं (pic4)

नए दस्तावेज़ पर डबल क्लिक करें, खुलने पर कोड को राइट क्लिक करें और पेस्ट करें (pic5)

इसके बाद हमें कोड के शीर्ष के पास लाइन जोड़नी होगी #include यह हमें बिटमैप डेटा को arduino पर फ्लैश मेमोरी में सहेजने की अनुमति देता है, फिर हम #define चौड़ाई, ऊंचाई और नाम का नाम बदलकर कुछ आसान करने के लिए इन्हें हाइलाइट किया जाता है तस्वीर 6 में, हम बेतरतीब ढंग से उत्पन्न वर्णों से उनका नाम बदलते हैं हम उनका नाम बदलकर नीचे दिए गए उदाहरण के लिए करते हैं

#LOGOWIDTH को परिभाषित करें

#LOGOHEIGHT परिभाषित करें

कास्ट अहस्ताक्षरित चार लोगोपिक कार्यक्रम

अगला क्लिक फ़ाइल फिर इस रूप में सहेजें, फ़ाइल को logo.c के रूप में सहेजें नोटपैड को बंद करें, logo.c पर राइट क्लिक करें और कॉपी पर क्लिक करें।

चरण 4: DrawBitmap का उपयोग करके लोगो प्रदर्शित करना

अब हम arduino IDE को लोड करते हैं और नया स्केच बनाते हैं और इसे logoexample.ino नाम से सहेजते हैं, arduino ide में एक चीट के रूप में आगे फ़ाइल मेनू पर क्लिक करें, फिर इस रूप में सहेजें, प्रोजेक्ट फ़ोल्डर में वापस जाएं और.c फ़ाइल में राइट क्लिक करें और पेस्ट करें। (pic2) फिर रद्द करें पर क्लिक करें, इससे आपको फ़ाइल में पेस्ट करने के लिए फ़ोल्डर में ब्राउज़ करने की बचत होती है।

Arduino IDE में निम्न कोड टाइप करें या ino में डाउनलोड करें।

(हम कॉपी और पेस्ट करने के बजाय टाइपिंग की सलाह देते हैं या नीचे दी गई फाइलों का उपयोग करना सीखने का सबसे अच्छा तरीका है)

#include /* यह इस बात पर निर्भर करता है कि आप कहां स्टोर करते हैं

इनो आमतौर पर फ़ोल्डर में C:\Users\~username\Documents\Arduino\project~name

और इस तरह हम अपने बिटमैप से लिंक करते हैं */

#शामिल

#शामिल

uint8_t बीएमपीएक्स, बीएमपीवाई = 0; /* 2 X 8 बिट पूर्णांकों के लिए आरक्षित मेमोरी, हमें केवल 8 बिट ints. की आवश्यकता है

चूंकि मान 128 (पिक्सेल) से अधिक कभी नहीं होता है, इसलिए हम 8 बिट इनट्स (जिसका अधिकतम मान 255 है) का उपयोग करके स्थान बचा सकते हैं */

व्यर्थ व्यवस्था()

{देरी (100); // डिस्प्ले आदि को डिस्प्ले पर पावर देने का समय दें। शुरू करें (SSD1306_SWITCHCAPVCC, 0x3C); // यह डिस्प्ले डिस्प्ले को इनिशियलाइज़ करना है। क्लियरडिस्प्ले (); // एक खाली स्क्रीन से शुरू करें}

/* कृपया ध्यान दें कि आपको इन टिप्पणियों को टाइप करने की आवश्यकता नहीं है, वे संदर्भ के लिए हैं ……………..

जिस कमांड पर हम ध्यान केंद्रित करने जा रहे हैं, वह है डिस्प्ले। ड्रॉबिटमैप, यही वह है जो हमारी स्प्लैश स्क्रीन को खींचता है। (बीएमपीएक्स, स्क्रीन पर एक्स अक्ष मान है जहां बिटमैप का एक्स एंकर बिंदु होगा और बीएमपीएक्स और बीएमपीवाई वे मान हैं जिन्हें हम आंदोलन बनाने में रुचि रखते हैं (बीएमपीवाई, स्क्रीन पर वाई अक्ष मान है जहां वाई एंकर बिटमैप का बिंदु यह होगा कि हमें संदर्भ नाम मिलेंगे जैसा कि हमने उन्हें logo.c में परिभाषित किया है (LOGOPIC, #included फ़ाइल में बिटमैप का नाम है। एंकर पॉइंट से बिटमैप (LOGOHEIGHT, एंकर पॉइंट से बिटमैप खींचने के लिए कितने पिक्सेल नीचे (Y) है, X और Y पिक्सेल के पार मैन्युअल रूप से दर्ज किया जा सकता है, लेकिन उन सभी को याद रखने की तुलना में पूर्वनिर्धारित लोगों का उपयोग करना आसान है (1, अंतिम मान रंग है क्योंकि स्क्रीन मोनो 0 काला 1 सफेद है। ठीक है अगली पंक्ति से टाइप करना शुरू करें: ¬D lol * / शून्य लूप () {display.clearDisplay (); // स्क्रीन को खाली करें // बिटमैप से खींचा गया ऊपर बाएँ, x, y, बिटमैप का नाम, चौड़ाई X, ऊँचाई Y, रंग डिस्प्ले। DrawBitmap(bmpX, bmpY, LOGOPIC, LOGOWIDTH, LOGOHEIGHT, 1); display.display(); // यह वास्तव में बफर को कभी भी डिस्प्ले पर खींचता है}

आप arduino कोड अपलोड करें और पुष्टि करें कि यह काम कर रहा है (pic3)।

चरण 5: बिटमैप स्प्राइट को स्थानांतरित करना

पहले के निर्देशों का उपयोग करते हुए पेंट.नेट का उपयोग करें और एक नई फ़ाइल बनाएं इसे 30x15 पिक्सेल (pic1) बनाएं और एक खुरदरी कार बनाएं हमारे युवा डिजाइनर पहले विंडस्क्रीन से शुरू करते हैं (चित्र 2 और 3)।

इसे फिर से विंडोज़ बीएमपी फ़ाइल के रूप में सहेजें (जैसा कि चरण 2 में है), सी बिटमैप (चरण 3) में कनवर्ट करें और कार.सी फ़ाइल (या जो भी आप कभी भी तय करें) को उसी फ़ोल्डर में रखें जैसे कि नए बनाए गए arduino ino (स्केच) फ़ाइल।

(p.s. car.c में #include लाइन जोड़ना याद रखें, यह हमें अक्सर पकड़ लेता था)

सबसे पहले अपने समकक्ष car.c. को लिंक करें

#शामिल

#include #include Adafruit_GFX.h> // https://github.com/adafruit/Adafruit-GFX-Library #include Adafruit_SSD1306 // https://github.com/adafruit/Adafruit-GFX-Library >

Adafruit_SSD1306 डिस्प्ले(128, 64); // डिस्प्ले का रिज़ॉल्यूशन सेट करें

/* bmpX/bmpY हमें इन मानों को बदलने और फिर से खींचने के रूप में चर होने की आवश्यकता है

स्क्रीन है कि हम आंदोलन एनीमेशन प्रभाव कैसे बनाते हैं। हिटसाइड और हिटटॉप यह है कि हम स्क्रीन में स्प्राइट कैसे रखते हैं */ uint8_t bmpX, bmpY=0; // 2 8 बिट इनट्स (0-255) के लिए आरक्षित मेमोरी हमें 128 की आवश्यकता नहीं है, सबसे बड़ी संख्या में बूल हिटसाइड = 0 का उपयोग किया जाएगा; बूल हिटटॉप = 0;

व्यर्थ व्यवस्था()

{देरी (100); // डिस्प्ले आदि को डिस्प्ले पर पावर देने का समय दें। शुरू करें (SSD1306_SWITCHCAPVCC, 0x3C); // यह डिस्प्ले डिस्प्ले को इनिशियलाइज़ करना है। क्लियरडिस्प्ले (); // एक खाली स्क्रीन से शुरू करें

}

शून्य लूप ()

{डिस्प्ले। क्लियरडिस्प्ले (); // स्क्रीन को खाली करें // ऊपर बाईं ओर से खींचा गया बिटमैप, x, y, बिटमैप का नाम, चौड़ाई X, ऊँचाई Y, रंग डिस्प्ले। DrawBitmap (bmpX, bmpY, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // डिस्प्ले। डिस्प्ले (); // यह वास्तव में बफर को कभी भी डिस्प्ले पर खींचता है / * इस तरह हम स्क्रीन के किनारे को ट्रैक करते हैं और तय करते हैं कि पिक्सेल को ऊपर से नीचे ले जाना है या नहीं या एक पिक्सेल को हटा दें (नीचे से ऊपर की ओर ले जाएँ) */ स्विच (हिटसाइड)) // यह बूल के आधार पर कार की दिशा चुनता है {केस 0: bmpX++; टूटना;

मामला एक:

बीएमपीएक्स--; टूटना; } // ये 2 अगर स्टेटमेंट बूल को सही या गलत पर सेट करता है अगर (bmpX == 0) {हिटसाइड = 0; } if(bmpX==96) // स्क्रीन की चौड़ाई घटा कार {हिटसाइड = 1; } // वाई अक्ष के लिए ऊपर के समान अगर (बीएमपीवाई == 0) {हिटटॉप = 0; } अगर (बीएमपीवाई == 49) // स्क्रीन की ऊंचाई कार की ऊंचाई से कम है {हिटटॉप = 1; } स्विच (हिटटॉप) {केस 0: bmpY++; टूटना; केस 1: बीएमपीवाई--; टूटना; }

}

आप संलग्न वीडियो में काम कर रहे कार्यक्रम को देख सकते हैं

चरण 6: ड्राइविंग गेम बनाना

सबसे पहले हम कुछ अलग कारों या बाधाओं को चित्रित करके शुरू करते हैं जैसे कि ट्यूटोरियल के पहले चरणों में उन्हें 30x15 पिक्सेल बनाते हैं। फिर हम उन्हें c बिटमैप्स में कनवर्ट करते हैं और कोड में लिंक करते हैं।

#include // इन रास्तों को बदलना होगा आश्रित

// जहां आप फाइलों को स्टोर करते हैं // संपादित करें: मुझे अभी पता चला है कि क्या आप // को " " से प्रतिस्थापित करते हैं, आपको पूर्ण पथ की आवश्यकता नहीं है // अपने स्वयं के पुस्तकालयों के साथ # शामिल करें

#शामिल

#शामिल करें #शामिल करें

#शामिल

#include // https://github.com/adafruit/Adafruit-GFX-Library #include <Adafruit_SSD1306 //

Adafruit_SSD1306 डिस्प्ले(128, 64); // प्रदर्शन मापदंडों को परिभाषित करें

चर और निश्चित मूल्यों को परिभाषित करें

// इनपुट पिन को परिभाषित करें ये arduino पर पिन हैं जो वे कभी नहीं बदलते हैं इसलिए #define#define INTPIN 3 // केवल पिन 2 और 3 UNO पर इंटरप्ट पिन हो सकते हैं #define UPPIN 4 // ये पिन से जुड़े tp प्रासंगिक स्विच #define हैं DWNPIN 5 #define LFTPIN 6 #define RHTPIN 7 #define SND 9 // दिशाओं को परिभाषित करें

#define DIRUP 1 // इन मूल्यों को "साँप" तय करने के लिए देखता है-

#define DIRDOWN 2 // जिस दिशा में सांप यात्रा करेगा #define DIRLEFT 3 #define DIRRIGHT 4

uint8_t dirPressed = 0; // उस दिशा को पंजीकृत करने के लिए मूल्य जिस पर पिन उच्च चला गया

// बूलियन स्टोर करते हैं कि कौन सा पिन ऊंचा हो गया

बूल बटप = 0; बूल बटन = 0; बूल बटलफ्ट = 0; बूल बटर = 0; // कार की स्थिति के लिए संस्करण uint8_t carPosX=1; uint8_t carPosY ={0, 16, 32, 48}; // सरणी को cahnging करने के लिए मूल्य की आवश्यकता है

uint8_t lanePosArr={0, 16, 32, 48}; // सरणी को स्टोर करने के लिए जहां प्रत्येक लेन है

uint8_t carPosYCnt =0; uint8_t carYTmp=0; // सड़क में लाइनों के लिए चर uint8_t RoadLineX1=51; // ये शुरुआत में पूर्वनिर्धारित होते हैं फिर रेखाएं निर्बाध दिखाई देती हैं uint8_t RoadLineX2=102; uint8_t रोडलाइनX3=153; uint8_t रोडलाइनएक्स4=254; uint8_t रोडलाइनX5=200;

// यह है कि एक समय में खेल क्षेत्र कितने पिक्सेल चलता है

uint8_t ड्रास्पीड = 4;

// दुश्मन के लिए युद्ध 0

uint8_t दुश्मन0PosX=255; uint8_t दुश्मन0PosY=0; uint8_t दुश्मन1PosX=255; uint8_t दुश्मन1PosY=0; uint8_t दुश्मन2PosX=255; uint8_t दुश्मन2PosY=0;

// वैरिएबल से रैंडम बाधाओं के लिए एक लेन नंबर असाइन करें

uint8_t लेनजेन = 0;

uint8_t लेनजेन0=0; uint8_t लेनजेन1=0; uint8_t लेनजेन2=0;

// स्कोर काउंटर

लंबा स्कोर = 0; // यह स्कोर है:/ योग्य लंबी तुलना = 0; // यह स्कोर को लांग हाईस्कोर=25 से तुलना करने के लिए अंतिम स्तर तक स्टोर करता है; uint8_t मीटरCnt=0;

यह वह जगह है जहाँ हम कार्य शुरू करते हैं

// यह कमांड का सेट है यदि इंटरप्ट सक्रिय है तो शून्य बाधित () {देरी (150); अद्यतन दिशा (); } // डीआईआर बूल की जांच करके अपडेट करें कि कौन सा मान दिशा में है //-------------------------- अद्यतन दिशा (खिलाड़ी) - ------------------------ शून्य अद्यतन दिशा () {//Serial.println ("अपडेटडायरेक्शन कॉल किया गया"); BUTUP = digitalRead (UPPIN); BUTDWN=digitalRead(DWNPIN); BUTLFT=digitalRead(LFTPIN); BUTRHT=digitalRead(RHTPIN); अगर (BUTUP==true) { dirPressed=DIRUP; } अगर (BUTDWN == सच) { dirPressed = DIRDOWN; } अगर (BUTLFT==true) { dirPressed=DIRLEFT; } अगर (BUTRHT==true) { dirPressed=DIRRIGHT; }

}

// ----------------------------- कार ले जाएँ --------------- ------------------------

// यह कार स्प्राइट के प्रस्तावक की स्क्रीन को अपडेट करेगा

शून्य चाल कार ()

{स्विच (dirPressed) {केस DIRUP: carPosYCnt--; CarPosY [carPosYCnt]; टोन (एसएनडी, 100, 100); अगर (carPosYCnt ==255) {carPosYCnt=0; } carYTmp=carPosY[carPosYCnt]; dirPressed=0; // Serial.println ("carPosY up"); // Serial.println (carPosYCnt); टूटना; केस DIRDOWN: carPosYCnt++; टोन (एसएनडी, 100, 100); अगर(carPosYCnt==4) {carPosYCnt=3; } // Serial.println ("carPosY"); // Serial.println (carPosYCnt); carYTmp=carPosY[carPosYCnt]; dirPressed=0; टूटना; // टिप्पणी की गई कार बाएं और दाएं टक्कर का पता लगाने में सक्षम है जो अभी तक अच्छी नहीं है / * मामला DIRLEFT: carPosX--; अगर (carPosX == 0) {carPosX = 1; } // Serial.println ("carPosX"); // Serial.println (carPosX); dirPressed=0; टूटना; */ केस DIRRIGHT: // सिर्फ मनोरंजन के लिए यदि आप दाएँ दबाते हैं तो गेम एक नॉइज़ टोन (SND, 100, 50) बना देगा; // कारपोसएक्स ++; // अगर (carPosX == 128) // {// carPosX = 127; // } // Serial.println ("carPosX"); // Serial.println (carPosX); // dirPressed = 0; टूटना; } अद्यतन प्रदर्शन (); }

//-------------------------- रैंडम पॉस एक्स ------------------- -----------

uint8_t randomPosX () // ये 2 रूटीन सिर्फ बाधाओं के लिए यादृच्छिक स्थिति उत्पन्न करते हैं

{ uint8_t posValTmp=0; posValTmp = यादृच्छिक (१२९, २३०); // सीरियल.प्रिंट्लन ("रैंडम एक्स"); // सीरियल.प्रिंट्लन (posValTmp); वापसी (posValTmp); }

//-------------------------- रैंडम पॉस वाई--------------------- -------------------

uint8_t randomPosY ()

{ uint8_t लेनवैल =0; लेनवैल = यादृच्छिक (0, 4); // यादृच्छिकता के लिए एक अतिरिक्त लेन जोड़ें यानी उस लेन में रहते हुए स्क्रीन पर कोई वस्तु नहीं //Serial.println("RandomY"); // Serial.println (lanePosArr [laneVal]); वापसी (लेनपोसएआर [लेनवैल]); }// ----------------------------- खेल की गति सेट करें-------------- -------------- शून्य सेटगेमस्पीड () // यह 20 से ऊपर जाने वाले स्तर को रोकता है जिससे गेम खेलने योग्य नहीं है {अगर (ड्रॉस्पीड <21) {ड्रॉस्पीड = ड्रॉस्पीड + 2; } }// ------------------------------------ क्रैश का पता लगाएं---------- ----------------------- शून्य का पता लगाएं क्रैश () {

अगर(दुश्मन0PosX=0&&enemy0PosY==carYTmp)

{// Serial.println ("ट्रैफिक 0 में CRAASSSSHHHHHHHEEEEDDD पर गेम ओवर"); खेल खत्म(); } if(enemy1PosX=0&&enemy1PosY==carYTmp) {//Serial.println ("ट्रैफिक 1 में गेम ओवर CRAASSSSHHHHHHHEEEEDDD"); खेल खत्म(); } if(enemy2PosX=0&&enemy2PosY==carYTmp) {//Serial.println ("ट्रैफिक 2 में गेम ओवर CRAASSSSHHHHHHHEEEEDDD"); खेल खत्म(); } }

ये दिनचर्याएँ हैं जो प्रदर्शन को आकर्षित करती हैं।

// ----------------------------- ड्रॉ रोड --------------- --------------------- शून्य ड्रॉरोड () // एक्स, वाई, लंबाई, चौड़ाई {डिस्प्ले।फिलरेक्ट (रोडलाइनएक्स 1, 15, 30, 4, सफेद); डिस्प्ले।फिलरेक्ट (रोडलाइनएक्स 1, 30, 30, 4, व्हाइट); डिस्प्ले.फिलरेक्ट (रोडलाइनएक्स1, 45, 30, 4, व्हाइट); डिस्प्ले.फिलरेक्ट (रोडलाइनएक्स 2, 15, 30, 4, व्हाइट); डिस्प्ले।फिलरेक्ट (रोडलाइनएक्स 2, 30, 30, 4, व्हाइट); डिस्प्ले।फिलरेक्ट (रोडलाइनएक्स 2, 45, 30, 4, व्हाइट); डिस्प्ले.फिलरेक्ट (रोडलाइनएक्स 3, 15, 30, 4, व्हाइट); डिस्प्ले।फिलरेक्ट (रोडलाइनएक्स 3, 30, 30, 4, व्हाइट); डिस्प्ले।फिलरेक्ट (रोडलाइनएक्स 3, 45, 30, 4, व्हाइट); डिस्प्ले.फिलरेक्ट (रोडलाइनएक्स 4, 15, 30, 4, व्हाइट); डिस्प्ले.फिलरेक्ट (रोडलाइनएक्स 4, 30, 30, 4, व्हाइट); डिस्प्ले।फिलरेक्ट (रोडलाइनएक्स 4, 45, 30, 4, व्हाइट); डिस्प्ले।फिलरेक्ट (रोडलाइनएक्स 5, 15, 30, 4, व्हाइट); डिस्प्ले।फिलरेक्ट (रोडलाइनएक्स 5, 30, 30, 4, व्हाइट); डिस्प्ले।फिलरेक्ट (रोडलाइनएक्स 5, 45, 30, 4, व्हाइट);

RoadLineX1=roadLineX1-drawSpeed;

RoadLineX2=roadLineX2-drawSpeed; RoadLineX3=roadLineX3-drawSpeed; RoadLineX4=roadLineX4-drawSpeed; RoadLineX5=roadLineX5-drawSpeed; डिस्प्ले.डिस्प्ले (); } //-------------------------------दुश्मनों को ड्रा करें --------------------------------------- शून्य शत्रु ड्रा () {// एक्स, वाई, बीएमपी नाम, चौड़ाई, ऊंचाई, रंग प्रदर्शन। ड्रा बिटमैप (दुश्मन 0 पीओएसएक्स, दुश्मन 0 पॉसी, ईएनईएमवाई 0, एनईएमवाई 0_WIDTH, ENEMY0_HEIGHT, 1); शत्रु0PosX=enemy0PosX-drawSpeed; display.drawBitmap(enemy1PosX, दुश्मन1PosY, ENEMY1, ENEMY1_WIDTH, ENEMY1_HEIGHT, 1); दुश्मन1PosX=enemy1PosX-drawSpeed; display.drawBitmap(enemy2PosX, दुश्मन2PosY, ENEMY2, ENEMY2_WIDTH, ENEMY2_HEIGHT, 1); दुश्मन2PosX=enemy2PosX-drawSpeed; डिस्प्ले.डिस्प्ले (); if(enemy0PosX>231&&enemy0PosX231&&enemy1PosX<255) { दुश्मन1PosX=randomPosX (); दुश्मन1PosY=randomPosY (); चेकडुप्लिकेट (); }

अगर (दुश्मन2PosX>२३१&&&enemy2PosX<२५५) { दुश्मन२PosX=randomPosX (); दुश्मन2PosY=randomPosY (); } } //-------------------------------------- अद्यतन प्रदर्शन -------- ---------------------------------------- शून्य अपडेटडिस्प्ले () {डिस्प्ले.क्लियरडिस्प्ले (); display.drawBitmap(carPosX, carPosY[carPosYCnt], CARSPRITE, 30, 15, 1); डिस्प्ले.फिलरेक्ट (100, 0, 28, 10, ब्लैक); डिस्प्ले.सेट कर्सर (१००, ०); display.setTextColor (सफेद, काला); डिस्प्ले.प्रिंट्लन (स्कोर); डिस्प्ले.डिस्प्ले ();

}

//------------------------ प्रेस लूप की प्रतीक्षा करें ------------------- ------

// यह होम स्क्रीन कोड है शून्य प्रतीक्षाफॉरप्रेस () {स्पलैशस्क्रीन (); बूल प्रतीक्षा = 0; // लूप समाप्त होता है जब यह सही होता है display.clearDisplay (); जबकि (प्रतीक्षा == 0) {

डिस्प्ले.फिलरेक्ट (१९, २०, ९०, ३२, ब्लैक); // पाठ के लिए रिक्त पृष्ठभूमि

display.setTextColor (सफेद); डिस्प्ले.सेट कर्सर (23, 24); डिस्प्ले.सेटटेक्स्टसाइज (0); display.println ("लापरवाह"); डिस्प्ले.सेट कर्सर (36, 34); display.println ("रेसर"); display.drawBitmap(74, 24, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // x y w h r col display.drawRoundRect(21, 21, 86, 23, 4, WHITE); // बॉर्डर स्नेक डिस्प्ले। ड्रारेक्ट (19, 20, 90, 33, व्हाइट); // बॉर्डर बॉक्स - 3 डिस्प्ले।सेट कर्सर (25, 43); डिस्प्ले.सेटटेक्स्टसाइज (0); // फ़ॉन्ट सामान्य डिस्प्ले पर वापस आ जाता है। प्रिंट्लन ("कोई भी कुंजी दबाएं"); डिस्प्ले.फिलरेक्ट (0, 0, 127, 8, ब्लैक); डिस्प्ले.सेट कर्सर (10, 0); डिस्प्ले.प्रिंट ("उच्च स्कोर:"); // उच्च स्कोर डिस्प्ले प्रदर्शित करें। प्रिंट (हाईस्कोर); डिस्प्ले.डिस्प्ले (); प्रतीक्षा = digitalRead (INTPIN); // यह देखने के लिए जांचें कि क्या कुंजी दबाई गई प्रतीक्षा 1 समाप्त होने पर बदल जाएगी dirPressed=0; // रीसेट बटन को बिना किसी दिशा के दबाएं } } //------------------------------------------ -----अपडेट गेम------------------------------------------ शून्य अपडेटगेम () {चालकार (); ड्रॉरोड (); दुश्मन ड्रा (); // शत्रु १ ड्रा (); // दुश्मन 2 ड्रा (); मीटर सीएनटी++; क्रैश का पता लगाएं (); if(metreCnt==5)// स्कोर बढ़ाने के लिए प्रत्येक 10 चक्रों के लिए एक अंक जोड़ता है {metreCnt=0; स्कोर++; } अगर(स्कोर==तुलना+5) सेटगेमस्पीड (); } नोटोन (एसएनडी); अद्यतन प्रदर्शन ();

}

// ------------------------------ खेल खत्म---------------- ----------------------------

// यह दिनचर्या मृत नायक कार के चारों ओर रेखाएँ खींचती है और फिर खेल को स्क्रीन पर प्रदर्शित करती है

शून्य गेमओवर ()

{टोन (एसएनडी, 200, 200); // ध्वनि चलाएं uint8_t linePosX, linePosY, pixwidth, pixheight=0; // कार लाइन के चारों ओर बक्से खींचने के लिए सेट वार्स PosX=carPosY; लाइनपॉसी=carYTmp; पिक्सविड्थ = 30; पिक्सहाइट = 15; display.drawRect (linePosX, linePosY, pixwidth, pixheight, WHITE); डिस्प्ले.डिस्प्ले (); for(int i=0;i<=26;i++) // यह विस्फोट का अनुकरण करने वाले आयतों में कार को घेरता है {linePosX=linePosX-2; लाइनपॉसी = लाइनपॉसी-2; पिक्सविड्थ=पिक्सविड्थ+4; पिक्सहाइट = पिक्सहाइट + 4; display.drawRect (linePosX, linePosY, pixwidth, pixheight, BLACK); display.drawRect (linePosX, linePosY, pixwidth, pixheight, WHITE); डिस्प्ले.डिस्प्ले (); टोन (एसएनडी, आई * 20, 50); देरी(10); } display.setTextSize(2); display.setTextColor (सफेद, काला); डिस्प्ले.सेट कर्सर (10, 23); टोन (एसएनडी, 50, 500); डिस्प्ले.प्रिंट ("गेम"); डिस्प्ले.डिस्प्ले (); देरी (500); टोन (एसएनडी, 40, 500); डिस्प्ले.प्रिंट ("ओवर"); डिस्प्ले.सेटटेक्स्टसाइज (0); डिस्प्ले.डिस्प्ले (); देरी (3000); पुनः खेल प्रारंभ करें(); प्रतीक्षाफोरप्रेस (); }

// ----------------------------------------- पुनः खेल प्रारंभ करें ----- -------------------------------------------------- -----

शून्य पुनरारंभ गेम () // यह उच्च स्कोर की प्रतिलिपि बनाता है और सभी आंकड़े रीसेट करता है और यादृच्छिक स्थिति उत्पन्न करता है

{अगर (स्कोर> = हाईस्कोर) // यह देखने के लिए जांचें कि क्या स्कोर उच्च स्कोर से अधिक है {हाईस्कोर = स्कोर; // सिंगल अगर स्टेटमेंट उच्च स्कोर को अपडेट करने के लिए}

स्कोर = 0;

ड्रास्पीड = 4; मीटर सीएनटी = 0; कारपोसवाईसीएनटी = 0; शत्रु0PosX = randomPosX (); दुश्मन0PosY=randomPosY (); दुश्मन1PosX=randomPosX (); दुश्मन1PosY=randomPosY (); दुश्मन2PosX=randomPosX (); दुश्मन2PosY=randomPosY (); नोटोन (एसएनडी);

चेकडुप्लिकेट ();

}

//------------------------------------------------ - चेक डुप्लीकेट ------------------------------------------- ------ शून्य चेकडुप्लिकेट () // यह देखने के लिए कि क्या बाधाएं एक ही गेम स्पेस पर कब्जा करती हैं {// Serial.println ("डुप्लिकेट चेक"); if(enemy2PosX>230&&enemy2PosX<255) { जबकि(enemy2PosY==enemy1PosY||enemy2PosY==enemy0PosY) { दुश्मन2PosY=randomPosY (); } }

if(enemy0PosX>230&&enemy0PosX230&&enemy2PosXenemy1PosX&&enemy2PosX230&&enemy0PosXenemy1PosX&&enemy0PosX

//------------------------------------------- स्प्लैश स्क्रीन --- --------------------------------

शून्य स्प्लैशस्क्रीन ()

{डिस्प्ले। क्लियरडिस्प्ले (); display.drawBitmap(0, 0, CRASH, CRASHWIDTH, CRASHHEIGHT, 1); डिस्प्ले.डिस्प्ले (); देरी (2000); }//------------------------------------------- सेट अप ------------------------------------------------- ----------- शून्य सेटअप () {देरी (100); // चीजों को शुरू होने दें // Serial.begin(9600); // इस और सभी सीरियल को अनकम्मेंट करें। फॉल्ट डायग डिस्प्ले के लिए कमांड। शुरू (SSD1306_SWITCHCAPVCC, 0x3C); डिस्प्ले.क्लियरडिस्प्ले (); display.setTextColor (सफेद, काला); display.setTextWrap (झूठा); डिस्प्ले.डिम (0); पिनमोड (इंटपिन, इनपुट); पिनमोड (अपपिन, इनपुट); पिनमोड (DWNPIN, INPUT); पिनमोड (एलएफटीपिन, इनपुट); पिनमोड (RHTPIN, INPUT);

अटैचइंटरप्ट (डिजिटलपिनटोइंटरप्ट (इंटपिन), इंटरप्रेस्ड, राइजिंग);

// बेतरतीब ढंग से अवरोधों को दुश्मन 0PosX = randomPosX (); दुश्मन0PosY=randomPosY (); दुश्मन1PosX=randomPosX (); दुश्मन1PosY=randomPosY (); दुश्मन2PosX=randomPosX (); दुश्मन2PosY=randomPosY (); चेकडुप्लिकेट (); // डुप्लिकेट स्थानों के लिए जाँच करें // Serial.println ("सेटअप पूर्ण"); स्प्लैश स्क्रीन(); प्रतीक्षाफोरप्रेस (); }//------------------------------------------- ----- कुंडली -------------------------------------------- ----------

शून्य लूप ()

{अपडेटगेम (); }

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