విషయము

• ఏర్పాటు
• మీ ఆట వీక్షణను సృష్టిస్తోంది
• థ్రెడ్లను సృష్టిస్తోంది
• ఆట లూప్‌ను సృష్టిస్తోంది
• గ్రాఫిక్స్ చేస్తున్నారు
• సర్వోత్తమీకరణం
• మూసివేసే ఆలోచనలు

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

ఏర్పాటు

మా ఆటను సృష్టించడానికి, మేము కొన్ని నిర్దిష్ట భావనలతో వ్యవహరించాల్సి ఉంటుంది: ఆట ఉచ్చులు, థ్రెడ్‌లు మరియు కాన్వాసులు. ప్రారంభించడానికి, Android స్టూడియోని ప్రారంభించండి. మీరు దీన్ని ఇన్‌స్టాల్ చేయకపోతే, ఆండ్రాయిడ్ స్టూడియోకి మా పూర్తి పరిచయాన్ని చూడండి, ఇది ఇన్‌స్టాలేషన్ ప్రాసెస్‌లోకి వెళుతుంది. ఇప్పుడు క్రొత్త ప్రాజెక్ట్‌ను ప్రారంభించి, మీరు ‘ఖాళీ కార్యాచరణ’ మూసను ఎంచుకున్నారని నిర్ధారించుకోండి. ఇది ఆట, కాబట్టి మీకు క్లిష్టతరమైన FAB బటన్ వంటి అంశాలు అవసరం లేదు.

మీరు చేయాలనుకుంటున్న మొదటి విషయం మార్చడం AppCompatActivity కు కార్యాచరణ. దీని అర్థం మేము యాక్షన్ బార్ లక్షణాలను ఉపయోగించము.

అదేవిధంగా, మేము కూడా మా ఆటను పూర్తి స్క్రీన్‌గా చేయాలనుకుంటున్నాము. SetContentView () కు కాల్ చేయడానికి ముందు కింది కోడ్‌ను onCreate () కు జోడించండి:

getWindow (). setFlags (WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); this.requestWindowFeature (Window.FEATURE_NO_TITLE);

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

మీ ఆట వీక్షణను సృష్టిస్తోంది

బటన్లు, చిత్రాలు మరియు లేబుల్‌ల వంటి వీక్షణల లేఅవుట్‌ను నిర్వచించడానికి XML స్క్రిప్ట్‌ని ఉపయోగించే అనువర్తనాలకు మీరు ఉపయోగించబడవచ్చు. ఇదే లైన్ setContentView మా కోసం చేస్తోంది.

కానీ మళ్ళీ, ఇది బ్రౌజర్ విండోస్ లేదా స్క్రోలింగ్ రీసైక్లర్ వీక్షణలు అవసరం లేదు. దానికి బదులుగా, బదులుగా కాన్వాస్‌ను చూపించాలనుకుంటున్నాము. Android స్టూడియోలో కాన్వాస్ కళలో ఉన్నట్లే: ఇది మేము గీయగల మాధ్యమం.

కాబట్టి చదవడానికి ఆ పంక్తిని మార్చండి:

setContentView (క్రొత్త గేమ్‌వ్యూ (ఇది))

ఇది మరోసారి ఎరుపు రంగులో ఉన్నట్లు మీరు కనుగొంటారు. కానీ ఇప్పుడు మీరు Alt + Enter నొక్కితే, తరగతి దిగుమతి చేసుకునే అవకాశం మీకు లేదు. బదులుగా, మీకు ఎంపిక ఉంది సృష్టించడానికి ఒక తరగతి. మరో మాటలో చెప్పాలంటే, మేము కాన్వాస్‌పై ఏమి చేయబోతున్నామో నిర్వచించే మా స్వంత తరగతిని తయారు చేయబోతున్నాము. రెడీమేడ్ వీక్షణలను చూపించకుండా, తెరపైకి తీసుకురావడానికి ఇది మాకు అనుమతిస్తుంది.

కాబట్టి ఎడమ వైపున మీ సోపానక్రమంలోని ప్యాకేజీ పేరుపై కుడి క్లిక్ చేసి ఎంచుకోండి క్రొత్త> తరగతి. మీ తరగతిని సృష్టించడానికి మీకు ఇప్పుడు విండో ఉంటుంది మరియు మీరు దానిని పిలవబోతున్నారు GameView. సూపర్ క్లాస్ కింద, వ్రాయండి: android.view.SurfaceView అంటే తరగతి సర్ఫేస్ వ్యూ నుండి పద్ధతులను - దాని సామర్థ్యాలను - వారసత్వంగా పొందుతుంది.

