విషయము

• డౌన్‌లోడ్ చేసి ఇన్‌స్టాల్ చేయండి
• ప్రాజెక్ట్ ప్రారంభిస్తోంది
• లువా పరిచయం
• ఆట రాయడం
• తదుపరి దశలు
• ర్యాప్ అప్

గూగుల్ ప్లే స్టోర్‌లో అత్యంత ప్రాచుర్యం పొందిన వర్గం ఎప్పుడూ ఆటలే. మనమందరం వెబ్ బ్రౌజర్, ఇమెయిల్ క్లయింట్ మరియు తక్షణ సందేశ అనువర్తనం వంటి కీలక ఉత్పాదకత అనువర్తనాలను ఉపయోగిస్తున్నప్పటికీ, మొబైల్ అనుభవంలో గేమింగ్ ఇప్పటికీ ఒక ముఖ్యమైన భాగంగా ఉంది. కాబట్టి ఆండ్రాయిడ్ కోసం అభివృద్ధి నేర్చుకోవాలనుకునే చాలా మంది ఆట ఆడటం ద్వారా ప్రారంభించడంలో ఆశ్చర్యం లేదు. అలాగే, నిజాయితీగా ఉండండి, ఉత్పాదకత అనువర్తనాన్ని అభివృద్ధి చేయడం కంటే ఆట రాయడం చాలా సరదాగా ఉంటుంది!

ఆండ్రాయిడ్ యొక్క అధికారిక భాష జావా మరియు అధికారిక అభివృద్ధి వాతావరణం ఆండ్రాయిడ్ స్టూడియో. మీరు జావాలో చూడాలనుకుంటే, నేను మా జావా బేసిక్స్ ట్యుటోరియల్‌ని సూచిస్తున్నాను, మరియు మీరు ఆండ్రాయిడ్ స్టూడియోని ఉపయోగించి ఒక అనువర్తనాన్ని ఎలా రాయాలో నేర్చుకోవాలనుకుంటే, మీ మొదటి Android అనువర్తనాన్ని వ్రాయడం గురించి మా ట్యుటోరియల్‌ను తనిఖీ చేయాలని నేను సూచిస్తున్నాను. అయితే జావా మరియు ఆండ్రాయిడ్ స్టూడియో Android కోసం అభివృద్ధి చేయడానికి ఏకైక మార్గాలు కాదు. మీరు మా గైడ్‌లో అందుబాటులో ఉన్న భాషలు మరియు ఎస్‌డికెల యొక్క అవలోకనాన్ని కనుగొనవచ్చు: నేను Android అనువర్తనాలను అభివృద్ధి చేయాలనుకుంటున్నాను - నేను ఏ భాషలను నేర్చుకోవాలి?

ప్రోగ్రామింగ్ లాంగ్వేజ్ గైడ్‌లో పేర్కొన్న ఎస్‌డికెలలో ఒకటి కరోనా, మూడవ పార్టీ ఎస్‌డికె ప్రధానంగా ఆటలను వ్రాయడానికి రూపొందించబడింది. జావాకు బదులుగా, కరోనా వేగంగా శక్తివంతమైన స్క్రిప్టింగ్ భాష అయిన లువాను ఉపయోగిస్తుంది. అయినప్పటికీ, కరోనా లువాను ఉపయోగించే ఏకైక మొబైల్ గేమింగ్ SDK కాదు, ఇతర ప్రసిద్ధ ఉదాహరణలు కోకోస్ 2 డి-ఎక్స్, మార్మాలాడే మరియు గిడెరోస్.

డౌన్‌లోడ్ చేసి ఇన్‌స్టాల్ చేయండి

కరోనాతో ప్రారంభించడానికి మీరు SDK ని డౌన్‌లోడ్ చేసి ఇన్‌స్టాల్ చేయాలి. కరోనా వెబ్‌సైట్‌కి వెళ్లి డౌన్‌లోడ్ బటన్ నొక్కండి. మీరు కిట్‌ను డౌన్‌లోడ్ చేయడానికి ముందు మీరు ఒక ఖాతాను సృష్టించాలి (ఇది ఉచితం). మీరు మీ ప్రోగ్రామ్‌ను ఎమ్యులేటర్‌లో అమలు చేయకుండా నిజమైన .apk ఫైల్‌ను నిర్మించాలనుకుంటే, మీరు జావా 7 ని ఇన్‌స్టాల్ చేయాలి, అయితే మీరు Android SDK ని ఇన్‌స్టాల్ చేయనవసరం లేదు. జావా 7 డెవలప్‌మెంట్ కిట్‌ను ఇన్‌స్టాల్ చేయడానికి, ఒరాకిల్ వెబ్‌సైట్‌కు వెళ్లి, “జావా SE డెవలప్‌మెంట్ కిట్ 7u79 called అని పిలువబడే విభాగం కోసం చూడండి మరియు మీ PC కోసం సంస్కరణను డౌన్‌లోడ్ చేయండి.

