Laporan Tugas Akhir Fix Last

PENERAPAN METODE RECURSIVE DIVISION DAN METODE
DEPTH FIRST SEARCH DALAM PEMBUATAN GAME HELP
SAKERA OUT PADA PERANGKAT BERGERAK

TUGAS AKHIR
Oleh:
Moh. Supandi
120411100027

PROGRAM STUDI TEKNIK INFORMATIKA
FAKULTAS TEKNIK
UNIVERSITAS TRUNOJOYO MADURA
BANGKALAN
2016

PENERAPAN METODE RECURSIVE DIVISION DAN METODE
DEPTH FIRST SERCH DALAM PEMBUATAN GAME HELP
SAKERA OUT PADA PERANGKAT BERGERAK

Pembimbing I
Pembmbing II

Moh. Supandi
(12.04.1.1.1.00027)
: Yonathan Ferry Hendrawan, S.T., MIT.
: Cucun Very Angkoso, S.T., MT.
ABSTRAK

Dalam pembuatan sebuah game terdapat 2 cara yang bisa
dilakukan. Cara yang pertama adalah dengan cara dinamis, sedangkan
cara yang kedua adalah cara statis. Cara dinamis memiliki kelebihan
dibandingkan dengan cara yang statis yaitu konten yang ada pada game
tidak mudah dihafalkan oleh pemain. Konten tersebut dapat berupa
dunia pada game, jalan cerita, aktor, musuh, peluru, serta, aspek lainnya.
Cara yang statis memiliki kelemahan yaitu segala aspek yang ada pada
game tidak akan pernah mengalami perubahan sehingga pemain dapat
dengan mudah memenangkan permainan dengan menghafalakan aspek
yang ada pada game. Salah satu cara untuk membuat sebuah game yang
dinamis adalah dengan menerapkan metode Recursive Division dan
metode Depth First Search(DFS). Metode Recursive Division adalah
metode untuk membangun sebuah maze. Sedangkan metode Depth First

Search adalah metode untuk mencari jalan keluar pada maze. Pada
penelitian ini, kedua metode tersebut diterapkan pada pembuatan game
yang berjudul Help Sakera Out. Game ini akan berjalan pada perangkat
bergerak Android.
Hasil penelitian menunjukkan bahwa metode
Recursive Division cederung lebih cepat dari pada metode
pembandingnya dan layout yang dihasilkan memiliki ciri khusus yaitu
terdapat 1 jalan keluar pada tengah-tengah maze.
Kata kunci : Metode Recursive Division, Metode Depth First Search,
Maze, Android

DAFTAR ISI
ABSTRAK...............................................................................................ii
DAFTAR ISI...........................................................................................iii
DAFTAR GAMBAR................................................................................v
DAFTAR TABEL..................................................................................vii
BAB I........................................................................................................1
1.1.
Latar Belakang........................................................................1
1.2.

Perumusan Masalah................................................................1
1.3.
Tujuan dan Manfaat................................................................2
1.4.
Batasan Masalah.....................................................................2
1.5.
Metodologi Penelitian.............................................................2
1.6.
Sistematika Penulisan.............................................................3
BAB II......................................................................................................5
2.1. Tinjauan Pustaka...........................................................................5
2.2.1. Penelitian Sebelumnya...........................................................5
2.2. Landasan Teori..............................................................................5
2.2.1. Maze...........................................................................................6
2.2.2. Metode Recursive Division....................................................6
2.2.2.1. Cara Kerja Metode Recursive Division...............................6
2.2.3. Metode Depth First search(DFS)............................................9
2.2.4. Android.................................................................................12
2.2.5. Metode Pembanding.............................................................13
BAB III...................................................................................................15

3.1. Algoritma Generate Maze...........................................................15
3.2. Flowchart Generating Level........................................................16
3.3. Skenario Game............................................................................17
3.4. MockUp Game............................................................................20
BAB IV...................................................................................................23
4.1. Implementasi Bahasa Pemrograman...........................................23
4.2. Lingkungan Ujicoba....................................................................28
4.3. Penjelasan User Interface dan Menu-menu.................................28
4.4. Pengujian.....................................................................................36
4.4.1. Ujicoba pada Emulator WVGA 1024 MB...........................36
4.4.2. Ujicoba pada ponsel IRO 1024MB......................................40
4.4.3. Ujicoba Layout.....................................................................42
BAB V....................................................................................................55
5.1. Kesimpulan..................................................................................55
5.2. Saran............................................................................................55

DAFTAR PUSTKA................................................................................56
LAMPIRAN...........................................................................................57

DAFTAR GAMBAR

Gambar 2.1 Maze 5x5 kosong.................................................................7
Gambar 2.2 Acak Dinding dan jalur pada maze......................................7
Gambar 2.3 Mengulangi langkah 2..........................................................8
Gambar 2.4: Hasil akhir maze..................................................................8
Gambar 2.5. Ilustrasi masalah..................................................................9
Gambar 2.6 Tandai node awal................................................................10
Gambar 2.7 Langkah ke 2......................................................................10
Gambar 2.8 Langkah 3...........................................................................11
Gambar 2.9 Hasil akhir DFS..................................................................11
Gambar 2.10 Flowchart Metode Depth First Search..............................12
Gambar 3.1 Flowchart Generate Level..................................................16
Gambar 3.2 Halaman awal game............................................................17
Gambar 3.3 Game Play...........................................................................18
Gambar 3.4 Halaman Setting.................................................................19
Gambar 3.5 Mockup game.....................................................................20
Gambar 4.1 Halaman Home...................................................................29
Gambar 4.2 Halaman About...................................................................30
Gambar 4.3 Halaman setting..................................................................30
Gambar 4.4 Halaman Loading...............................................................31
Gambar 4.5 Halaman informasi game....................................................32

Gambar 4.6 Halaman Game Play...........................................................32
Gambar 4.7 Halaman bantun..................................................................33
Gambar 4.8 Halaman Pause...................................................................34
Gambar 4.9 Halaman menang................................................................35
Gambar 4.10 Halaman kalah..................................................................36
Gambar 4.11 Ujicoba pada emulator......................................................37
Gambar 4.12 Ujicoba pada ponsel..........................................................40
Gambar 4.13 Recursive Level 1.............................................................43
Gambar 4.14 Aldous Broder level 1.......................................................43
Gambar 4.15 Recursive Division level 2..............................................43
Gambar 4.16 Aldous Broder level 2.......................................................43
Gambar 4.17 Recursive Division level 3...............................................44
Gambar 4.18 Aldous Broder level 3.......................................................44
Gambar 4.19 Recursive Division level 4...............................................44

Gambar 4.20 Aldous Broder level 4.......................................................44
Gambar 4.21 Recursive Division level 5...............................................45
Gambar 4.22 Aldous Broder level 5.......................................................45
Gambar 4.23 Recursive Division level 6...............................................45
Gambar 4.24 Aldous Broder level 6.......................................................45

