அர்டுடினோ மற்றும் நோக்கியா 5110 வரைகலை காட்சியைப் பயன்படுத்தி விண்வெளி பந்தய விளையாட்டு

புரோகிராமிங் எப்போதுமே வேடிக்கையாக உள்ளது, மேலும் இது அர்டுயினோ போன்ற மேம்பாட்டு தளங்களுடன் மிகவும் சிறப்பாக உள்ளது. இங்குள்ள ஒவ்வொரு புரோகிராமரும் அவர்கள் கற்றுக் கொள்ளும் / பயிற்சி செய்யும் மொழியைப் பயன்படுத்தி ஒருவித விளையாட்டை உருவாக்க முயற்சித்திருப்பார்கள். இது அவர்களின் நிரலாக்க திறன்களை வேடிக்கையான மற்றும் உற்பத்தி முறையில் மாற்றியமைக்க உதவுகிறது. நான் ஆர்டுயினோவை அறிமுகப்படுத்தியதிலிருந்தே ஒரு பெரிய ரசிகனாக இருந்தேன், எப்போதும் அதனுடன் குளிர்ச்சியான ஒன்றை முயற்சிக்க விரும்பினேன், நோக்கியா 5110 போன்ற ஒரு வரைகலை எல்.சி.டி உடன் எவ்வளவு குளிர்ச்சியைப் பெற முடியும் என்பதைக் கண்டறிந்தபோது, ​​அர்டுயினோவுடன் ஒரு விளையாட்டை உருவாக்கும் எனது யோசனை உதைத்தது. சில நிரலாக்க திறன்களை மேம்படுத்துவதற்கும் ஒரே நேரத்தில் வேடிக்கை பார்ப்பதற்கும் இது ஒரு சுவாரஸ்யமான வழியாகும், எனவே உங்கள் விளையாட்டையும் வளர்ப்பதில் நீங்கள் ஆர்வமாக இருக்கலாம். எனவே இந்த டுடோரியலில் Arduino மற்றும் Graphical LCD களைப் பயன்படுத்தி ஒழுக்கமான விளையாட்டை எவ்வாறு உருவாக்கலாம் என்பதைக் கற்றுக்கொள்வோம்.

நாங்கள் ஏற்கனவே பழைய பாம்பு விளையாட்டை அர்டுயினோவைப் பயன்படுத்தி உருவாக்கியுள்ளோம், எனவே இந்த நேரத்தில் நாங்கள் புதிதாக ஒன்றை முயற்சிக்கிறோம், இந்த விளையாட்டுக்கு ஸ்பேஸ் ரேஸ் கேம் என்று பெயரிட்டோம், அங்கு உங்கள் கப்பலை ஜாய்ஸ்டிக் பயன்படுத்தி எதிரி கப்பல்களில் இருந்து பாதுகாப்பாக வைத்திருக்க வேண்டும்.

விளையாட்டு திட்டம்:

நாங்கள் தொடங்குவதற்கு முன், உங்கள் விளையாட்டு உண்மையில் எவ்வாறு செயல்படும் என்பதைத் திட்டமிடுவது மிகவும் முக்கியம். எனது வன்பொருள் தேர்வுக்காக நோக்கியா 5110 கிராஃபிக்கல் எல்சிடி மற்றும் ஜாய்ஸ்டிக் உடன் சென்றேன். இந்த டுடோரியலில் நீங்களும் இதைத் தேர்ந்தெடுத்துள்ளீர்கள் என்று கருதுகிறேன். நோக்கியா 5110 அதிக இடத்துடன் வரவில்லை என்பதால், எங்கள் காட்சியின் 84 * 48 பிக்சல் தீர்மானத்திற்குள் எங்கள் முழு விளையாட்டையும் திட்டமிட்டுள்ளோம். நோக்கியா 5110 எல்சிடியை அர்டுயினோவுடன் ஜாய்ஸ்டிக் மற்றும் அர்டுயினோவுடன் எவ்வாறு இடைமுகப்படுத்துவது என்பது குறித்த பயிற்சிகளை நாங்கள் ஏற்கனவே செய்துள்ளோம்.

