เนื้อหา
มีหลายวิธีในการสร้างเกมสำหรับ Android และวิธีการหนึ่งที่สำคัญคือทำตั้งแต่เริ่มต้นใน Android Studio กับ Java สิ่งนี้จะช่วยให้คุณควบคุมได้อย่างเต็มที่ว่าคุณต้องการให้เกมของคุณมีลักษณะและการทำงานอย่างไรและกระบวนการนี้จะสอนทักษะที่คุณสามารถใช้ในสถานการณ์อื่น ๆ ได้เช่นกันไม่ว่าคุณจะสร้างหน้าจอสาดสำหรับแอพ เพิ่มภาพเคลื่อนไหวบางอย่าง เมื่อทราบแล้วว่าบทช่วยสอนนี้จะแสดงวิธีสร้างเกม 2D แบบง่ายโดยใช้ Android Studio และ Java คุณสามารถค้นหารหัสและแหล่งข้อมูลทั้งหมดได้ที่ Github หากคุณต้องการติดตาม
การตั้งค่า
ในการสร้างเกมของเราเราจะต้องจัดการกับแนวคิดเฉพาะบางประการ: ลูปเกม, เธรดและผืนผ้า เริ่มต้นด้วยเริ่ม Android Studio หากคุณยังไม่ได้ติดตั้งให้ลองตรวจสอบการแนะนำเต็มรูปแบบของเราเกี่ยวกับ Android Studio ซึ่งจะผ่านกระบวนการติดตั้ง ตอนนี้เริ่มโครงการใหม่และให้แน่ใจว่าคุณเลือกเทมเพลต ‘กิจกรรมว่าง’ นี่เป็นเกมดังนั้นแน่นอนว่าคุณไม่จำเป็นต้องมีองค์ประกอบต่างๆเช่นปุ่ม FAB ที่มีความซับซ้อน
สิ่งแรกที่คุณต้องการทำคือการเปลี่ยนแปลง AppCompatActivity ไปยัง กิจกรรม. ซึ่งหมายความว่าเราจะไม่ใช้คุณลักษณะของแถบการกระทำ
ในทำนองเดียวกันเราต้องการทำให้เกมเต็มหน้าจอ เพิ่มรหัสต่อไปนี้เพื่อ onCreate () ก่อนการโทรไปที่ setContentView ():
getWindow (). setFlags (WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); this.requestWindowFeature (Window.FEATURE_NO_TITLE);
โปรดทราบว่าหากคุณเขียนรหัสบางส่วนและมีการขีดเส้นใต้เป็นสีแดงนั่นอาจหมายความว่าคุณต้องนำเข้าชั้นเรียน กล่าวอีกนัยหนึ่งคุณต้องบอก Android Studio ว่าคุณต้องการใช้คำสั่งบางอย่างและทำให้พร้อมใช้งาน หากคุณเพียงคลิกที่ใดก็ได้บนคำที่ขีดเส้นใต้จากนั้นกด Alt + Enter ระบบจะดำเนินการให้คุณโดยอัตโนมัติ!
สร้างมุมมองเกมของคุณ
คุณอาจคุ้นเคยกับแอพที่ใช้สคริปต์ XML เพื่อกำหนดเค้าโครงของมุมมองเช่นปุ่มรูปภาพและป้ายกำกับ นี่คือสิ่งที่สาย setContentView กำลังทำเพื่อเรา
แต่นี่เป็นเกมที่มีความหมายว่าไม่จำเป็นต้องมีหน้าต่างเบราว์เซอร์หรือเลื่อนมุมมองผู้รีไซเคิล แทนที่จะเป็นเช่นนั้นเราต้องการแสดงผืนผ้าใบแทน ใน Android Studio ผ้าใบเป็นแบบเดียวกับที่ใช้ในงานศิลปะมันเป็นสื่อที่เราสามารถวาดได้
ดังนั้นเปลี่ยนบรรทัดนั้นให้อ่านดังนี้
setContentView (GameView ใหม่ (นี้))
คุณจะพบว่านี่เป็นสีแดงที่ขีดเส้นใต้อีกครั้ง แต่ ตอนนี้ หากคุณกด Alt + Enter คุณไม่มีตัวเลือกในการนำเข้าชั้นเรียน คุณมีตัวเลือกแทน สร้าง ห้องเรียน. กล่าวอีกนัยหนึ่งเรากำลังจะสร้างชั้นเรียนของเราเองที่จะกำหนดสิ่งที่จะเกิดขึ้นบนผืนผ้าใบ นี่คือสิ่งที่จะช่วยให้เราสามารถวาดลงบนหน้าจอแทนที่จะแสดงเพียงมุมมองสำเร็จรูป
คลิกขวาที่ชื่อแพ็คเกจในลำดับชั้นของคุณทางด้านซ้ายแล้วเลือก ใหม่> คลาส. คุณจะได้รับการนำเสนอพร้อมหน้าต่างเพื่อสร้างชั้นเรียนของคุณและคุณจะเรียกมันว่า GameView. ภายใต้ SuperClass ให้เขียน: android.view.SurfaceView ซึ่งหมายความว่าคลาสจะสืบทอดวิธี - ความสามารถของมัน - จาก SurfaceView
ในกล่องอินเทอร์เฟซคุณจะเขียน android.view.SurfaceHolder.Callback. เหมือนกับคลาสใด ๆ ตอนนี้เราต้องสร้างคอนสตรัคเตอร์ของเรา ใช้รหัสนี้:
เธรดหลักเธรดส่วนตัว; GameView สาธารณะ (บริบทบริบท) {super (บริบท); . getHolder () addCallback (นี้); }
ทุกครั้งที่คลาสของเราถูกเรียกให้สร้างวัตถุใหม่ (ในกรณีนี้คือพื้นผิวของเรา) มันจะเรียกใช้ตัวสร้างและมันจะสร้างพื้นผิวใหม่ บรรทัด 'super' จะเรียก superclass และในกรณีของเรานั่นคือ SurfaceView
เมื่อเพิ่มการติดต่อกลับเราจะสามารถสกัดเหตุการณ์ได้
ตอนนี้แทนที่วิธีการบางอย่าง:
@Override public void surfaceChanged (ผู้ถือ SurfaceHolder, รูปแบบ int, ความกว้าง int, ความสูง int) {} @Override public void surfaceCreated (ผู้ถือ SurfaceHolder) {} @Override public void surfaceDestroyed (ผู้ถือ SurfaceHolder) {}
สิ่งเหล่านี้ช่วยให้เราสามารถแทนที่วิธี (ชื่อดังนั้น) ใน superclass (SurfaceView) ตอนนี้คุณไม่ควรขีดเส้นใต้สีแดงในรหัสของคุณอีก ดี
คุณเพิ่งสร้างคลาสใหม่และทุกครั้งที่เราอ้างถึงมันจะสร้างพื้นที่สำหรับเกมของคุณเพื่อทาสี การเรียนการสอน สร้าง วัตถุและเราต้องการอีกหนึ่ง
กำลังสร้างเธรด
คลาสใหม่ของเรากำลังจะถูกเรียก MainThread. และหน้าที่ของมันคือการสร้างเธรด เธรดนั้นเป็นเหมือนส้อมของโค้ดที่สามารถทำงานพร้อมกันได้ หลัก ส่วนหนึ่งของรหัสของคุณ คุณสามารถมีเธรดจำนวนมากที่ทำงานทั้งหมดในครั้งเดียวดังนั้นจึงอนุญาตให้สิ่งต่าง ๆ เกิดขึ้นพร้อมกันแทนที่จะทำตามลำดับที่เข้มงวด สิ่งนี้มีความสำคัญสำหรับเกมเนื่องจากเราต้องตรวจสอบให้แน่ใจว่าเกมนั้นยังคงทำงานได้อย่างราบรื่นแม้ว่าจะเกิดขึ้นบ่อยครั้ง
สร้างคลาสใหม่ของคุณเหมือนที่คุณเคยทำมาก่อนและคราวนี้มันจะขยายออกไป ด้าย. ในตัวสร้างเรากำลังจะโทรหา ซุปเปอร์ (). โปรดจำไว้ว่านั่นคือซุปเปอร์คลาสซึ่งก็คือเธรดและสามารถยกระดับหนักสำหรับเราได้ทั้งหมด มันเหมือนกับการสร้างโปรแกรมเพื่อล้างจานที่เพิ่งโทรมา เครื่องซักผ้า().
เมื่อคลาสนี้ถูกเรียกมันจะสร้างเธรดแยกต่างหากที่รันในรูปแบบของสิ่งที่สำคัญ และมันมาจาก ที่นี่ ที่เราต้องการสร้าง GameView ของเรา นั่นหมายความว่าเรายังต้องอ้างอิงคลาส GameView และเรายังใช้ SurfaceHolder ซึ่งมีภาพวาด ดังนั้นถ้าผืนผ้าใบเป็นพื้นผิว SurfaceHolder คือขาตั้ง และ GameView เป็นสิ่งที่ทำให้ทุกอย่างเข้าด้วยกัน
สิ่งที่สมบูรณ์ควรมีลักษณะดังนี้:
ชั้นสาธารณะ MainThread ขยายกระทู้ {ส่วนตัว SurfaceHolder surfaceHolder; GameView gameView ส่วนตัว; เธรดหลักสาธารณะ (SurfaceHolder surfaceHolder, GameView gameView) {super (); this.surfaceHolder = surfaceHolder; this.gameView = gameView; }}
Schweet ตอนนี้เรามี GameView และเธรด!
การสร้างลูปเกม
ตอนนี้เรามีวัตถุดิบที่เราต้องสร้างเกมของเรา แต่ไม่มีอะไรเกิดขึ้น นี่คือที่วนรอบของเกมเข้ามาโดยทั่วไปนี่คือลูปของโค้ดที่วนไปรอบ ๆ และวนรอบและตรวจสอบอินพุตและตัวแปรก่อนที่จะวาดหน้าจอ เป้าหมายของเราคือการทำให้สิ่งนี้มีความสอดคล้องมากที่สุดเท่าที่จะทำได้เพื่อไม่ให้มี stutters หรือ hiccups ในอัตราเฟรมซึ่งฉันจะทำการสำรวจในภายหลัง
สำหรับตอนนี้เรายังอยู่ใน MainThread ชั้นเรียนและเราจะแทนที่เมธอดจากซูเปอร์คลาส อันนี้ก็คือ วิ่ง.
และมันจะเป็นแบบนี้:
@Override โมฆะสาธารณะวิ่ง () {ขณะ (วิ่ง) {canvas = null; ลอง {canvas = this.surfaceHolder.lockCanvas (); ทำข้อมูลให้ตรงกัน (surfaceHolder) {this.gameView.update (); this.gameView.draw (ผ้าใบ); }} catch (Exception e) {} ในที่สุด {if (canvas! = null) {ลอง {surfaceHolder.unlockCanvasAndPost (canvas); } catch (Exception e) {e.printStackTrace (); }}}}}
คุณจะเห็นการขีดเส้นใต้จำนวนมากดังนั้นเราจำเป็นต้องเพิ่มตัวแปรและการอ้างอิงเพิ่มเติม มุ่งหน้ากลับไปด้านบนและเพิ่ม:
SurfaceHolder ส่วนตัว GameView gameView ส่วนตัว; บูลีนส่วนตัวทำงาน ผ้าใบสาธารณะแบบคงที่;
อย่าลืมนำเข้า Canvas Canvas เป็นสิ่งที่เราจะต้องวาดบน สำหรับ 'lockCanvas' สิ่งนี้สำคัญเพราะมันเป็นสิ่งที่ทำให้ผืนผ้าใบค้างเพื่อให้เราสามารถวาดมันได้ นั่นเป็นสิ่งสำคัญเพราะมิฉะนั้นคุณอาจมีหลายเธรดที่พยายามจะวาดในครั้งเดียว เพิ่งรู้ว่าในการแก้ไขผืนผ้าใบคุณต้องก่อน ล็อค ผ้าใบ
การอัปเดตเป็นวิธีการที่เราจะสร้างขึ้นและนี่คือสิ่งที่ความสนุกจะเกิดขึ้นในภายหลัง
ลอง และ จับ ในขณะเดียวกันเป็นข้อกำหนดของ Java ที่แสดงว่าเรายินดีที่จะลองและจัดการข้อยกเว้น (ข้อผิดพลาด) ที่อาจเกิดขึ้นหากผ้าใบไม่พร้อม ฯลฯ
ในที่สุดเราต้องการที่จะสามารถเริ่มหัวข้อของเราเมื่อเราต้องการ ในการทำเช่นนี้เราจะต้องใช้วิธีการอื่นที่นี่เพื่อให้เราสามารถกำหนดสิ่งต่าง ๆ ให้เคลื่อนไหวได้ นั่นคือสิ่งที่ วิ่ง ตัวแปรมีไว้สำหรับ (โปรดทราบว่าบูลีนเป็นประเภทของตัวแปรที่เป็นจริงหรือเท็จเท่านั้น) เพิ่มวิธีนี้ใน MainThread ระดับ:
โมฆะสาธารณะ setRunning (บูลีน isRunning) {วิ่ง = isRunning; }
แต่ ณ จุดนี้สิ่งหนึ่งที่ควรเน้นก็คือ ปรับปรุง. นี่เป็นเพราะเรายังไม่ได้สร้างวิธีการอัปเดต ดังนั้นกลับเข้ามา GameView และตอนนี้เพิ่มวิธีการ
การปรับปรุงโมฆะสาธารณะ () {}
เรายังต้อง เริ่มต้น ด้าย! เรากำลังจะทำสิ่งนี้ในของเรา surfaceCreated วิธี:
@Override โมฆะสาธารณะ surfaceCreated (ผู้ถือ SurfaceHolder) {thread.setRunning (จริง); thread.start (); }
เราต้องหยุดด้ายเมื่อพื้นผิวถูกทำลาย ในขณะที่คุณอาจเดาได้เราจัดการสิ่งนี้ใน surfaceDestroyed วิธี. แต่เมื่อเห็นว่าอาจต้องใช้ความพยายามหลายครั้งในการหยุดเธรดเราจะทำการวนซ้ำและใช้งาน ลอง และ จับ อีกครั้ง ชอบมาก
@Override โมฆะสาธารณะ surfaceDestroyed (ผู้ถือ SurfaceHolder) {ลองบูลีน = จริง; ในขณะที่ (ลองใหม่) {ลอง {thread.setRunning (false); thread.join (); } catch (InterruptedException e) {e.printStackTrace (); } ลองใหม่ = false; }}
และในที่สุดก็มุ่งหน้าไปยังผู้สร้างและตรวจสอบให้แน่ใจว่าได้สร้างอินสแตนซ์ใหม่ของเธรดของคุณมิฉะนั้นคุณจะได้รับข้อยกเว้นตัวชี้โมฆะที่น่ากลัว! จากนั้นเราจะทำให้ GameView สามารถโฟกัสได้ซึ่งหมายความว่ามันสามารถจัดการกับเหตุการณ์ได้
ด้าย = ใหม่หัวข้อ (getHolder (), นี้); setFocusable (จริง);
ตอนนี้คุณสามารถ ในที่สุด ทดสอบสิ่งนี้จริง ๆ ! ถูกต้องแล้วคลิกเรียกใช้แล้ว ควร ทำงานจริงโดยไม่มีข้อผิดพลาดใด ๆ เตรียมที่จะปลิวไป!
มันคือ ... มันคือ ... หน้าจอว่างเปล่า! รหัสทั้งหมดนั้น สำหรับหน้าจอว่าง แต่นี่เป็นหน้าจอว่างของ โอกาส. คุณพร้อมแล้วที่จะวิ่งวนรอบเกมเพื่อรับมือกับเหตุการณ์ ตอนนี้สิ่งที่เหลืออยู่ก็ทำให้ทุกอย่างเกิดขึ้น ไม่สำคัญว่าคุณจะไม่ทำตามทุกอย่างในบทช่วยสอนจนถึงจุดนี้ ประเด็นคือคุณสามารถรีไซเคิลรหัสนี้เพื่อเริ่มเกมที่ยอดเยี่ยม!
ทำกราฟิก
ตอนนี้เรามีหน้าจอว่างเปล่าที่จะวาดบนทั้งหมดที่เราต้องทำคือวาดบนมัน โชคดีที่เป็นส่วนที่เรียบง่าย สิ่งที่คุณต้องทำคือการแทนที่วิธีการวาดในของเรา GameView ชั้นเรียนแล้วเพิ่มรูปภาพสวย ๆ :
@Override การจับโมฆะสาธารณะ (Canvas canvas) {super.draw (canvas); if (canvas! = null) {canvas.drawColor (Color.WHITE); Paint paint = new Paint (); paint.setColor (Color.rgb (250, 0, 0)); canvas.drawRect (100, 100, 200, 200, สี); }}
เรียกใช้สิ่งนี้และตอนนี้คุณควรมีสี่เหลี่ยมสีแดงที่ด้านซ้ายบนของหน้าจอสีขาว นี่คือการปรับปรุงอย่างแน่นอน
ในทางทฤษฎีคุณสามารถสร้างเกมของคุณได้ทั้งเกมโดยใช้วิธีนี้ (และเอาชนะได้) onTouchEvent เพื่อจัดการกับการป้อนข้อมูล) แต่นั่นไม่ใช่วิธีที่ดีในการทำเรื่องต่างๆ การวางโปรแกรมระบายสีใหม่ลงในลูปของเราจะทำให้สิ่งต่าง ๆ ช้าลงอย่างมากและแม้ว่าเราจะวางสิ่งนี้ไว้ที่อื่นเพิ่มรหัสมากเกินไปให้กับ วาด วิธีการน่าเกลียดและยากที่จะติดตาม
แต่มันมีเหตุผลมากกว่าที่จะจัดการกับวัตถุของเกมด้วยคลาสของตัวเอง เราจะเริ่มต้นด้วยตัวละครที่แสดงตัวละครและคลาสนี้จะถูกเรียก CharacterSprite. ไปข้างหน้าและทำมัน
ชั้นนี้จะวาดเทพดาลงบนผืนผ้าใบและจะเป็นเช่นนั้น
คลาสสาธารณะ CharacterSprite {รูปภาพบิตแมปส่วนตัว CharacterSprite สาธารณะ (บิตแมป bmp) {image = bmp; } การจับโมฆะสาธารณะ (Canvas canvas) {canvas.drawBitmap (ภาพ, 100, 100, null); }}
ตอนนี้เพื่อใช้สิ่งนี้คุณจะต้องโหลดบิตแมปก่อนแล้วจึงเรียกคลาสจาก GameView. เพิ่มการอ้างอิงถึง ไพรเวต CharacterSprite characterSprite และจากนั้นใน surfaceCreated วิธีการเพิ่มบรรทัด:
characterSprite = ใหม่ CharacterSprite (BitmapFactory.decodeResource (getResources (), R.drawable.avdgreen));
อย่างที่คุณเห็นบิตแมปที่เรากำลังโหลดจะถูกเก็บไว้ในแหล่งข้อมูลและเรียกว่า avdgreen (มาจากเกมก่อนหน้านี้) ตอนนี้สิ่งที่คุณต้องทำคือส่งบิตแมปนั้นไปยังคลาสใหม่ใน วาด วิธีการกับ:
characterSprite.draw (ผ้าใบ);
ตอนนี้คลิกเรียกใช้และคุณควรเห็นกราฟิกของคุณปรากฏบนหน้าจอ! นี่คือ BeeBoo ฉันเคยวาดเขาในหนังสือเรียนของฉัน
ถ้าเราต้องการทำให้เจ้าตัวเล็กเคลื่อนไหว ง่าย: เราเพิ่งสร้างตัวแปร x และ y สำหรับตำแหน่งของเขาจากนั้นเปลี่ยนค่าเหล่านี้ใน ปรับปรุง วิธี.
ดังนั้นเพิ่มการอ้างอิงไปยังของคุณ CharacterSprite แล้ววาดบิตแมปของคุณที่ x, y. สร้างวิธีการอัปเดตที่นี่และตอนนี้เรากำลังจะลอง:
Y ++;
ทุกครั้งที่การวนซ้ำของเกมทำงานเราจะย้ายตัวละครไปที่หน้าจอ โปรดจำไว้ว่า Y พิกัดวัดจากด้านบนดังนั้น 0 เป็นส่วนบนของหน้าจอ แน่นอนว่าเราต้องโทรหา ปรับปรุง วิธีการใน CharacterSprite จาก ปรับปรุง วิธีการใน GameView.
กดเล่นอีกครั้งและตอนนี้คุณจะเห็นว่ารูปภาพของคุณช้าลงเรื่อย ๆ ตามรอยหน้าจอ เรายังไม่ชนะรางวัลเกมใด ๆ แต่เป็นจุดเริ่มต้น!
โอเคเพื่อทำสิ่งต่างๆ เล็กน้อย น่าสนใจยิ่งขึ้นฉันจะวางรหัส 'ลูกบอลเด้ง' ที่นี่ นี่จะทำให้กราฟิกของเราเด้งไปมารอบ ๆ หน้าจอตรงขอบเช่นเดียวกับสกรีนเซฟเวอร์ Windows รุ่นเก่า คุณก็รู้คนที่ถูกสะกดจิตแปลก ๆ
การอัพเดทโมฆะสาธารณะ () {x + = xVelocity; 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 int ส่วนตัว = 10; ส่วนตัว int yVelocity = 5; private int screenWidth = Resources.getSystem (). getDisplayMetrics (). widthPixels; private int screenHeight = Resources.getSystem (). getDisplayMetrics (). heightPixels;
การเพิ่มประสิทธิภาพ
นั่นคือ ความอุดมสมบูรณ์ มากขึ้นที่จะเจาะลึกลงไปที่นี่จากการจัดการอินพุตของผู้เล่นไปจนถึงการปรับขนาดภาพไปจนถึงการจัดการที่มีตัวละครมากมายที่เคลื่อนไหวไปรอบ ๆ หน้าจอพร้อมกัน ตอนนี้ตัวละครจะเด้ง แต่ถ้าคุณมองอย่างใกล้ชิดมีการพูดติดอ่างเล็กน้อย มันไม่น่ากลัว แต่ความจริงที่ว่าคุณสามารถมองเห็นได้ด้วยตาเปล่านั้นเป็นสัญญาณเตือน ความเร็วยังแตกต่างกันมากบนตัวจำลองเมื่อเปรียบเทียบกับอุปกรณ์ทางกายภาพ ลองจินตนาการว่าเกิดอะไรขึ้นเมื่อคุณมี ตัน เกิดขึ้นบนหน้าจอในครั้งเดียว!
มีวิธีแก้ไขปัญหานี้เล็กน้อย สิ่งที่ฉันต้องการทำเพื่อเริ่มต้นคือการสร้างจำนวนเต็มส่วนตัวใน MainThread และเรียกมันว่า targetFPS. สิ่งนี้จะมีค่า 60ฉันจะพยายามทำให้เกมของฉันทำงานด้วยความเร็วนี้และในขณะเดียวกันฉันจะตรวจสอบเพื่อให้แน่ใจว่าเป็นจริง เพื่อที่ฉันยังต้องการคู่ส่วนตัวที่เรียกว่า averageFPS.
ฉันจะอัปเดตด้วย วิ่ง วิธีการในการวัดระยะเวลาในการวนซ้ำของแต่ละเกม หยุด เกมนั้นวนซ้ำชั่วคราวหากอยู่ข้างหน้าเป้าหมาย FPS จากนั้นเราจะคำนวณระยะเวลา ตอนนี้ เอาไปแล้วพิมพ์มันเพื่อเราจะได้เห็นมันในบันทึก
@Override โมฆะสาธารณะเรียกใช้ () {startTime ยาว เวลานานมิลลิส; เวลารอนาน longTime ทั้งหมด = 0; int frameCount = 0; long targetTime = 1000 / targetFPS; ในขณะที่ (ทำงาน) {startTime = System.nanoTime (); canvas = null; ลอง {canvas = this.surfaceHolder.lockCanvas (); ทำข้อมูลให้ตรงกัน (surfaceHolder) {this.gameView.update (); this.gameView.draw (ผ้าใบ); }} catch (Exception e) {} ในที่สุด {if (canvas! = null) {ลอง {surfaceHolder.unlockCanvasAndPost (canvas); } catch (Exception e) {e.printStackTrace (); }}} timeMillis = (System.nanoTime () - startTime) / 1000000; waitTime = targetTime - timeMillis; ลอง {this.sleep (waitTime); } catch (Exception e) {} totalTime + = System.nanoTime () - startTime; frameCount ++; if (frameCount == targetFPS) {averageFPS = 1000 / ((totalTime / frameCount) / 1000000); frameCount = 0; totalTime = 0; System.out.println (averageFPS); }}}
ขณะนี้เกมของเรากำลังพยายามล็อค FPS เป็น 60 และคุณควรพบว่าโดยทั่วไปแล้วจะวัดค่า 58-62 FPS ที่เสถียรบนอุปกรณ์ที่ทันสมัย บนเครื่องจำลองแม้ว่าคุณอาจได้รับผลลัพธ์ที่แตกต่าง
ลองเปลี่ยนเป็น 60 ถึง 30 แล้วดูว่าเกิดอะไรขึ้น เกมช้าลงและมัน ควร ตอนนี้อ่าน 30 ใน logcat ของคุณ
การปิดความคิด
มีบางสิ่งที่เราสามารถทำได้เพื่อเพิ่มประสิทธิภาพการทำงานเช่นกัน มีโพสต์บล็อกที่ยอดเยี่ยมเกี่ยวกับเรื่องที่นี่ พยายามละเว้นจากการสร้างอินสแตนซ์ใหม่ของ Paint หรือบิตแมปในลูปและทำการเริ่มต้นทั้งหมด ด้านนอก ก่อนที่เกมจะเริ่ม
หากคุณวางแผนที่จะสร้างเกม Android ยอดนิยมเกมต่อไป อย่างแน่นอน วิธีการที่ง่ายและมีประสิทธิภาพยิ่งขึ้นในทุกวันนี้ แต่ยังคงมีกรณีการใช้งานแน่นอนสำหรับความสามารถในการวาดลงบนผืนผ้าใบและเป็นทักษะที่มีประโยชน์อย่างมากในการเพิ่มเพลงของคุณ ฉันหวังว่าคู่มือนี้จะช่วยได้บ้างและหวังว่าคุณจะโชคดีในการเขียนโปรแกรมที่กำลังจะมาถึง!
ต่อไป – คู่มือสำหรับผู้เริ่มต้นสู่ Java
