Sabtu, 22 Juli 2017

ARDUINO FLAPPY BIRD (BAB 3)

Bab 3
IMPLEMENTASI
3.1 Memulai untuk pemrograman LCD TFT 2.4
Bahan yang perlu dipersiapkan :
Hal yang pertama dilakukan yaitu mendownload default library diatas. Setelah file di download, semua library yang dibutuhkan kemudian ekstrak menggunakan aplikasi “Winrar/Winzip” dan dicopykan master folder yang ada di dalamnya ke dalam folder ‘libraries‘ yang ada pada directory installer Arduino IDE.
    Peletakan Library pada OS :
    1. Mac : (home directory)/Documents/Arduino/libraries
    2. PC (Windows) : My Documents -> Arduino -> libraries
    3. Linux : (home directory)/sketchbook/libraries

Tutorial pertama yaitu menggunakan file example “graphictest_kbv” digunakan untuk trial performa dari LCD dalam hal warna dan transisi. Pada trial graphic sementara ini diabaikan akan fitur Touchscree-nya.

Tutorial kedua yaitu menggunakan file example “Touch_shield_kbv” digunakan untuk trial warna dengan penambahan fungsi layar sentuh dari module ini.

Pada test ini akan disuguhkan dengan sebuah layar untuk berkreasi mewarnai dengan beberapa pilihan warna pen.

Kemudian tuliskan code untuk arduino gamenya, dengan menggunakan perpustakaan UTFT dan URTouch yang dibuat oleh Henning Karlsen. Anda dapat mendownload perpustakaan ini dari situs webnya, www.RinkyDinkElectronics.com. Juga kita akan menggunakan perpustakaan EEPROM untuk menyimpan nilai tertinggi di EEPROM. EEPROM adalah memori yang dapat menyimpan data bahkan saat board dimatikan.

Setelah kita memasukkan perpustakaan kita perlu membuat objek UTFT dan URTouch serta menentukan variabel yang dibutuhkan untuk permainan. Di bagian penyiapan, kita perlu memulai tampilan dan sentuhannya, membaca skor tertinggi dari EEPROM dan memulai permainan menggunakan fungsi kustom initiateGame ().

Kode Sumber

#include <UTFT.h>
  1. #include <URTouch.h>
  2. #include <EEPROM.h>
  3. // ==== Membuat Objek
  4. UTFT myGLCD ( SSD1289, 38 , 39 , 40 , 41 ) ; // Parameter harus disesuaikan dengan model Display / Schield Anda
  5. URTouch myTouch ( 6 , 5 , 4 , 3 , 2 ) ;
  6. // ==== Mendefinisikan Font
  7. extern uint8_t SmallFont [ ] ;
  8. extern uint8_t BIGFONT [ ] ;
  9. extern uint8_t SevenSegNumFont [ ] ;
  10. extern unsigned int bird01 [ 0x41A ] ; // Bird Bitmap
  11. Int x, y; // Variabel untuk koordinat tempat tampilan ditekan
  12. // Floppy Bird
  13. Int xP = 319 ;
  14. Int yP = 100 ;
  15. Int yB = 50 ;
  16. Int movingRate = 3 ;
  17. Int fallRateInt = 0 ;
  18. Float fallRate = 0 ;
  19. Skor int = 0 ;
  20. Int lastSpeedUpScore = 0 ;
  21. Int highScore;
  22. Layar booleanPressed = false ;
  23. Permainan booleanStarted = false ;
  24. Pengaturan kosong ( ) {
  25. // Inisiasi tampilan
  26. MyGLCD. InitLCD ( ) ;
  27. MyGLCD. ClrScr ( ) ;
  28. MyTouch InitTouch ( ) ;
  29. MyTouch SetPrecision ( PREC_MEDIUM ) ;
  30. HighScore = EEPROM. Baca ( 0 ) ; // Baca skor tertinggi dari EEPROM
  31. InitiateGame ( ) ; // Memulai permainan
  32. }