మీరు కరోనాను ఇన్‌స్టాల్ చేసిన తర్వాత దాన్ని సక్రియం చేయాలి. ఇది ఒక-సమయం ప్రక్రియ, ఇది ఉచితం. కరోనా సిమ్యులేటర్‌ను ప్రారంభించి, లైసెన్స్‌కు అంగీకరిస్తున్నారు. మీరు డౌన్‌లోడ్ కోసం ఉపయోగించిన ఇమెయిల్ చిరునామా మరియు పాస్‌వర్డ్‌లో నమోదు చేసి, లాగిన్ క్లిక్ చేయండి.

ప్రాజెక్ట్ ప్రారంభిస్తోంది

కరోనా సిమ్యులేటర్ నుండి “క్రొత్త ప్రాజెక్ట్” పై క్లిక్ చేయండి. “అప్లికేషన్ పేరు:” ఫీల్డ్‌లో మీ అనువర్తనం కోసం ఒక పేరును నమోదు చేయండి మరియు మిగిలిన సెట్టింగులను వాటి డిఫాల్ట్‌లలో వదిలివేయండి. “సరే” క్లిక్ చేయండి.

ఇప్పుడు మూడు కిటికీలు కనిపిస్తాయి. మొదటి రెండు కరోనా సిమ్యులేటర్ మరియు కరోనా సిమ్యులర్ అవుట్పుట్. కరోనా మీ ప్రాజెక్ట్ కోసం ఫైళ్ళను చూపించే ఫైల్ ఎక్స్‌ప్లోరర్ విండోను కూడా తెరుస్తుంది.

ప్రాజెక్ట్ డైరెక్టరీలోని మెజారిటీ ఫైల్స్ (వాటిలో 23) అప్లికేషన్ ఐకాన్ కోసం! ప్రస్తుతం మాకు చాలా ముఖ్యమైన ఫైల్ main.lua, ఇక్కడే మేము మా అనువర్తనం కోసం కోడ్‌ను వ్రాస్తాము.

లువా పరిచయం

మేము కోడ్ రాయడానికి ముందు, మేము లువా యొక్క విజిల్-స్టాప్ టూర్ చేయాలి. విండోస్, OS X మరియు Linux కోసం లువా వ్యాఖ్యాత (ఇది స్క్రిప్టింగ్ భాష అని గుర్తుంచుకోండి, సంకలనం చేయబడిన భాష కాదు). అయితే ఇది కరోనాకు అంతర్నిర్మితంగా ఉంది, కాబట్టి ఈ సమయంలో మీరు అదనంగా ఏదైనా ఇన్‌స్టాల్ చేయవలసిన అవసరం లేదు. లువాతో ఆడటానికి సులభమైన మార్గం ఆన్‌లైన్ లైవ్ డెమోని ఉపయోగించడం.

మీరు ఆన్‌లైన్‌లో లువా గురించి చాలా మంచి ట్యుటోరియల్‌లను కనుగొనవచ్చు మరియు మీరు లువా రిఫరెన్స్ మాన్యువల్, ప్రోగ్రామింగ్ ఆఫ్ లువా, ది.లువా ట్యుటోరియల్ మరియు ది ట్యుటోరియల్స్ పాయింట్ లువా ట్యుటోరియల్‌ను పరిశీలించాలి.

ఇక్కడ ఒక చిన్న లువా ప్రోగ్రామ్ ఉంది, ఇది లువా యొక్క కొన్ని ముఖ్య లక్షణాలను మీకు చూపుతుంది:

స్థానిక ఫంక్షన్ డబుల్ఇట్ (x) రిటర్న్ x * 2 ఎండ్ i = 1,10,1 డూ x = డబుల్ఇట్ (ఐ) (x == 10) ఉంటే ప్రింట్ ("పది") లేకపోతే ప్రింట్ (డబుల్ఇట్ (ఐ) ఎండ్ ఎండ్

పై కోడ్ మూడు ముఖ్యమైన లువా నిర్మాణాలను చూపిస్తుంది: విధులు, ఉచ్చులు మరియు ఉంటే ప్రకటనలు. ఫంక్షన్ doubleIt () ఇది చాలా సులభం, ఇది పరామితిలో ఆమోదించిన రెట్టింపు అవుతుంది x.

ప్రధాన కోడ్ a కోసం 1 నుండి 10 వరకు లూప్ చేయండి doubleIt () ప్రతి పునరావృతం కోసం. తిరిగి వచ్చే విలువ 10 అయితే (అనగా ఎప్పుడు నేను 5) అప్పుడు కోడ్ “పది” ను ప్రింట్ చేస్తుంది లేకపోతే అది ఫలితాన్ని ప్రింట్ చేస్తుంది doubleIt ().

మీకు ఏదైనా కోడింగ్ అనుభవం ఉంటే, ఉదాహరణ కోడ్ అనుసరించేంత తేలికగా ఉండాలి. మీరు కొన్ని ప్రాథమిక ప్రోగ్రామింగ్ నేర్చుకోవాలనుకుంటే, మీ నైపుణ్యాలను మెరుగుపర్చడానికి పైన లింక్ చేసిన కొన్ని వనరులను ఉపయోగించమని నేను సూచిస్తున్నాను.

ఆట రాయడం

కరోనాలో ప్రాథమిక కార్యక్రమాలు రాయడం చాలా సులభం. మీకు ఒక ఫైల్‌తో మాత్రమే ఆందోళన అవసరం, main.lua, మరియు కరోనా అన్ని భారీ లిఫ్టింగ్ చేయనివ్వండి. మేము వ్రాయబోయే ఆట సాధారణ “ట్యాప్” గేమ్. బెలూన్ లేదా బాంబు తెరపైకి విఫలమవుతుంది. ఆటగాడు వారు పాయింట్ స్కోరు చేసిన బెలూన్‌పై నొక్కితే, వారు బాంబుపై నొక్కండి, అప్పుడు స్కోరు 2 ద్వారా విభజించబడుతుంది, పెనాల్టీగా. కోడ్ రాయడానికి మీరు సవరించాలి main.lua. మీరు దీన్ని ఏదైనా టెక్స్ట్ ఎడిటర్‌లో చేయవచ్చు.

కరోనా ఎస్‌డికెలో అంతర్నిర్మిత 2 డి ఫిజిక్స్ ఇంజన్ ఉంది, ఇది బిల్డింగ్ గేమ్‌లను చాలా సులభం చేస్తుంది. ఆట రాయడానికి మొదటి దశ భౌతిక ఇంజిన్‌ను ప్రారంభించడం:

స్థానిక భౌతికశాస్త్రం = అవసరం ("భౌతికశాస్త్రం") భౌతికశాస్త్రం.స్టార్ట్ ()

కోడ్ చాలా స్వీయ వివరణాత్మకమైనది. మాడ్యూల్ భౌతికశాస్త్రం లోడ్ చేయబడింది మరియు ప్రారంభించబడింది, ఇది వేరియబుల్‌కు కేటాయించబడుతుంది భౌతిక. ఇంజిన్ను ప్రారంభించడానికిphysics.start () అంటారు.

తరువాత మేము కొన్ని ఉపయోగకరమైన వేరియబుల్స్‌ని సృష్టిస్తాము, ఇవి ఈ సాధారణ ఆటకు మాత్రమే కాకుండా, మరింత క్లిష్టమైన ఆటలకు కూడా ఉపయోగపడతాయి. halfW మరియు halfH స్క్రీన్ వెడల్పులో సగం మరియు స్క్రీన్ ఎత్తులో సగం విలువలను పట్టుకోండి:

halfW = display.contentWidth * 0.5 halfH = display.contentHeight * 0.5

ది ప్రదర్శన ఆబ్జెక్ట్ అనేది ముందుగా నిర్వచించిన వస్తువు, ఇది కరోనా ప్రపంచవ్యాప్తంగా అందుబాటులో ఉంటుంది.

ఇప్పుడు తెరపై ఏదో జరిగేలా చేసే మొదటి దశ వస్తుంది:

స్థానిక bkg = display.newImage ("night_sky.png", halfW, halfH)

అలాగే లక్షణాలు contentHeight మరియు contentWidth, ది ప్రదర్శన వస్తువు కూడా చాలా ఉపయోగకరమైన విధులను కలిగి ఉంది. ది newImage () ఫంక్షన్ ఒక ఇమేజ్ ఫైల్‌ను చదువుతుంది (ఈ సందర్భంలో .png) మరియు దాన్ని తెరపై ప్రదర్శిస్తుంది. ప్రదర్శన వస్తువులు పొరలుగా ఇవ్వబడతాయి, కాబట్టి ఇది మేము తెరపై ఉంచే మొదటి చిత్రం కనుక ఇది ఎల్లప్పుడూ నేపథ్యంగా ఉంటుంది (కోడ్ దానిని మార్చడానికి ఏదైనా స్పష్టంగా చేయకపోతే). పారామితులు halfW మరియు halfH చిత్రాన్ని మధ్యలో ఉంచమని కరోనాకు చెప్పండి.

ఈ సమయంలో మీరు ఎమ్యులేటర్‌లో కోడ్‌ను అమలు చేయవచ్చు మరియు నేపథ్య చిత్రాన్ని చూడవచ్చు. మీరు ఫైల్‌ను సేవ్ చేస్తే, ఫైల్ మారినట్లు ఎమ్యులేటర్ గమనించి, తిరిగి ప్రారంభించడానికి ఆఫర్ చేస్తుంది. అది జరగకపోతే ఫైల్-> రీలాంచ్ ఉపయోగించండి.

వినియోగదారు బెలూన్లను నొక్కడం కోసం పాయింట్లను స్కోర్ చేస్తారు కాబట్టి, మేము స్కోరు వేరియబుల్‌ను ప్రారంభించి, స్క్రీన్‌పై స్కోర్‌ను ప్రదర్శించాలి:

స్కోరు = 0 స్కోర్‌టెక్స్ట్ = display.newText (స్కోరు, సగం W, 10)

స్కోరు name హాజనితంగా పేరు పెట్టబడిన వేరియబుల్‌లో ఉంచబడుతుంది స్కోర్,మరియు scoreText స్కోర్‌ను ప్రదర్శించే వస్తువు. ఇలా newImage (), newText () తెరపై ఏదో ఉంచండి, ఈ సందర్భంలో వచనం. నుండి scoreText గ్లోబల్ వేరియబుల్ అప్పుడు మనం ఏ సమయంలోనైనా వచనాన్ని మార్చవచ్చు. కానీ మేము త్వరలోనే దాన్ని పొందుతాము.

మీరు ఎమ్యులేటర్‌ను తిరిగి ప్రారంభించవచ్చు మరియు స్క్రీన్ పైభాగంలో 0 డిస్ప్లే స్కోర్‌ను చూడవచ్చు.

ఎడమ: నేపథ్యం. కుడి: నేపధ్యం మరియు స్కోరు.

ఇప్పుడు కొంచెం గమ్మత్తైనది వచ్చింది, కానీ చింతించకండి నేను దానిని పంక్తిగా వివరిస్తాను:

స్థానిక ఫంక్షన్ బెలూన్ టచ్డ్ (ఈవెంట్) ఉంటే (event.phase == "ప్రారంభమైంది") అప్పుడు రన్‌టైమ్: removeEventListener ("enterFrame", event.self) event.target:removeSelf () స్కోరు = స్కోరు + 1 స్కోర్‌టెక్స్ట్.టెక్స్ట్ = స్కోరు ముగింపు

పై కోడ్ అనే ఫంక్షన్‌ను నిర్వచిస్తుంది balloonTouched () బెలూన్ నొక్కిన ప్రతిసారీ దీనిని పిలుస్తారు. బెలూన్ నొక్కిన ప్రతిసారీ ఈ ఫంక్షన్‌కు కాల్ చేయమని మేము ఇంకా కరోనాకు చెప్పలేదు, అది తరువాత వస్తుంది, కాని మేము దీన్ని చేసినప్పుడు ఫంక్షన్ అని పిలుస్తారు.

ట్యాప్ లేదా టచ్ ఈవెంట్‌లకు అనేక దశలు ఉన్నాయి, చాలా లాగడానికి మద్దతు ఇస్తాయి. వినియోగదారు ఒక వస్తువుపై వేలు పెడతారు, ఇది “ప్రారంభమైన” దశ. వారు ఏ దిశలోనైనా వేలును స్లైడ్ చేస్తే, అది “కదిలిన” దశ. వినియోగదారు స్క్రీన్ నుండి వేలు ఎత్తినప్పుడు, అది “ముగిసిన” దశ.

యొక్క మొదటి పంక్తి balloonTouched () తనిఖీలు మేము “ప్రారంభ” దశలో ఉన్నాము. మేము బెలూన్‌ను తీసివేసి, సాధ్యమైనంత త్వరగా స్కోర్‌ను పెంచాలనుకుంటున్నాము. ఫంక్షన్ "ఎండ్" వంటి ఇతర దశల కోసం మళ్ళీ పిలువబడితే ఫంక్షన్ ఏమీ చేయదు.

లోపలఉంటే స్టేట్మెంట్ కోడ్ యొక్క నాలుగు పంక్తులు. చివరి రెండు సరళమైనవి కాబట్టి మొదట వాటిని పరిష్కరించుకుందాం.స్కోరు = స్కోరు + 1 స్కోర్‌ను ఒక్కొక్కటిగా పెంచుతుంది మరియుscoreText.text = స్కోరు క్రొత్త స్కోర్‌ను ప్రతిబింబించేలా స్క్రీన్‌పై స్కోరు వచనాన్ని మారుస్తుంది. నేను ఎలా చెప్పానో గుర్తుంచుకోscoreText గ్లోబల్ మరియు ఎక్కడైనా యాక్సెస్ చేయవచ్చు, అదే మేము ఇక్కడ చేస్తున్నది.

ఇప్పుడు మొదటి రెండు పంక్తుల కోసం. స్క్రీన్ దిగువన బెలూన్ లేదా బాంబు పడిపోయిన తర్వాత అది ఇప్పటికీ అనువర్తన జ్ఞాపకశక్తిలో ఉంది, మీరు చూడలేరు. ఆట అభివృద్ధి చెందుతున్నప్పుడు ఈ ఆఫ్-స్క్రీన్ వస్తువుల సంఖ్య క్రమంగా పెరుగుతుంది. అందువల్ల వస్తువులను చూడగానే వాటిని తొలగించే ఒక యంత్రాంగాన్ని మనం కలిగి ఉండాలి. మేము ఒక ఫంక్షన్ లో చేస్తామురూపురేఖలకు, మేము ఇంకా వ్రాయలేదు. ఆ ఫంక్షన్ ఆట సమయంలో ప్రతి ఫ్రేమ్‌కు ఒకసారి పిలువబడుతుంది. బెలూన్ ట్యాప్ చేయబడిన తర్వాత, మేము దానిని తొలగించి, బెలూన్ ఆఫ్‌స్క్రీన్ అయిపోయిందో లేదో తనిఖీ చేసే కాల్‌ను తొలగించాలి.

గీతevent.target:removeSelf () బెలూన్‌ను తొలగిస్తుంది. టచ్ ఈవెంట్ సంభవించినప్పుడు వినేవారి ఫంక్షన్ యొక్క పారామితులలో ఒకటిఈవెంట్ పరామితి. ఇది ఈవెంట్ గురించి ఫంక్షన్‌ను చెబుతుంది మరియు ఇది ఏ రకమైన సంఘటన, ఉదా.event.phase. ఏ బెలూన్ నొక్కబడిందో కూడా ఇది మాకు చెబుతుంది,event.target. దిremoveSelf () ఫంక్షన్ అది చెప్పినట్లు చేస్తుంది, అది వస్తువును తొలగిస్తుంది (ఈ సందర్భంలో బెలూన్).

దీనికి ముందు ఉన్న పంక్తి “ఎంటర్‌ఫ్రేమ్” వినేవారిని తొలగిస్తుంది, ఇది బెలూన్ స్క్రీన్ దిగువ నుండి పడిపోయిందో లేదో చూడటానికి ప్రతి ఫ్రేమ్ అని పిలువబడే ఫంక్షన్. మేము వ్రాయడానికి వచ్చినప్పుడు దానిని మరింత వివరంగా పరిశీలిస్తామురూపురేఖలకు వినేవారి ఫంక్షన్.

కాబట్టి, రీక్యాప్ చేయడానికి.balloonTouched ()ఇది టచ్ సీక్వెన్స్ యొక్క ప్రారంభం అని తనిఖీ చేస్తుంది. ఇది "ఎంటర్ఫ్రేమ్" వినేవారిని తొలగిస్తుంది, ఇది బెలూన్ స్క్రీన్ దిగువ నుండి పడిపోయిందో లేదో చూడటానికి ప్రతి ఫ్రేమ్ అని పిలువబడే ఫంక్షన్. ఇది బెలూన్‌ను తొలగిస్తుంది, స్కోర్‌ను పెంచుతుంది మరియు క్రొత్త స్కోర్‌ను ప్రదర్శిస్తుంది.

అది బెలూన్ల కోసం, ఇప్పుడు మనకు బాంబుల కోసం ఇలాంటిదే కావాలి:

లోకల్ ఫంక్షన్ బాంబ్ టచ్డ్ (ఈవెంట్) ఉంటే (event.phase == "ప్రారంభమైంది") అప్పుడు రన్‌టైమ్: removeEventListener ("enterFrame", event.self) event.target:removeSelf () score = math.floor (score * 0.5) scoreText.text = స్కోరు ముగింపు ముగింపు

మీరు చూడగలిగినట్లుగా, స్కోరును పెంచడం కంటే, స్కోరు 0.5 తో గుణించబడుతుంది (అనగా 2 ద్వారా విభజించబడింది). ది math.floor () ఫంక్షన్ పూర్తి స్కోరును సమీప పూర్ణాంకానికి రౌండ్ చేస్తుంది. కాబట్టి ఆటగాడికి 3 స్కోరు ఉంటే మరియు బాంబును నొక్కండి, అప్పుడు కొత్త స్కోరు 1, మరియు 1.5 కాదు.

నేను ప్రస్తావించాను రూపురేఖలకు () ముందు ఫంక్షన్. ఒక వస్తువు తెరపైకి పోయిందో లేదో తనిఖీ చేయడానికి ఈ ఫంక్షన్‌ను ప్రతి ఫ్రేమ్ అంటారు. కోడ్ ఇక్కడ ఉంది:

లోకల్ ఫంక్షన్ ఆఫ్‌స్క్రీన్ (సెల్ఫ్, ఈవెంట్) ఉంటే (self.y == nil) అప్పుడు తిరిగి వస్తే (self.y> display.contentHeight + 50) అప్పుడు రన్‌టైమ్: removeEventListener ("enterFrame", self) self: removeSelf () end end

కంప్యూటింగ్‌లో రేసు కండిషన్ అని పిలువబడే పరిస్థితి ఉంది. ఇక్కడే రెండు విషయాలు జరగబోతున్నాయి కాని ఒకటి మొదట జరగవచ్చు, లేదా కొన్నిసార్లు మరొకటి మొదట జరగవచ్చు. ఇది ఒక జాతి. కొన్ని జాతి పరిస్థితులు కనిపించవు ఎందుకంటే ఒక విషయం ఎప్పుడూ మొదటగా అనిపిస్తుంది, కాని అవి ఆ రోజులో ఆసక్తికరమైన దోషాలను కలిగిస్తాయి, సరైన పరిస్థితులలో, మరొక విషయం మొదట జరుగుతుంది మరియు తరువాత సిస్టమ్ విచ్ఛిన్నమవుతుంది!

ఈ సరళమైన ఆటలో జాతి పరిస్థితి ఉంది, ఎందుకంటే రెండు విషయాలు ఒకదానికొకటి చాలా దగ్గరగా జరుగుతాయి: ఒక బెలూన్ నొక్కడం మరియు రూపురేఖలకు () బెలూన్ స్క్రీన్ నుండి పోయిందో లేదో చూడటానికి ఫంక్షన్ పిలువబడుతుంది. ఫలితం ఏమిటంటే, బెలూన్‌ను తొలగించే కోడ్‌ను పిలవవచ్చు మరియు తరువాత రూపురేఖలకు () ఫంక్షన్ అంటారు (ఇది సెకనుకు 30 సార్లు జరుగుతుంది). సంఘటనల యొక్క ఈ బేసి క్రమాన్ని పొందడానికి రూపురేఖలకు () ఫంక్షన్ తనిఖీ చేయాల్సిన అవసరం ఉంది y వస్తువు యొక్క విలువ శూన్యం (శూన్య) లేదా. అది ఉంటే శూన్యం అప్పుడు ఆ వస్తువు ఇప్పటికే తొలగించబడిందని అర్థం, కాబట్టి ముందుకు సాగండి, ఇవి మనం వెతుకుతున్న డ్రాయిడ్లు కాదు.

ఆబ్జెక్ట్ ఇంకా ప్లేలో ఉంటే, దాని స్థానాన్ని తనిఖీ చేయండి, అది స్క్రీన్ నుండి 50 పిక్సెల్స్ పోయినట్లయితే దాన్ని తొలగించి వినేవారిని తొలగించండి రూపురేఖలకు () ఈ వస్తువు కోసం ఫంక్షన్ మళ్లీ పిలువబడదు. అని నిర్ధారించుకోవడానికి కోడ్రూపురేఖలకు () ప్రతి ఫ్రేమ్ కోడ్ యొక్క తరువాతి విభాగంలో భాగం అని పిలుస్తారు.

ఈ ఆట యొక్క మొత్తం ఆవరణ ఏమిటంటే, కొత్త బెలూన్లు లేదా బాంబులు తెరపైకి వస్తాయి. అందువల్ల మాకు కొత్త బెలూన్ లేదా కొత్త బాంబును సృష్టించే ఫంక్షన్ అవసరం:

స్థానిక ఫంక్షన్ addNewBalloonOrBomb () local startX = math.random (display.contentWidth * 0.1, display.contentWidth * 0.9) if (math.random (1,5) == 1) if - BOMB! లోకల్ బాంబ్ = display.newImage ("బాంబ్.పిఎన్", స్టార్ట్ఎక్స్, -300) ఫిజిక్స్.అడ్ బాడీ (బాంబ్) బాంబ్.ఎంటర్ఫ్రేమ్ = ఆఫ్‌స్క్రీన్ రన్‌టైమ్: addEventListener ("ఎంటర్‌ఫ్రేమ్", బాంబు) బాంబు: addEventListener ("touch", బాంబ్ టచ్డ్ - బెలూన్ లోకల్ బెలూన్ = display.newImage ("red_balloon.png", startX, -300) physics.addBody (బెలూన్) balloon.enterFrame = ఆఫ్‌స్క్రీన్ రన్‌టైమ్: addEventListener ("enterFrame", బెలూన్) బెలూన్: addEventListener (addEventListener) బెలూన్ టచ్డ్) ఎండ్ ఎండ్

ఫంక్షన్ యొక్క మొదటి పంక్తి బెలూన్ ఎక్కడ నుండి పడిపోతుందో నిర్ణయిస్తుంది x విమానం. బెలూన్ లేదా బాంబు ఎల్లప్పుడూ మధ్యలో పడిపోతే, అది చాలా ఆసక్తికరంగా ఉండదు! కాబట్టిstartX స్క్రీన్ వెడల్పులో 10 శాతం మరియు 90 శాతం మధ్య యాదృచ్ఛిక సంఖ్య.

తరువాత 1 మరియు 5 మధ్య యాదృచ్ఛిక సంఖ్య ఎంపిక చేయబడుతుంది.సంఖ్య 1 అయితే బాంబు పడతారు. అది 2, 3, 4 లేదా 5 అయితే బెలూన్ పడిపోతుంది. అంటే 20 శాతం సమయం బాంబులను పడవేస్తారు.

బాంబు మరియు బెలూన్ కోడ్ చాలా పోలి ఉంటాయి. మొదట చిత్రం (బాంబు లేదా బెలూన్) ఉపయోగించి ప్రదర్శించబడుతుందిnewImage(). దీని x స్థానం ఆstartX దాని అయితే y స్థానం -300 కు సెట్ చేయబడింది, అనగా స్క్రీన్ పైభాగంలో. దానికి కారణం ఏమిటంటే, ఆ వస్తువు స్క్రీన్ ప్రాంతం వెలుపల నుండి కనిపించే ప్రదేశంలోకి పడిపోయి, ఆపై దిగువ నుండి పడిపోవాలని మేము కోరుకుంటున్నాము. మేము 2D ఫిజిక్స్ ఇంజిన్‌ను ఉపయోగిస్తున్నందున, వస్తువు పడిపోవడానికి ప్రారంభ దూరాన్ని ఇవ్వడం మంచిది, కనుక ఇది కొంత వేగాన్ని పొందవచ్చు.

కాల్physics.addBody () లోడ్ చేసిన చిత్రాన్ని తీసుకుంటుంది newImage () మరియు దానిని భౌతిక ఇంజిన్‌లోని వస్తువుగా మారుస్తుంది. ఇది చాలా శక్తివంతమైనది. ఏదైనా ఇమేజ్ ఫైల్‌ను శరీరంలోకి మార్చవచ్చు, ఇది గురుత్వాకర్షణకు మరియు గుద్దుకోవటానికి ప్రతిస్పందిస్తుందిphysics.addBody ().

బాంబు లేదా బెలూన్ కోడ్ యొక్క చివరి మూడు పంక్తులు శ్రోతలను ఏర్పాటు చేస్తాయి. సెట్టింగ్enterFrame ఆస్తి ప్రతి ఫ్రేమ్‌ను మరియు కాల్‌ను పిలవడానికి కరోనాకు చెబుతుందిరన్టైమ్: addEventListener () దాన్ని అమర్చుతుంది. చివరగా కాల్బెలూన్: addEventListener () బాంబు లేదా బెలూన్ తాకినట్లయితే ఏ ఫంక్షన్ కాల్ చేయాలో కరోనాకు చెబుతుంది.

ఇప్పుడు ఆట దాదాపు పూర్తయింది. మాకు మరో రెండు పంక్తుల కోడ్ అవసరం:

addNewBalloonOrBomb () timer.performWithDelay (500, addNewBalloonOrBomb, 0)

మొదటి పంక్తి స్పష్టంగా పిలవడం ద్వారా మొట్టమొదటి బాంబు లేదా బెలూన్ పతనం చేస్తుందిaddNewBalloonOrBomb (). రెండవ పంక్తి టైమర్‌ను సెట్ చేస్తుంది, ఇది కాల్ చేస్తుందిaddNewBalloonOrBomb () ప్రతి అర సెకను (500 మిల్లీసెకన్లు). అంటే ప్రతి అర సెకనుకు కొత్త బెలూన్ లేదా బాంబు పడతాయి.

మీరు ఇప్పుడు ఆటను ఎమ్యులేటర్‌లో అమలు చేయవచ్చు.

Main.lua కోసం పూర్తి జాబితా ఇక్కడ ఉంది, ఈ ఆట కోసం పూర్తి ప్రాజెక్ట్ సోర్స్ కోడ్ ఇక్కడ GitHub లో చూడవచ్చు.

-------------------------------------------------- --------------------------------------- - పడిపోతున్న బెలూన్ మరియు బాంబు ఆట - గారి సిమ్స్ రాసినది - ------------------------------------------- ---------------------------------------------- - ప్రారంభించండి ఫిజిక్స్ ఇంజిన్ లోకల్ ఫిజిక్స్ = అవసరం ("ఫిజిక్స్") ఫిజిక్స్.స్టార్ట్ () - సగం స్క్రీన్ వెడల్పు మరియు ఎత్తును లెక్కించండి సగం డబ్ల్యూ = డిస్ప్లే.కాంటెంట్విడ్త్ * 0.5 హాఫ్ హెచ్ = డిస్ప్లే.కాంటెంట్హైట్ * 0.5 - నేపథ్యాన్ని సెట్ చేయండి స్థానిక bkg = display.newImage ("night_sky.png", halfW, halfH) - స్కోరు స్కోరు = 0 స్కోర్‌టెక్స్ట్ = display.newText (స్కోరు, సగం W, 10) - బెలూన్‌ను ప్లేయర్ ట్యాప్ చేసినప్పుడు పిలుస్తారు - 1 స్థానిక ఫంక్షన్ బెలూన్ టచ్డ్ ద్వారా స్కోర్‌ను పెంచండి ( ఈవెంట్) if (event.phase == "ప్రారంభమైంది") అప్పుడు రన్‌టైమ్: removeEventListener ("enterFrame", event.self) event.target:removeSelf () స్కోరు = స్కోరు + 1 స్కోరు టెక్స్ట్.టెక్స్ట్ = స్కోరు ముగింపు ముగింపు - ఎప్పుడు పిలుస్తారు బాంబును ఆటగాడు నొక్కాడు - పెనాల్టీగా సగం స్కోరు స్థానిక ఫంక్షన్ బాంబ్ టచ్డ్ (ఈవెంట్) ఉంటే (event.phase == "ప్రారంభమైంది") ఆపై రన్‌టైమ్: removeEventListener ("enterFrame", event.self) event.target:removeSelf () స్కోరు = math.floor (స్కోరు * 0.5) scoreText.text = స్కోరు ముగింపు ముగింపు - పడిపోయిన వస్తువులను తొలగించండి స్క్రీన్ దిగువన స్థానిక ఫంక్షన్ ఆఫ్‌స్క్రీన్ (సెల్ఫ్, ఈవెంట్) ఉంటే (self.y == నిల్) అప్పుడు తిరిగి వస్తే (self.y> display.contentHeight + 50) అప్పుడు రన్‌టైమ్: removeEventListener ("enterFrame", self) self: removeSelf () ముగింపు ముగింపు - కొత్తగా పడే బెలూన్ లేదా బాంబు స్థానిక ఫంక్షన్‌ను జోడించు addNewBalloonOrBomb () - మీరు GitHub రెపో లోకల్ startX = math.random (display.contentWidth * 0.1, display.contentWidth * 0.9) ఉంటే (math.random (1,5) == 1) అప్పుడు - BOMB! స్థానిక బాంబు = display.newImage ("బాంబ్.పిఎంగ్", స్టార్ట్ఎక్స్, -300) ఫిజిక్స్ - బెలూన్ లోకల్ బెలూన్ = display.newImage ("red_balloon.png", startX, -300) physics.addBody (బెలూన్) బెలూన్. బెలూన్ టచ్డ్) ఎండ్ ఎండ్ - ఇప్పుడు కొత్త బెలూన్ లేదా బాంబును జోడించండి addNewBalloonOrBomb () - ప్రతి 0.5 సెకన్లకు ఒక కొత్త బెలూన్ లేదా బాంబును జోడించడం కొనసాగించండి timer.performWithDelay (500, addNewBalloonOrBomb, 0)