இந்த இடத்திற்குள் நாம் கேமிங் பகுதி மற்றும் ஸ்கோர் போர்டு பகுதியில் இறுக்கமாக பொருத்த வேண்டும், இது மதிப்பெண் மற்றும் பொருள் போன்றவற்றைக் காண்பிக்கும். பிக்சல் இருப்பிடங்களைக் கண்காணித்து அவற்றை திரையில் புதுப்பிக்க நீங்கள் பொருட்களை எங்கு வைக்கிறீர்கள் என்பதற்கான பிக்சல் இருப்பிடத்தை அறிந்து கொள்வது மிகவும் முக்கியம்.

விளையாட்டுத் திரை தோற்றம் முடிவு செய்யப்பட்டவுடன், எங்கள் விளையாட்டில் உள்ள எழுத்துக்களை நாங்கள் தீர்மானிக்க வேண்டும். எனது விளையாட்டிற்கு எங்களிடம் இரண்டு மட்டுமே உள்ளன, இது ஒரு விண்வெளி கப்பல் மற்றும் ஒரு எதிரி பாத்திரம் ஆகும், இது ஒரு அன்னிய விண்கலம் போல இருக்க வேண்டும். நோக்கியா எல்சிடி பிட்மேப் படங்களை காண்பிக்க முடியும், எனவே எனது விண்வெளி கப்பலையும் எதிரிகளையும் காட்ட அந்த விருப்பத்தைப் பயன்படுத்த முடிவு செய்தேன்.

ஆகவே, வேற்றுகிரகவாசிகளின் விண்கலங்கள் வழியாக ஓடும் ஒரு விண்வெளி கப்பல் எங்களிடம் இருக்கும், இந்த விண்கலம் வெளிநாட்டினருடன் ஒரு வெற்றியைத் தவிர்ப்பதற்காக மாற்றங்களுக்கு மூன்று பாதைகளைக் கொண்டிருக்கும். எல்லா நேரத்திலும் வேற்றுகிரகவாசிகள் இரண்டு தடங்களை மட்டுமே ஆக்கிரமிக்க முடியும், மேலும் வீரர் இலவச பாதையில் ஓட்ட முடியும். இந்த யோசனைகள் முடிந்ததும், வன்பொருள் மற்றும் நிரலாக்கத்துடன் தொடரலாம்.

சுற்று வரைபடம்:

இந்த Arduino விளையாட்டுக்கான சுற்று மிகவும் எளிது; நாம் நோக்கியா 5110 எல்சிடி தொகுதி மற்றும் ஜாய்ஸ்டிக் ஆகியவற்றை அர்டுயினோவுடன் இடைமுகப்படுத்த வேண்டும். முழுமையான சுற்று வரைபடம் கீழே காட்டப்பட்டுள்ளது

நோக்கியா 5110 எல்சிடி 3.3 வி மற்றும் ஜாய்ஸ்டிக் தொகுதி வேலை மகன் 5 வி உடன் வேலை செய்கிறது, எனவே எல்சிடியை 3.3 வி உடன் மட்டுமே இணைக்கிறீர்கள் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள், ஏனெனில் 5 வி அதை நிரந்தரமாக சேதப்படுத்தும். எல்.சி.டி ஆர்டுயினோவுடன் எஸ்.பி.ஐ நெறிமுறை மூலம் தொடர்பு கொள்கிறது மற்றும் ஜாய்ஸ்டிக் மின்னழுத்த மாற்றத்தை படிக்க ஏ.டி.சி.யை மட்டுமே படிக்கிறது. இணைப்பு அமைவு இது போன்ற ஏதாவது கீழே இருக்கும்

முன்நிபந்தனைகள்:

நாங்கள் நிரலாக்கப் பகுதிக்குள் நுழைவதற்கு முன்பு, காட்சி தொகுதி மற்றும் ஜாய்ஸ்டிக் ஆகியவற்றுடன் நீங்கள் வசதியாக இருப்பது முக்கியம், எனவே அவற்றைப் பற்றி மேலும் அறிய பின்வரும் பயிற்சிகளைப் பயன்படுத்தலாம், பின்னர் நாங்கள் திரும்பி வருவோம். இது தேவை!

• நோக்கியா 5110 எல்சிடி அர்டுயினோவுடன் இடைமுகம்
• அர்டுயினோவுடன் ஜாய்ஸ்டிக் தொகுதி இடைமுகம்

விண்வெளி ரேஸ் விளையாட்டுக்கான புரோகிராமிங் அர்டுயினோ:

விளையாட்டிற்கான முழுமையான நிரலை இந்த பக்கத்தின் இறுதியில் காணலாம்; நீங்கள் அதை உங்கள் Arduino IDE இல் நேரடியாகப் பயன்படுத்தலாம் மற்றும் அதை உங்களிடம் போர்டில் பதிவேற்றலாம். ஆனால் குறியீட்டிற்குள் உண்மையில் என்ன நடக்கிறது என்பதை நீங்கள் தெரிந்து கொள்ள விரும்பினால் மேலும் படிக்கவும்.

எங்கள் நூலக தலைப்பு கோப்புகளைச் சேர்ப்பதன் மூலம் நாங்கள் எப்போதும் எங்கள் திட்டத்தைத் தொடங்குகிறோம், இந்த திட்டத்திற்கு எங்களுக்கு மூன்று நூலகங்கள் தேவை, அவற்றில் SPI நூலகம் இயல்பாகவே உங்கள் IDE இல் சேர்க்கப்படுகிறது. மற்ற இரண்டு நூலகங்களை அடாஃப்ரூட் கிதுப் பக்கத்திலிருந்து பதிவிறக்கம் செய்ய வேண்டும். நூலகத்தை எவ்வாறு சேர்ப்பது என்று உங்களுக்குத் தெரியாவிட்டால், முன்நிபந்தனைகள் பிரிவில் குறிப்பிடப்பட்டுள்ள எல்சிடி இடைமுக பயிற்சியைப் பின்பற்றவும்.

#சேர்க்கிறது // எஸ்பிஐ தகவல்தொடர்புக்கான நூலகம் # அடங்கும் // எல்சிடிக்கான கிராபிக்ஸ் லிப் # அடங்கும் // நோக்கியா 5110 எல்சிடி நூலகம்

நீங்கள் டுடோரியலைப் பின்தொடர்ந்திருந்தால் , பிட்மேப் படங்களை எல்சிடியில் காண்பிக்க முடியும் என்பதை நீங்கள் அறிந்து கொள்ள வேண்டும். எனவே டுடோரியலில் குறிப்பிடப்பட்டுள்ள மென்பொருளைப் பயன்படுத்தி தேவையான படத்தை நாங்கள் பிட்மேப் குறியீடாக மாற்ற வேண்டும், நீங்கள் இணையத்திலிருந்து எந்தப் படத்தையும் தேர்ந்தெடுத்து அவற்றை பிட்மேப் குறியீடாக மாற்றுவதன் மூலம் பயன்படுத்தலாம். படம் எங்கள் எல்சிடி திரையில் காண்பிக்கப்படும் அளவுக்கு எளிமையானது என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள், உண்மையில் எல்சிடி திரையில் முயற்சிக்கும் முன் மாதிரிக்காட்சியை சரிபார்க்கவும். எங்கள் திட்டத்தில் நாங்கள் இரண்டு பிட்மேப் எழுத்துக்களைப் பயன்படுத்தினோம், ஒன்று விண்வெளி கப்பல், மற்றொன்று எதிரி கப்பல், இரண்டிற்குமான பிட்மேப் குறியீடு கீழே காட்டப்பட்டுள்ளபடி எங்கள் குறியீட்டில் சேர்க்கப்பட்டுள்ளது.

// பிட்மேப் தரவு விண்கலம் க்கான கையொப்பமிடாத எரிப்பதை PROGMEM கப்பல் கான்ஸ்ட் நிலையான = { B00000000, B00000000, B00000001, B00000000, B00000011, B10000000, B00000010, B10000000, B00000010, B11000000, B00000111, B11000000, B00001101, B11100000, B00011111, B11110000, B00111111, B11111000, B01111111, B11111100, B01111111, B11111100, B01111111, B11111100, B00011111, B11110000, B00000111, B11100000, B00000000, B00000000, }; // எதிரிக்கான நிலையான கான் கையொப்பமிடப்படாத கரி PROGMEM எதிரி = { B00000101, B11000000, B00001011, B11100000, B00000011, B11100000, B00110011, B11111000, B01111111, B11111100, B10111111, B11111010, B01110111, B11011100, B01111110, B11111100, B00111111, B11111100, B11101111, B11101110, B11000001, B00000110, B10000001, B00000010, B10000000, B00000010, B00000000, B00000000, };