Gambar 4.25 Recursive Division level 7...............................................46
Gambar 4.26 Aldous Broder level 7.......................................................46
Gambar 4.27 Recursive Division level 8...............................................46
Gambar 4.28 Aldous Broder level 8.......................................................46
Gambar 4.29 Recursive Division level 9...............................................47
Gambar 4.30 Aldous Broder level 9.......................................................47
Gambar 4.31 Recursive Division level 10.............................................47
Gambar 4.32 Aldous Broder level 10.....................................................47
Gambar 4.33 Recursive Division level 11.............................................48
Gambar 4.34 Aldous Broder level 11.....................................................48
Gambar 4.35 Recursive Division level 12.............................................48
Gambar 4.36 Aldous Broder level 12.....................................................48
Gambar 4.37 Recursive Division level 13.............................................49
Gambar 4.38 Aldous Broder level 13.....................................................49
Gambar 4.39 Recursive Division level 14.............................................49
Gambar 4.40 Aldous Broder level 14.....................................................49
Gambar 4.41 Recursive Division level 15.............................................50
Gambar 4.42 Aldous Broder level 15....................................................50
Gambar 4.43 Recursive Division level 16.............................................50
Gambar 4.44 Aldous Broder level 16.....................................................50

Gambar 4.45 Recursive Division level 17.............................................51
Gambar 4.46 Aldous Broder level 17.....................................................51
Gambar 4.47 Recursive Division level 18.............................................51
Gambar 4.48 Aldous Broder level 18.....................................................51
Gambar 4.47 Recursive Division level 19.............................................52
Gambar 4.50 Aldous Broder level 19.....................................................52
Gambar 4. 49 Division level 20.............................................................52
Gambar 4.52 Aldous Broder level 20.....................................................52

DAFTAR TABEL
Tabel 2.1 Penelitian sebelumnya..............................................................5
Tabel 3.1 Daftar Algoritma generate maze............................................15
Table 3.2 Perbedaan pada tiap level.......................................................21
Table 4.1 Spesifikasi perangkat..............................................................28
Tabel 4.2 Ujicoba metode Recursive Division.......................................38
Tabel 4.3 Ujicoba Metode Aldous Broder.............................................39
Tabel 4.4 Ujicoba Metode Recursive Division......................................41
Tabel 4.5 Ujicoba pada metode Aldous Broder.....................................42
Tabel 4.6 Ujicoba Layout.......................................................................43
BAB I

PENDAHULUAN
1.1. Latar Belakang
Game merupakan sebuah hiburan yang saat ini banyak
digemari oleh berbagai kalangan, mulai dari anak-anak hingga orang
dewasa. Selain sebagai media untuk bersenang-senang, game juga dapat
dijadikan sebagai media untuk belajar yang efektif seperti misalnya
game matematika yang banyak beredar baik dikomputer maupun
dperangkat bergerak Android.
Hingga saat ini,game yang dapat di unduh pada perangkat
bergerak android jumlahnya banyak sekali dengan berbagai jenis game
yang berbeda-beda. Jenis game puzzle yang bisa diunduh melalui situs
store.google.com kebanyakan merupakan game puzzle yang mudah
ditebak baik dalam pembuatan alur cerita pada game ataupun pembuatan
dunia pada game. Pembutan game yang statis dapat membuat pemain
dengan mudah menghafal game yang mereka mainkan sehingga game
akan terasa tidak memiliki tantagan.
Pada penelitian ini, telah dibuat sebuah game dengan judul
Help Sakera Out yang menerapkan metode Recursive Division dalam
pembuatan layout pada game dan metode Depth First Search yang
digunakan untuk mencari jalan keluar pada game. Metode Recursive

Division merupakan metode yang digunakan untuk membangun sebuah
maze. Sedangkan metode Depth First Search merupakan sebuah
metode yang dapat digunakan untuk mencari jalan keluar dari maze.

1.2. Perumusan Masalah
Dari uraian latar belakang yang telah dipaparkan, rumusan masalah yang
dapat diangkat adalah sebagai berikut:
1. Bagaimana membuat sebuah maze dengan menggunakan
metode Recursive Division?
2. Bagaimana mencari jalan keluar pada maze dengan
menggunakan metode Depth First Search.
3. Bagaimana membuat sebuah game dinamis dengan menerapkan
metode Recursive Division dan metode Depth First Search.

1.3. Tujuan dan Manfaat
Tujuan dan manfaat yang dapat diambil dari permasalahan diatas antara
lain:
1. Tujuan
Tujuan pada peelitian ini adalah:
1. Membuat game dinamis yang layout pada game tidak

mudah dihafalkan oleh pemain.
2. Menerapkan metode Recursive Division pada pembuatan
layout game.
3. Menerapkan metode Depth First Search untuk mencari
jalan keluar pada layout game.
2. Manfaat
Manfaat yang dapat diambil dari penelitian ini adalah terujinya
sebuah metode dalam membangun maze pada sebuah game sehingga
kecepatan yang dimiliki oleh metode Recursive Division dapat
dimanfaatkan oleh peneliti senlajutnya.
1.4. Batasan Masalah
Batasan masalah dari penelitian ini antara lain:
1. Perangkat bergerak Android minimal yang digunakan
adalah perangkat bergerak Android dengan versi 4.2(Jelly
Bean).
2. Resolusi minimal perangkat bergerak Android yang
digunakan adalah 320x480 pixel.
3. Ukuran maze minimal 2x2.
4. Ukuran maze maksimal 21x21.
5. Jumlah level pada game sebanyak 20 level.

1.5. Metodologi Penelitian
Adapun metodologi penelitian yang digunakan adalah sebagai berikut:
1. Menganalisa kebutuhan.
2. Studi litearatur dan pengumpulan data, yaitu melakukan
tinjauan pustaka tentang konsep dan teori tentang metode
yang digunakan dalam membangun game dinamis.
3. Perancangan dan desain game yang akan dibangun.
4. Implementasi metode bahasa pemrograman dalam
pembuatan game pada IDE Eclipse.
5. Uji coba program
6. Menganalisa kesalahan program.
7. Perbaikan kesalahan pada program
8. Penyusunan laporan, pada tahapan penulisan laporan
disesuaikan pada sistematika penulisan penelitian yang
ada.
1.6. Sistematika Penulisan
Sistematika pembahasan yang digunakan untuk menyelesaikan Tugas
Akhir adalah sebagai berikut :
BAB I : PENDAHULUAN
Bab ini membahas tentang latar belakang penelitian, ruang
lingkup, tujuan dan manfaat penulisan, metodologi penulisan,
dan sistematika penulisan.
BAB II : STUDI PUSTAKA
Bab ini membahas mengenai landasan teori-teori pokok yang
digunakan dalam menyusun penelitian ini. Landasan teori
yang dibahas meliputi teori umum dan teori khusus.
BAB III : PERANCANGAN SISTEM
Dalam bab ini akan menjelaskan mengenai rancangan yang
digunakan dalam pembuatan sistem
BAB IV : IMPLEMENTASI SISTEM
Bab ini akan menjelaskan mengenai hasil implementasi dari
aplikasi.
BAB V : KESIMPULAN DAN SARAN
Bab ini merupakan kesimpulan yang penulis dapatkan
berdasarkan hasil penelitian. Pada bab ini juga terdapat
kesimpulan dan saran penulis kepada berbagai pihak yang
berhubungan dengan laporan skripsi ini untuk pengembangan
selanjutnya.