తదుపరి దశలు

తదుపరి దశ నిజమైన Android పరికరంలో ఆట ఆడటం. .Apk ఫైల్‌ను నిర్మించడానికి ఫైల్-> బిల్డ్ ఫర్ ఆండ్రాయిడ్… పై క్లిక్ చేసి ఫీల్డ్‌లను పూరించండి. ఫలితం .apk ఫైల్ అవుతుంది, అది మీరు మీ పరికరంలోకి కాపీ చేసి ఇన్‌స్టాల్ చేయవచ్చు. తెలియని మూలాల నుండి అనువర్తనాన్ని ఇన్‌స్టాల్ చేయడానికి అనుమతించడానికి మీరు మీ పరికరాన్ని కాన్ఫిగర్ చేశారని నిర్ధారించుకోవాలి. అమెజాన్ దీనిపై కొన్ని మంచి డాక్యుమెంటేషన్ కలిగి ఉంది, ఎందుకంటే మీరు అమెజాన్ యాప్‌స్టోర్‌ను ఇన్‌స్టాల్ చేయడానికి కూడా దీన్ని సెట్ చేయాలి. Android పరికరాల్లో మీ అనువర్తనానికి సంతకం చేయడం, నిర్మించడం మరియు పరీక్షించడం ఎలా అనే దానిపై గైడ్ కూడా ఉంది.