ఇంటర్ఫేస్ (లు) పెట్టెలో, మీరు వ్రాస్తారు android.view.SurfaceHolder.Callback. ఏ తరగతి మాదిరిగానే, ఇప్పుడు మన కన్స్ట్రక్టర్‌ను సృష్టించాలి. ఈ కోడ్‌ను ఉపయోగించండి:

ప్రైవేట్ మెయిన్ థ్రెడ్ థ్రెడ్; పబ్లిక్ గేమ్‌వ్యూ (సందర్భ సందర్భం) {సూపర్ (సందర్భం); . GetHolder () addCallback (ఈ); }

క్రొత్త వస్తువును తయారు చేయడానికి మా తరగతి పిలువబడిన ప్రతిసారీ (ఈ సందర్భంలో మా ఉపరితలం), ఇది కన్స్ట్రక్టర్‌ను అమలు చేస్తుంది మరియు ఇది కొత్త ఉపరితలాన్ని సృష్టిస్తుంది. ‘సూపర్’ అనే పంక్తి సూపర్ క్లాస్ అని పిలుస్తుంది మరియు మన విషయంలో, అది సర్ఫేస్ వ్యూ.

కాల్‌బ్యాక్‌ను జోడించడం ద్వారా, మేము ఈవెంట్‌లను అడ్డగించగలము.

ఇప్పుడు కొన్ని పద్ధతులను భర్తీ చేయండి:

Public పబ్లిక్ శూన్య ఉపరితలం మార్చబడింది (సర్ఫేస్హోల్డర్ హోల్డర్, పూర్ణాంక ఫార్మాట్, పూర్ణాంక వెడల్పు, పూర్ణాంక ఎత్తు) public public public పబ్లిక్ శూన్య ఉపరితలం సృష్టించండి (సర్ఫేస్హోల్డర్ హోల్డర్)

ఇవి ప్రాథమికంగా సూపర్ క్లాస్ (సర్ఫేస్ వ్యూ) లోని పద్ధతులను భర్తీ చేయడానికి (అందుకే పేరు) అనుమతిస్తాయి. మీరు ఇప్పుడు మీ కోడ్‌లో ఎరుపు అండర్‌లైన్‌లను కలిగి ఉండకూడదు. నైస్.

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

థ్రెడ్లను సృష్టిస్తోంది

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

మీరు ఇంతకుముందు చేసినట్లే మీ క్రొత్త తరగతిని సృష్టించండి మరియు ఈసారి అది విస్తరించబోతోంది Thread. కన్స్ట్రక్టర్‌లో మేము కాల్ చేయబోతున్నాం సూపర్ (). గుర్తుంచుకోండి, ఇది సూపర్ క్లాస్, ఇది థ్రెడ్, మరియు ఇది మాకు అన్ని భారీ లిఫ్టింగ్ చేయగలదు. ఇది కేవలం కాల్ చేసే వంటలను కడగడానికి ఒక ప్రోగ్రామ్‌ను సృష్టించడం లాంటిది వాషింగ్ మెషీన్().

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

పూర్తి విషయం ఇలా ఉండాలి:

పబ్లిక్ క్లాస్ మెయిన్ థ్రెడ్ థ్రెడ్ {ప్రైవేట్ సర్ఫేస్హోల్డర్ ఉపరితల హోల్డర్‌ను విస్తరించింది; ప్రైవేట్ గేమ్‌వ్యూ గేమ్వ్యూ; పబ్లిక్ మెయిన్ థ్రెడ్ (సర్ఫేస్హోల్డర్ ఉపరితల హోల్డర్, గేమ్ వ్యూ గేమ్ వ్యూ) {సూపర్ (); this.surfaceHolder = ఉపరితల హోల్డర్; this.gameView = గేమ్ వ్యూ; }}

Schweet. మాకు ఇప్పుడు గేమ్‌వ్యూ మరియు థ్రెడ్ ఉంది!

ఆట లూప్‌ను సృష్టిస్తోంది

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

ప్రస్తుతానికి, మేము ఇంకా ఉన్నాము MainThread తరగతి మరియు మేము సూపర్ క్లాస్ నుండి ఒక పద్ధతిని భర్తీ చేయబోతున్నాము. ఇది ఒకటి రన్.