[Halaman ini sengaja dikosongkan]

BAB II
STUDI PUSTAKA
2.1. Tinjauan Pustaka
Tinjauan pustaka merupakan teori dasar dan teori pendukung
diadakannya penelitian ini. Teori-teori tersebut antara lain:
2.2.1. Penelitian Sebelumnya
Terdapat 2 penelitian sebelumnya yang membahas tentang implementasi
metode dalam membuat maze. Penlitian ini dapat dilihat pada tabel 2.1.
Tabel 2.1 Penelitian sebelumnya
NO

JUDUL

TAHUN

1

Implementasi
Algoritma Prim
dan Depth First
Search
Pada
Pembuatan Maze
Game
Berbasis
Android
OS
Mobile

2012

2

Rancang Bangun
Game
Maze
Sebagai
Game
Edukasi Bahasa
Inggris Pada Anak

2015

KETERANGAN
Penelitain ini berfokus
pada pembuatan maze
dan pencarian lintasan.
Pemain harus mencari
jalan keluar dalam selang
waktu terntentu untuk
memenagkan permainan.
[CITATION MKh12 \l
1057 ]
Pada penelitian ini, maze
digunakan sebagai dunia
pada game. Player harus
mendatangi item yang
disebutkan pada soal
dalam bentuk bahasa
ingris. Item secara acak
di letekkan pada bagian
maze
yang
kosong.
[CITATION Nur15 \l
1057 ]

Metode Prim adalah salah satu metode dalam membuat sebuah
maze. metode ini berfokus pada pembuatan jalan dalam membangun
maze sedangkan metode Recursive Division berfokus pada pembuatan
dinding pada maze. Menurut penelitian yang dilakukan oleh Walter D
Pullen(2015), “Metode Recursive Division memiliki kecepatan yang
jauh lebih baik dari metode Prime,Kruskal dan, Aldous Broder”
[ CITATION Wal15 \l 1057 ].

2.2. Landasan Teori
Landasan teori merupakan teori dasar yang digunakan dalam
penelitian ini. Terdapat beberapa teori dan metode yang dijelaskan,
antara lain:

2.2.1. Maze
“Maze merupakan koleksi jalan biasanya dari pintu masuk
menuju pintu keluar” [ CITATION Her00 \l 1057 ] . Maze sering juga
dikenal dengan kata labirin. Labirin dan maze memiliki kesamaan,
namun keduanya adalah suatu hal yang berbeda. Maze memiliki jalan
yang berliku-liku dan terdapat percabangan pada beberapa jalan dan
memiliki beberapa jalan buntu. Labirin juga merupakan jalan yang
berliku-liku, namun labirin tidak memiliki percabangan pada jalannya
dan juga tidak terdapat jalan buntu. Terdapat beberapa metode yang
dapat digunakan untuk membangun maze. Masing-masing metode
memiliki kelebihan dan kekurangan. Pada penelitan ini maze digunakan
untuk membangun layout pada game yang berentuk jalan. Metode yang
digunakan adalah metode Recursive Division. Selain metode untuk
membangun maze, digunakan juga sebuah metode yang dapat mencari
jalan keluar pada maze, yaitu metode Depth First Serach(DFS) .
2.2.2. Metode Recursive Division
Metode Recursive Division adalah metode dalam pembuatan
maze. dalam pembuatan maze, metode ini memiliki cara yang unik dari
metode-metode yang ada. Metode ini berfokus pada pembuatan
dinding . Hal ini sangat berbeda dengan kebanyakan metode yang
berfokus pada pembuatan jalur. Meskipun dalam membangun maze
cenderung tidak sama dengan metode yang lainnya, metode ini juga
memiliki kesamaan dengan metode yang lain, yaitu dalam membangun
jalannya.
2.2.2.1. Cara Kerja Metode Recursive Division
Cara kerja metode Recursive Division dapat dilihat pada
ilustrasi gambar 2.1 hingga gambar 2.4. Berikut penjelasan dari masingasing gambar.
1. Gambar 2.1 : inisialisasi maze dengan ukuran 5x5 namun maze
dalam kondisi kosong.

Gambar 2.1 Maze 5x5 kosong

2.

Gambar 2.2: acak sebuah dinding kemudian acak juga sebuah
jalur pada dinding yang telah terbentuk. Maze akan terbagi
menjadi 2 bagian.

Gambar 2.2 Acak Dinding dan jalur pada maze.
3.

Gambar 2.3 : Lanjutkan proses pengacakan secara rekursif
untuk setiap area yang dihasilkan.

Gambar 2.3 Mengulangi langkah 2.
4.

Gambar 2.4: Proses rekursif dihentikan karena semua area
sudah tidak dapat dibagi 2.

Gambar 2.4: Hasil akhir maze.

2.2.3. Metode Depth First search(DFS)
Metode Depth First Search merupakan sebuah metode yang
dapat digunakan untuk mencari jalur. jalur yang dimaksud dapat berupa
jalur pada maze, labirin atau sebuah percabangan tertentu.
2.2.3.1. Cara Kerja Metode Depth First Search
Terdapat sebuah kasus yang dapat dilihat pada gambar 2.5.
Titik awal adalah node 1 sedangkan titik tujuan adalan node 5.

Gambar 2.5. Ilustrasi masalah
Maka langkah yang dapat diambil adalah dengan menandai titik pada
node seperti pada gambar 2.6.

Gambar 2.6 Tandai node awal
Langkah selanjutnya adalah dengan mengecek apakah node yang sedang
aktif merupakan node tujuan, jika bukan maka lihat sebelah kiri node
aktif. Jika terdapat sebuah node disebelah kiri node yang sedang aktif,
maka kunjungi dan tandai. Ilustrasi ini dapat dilihat pada gambar 2.7.

Gambar 2.7 Langkah ke 2
Langkah selanjutnya adalah dengan melihat seblah kiri node yang
sedang aktif. Karena tidak terdapat node disebelah kiri node aktif, maka
cek node disebelah kana node aktif. Karena tidak terdapat node

disebelah kanan node yang sedang aktif maka node yang sedang aktif
dinaikkan 1 dan langusng pindah ke node sebelah kanan. langkah
selanjutnya adalah dengan mengulangi langkah 1 dan langkah 2 hingga
ditemukan titik tujuan. Ilustrasi ini dapat dilihat pada gambar 2.8.

Gambar 2.8 Langkah 3
Langkah terakhir adalah jika titik tujuan sudah ditemukan, maka proses
pencarian titik tujuan dihentikan dan jalur yang dilalui diberikan tanda.
Seperti yang dapat dilihat pada gambar 2.9.

Gambar 2.9 Hasil akhir DFS

Langkah-langkah diatas dapat dibuat diagram alur seperti pada gambar
2.10.