Jadi dengan fungsi spesial initiateGame () kita akan menggambar keadaan awal permainan dan inilah cara kita akan melakukannya. Pertama, kita perlu membersihkan layar, lalu menggambar latar belakang biru, menarik bagian bawah, menambahkan teks dan memanggil fungsi drawBird () untuk menggambar burung. Setelah ini kita membutuhkan loop sementara yang akan mencegah permainan dimulai sampai kita mengetuk layar. Jadi saat kita berada di negara ini, jika kita menekan sudut kanan atas kita dapat mengatur ulang nilai tertinggi menjadi nol dan jika kita menekan di tempat lain di layar kita akan keluar dari loop sementara dan masuk ke loop utama kode yang Akan memulai permainan.


// ===== initiateGame - Fungsi Kustom
  1. Void initiateGame ( ) {
  2. MyGLCD. ClrScr ( ) ;
  3. // latar belakang biru
  4. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  5. MyGLCD. FillRect ( 0 , 0 , 319 , 239 ) ;
  6. // Dasar
  7. MyGLCD. SetColor ( 221 , 216 , 148 ) ;
  8. MyGLCD. FillRect ( 0 , 215 , 319 , 239 ) ;
  9. MyGLCD. SetColor ( 47 , 175 , 68 ) ;
  10. MyGLCD. FillRect ( 0 , 205 , 319 , 214 ) ;
  11. // Teks
  12. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  13. MyGLCD. SetBackColor ( 221 , 216 , 148 ) ;
  14. MyGLCD. SetFont ( BigFont ) ;
  15. MyGLCD. Cetak ( "Skor:" , 5 , 220 ) ;
  16. MyGLCD. SetFont ( SmallFont ) ;
  17. MyGLCD. Cetak ( "HowToMechatronics.com" , 140 , 220 ) ;
  18. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  19. MyGLCD. SetBackColor ( 114 , 198 , 206 ) ;
  20. MyGLCD. Cetak ( "Skor Tertinggi:" , 5 , 5 ) ;
  21. MyGLCD. PrintNumI ( highScore, 120 , 6 ) ;
  22. MyGLCD. Print ( "> RESET <" , 255 , 5 ) ;
  23. MyGLCD. DrawLine ( 0 , 23 , 319 , 23 ) ;
  24. MyGLCD. Cetak ( "TAP TO START" , CENTER, 100 ) ;
  25. DrawBird ( yB ) ; // menarik burung itu
  26. // Tunggu sampai kita mengetuk sreen
  27. Sementara ( ! GameStarted ) {
  28. Jika ( myTouch. DataAvailable ( ) ) {
  29. MyTouch Baca ( ) ;
  30. X = myTouch GetX ( ) ;
  31. Y = myTouch GetY ( ) ;
  32. // setel ulang skor tertinggi
  33. If ( ( x> = 250 ) && ( x <= 319 ) && ( y> = 0 ) && ( y <= 28 ) ) {
  34. TertinggiCore = 0 ;
  35. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  36. MyGLCD. FillRect ( 120 , 0 , 150 , 22 ) ;
  37. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  38. MyGLCD. PrintNumI ( highScore, 120 , 5 ) ;
  39. }
  40. If ( ( x> = 0 ) && ( x <= 319 ) && ( y> = 30 ) && ( y <= 239 ) ) {
  41. GameStarted = true ;
  42. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  43. MyGLCD. FillRect ( 0 , 0 , 319 , 32 ) ;
  44. }
  45. }
  46. }
  47. // Menghapus teks "TAP TO START" sebelum game dimulai
  48. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  49. MyGLCD. FillRect ( 85 , 100 , 235 , 116 ) ;
  50. }