நோக்கியா எல்சிடி 5110 டிஸ்ப்ளே இணைக்கப்பட்டுள்ள ஊசிகளை நாம் குறிப்பிட வேண்டும். காட்சி SPI தகவல்தொடர்புகளைப் பயன்படுத்தி தொடர்பு கொள்ளப்படுகிறது, நீங்கள் மேலே உள்ள சுற்று வரைபடத்தைப் பின்பற்றியிருந்தால், எல்சிடியைத் தொடங்குவதற்கான குறியீடு பின்வருமாறு இருக்கும், அதை நீங்கள் மாற்ற வேண்டியதில்லை.

Adafruit_PCD8544 display = Adafruit_PCD8544 (7, 6, 5, 4, 3); // குறிப்பிடுக இது எல்சிடி இணைக்கப்பட்டுள்ளது ஊசிகளையும்

அமைவு செயல்பாட்டின் உள்ளே, சீரியல் மானிட்டரை 9600 பாட் வீதத்தில் தொடங்குவோம், இதன்மூலம் விஷயங்களை பிழைத்திருத்தலாம், பின்னர் எல்சிடி டிஸ்ப்ளேவைத் தொடங்கலாம். எல்சிடி டிஸ்ப்ளேவின் மாறுபாட்டை நாங்கள் அமைக்க வேண்டும், ஒவ்வொரு டிஸ்ப்ளேவும் வேறுபட்ட கான்ட்ராஸ்ட் மட்டத்தில் சிறப்பாக செயல்படும், எனவே உங்களுக்கு எது பொருத்தமானது என்பதை சரிபார்க்க மதிப்புடன் விளையாடுங்கள். இறுதியாக புதியதாகத் தொடங்க காட்சித் திரையையும் அழிக்கிறோம்.