Gambar 2.10 Flowchart Metode Depth First Search
2.2.4. Android
Android merupakan sebuah sistem operasi yang berjalan di
mobile. Android merupakan keturunan dari linux. Linux masih berjalan
pada computer. Android awalnya dikembangkan oleh Android INC.
Android INC merupakan sebuah perusahaan yang membuat sebuah
perangkat lunak untuk ponsel yang berada di Palo Alto, California
Amerika Serikat. Pada tahun 2005 Google membeli/mengakuisisi
perusahaan yang waktu itu bernama Android. Setelah diambil alih oleh

Google, Pada November 2007 Google mengumumkan bahwa mereka
sedang mengembangkan ponsel Google dengan OS(Operating System)
mobile terbaru yang mereka namai Android. OS Android ini sebenarnya
didasarkan pada kernel Linux dan dirancang oleh Open Handset
Alliance yang terdiri dari sekelompok puluhan pembuat hardware,
carrier dan perusahaan terkait perangkat mobile lainnya, diantaranya
Google, HTC, Intel, Motorola, Qualcomm, T-Mobile, Nvidia, dll. Open
Handset Alliance dibentuk untuk mengembangkan Android yang
bersifat open source yang sourcenya di berikan secara gratis bagi para
pengembang (developer) .
Sampai saat ini, Android mengeluarkan hingga beberapa versi
antara lain:
1. Tanpa nama (Android versi 1.01.1)
2. Cupcake (Android versi 1.2 – 1.5)
3. Donut (Android versi 1.6)
4. Eclair (Android versi 2.0 – 2.1)
5. Froyo (Android versi 2.2 – 2.2.3)
6. Gingerbread (Android versi 2.3 - 2.4)
7. Honeycomb(Android versi 3.0 – 3.2)
8. Ice Cream Sandwich (Android versi 4)
9. Jelly Bean (Android versi 4.1-4.3)
10. Kikat (Android versi 4.4)
11. Lollipop (Android versi 5.0)
12. Android Marshmallow (Android versi 6.0)
2.2.5. Metode Pembanding
Metode yang digunakan untuk membandingkan kecepatan pada metode
yang digunakan pada penelitian ini adalah metode Aldous Broder.
Metode Aldous Broder adalah metode untuk membangun maze. Metode
ini berfokus pada pembuatan jalan sedangkan metode Recursive
Division merupakan metode yang berfokus pada pembuatan dinding.
Kedua metode ini memiliki ciri masing-masing dalam membangun
maze sehingga bentuk dan waktu pembuatannya pun juga berbeda.
Metode Aldous Broder mengacak semua kolom dan baris yang ada pada
maze untuk mebetuk jalan keluar pada maze sedangkan metode
Recursive Division tidak mengunjungi maupun mengacak setiap baris
dan kolom yang ada pada maze.

[Halaman ini sengaja dikosongkan]

BAB III
PERANCANGAN SISTEM
3.1. Algoritma Generate Maze
Algoritma generate mazeadalah algoritma yang digunakan
untuk membangun maze. terdapat bebreapa algortima yang dapat
digunakan untuk membangun maze. Algoritma-algoritma yang
dimaksud dapat dilihat pada tabel 3.1.
Tabel 3.1 Daftar Algoritma generate maze

Algoritma

Tipe

Fokus

Tabel 3.1 merupakan hasil penelitian yang dilakukan oleh amstrolog.
Ujicoba dilakukan dengan menjalankan masing-masing metode pada
ukuran maze sebesar 100x100[Kasih referensi]. Pada penelitian ini,
metode yang digunakan adalah metode Recursive Division dimana
metode ini merupakan metode tercepat dari beberapa metode yang
lainnya. Berikut Algoritma Recursive Division.
1. Buat matriks dengan ukuran NxM
2. Buat tembok pada bagian terluar matriks.
3. Buat tembok secara vertikal pada posisi x=N/2 sepanjang M
4. Buat 1 jalan secara acak pada tembok yang sudah selesai
dibuat.
5. Matriks akan terbagi menjadi 2 bagian. Bagian pertama terletak
pada x1=0, x2=N/2, y1=0 dan y2=M. Bagian 2 terletak pada
posisi x1=n/2+1, x2=N, y1=0 dan y2=M.
6. Buat tembok secara horisontal pada posisi x1=0, x2=N/2,
y1=M/2 dan y2=M/2.
7. Buat 1 jalan secara acak pada tembok yang sudah selesai
dibuat.
8. Ulangi langkah 3 sampai dengan langkah 7 hingga semua
bagian matriks berukuran 2x1, 1x2 atau 1x1.

3.2. Flowchart Generating Level
Generating Level merupakan bagian yang penting pada game. Ada
bagian ini akan dijelaskan level yang terbentuk pada game melalui
diagram alur yang dapat dilihat pada gambar 3.1.

Gambar 3.1 Flowchart Generate Level
Pada gambar 3.1 terdapat beberapa proses yag akan dijelaskan antara
lain:

1.

Saat pemain memainka game pada level pertama, level secara
otomatis diatur menjadi level 1.
2. Sistem akan melakukan pengecekan apakah sudah level
maksimum atau pemain dianggap sudah memilih level
selanjutnya . dalam hal ini masih dianggap benar semua.
3. Sistem akan memanggil fungsi GenerateMaze untuk
pembuatan layout pada game.
4. Sistem akan membuat layout pada game berdasarkan hasil dari
fungsi GenerateMaze.
5. Pemain akan memainkan game.
6. Pemain akan ditanya melanjutkan ke permainnan selanjutnya
atau tidak. Jika pemain memilih iya, maka pemain akan
mendapatkan level baru.
7. Langkah diulangi hingga pemain tidak lagi memilih untuk
melanjutkan game atau level sudah maksimum.
3.3. Skenario Game
Pada bagian ini akan dibahas mengenai setiap modul yang dibangun
pada game diantaranya:
3.3.1. Home
Bagian ini adalah bagian dimana pemain dapat memilih menu yang ada
pada game. Gambar 3.2 menunjukan tampilan awal dari game saat
pemain emmainkan game ini.

Gambar 3.2 Halaman awal game
Berikut penjelasan dari gambar 3.2
1.

Tombol START
Tombol ini berfungsi untuk memulai permainan.
2. Tombol Sett
Tombol ini berfungsi untuk menuju halaman pengaturan.
3. Tombol About
Dignakan untuk menuju halaman tentang game.
4. Tombol LVL DWN
Digunakan untuk menurunkan level yang Ingin dimainkan.
5. Tombol LVL UP
Digunakan untuk menambah level yang ingin dimainkan.
3.3.2. Game Play
Game Play adalah bagian inti dari game. Pada bagian ini pemain dapat
mengetahui jalan cerita dari game. Bagian ini dapat dilihat pada gambar
3.3 .

Gambar 3.3 Game Play
Berikut penjelasan dari gambar 3.3
1.