Pada bagian loop utama kita memiliki variabel xP yang digunakan untuk menggambar pilar, serta variabel yP. Pada awalnya, variabel xP memiliki nilai 319 sebagai ukuran layar dan variabel yP memiliki nilai 100 yang merupakan tinggi dari pilar pertama. Setiap iterasi nilai variabel xP mengalami penurunan dengan nilai variabel movingRate yang pada awalnya memiliki nilai 3 dan saat kita melanjutkan permainan, itu akan meningkat.
// Bagian Main Loop
  1. Void loop ( ) {
  2. XP = xP-movingRate; // xP - x koordinat pilars; Kisaran: 319 - (-51)
  3. DrawPilars ( xP, yP ) ; // Menarik pilar-pilarnya
  4. // yB - y koordinat burung yang tergantung pada nilai variabel fallingRate
  5. YB + = fallRateInt;
  6. FallRate = fallRate + 0. 4 ; // Setiap inetration tingkat kenaikan jatuh sehingga kita bisa efek percepatan / gravitasi
  7. FallRateInt = int ( fallRate ) ;
  8. // Cek tabrakan
  9. Jika ( yB> = 180 || yB <= 0 ) { // atas dan bawah
  10. GameOver ( ) ;
  11. }
  12. jika ( ( xP <= 85 ) && ( xP> = 5 ) && ( yB <= yP- 2 ) ) { // pilar atas
  13. GameOver ( ) ;
  14. }
  15. jika ( ( xP <= 85 ) && ( xP> = 5 ) && ( yB> = YP + 60 ) ) { // pilar yang lebih rendah
  16. GameOver ( ) ;
  17. }
  18. // menarik burung itu
  19. DrawBird ( yB ) ;
  20. // Setelah pilar itu melewati layar
  21. Jika ( xP <= - 51 ) {
  22. XP = 319 ; // Resets xP sampai 319
  23. YP = rand ( ) % 100 + 20 ; // Nomor acak untuk tinggi pilar
  24. Skor ++; // Tingkatkan skor menjadi satu
  25. }
  26. // ==== Mengontrol burung
  27. Jika ( myTouch. DataAvailable ( ) &&! ScreenPressed ) {
  28. FallRate = - 6 ; // Setting fallRate negative akan membuat burung melompat
  29. ScreenPressed = true ;
  30. }
  31. // Tidak membiarkan memegang layar / Anda harus menyentuhnya
  32. Lain jika ( ! MyTouch. DataAvailable ( ) && screenPressed ) {
  33. ScreenPressed = false ;
  34. }
  35. // Setelah masing-masing lima poin, tingkatkan laju pergerakan pilar
  36. Jika ( ( skor - lastSpeedUpScore ) == 5 ) {
  37. LastSpeedUpScore = skor;
  38. MoveRate ++;
  39. }
  40. }
Inilah prinsip kerja permainan: kami memiliki pilar lebar 50 piksel yang bergerak dari kanan ke kiri dan setiap pilar berikutnya memiliki ketinggian acak yang berbeda. Untuk membuat mereka bergerak, secara logis, setelah setiap iterasi kita perlu membersihkan layar dan menggambar ulang grafik dengan pilar pada posisi barunya. Namun, kita tidak bisa melakukan itu karena refresh rate layar yang rendah, yang akan menyebabkan kerlip grafis. Untuk mengaktifkan semua pikselnya layar membutuhkan waktu sedikit lebih lama sehingga oleh karena itu kita harus melakukan improvisasi dan redraw hanya hal-hal yang sedang bergerak. 


