- గేమ్ ప్లాన్:
- సర్క్యూట్ రేఖాచిత్రం:
- ముందస్తు అవసరాలు:
- స్పేస్ రేస్ గేమ్ కోసం ప్రోగ్రామింగ్ ఆర్డునో:
- ఆర్డునో స్పేస్ రేసర్ గేమ్ పని:
ప్రోగ్రామింగ్ ఎల్లప్పుడూ సరదాగా ఉంటుంది మరియు ఆర్డునో వంటి అభివృద్ధి ప్లాట్‌ఫామ్‌లతో ఇది చాలా మెరుగుపడింది. ఇక్కడ ఉన్న దాదాపు ప్రతి ప్రోగ్రామర్ వారు నేర్చుకునే / అభ్యసిస్తున్న భాషను ఉపయోగించి ఒక రకమైన ఆటను అభివృద్ధి చేయడానికి ప్రయత్నించారు. ఇది వారి ప్రోగ్రామింగ్ నైపుణ్యాలను సరదాగా ఇంకా ఉత్పాదక పద్ధతిలో ట్యూన్ చేయడానికి వారికి సహాయపడుతుంది. నేను పరిచయం చేసినప్పటి నుండి నేను ఆర్డునో యొక్క పెద్ద అభిమానిని మరియు దానితో చల్లగా ఏదైనా ప్రయత్నించాలని అనుకున్నాను, నోకియా 5110 వంటి గ్రాఫికల్ ఎల్‌సిడితో ఇది ఎంత బాగుంది అని తెలుసుకున్నప్పుడు, ఆర్డునోతో పాటు ఆటను అభివృద్ధి చేయాలనే నా ఆలోచన కొన్ని ప్రోగ్రామింగ్ నైపుణ్యాలను ట్యూన్ చేయడానికి మరియు ఒకే సమయంలో ఆనందించడానికి ఇది ఒక ఆసక్తికరమైన మార్గం, కాబట్టి మీరు మీ ఆటను అభివృద్ధి చేయడంలో ఆసక్తి కలిగి ఉండవచ్చు. అందువల్ల ఈ ట్యుటోరియల్‌లో మనం ఆర్డునో మరియు గ్రాఫికల్ ఎల్‌సిడిలను ఉపయోగించి మంచి ఆటను ఎలా సృష్టించవచ్చో నేర్చుకుంటాము.
మేము ఇప్పటికే ఆర్డునోను ఉపయోగించి పాత ఫ్యాషన్ స్నేక్ గేమ్‌ను నిర్మించాము, కాబట్టి ఈసారి మేము క్రొత్తదాన్ని ప్రయత్నిస్తున్నాము మరియు మేము ఈ ఆటను స్పేస్ రేస్ గేమ్ అని పేరు పెట్టాము, ఇక్కడ మీరు మీ ఓడను జాయ్ స్టిక్ ఉపయోగించి శత్రు నౌకల నుండి సురక్షితంగా ఉంచాలి.
గేమ్ ప్లాన్:
మేము ప్రారంభించడానికి ముందు, మీ ఆట వాస్తవానికి ఎలా పని చేస్తుందో ప్లాన్ చేయడం చాలా ముఖ్యం. నా హార్డ్‌వేర్ ఎంపిక కోసం నోకియా 5110 గ్రాఫికల్ ఎల్సిడి మరియు జాయ్‌స్టిక్‌తో వెళ్లాను. ఈ ట్యుటోరియల్‌లో మీరు కూడా అదే ఎంచుకున్నారని అనుకుంటాను. నోకియా 5110 చాలా స్థలంతో రాదు కాబట్టి, మా ప్రదర్శన యొక్క 84 * 48 పిక్సెల్ రిజల్యూషన్ లోపల మా మొత్తం ఆటను ప్లాన్ చేసాము. నోకియా 5110 ఎల్‌సిడిని ఆర్డునోతో, జాయ్‌స్టిక్‌తో ఆర్డునోతో ఎలా ఇంటర్ఫేస్ చేయాలనే దానిపై మేము ఇప్పటికే ట్యుటోరియల్స్ చేసాము.
ఈ స్థలంలో మేము గేమింగ్ ఏరియా మరియు స్కోరు మరియు స్టఫ్ వంటి వాటిని ప్రదర్శించే స్కోరు బోర్డు ప్రాంతంలో గట్టిగా సరిపోయేలా చేయాలి. పిక్సెల్ స్థానాలను ట్రాక్ చేయడానికి మరియు వాటిని తెరపై నవీకరించడానికి మీరు వస్తువులను ఎక్కడ ఉంచారో పిక్సెల్ స్థానాన్ని తెలుసుకోవడం చాలా ముఖ్యం.
గేమ్ స్క్రీన్ ప్రదర్శన నిర్ణయించిన తర్వాత మన ఆటలోని పాత్రలను నిర్ణయించుకోవాలి. నా ఆట కోసం మనకు రెండు మాత్రమే ఉన్నాయి, ఇది స్పేస్ షిప్ మరియు శత్రు పాత్ర అయిన ప్లేయర్ క్యారెక్టర్, ఇది గ్రహాంతర స్పేస్ షిప్ లాగా ఉండాలి. నోకియా ఎల్సిడి బిట్మ్యాప్ చిత్రాలను ప్రదర్శించగలదు, కాబట్టి నా అంతరిక్ష నౌకను మరియు శత్రువులను ప్రదర్శించడానికి ఆ ఎంపికను ఉపయోగించాలని నిర్ణయించుకున్నాను.
కాబట్టి మనకు గ్రహాంతర అంతరిక్ష నౌకల ద్వారా పరుగెత్తే అంతరిక్ష నౌక ఉంటుంది, ఈ అంతరిక్ష నౌకలో గ్రహాంతరవాసులతో దెబ్బతినకుండా ఉండటానికి మార్పులకు మూడు దారులు ఉంటాయి. అన్ని సమయాల్లో గ్రహాంతరవాసులు కేవలం రెండు ట్రాక్‌లను మాత్రమే ఆక్రమించగలరు మరియు ఆటగాడు ఉచిత ట్రాక్ ద్వారా డ్రైవ్ చేయగలగాలి. ఈ ఆలోచనలు ముగిసిన తర్వాత మేము హార్డ్‌వేర్ మరియు తరువాత ప్రోగ్రామింగ్‌తో కొనసాగవచ్చు.
సర్క్యూట్ రేఖాచిత్రం:
ఈ ఆర్డునో ఆట యొక్క సర్క్యూట్ చాలా సులభం; మేము నోకియా 5110 ఎల్సిడి మాడ్యూల్ మరియు జాయ్ స్టిక్ ను ఆర్డునోతో ఇంటర్ఫేస్ చేయాలి. పూర్తి సర్క్యూట్ రేఖాచిత్రం క్రింద చూపబడింది
నోకియా 5110 ఎల్సిడి 3.3 వి మరియు జాయ్ స్టిక్ మాడ్యూల్ వర్క్ సన్ 5 వితో పనిచేస్తుంది, కాబట్టి మీరు ఎల్‌సిడిని 3.3 వితో మాత్రమే కనెక్ట్ చేశారని నిర్ధారించుకోండి, ఎందుకంటే 5 వి దానిని శాశ్వతంగా దెబ్బతీస్తుంది. ఎల్సిడి ఆర్డినోతో ఎస్‌పిఐ ప్రోటోకాల్ ద్వారా కమ్యూనికేట్ చేస్తుంది మరియు వోల్టేజ్‌లో మార్పును చదవడానికి జాయ్ స్టిక్ ఎడిసిని మాత్రమే చదువుతుంది. కనెక్షన్ సెటప్ క్రింద ఇలా కనిపిస్తుంది
ముందస్తు అవసరాలు:
మేము ప్రోగ్రామింగ్ భాగంలోకి ప్రవేశించే ముందు మీరు డిస్ప్లే మాడ్యూల్ మరియు జాయ్‌స్టిక్‌తో సౌకర్యవంతంగా ఉండటం చాలా ముఖ్యం, కాబట్టి మీరు ఈ క్రింది ట్యుటోరియల్‌లను ఉపయోగించి వాటి గురించి మరింత తెలుసుకోవచ్చు మరియు తరువాత మేము ఇక్కడకు తిరిగి వెళ్తాము. ఇది అవసరం!
- నోకియా 5110 ఎల్సిడి ఇంటర్‌ఫేసింగ్ విత్ ఆర్డునో
- ఆర్డునోతో జాయ్ స్టిక్ మాడ్యూల్ ఇంటర్‌ఫేసింగ్
స్పేస్ రేస్ గేమ్ కోసం ప్రోగ్రామింగ్ ఆర్డునో:
గేమ్ పూర్తి కార్యక్రమం ఈ పేజీ చివర చూడవచ్చు; మీరు దీన్ని నేరుగా మీ Arduino IDE లో ఉపయోగించవచ్చు మరియు దానిని మీ బోర్డుకి అప్‌లోడ్ చేయవచ్చు. కానీ కోడ్ లోపల అసలు ఏమి జరుగుతుందో తెలుసుకోవాలంటే మరింత చదవండి.
ఎప్పటిలాగే మేము మా లైబ్రరీ హెడర్ ఫైళ్ళను జోడించడం ద్వారా మా ప్రోగ్రామ్‌ను ప్రారంభిస్తాము, ఈ ప్రాజెక్ట్ కోసం మాకు మూడు లైబ్రరీలు అవసరం, వీటిలో SPI లైబ్రరీ మీ IDE కి అప్రమేయంగా జోడించబడుతుంది. మిగతా రెండు లైబ్రరీని అడాఫ్రూట్ గితుబ్ పేజీ నుండి డౌన్‌లోడ్ చేసుకోవాలి. లైబ్రరీని ఎలా జోడించాలో మీకు తెలియకపోతే ప్రీ-ఆవశ్యకత విభాగంలో పేర్కొన్న LCD ఇంటర్‌ఫేసింగ్ ట్యుటోరియల్‌ను అనుసరించండి.
# చేర్చండి
మీరు ట్యుటోరియల్‌ను అనుసరించినట్లయితే , బిట్మ్యాప్ చిత్రాలను ఎల్‌సిడిలో ప్రదర్శించడం సాధ్యమని మీరు తెలుసుకోవాలి. కాబట్టి మేము ట్యుటోరియల్‌లో పేర్కొన్న సాఫ్ట్‌వేర్‌ను ఉపయోగించడం ద్వారా అవసరమైన చిత్రాన్ని బిట్మ్యాప్ కోడ్‌గా మార్చాలి, మీరు ఇంటర్నెట్ నుండి ఏదైనా చిత్రాన్ని ఎంచుకోవచ్చు మరియు వాటిని బిట్మ్యాప్ కోడ్‌గా మార్చడం ద్వారా ఉపయోగించవచ్చు. చిత్రం మా ఎల్సిడి స్క్రీన్‌లో ప్రదర్శించబడేంత సరళంగా ఉందని నిర్ధారించుకోండి, వాస్తవానికి ఎల్సిడి స్క్రీన్‌పై ప్రయత్నించే ముందు ప్రివ్యూను తనిఖీ చేయండి. మా ప్రోగ్రామ్‌లో మేము రెండు బిట్మ్యాప్ అక్షరాలను ఉపయోగించాము ఒకటి స్పేస్ షిప్ మరియు మరొకటి శత్రువు షిప్, రెండింటికి బిట్మ్యాప్ కోడ్ క్రింద చూపిన విధంగా మా కోడ్‌లో చేర్చబడుతుంది.
// బిట్మ్యాప్ డేటా అంతరిక్ష కోసం స్టాటిక్ సైన్ చేయని చార్ 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 కమ్యూనికేషన్‌ను ఉపయోగించి కమ్యూనికేట్ చేయబడుతుంది, మీరు పైన సర్క్యూట్ రేఖాచిత్రాన్ని అనుసరించినట్లయితే, LCD ని ప్రారంభించే కోడ్ ఈ క్రింది విధంగా ఉంటుంది, మీరు దానిని మార్చాల్సిన అవసరం లేదు.
Adafruit_PCD8544 display = Adafruit_PCD8544 (7, 6, 5, 4, 3); // LCD అనుసంధానించబడిన పిన్‌లను పేర్కొనండి
సెటప్ ఫంక్షన్ లోపల మేము సీరియల్ మానిటర్‌ను 9600 బాడ్ రేట్‌లో ప్రారంభిస్తాము, తద్వారా మనం అంశాలను డీబగ్ చేసి, ఆపై ఎల్సిడి డిస్‌ప్లేను ప్రారంభించవచ్చు. మేము ఎల్సిడి డిస్ప్లే యొక్క కాంట్రాస్ట్‌ను కూడా సెట్ చేయాలి, ప్రతి డిస్ప్లే వేరే కాంట్రాస్ట్ స్థాయిలో ఉత్తమంగా పని చేస్తుంది, కాబట్టి మీకు ఏది సరిపోతుందో తనిఖీ చేయడానికి విలువతో ప్లే చేయండి. చివరగా మేము క్రొత్తగా ప్రారంభించడానికి ప్రదర్శన స్క్రీన్‌ను కూడా క్లియర్ చేస్తాము.
శూన్య సెటప్ () { Serial.begin (9600); // డీబగ్గింగ్ కొరకు సీరియల్ మానిటర్ display.begin (); // ఎల్సిడి కమ్యూనికేషన్ డిస్‌ప్లేను ప్రారంభించండి.సెట్‌కాంట్రాస్ట్ (30); // డిస్ప్లే డిస్ప్లేకి విరుద్ధంగా సెట్ చేయండి. క్లియర్డిస్ప్లే (); // స్క్రీన్‌ను క్లియర్ చేస్తుంది మరియు క్రొత్తదాన్ని ప్రారంభించండి }
స్క్రీన్ క్లియర్ అయిన వెంటనే మేము లూప్ ఫంక్షన్ లోకి దూకుతాము మరియు అక్కడ మేము గేమ్ స్క్రీన్ ను ప్రదర్శిస్తాము. గేమ్ స్క్రీన్ ఏమీ కాదు, ఇది స్కోరు మరియు వేగ స్థాయితో పాటు ఆటకు ప్రాథమిక అస్థిపంజరాన్ని ప్రదర్శిస్తుంది. మేము మూడు పంక్తులను సరిహద్దులుగా గీయడానికి లైన్ ఫంక్షన్‌ను ఉపయోగించాము మరియు పాత రెట్రో హ్యాండ్ హోల్డ్ గేమింగ్ పరికరాల మాదిరిగానే టెక్స్ట్ స్కోర్ మరియు వేగాన్ని ప్రదర్శిస్తాము.
శూన్య గేమ్‌స్క్రీన్ () { // స్క్రీన్ డిస్ప్లే కోసం బోర్డర్‌ను గీయండి. డ్రాలైన్ (0, 0, 0, 47, బ్లాక్); display.drawLine (50, 0, 50, 47, BLACK); display.drawLine (0, 47, 50, 47, BLACK); // డిఫాల్ట్ టెక్స్ట్స్ ఎంటర్ చేయండి display.setTextSize (1); display.setTextColor (BLACK); display.setCursor (52,2); display.println ("వేగం"); display.setCursor (54,12); display.println (గేమ్_స్పీడ్); display.setCursor (52,25); display.println ("స్కోరు"); display.setCursor (54,35); display.println (స్కోరు); }
తరువాత మేము అతనిని / ఆమెను అంతరిక్ష నౌకను నియంత్రించడానికి అనుమతించటానికి వినియోగదారు నుండి ఇన్పుట్ పొందాలి. పిన్ A1 కి అనుసంధానించబడిన జాయ్ స్టిక్ మాడ్యూల్ నుండి ఇన్పుట్ స్వీకరించబడుతుంది. సెన్సార్ నుండి అనలాగ్ విలువ 512 అవుతుంది, అది తరలించబడకపోతే మరియు X- అక్షం వెంట కదిలినప్పుడు పెరుగుతుంది మరియు తగ్గుతుంది. వినియోగదారు ఎడమ లేదా కుడి వైపుకు వెళ్లాలనుకుంటున్నారో లేదో తెలుసుకోవడానికి మేము ఈ విలువలను ఉపయోగిస్తాము. దిగువ ప్రోగ్రామ్‌ను అర్థం చేసుకోవడం మీకు కష్టమైతే, ప్రీ-ఆవశ్యకతలలో పేర్కొన్న ఆర్డునో ట్యుటోరియల్‌తో మీరు జాయ్ స్టిక్ ఇంటర్‌ఫేసింగ్ చదవాలి.
// యూజర్ నుండి ఇన్పుట్ పొందండి జాయ్_ఎక్స్ = అనలాగ్ రీడ్ (ఎ 1); // (జాయ్_ఎక్స్ <312 && పిఓఎస్! = 1 && కంట్రోల్ == ట్రూ) // జాయ్ స్టిక్ నుండి ఎక్స్ వే చదవండి // జాయ్ స్టిక్ కుడివైపుకి కదులుతుంటే {POS--; control = false;} // స్పేస్ షిప్ యొక్క క్షీణత స్థానం (జాయ్_ఎక్స్> 712 && POS! = 3 && కంట్రోల్ == నిజం) // ఆనందం స్టిక్ కుడివైపుకి వెళితే {POS ++; 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, BLACK); if (pos == 3) display.drawBitmap (34, 32, ఓడ, 15, 15, BLACK); }
ఇప్పుడు మా స్పేస్ షిప్ తెరపై ఉంచబడింది మరియు రేసింగ్ కోసం సిద్ధంగా ఉంది, మేము ఆటగాడితో పాటు పోటీ పడే శత్రు నౌకలను పరిచయం చేయాలి. ప్రతిసారీ శత్రు ఓడ తెర దాటినప్పుడు అతను చనిపోయాడని అనుకుంటాము మరియు అతను చనిపోయినప్పుడు మనం కొత్త అంతరిక్ష నౌకను సృష్టించాలి. దిగువ ఫంక్షన్ అదే చేస్తుంది. ఇది రెండు శత్రు నౌకలకు క్రొత్త స్థానాన్ని సృష్టిస్తుంది మరియు వాటిని స్క్రీన్ పైన ఉంచుతుంది.
if (శత్రువు_దశ) // శత్రు నౌకల తనిఖీ చనిపోయి ఉంటే {// అవి చనిపోయినట్లయితే శత్రువు_0_పోస్ = POS; // అంతరిక్ష నౌక పైన మొదటి శత్రువును సృష్టించండి శత్రువు_1_పోస్ = యాదృచ్ఛిక (0,4); // కొన్ని ఇతర యాదృచ్ఛిక ప్రదేశంలో సెకండ్ శత్రువును సృష్టించండి శత్రువు_ఫేస్ = 0; // శత్రువును అగ్ర శత్రువుగా తీసుకురండి శత్రువు_దేడ్ = తప్పుడు; // శత్రువు సృష్టించబడ్డాడు కాబట్టి వారు ఇక చనిపోరు }
స్క్రీన్ పైభాగంలో శత్రు నౌకలను ఉంచిన తరువాత మనం దానిని దించవలసి ఉంటుంది, తద్వారా అది మా ప్లేయర్ పైకి పరుగెత్తుతున్నట్లుగా స్పియర్స్ చేస్తుంది, అలా చేయడానికి మనం దశను పెంచాలి (చిత్రం ప్రదర్శించబడే ప్రదేశం) అది నెమ్మదిగా వస్తుంది. క్రింద చూపిన విధంగా శత్రు నౌకలకు కూడా ఇది జరుగుతుంది
శత్రువు_షిప్ (శత్రువు_0_పోస్, శత్రువు_ఫేస్); శత్రువు_ఫేస్ ++; // మొదటి శత్రువును తెరపై ఉంచండి మరియు అతన్ని శత్రువు_షిప్ (శత్రువు_1_పోస్, శత్రువు_ఫేస్) నుండి క్రిందికి నడపండి; శత్రువు_ఫేస్ ++; // తెరపై సెకండ్ శత్రువును ఉంచి అతన్ని కిందకు దించండి
ఫంక్షన్ శత్రువు_షిప్ క్రింద చూపబడింది, ఇది ప్లేయర్ కార్ ఫంక్షన్‌కు చాలా పోలి ఉంటుంది కాని ఇక్కడ మనకు రెండు పారామితులు ఉన్నాయి. ఒకటి శత్రువును ట్రాక్‌లో ఉంచడం, మరొకటి శత్రువును కిందికి తరలించడం.
void శత్రువు_షిప్ (పూర్ణాంక స్థలం, పూర్ణాంక దశ) // శత్రువు_షిప్‌ను క్రొత్త స్థలంలో ఉంచండి మరియు దశ { if (place == 1) display.drawBitmap (2, దశ, శత్రువు, 15, 15, BLACK); if (place == 2) display.drawBitmap (18, దశ, శత్రువు, 15, 15, BLACK); if (place == 3) display.drawBitmap (34, దశ, శత్రువు, 15, 15, BLACK); }
తదుపరి కోడ్ కోడ్ అంతరిక్ష నౌక శత్రువు ఓడను తప్పించిందో లేదో తనిఖీ చేయాలి. దీన్ని తనిఖీ చేయడానికి శత్రు నౌకల స్థానం మరియు ఆటగాడి అంతరిక్ష నౌకను తెలుసుకోవాలి. అంతా మనకు తెలుసు కాబట్టి, అంతరిక్ష నౌక స్థానం శత్రు ఓడ వలె ఉందా అని మనం తనిఖీ చేయాలి. శత్రు ఓడ అంతరిక్ష నౌకకు చేరుకున్నప్పుడే మేము దీన్ని తనిఖీ చేస్తాము. ఆటగాడు శత్రువును తప్పించకపోతే అది ఆట ముగిసింది.
if (శత్రువు_ఫేస్> 22 && ((శత్రువు_0_పోస్ == POS) - (శత్రువు_1_పోస్ == POS))) // స్పేస్ షిప్ శత్రువు గేమ్_ఓవర్ () లో దేనినైనా తాకినట్లయితే ; // ఆటను ప్రదర్శించండి
ఆటగాడు శత్రువును విజయవంతంగా తప్పించినట్లయితే, మనం శత్రువును చంపి ఆటగాడికి ఒక పాయింట్ ఇవ్వాలి. ఇది చేయుటకు మనం శత్రువు స్క్రీన్ దిగువకు చేరుకున్నామో లేదో తనిఖీ చేస్తాము మరియు అది చేస్తే దిగువ కోడ్ ఉపయోగించి దాన్ని చంపుతాము
if (శత్రువు_ఫేస్> 40) // ఒకవేళ థీస్పేస్ ఓడ శత్రువుల నుండి తప్పించుకుంటే {శత్రువు_దేడ్ = నిజం; స్కోరు ++;} // స్కోరు పెంచండి మరియు శత్రువులను చంపండి
మేము ఎక్కువ స్కోర్లు సాధించినందున ఆట యొక్క కష్టాన్ని పెంచుకోకపోతే అది ఎంత సరదాగా ఉంటుంది. కాబట్టి మేము మరొక ఫంక్షన్‌ను ఉపయోగిస్తాము , అది ప్లేయర్ యొక్క స్కోర్‌ను పర్యవేక్షిస్తుంది మరియు స్కోరు ఆధారంగా ఇది ఆట యొక్క వేగాన్ని పెంచుతుంది. ఆలస్యం ఫంక్షన్‌ను ఉపయోగించడం ద్వారా వేగం వాస్తవానికి నియంత్రించబడుతుంది, ఇది ఆట యొక్క రిఫ్రెష్ విరామాన్ని నియంత్రిస్తుంది, తద్వారా ఇది వేగంగా లేదా నెమ్మదిగా చేస్తుంది.
void Level_Controller () // స్కోరు ఆధారంగా ఆట వేగాన్ని పెంచండి. { if (స్కోరు> = 0 && స్కోరు <= 10) // స్కోరు ఉంటే 0-10 { గేమ్_స్పీడ్ = 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 నెమ్మదిగా చేయండి } }
ఆర్డునో స్పేస్ రేసర్ గేమ్ పని:
హార్డ్‌వేర్ మరియు ప్రోగ్రామ్ అర్థమైందని నిర్ధారించుకున్న తర్వాత, సర్క్యూట్‌ను నిర్మించి, కోడ్‌ను ఆర్డునో బోర్డ్‌కు అప్‌లోడ్ చేయండి. క్రింద చూపిన విధంగా ఆట ప్రారంభించడాన్ని మీరు గమనించాలి
ఎడమ లేదా కుడి వైపుకు కదిలి శత్రువు ఓడ నుండి తప్పించుకోవడానికి జాయ్ స్టిక్ ఉపయోగించండి. ప్రతి శత్రువును తప్పించడం కోసం మీ స్కోరు ఒక్కొక్కటిగా పెరుగుతుంది. స్కోరు అధికంగా ఉన్నప్పుడు ఆట యొక్క వేగం కూడా పెరుగుతుంది, అంటే మీరు స్కోర్ చేసిన ప్రతి 10 పాయింట్లకు 10ms వేగం పెరుగుతుంది. యాక్సిలెరోమీటర్ ఉపయోగించి కదలిక అయినప్పటికీ దాన్ని నియంత్రించడానికి మీరు కొత్త స్థాయిలను పరిచయం చేయడానికి లేదా ప్రతి హార్డ్‌వేర్ మార్పులను చేయడానికి ఈ ఆటను రూపొందించవచ్చు. సృజనాత్మకత మాత్రమే పరిమితి. మీ సూచన కోసం మీరు ఇక్కడ ఆర్డునోతో యాక్సిలెరోమీటర్‌ను ఉపయోగించడం నేర్చుకుంటారు.
మీరు ప్రాజెక్ట్ను అర్థం చేసుకున్నారని మరియు దానిని నిర్మించడం ఆనందించారని ఆశిస్తున్నాము. ఇది పని చేయడంలో మీకు ఏమైనా సమస్య ఎదురైతే, దయచేసి దిగువ వ్యాఖ్య విభాగంలో సమస్యను పోస్ట్ చేయడానికి సంకోచించకండి లేదా సాంకేతిక సహాయం కోసం ఫోరమ్‌లను ఉపయోగించండి. హ్యాపీ గేమింగ్ !!
పూర్తి కోడ్ మరియు దిగువ ప్రదర్శన వీడియోను తనిఖీ చేయండి.