Warna hitam merupakan maze yang terbentuk. Maze ini
merupkan layout daru game. Layout ini berfungsi sebagai jalur
yang harus dilewati oelh aktor pada game.
2. Lingkaran berwarna merah muda merupakan musuh yang harus
dihadapi oleh aktor pada game.
3. Lingkaran berwarna hijau merupakan aktor. Pemain harus
menggerakkan aktor pada game untuk memenangkan
permainan.
3.3.3. Setting
Halaman setting merupakan halaman yang dapat digunakan oleh pemain
untuk mengatur beberapa hal yang ada pada game. Halaman setting ini
dapat dilihat pada gambar 3.4.

Gambar 3.4 Halaman Setting
Terdapat tiga menu yang dapat dgunakan oleh pemain saat menekan
tombol setting yang ada dihalama home antara lain:
1.

2.

3.

Tombol Metode
Tombol ini berfungsi untuk memilih metode yang digunakan
untuk membangun layout pada game.
Tombol Reset
Digunakan untuk mengembalikan nilai level dan nilai skor
pada game.
Tombol Silent
Tombol ini digunakan untuk mematikan atau menyalakan
music pada game.

3.4. MockUp Game
pada bagian ini akan digambarkan rancangan game play mulai dari tata
letak layout hingga tataletak pemain, skor, musuh, dan jumlah peluru
yang dimiliki oleh pemain. Gambar 3.5 merupakan mockup dari game.

Gambar 3.5 Mockup game
Berikut penjelasan daari gambar 3.5.
1.
2.
3.
4.
5.

Gambar 03 pada bagian kiri atas gambar merupakan informasi
peluru yang dimiliki oleh pemain.
Tombol tanda tanya pada bagian atas digunakan untuk mencari
jalan keluar.
Tombol pause pada bagian kanan atas digunakan untuk
menghentikan sementara permainan.
Kotak merupakan aktor dari game yang harus digerakkan oleh
pemain.
Segitiga merupakan musuh yang harus pemain lawan.

6.

Lingkaran berwarna merah merupakan tombol untuk
menembakkan peluru.
7. Panah berwarna merah merupakan tombol yang dapat
digunakan oleh pemain untuk menggerakkan aktor paa game.
Tujuan dari game ini adalah pemain harus menggerakkan aktor pada
game untuk menuju jalan keluar tanpa tertangkap oleh dengan melewati
layout yang berbetuk maze. ukuran maze yang terbentuk juga
mempengaruhi jumlah musuh yang keluar. Perbedaan ukuran maze dan
jumlah msuh ini dapat dilihat pada tabel 3.2.
Table 3.2 Perbedaan pada tiap level
Level Ukuran Maze Jumlah Musuh
1
2x2
2
2
3x3
3
3
4x4
4
4
5x5
5
5
6x6
6
6
7x7
7
7
8x8
8
8
9x9
9
9
10x10
10
10
11x11
11
11
12x12
12
12
13x13
13
13
14x14
14
Tabel 3.2 Perbedaan pada tiap level
Level Ukuran Maze Jumlah Musuh
14
15x15
15
15
16x16
16
16
17x17
17
17
18x18
18
18
19x19
19
19
20x20
20
20
21x21
21

BAB IV
IMPLEMENTASI SISTEM
4.1. Implementasi Bahasa Pemrograman
Implementasi bahasa pemrogram merupakan implemetsi semua
metode terhadap bahasa pemrograman yang digunakan yaitu bahasa
java. Hasil implentasi antara lain:
1. Implementasi metode Reursive Division
Baris program dibawah ini merupakan baris program dari
metode Recursive Division.
public RecursiveDivision(int n) {
maze = new int[(n * 2) + 1][(n * 2) + 1];
for (int i = 0; i < (n * 2) + 1; i++) {
maze[0][i] = maze[(n * 2)][i] = maze[i][(n *
2)] = maze[i][0] = 1;
}
for (int i = 0; i < maze.length; i += 2) {
for (int j = 0; j < maze[0].length; j += 2) {
maze[i][j] = 1;
}
}
Random position = new Random();
recursive(0, 0, n, n, position.nextBoolean());
maze[0][1] = 0;
maze[maze.length - 1][maze.length - 2] = 0;
}
private void recursive(int x1, int y1, int x2, int y2, boolean
hor) {
if (y2 - y1 > 1 && x2 - x1 > 1) {
if (hor) {
for (int i = (x1 * 2) + 1; i < (x2 * 2);
i++) {
maze[((((y2 - y1) / 2) + y1)
* 2)][i] = 1;
}

int rand = Clear.nextInt(x2 - x1);
rand = (rand * 2) + (x1 * 2) + 1;
maze[((((y2 - y1) / 2) + y1) * 2)]
[rand] = 0;
recursive(x1, y1, x2, ((y2 - y1) / 2) +
y1, false);
recursive(x1, (((y2 - y1) / 2) + y1),
x2, y2, false);
} else {
for (int i = (y1 * 2) + 1; i < (y2 * 2);
i++) {
maze[i][((((x2 - x1) / 2) +
x1) * 2)] = 1;
}
int rand = Clear.nextInt(y2 - y1);
rand = (rand * 2) + (y1 * 2) + 1;
maze[rand][((((x2 - x1) / 2) + x1) *
2)] = 0;
recursive(x1, y1, (((x2 - x1) / 2) +
x1), y2, true);
recursive((((x2 - x1) / 2) + x1), y1,
x2, y2, true);
}
}

2.

}
public void setMaze(int x, int y) {
maze[x][y] = 2;
}
Implementasi metode Depth First Search
Baris program dibawah ini merupakan baris program dari
implemntasi metode Depth First Search pada Bahasa java.