మీ పరికరంలో ఆట విజయవంతంగా ఇన్‌స్టాల్ చేయడంతో తదుపరి విషయం ఏమిటంటే ఆటను మెరుగుపరచడం. ఉదాహరణకు, బెలూన్ లేదా బాంబు నొక్కబడిన ప్రతిదాన్ని “పాప్” లేదా “బ్యాంగ్” ధ్వనిని జోడించడానికి ఎందుకు ప్రయత్నించకూడదు. కరోనాకు ఒక API ఉంది:media.playEventSound ().

లేదా మూడవ రకం వస్తువును జోడించడానికి ఎందుకు ప్రయత్నించకూడదు, ప్రస్తుత స్కోరును రెట్టింపు చేసే సూపర్ బూస్ట్ చెప్పండి లేదా కొన్ని నేపథ్య సంగీతం గురించి ఎలా చెప్పాలి?

ర్యాప్ అప్

కరోనాతో ఆటలను రాయడం చాలా సరళంగా ఉంటుంది, ఎందుకంటే SDK ఓపెన్‌జిఎల్ వంటి వాటిని నిర్వహిస్తుంది మరియు ఇందులో అంతర్నిర్మిత 2 డి ఫిజిక్స్ ఇంజిన్ ఉంటుంది. అలాగే లువా నేర్చుకోవడం చాలా సులభం మరియు కనీస ప్రోగ్రామింగ్ అనుభవం ఉన్నవారికి కూడా కష్టపడకూడదు. కరోనాలాబ్స్ వెబ్‌సైట్‌లో చాలా గైడ్‌లు మరియు ట్యుటోరియల్‌లతో సహా చాలా డాక్యుమెంటేషన్ ఉంది.

100 కంటే తక్కువ కోడ్లలో మాకు పని గేమ్ ఉంది. సరే, ఇది బహుమతులు గెలుచుకోదు, అయినప్పటికీ ఇది కరోనా SDK యొక్క శక్తి మరియు వశ్యతను చూపుతుంది.