Jadi mari kita lihat bagaimana fungsi kustom drawPilars () akan melakukannya. Dibutuhkan variabel xP dan yP dan menggunakannya dan fungsi fillRect () akan menarik pilar. Jadi setiap iterasi, ia menarik pilar di lokasi baru mereka dengan tambahan persegi panjang biru dari sisi kiri dan kanan mereka yang menghapus pilar yang ditarik sebelumnya dan dengan cara itu kita benar-benar melakukan improvisasi untuk menggambar ulang pilar yang bergerak. Jika pernyataan di sini adalah improvisasi tambahan karena untuk beberapa alasan fungsi fillRect () tidak bekerja jika parameter 'x2'nya memiliki nilai dari ukuran layar. Selain itu, pada akhir fungsi khusus ini kita perlu mencetak nilai pencapaian skor.
// ===== drawPlillars - Fungsi Kustom
  1. Void drawPilars ( int x, int y ) {
  2. Jika ( x> = 270 ) {
  3. MyGLCD. SetColor ( 0 , 200 , 20 ) ;
  4. MyGLCD. FillRect ( 318 , 0 , x, y- 1 ) ;
  5. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  6. MyGLCD. DrawRect ( 319 , 0 , x- 1 , y ) ;
  7. MyGLCD. SetColor ( 0 , 200 , 20 ) ;
  8. MyGLCD. FillRect ( 318 , y + 81 , x, 203 ) ;
  9. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  10. MyGLCD. DrawRect ( 319 , y + 80 , x- 1 , 204 ) ;
  11. }
  12. Lain jika ( x <= 268 ) {
  13. // Menarik persegi panjang biru dari pilar
  14. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  15. MyGLCD. FillRect ( x + 51 , 0 , x + 60 , y ) ;
  16. // Menarik pilar
  17. MyGLCD. SetColor ( 0 , 200 , 20 ) ;
  18. MyGLCD. FillRect ( x + 49 , 1 , x + 1 , y- 1 ) ;
  19. // Menarik bingkai hitam pilar
  20. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  21. MyGLCD. DrawRect ( x + 50 , 0 , x, y ) ;
  22. // Menarik kotak biru dari pilar
  23. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  24. MyGLCD. FillRect ( x- 1 , 0 , x- 3 , y ) ;
  25. // Pilar bawah
  26. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  27. MyGLCD. FillRect ( x + 51 , y + 80 , x + 60 , 204 ) ;
  28. MyGLCD. SetColor ( 0 , 200 , 20 ) ;
  29. MyGLCD. FillRect ( x + 49 , y + 81 , x + 1 , 203 ) ;
  30. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  31. MyGLCD. DrawRect ( x + 50 , y + 80 , x, 204 ) ;
  32. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  33. MyGLCD. FillRect ( x- 1 , y + 80 , x- 3 , 204 ) ;
  34. }
  35. // gambarkan skor
  36. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  37. MyGLCD. SetBackColor ( 221 , 216 , 148 ) ;
  38. MyGLCD. SetFont ( BigFont ) ;
  39. MyGLCD. PrintNumI ( skor, 100 , 220 ) ;
  40. }
Kembali di bagian loop kita memiliki variabel yB yang merupakan posisi y burung dan itu tergantung pada tingkat jatuh yang setelah setiap iterasi meningkat dan dengan cara itu kita mendapatkan efek percepatan atau gravitasi. Juga, di sini kita periksa tabrakan dan gunakan jika pernyataan untuk membatasi burung sehingga jika sampai di atas, tanah atau pilar permainan akan berakhir. 
Selanjutnya adalah fungsi kustom drawBird () dan mari kita lihat bagaimana cara kerjanya. Burung itu sebenarnya adalah foto yang diubah menjadi bitmap menggunakan alat ImageConverter565 buatan Henning Karlsen. File ".c" yang dibuat dengan menggunakan alat harus disertakan dalam direktori sehingga dimuat saat meluncurkan sketsa. Juga kita harus mendefinisikan bitmap seperti ini dan menggunakan fungsi drawBitmap () kita akan menggambar foto di layar. Burung tersebut memiliki koordinat X tetap dan variabel yB sebagai koordinat Y. Serupa dengan pilar kita akan membersihkan keadaan burung sebelumnya dengan menggambar dua persegi panjang biru di atas dan di bawah burung.
// ====== drawBird () - Fungsi Kustom
  1. Void drawBird ( int y ) {
  2. / / Menggambar burung - bitmap
  3. MyGLCD. DrawBitmap ( 50 , y, 35 , 30 , bird01 ) ;
  4. // Menggambar persegi panjang biru di atas dan di bawah burung untuk membersihkan keadaannya yang sebenarnya
  5. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  6. MyGLCD. FillRoundRect ( 50 , y, 85 , y- 6 ) ;
  7. MyGLCD. FillRoundRect ( 50 , y + 30 , 85 , y + 36 ) ;
  8. }