private void setVisit() {
visit = new int[maze.getMaze().length]
[maze.getMaze().length];
for (int i = 0; i < visit.length; i++) {
System.arraycopy(maze.getMaze()[i], 0,
visit[i], 0, visit.length);
}
}
public void setNode(int x,int y) {
visit[x][y] = 1;
node.add(new Point(x, y));
while (x < maze.getMaze().length - 1 | y <
maze.getMaze().length - 2) {
Log.d("x,y", x + "," + y);
if (visit[x + 1][y] == 0) {
x += 1;
node.add(new Point(x, y));
visit[x][y] = 1;
} else if (visit[x][y + 1] == 0) {
y += 1;
node.add(new Point(x, y));
visit[x][y] = 1;
} else if (visit[x][y - 1] == 0) {
y -= 1;
node.add(new Point(x, y));
visit[x][y] = 1;
} else if (visit[x - 1][y] == 0) {
x -= 1;
node.add(new Point(x, y));
visit[x][y] = 1;
} else {
node.remove(node.size() - 1);
x = node.get(node.size() - 1).x;
y = node.get(node.size() - 1).y;
}
}

for (int i = 0; i < node.size(); i++) {
maze.setMaze(node.get(i).x, node.get(i).y);
}
}
3. Implementasi metode Aldous Broder
Baris program dibawah ini iplementasi metode Aldous Broder
pada Bahasa pemrograman java.
private void generateMaze() {
setDefault();
x = new Random().nextInt((maze.length - 1) / 2) * 2 + 1;
y = new Random().nextInt((maze.length - 1) / 2) * 2 + 1;
while (temp < ((maze.length - 1) / 2) * ((maze.length - 1) / 2)) {
if (maze[x][y] == 0) {
setMaze(x, y);
temp++;
}
destination = new Random().nextInt(4);
switch (destination) {
case TOP:
if (y - 2 > 0) {
y -= 2;
if (maze[x][y] == 0) {
maze[x][y + 1] = 0;
}
}
break;
case BOT:
if (y + 2 < maze.length - 1) {
y += 2;
if (maze[x][y] == 0)
maze[x][y - 1] = 0;
}
break;
case LEFT:
if (x - 2 > 0) {
x -= 2;
if (maze[x][y] == 0)

maze[x + 1][y] = 0;
}
break;
case RIGHT:
if (x + 2 < maze.length - 1) {
x += 2;
if (maze[x][y] == 0)
maze[x - 1][y] = 0;
}
break;
}
}
Default();
}
public void setMaze(int x, int y) {
maze[x][y] = 2;
}
private void setDefault() {
for (int i = 0; i < maze.length; i++) {
for (int j = 0; j < maze.length; j++) {
if (i == 0 || j == 0 || i == maze.length - 1
|| j == maze.length - 1 || j % 2 == 0 || i % 2 == 0) {
maze[i][j] = 1;
} else {
maze[i][j] = 0;
}
}
}
}
private void Default(){
for (int i = 0; i < maze.length; i++) {
for (int j = 0; j < maze.length; j++) {
if (maze[i][j]==2)
maze[i][j]=0;
}

}
}
4.2. Lingkungan Ujicoba
Lingkungan pengujian aplikasi meliputi perangkat keras dan
perangkat lunak yang digunakan dalam menjalankan game. Pada tabel
4.1 disebutkan spesfikasi perangkat yang telah digunakan untuk
menjalankan game.
Table 4.1 Spesifikasi perangkat
Nama atau spesifikasi
Perangkat keras Komputer
Processor : intel ® core ™ i5
CPU : 2.40 Ghz
RAM : 4.00 GB
Sistem Operasi : Windows 10
Pro
Ponsel
RAM : 1.00 GB
Sistem Operasi : Android 4.2
Adt-bundle-windows-x86_6420140702

Perangkat lunak
rancang bangun
aplikasi
Perangkat lunak -Adobe photoshop cs 3
desain
atribut -Corel draw x5
gambar
4.3. Penjelasan User Interface dan Menu-menu
Pada bagian ini terdapat tampilan yang perlu dipahami oleh
pemain antara lain:
1. Home
Home merupakan halaman awal yang terdapat pada game. Terdapat
beberapa tombol pada halaman home seperti pada gambar 4.1

Gambar 4.1 Halaman Home
1. Tombol Play
Tombol ini berfungsi untuk memainkan game.
2. Tombol Informasi
Tombol ini berfungsi untuk melihat inforasi seputar game.
3. Tombol Setting
Tombol ini berfungsi untuk menuju halaman setting.
4. Tomol Arah
Tombol ini berfungsi untuk menurunkan atau menaikkan level.
2. About
Halaman ini dapat dilihat pada gambar 4.2. halaman ini berfungsi untuk
memberikan informasi kepada pemain tentang game.

Gambar 4.2 Halaman About
3. Setting
Halaman ini berfungsi untuk mengatur beberapa hal yang ada pada
game. Halaman ini dapat dilihat pada gambar 4.3.

Gambar 4.3 Halaman setting

Berikut penjelasan dari ketiga tombol yang ada pada gambar 4.3.
1. Tombol Metode
Tombol ini berfungsi untuk mengubah metode yang digunakan
untuk membut layout pada game.
2. Tombol Reset
Tombol ini berfungsi untuk mengubah nilai skor menjadi 0
disemua level dan mengubah level yang terbua hanya level 1.
3. Tombol Volume
Tombol ini berfungsi untuk mematikan dan menyalakan musik.
4. Tombol Kembali
Tombol ini berfungsi untuk kembali kehalaman home.
4. Loading Screen
Loading screen adalah sebuah halaman yang berfungsi untuk memanggil
gambar yang akan ditampilkan di game. Halaman loading screen dapat
dilihat pada gambar 4.4.

Gambar 4.4 Halaman Loading
5. Info Game Play
Halaman ini hanya berfungsi sebagai informasi tentang level yang
sedang dimainkan, skor tertinggi yang sudah pernah didapat pada level
yang sedang dimainkan,ukuran maze, serta jumlah musuh yang ada pada

level yang sedang dimainkan. Halaman ini dapat dilihat pada gambar
4.5.

Gambar 4.5 Halaman informasi game
6. Game Play
Bagian ini merupakan bagian terpenting dari game. Halaman game play
dapat dilihat pada gambar 4.6.

Gambar 4.6 Halaman Game Play
Berikut penjelasan dari gambar 4.6.
1. Tombol Arah
Tombol ini berfungsi untuk menggerakkan aktor pada game.
2. Tombol Tembak
Tombol ini berfungsi untuk mengeluarkan peluru.
3. Tombol Pause
Untuk menhentikan sementara permainan.
4. Tombol Bantuan
Menunjukkan jalan keluar pada layout.
7. Help Screen
Help screen merupakan sebuah halaman yang dapat menunjukkan jalan
keluar pada layout dari posisi aktor. Halaman ini dapat dilihat pada
gambar 4.7.

Gambar 4.7 Halaman bantun
Bantuan disini diwakili oleh kotak berwarna kuning tua yang terbentuk
dari posisi aktor hingga jalan keluar.
8. Pause Screen
Pause screen meruakan sebuah halaman yang berfungsi untuk
menhentikan permainan sementara. Halaman ini dapat dilihat pada
gambar 4.8.

Gambar 4.8 Halaman Pause
Terdapat beberapa tombol yang dapat digunakan pada halaman pause
ini, antaranya:
1. Tombol Main menu
Tombol ini berfungsi untuk kembali kehalaman home.
2. Tombol Restart
Tombol ini berfungsi untuk membuat layout baru pada level
yang sedang dimainkan.
3. Tombol Lanjut
Tombol ini berfungsi untuk melanjutkan permainan yang sepat
dihentikan tanpa membuat layout baru pada game.
9. Win Screen
Merupakan sebuah halaman yang berfungsi untuk menunjukkan hasil
skor yang didapatkan oleh pemain. Halaman ini dapat dilihat pada
gambar 4.9.

Gambar 4.9 Halaman menang
Terdapat beberapa tombol yang dapat digunakan oleh pemain antara
lain:
1. Tombol Main Menu
Tombol ini berfungsi untuk kembali kehalaman home.
2. Tombol Restart
Tombol ini berfungsi untuk meminkan kembali level yang
sama dengan layout yang berbeda.
3. Tombol Lanjut
Tombol in berfungsi untuk melanjutkan permainan dengan
level yang baru dan layout yang baru pula.
10. Lose Screen
Merupakan sebuah halaman yang berfungsi sebagai informasi bahwa
game telah gagal diselesaikan. Halaman ini dapat dilihat pada gambar
4.10.