మరియు ఇది ఇలా ఉంటుంది.

Run నడుస్తున్నప్పుడు పబ్లిక్ శూన్య పరుగు () {ఓవర్రైడ్ (నడుస్తున్నప్పుడు) {కాన్వాస్ = శూన్య; ప్రయత్నించండి {canvas = this.surfaceHolder.lockCanvas (); సమకాలీకరించబడింది (ఉపరితల హోల్డర్) {this.gameView.update (); this.gameView.draw (కాన్వాస్); }} క్యాచ్ (మినహాయింపు ఇ) {} చివరకు {if (కాన్వాస్! = శూన్యమైనది) {ప్రయత్నించండి {surfaceHolder.unlockCanvasAndPost (కాన్వాస్); } క్యాచ్ (మినహాయింపు ఇ) {e.printStackTrace (); }}}}}

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

ప్రైవేట్ సర్ఫేస్హోల్డర్ ఉపరితల హోల్డర్; ప్రైవేట్ గేమ్‌వ్యూ గేమ్వ్యూ; ప్రైవేట్ బూలియన్ రన్నింగ్; పబ్లిక్ స్టాటిక్ కాన్వాస్ కాన్వాస్;

కాన్వాస్‌ను దిగుమతి చేసుకోవడం గుర్తుంచుకోండి. కాన్వాస్ అంటే మనం నిజంగా గీయడం. ‘లాక్‌కాన్వాస్’ విషయానికొస్తే, ఇది చాలా ముఖ్యం ఎందుకంటే ఇది కాన్వాస్‌పై గీయడానికి అనుమతించటానికి తప్పనిసరిగా స్తంభింపజేస్తుంది. ఇది చాలా ముఖ్యం ఎందుకంటే లేకపోతే, మీరు ఒకేసారి దానిపై గీయడానికి బహుళ థ్రెడ్‌లను కలిగి ఉండవచ్చు. కాన్వాస్‌ను సవరించడానికి, మీరు మొదట తప్పక తెలుసుకోండి లాక్ కాన్వాస్.

నవీకరణ అనేది మేము సృష్టించబోయే ఒక పద్ధతి మరియు ఇక్కడే సరదా విషయాలు జరుగుతాయి.

ది ప్రయత్నించండి మరియు క్యాచ్ ఇంతలో, జావా యొక్క అవసరాలు, కాన్వాస్ సిద్ధంగా లేకుంటే సంభవించే మినహాయింపులు (లోపాలు) ప్రయత్నించడానికి మరియు నిర్వహించడానికి మేము సిద్ధంగా ఉన్నామని చూపిస్తుంది.