Kembali pada loop kita bisa melihat bahwa setelah pilar telah melewati layar, variabel xP akan direset menjadi 319, yP akan mendapatkan nilai acak baru dari 20 sampai 100 untuk tinggi pilar dan skor akan meningkat satu. Dengan berikutnya jika pernyataan kita mengendalikan burung. Jika kita mengetuk layar kita akan mengatur tingkat jatuh ke negatif apa yang akan membuat burung melompat dan yang lain jika pernyataan tidak memungkinkan terjadi jika kita hanya memegang layar. Yang terakhir jika pernyataannya adalah untuk kesulitan permainan dan meningkatkan tingkat pergerakan pilar setelah masing-masing poin bagus.
Ok apa yang tertinggal sekarang adalah melihat bagaimana fungsi main gameOver () berfungsi. Setelah penundaan satu detik, akan menghapus layar, mencetak skor dan beberapa teks, jika skor lebih tinggi dari nilai tertinggi maka akan menuliskannya ke EEPROM, maka akan mengatur ulang semua variabel ke nilai posisi awal dan pada akhir Itu akan memanggil initiateGame () fungsi kustom untuk me-restart permainan.


// ======== gameOver () - Fungsi Kustom
  1. Void gameOver ( ) {
  2. Keterlambatan ( 1000 ) ; // 1 detik
  3. // Menghapus layar dan mencetak teksnya
  4. MyGLCD. ClrScr ( ) ;
  5. MyGLCD. SetColor ( 255 , 255 , 255 ) ;
  6. MyGLCD. SetBackColor ( 0 , 0 , 0 ) ;
  7. MyGLCD. SetFont ( BigFont ) ;
  8. MyGLCD. Cetak ( "GAME OVER" , CENTER, 40 ) ;
  9. MyGLCD. Cetak ( "Skor:" , 100 , 80 ) ;
  10. MyGLCD. PrintNumI ( skor, 200 , 80 ) ;
  11. MyGLCD. Cetak ( "Mulai ulang ..." , PUSAT, 120 ) ;
  12. MyGLCD. SetFont ( SevenSegNumFont ) ;
  13. MyGLCD. PrintNumI ( 2 , CENTER, 150 ) ;
  14. Keterlambatan ( 1000 ) ;
  15. MyGLCD. PrintNumI ( 1 , CENTER, 150 ) ;
  16. Keterlambatan ( 1000 ) ;
  17. // Menulis skor tertinggi di EEPROM
  18. Jika ( score> highScore ) {
  19. Skor tertinggi = skor;
  20. EEPROM. Tulis ( 0 , tertinggiScore ) ;
  21. }
  22. // ulangi variabel untuk memulai nilai posisi
  23. XP = 319 ;
  24. YB = 50 ;
  25. FallRate = 0 ;
  26. Skor = 0 ;
  27. LastSpeedUpScore = 0 ;
  28. MovingRate = 3 ;
  29. GameStarted = false ;
  30. // Restart permainan
  31. InitiateGame ( ) ;
  32. }