Gambar 4.10 Halaman kalah
Pada gambar 4.10, terdapat 2 tombol yang dapat digunakan
oleh pemain antara lain:
1. Tombol Main Menu
Tombol ini berfungsi untuk kembali kehalaman awal game.
2. Tombol Restart
Tombol ini berfungsi untuk mengulang game tanpa merubah
layout yang sudah dimainkan oleh pemain.
4.4. Pengujian
Ujicoba dilakukan untuk melihat kecepatan yang dimiliki oleh
metode Recursive Division dan metode Aldous Broder. Selain untuk
melihat kecepatan, ujicoba dilakukan untuk melihat layout yang
dihasilkan oleh masing-masing metode.
4.4.1. Ujicoba pada Emulator WVGA 1024 MB
Ujicoba yang dilakukan adalah dengan menggunakan emulator
Android. Ujicoba dilakukan dengan cara menjalankan game pada
emulator dengan menggunakan kedua metode kemudian waktu untuk
membuat layout pada game dihitung berdasarkan satuan detik. Gambar
4.11 menunjukkan saat game dijalankan pada emulator sedangkan tabel
4.2 dan tabel 4.3 menunjukkan hasil yang diperoleh dari mengukur
kecepatan pada masing-masing metode.

Gambar 4.11 Ujicoba pada emulator
Gambar 4.11 merupakan gambar dari emulator yang sedang
menjalankan game. Terlihat game dapat berjalan dengan baik pada level
7. Selanjutnya adalah waktu yang dibutuhkan oleh masing-masing
metode untuk membangun layout pada game. Hasil ini ditunjukkan oleh
tabel 4.2 dan tabel 4.3

Tabel 4.2 Ujicoba metode Recursive Division

Recursive Division Emulator
Tabel 4.2 menunjukan hasil dari ujicoba yang dilakukan
dengan menjalankan game sebanyak 5 kali kemudian diambil rata-rata
keepatan yang diperoleh dari 5 percobaan pada masing-masing level.
Terlihat kecepatan pada level 15 merupakan kecepatan terlambat yaitu
selama 0.0082 detik seddangkan waktu tercepat adalah pada level 2
yaitu dengan waktu selama 0.00003 detik. Percobaan yang kedua adalah
dengan mnegganti metode yaitu metode Aldous Broder. Hasil dapat
dilihat pada tabel 4.3.

Tabel 4.3 Ujicoba Metode Aldous Broder

Recursive Division Emulator
Pada percobaan ini, metode yang digunakan adalah metode
Aldous Broder. Kecepatan terbaik adalah pada saat level 1 yaitu dengan
waktu 0.02 detik sedangkan waktu terlama yang dibuthkan oleh metode
ini adalah pada saat level 18 yaitu selama 4.5 detik.
Dari hasil ujicoba pada emulator ini, terlihat bahwa metode
Recursive Division memiliki kecepatan yang lebih baik dari pada
metode Aldous Broder
.

4.4.2. Ujicoba pada ponsel IRO 1024MB
Percobaan kali ini dilakukan pada ponsel IRO. Ujicoba
dilakukan dengan menjalankan kedua metode secara bergantian.
Masing-masing metode djalankan 5 kali pada masing-masing level.
Gambar hil percobaan dapat dilihat pada gambar 4.12.

Gambar 4.12 Ujicoba pada ponsel
Gambar 4.12 merupakan gambar ujicoba pada ponsel IRO pada
level 7 dengan ukuran maze sebesar 8x8. Hasil percobaan dapaat dilihat
pada tabel 4.4 dan tabel 4.5.

Tabel 4.4 Ujicoba Metode Recursive Division

Recursive Division Emulator
Tabel 4.4 merupakan hasil percobaan yang dilakukan pada
metode Recursive Division. Hasil menunjukan bahwa kecepatan terbaik
saat dijalankan pada ponsel adalah pada saat level 1 yaitu selama
0.000013 detik. Kecepatan ini lebih cepat dibandingkan saat dijalankan
pada emulator. Ujicoba yang kedua dilakukan pada metode Aldous
Broder. Hasil ujicoba dapat dilihat pada tabel 4.5.

Tabel 4.5 Ujicoba pada metode Aldous Broder

Recursive Division Emulator
Hasil percobaan pada tabel 4.5 menunjukkan kecpatan metode
Aldous Broder pada ponsel lebih lambat dibandingkan metode
Recursive Division. Hal ini dapat dilihat pada kecepatan terbaik yang
dimiliki oleh metode Aldous Brode adalah selama 0.0016 pada level 1.
4.4.3. Ujicoba Layout
Ujicoba dilakukan dengan menjalankan semua metode pada
semua level. Hasil ujicoba dapat dilihat pada gambar 4.13 sampai
gambar 4.52 yang terdapat pada tabel 4.6.

Level
1

Tabel 4.6 Ujicoba Layout
Recursve Division
Aldous Broder

Gambar 4.13 Recursive
Level 1

Gambar 4.14 Aldous Broder
level 1

Gambar 4.15 Recursive
Division level 2

Gambar 4.16 Aldous Broder
level 2

2

3

Gambar 4.17 Recursive
Division level 3

Gambar 4.18 Aldous Broder
level 3

Gambar 4.19 Recursive
Division level 4

Gambar 4.20 Aldous Broder
level 4

4

5

Gambar 4.21 Recursive
Division level 5

Gambar 4.22 Aldous Broder
level 5

Gambar 4.23 Recursive
Division level 6

Gambar 4.24 Aldous Broder
level 6

6

7

Gambar 4.25 Recursive
Division level 7

Gambar 4.26 Aldous Broder
level 7

Gambar 4.27 Recursive
Division level 8

Gambar 4.28 Aldous Broder
level 8

8

9

Gambar 4.29 Recursive
Division level 9

Gambar 4.30 Aldous Broder
level 9

Gambar 4.31 Recursive
Division level 10

Gambar 4.32 Aldous Broder
level 10

10

11

Gambar 4.33 Recursive
Division level 11

Gambar 4.34 Aldous Broder
level 11

Gambar 4.35 Recursive
Division level 12

Gambar 4.36 Aldous Broder
level 12

12

13

Gambar 4.37 Recursive
Division level 13

Gambar 4.38 Aldous Broder
level 13

Gambar 4.39 Recursive
Division level 14

Gambar 4.40 Aldous Broder
level 14

14

15

Gambar 4.41 Recursive
Division level 15

Gambar 4.42 Aldous Broder
level 15

Gambar 4.43 Recursive
Division level 16

Gambar 4.44 Aldous Broder
level 16

16

17

Gambar 4.45 Recursive
Division level 17

Gambar 4.46 Aldous Broder
level 17

Gambar 4.47 Recursive
Division level 18

Gambar 4.48 Aldous Broder
level 18

18

19

Gambar 4.47 Recursive
Division level 19

Gambar 4.50 Aldous Broder
level 19

Gambar 4. 49 Division
level 20

Gambar 4.52 Aldous Broder
level 20

20

