ARDUINO FLAPPY BIRD (BAB 5)

Bab 5

PENUTUP

5.1 Kesimpulan

Arduino adalah pengendali mikro single-board yang bersifat open-source, diturunkan dari Wiring platform, dirancang untuk memudahkan penggunaan elektronik dalam berbagai bidang. Hardwarenya memiliki prosesor Atmel AVR dan softwarenya memiliki bahasa pemrograman sendiri. Saat ini Arduino sangat populer di seluruh dunia.Otak utama dari arduino ini adalah mikrokontroler yang ditanam pada setiap serinya, setiap seri arduino menggunakan mikrokontroler yang berbeda sesuai dengan kebutuhan, misal untuk arduino uno biasanya mikrokontroler yang dipakai adalah ATMega 328 dan bahasa pemrograman yang dipakai untuk memprogram arduino adalah C.

Mikrokontroler adalah sebuah sistem kompuer fungsional dalam sebuah chip. Di dalamnya terkandung sebuah inti prosesor, memori (sejumlah kecil RAM, memori program, atau keduanya), dan perlengkapan input output. Dengan kata lain, mikrokontroler adalah suatu alat elektronika digital yang mempunyai masukan dan keluaran serta kendali dengan program yang bisa ditulis dan dihapus dengan cara khusus, cara kerja mikrokontroler sebenarnya membaca dan menulis data. Agar sebuah mikrokontroler dapat berfungsi, maka mikrokontroler tersebut memerlukan komponen eksternal yang kemudian disebut dengan sistem minimum. Untuk membuat sistem minimal paling tidak dibutuhkan sistem clock dan reset, walaupun pada beberapa mikrokontroler sudah menyediakan sistem clock internal, sehingga tanpa rangkaian eksternal pun mikrokontroler sudah beroperasi. Yang dimaksud dengan sistem minimal adalah sebuah rangkaian mikrokontroler yang sudah dapat digunakan untuk menjalankan sebuah aplikasi. Sebuah IC mikrokontroler tidakakan berarti bila hanya berdiri sendiri. Pada dasarnya sebuah sistem minimal mikrokontroler AVR memiliki prinsip yang sama.

Flappy Bird adalah sebuah permainan di Android dan iOS, yang dibuat oleh seorang pengembang dari Hanoi, Vietnam bernama Nguyen Ha Dong dan diluncurkan pada bulan Mei 2013. Cara bermainnya yakni dengan mengetukkan jari ke layar ponsel pintar untuk membuat si burung terbang, melewati setiap pipa berwarna hijau. Jika waktu ketika mengetuk layar tidak tepat, maka dapat membuat si burung terbang menabrak pipa dan pada akhirnya harus mengulang permainan ini dari awal. Nguyen beralasan bahwa dia menciptakan permainan ini untuk kegiatan bersantai para pemainnya. Karakter utama permainan dengan nuansa grafis 8-bit ini adalah seekor burung. Cara memainkan Flappy Bird cukup dengan mengetuk jari ke layar untuk membuat si burung terbang. Bukan hanya sembarang terbang saja, namun tantangannya di sini adalah menjaga agar burung tersebut tidak menabrak pipa-pipa hijau dengan cara terbang melalui celah-celahnya. Pemain akan mendapat skor 1 (satu) jika berhasil melewati satu pipa. Jika waktu ketika mengetuk layar tidak tepat, maka dapat membuat si burung terbang menabrak pipa dan pada akhirnya harus mengulang permainan ini dari awal.

DAFTAR PUSTAKA

• https://id.wikipedia.org/wiki/Arduino
• https://ariefeeiiggeennblog.wordpress.com/2014/02/07/pengertian-fungsi-dan-kegunaan-arduino/
• https://id.wikipedia.org/wiki/Flappy_Bird
• http://repository.usu.ac.id/bitstream/handle/123456789/35001/Chapter%20II.pdf;jsessionid=133806610709FB8D1FE90443DEC3C04A?sequence=4
• http://tobuku.com/docs/Arduino-Pengenalan.pdf
• http://blog.unnes.ac.id/antosupri/pengertian-cara-kerja-dan-fungsi-transistor/
• http://www.dien-elcom.com/2012/08/pengertian-dan-jenis-transistor.html
• http://teknikelektronika.com/pengertian-ic-integrated-circuit-aplikasi-fungsi-ic/
• http://belajarelektronika.net/pengertian-dan-fungsi-ic-integrated-circuit/
• http://teknikelektronika.com/kelebihan-keterbatasan-ic-integrated-circuit/
• http://blog.unnes.ac.id/antosupri/pengertian-push-button-switch-saklar-tombol-tekan/
• http://fachrozyaulia.blogspot.co.id/2014/01/fungsi-jenis-jenis-dan-pengertian-dioda.html
• http://konstelasi.com/apa-jadinya-game-flappy-bird-dibikin-secara-nyata/
• http://www.ngarep.net/tutorial-arduino-mengakses-module-lcd-tft-2-4/
• http://howtomechatronics.com/projects/arduino-game-project-replica-of-flappy-bird-for-arduino-on-a-tft-touch-screen/
• https://www.youtube.com/watch?v=9I19S5RbtcY

ARDUINO FLAPPY BIRD (BAB 4)

Bab 4

HASIL GAME

4.1 Hasil Game Flappy Bird

Berikut ini adalah tampilan pada saat flappy bird dijalankan di arduino dengan LCD 3.2inch:

1. Pada saat tampilan Start, terlihat tulisan “Tap To Start” yang menandakan jika pemain menyentuh layar, maka permainan akan dimulai.  

2. Berikut terlihat penambahan Score dimana posisi burung harus menghindari pipa penghalang agar Score dapat bertambah. Untuk menghindari pipa, pemain harus menyentuh layar berulang kali sesuai dengan posisi burung saat naik dan turun

3. Selain menggunakan Touch Screen, permainan ini dapat digunakan menggunakan Button seperti berikut.

4. Jika burung bertubrukan dengan penghalang pipa, maka pemain dinyatakan gagal/game over seprti dibawah ini. Pada scene game over, terdapat countdown untuk kembali ke permainan/restart.

ARDUINO FLAPPY BIRD (BAB 3)

Bab 3

IMPLEMENTASI

3.1 Memulai untuk pemrograman LCD TFT 2.4

Bahan yang perlu dipersiapkan :

• Arduino Uno
• Komputer + Software IDE Arduino
• Module LCD TFT 2.4 tipe MCUFriends
• Libraries : Mcufriend_kbv_2.90 & Adafruit-GFX-Library-master

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. }