Kode lengkap permainan
/ * Arduino Game Proejct
  1. * Program yang dibuat oleh Dejan Nedelkovski,
  2. * Www.HowToMechatronics.com
  3. * /
  4. / * Program ini menggunakan perpustakaan UTFT dan URTouch
  5. * Dibuat oleh Henning Karlsen.
  6. * Anda dapat menemukan dan mendownloadnya di:
  7. * Www.RinkyDinkElectronics.com
  8. * /
  9. #include <UTFT.h>
  10. #include <URTouch.h>
  11. #include <EEPROM.h>
  12. // ==== Membuat Objek
  13. UTFT myGLCD ( SSD1289, 38 , 39 , 40 , 41 ) ; // Parameter harus disesuaikan dengan model Display / Schield Anda
  14. URTouch myTouch ( 6 , 5 , 4 , 3 , 2 ) ;
  15. // ==== Mendefinisikan Font
  16. extern uint8_t SmallFont [ ] ;
  17. extern uint8_t BIGFONT [ ] ;
  18. extern uint8_t SevenSegNumFont [ ] ;
  19. extern unsigned int bird01 [ 0x41A ] ; // Bird Bitmap
  20. Int x, y; // Variabel untuk koordinat tempat tampilan ditekan
  21. // Floppy Bird
  22. Int xP = 319 ;
  23. Int yP = 100 ;
  24. Int yB = 50 ;
  25. Int movingRate = 3 ;
  26. Int fallRateInt = 0 ;
  27. Float fallRate = 0 ;
  28. Skor int = 0 ;
  29. Int lastSpeedUpScore = 0 ;
  30. Int highScore;
  31. Layar booleanPressed = false ;
  32. Permainan booleanStarted = false ;
  33. Pengaturan kosong ( ) {
  34. // Inisiasi tampilan
  35. MyGLCD. InitLCD ( ) ;
  36. MyGLCD. ClrScr ( ) ;
  37. MyTouch InitTouch ( ) ;
  38. MyTouch SetPrecision ( PREC_MEDIUM ) ;
  39. HighScore = EEPROM. Baca ( 0 ) ; // Baca skor tertinggi dari EEPROM
  40. InitiateGame ( ) ; // Memulai permainan
  41. }
  42. Void loop ( ) {
  43. XP = xP-movingRate; // xP - x koordinat pilars; Kisaran: 319 - (-51)
  44. DrawPilars ( xP, yP ) ; // Menarik pilar-pilarnya
  45. // yB - y koordinat burung yang tergantung pada nilai variabel fallingRate
  46. YB + = fallRateInt;
  47. FallRate = fallRate + 0 .4 ; // Setiap inetration tingkat kenaikan jatuh sehingga kita bisa efek percepatan / gravitasi
  48. FallRateInt = int ( fallRate ) ;
  49. // Cek tabrakan
  50. Jika ( yB> = 180 || yB <= 0 ) { // atas dan bawah
  51. GameOver ( ) ;
  52. }
  53. jika ( ( xP <= 85 ) && ( xP> = 5 ) && ( yB <= yP- 2 ) ) { // pilar atas
  54. GameOver ( ) ;
  55. }
  56. jika ( ( xP <= 85 ) && ( xP> = 5 ) && ( yB> = YP + 60 ) ) { // pilar yang lebih rendah
  57. GameOver ( ) ;
  58. }
  59. // menarik burung itu
  60. DrawBird ( yB ) ;
  61. // Setelah pilar itu melewati layar
  62. Jika ( xP <= - 51 ) {
  63. XP = 319 ; // Resets xP sampai 319
  64. YP = rand ( ) % 100 + 20 ; // Nomor acak untuk tinggi pilar
  65. Skor ++; // Tingkatkan skor menjadi satu
  66. }
  67. // ==== Mengontrol burung
  68. Jika ( myTouch. DataAvailable ( ) &&! ScreenPressed ) {
  69. FallRate = - 6 ; // Setting fallRate negative akan membuat burung melompat
  70. ScreenPressed = true ;
  71. }
  72. // Tidak membiarkan memegang layar / Anda harus menyentuhnya
  73. Lain jika ( ! MyTouch. DataAvailable ( ) && screenPressed ) {
  74. ScreenPressed = false ;
  75. }
  76. // Setelah masing-masing lima poin, tingkatkan laju pergerakan pilar
  77. Jika ( ( skor - lastSpeedUpScore ) == 5 ) {
  78. LastSpeedUpScore = skor;
  79. MoveRate ++;
  80. }
  81. }
  82. // ===== initiateGame - Fungsi Kustom
  83. Void initiateGame ( ) {
  84. MyGLCD. ClrScr ( ) ;
  85. // latar belakang biru
  86. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  87. MyGLCD. FillRect ( 0 , 0 , 319 , 239 ) ;
  88. // Dasar
  89. MyGLCD. SetColor ( 221 , 216 , 148 ) ;
  90. MyGLCD. FillRect ( 0 , 215 , 319 , 239 ) ;
  91. MyGLCD. SetColor ( 47 , 175 , 68 ) ;
  92. MyGLCD. FillRect ( 0 , 205 , 319 , 214 ) ;
  93. // Teks
  94. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  95. MyGLCD. SetBackColor ( 221 , 216 , 148 ) ;
  96. MyGLCD. SetFont ( BigFont ) ;
  97. MyGLCD. Cetak ( "Skor:" , 5 , 220 ) ;
  98. MyGLCD. SetFont ( SmallFont ) ;
  99. MyGLCD. Cetak ( "HowToMechatronics.com" , 140 , 220 ) ;
  100. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  101. MyGLCD. SetBackColor ( 114 , 198 , 206 ) ;
  102. MyGLCD. Cetak ( "Skor Tertinggi:" , 5 , 5 ) ;
  103. MyGLCD. PrintNumI ( highScore, 120 , 6 ) ;
  104. MyGLCD. Print ( "> RESET <" , 255 , 5 ) ;
  105. MyGLCD. DrawLine ( 0 , 23 , 319 , 23 ) ;
  106. MyGLCD. Cetak ( "TAP TO START" , CENTER, 100 ) ;
  107. DrawBird ( yB ) ; // menarik burung itu
  108. // Tunggu sampai kita mengetuk sreen
  109. Sementara ( ! GameStarted ) {
  110. Jika ( myTouch. DataAvailable ( ) ) {
  111. MyTouch Baca ( ) ;
  112. X = myTouch GetX ( ) ;
  113. Y = myTouch GetY ( ) ;
  114. // setel ulang skor tertinggi
  115. If ( ( x> = 250 ) && ( x <= 319 ) && ( y> = 0 ) && ( y <= 28 ) ) {
  116. TertinggiCore = 0 ;
  117. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  118. MyGLCD. FillRect ( 120 , 0 , 150 , 22 ) ;
  119. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  120. MyGLCD. PrintNumI ( highScore, 120 , 5 ) ;
  121. }
  122. If ( ( x> = 0 ) && ( x <= 319 ) && ( y> = 30 ) && ( y <= 239 ) ) {
  123. GameStarted = true ;
  124. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  125. MyGLCD. FillRect ( 0 , 0 , 319 , 32 ) ;
  126. }
  127. }
  128. }
  129. // Menghapus teks "TAP TO START" sebelum game dimulai
  130. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  131. MyGLCD. FillRect ( 85 , 100 , 235 , 116 ) ;
  132. }
  133. // ===== drawPlillars - Fungsi Kustom
  134. Void drawPilars ( int x, int y ) {
  135. Jika ( x> = 270 ) {
  136. MyGLCD. SetColor ( 0 , 200 , 20 ) ;
  137. MyGLCD. FillRect ( 318 , 0 , x, y- 1 ) ;
  138. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  139. MyGLCD. DrawRect ( 319 , 0 , x- 1 , y ) ;
  140. MyGLCD. SetColor ( 0 , 200 , 20 ) ;
  141. MyGLCD. FillRect ( 318 , y + 81 , x, 203 ) ;
  142. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  143. MyGLCD. DrawRect ( 319 , y + 80 , x- 1 , 204 ) ;
  144. }
  145. Lain jika ( x <= 268 ) {
  146. // Menarik persegi panjang biru dari pilar
  147. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  148. MyGLCD. FillRect ( x + 51 , 0 , x + 60 , y ) ;
  149. // Menarik pilar
  150. MyGLCD. SetColor ( 0 , 200 , 20 ) ;
  151. MyGLCD. FillRect ( x + 49 , 1 , x + 1 , y- 1 ) ;
  152. // Menarik bingkai hitam pilar
  153. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  154. MyGLCD. DrawRect ( x + 50 , 0 , x, y ) ;
  155. // Menarik kotak biru dari pilar
  156. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  157. MyGLCD. FillRect ( x- 1 , 0 , x- 3 , y ) ;
  158. // Pilar bawah
  159. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  160. MyGLCD. FillRect ( x + 51 , y + 80 , x + 60 , 204 ) ;
  161. MyGLCD. SetColor ( 0 , 200 , 20 ) ;
  162. MyGLCD. FillRect ( x + 49 , y + 81 , x + 1 , 203 ) ;
  163. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  164. MyGLCD. DrawRect ( x + 50 , y + 80 , x, 204 ) ;
  165. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  166. MyGLCD. FillRect ( x- 1 , y + 80 , x- 3 , 204 ) ;
  167. }
  168. // gambarkan skor
  169. MyGLCD. SetColor ( 0 , 0 , 0 ) ;
  170. MyGLCD. SetBackColor ( 221 , 216 , 148 ) ;
  171. MyGLCD. SetFont ( BigFont ) ;
  172. MyGLCD. PrintNumI ( skor, 100 , 220 ) ;
  173. }
  174. // ====== drawBird () - Fungsi Kustom
  175. Void drawBird ( int y ) {
  176. / / Menggambar burung - bitmap
  177. MyGLCD. DrawBitmap ( 50 , y, 35 , 30 , bird01 ) ;
  178. // Menggambar persegi panjang biru di atas dan di bawah burung untuk membersihkan keadaannya yang sebenarnya
  179. MyGLCD. SetColor ( 114 , 198 , 206 ) ;
  180. MyGLCD. FillRoundRect ( 50 , y, 85 , y- 6 ) ;
  181. MyGLCD. FillRoundRect ( 50 , y + 30 , 85 , y + 36 ) ;
  182. }
  183. // ======== gameOver () - Fungsi Kustom
  184. Void gameOver ( ) {
  185. Keterlambatan ( 3000 ) ; // 1 detik
  186. // Menghapus layar dan mencetak teksnya
  187. MyGLCD. ClrScr ( ) ;
  188. MyGLCD. SetColor ( 255 , 255 , 255 ) ;
  189. MyGLCD. SetBackColor ( 0 , 0 , 0 ) ;
  190. MyGLCD. SetFont ( BigFont ) ;
  191. MyGLCD. Cetak ( "GAME OVER" , CENTER, 40 ) ;
  192. MyGLCD. Cetak ( "Skor:" , 100 , 80 ) ;
  193. MyGLCD. PrintNumI ( skor, 200 , 80 ) ;
  194. MyGLCD. Cetak ( "Mulai ulang ..." , PUSAT, 120 ) ;
  195. MyGLCD. SetFont ( SevenSegNumFont ) ;
  196. MyGLCD. PrintNumI ( 2 , CENTER, 150 ) ;
  197. Keterlambatan ( 1000 ) ;
  198. MyGLCD. PrintNumI ( 1 , CENTER, 150 ) ;
  199. Keterlambatan ( 1000 ) ;
  200. // Menulis skor tertinggi di EEPROM
  201. Jika ( score> highScore ) {
  202. Skor tertinggi = skor;
  203. EEPROM. Tulis ( 0 , tertinggiScore ) ;
  204. }
  205. // ulangi variabel untuk memulai nilai posisi
  206. XP = 319 ;
  207. YB = 50 ;
  208. FallRate = 0 ;
  209. Skor = 0 ;
  210. LastSpeedUpScore = 0 ;
  211. MovingRate = 3 ;
  212. GameStarted = false ;
  213. // Restart permainan
  214. InitiateGame ( ) ;
  215. }







-
Label:

Tidak ada komentar:

Posting Komentar

Langganan: Posting Komentar (Atom)

Pengantar Komputasi Modern Tugas 2

I. PENGERTIAN DAN PENDAHULUAN CLOUD COMPUTING Cloud computing  (komputasi awan) merupakan gabungan pemanfaatan teknologi komputer ...