Pada tabel 4.6 terlihat hasil layout pada semua level. Layout
yang dihasilkan menunjukan perbedaan yang sangat jelas antara kedua
metode. Metode Recursive Division tidak memiliki pola akan tetapi
memiliki kelemahana yaitu pada tengah-tengah layout hanya terdapat 1
jalan keluar hal ini diakibatkan karena proses pembuatan layout Selalu
dibagi dua dan hal ini menjadi kelemahan pada metode ini. Metode

Aldous Broder memiliki kelemahan juga pada tampilan layoutnya yaitu
jalan keluar seperti berbentuk huruf L sehingga pemain akan sanagat
mudah menebak jalan keluar pada layout.

[Halaman ini sengaja diskosongkan]

BAB V
PENUTUP
5.1. Kesimpulan
Dari hasil penelitian yang telah dilakukan, dapat ditarik
kesimpulan sebaga berikut:
1. Salah satu cara untuk membuat sebuah game yang dinamis
adalah dengan cara menerapkan metode Recursive Division
pada pembuatan layout pada game dan metode Depth First
Search untuk mencari jalan keluar pada layout.
2. Metode Recursive Division memiliki kecepatan lebih stabil
pada ponsel dengan kecepatan trebaik pada level 1 yaitu selama
0.000013 detik.
3. Metode Recursive Division lebih cepat dibandingkan dengan
metode Aldous Broder dengan perbedaan kecepatan selama
0.0015 detik pada kecepatan terbaik kedua metode dan 0.88
pada kecepatan terlamban kedua metode
4. Layaout yang dihasilkan oleh metode Recursive Division
memiliki kelemahan yaitu hanya tredapat 1 jalan pada tengahtngah layout, hal ini dapat membuat pemain dengan mudah
menemukan jalan keluar pada alayout.
5. Metode Aldous Broder layout yang dihasilkan beragam, akan
tetapi karena proses pembuatanya secara acak, jalan keluar
yang dihasilkan dapat berupa huruf L saja sehingga pemain
tidak perlu berfikir untuk mencari jalan keluar pada layout.
5.2. Saran
Pada penelitian ini, gambar yang digunakan terlalu kaku
sehingga game ini tidak terlalu menarik perhatian. Untuk penelitian
lebih lanjut, disarankan menggunakan gambar yang lebih bagus untuk
membuat game lebih menarik.

DAFTAR PUSTKA
[1] M. K. Anwar, "Implementasi Algoritma Prim Dan Depth First
Search Pada Pembuatan Maze Game Berbasis Android OS Mobile,"
2012.
[2] N. Maulida, "Rancang Bangun Game Maze Sebagai Game Edukasi
Bahasa Inggris Pada Anak.," 2015.
[3] W. D. Pullen, "Maze Classification," 20 November 2015. [Online].
Available:
http://www.astrolog.org/labyrnth/algrithm.htm.
[Accessed 30 Nopember 2015].
[4] H. Kern, in Through the labyrinth: designs and meanings over 5000
years, Prestel, 2000, p. 23.

1.

LAMPIRAN
Program pemilihan algortiam pada game
public class MazeGenerator {
private
private
private
private
private

final int RECURSIVE = 0;
final int BRODER = 1;
final int RANDOM = 2;
long start, end;
int maze[][];

public MazeGenerator(int level, int
metode) {
start = System.nanoTime();
ChooseMethod(level, metode);
end = System.nanoTime();
Log.d("Waktu Generate : ", ""
+ (float) ((float) (end
- start) / (float) 1000000000)
+ " Detik");
}
private void ChooseMethod(int level, int
metode) {
switch (metode) {
case RECURSIVE:
maze = new
RecursiveDivision(level).getMaze();
break;
case BRODER:
maze = new
AldousBroder(level).getMaze();
break;
case RANDOM:
int random = new
Random().nextInt(2);
ChooseMethod(level, random);
break;
}

}
public void setMaze(int x, int y) {
maze[x][y] = 2;
}

}
2.

public int[][] getMaze() {
return maze;
}
Program peletakan dan pergerakan musuh

public class Enemie extends GameObject {
MazeGenerator maze;
int direction, xM, yM, rotation;
float timer;
public final float width, height;
public Enemie(float x, float y, float w,
float h, MazeGenerator maze,
int xM, int yM) {
// TODO Auto-generated constructor
stub
super(x, y, w, h);
this.maze = maze;
this.xM = xM;
this.yM = yM;
this.width = w;
this.height = h;
direction = 0;
timer = 1;
getDirection();
}
public void getDirection() {
if (maze.getMaze()[xM][yM - 1] !=1 &
yM - 1 >= 0) {

direction = 1;
} else if (maze.getMaze()[xM][yM +
1] !=1

& yM + 1 <
maze.getMaze().length - 1) {
direction = 3;
} else if (maze.getMaze()[xM + 1]
[yM] !=1) {
direction = 2;
} else if (maze.getMaze()[xM - 1]
[yM] !=1) {
direction = 4;
}
}
public void Moved() {
switch (direction) {
case 1:
if (rotation == 0) {
if (maze.getMaze()
[xM][yM - 1] != 1 & yM - 1 >= 0) {
super.position.y += (320 / (float)
maze.getMaze().length);
yM--;
} else {
direction =
3;
}
} else {
rotation = 0;
}
break;
case 2:
if (rotation == -90) {
if (xM + 1 <
maze.getMaze().length - 1

maze.getMaze()[xM + 1][yM] != 1) {

&

super.position.x += (320 / (float)
maze.getMaze().length);
xM++;
} else {
direction =
4;
}
} else {
rotation = -90;
}
break;
case 3:
if (rotation == -180) {
if (maze.getMaze()
[xM][yM + 1] != 1 & yM + 1 <
maze.getMaze().length - 1) {
super.position.y -= (320 / (float)
maze.getMaze().length);
yM++;
} else {
direction =
1;
}
} else {
rotation = -180;
}
break;
case 4:
if (rotation == 90) {
if (maze.getMaze()
[xM - 1][yM] != 1) {
super.position.x -= (320 / (float)
maze.getMaze().length);

xM--;
} else {
direction =

2;

}

}
break;
} else{
rotation = 90;
}

}
public void update(float deltaTime) {
timer += deltaTime;
if (timer >= 1) {
Moved();
bounds.lowerLeft.set(position).sub(bounds.wid
th / 2-(width/2), bounds.height /
2-(height/2));
timer = 0;
}
}
}
3.

Program pergerakan peluru

public class Peluru extends GameObject {
public final float width, height;
public int rotation;
public Peluru(float x, float y, float w,
float h, int rotation) {
// TODO Auto-generated constructor
stub
super(x, y, w, h);
this.width = w;

this.height = h;
this.rotation = rotation;
}
public void update() {
switch (rotation) {
case 0:
super.position.y++;
break;
case 90:
super.position.x--;
break;
case -180:
super.position.y--;
break;
case -90:
super.position.x++;
break;
}
bounds.lowerLeft.set(position).sub(bounds.wid
th / 2-(width/2), bounds.height /
2-(height/2));
}
}