void setup () { Serial.begin (9600); // பிழைத்திருத்தத்திற்கான சீரியல் மானிட்டர் display.begin (); // எல்சிடி தகவல்தொடர்பு காட்சியைத் தொடங்குங்கள்.செட் கான்ட்ராஸ்ட் (30); // காட்சி காட்சியின் மாறுபாட்டை அமைக்கவும். ClearDisplay (); // திரையை அழித்து புதியதைத் தொடங்கவும் }

திரை அழிக்கப்பட்டவுடன், லூப் செயல்பாட்டில் குதித்து, அங்கு விளையாட்டுத் திரையைக் காண்பிப்போம். விளையாட்டுத் திரை என்பது வேறொன்றுமில்லை, இது விளையாட்டுக்கான அடிப்படை எலும்புக்கூட்டை ஸ்கோர் மற்றும் வேக மட்டத்துடன் காண்பிக்கும். மூன்று வரிகளை எல்லைகளாக வரைய வரிச் செயல்பாட்டைப் பயன்படுத்தினோம், வலதுபுறத்தில் பழைய ரெட்ரோ கையில் வைத்திருக்கும் கேமிங் சாதனங்களைப் போலவே உரை மதிப்பையும் வேகத்தையும் காண்பிப்போம்.

வெற்றிட கேம்கிரீன் () { // திரைக்கான எல்லையை வரையவும் display.drawLine (0, 0, 0, 47, BLACK); display.drawLine (50, 0, 50, 47, கருப்பு); display.drawLine (0, 47, 50, 47, கருப்பு); // இயல்புநிலை உரைகளை உள்ளிடவும் display.setTextSize (1); display.setTextColor (BLACK); display.setCursor (52,2); display.println ("வேகம்"); display.setCursor (54,12); display.println (game_speed); display.setCursor (52,25); display.println ("ஸ்கோர்"); display.setCursor (54,35); display.println (மதிப்பெண்); }

அடுத்து விண்வெளி கப்பலைக் கட்டுப்படுத்த பயனரை அனுமதிக்க அவரிடமிருந்து உள்ளீட்டைப் பெற வேண்டும். முள் A1 உடன் இணைக்கப்பட்டுள்ள ஜாய்ஸ்டிக் தொகுதியிலிருந்து உள்ளீடு பெறப்படும். சென்சாரிலிருந்து அனலாக் மதிப்பு நகர்த்தப்படாவிட்டால் 512 ஆக இருக்கும், மேலும் எக்ஸ்-அச்சில் நகரும்போது அதிகரிக்கும் மற்றும் குறையும். பயனர் இடது அல்லது வலது பக்கம் செல்ல விரும்புகிறாரா என்பதை தீர்மானிக்க இந்த மதிப்புகளைப் பயன்படுத்துகிறோம். கீழேயுள்ள நிரலைப் புரிந்துகொள்வது உங்களுக்கு கடினமாக இருந்தால், முன் தேவைகளில் குறிப்பிடப்பட்டுள்ள அர்டுயினோ டுடோரியலுடன் ஜாய்ஸ்டிக் இடைமுகத்தைப் படிக்க வேண்டும்.

// பயனரிடமிருந்து உள்ளீட்டைப் பெறுக ஜாய்_எக்ஸ் = அனலாக் ரீட் (ஏ 1); // ஜாய்ஸ்டிக்கிலிருந்து எக்ஸ் வாய் படிக்கவும் (ஜாய்_எக்ஸ் <312 && பிஓஎஸ்! = 1 && கட்டுப்பாடு == உண்மை) // மகிழ்ச்சி குச்சி வலதுபுறமாக நகர்ந்தால் {POS--; control = false;} // விண்வெளிக் கப்பலின் குறைவு நிலை (ஜாய்_எக்ஸ்> 712 && பிஓஎஸ்! = 3 && கட்டுப்பாடு == உண்மை) // மகிழ்ச்சி குச்சி வலதுபுறமாக நகர்ந்தால் {பிஓஎஸ் ++; control = false;} // விண்வெளிக் கப்பலின் அதிகரிப்பு நிலை என்றால் (ஜாய்_எக்ஸ்> 502 && ஜாய்_எக்ஸ் <522) // ஜாய்ஸ்டிக் ஆரம்ப நிலைக்குத் திரும்பினால் கட்டுப்பாடு = உண்மை; // அடுத்த நகர்வுக்கு அதைத் தயாரிக்கவும் // பெறப்பட்ட பயனரிடமிருந்து உள்ளீடு

பயனரிடமிருந்து விண்கலத்தின் நிலையைப் பெற்ற பிறகு, அந்த குறிப்பிட்ட இடத்தில் விண்வெளி கப்பலை வைக்க வேண்டும். கீழேயுள்ள செயல்பாட்டைப் பயன்படுத்துகிறோம் மற்றும் நிலையின் மதிப்பை ஒரு அளவுருவாக அனுப்புகிறோம், பின்னர் விண்வெளி கப்பல் அந்தந்த பாதையில் வைக்கப்படும் நிலையின் அடிப்படையில்.

void player_car (char pos) // பயனர் தேர்ந்தெடுக்கப்பட்ட நிலையின் அடிப்படையில் விண்கலத்தை வைக்கவும் { if (pos == 1) display.drawBitmap (2, 32, கப்பல், 15, 15, BLACK); if (pos == 2) display.drawBitmap (18, 32, கப்பல், 15, 15, கருப்பு); if (pos == 3) display.drawBitmap (34, 32, கப்பல், 15, 15, கருப்பு); }

இப்போது எங்கள் விண்கலம் திரையில் வைக்கப்பட்டு, ஓட்டப்பந்தயத்திற்கு தயாராக இருப்பதால், வீரருடன் போட்டியிடும் எதிரி கப்பல்களை அறிமுகப்படுத்த வேண்டும். ஒவ்வொரு முறையும் ஒரு எதிரி கப்பல் திரையைத் தாண்டும்போது அவர் இறந்துவிட்டார் என்று கருதுகிறோம், அவர் இறந்தவுடன் ஒரு புதிய விண்வெளி கப்பலை உருவாக்க வேண்டும். கீழேயுள்ள செயல்பாடு அப்படியே செய்கிறது. இது இரண்டு எதிரி கப்பல்களுக்கு ஒரு புதிய நிலையை உருவாக்கி அவற்றை திரையின் மேல் வைக்கிறது.

if (எதிரி_தேதி) // எதிரி கப்பல்களின் சோதனை இறந்துவிட்டது {// அவை இறந்திருந்தால் எதிரி_0_போஸ் = பிஓஎஸ்; // விண்வெளி கப்பலுக்கு மேலே முதல் எதிரியை உருவாக்குங்கள் எதிரி_1_போஸ் = சீரற்ற (0,4); // வேறு ஏதேனும் சீரற்ற இடத்தில் பாதுகாப்பான எதிரியை உருவாக்குங்கள் எதிரி_பஸ் = 0; // எதிரிகளை மேலே கொண்டு வாருங்கள் எதிரி_தேடை = பொய்; // எதிரி உருவாக்கப்பட்டது, அதனால் அவர்கள் இனி இறந்துவிட மாட்டார்கள் }

எதிரி கப்பல்களை திரையின் மேல் வைத்த பிறகு, அதை கீழே கொண்டு வர வேண்டும், இதனால் அது எங்கள் வீரர் மேல்நோக்கி ஓடுவதைப் போல ஈட்டுகிறது, இதைச் செய்ய நாம் கட்டத்தை அதிகரிக்க வேண்டும் (படம் காட்டப்படும் இடம்) அது மெதுவாக கீழே வருகிறது. கீழே காட்டப்பட்டுள்ளபடி எதிரி கப்பல்களுக்கும் இது செய்யப்படுகிறது

எதிரி_ஷிப் (எதிரி_0_போஸ், எதிரி_பஸ்); எதிரி_ கட்டம் ++; // முதல் எதிரியை திரையில் வைத்து அவரை எதிரி_ஷிப்பை (எதிரி_1_போஸ், எதிரி_பஸ்) கீழே தள்ளுங்கள்; எதிரி_ கட்டம் ++; // செகண்ட் எதிரியை திரையில் வைத்து அவரை கீழே தள்ளுங்கள்

எதிரி_ஷிப் செயல்பாடு கீழே காட்டப்பட்டுள்ளது, இது பிளேயர் கார் செயல்பாட்டிற்கு மிகவும் ஒத்திருக்கிறது, ஆனால் இங்கே நமக்கு இரண்டு அளவுருக்கள் உள்ளன. ஒன்று எதிரிகளை ஒரு பாதையில் வைப்பதற்கும், மற்றொன்று எதிரிகளை கீழே நோக்கி நகர்த்துவதற்கும்.

void සතුர்_ஷிப் (எண்ணாக இடம், முழு கட்டம்) // எதிரி_ஷிப்பை புதிய இடத்திலும் கட்டத்திலும் வைக்கவும் { if (இடம் == 1) display.drawBitmap (2, கட்டம், எதிரி, 15, 15, கருப்பு); if (இடம் == 2) display.drawBitmap (18, கட்டம், எதிரி, 15, 15, கருப்பு); if (இடம் == 3) display.drawBitmap (34, கட்டம், எதிரி, 15, 15, கருப்பு); }

விண்வெளிக் கப்பல் எதிரி கப்பலைத் தவிர்த்துவிட்டதா என்பதை அடுத்த குறியீடு சரிபார்க்க வேண்டும். இதைச் சரிபார்க்க எதிரி கப்பல்களின் நிலை மற்றும் வீரரின் விண்வெளி கப்பல் ஆகியவற்றை நாம் அறிந்து கொள்ள வேண்டும். எல்லாவற்றையும் நாங்கள் அறிந்திருப்பதால், விண்வெளி கப்பலின் நிலை எதிரி கப்பலைப் போலவே இருக்கிறதா என்று சோதிக்க வேண்டும். விண்வெளிக் கப்பலின் அருகே எதிரி கப்பல் அடைந்திருந்தால் மட்டுமே இதைச் சரிபார்க்கிறோம். வீரர் எதிரியைத் தவிர்க்கவில்லை என்றால், அது விளையாட்டு முடிந்துவிட்டது.

if (සතුர்_ கட்டம்> 22 && ((எதிரி_0_போஸ் == பிஓஎஸ்) - (எதிரி_1_போஸ் == பிஓஎஸ்))) // விண்கலம் எதிரி கேம்_ஓவர் () ஐத் தொட்டால் ; // விளையாட்டைக் காண்பி

வீரர் வெற்றிகரமாக எதிரியைத் தவிர்த்துவிட்டால், நாம் எதிரியைக் கொன்று வீரருக்கு ஒரு புள்ளியைக் கொடுக்க வேண்டும். இதைச் செய்ய, எதிரி திரையின் அடிப்பகுதியை அடைந்துவிட்டாரா என்பதைச் சரிபார்க்கிறோம், அது இருந்தால் கீழே உள்ள குறியீட்டைப் பயன்படுத்தி அதைக் கொன்றுவிடுகிறோம்

if (எதிரி_ கட்டம்> 40) // விண்வெளி கப்பல் எதிரிகளிடமிருந்து தப்பித்தால் {எதிரி_தேடை = உண்மை; மதிப்பெண் ++;} // மதிப்பெண்ணை அதிகரித்து எதிரிகளைக் கொல்லுங்கள்

அதிக மதிப்பெண்களைப் பெறுவதால் விளையாட்டின் சிரமத்தை அதிகரிக்காவிட்டால் என்ன வேடிக்கையாக இருக்கும். எனவே நாங்கள் மற்றொரு செயல்பாட்டைப் பயன்படுத்துகிறோம், பின்னர் அது வீரரின் மதிப்பெண்ணைக் கண்காணிக்கும் மற்றும் மதிப்பெண்ணின் அடிப்படையில் அது விளையாட்டின் வேகத்தை அதிகரிக்கும். தாமத செயல்பாட்டைப் பயன்படுத்துவதன் மூலம் வேகம் உண்மையில் கட்டுப்படுத்தப்படுகிறது, இது விளையாட்டின் புதுப்பிப்பு இடைவெளியைக் கட்டுப்படுத்தும், இதனால் இது வேகமாக அல்லது மெதுவாக இருக்கும்.

void Level_Controller () // மதிப்பெண்ணின் அடிப்படையில் விளையாட்டின் வேகத்தை அதிகரிக்கவும். { if (மதிப்பெண்> = 0 && மதிப்பெண் <= 10) // மதிப்பெண் 0-10 என்றால் { game_speed = 0; தாமதம் (80); // விளையாட்டை 80ms குறைக்கவும் } if (மதிப்பெண்> 10 && மதிப்பெண் <= 20) // மதிப்பெண் 10-40 என்றால் { game_speed = 1; தாமதம் (70); // விளையாட்டை 70ms குறைத்தால் } if (மதிப்பெண்> 20 && மதிப்பெண் <= 30) // மதிப்பெண் 20-40 என்றால் { game_speed = 2; தாமதம் (60); // விளையாட்டை 60ms குறைக்கவும் } if (மதிப்பெண்> 30 && மதிப்பெண் <= 40) // மதிப்பெண் 30-40 என்றால் { game_speed = 3; தாமதம் (50); // விளையாட்டை 50ms குறைக்கவும் } }

Arduino விண்வெளி ரேசர் விளையாட்டு வேலை:

வன்பொருள் மற்றும் நிரல் புரிந்துகொள்ளப்பட்டதை உறுதிசெய்த பிறகு, சுற்றுவட்டத்தை உருவாக்கி, குறியீட்டை அர்டுயினோ போர்டில் பதிவேற்றவும். கீழே காட்டப்பட்டுள்ளபடி விளையாட்டு தொடங்குவதை நீங்கள் கவனிக்க வேண்டும்

ஜாய்ஸ்டிக் பயன்படுத்தி எதிரி கப்பலில் இருந்து இடது அல்லது வலது பக்கம் நகர்ந்து தப்பிக்கவும். ஒவ்வொரு எதிரியையும் தவிர்ப்பதற்கு, உங்கள் மதிப்பெண் ஒவ்வொன்றாக அதிகரிக்கும். மதிப்பெண் அதிகமாக இருக்கும்போது விளையாட்டின் வேகமும் அதிகரிக்கும், அதாவது நீங்கள் அடித்த ஒவ்வொரு 10 புள்ளிகளுக்கும் 10 மீட்டர் வேகம் அதிகரிக்கும். புதிய நிலைகளை அறிமுகப்படுத்த நீங்கள் முன்னேறி இந்த விளையாட்டை உருவாக்கலாம் அல்லது ஒவ்வொன்றும் ஒரு முடுக்க மானியைப் பயன்படுத்தி இயக்கம் என்றாலும் அதைக் கட்டுப்படுத்த சில வன்பொருள் மாற்றங்களைச் செய்யலாம். படைப்பாற்றல் மட்டுமே வரம்பு. உங்கள் குறிப்புக்கு இங்கே Arduino உடன் முடுக்க மானியைப் பயன்படுத்த கற்றுக்கொள்கிறீர்கள்.

நீங்கள் திட்டத்தை புரிந்துகொண்டு அதை உருவாக்கி மகிழ்ந்தீர்கள் என்று நம்புகிறேன். இதைச் செயல்படுத்துவதில் நீங்கள் ஏதேனும் சிக்கலைச் சந்தித்திருந்தால், தயவுசெய்து கீழே உள்ள கருத்துப் பிரிவில் சிக்கலை இடுகையிடவும் அல்லது தொழில்நுட்ப உதவிக்கு மன்றங்களைப் பயன்படுத்தவும். இனிய கேமிங் !!

முழுமையான குறியீடு மற்றும் ஆர்ப்பாட்ட வீடியோவை கீழே சரிபார்க்கவும்.