చివరగా, మనకు అవసరమైనప్పుడు మా థ్రెడ్‌ను ప్రారంభించగలగాలి. దీన్ని చేయడానికి, మాకు ఇక్కడ మరొక పద్ధతి అవసరం, ఇది కదలికలను సెట్ చేయడానికి అనుమతిస్తుంది. అదే నడుస్తున్న వేరియబుల్ కోసం (బూలియన్ అనేది ఒక రకమైన వేరియబుల్ అని గమనించండి, అది ఎప్పుడూ నిజం లేదా తప్పు. ఈ పద్ధతిని జోడించండి MainThread తరగతి:

public void setRunning (బూలియన్ isRunning) {running = isRunning; }

ఈ సమయంలో, ఒక విషయం ఇంకా హైలైట్ చేయాలి మరియు అది నవీకరణ. దీనికి కారణం మేము ఇంకా నవీకరణ పద్ధతిని సృష్టించలేదు. కాబట్టి తిరిగి పాప్ చేయండి GameView ఇప్పుడు పద్ధతిని జోడించండి.

పబ్లిక్ శూన్య నవీకరణ () {}

మేము కూడా అవసరం ప్రారంభం థ్రెడ్! మేము దీన్ని మాలో చేయబోతున్నాము surfaceCreated పద్ధతి:

Public ఓవర్రైడ్ పబ్లిక్ శూన్య ఉపరితలం సృష్టించబడింది (సర్ఫేస్హోల్డర్ హోల్డర్) {thread.setRunning (true); thread.start (); }

ఉపరితలం నాశనం అయినప్పుడు మనం థ్రెడ్‌ను కూడా ఆపాలి. మీరు have హించినట్లుగా, మేము దీనిని నిర్వహిస్తాము surfaceDestroyed పద్ధతి. వాస్తవానికి థ్రెడ్‌ను ఆపడానికి బహుళ ప్రయత్నాలు చేయవచ్చని చూస్తే, మేము దీన్ని లూప్‌లో ఉంచి ఉపయోగించబోతున్నాము ప్రయత్నించండి మరియు క్యాచ్ మళ్ళీ. వంటి:

Public ఓవర్రైడ్ పబ్లిక్ శూన్య ఉపరితలండ్రోయిడ్ (సర్ఫేస్హోల్డర్ హోల్డర్) {బూలియన్ రిట్రీ = ట్రూ; (మళ్లీ ప్రయత్నించండి) {try {thread.setRunning (తప్పుడు); thread.join (); } క్యాచ్ (ఇంటరప్టెడ్ ఎక్సెప్షన్ ఇ) {e.printStackTrace (); } retry = తప్పుడు; }}

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

థ్రెడ్ = కొత్త మెయిన్‌థ్రెడ్ (getHolder (), ఇది); setFocusable (నిజమైన);

ఇప్పుడు మీరు చేయవచ్చు చివరకు నిజానికి ఈ విషయం పరీక్షించండి! ఇది నిజం, రన్ క్లిక్ చేయండి మరియు అది చదవాల్సిన వాస్తవానికి ఎటువంటి లోపాలు లేకుండా నడుస్తుంది. ఎగిరిపోయేలా సిద్ధం!

ఇది… ఇది… ఖాళీ స్క్రీన్! అన్ని కోడ్. ఖాళీ స్క్రీన్ కోసం. కానీ, ఇది ఖాళీ స్క్రీన్ అవకాశం. ఈవెంట్‌లను నిర్వహించడానికి మీరు మీ ఉపరితలం పైకి లేచి గేమ్ లూప్‌తో నడుస్తున్నారు. ఇప్పుడు మిగిలి ఉన్నవన్నీ విషయాలు జరిగేలా చేస్తాయి. ఈ సమయం వరకు మీరు ట్యుటోరియల్‌లోని ప్రతిదాన్ని అనుసరించకపోయినా ఫర్వాలేదు. పాయింట్ ఏమిటంటే, అద్భుతమైన ఆటలను ప్రారంభించడానికి మీరు ఈ కోడ్‌ను రీసైకిల్ చేయవచ్చు!

గ్రాఫిక్స్ చేస్తున్నారు

ప్రస్తుతం, ఇప్పుడు మనకు గీయడానికి ఖాళీ స్క్రీన్ ఉంది, మనం చేయవలసిందల్లా దానిపై గీయడం. అదృష్టవశాత్తూ, ఇది సరళమైన భాగం. మీరు చేయాల్సిందల్లా మాలోని డ్రా పద్ధతిని భర్తీ చేయడం GameView తరగతి ఆపై కొన్ని అందమైన చిత్రాలను జోడించండి:

Public ఓవర్రైడ్ పబ్లిక్ శూన్య డ్రా (కాన్వాస్ కాన్వాస్) {సూపర్.డ్రా (కాన్వాస్); if (కాన్వాస్! = శూన్య) {canvas.drawColor (Color.WHITE); పెయింట్ పెయింట్ = కొత్త పెయింట్ (); పెయింట్.సెట్ కలర్ (కలర్.ఆర్జిబి (250, 0, 0 శాతం); canvas.drawRect (100, 100, 200, 200, పెయింట్); }}

దీన్ని అమలు చేయండి మరియు మీరు ఇప్పుడు తెల్లటి స్క్రీన్ యొక్క ఎడమ ఎగువ భాగంలో అందంగా ఎరుపు చతురస్రాన్ని కలిగి ఉండాలి. ఇది ఖచ్చితంగా మెరుగుదల.

ఈ పద్ధతిలో (మరియు అతిక్రమిస్తూ) మీ మొత్తం ఆటను మీరు సిద్ధాంతపరంగా సృష్టించవచ్చు onTouchEvent ఇన్‌పుట్‌ను నిర్వహించడానికి) కానీ విషయాల గురించి తెలుసుకోవడానికి ఇది చాలా మంచి మార్గం కాదు. క్రొత్త పెయింట్‌ను మా లూప్‌లో ఉంచడం వల్ల విషయాలు చాలా మందగిస్తాయి మరియు మనం దీన్ని వేరే చోట ఉంచినా, దీనికి ఎక్కువ కోడ్‌ను జోడిస్తుంది డ్రా పద్ధతి అగ్లీ మరియు అనుసరించడం కష్టం.

బదులుగా, ఆట వస్తువులను వారి స్వంత తరగతులతో నిర్వహించడం చాలా ఎక్కువ అర్ధమే. మేము పాత్రను చూపించే ఒకదానితో ప్రారంభించబోతున్నాము మరియు ఈ తరగతి పిలువబడుతుంది CharacterSprite. ముందుకు సాగండి.

ఈ తరగతి కాన్వాస్‌పై స్ప్రైట్‌ను గీయబోతోంది మరియు అలా కనిపిస్తుంది

పబ్లిక్ క్లాస్ క్యారెక్టర్‌స్రైట్ {ప్రైవేట్ బిట్‌మ్యాప్ చిత్రం; public CharacterSprite (Bitmap bmp) {image = bmp; } పబ్లిక్ శూన్య డ్రా (కాన్వాస్ కాన్వాస్) {canvas.drawBitmap (చిత్రం, 100, 100, శూన్య); }}

ఇప్పుడు దీన్ని ఉపయోగించడానికి, మీరు మొదట బిట్‌మ్యాప్‌ను లోడ్ చేసి, ఆపై తరగతి నుండి కాల్ చేయాలి GameView. దీనికి సూచనను జోడించండి ప్రైవేట్ క్యారెక్టర్‌స్ప్రైట్ క్యారెక్టర్‌స్ప్రైట్ ఆపై surfaceCreated పద్ధతి, పంక్తిని జోడించండి:

characterSprite = new CharacterSprite (BitmapFactory.decodeResource (getResources (), R.drawable.avdgreen));

మీరు చూడగలిగినట్లుగా, మేము లోడ్ చేస్తున్న బిట్‌మ్యాప్ వనరులలో నిల్వ చేయబడుతుంది మరియు దీనిని avdgreen అంటారు (ఇది మునుపటి ఆట నుండి వచ్చింది). ఇప్పుడు మీరు చేయాల్సిందల్లా ఆ బిట్‌మ్యాప్‌ను క్రొత్త తరగతికి పంపండి డ్రా దీనితో పద్ధతి:

characterSprite.draw (కాన్వాస్);

ఇప్పుడు రన్ క్లిక్ చేయండి మరియు మీ స్క్రీన్‌లో మీ గ్రాఫిక్ కనిపించడాన్ని మీరు చూడాలి! ఇది బీబూ. నేను అతనిని నా పాఠశాల పాఠ్యపుస్తకాల్లో గీస్తాను.

మేము ఈ చిన్న వ్యక్తిని తరలించాలనుకుంటే? సరళమైనది: మేము అతని స్థానాల కోసం x మరియు y వేరియబుల్స్‌ని సృష్టించి, ఆపై ఈ విలువలను ఒక నవీకరణ పద్ధతి.

కాబట్టి మీ సూచనలను జోడించండి CharacterSprite ఆపై మీ బిట్‌మ్యాప్‌ను గీయండి x, y. నవీకరణ పద్ధతిని ఇక్కడ సృష్టించండి మరియు ప్రస్తుతానికి మేము ప్రయత్నించబోతున్నాం:

y ++;

గేమ్ లూప్ నడుస్తున్న ప్రతిసారీ, మేము పాత్రను తెరపైకి కదిలిస్తాము. గుర్తుంచుకోండి, y అక్షాంశాలు పై నుండి కొలుస్తారు 0 స్క్రీన్ పైభాగం. వాస్తవానికి మనం కాల్ చేయాలి నవీకరణ లో పద్ధతి CharacterSprite నుండి నవీకరణ లో పద్ధతి GameView.

మళ్ళీ ప్లే నొక్కండి, ఇప్పుడు మీ చిత్రం నెమ్మదిగా తెరపైకి వస్తుందని మీరు చూస్తారు. మేము ఇంకా ఏ ఆట అవార్డులను గెలుచుకోలేదు, కానీ ఇది ప్రారంభమే!

సరే, వస్తువులను తయారు చేయడానికి కొద్దిగా మరింత ఆసక్తికరంగా, నేను ఇక్కడ కొన్ని ‘బౌన్సీ బాల్’ కోడ్‌ను వదలబోతున్నాను. ఇది పాత విండోస్ స్క్రీన్సేవర్ల మాదిరిగా అంచుల నుండి స్క్రీన్ చుట్టూ మా గ్రాఫిక్ బౌన్స్ అవుతుంది. మీకు తెలుసు, వింతగా హిప్నోటిక్ వాటిని.

పబ్లిక్ శూన్య నవీకరణ () {x + = x వెలోసిటీ; y + = yVelocity; if ((x & gt; screenWidth - image.getWidth ()) || (x & lt; 0)) {xVelocity = xVelocity * -1; } if ((y & gt; screenHeight - image.getHeight ()) || (y & lt; 0)) {yVelocity = yVelocity * -1; }}

మీరు ఈ వేరియబుల్స్ ను కూడా నిర్వచించాలి:

ప్రైవేట్ పూర్ణాంకం xVelocity = 10; ప్రైవేట్ పూర్ణాంక yVelocity = 5; private int screenWidth = Resources.getSystem (). getDisplayMetrics (). వెడల్పు పిక్సెల్స్; ప్రైవేట్ ఇంటెంట్ స్క్రీన్హైట్ = రిసోర్సెస్.జెట్సిస్టమ్ (). getDisplayMetrics (). ఎత్తు పిక్సెల్స్;

సర్వోత్తమీకరణం

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

ఈ సమస్యకు కొన్ని పరిష్కారాలు ఉన్నాయి. ప్రారంభించడానికి నేను ఏమి చేయాలనుకుంటున్నాను, ఒక ప్రైవేట్ పూర్ణాంకాన్ని సృష్టించడం MainThread మరియు దానిని కాల్ చేయండి targetFPS. దీని విలువ 60 ఉంటుంది.నేను నా ఆటను ఈ వేగంతో నడపడానికి ప్రయత్నిస్తాను, అదే సమయంలో, అది ఉందో లేదో తనిఖీ చేస్తాను. దాని కోసం, నేను ప్రైవేట్ డబుల్ అని కూడా కోరుకుంటున్నాను averageFPS.

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

Public ఓవర్‌రైడ్ పబ్లిక్ శూన్యత రన్ () {లాంగ్ స్టార్ట్‌టైమ్; దీర్ఘకాలం మిల్లిస్; దీర్ఘ నిరీక్షణ సమయం; దీర్ఘ మొత్తం టైమ్ = 0; పూర్ణాంక ఫ్రేమ్‌కౌంట్ = 0; లాంగ్ టార్గెట్ టైమ్ = 1000 / టార్గెట్ ఎఫ్పిఎస్; (నడుస్తున్నప్పుడు) {startTime = System.nanoTime (); canvas = శూన్య; ప్రయత్నించండి {canvas = this.surfaceHolder.lockCanvas (); సమకాలీకరించబడింది (ఉపరితల హోల్డర్) {this.gameView.update (); this.gameView.draw (కాన్వాస్); }} క్యాచ్ (మినహాయింపు ఇ) {} చివరకు {if (కాన్వాస్! = శూన్యమైనది) {ప్రయత్నించండి {surfaceHolder.unlockCanvasAndPost (కాన్వాస్); } క్యాచ్ (మినహాయింపు ఇ) {e.printStackTrace (); }}} timeMillis = (System.nanoTime () - startTime) / 1000000; waitTime = targetTime - timeMillis; ప్రయత్నించండి {this.sleep (వెయిట్‌టైమ్); } క్యాచ్ (మినహాయింపు ఇ) {} టోటల్‌టైమ్ + = సిస్టమ్.నానోటైమ్ () - స్టార్ట్‌టైమ్; frameCount ++; if (frameCount == targetFPS) {averageFPS = 1000 / ((totalTime / frameCount) / 1000000); frameCount = 0; టోటల్ టైమ్ = 0; System.out.println (averageFPS); }}}

ఇప్పుడు మా ఆట అది FPS ని 60 కి లాక్ చేయడానికి ప్రయత్నిస్తోంది మరియు ఇది సాధారణంగా ఆధునిక పరికరంలో 58-62 FPS ని స్థిరంగా కొలుస్తుందని మీరు కనుగొనాలి. ఎమ్యులేటర్‌లో మీరు వేరే ఫలితాన్ని పొందవచ్చు.

60 నుండి 30 వరకు మార్చడానికి ప్రయత్నించండి మరియు ఏమి జరుగుతుందో చూడండి. ఆట నెమ్మదిస్తుంది మరియు అది చదవాల్సిన ఇప్పుడు మీ లాగ్‌క్యాట్‌లో 30 చదవండి.

మూసివేసే ఆలోచనలు

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

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

తరువాత – జావాకు ఒక అనుభవశూన్యుడు గైడ్