pembuatan game balap kucing dengan unity …library.stmikgici.ac.id/skripsi/161300024.pdfvii abstrak...
Post on 28-Dec-2019
56 Views
Preview:
TRANSCRIPT
PEMBUATAN GAME BALAP KUCING DENGAN UNITY BERBASIS ANDROID
SKRIPSI
Diajukan Untuk Memenuhi Salah Satu Syarat Memperoleh Gelar Sarjana
Oleh:
Yandaka Ganesha Putra
161300024
PROGRAM STUDI SISTEM INFORMASI SEKOLAH TINGGI MANAJEMEN INFORMATIKA DAN
KOMPUTER (STMIK) GICI 2017
vii
ABSTRAK
Pembuatan game bertema balap lari kucing yang dilakukan dengan game engine
Unity didukung aplikasi Blender3D. Game ini dibuat untuk platform Android. Dalam
skripsi ini, dijelaskan langkah-langkah pembuatan game tersebut dan penjabaran
script-script yang digunakan di dalam game. Game yang dibuat memiliki fitur save
dan load untuk menyimpan dan membaca data permainan pemain. Skripsi ini juga
mengandung cara memindahkan data dari satu scene ke scene lain dalam Unity
sehingga memungkinkan untuk membangun game dengan banyak scene tanpa
kehilangan data ketika game dijalankan dan game harus berpindah dari satu scene ke
scene lain. Hal ini dapat mengurangi resiko munculnya bug.
Kata kunci: Game, Unity, Android, Blender
viii
ABSTRACT
Cat foot race game creation using Unity game engine supported by Blender3D. This
game was made for the Android Platform. This book will explain the steps to make
the game and describe the scripts used in the game. This game will have the save and
load feature to store and read player’s game progress. This book also includes the
way to transfer data between scenes in Unity, enabling game creation using multiple
scenes without losing data when the game is run and it has to move from one scene to
another. This will reduce the risk of bug.
Keywords: Game, Unity, Android, Blender
ix
DAFTAR ISI
Judul Halaman
HALAMAN JUDUL .........................................................................................ii
HALAMAN PERSETUJUAN .........................................................................iii
HALAMAN PENGESAHAN ...........................................................................iv
HALAMAN PERNYATAAN ...........................................................................v
KATA PENGANTAR .......................................................................................vi
ABSTRAK .........................................................................................................vii
ABSTRACT .......................................................................................................viii
DAFTAR ISI ......................................................................................................ix
BAB I PENDAHULUAN ..................................................................................1
1.1 Latar Belakang ................................................................................1
1.2 Rumusan Masalah ...........................................................................3
1.3 Batasan Masalah .............................................................................3
1.4 Tujuan Penelitian ............................................................................3
1.5 Manfaat Penelitian ..........................................................................4
1.6 Sistematika Penulisan .....................................................................4
BAB II LANDASAN TEORI ...........................................................................7
2.1 Teori Pendukung .............................................................................7
2.1.1 Pengertian Game ...................................................................7
2.1.1.1 First Person Shooter (FPS)....................................8
2.1.1.2 Role Playing Game (RPG) .....................................8
2.1.1.3 Arcade ....................................................................9
2.1.1.4 Simulation ..............................................................9
2.1.1.5 Racing ....................................................................10
2.1.2 Pengertian Android ...............................................................10
x
2.1.3 Pengertian Blender ................................................................12
2.1.4 Benda 3 Dimensi ...................................................................13
2.1.5 Pengertian Unity ...................................................................14
2.1.5.1 Scene ......................................................................15
2.1.5.2 GameObjects ..........................................................15
2.1.5.3 Components ............................................................16
2.1.6 C# ..........................................................................................16
2.2 Penelitian Sebelumnya ....................................................................17
2.2.1 Pembuatan Game Balap Karung di SmartPhone Android ....17
2.2.2 Pengembangan Game Edukasi Lingkungan Berbasis
Android .................................................................................17
2.2.3 Pembuatan Game Edukasi Pintar Memilih Sampah Berbasis
Android .................................................................................17
BAB III METODOLOGI PENELITIAN .......................................................18
3.1 Kerangka Kerja ...............................................................................18
BAB IV ANALISIS DAN IMPLEMENTASI .................................................21
4.1 Analisis Sistem................................................................................21
4.1.1 Garis Besar Game yang akan Dibuat ....................................21
4.1.2 Karakter ................................................................................21
4.1.3 Arena Balap ..........................................................................23
4.1.4 Grafis ....................................................................................25
4.1.5 Cara Bermain ........................................................................27
4.1.6 Status .....................................................................................29
4.1.7 Cerita Latar Belakang ...........................................................30
4.1.8 Penjelasan Scene ...................................................................31
4.1.9 Script .....................................................................................33
4.2 Implementasi ...................................................................................46
BAB V KESIMPULAN DAN SARAN ............................................................51
5.1 Kesimpulan .....................................................................................51
5.2 Saran…………. ..............................................................................51
xi
DAFTAR PUSTAKA ........................................................................................52
LAMPIRAN
1
BAB I
PENDAHULUAN
1.1 Latar Belakang
Pada tahun 2017, bahkan anak-anak pun sudah terbiasa menggunakan
perangkat telepon pintar atau smartphone. Sebagian besar dari smartphone
tersebut dijalankan dengan sistem operasi Android atau IOS. Dalam smartphone
terdapat aplikasi-aplikasi yang dapat digunakan untuk berbagai keperluan. Salah
satu jenis dari aplikasi-aplikasi tersebut adalah game.
Selain sebagai perangkat untuk membantu pekerjaan, smartphone juga
dapat digunakan sebagai perangkat hiburan dengan adanya game. Game-game ini
sama halnya dengan aplikasi-aplikasi jenis lain, dapat dengan mudah didownload
dari Google Play.
Selain sebagai wahana permainan dan hiburan, game juga dapat dijadikan
peluang bisnis dan iklan. Penulis tertarik untuk membuat sebuah game khusus
smartphone dengan sistem operasi android karena adanya peluang tersebut.
Namun untuk membuat game tidaklah mudah. Walaupun dengan adanya
program game engine gratis seperti Unity, ada tantangan-tanganan yang akan
dialami oleh seorang pembuat game atau game developer. Jika pembuat tersebut
tidak mampu melewati tantangan-tantangan ini, maka game tidak akan selesai.
Salah satu dari tantangan tersebut adalah penyimpanan informasi pemain.
Sebagian besar game tidak dapat diselesaikan dalam waktu singkat. Pemain juga
memiliki kesibukan masing-masing yang berarti waktu mereka untuk bermain
terbatas. Ketika pemain berhenti bermain, tentunya ketika pemain tersebut hendak
2
bermain lagi, pemain ingin melanjutkan permainan dari titik di mana dia terakhir
berhenti bermain, bukan dari awal. Maka dibutuhkan sistem simpan dan baca atau
save and load.
Save menuliskan data-data terakhir pemain ke dalam sebuah file, sementara
Load berfungsi untuk membaca dan memproses data-data tersebut ke dalam
game.
Masih berbicara tentang data dalam sebuah game, Unity menyediakan fitur
scene di mana game developer dapat memecah dan menyusun game nya ke dalam
scene-scene kecil yang kemudian dapat dihubungkan. Masalahnya setiap kali
scene baru dibuka, semua data yang terkandung dalam scene sebelumnya akan
hilang sehingga menyebabkan kesulitan jika data yang hilang tersebut dibutuhkan
di scene berikutnya. Bisa saja game dibuat hanya menggunakan satu scene,
namun hal tersbut sangat bersiko karena dapat memunculkan bug atau kesalahan
sistem juga beresiko kehilangan hasil kerja jika scene tersebut rusak atau corrupt
karena berbagai alasan. Maka pembuat game harus mengetahui cara untuk
memindahkan data dari satu scene ke scene lain yang efektif.
Masalah lain yang akan muncul adalah cara mengintegrasikan script satu
dengan script yang lain sehingga script-script tersebut dapat saling terhubung dan
bekerja sama untuk menjalankan game. Ini berarti script-script yang dibuat harus
dapat membentuk sebuah sistem yang berjalan dengan baik.
Selain itu, game engine seperti Unity tidak memiliki fitur untuk membuat
model 3D kompleks secara default. Model tersebut harus dibuat dari program lain
seperti Blender yang adalah program khusus untuk mengolah data 3D.
3
1.2 Rumusan Masalah
1. Apakah bisa model 3D yang dibuat dengan Blender dimasukkan ke dalam
Unity untuk membuat game?
2. Bagaimana cara menghubungkan fungsi dari satu script ke script lain dalam
Unity sehingga membentuk sebuah sistem yang dapat menajalankan sebuah
game?
3. Bagaimana cara menulis, menyimpan, membaca, dan menghubungkan data
atau informasi pemain dari satu scene ke scene lain sehingga dapat dibaca dan
diproses di dalam permainan?
1.3 Batasan Masalah
1. Game yang dibuat adalah game offline yang tidak membutuhkan koneksi
internet untuk dimainkan.
2. Penelitian hanya membahas cara membuat game dan tidak membahas cara
menjual game ke pasaran.
3. Penelitian tidak membahas cara memasukkan iklan ke dalam game.
1.4 Tujuan Penelitian
1. Mengetahui cara membuat dan memasukkan model 3D dari Blender ke Unity.
2. Mengetahui cara membuat script-script yang dapat membentuk sebuah sistem
game yang baik dalam Unity.
3. Mengetahui cara menulis, membaca, memindahkan, dan mengolah data-data
dalam game yang dibuat.
1.5 Manfaat Penelitian
4
1. Penulis dan pembaca mengetahui cara membuat dan memasukkan model 3D
dari Blender ke Unity.
2. Penulis dan pembaca mengetahui script-script seperti apa yang dapat
membentuk sistem game yang baik dengan Unity.
3. Penulis dan pembaca mengetahui cara menulis, membaca, dan mengola data-
data dalam game yang dibuat.
1.6 Sitematika penulisan
BAB I Pendahuluan
1.1 Latar Belakang
1.2 Rumusan Masalah
1.3 Batasan Masalah
1.4 Tujuan Penelitian
1.5 Manfaat Penelitian
BAB II Landasan Teori
2.1 Teori Pendukung
2.1.1 Pengertian Game
2.1.1.1 First Person Shooter (FPS)
2.1.1.2 Role Playing Game (RPG)
2.1.1.3 Arcade
2.1.1.4 Simulation
5
2.1.1.5 Racing
2.1.2 Pengertian Android
2.1.3 Pengertian Blender
2.1.4 Benda 3 Dimensi
2.1.5 Pengerti Unity
2.1.5.1 Scene
2.1.5.2 GameObjects
2.1.5.3 Components
2.1.6 C#
2.2 Penelitian Sebelumnya
2.2.1 Pembuatan Game Balap Karung di SmartPhone Android
2.2.2 Pembuatan Game Edukasi Lingkungan Berbasis Android
2.2.3 Pembuatan Game Edukasi Pintar Memilih Sampah Berbasis Android
BAB III Metodologi Penelitian
3.1 Kerangka Kerja
BAB IV Analisis dan Implementasi
4.1 Analisis Sistem
4.1.1 Garis Besar Game yang akan Dibuat
6
4.1.2 Karakter
4.1.3 Arena Balap
4.1.4 Grafis
4.1.5 Cara Bermain
4.1.6 Status
4.1.7 Cerita Latar Belakang
4.1.8 Penjelasan Scene
4.1.9 Script
4.2 Implementasi
BAB V Kesimpulan dan Saran
5.1 Kesimpulan
5.2 Saran
7
BAB II
LANDASAN TEORI
2.1 Teori Pendukung
2.1.1 Pengertian Game
Game berasal dari bahasa Inggris. Dalam kamus bahasa Indonesia istilah
Game berarti permainan. Menurut Zamroni, Suryawan, dan Jalaluddin (2013: 489),
permainan sebuah sistem dimana pemain terlibat dalam konflik buatan. Pemain
berinteraksi dengan sistem dan konflik dalam permainan. Dalam permainan terdapat
peraturan yang bertujuan untuk membatasi perilaku pemain dan menentukan
permainan.
Menurut Singkoh, dkk (2016) game yang pertama di dunia diciptakan pada
tahun 1963 oleh Steve Russel seorang ahli computer yang berasal dari Amerika.
Game tersebut adalah Spacewar yang kemudian dikembangkan oleh sebuah tim
Martin Graetz, Pete Simson, dan Dan Edwards. Mereka juga mengubah persepsi
masyarakat pada waktu itu yang menganggap komputer hanya untuk kerja yang
serius.
Masih menurut Singkoh, dkk (2016) konsol game yang pertama di dunia
dibuat oleh Ralph H. Baer, lahir 8 Maret 1922. Seorang Jerman yang tinggal di
Amerika sejak kecil. Ralph menciptakan sebuah permainan di televise yang saat itu
sedang ia kerjakan sekitar tahun 1966, di perusahaan bernama Sanders. Penemuan ini
dikembangkan hingga menjadi prototype konsol game pertama yang dinamakan
Brown Box dan dipatenkan pada tahun 1986. Ralph juga menemukan control pistol
8
untuk video games yang bisa dimainkan di televisi, juga merupakan yang pertama di
dunia.
Menurut Wafda (2015) jika dilihat dari graifs yang digunakan, game dapat
digolongkan menjadi dua jenis, yaitu 2D dan 3D. Sementara jika dilihat dari cara
memainkannya game memiliki beberapa genre di antaranya: First Person Shooter,
Role Playing Game, Arcade, Simulation, Racing, dan sebagainya.
2.1.1.1 First Person Shooter (FPS)
Sesuai nama genrenya yang mengandung kata ‘first person’ yang berarti
‘orang pertama’ dan ‘shooter’ yang berarti ‘penembak’, game FPS berfokus pada
aksi tembak-menembak dengan beragam senapan yang dimainkan dari pandangan
orang pertama atau langsung dari penglihatan mata si karakter yang dimainkan. Jadi
game jenis ini melatih keahlian pemain untuk membidik musuh. Genre FPS adalah
salah satu genre yang sangat terkenal dan sangat sering dipakai di game-game jaman
sekarang. Contoh game FPS yang terkenal adalah seri Battlefield, seri Half-life, seri
Left 4 Dead, dan seri Call of Duty.
2.1.1.2 Role Playing Game (RPG)
RPG adalah genre game yang menempatkan pemain untuk berperan sebagai
salah satu karakter di dalam game tersebut. Karakter yang dimaksud dapat berupa
karakter yang telah disediakan oleh game atau dibuat sendiri oleh pemain jika game
yang dimainkan memiliki fitur tersebut. Kata Role Playing sendiri sebenarnya berarti
memerankan sebuah peran dan hampir semua game menempatkan pemain ke dalam
9
peran sebuah karakter. Namun RPG sering dimaksudkan sebagai sebuah game
dengan cerita, memiliki sistem level di mana pemain dapat meningkatkan levelnya
untuk menjadi semakin kuat, memiliki sistem status di mana pemain dapat
mengalokasikan poin-poin yang didapat ketika berhasil menaikkan levelnya untuk
meningkatnya misalnya kekuatan fisik, pertahanan, kecepatan, dan sebagainya,
memiliki sistem skill atau kemampuan-kemampuan khusus yang dapat digunakan
pemain dalam menghadapi musuh, memiliki sistem equipment untuk mengganti
perlengkapan yang dipakai pemain, dan seringkali memperbolehkan pemain untuk
bergerak bebas di dunia game tersebut. Contoh RPG yang terkenal adalah seri
Neptunia, seri Final Fantasy, seri Dragon Age, seri Elder Scrolls, dan seri Fallout.
2.1.1.3 Arcade
Jenis game arcade adalah game singkat yang dimainkan untuk kesenangan
dan menghabiskan waktu. Tidak seperti dua genre di atas, game arcade biasanya
tidak memiliki cerita dan sistem yang mendalam namun game arcade memiliki cara
main yang lebih bervariasi tergantung gamenya. Contoh game arcade yang terkenal
adalah tetris, pac-man, alien invasion, dan snake.
2.1.1.4 Simulation
Sesuai namanya, ‘simulation’ berarti ‘simulasi. Game simulation adalah game
yang mengsimulasikan sesuatu sedekat mungkin dengan dunia nyata, walaupun
beberapa di antaranya sengaja mengsimulasikannya dengan salah untuk tujuan
kesenangan. Simulasi yang dimaksud beragam, bisa berupa simulasi kehidupan,
10
simulasi bertani, simulasi mengemudi, simulasi roket luar angkasa, dan sebagainya.
Contoh game simulation yang terknal adalah seri The Sims, Kerbal Space Program,
dan Truck Simulator.
2.1.1.5 Racing
Racing berarti balap. Jadi, game racing adalah game yang menantan pemain
untuk beradu kecepatan dan kegesitan dengan komputer atau pemain lain
menggunakan beragam kendaraan seperti mobil, motor, dan sebagainya tergantung
game racing apa yang dimainkan. Contoh game racing yang terkenal adalah seri
Need For Speed dan seri Test Drive.
2.1.2 Pengertian Android
Android merupakan generasi baru platform mobile berbasis Linux yang
mencakup sistem operasi, middleware, dan aplikasi (Nazruddin Safaat, 2012).
Menurut Damarullah, dkk (2013), Android awalnya dikembangkan oleh Android Inc.
dengan dukungan finansial dari Google yang kemudian membelinya pada tahun
2005. Sistem operasi ini dirilis secara resmi pada tahun 2007, bersamaan dengan
didirikannya Open Handset Alliance, konsorsium dari perusahaan-perusahaan
perangkat keras, perangkat lunak, dan telekomunikasi yang bertujuan untuk
memajukan standar terbuka perangkat seluler.
Menurut Wafda (2015) Android memiliki beberapa versi yaitu:
a. Gingerbread (2.3)
11
Perubahan utama di versi ini termasuk update UI, peningkatan fitur
soft keyboard & copy/ paste, power management, dan Near Field
Communication.
b. Honeycomb (3.0-3.2)
Android Honeycomb dikhususkan untuk perangkat tablet. Fitur yang
disediakan memang disesuaikan dengan kebutuhan pada perangkat layar
lebar. Salah satu perubahan yang cukup besar adalah pada tampilan yang lebih
professional.
c. Ice Cream Sandwich (3.2-4.0)
Android Ice Cream Sandwitch atau biasa disingkat dengan ICS adalah
android pertama yang memiliki fitur membuka kunci dengan pengenalan
wajah. Perkembangan versi ini sangat terasa pada tampilan interface bersih
dan smooth.
d. Jelly Bean (4.1-4.3)
Keunggulan Android Jelly Bean dibanding seri terdahulu antara lain:
Sistem Keamanan (Sekuritas), Dual Boot, File Manager, Keyboard Virtual.
Sistem operasi Android Jelly Bean ini akan lebih ringan disertai kinerja dalam
mengakses aplikasi pada smartphone / komputer lebih cepat, terdapat aplikasi
khusus penghemat daya baterai yang langsung bult-in tanpa harus melakukan
download di Android market, dan kelebihan lainnya android versi di atas 4.1
12
juga sangat dimungkinkan untuk menjalankan perangkat lunak yang
dikembangkan.
2.1.3 Pengertian Blender
“Blender is the free and open source 3D creation suite. It supports the entirety
of the 3D pipeline – Modeling, rigging, animation, simulation, rendering,
compositing and motion tracking, even video editing and game creation….”
(www.blender.org/about/).
Dari kutipan di atas yang diambil langsung dari laman resmi Blender,
dikatakan bahwa Blender adalah aplikasi kreasi 3D yang gratis dan bersifat open
source. Blender mendukung semua aktifitas penting 3D – modeling, rigging, animasi,
simulasi, rendering, compositing, dan motion tracking, bahkan video editing dan
pembuatan game.
Modeling adalah pembuatan model 3D. Model tersebut kemudian menjalani
proses rigging di mana ‘tulang-tulang’ ditanamkan ke dalamnya agar model tersebut
dapat digerakkan. Animasi adalah proses penggerakan model tersebut di mana data
animasi tersebut kemudian disimpan untuk digunakan nantinya. Simulasi yang
dimaksud di sini adalah pencitraan virtual dari suatu kejadian seperti pergerakan kain
yang terjatuh ke atas sebuah kotak, atau hancurnya dinding bata yang dihantam
sebuah bola. Rendering merupakan proses di mana setiap frame animasi digambar
dan diolah menjadi gambar-gambar 2D yang kemudian dideretkan dan dijadikan
sebuah file video. Blender juga mendukung rendering ke file gambar setiap
13
framenya, atau bias juga bila hasil rendering tersebut tidak diekspor keluar.
Compositing berarti proses memperindah gambar dengan mengatur efek shader,
pencahayaan, dan sebagainya.
Blender mendukung pengmodifikasian face, edge, dan vertex dalam proses
modeling sehingga proses tersebut dapat dilakukan dengan sedetil mungkin. Blender
juga memiliki berbagai perintah yang memudahkan proses modeling seperti extrude
untuk menambahkan face, edge, atau vertex yang langsung terhubung dengan face,
edge, atau vertex sebelumnya, subdivide yang akan membagi semua face menjadi
empat bagian, merge untuk menyatukan dua vertex atau lebih, dan berbagai perintah
lainnya.
Selain itu, kemudahan lain yang ditawarkan oleh Blender adalah sistem
modifier. Salah satu modifier yang paling sering digunakan adalah mirror yang
berarti ‘cermin’ yang seperti namanya berfungsi untuk mencerminkan sebuah model
ke sisi yang dipilih, yang memudahkan proses modeling sehingga pengguna cukup
membuat model satu sisi saja dan sisi lainnya akan dibuat otomatis mengikuti sisi
tersebut.
2.1.4 Benda 3 Dimensi
Menurut Ardhianto, dkk (2012) benda 3 dimensi (3D) adalah sebuah objek
atau ruang yang memiliki panjang, lebar, dan tinggi yang memiliki bentuk. 3D tidak
hanya digunakan dalam matematikan dan fisika melainkan di bidang grafis, seni,
animasi, komp[uter, dan lain-lain. Konsep tiga dimensi atau 3D menunjukkan sebuah
14
objek atau ruang memilki tiga dimensi geometris yang terdiri dari: kedalaman, lebar
dan tinggi. Contoh tiga dimensi suatu objek atau benda adalah bola, piramida, atau
benda spasial seperti kotak sepatu.
2.1.5 Pengertian Unity
Unity 3D merupakan sebuah tools ayang terintegrasi untuk membuat bentuk
objek tiga dimensi pada video games atau untuk konteks interaktif lain seperti
Visualisasi Arsitektur atau animasi 3D real-time. Lingkungan dari pemgembangan
Unity 3D berjalan pada Microsoft Windows dan Mac OS X, serta aplikasi yang dibuat
oleh Unity 3D dapat berjalan pada Windows, Mac, Xbox 360, PlayStation 3, Wii,
iPad, iPhone dan tidak ketinggalan pada platform Android. Unity juga dapat
membuat game berbasi browser yang menggunakan Unity web player plugin, yang
dapat bekerja pada Mac dan Windows, tapi tidak pada Linux (Sudyamika, dkk.
2014).
Unity menyediakan fitur-fitur dan kemudahan untuk membuat game.
Contohnya adalah sistem scene untuk memilah-milah bagian game sehingga mudah
untuk berpindah misalnya dari menu utama ke menu settings dan kembali ke menu
utama. Kemudian sistem prefab di mana pengguna dapat menyimpan sebuah atau
sekumpulan asset-asset (file game) yang telah dimasukkan ke dalam sebuah scene
menjadi satu objek beserta setingannya yang dinamakan prefab, kemudian dari prefab
itu pemain dapat meletakkannya di dalam game dan mengatur settingan untuk semua
prefab yang telah dimasukkan tersebut dari prefab yang ada di folder. Unity juga
menyediakan asset store di mana pengguna dapat mendownload asset-asset dan
15
menggunakannya untuk game mereka, jadi pengguna tidak harus membuat semua
asset mereka satu per satu jika mau menggunakan asset store.
2.1.5.1 Scene
Menurut halaman resmi Unity, Scene menampung objek-objek game. Scene
dapat digunakan untuk membuat menu utama, level individu, dan lain-lain. Bisa
dikatakan bahwa sebuah file scene adalah sebuah level unik. Di dalam setiap scene,
pengguna akan meletakkan lingkungan, rintangan, dan dekorasi, dengan kata lain
mendesain dan membangun game dalam pecahan.
2.1.5.2 GameObjects
Menurut halaman resmi Unity, GameObject adalah konsep paling utama
dalam pembuatan game dengan Unity. Setiap objek di dalam game adalah
GameObject yang berarti apapun itu yang harus dimasukkan ke dalam game adalah
GameObject. Namun GameObject tidak dapat melakukan apapun jika sendirian.
Pengguna harus memeberikan property-properti sebelum objek tersebut dapat
menjadi karakter, lingkungan, atau efek ruang.
GameObject adalah penampung. Pengguna menambahkan pecahan-pecahan
ke dalam penampung itu untuk membuatnya menjadi karakter, cahaya, pohon, suara,
atau apapun yang pengguna inginkan. Setiap pecahan tersebut disebut dengan
Component.
Tergantung objek apakah yang ingin penguna buat, pengguna menambahkan
kombinasi Component berbeda ke dalam sebuah GameObject. Dapat dikatakan
16
bahwa GameObject bagaikan sebuah panci kosong dan Component adalah beragam
bahan masak untuk membuat resep gameplay pengguna.
2.1.5.3 Components
Menurut halaman resmi Unity, component atau komponen adalah inti dari
sebuah objek dan sifatnya dalam game. Komponen adalah pecahan-pecahan
fungsional dari setiap GameObject.
2.1.6 C#
Menurut Syakir (2015) C# adalah bahasa pemrograman baru yang diciptakan
oleh Microsoft yang dikembangkan di bawah kepemimpinan Anders Hejlsberg yang
telah menciptakan berbagai macam bahasa pemrograman termasuk Borland Turbo
C++ dan Borland Delphi. Bahasa C# juga telah distandarisasi secara internationsal
oleh ECMA. Seperti halnya bahasa pemrograman yang lain, C# bisa digunakan untuk
membangun berbagai macam jenis aplikasi, seperti aplikasi berbasis windows
(desktop) dan aplikasi berbasis web serta aplikasi berbasi web services.
C# memiliki fitur-fitur seperi desain berorientasi objek, seperti garbage
collection, reflection, akar kelas (root class), dan penyederhanaan terhadap pewarisan
jamak (multiple inheritance). Fitur-fitur tersebut di dalam C# kini telah diaplikasikan
terhadap iterasi, property, kejadian (event), metadata, dan konversi antara tipe-tipe
sederhana dan objek.
17
C# didesain untuk memenuhi kebutuhan akan sintaksis C++ yang lebih
ringkas dan Rapid Application Development yang ‘tanpa batas’ dibandingkan dengan
RAD yang ‘terbatas’ seperti yang terdapat pada Delphi dan Visual Basic.
C# juga merupakan salah satu dari bahasa pemrograman yang didukung Unity
selain dua bahasa lainnya, yakni Java dan Boo.
2.2 Penelitian Terdahulu
2.2.1 Pembuatan Game Balap Karung di SmartPhone Android
Ditulis oleh Denny Listyo Mu’adzin pada tahun 2013 untuk Sekolah Tinggi
Manajemen Informatika dan Komputer Yogyakarta. Dari pembuatan ini dihasilkan
game bertema balap karung untuk Android menggunakan Unity. Tampilan game
yang dihasilkan dalam pembuatan ini bersifat dua dimensi.
2.2.2 Pengembangan Game Edukasi Lingkungan Berbasis Android
Ditulis oleh Wafda Adita Rifai pada tahun 2015 untuk Universitas Negeri
Yogyakarta. Dari pengembangan ini dihasilkan game edukasi lingkungan untuk
Android yang dibuat dengan aplikasi Construct 2.
2.2.3 Pembuatan Game Edukasi Pintar Memilih Sampah Berbasis Android
Ditulis oleh Rizki Catur Putra pada tahun 2016 untuk Fakultas Komunikasi
dan Informatika Universitas Muhammadiyah Surakarta. Dari pembuatan ini
dihasilkan game edukasi pemilihan sampah untuk Android yang dibuat menggunakan
aplikasi Construct 2.
18
BAB III
METODOLOGI PENELITIAN
3.1 Kerangka kerja
Berikut akan dijelaskan kerangka kerja dalam pembuatan game ini. Kerangka
akan dibagi dalam bentuk langkah-langkah, kemudian setiap langkah tersebut akan
dijelaskan.
1. Langkah pertama: Perancangan cerita.
Akan lebih mudah untuk membuat sebuah game jika pembuat sudah
merancang tentang apakah game tersebut. Tidak semua game harus bercerita,
namun untuk game yang akan dibuat dalam penelitian ini, ada cerita yang
terkandung.
2. Langkah kedua: Perancangan gameplay.
Sebelum game dibuat, harus diketahui seperti apa gameplaynya.
Gameplay adalah cara sebuah game berjalan atau cara memainkan sebuah
game. Apakah game akan berupa game aksi, atau game balap, dan sebagainya.
3. Langkah ketiga: Perancangan dan pembuatan karakter.
Setelah mendapatkan cerita dan gameplay maka dapat dilanjutkan
dengan merancang dan membuat karakter yang sesuai. Karakter-karakter yang
dibuat adalah karakter pemain dan karakter yang dijalankan otomatis oleh
komputer. Kemudian karakter dibuat sesuai rancangan menjadi model 3D
menggunakan Blender.
19
4. Langkah keempat: Membuat model-model tambahan
Karakter yang telah dibuat tidak dapat berbuat apa-apa di dalam game
jika tidak ada benda lain seperti lingkungannya. Maka setelah mendapatkan
model karakter yang sesuai, langkah berikutnya adalah membuat model-model
lain seperti model lingkungan, model garis finish, gedung, lintasan, dan
sebagainya.
5. Langkah kelima: Merancang dan membuat antar muka
Antar muka berfungsi sebagai media interaksi pemain dengan game.
Langkah berikutnya adalah merancang antar muka seperti tombol-tombol yang
dibutuhkan, gambar yang dibutuhkan, letaknya media-media tersebut, dan
sebagainya. Kemudian media-media tersebut dibuat menggunakan program-
program yang sesuai misalnya judul game di menu utama dibuat menggunakan
Photoshop.
6. Langkah keenam: Penyusunan asset.
Karakter, model, antar muka, dan benda-benda lain yang sudah selesai
dan akan digunakan di dalam game diistilahkan sebagai asset. Asset-asset
tersebut kemudian diimport ke dalam projek game alam Unity dan disusun rapi
sedemikian rupa.
7. Langkah ketujuh: Penulisan script.
Asset-asset yang telah dibuat tidak dapat berbuat apapun jika tidak
diberikan perintah. Perintah tersebut diberikan dengan script. Script-script ini
dibuat dan ditempelkan ke asset-asset yang sesuai sehingga game dapat
berjalan.
20
8. Langkah kedepalan: Uji coba dan perbaikan.
Sangat sulit untuk membuat game yang sempurna dalam sekali coba.
Game yang telah selesai dibuat kemudian diuji coba dengan cara dimainkan di
media yang dituju. Untuk game ini media tersebut adalah perangkat android.
Dari uji coba tersebut dapat ditemukan kesalahan-kesalahan baik dalam script,
model, animasi, dan sebagainya. Kesalahan-kesalahan tersebut kemudian
diperbaiki sebelum diuji coba lagi. Proses ini diulangi terus menerus hingga
semua kesalahan yang ditemukan telah diselesaikan.
9. Langkah kesembilan: Evaluasi
Selama membuat game, pembuat akan mendapatkan pengalaman. Dari
pengalaman tersebut kemudian dapat ditarik pelajaran-pelajaran yang dapat
diterapkan untuk meningkatkan kualitas game-game lain yang akan dibuat ke
depannya.
21
BAB IV
ANALISIS DAN IMPLEMENTASI
4.1 Analisis Sistem
4.1.1 Garis Besar Game yang akan Dibuat
Game yang akan dibuat adalah sebuah game balap lari dengan karakter manusia
kerdil dengan telinga dan ekor kucing. Alasan penulis memilih balap lari adalah karena
game lomba balap dengan kendaraan sudah umum dan alasan penulis memilih karakter
tersebut adalah untuk menarik perhatian. Game ini dibuat menggunakan dua aplikasi
yaitu Blender untuk membuat karakter 3D dan Unity untuk menyusun game. Sudut
pandang yang diambil adalah sudut pandang orang ketiga di mana pemain akan melihat
melalui kamera yang dipasang di belakang karakter yang dimainkan dan grafis yang
dipilih adalah grafis 3D. Cara memainkannya adalah dengan terus menekan dua tombol
di sisi kiri dan kanan layar untuk berlari lebih cepat. Pemain juga akan diberikan skill-
skill yang berguna untuk menggapai juara pertama. Game ini dibuat khusus untuk
platform android.
4.1.2 Karakter
Seperti yang telah disebutkan di atas, karakter dalam game ini adalah manusia
kerdil dengan telinga dan ekor kucing. Karakter tersebut dipilih karena dianggap lucu
dan menarik perhatian. Model karakter dibuat dengan aplikasi Blender dalam bentuk
3D. Ciri-ciri karakter adalah sebagai berikut:
a. Bertubuh kecil sebesar kucing.
b. Berwajah manusia dengan style anime.
22
c. Berambut pendek sebahu.
d. Mengenakan sweater.
e. Mengenakan rok merah.
f. Mengenakan kaus kaki dan sepatu.
g. Memiliki telinga dan ekor kucing.
Model karakter pemain dan karakter lawan sama, namun untuk karakter lawan
nantinya akan memiliki beragam warna sesuai warna random yang dipilihkan
komputer, sedangkan baju karakter pemain berwarna oranye yang adalah warna GICI.
Perbedaan lain antara karakter pemain dan karakter lawan adalah, mata karakter lawan
tertutup bayangan.
Gambar 4.1 Model karakter pemain.
23
Gambar 4.2 Model karakter lawan.
4.1.3 Arena Balap
Arena Balap yang akan dipakai adalah sebuah lintasan datar berbentuk persegi
delapan. Di samping lintasan terdapat deretan lampu penerangan jalan. Di sekitar arena
juga akan terdapat gedung-gedung tinggi yang ditempeli poster dengan logo GICI.
Garis finish tujuan para pelari ditandai dengan silinder merah yang menjulang ke atas.
Gambar 4.3 Arena balap dari atas dengan gedung-gedungnya disembunyikan
24
Gambar 4.4 Arena balap tampak dekat dengan gedung-gedung yang diperlihatkan
Gambar 4.5 Garis finish
25
4.1.4 Grafis
Game akan menggunakan tampilan 3D untuk membuat pemain dapat
merasakan kecepatan ketika bermain. Mengingat perangkat android belum dapat
menggangkat game yang terlalu berat, maka penulis memutuskan untuk menurunkan
jarak pandang pemain dan membuat seolah-olah arena permainan berkabut. Hal ini
bertujuan untuk membuat game lebih ringan. Dengan menurunkan jarak pandang,
maka objek-objek yang harus digambar oleh perangkat menjadi lebih sedikit, namun
akan membuat game terlihat buruk. Maka penulis juga akan meletakkan sebuah objek
kabut yang mengikuti karakter pemain untuk menutupi keburukan tersebut.
Gambar 4.6 Contoh jarak pandang jauh tanpa kabut.
26
Gambar 4.7 Contoh jarak pandang dekat tanpa kabut.
Gambar 4.8 Jarak pandang dekat dengan kabut built-in
27
Gambar 4.9 Jarak pandang dekat dengan kabut built-in ditambah objek kabut untuk
menutupi langit.
Gambar 4.10 Wujud objek kabut
4.1.5 Cara Bermain
Tujuan pemain adalah berlari secepat mungkin untuk mencapai juara pertama.
Untuk membuat karakter berlari, pemain harus menekan dua tombol hitam di sisi kiri
28
dan kanan layar. Tombol ini akan mengisi bar putih di atas layar yang menentukan
apakah si karakter akan berjalan, berlari, berlari lebih cepat, atau diam. Isi bar tersebut
akan terus berkurang dengan sendirinya, maka pemain harus menekan secepat
mungkin.
Terdapat dua fase ketika kucing pemain berlari, yakni berlari biasa dan berlari
cepat atau sprint. Di bawah layar terdapat dua bar, hijau dan merah. Bar hijau
menandakan stamina pemain dan bar merah ketahanan pemain. Sprint akan menguras
bar hijau. Jika bar hijau habis, maka yang dikuras adalah bar merah. Jika keduanya
habis, pemain hanya dapat berjalan atau berhenti hingga kedua bar kembali penuh.
Kedua bar tersebut dapat diisi kembali dengan berhenti, berjalan, atau berlari biasa.
Berhenti akan mengisi bar lebih cepat dari berjalan. Berjalan akan mengisi bar lebih
cepat dari berlari biasa. Bar merah dapat diisi sambil melakukan sprint namun hanya
jika bar hijau tidak kosong.
Kucing pemain mengikuti lintasan secara otomatis. Hal ini dapat dilakukan
dengan menggunakan komponen navmesh agent pada Unity yang memungkinkan
suatu objek untuk mencari jalannya sendiri ke tempat tujuan dan bergerak ke tujuan
tersebut secara otomatis. Maka pemain cukup berfokus pada mengatur kecepatan
kucingnya.
Pemain akan diberikan tiga skill untuk membantu mereka dalam berlomba.
Setiap skill ini memiliki efek khusus dan cooldown tersendiri. Cooldown adalah
hitungan waktu yang berjalan mundur. Jika cooldown suatu skill masih di atas 0, maka
skill tersebut tidak dapat dipakai. Ketiga skill tersebut dijelaskan sebagai berikut:
29
A. Adrenaline
Mengisi penuh baru putih untuk membuat pemain melompat langsung
ke fase sprint dan membuat konsumsi stamina dan ketahanan menjadi 0 selama
5 detik. Cooldown untuk skill ini adalah 10 detik.
B. Concentrate
Meningkatkan kecepatan mengisi bar stamina dan ketahanan sebanyak
5 kali lipat selama 5 detik. Cooldown untuk skill ini adalah 30 detik.
C. Last Spurt
Meningkatkan kecepatan sprint pemain sebanyak 2 kali lipat selama 5
detik. Cooldown untuk skill ini adalah 60 detik atau 1 menit.
4.1.6 Status
Pemain dapat mengakses halaman status dari menu utama melalui menu stats.
Dari sini pemain dapat memodifikasi 9 parameter yang berhubungan dengan
kemampuan karakter pemain. Kesembilan parameter tersebut adalah:
1. Walk speed untuk kecepatan berjalan.
2. Run speed untuk kecepatan berlari.
3. Sprint speed untuk kecepatan sprint.
4. Stamina max untuk kapasitas stamina.
5. Stamina regeneration untuk kecepatan regenerasi stamina.
6. Stamina consumption untuk jumlah pemakaian stamina.
7. Vitality max untuk kapasitas ketahanan.
8. Vitality regeneration untuk kecepatan regenerasi ketahanan.
30
9. Vitality consumption untuk jumlah pemakaian ketahanan.
Untuk memodifikasi parameter-parameter tersebut, pemain membutuhkan
status point. Pemain hanya dapat menambahkan nilai sebuah parameter jika pemain
masih memiliki status point yang tersisi. Pemain dapat mengembalikan poin tersebut
dengan mengurangi nilai parameter yang telah diisi melebihi 0. Pemain juga dapat
mendapatkan poin tersebut dengan melakukan Level Up. Setiap Level Up, pemain
mendapatkan 1 status point. Untuk melakukan Level Up, pemain membutuhkan
Experience yang mencukupi nilai tertentu tergantung level pemain. Semakin tinggi
level pemain, semakin besar nilai yang dibutuhkan. Experience didapatkan ketika
berhasil menyelesaikan sebuah perlombaan.
4.1.7 Cerita Latar Belakang
Pemain dapat mengakses halaman cerita dari menu utama dengan tombol
story. Di sini diceritakan secara singkat tentang cerita latar game. Cerita tersebut
tertulis dalam bahasa Inggris sebagai berikut:
“Humans evolve and so do we. They now roam the sky, lives in
towers above like birds, freely. While us, cats, having taken form and mind
alike to them, began our own civilization. But we aren't as stupid. Humans
had set us an example that brute force solves problems, yet also gives birth to
another. We left that way of life now. Instead we choose to run. We run for
territories. We run for brides. We run for honor. We hold sportsmanship dear
as our principle. So when there is problem... we, cats, below the towers, run.”
31
Tulisan tersebut dapat diartikan sebagai berikut:
“Layaknya manusia, kami juga berevolusi. Mereka kini terbang di
udara, tinggi di menara-menara di atas, bebas seperti burung. Sementara kami,
pada kucing, setelah mendapatkan tubuh dan pikiran yang mirip dengan
mereka, memulai peradaban kami sendiri. Namun kami tidak sebodoh
mereka. Manusia mengajarkan kami bahwa kekerasan mungkin bisa
menyelesaikan masalah, tapi juga melahirkan masalah baru. Kami sudah
meninggalkan cara hidup seperti itu sekarang. Kami lebih memilih untuk lari.
Kami lari untuk teritori. Kami lari untuk pasangan. Kami lari demi
kehormatan. Kami memegang teguh sportifitas sebagai prinsip. Maka ketika
ada masalah, kami para kucing, di bawah menara-menara, lari.”
Dari tulisan tersebut dapat ditarik kesimpulan bahwa, latar game mengambil
waktu di masa depan di mana manusia kini berkemampuan untuk terbang dan tinggal
di menara-menara. Sementara itu kucing-kucing yang masih tinggal di dasar berevolusi
dan memulai peradaban mereka sendiri. Di peradaban tersebut terdapat budaya di mana
untuk menyelesaikan masalah, mereka berlomba lari dan pihak yang kalah harus
mengalah dalam masalah tersebut.
4.1.8 Penjelasan Scene
Game ini dibagi dalam beberapa scene. Setiap scene memiliki fungsi-fungsi
tersendiri. Berikut adalah penejelasannya:
1. Initialization
32
Scene Initialization adalah scene yang paling pertama dibuka ketika
game dimulai. Namun scene ini tidak dapat dilihat oleh pemain karena terdapat
script yang akan langsung memindahkan pemain ke scene menu utama. Hal itu
dikarenakan scene Initialization tidak memiliki tampilan apapun dan tidak
memiliki interaksi dengan pemain. Fungsi dari scene ini adalah untuk
menampung script-script yang tidak boleh dihancurkan ketika terjadi
perpindahan scene. Script-script ini mengandung data-data yang harus
dipindah-pindahkan dari satu scene ke scene lainnya. Jika script-script ini
hancur, maka data itu akan hilang. Script-script tersebut juga tidak dapat
diletakkan di scene lain karena ketika pemain kembali ke scene yang
mengandung script tersebut, script yang sama akan muncul membuat script
yang dimaksud berjumlah lebih dari satu dengan nilai data yang berbeda,
kemudian script yang baru ini tidak akan hancur selama permainan. Hal ini
akan menyebabkan program kebingungan dalam pengambilan dan penulisan
data pada script tersebut.
2. Main Menu
Scene menu utama ini adalah scene kedua setelah initialization namun
adalah scene yang pertama kali dilihat oleh pemain ketika memulai permainan.
Dalam scene ini terdapat tombol-tombol navigasi ke scene lainnya seperti
tombol untuk memulai permainan, melihat story, merubah status, dan keluar
dari permainan.
3. Setup_race
33
Sebelum pertandingan dimulai, pemain dapat mengatur beberapa
pengaturan pertandingan tersebut seperti jumlah kucing lawan, jarak lari, dan
tingkat kesulitan. Pengaturan tersebut dilakukan di scene setup_race ini. Scene
ini dapat diakses langsung dari menu utama.
4. Stadium
Dalam scene inilah pertandingan berlangsung. Scene ini dapat diakses
dari tombol START di scene setup_race.
5. Stats
Scene stats adalah scene di mana pemain dapat merubah status
kucingnya seperti yang telah dijelaskan di atas. Scene ini dapat diakses dari
menu utama dengan tombol STATS.
6. Story
Adalah scene di mana pemain dapat membaca cerita latar belakang
game ini seperti yang telah dijelaskan di atas. Scene ini dalah diakses dari menu
utama.
4.1.9 Script
Script dalam game ini menggunakan bahasa pemrograman C#, salah satu dari
tiga bahasa pemrograman yang didukung oleh Unity. Berikut adalah penjelasan
masing-masing script tersebut.
1. Aispawner
Berfungsi untuk memunculkan kucing-kucing lawan sesuai dengan
jumlah yang telah diinput pemain di halaman pengaturan perlombaan. Jumlah
34
ini kemudian dimasukkan ke dalam variabel aimax. Script ini bekerja dengan
cara membaca nilai aimax, lalu membaca variabel I yang awalnya bernilai nol.
Jika variabel tersebut bernilai kurang dari aimax, maka script akan terus
memunculkan kucing lawan dan menaikkan nilai I sebanyak 1 poin hingga nilai
I menjadi lebih besar atau sama dengan aimax. Kemudian terdapat variabel X
dan Z yang akan diisi dengan angka acara dari 1 sampai 5 setiap kali kucing
lawan baru akan dimunculkan. Kedua variable itu digunakan untuk membuat
koordinat Vertor3 baru dengan nilai (X,0,Z) yang lalu ditambahkan dengan
koordinat lokasi kucing pemain untuk mendapatkan variabel Desiredlocation.
Variabel Desiredlocation digunakan sebagai titik di mana script akan
memunculkan kucing lawan yang baru. Setelah jumlah I menjadi lebih besar
atau sama dengan aimax, permainan dimulai dan script ini dihapus.
Script ini ditempelkan ke sebuah gameobject kosong bernama
GAMEMASTER sebagai sebuah komponen. Gameobject kosong adalah
gameobject yang hanya berupa koordinat di dalam scene sehingga tidak akan
mengganggu jalannya permainan. Gameobject seperti ini sangat cocok untuk
ditempeli script-script yang mengatur permainan secara general seperti script
aispawner ini.
2. Aicolorswitch
Adalah sebuah script yang ditempelkan ke setiap objek kucing lawan.
Fungsi dari script ini adalah untuk merubah warna rambut dan baju kucing yang
ditempelinya secara acak dengan cara mengganti material dari objek rambut
35
dan baju tersebut dengan material yang telah disediakan sebagai bagian dari
sebuah list di script lain bernama matlister yang tertempel di GAMEMASTER.
Script ini bekerja dengan cara merubah nilai variabel I menjadi sebuah
angka acak dari 0 hingga banyak material yang bersangkutan di script matlister
dikurangi 1. Jadi misalnya jumlah material di script matlister adalah 5, maka
angka acak yang diberikan untuk variabel I adalah 0 hingga 5. Kemudian script
ini mengambil material bersangkutan dengan indeks nilai I dari script matlister
dan mengganti material pada objek rambut dan baju kucing dengan material
tersebut.
3. Aiselector
Termasuk ke dalam script-script yang akan ditempeli ke dalam setiap
kucing lawan adalah script aibehavioursmart dan aibehavioursprinter. Kedua
script ini adalah script yang mengontrol sifat dari kucing. Hanya salah satu dari
kedua script tersebut yang akan aktif selama perlombaan, maka setiap kucing
lawan akan memiliki strategi tersendiri untuk berlari tergantung script mana
yang aktif.
Aiselector adalah script yang akan menentukan yang mana dari antara
kedua script tersebut yang akan diaktifkan untuk seekor kucing lawan. Cara
kerja dari script ini adalah memberikan nilai 1 atau 2 kepada variabel I. Angka
ini dipilih secara acak oleh komputer. Jika I bernilai 1 maka script
aibehavioursprinterlah yang akan diaktifkan. Jika I bernilai 2 maka script yang
akan diaktifkan adalah aibehavioursmart. Setelah script aiselector mengatifkan
salah satu dari kedua script tersebut, script ini akan menghapus dirinya sendiri
36
dari kucing yang ditempelinya untuk mengurangi beban memori pada
perangkat.
4. Aibehavioursprinter
Salah satu dari dua tipe sifat kucing lawan. Script ini bekerja dengan
cara mengarahkan kucing ke checkpoint berikutnya menggunakan komponen
navmesh agent sambil terus melakukan sprint. Ketika stamina kucing tersebut
habis, kucing lawan tersebut akan berhenti melakukan sprint dan berjalan untuk
memulihkan stamina hingga penuh sebelum kembali melakukan sprint. Sifat
ini ceroboh karena terus menggunakan stamina hingga habis dan kucing dengan
sifat ini sangat mudah dilewati ketika sedang berjalan, namun sifat ini memiliki
kecepatan sprint dan jumlah stamina yang banyak membuatnya menjadi lawan
yang tangguh ketika melakukan sprint.
5. Aibehavioursmart
Salah satu dari dua sifat kucing lawan. Seperti namanya yang
mengandung kata ‘smart’ yang berarti ‘pintar’, sifat ini adalah kebalikan dari
script aibehavioursprinter. Kucing lawan dengan sifat ini akan berlari biasa,
namun ketika jarak antara kucing tersebut dan checkpoint berikutnya sudah
dekat, kucing ini akan langsung melakukan sprint. Dengan cara ini, kucing
dengan script aibehavioursmart sangat jarang kehabisan stamina dan ditambah
kecepatan lari dan sprint mereka yang tinggi, kucing dengan sifat ini bisa
menjadi lawan tangguh tergantung kemampuan pemain.
6. Bgmchange
37
Script ini digunakan untuk mengganti musik latar game. Terdapat 1
musik untuk menu utama dan 5 musik untuk perlombaan. Script ini
ditempelkan ke sebuah objek kosong seperti GAMEMASTER, lalu script ini
ditempeli beberapa asset musik yang akan dipakai dalam bentuk list. Script ini
bekerja dengan cara memberikan nilai acak dari angka 0 hingga jumlah list
musik yang menempelinya dikurangi 1 kepada variabel I. Kemudian script
mencari objek kosong bernama ‘sound’ yang ditempeli komponen audio source
dan mengganti musik pada komponen tersebut dengan musik di indeks I pada
list musik script ini.
7. Bgmcontrol
Adalah script yang ditempelkan pada objek kosong sound. Script ini
berfungsi untuk mencegah agar objek sound tidak dihapus ketika terjadi
penggantian scene. Objek sound ini sendiri terdapat pada scene initialization
yang adalah scene paling pertama dalam game ini yang diputar sebelum game
dimulai. Scene ini berfungsi untuk menyimpan objek-objek kosong yang tidak
boleh dihapus ketika penggantian scene karena mengandung data-data yang
harus ditransfer dari scene satu ke scene yang lain seperti komponen pemutar
musik latar, data pemain, data perlombaan, dan sebagainya.
8. Checkpointcontrol
Dalam pertandingan akan terdapat objek garis finish seperti yang telah
dijelaskan di atas. Objek tersebut akan ditempelkan script checkpointcontrol
untuk membaca dan merekam posisi akhir kucing-kucing yang telah
melewatinya. Script ini bekerja dengan cara membaca capsule collider yang
38
tertempel pada objek garis finish. Ketika collider ini bertabrakan dengan seekor
kucing, makan script akan menambahkan kucing tersebut ke dalam sebuah list
di script positionrecorder yang tertempel di objek GAMEMASTER. Ketika
kucing pemain bertabrakan dengan collider tersebut, script akan menambahkan
kucing pemain ke dalam list tersebut dan memunculkan indeksnya ditambah 1
sebagai posisi akhirnya, lalu menampilkan tulisan finish dan memberikan
pilihan kepada pemain untuk mengulang pertandingan atau kembali ke menu
utama.
9. Checkpointlister
GAMEMASTER juga akan ditempeli script checkpointlister ini. Script
ini berfungsi untuk menampung checkpoint-checkpoint yang terdapat di arena
pertandingan. Data checkpoint-checkpoint ini kemudian dibaca oleh setiap
kucing lawan untuk mengetahui checkpoint selanjutnya yang akan dijadikan
tujuan navmesh agent kucing tersebut sehingga kucing lawan dapat bergerak
mengikuti lintasan ke garis finish.
10. Closeapp
Sebuah script sederhana yang ditempelkan ke tombol EXIT APP yang
berfungsi untuk menutup aplikasi.
11. Cooldown
Script ini ditempelkan ke semua text cooldown skill pemain untuk
menghitung sisa waktu cooldown skill tersebut dan mengganti nilai text yang
ditempelinya dengan nilai waktu yang tersisa tersebut sehingga pemain dapat
mengetahuinya.
39
12. Countdowntostart
Tertempel di objek ‘ready’ di scene pertandingan, script ini berfungsi
untuk menampilkan angka 3, 2, 1, dan tulisan GO secara berurutan dengan
interval 1 detik, kemudian memulai pertandingan. Untuk melakukannya, script
coundowntostart ini menggunakan metode IEnumerator pada Unity.
13. Finisher
Sebuah script yang berfungsi untuk menghitung jumlah experience
yang diperoleh pemain di akhir pertandingan dan menambahkannya ke status
pemain lalu menyimpan data tersebut agar tidak hilang.
Rumush experience yang didapat pemain di akhir pertandingan adalah
sebagai berikut:
((jumlah lawan + (jarak lari /10)) * level lawan)/posisi.
Jadi jika dalam sebuah pertandingan jumlah kucing lawan adalah 10
ekor, jarak lari 700 meter, level lawan adalah 2, dan posisi pemain adalah 4,
maka experience yang didapat pemain adalah:
((10 + (700/10)) * 2) / 4 = 40 poin.
14. Followplayer
Sebuah script sederhana yang berfungsi untuk membuat sebuah objek
mengikuti objek target, yang biasanya adalah kucing pemain, dengan cara
membaca posisi target setiap framenya dan memindahkan objek yang ditempeli
followplayer ini ke posisi target tersebut menggunakan metode slerp. Script ini
ditempelkan pada objek kabut dan pivot kamera.
15. Leveler
40
Script ini berfungsi untuk mengoperasikan tombol LEVEL UP di
halaman Status. Cara kerja dari script Leveler ini adalah, membaca jumlah
experience yang dimiliki pemain, lalu membaca jumlah experience yang
dibutuhkan pemain untuk level up, yang dihitung dengan rumus:
Experience yang dibutuhkan = level sekarang * 100
Jika experience yang dimiliki pemain sama atau lebih tinggi dari
experience yang dibutuhkan, maka ketika pemain menekan tombol LEVEL UP,
level pemain akan naik sebanyak 1 poin, jumlah experience yang dibutuhkan
dihitung kembali dengan rumus di atas, dan total experience yang dimiliki
pemain akan dikurangkan dengan jumlah experience yang dibutuhkan
sebelumnya.
16. Matlister
Seperti yang telah disebutkan di atas, matlister adalah sebuah script
yang berfungsi untuk menampung material-material untuk rambut dan baju
kucing lawan. Script sederhana ini menggunakan sistem list untuk menampung
material-material tersebut sehingga developer dapat menambahkan atau
mengurangi material yang disediakan. Script matlister ditempelkan pada objek
GAMEMASTER.
17. Noisemaker
Untuk menghasilkan suara, sebuah objek ditempeli komponen Audio
Source dan script Noisemaker. Script ini menampung sebuah file audio yang
telah ditanamkan oleh developer. Terdapat fungsi noise dalam script
Noisemaker, yang jika dipanggil, akan mengganti clip pada Audio Source objek
41
yang ditempeli script ini dengan file audio yang ditampungnya dan memutar
suara tersebut. Script ini ditempelkan pada kucing-kucing untuk menghasilkan
suara tapak kaki.
18. PlayerMove
Sebuah script panjang yang berperang besar pada jalannya game.
Seperti namanya, script PlayerMove mengatur pergerakan pemain. Script ini
membuat kucing pemain bergerak sesuai jumlah ketukan yang diinput pemain
dan berubah dari fase diam, jalan, berlari, dan sprint. Script ini juga membuat
kucing pemain dapat mengenali posisi-posisi checkpoint di dalam arena
pertandingan dan dengan menggunakan komponen NavMesh Agent, membuat
kucing tersebut dapat bergerak dari checkpoint ke checkpoint layaknya
bertanding sesuai lintasan.
Selain itu, script PlayerMove juga memiliki fungsi untuk mengambil
data status kucing pemain seperti kecepatan berlari, stamina, dan sebagainya
dari script Plyrstat, lalu menyimpan dan mengolah data tersebut selama
permainan. Script inilah yang mengatur jumlah stamina dan ketahanan kucing
pemain sesuai pergerakannya, lalu membuat kucing tersebut tidak dapat berlari
ketika kedua variabel tersebut kosong. Kecepatan jalan, lari, dan sprint kucing
pemain juga diatur oleh script ini yang didasarkan pada status kucing pemain.
19. Playerskill
Seperti yang telah dijelaskan di atas, pemain akan diberikan tiga skill
yakni Adrenaline, Concentrate, dan Last Spurt. Ketiga skill ini dikendalikan
42
menggunakan script Playerskill yang juga ditempelkan pada objek kucing
pemain sama seperti script PlayerMove.
Scipt ini memiliki fungsi-fungsi yang dapat dipanggil ketika pemain
menekan tombol skill yang bersangkutan. Fungsi Boost berfungsi untuk
mengaktifkan skill Adrenaline dengan merubah nilai stamina consume dan
vitality consume pada script PlayerMove menjadi 0 untuk sementara waktu.
Fungsi Con mengaktifkan skill Concentrate dan meningkatkan nilai regenerasi
stamina dan vitality pemain pada script PlayerMove menjadi 5 kali lipat selama
beberapa detik. Dan terakhir fungsi Spurt yang mengaktifkan skill Last Spurt
yang meningkatkan nilai kecepatan sprint pada script PlayerMove menjadi 2
kali lipat selama 5 detik.
20. Plyrstat
Script yang berfungsi untuk menampung data status pemain. Data ini
kemudian dapat dibaca dan ditulis ulang oleh script lain. Script ini terdapat pada
scene Initialization dan tidak ikut dihancurkan pada pemindahan scene.
Selain itu, script Plyrstat ini juga memilikir fungsi save dan load yang
sangat penting. Kedua fungsi ini seperti namanya berfungsi untuk menyimpan
dan membaca data pemain ketika dipanggil. Data tersebut tersimpan di dalam
sebuah file sehingga data tersebut dapat dirubah dan dibaca kembali oleh
aplikasi. Kedua fungsi ini dapat dipanggil oleh script manapun yang memiliki
fungsi untuk memanggilnya sehingga memudahkan developer memerintahkan
program untuk melakukan save dan load karena developer tidak perlu mengetik
ulang fungsi tersebut, cukup memanggil dari script Plyrstat.
43
21. Positionrecorder
Terintegrasi dengan script Checkpointcontrol, script ini berfungsi untuk
merekam posisi kucing-kucing yang telah melewati garis finish. Objek
checkpoint yang ditempeli script Checkpointcontrol juga memiliki komponen
capsule collider. Ketika seekor kucing menyentuh collider ini, script
Checkpointcontrol akan mendaftarkan kucing tersebut ke sebuah list di script
Positionrecorder. List bekerja seperti array yang berarti setiap anggota di
dalam list tersebut memiliki indeks. Indeks inilah yang kemudian digunakan
untuk menentukan posisi akhir seekor kucing dengna rumus:
Posisi akhir = indeks kucing + 1
22. Racereadsetupatstart
Berfungsi untuk membaca pengaturan pertandingan yang diinginkan
pemain seperti banyaknya lawan, tingkat kesulitan, dan jarak lari. Data-data ini
disimpan di sebuah script beranma setuprace dan dibaca oleh script
Racereadsetupatstart ini untuk kemudian didistribusikan ke script-script
bersangkutan di objek GAMEMASTER pada scene pertandingan. Contohnya
data banyaknya lawan kemudian diberikan kepada script Aispawner untuk
memunculkan kucing lawan dengan jumlah yang sesuai.
23. Readplyrstatforplayer
Script ini berfungsi untuk membaca status pemain dari script plyrstat,
mengolah data yang dibaca tersebut, dan menyampaikannya pada script
Playermove. Yang dimaksud dengan mengolah data di sini adalah
menambahkan status pemain ke dalam status dasar dengan rumus tertentu.
44
Berikut akan dijelaskan rumus-rumus tersebut. Yang dimaksud dengan nilai
dasar adalah nilai status kucing sebelum ditambahkan, sementara yang
dimaksud dengan poin adalah poin status bersangkutan yang telah ditingkatkan
oleh pemain dan disimpan di script Plyrstat. Rumus-rumus tersebut adalah:
1. Kecepatan berjalan = kecepatan berjalan dasar + (poin kecepatan
berjalan dari plyrstat / 10)
2. Kecepatan berlari = kecepatan berlari dasar + (poin kecepatan
berlari / 10)
3. Kecepatan sprint = kecepatan sprint dasar + (poin kecepatan sprint
/ 10)
4. Stamina maksimum = jumlah stamina dasar + (poin stamina
maksimum * 10)
5. Regenerasi stamina saat diam = nilai dasar + (poin / 10)
6. Regenerasi stamina saat berjalan = nilai dasar + (poin / 20)
7. Regenerasi stamina saat berlari = nilai dasar + (poin / 30)
8. Konsumsi stamina = nilai dasar – (poin / 100)
9. Ketahanan maksimum = nilai dasar + (poin * 5)
10. Regenerasi ketahanan saat diam = nilai dasar + (poin / 10)
11. Regenerasi ketahanan saat berjalan = nilai dasar + (poin / 20)
12. Regenerasi ketahanan saat berlari = nilai dasar + (poin / 30)
13. Konsumsi ketahanan = nilai dasar – (poin / 100)
24. Readplyrstatfortext
45
Hampir mirip dengan Readplyrstatforplayer, script ini berfungsi untuk
membaca data dari script Plyrstat. Namun script Readplyrstatfortext ini
terdapat di halaman penaikkan status. Data-data yang dibaca tersebut kemudian
didistribusikan kepada objek-objek text bersangkutan untuk menampilkan nilai
yang sesuai dengan data.
25. Restart
Seperti namanya script ini berfungsi untuk mengulang permainan
dengan pengaturan yang sama. Tertempel pada tombol restart yang muncul
ketika pertandingan berakhir. Jika permainan diulang, bukan berarti experience
yang telah didapatkan hilang karena sebelumnya telah disave oleh script
Finisher.
26. Scenechanger
Sebuah script general yang tertempel di tombol-tombol yang berfungsi
untuk berpindah dari scene sekarang ke scene tujuan.
27. Setuprace
Berfungsi untuk menyimpan pengaturan pertandingan yang diinput
pemain, script sederhana ini terdapat di scene initialization dan telah diatur agar
tidak dapat dihancurkan. Data yang disimpannya dapat dirubah dari halaman
pengaturan pertandingan.
28. Startrace
Script ini terdapat di halaman pengaturan pertandingan dan adalah
script yang berfungsi untuk mengubah data script Setuprace di atas. Selain itu
cript ini juga berfungsi untuk mencegah pemain memasukkan angka 0 atau
46
tidak memasukkan apapun pada jumlah kucing lawan dan tingkat kesulitan.
Jika pemain memasukkan nilai tersebut, script akan merubah nilainya menjadi
default yang berarti jumlah kucing lawan adalah 5 ekor dan tingkat kesulitan
adalah level 1.
29. Startthegame
Sebuah script lain yang terdapat di scene initialization yang berfungsi
untuk berpindah ke halaman menu utama dan meload data status pemain ke
script Plyrstat. Namun script ini tidak disetting agar tidak hancur, yang berarti
script ini akan hilang ketika pemain berpindah ke halaman menu utama.
30. Statmin dan Statplus
Dua script yang hampir mirip ini berfungsi untuk mengurangi dan
menambahkan poin status yang bersangkutan ketika pemain menekan tombol
yang bersangkutan pula. Keduanya terdapat pada tombol-tombol perubahan
status di halaman penaikkan status.
4.10 Runtutan Pembuatan
Seperti yang telas dijelaskan, pembuatan game ini melibatkan aplikasi
Blender untuk membuat model 3D dan Unity untuk membangun game. Selain itu, juga
digunakan program lain seperti Photoshop untuk membuat asset-asset berupa gambar.
Berikut dijelaskan runtutan pembuatan game tersebut.
1. Pembuatan karakter pemain dan karakter musuh dilakukan di Blender.
Dalam tahap ini dilakukan modeling, rigging, dan animating. Modeling
adalah proses pembuatan model 3D karakter. Rigging adalah proses
47
penanaman bone atau tulang-tulang ke dalam karakter yang telah selesai
untuk kemudian di animasikan. Animating dilakukan dengan cara
memisahkan animasi karakter ke beberapa animasi seperti idle untuk
animasi berdiri diam, walk untuk animasi berjalan, run untuk animasi
berlari, dan sprint untuk animasi berlari cepat. Setelah semua proses
selesai, file 3D karakter diexport dalam format .fbx yang selain menampung
data 3D karakter, juga menampung data animasi yang telah dipisah tadi.
2. Kedua file 3D tersebut kemudian diimport ke dalam Unity sebagai Asset.
Setelah selesai proses import, maka dilanjutkan dengan proses
pembangunan scene. Pembangunan dimulai dari scene Initialization yang
adalah scene paling pertama dalam game. Kemudian dilanjutkan dengan
membangun scene-scene yang lain seperti menu utama, jendela status,
jendela cerita, jendela pengaturan pertandingan, dan scene pertandingan.
Asset-asset yang berhubungan dimasukkan ke dalam scene-scene tersebut
agar dapat berfungsi. Beberapa asset kecil seperti logo juga dibuat
menggunakan Photoshop.
3. Proses pengkodingan tidak dilakukan setelah pembangunan scene. Proses
ini dilakukan bersamaan dengan pembangunan tersebut. Script-script
ditulis untuk membuat scene-scene tersebut berfungsi. Kemudian
dilakukan uji coba untuk setiap script yang dibuat dan dilakukan perbaikan
pada script atau tata letak asset pada scene yang berhubungan sampai
semua scene berjalan dengan baik. Scene yang paling banyak memakan
48
waktu adalah scene pertandingan. Fungsi pergerakan pemain dibuat
terlebih dahulu, lalu disusul dengan fungsi kecerdasan lawan dan diakhiri
dengan fungsi pertandingan seperti membaca pemenang, stamina, skill, dan
sebagainya.
4. Tahap berikutnya adalah tahap debugging di mana game yang telah selesai
dibangun dimainkan dan disempurnakan. Tahap ini pertama kali dilakukan
di PC menggunakan Unity itu sendiri. Game berkali-kali dimainkan oleh
pembuat untuk ditemukan kesalahannya dan diperbaiki. Namun ada hal
yang tidak cukup dilakukan di PC. Tahap selanjutnya dalam debugging
dilakukan dengan smartphone Android. Game dieksport dalam format .apk
yang adalah format installer untuk Android, kemudian ditransfer ke
perangkat Android dan diinstall. Game tersebut kemudian dimainkan di
perangkat dan diperbaiki melalui komputer. Tahap ini diulang terus-
menerus sehingga jalannya game dinilai stabil dan layak main.
5. Setelah game dinilai layak main, dapat dikatakan game telah selesai dibuat.
Game versi final tersebut kemudian dieksport dalam format .apk dan
sekarang dapat diinstall di perangkat-perangkat Android yang mendukung.
4.2 Implementasi
Berikut adalah hasil dari pembuatan game. Gambar-gambar berikut diambil
langsung dari perangkat smartphone Android.
1. Tampilan menu utama
49
Gambar 4.11 Tampilan menu utama
Berisikan menu-menu navigasi ke scene-scene lainnya seperti memulai
permainan, berpindah ke scene story, berpindah ke scene stats, dan mengakhiri
aplikasi.
2. Tampilan Story
Gambar 4.12 Tampilan scene Story
50
Berisikan cerita latar belakang game yang telah dijelaskan dalam Bab
4. Terdapat satu tombol ‘Back’untuk kembali ke halaman utama.
3. Tampilan scene Stats
Gambar 4.13 Tampilan scene Stats
Terdapat tombol tambah dan kurang untuk setiap jenis status yang dapat
dirubah oleh pemain. Juga terdapat tombol ‘Level Up’ untuk menaikkan level
dan tombol ‘Back’ untuk kembali ke menu utama. Scene ini menampilkan
informasi status, experience, dan level pemain. Juga menampilkan model
kucing pemain di sebelah kanan layar.
51
4. Tampilan pengaturan pertandingan
Gambar 4.14 Tampilan pengaturan pertandingan
Dapat diakses dari menu utama dengan menekan tombol ‘New Race’.
Di sini pemain dapat merubah pengaturan pertandingan seperti jumlah lawan,
jarak lari, dan tingkat kesulitan. Pemain juga dapat langsung saja menekan
tombol ‘START’ tanpa merubah nilai manapun karena jika pemain melakukan
hal tersebut game akan mengubah nilai pengaturan secara otomatis
menggunakan sebuah script seperti yang telah di jelaskan di atas. Juga terdapat
tombol ‘Back’ untuk kembali ke menu utama.
52
5. Tampilan pertandingan
Gambar 4.15 Tampilan pertandingan
Ini adalah scene di mana pemain berlari melawan kucing-kucing lain.
Pemain harus terus mengetuk dua tombol hitam di sisi kiri dan kanan layar
untuk membuat kucingnya berlari. Kecepatan kucing bergantung pada seberapa
cepat pemain mengetuk tombol tersebut. Di sisi kanan juga terdapat tiga tombol
untuk skill dengan tombol merah untuk Last Spurt, tombol hijau untuk
concentrate, dan tombol biru untuk adrenaline. Di sisi atas layar terdapat
sebuah bar yang adalah sebuah objek slider yang menampilkan informasi
tentang fase apa yang sedang dilakukan kucingnya pada pemain. Bar tersebut
akan terus turun namun akan bertambah sesuai kecepatan ketukan pemain. Di
bawah layar terdapat bar hijau yang adalah stamina pemain dan bar merah yang
adalah ketahanan pemain. Jika bar hijau kosong maka bar merah yang akan
53
berkurang ketika melakukan sprint. Jika keduanya kosong, pemain tidak dapat
berlari dan hanya dapat berjalan hingga kedua bar tersebut kembali penuh.
4.2.1 Uji Coba
Game ini dapat berjalan di sistem operasi Android versi 2.3.1 atau Gingerbread
(API Level 9) ke atas. Dengan menggunakan sistem anchor pada pembuatan UI dengan
Unity, Game ini dapat berjalan di semua resolusi dengan orientasi landscape.
Versi Kompatibel / Tidak
2.3.1 Kompatibel
2.3.3 Kompatibel
3.0 Kompatibel
3.1 Kompatibel
3.2 Kompatibel
4.0 Kompatibel
4.0.3 Kompatibel
4.1 Kompatibel
4.2 Kompatibel
4.3 Kompatibel
4.4 Kompatibel
5.0 Kompatibel
5.1 Kompatibel
Tabel 4.1 Tabel kompatibilitas game dengan versi Android.
54
Aspek Ratio Kompatibilitas
4:3 Kompatibel
3:2 Kompatibel
8:5 Kompatibel
5:3 Kompatibel
16:9 Kompatibel
Tabel 4.2 Kompatibilitas game dengan berbagai aspek ratio layar smartphone
Android berorientasi landscape.
53
BAB V
KESIMPULAN DAN SARAN
5.1 Kesimpulan
Dari pembuatan game balap kucing berbasis Android ini, dapat ditarik
kesimpulan bahwa:
1. Blender 3D dapat digunakan untuk membuat model 3D yang kemudian dapat
digunakan di dalam game.
2. Dengan cara menyimpan data-data di dalam sebuah script, menempelkan script
itu ke sebuah object, lalu mencegah agar object itu tidak dihapus ketika
perpindahan scene, kita dapat memindahkan data-data dari satu scene ke scene
yang lain.
3. Kita dapat menyimpan dan membaca data pemain dengan cara membuat suatu
file untuk menyimpan data tersebut dan membacanya kemudian.
5.2 Saran
Namun game ini masih jauh dari sempurna. Setelah game berhasil dibuat dan
dijalankan, penulis menyadari beberapa hal yang dapat ditambahkan di dalamnya,
yaitu:
1. Memasukkan story mode agar pemain dapat bermain sambil menjalankan
cerita, dengan tujuan pemain tidak cepat bosan.
2. Memasukkan fitur kostum di mana pemain dapat mengganti warna baju kucing
mereka bahkan merubah modelnya.
3. Membuat beberapa arena lain agar pemain tidak cepat merasa bosan.
54
DAFTAR PUSTAKA
Ardhianto, Eka, Hadikurniawati, Wiwien & Winarno, Edy. 2012. Augmented Reality
Objek 3 Dimensi dengan Perangkat Artoolkit dan Blender. ISSN: 0854-9524.
Damarullah, Wandy, Hamzah, Amir, & Lestari, Uning. 2013. Aplikasi Pengenalan dan
Pembelajaran Bahasa Korea (Hangeul) Berbasis Android. Yogyakarta. ISSN:
2338-6304.
https://docs.unity3d.com/Manual/CreatingScenes.html, diakses pada 14 Mei 2017.
https://docs.unity3d.com/Manual/GameObjects.html, diakses pada 14 Mei 2017.
https://docs.unity3d.com/Manual/UsingComponents.html, diakses pada 14 Mei 2017.
pascal.computer.org/sev_display/index.action, kata kunci: Flow Chart, diakses pada 13
April 2017.
Rifai, Wafda Adita. 2015. Pengembangan Game Edukasi Lingkungan Berbasis
Android. Yogyakarta: 2015.
Safaat, Nazruddin. (2012). Pemrograman Aplikasi Mobile Smartphone dan Tablet PC
Berbasis Android. Bandung: Informatika.
Singkoh, Robert Theophani, Lumenta, Arie S.M., & Tulenan, Virginia. 2016.
Perancangan Game FPS (First Person Shooter) Police Personal Training.
ISSN: 2301-8402.
Sudyatmika, P.A., Crisnapati, P.N., Darmawiguna, I.G.M., & Kesiman, M.W.A. 2014.
Pengembangan Aplikasi Augmented Reality Book Pengenakan Objek Wisata
Taman Ujung Soekasada dan Taman Air Tirta Gangga di Kabupaten
Karangasem. Universitas Pendidikan Ganesha. ISSN 0216-3241.
Syakir, Abid Alfan. 2015. Bahasa Pemrograman C# Berbasis Windows Application
Menggunakan Editor SharpDeveleop 4.4 (Program Kalkulator Sederhana).
Sekolah Tinggi Ilmu Komputer PGRI. Banyuwangi: 2015.
www.blender.org/about/, diakses 2 April 2017.
Zamroni, M.Rosidi, Suryaman, Nizar, & Jalaluddin, Ahmad. 2013. Rancang Bangun
Aplikasi Permainan Untuk Pembelajaran Anak Menggunakan HTML 5. Jurnal
Teknika (Volume 5 Nomor 2). 489.
LAMPIRAN
Aibehavioussmart
using UnityEngine; using System.Collections; using System.Collections.Generic; public class aibehavioursmart: MonoBehaviour { NavMeshAgent nav; GameObject gm; checkpointlister cl; Animator anim; public int i; int oldi; Vector3 desireddest; Vector3 curdest; public float walkspeed; public float runspeed; public float sprintspeed; public float sta; public float stamax; public float idleregen; public float walkregen; public float runregen; public float staconsume; bool allowsprinting; float distance; float bonus; public float bonusmax; positionrecorder pr; public bool hasfinish; racereadsetupatstart readsetup; //GameObject team; // Use this for initialization void Start () { //team = GetComponent<aiteamrecognizer> ().team;
gm = GameObject.Find ("GAMEMASTER"); readsetup=gm.GetComponent<racereadsetupatstart>(); bonusmax = readsetup.dif; nav = GetComponent<NavMeshAgent> (); cl = gm.GetComponent<checkpointlister> (); pr = gm.GetComponent<positionrecorder> (); anim = GetComponent<Animator> (); bonus = Random.Range ((bonusmax * (75/100)), bonusmax); stamax += bonus * 10f; bonus = Random.Range ((bonusmax * (75/100)), bonusmax); walkspeed += bonus; bonus = Random.Range ((bonusmax * (75/100)), bonusmax); runspeed += bonus; bonus = Random.Range ((bonusmax * (75/100)), bonusmax); sprintspeed += bonus; bonus = Random.Range ((bonusmax * (75/100)), bonusmax); idleregen += bonus /10f; bonus = Random.Range ((bonusmax * (75/100)), bonusmax); runregen += bonus/10f; bonus = Random.Range ((bonusmax * (75/100)), bonusmax); walkregen += bonus/10f; sta = stamax; allowsprinting = true; i = 0; newdest (cl.cps [0].transform); } // Update is called once per frame void Update () { //i = team.GetComponent<teammanager> ().teamvariable;
if (nav.velocity == Vector3.zero) { idle (); } if (sta > stamax) { sta = stamax; } else if (sta < 0) { sta = 0; } if (sta == 0) { StartCoroutine ("rest"); } if (nav.remainingDistance < 15) { sprint (); } else { run (); } } void LateUpdate(){ distance = Vector3.Distance (transform.position, curdest); if (transform.position==curdest || distance < 2f) { i++; if (i < cl.cps.Count) { //i++; newdest (cl.cps [i].transform); } else { //nav.Stop (); if (hasfinish == false) { pr.racer.Add (this.gameObject); hasfinish = true; } walk(); i = Random.Range (0, cl.cps.Count); newdest(cl.cps[i].transform); } } /* if (oldi != i) { newdest (cl.cps [i].transform); oldi = i;
} oldi = i; */ } void newdest(Transform target){ float x = Random.Range (0, 1.5f); float z = Random.Range (0, 1.5f); desireddest = new Vector3 (x, 0, z); nav.destination = target.position + desireddest; curdest = nav.destination; nav.Resume (); } void walk(){ anim.SetBool ("walk", true); anim.SetBool ("run", false); anim.SetBool ("sprint", false); nav.speed = walkspeed; if (sta < stamax) { sta += walkregen; } } void run(){ anim.SetBool ("walk", false); anim.SetBool ("run", true); anim.SetBool ("sprint", false); nav.speed = runspeed; if (sta < stamax) { sta += runregen; } } void sprint(){ anim.SetBool ("walk", false); anim.SetBool ("run", false); anim.SetBool ("sprint", true); nav.speed = sprintspeed; sta -= staconsume; } void idle(){ anim.SetBool ("walk", false);
anim.SetBool ("run", false); anim.SetBool ("sprint", false); if (sta < stamax) { sta += idleregen; } } IEnumerator rest(){ walk (); allowsprinting = false; yield return new WaitWhile (() => sta < stamax); allowsprinting = true; } }
Aibehavioursprinter
using UnityEngine; using System.Collections; using System.Collections.Generic; public class aibehavioursprinter : MonoBehaviour { NavMeshAgent nav; GameObject gm; checkpointlister cl; Animator anim; public int i; //int oldi; Vector3 desireddest; Vector3 curdest; public float walkspeed; public float runspeed; public float sprintspeed; public float sta; public float stamax; public float idleregen; public float walkregen; public float runregen; public float staconsume;
bool allowsprinting; float distance; float bonus; public float bonusmax; public bool hasfinish; positionrecorder pr; racereadsetupatstart readsetup; //GameObject team; // Use this for initialization void Start () { //team = GetComponent<aiteamrecognizer> ().team; gm = GameObject.Find ("GAMEMASTER"); readsetup=gm.GetComponent<racereadsetupatstart>(); bonusmax = readsetup.dif; nav = GetComponent<NavMeshAgent> (); cl = gm.GetComponent<checkpointlister> (); pr = gm.GetComponent<positionrecorder> (); anim = GetComponent<Animator> (); bonus = Random.Range ((bonusmax * (75/100)), bonusmax); stamax += bonus * 10f; bonus = Random.Range ((bonusmax * (75/100)), bonusmax); walkspeed += bonus; bonus = Random.Range ((bonusmax * (75/100)), bonusmax); runspeed += bonus; bonus = Random.Range ((bonusmax * (75/100)), bonusmax); sprintspeed += bonus; bonus = Random.Range ((bonusmax * (75/100)), bonusmax); idleregen += bonus /10f; bonus = Random.Range ((bonusmax * (75/100)), bonusmax); runregen += bonus/10f;
bonus = Random.Range ((bonusmax * (75/100)), bonusmax); walkregen += bonus/10f; sta = stamax; allowsprinting = true; i = 0; newdest (cl.cps [0].transform); } // Update is called once per frame void Update () { //i = team.GetComponent<teammanager> ().teamvariable; if (nav.velocity == Vector3.zero) { idle (); } else if (anim.GetBool ("walk") == true && anim.GetBool ("run") == false && anim.GetBool ("sprint") == false) { walk (); } if (sta > stamax) { sta = stamax; } else if (sta < 0) { sta = 0; } if (sta > (0.01 * stamax)) { if (allowsprinting == true) { sprint (); } } else { StartCoroutine ("rest"); } } void LateUpdate(){ distance = Vector3.Distance (transform.position, curdest); if (transform.position==curdest || distance < 2f) { i++; if (i < cl.cps.Count) { //i++;
newdest (cl.cps [i].transform); } else { //nav.Stop (); //idle (); //Destroy (this); if (hasfinish == false) { pr.racer.Add (this.gameObject); hasfinish = true; } walk(); i = Random.Range (0, cl.cps.Count); newdest(cl.cps[i].transform); } } /* if (oldi != i) { newdest (cl.cps [i].transform); oldi = i; } oldi = i; */ } void newdest(Transform target){ float x = Random.Range (0, 1.5f); float z = Random.Range (0, 1.5f); desireddest = new Vector3 (x, 0, z); nav.destination = target.position + desireddest; curdest = nav.destination; nav.Resume (); } void walk(){ anim.SetBool ("walk", true); anim.SetBool ("run", false); anim.SetBool ("sprint", false); nav.speed = walkspeed; if (sta < stamax) { sta += walkregen; } } void run(){ anim.SetBool ("walk", false);
anim.SetBool ("run", true); anim.SetBool ("sprint", false); nav.speed = runspeed; if (sta < stamax) { sta += runregen; } } void sprint(){ anim.SetBool ("walk", false); anim.SetBool ("run", false); anim.SetBool ("sprint", true); nav.speed = sprintspeed; sta -= staconsume; } void idle(){ anim.SetBool ("walk", false); anim.SetBool ("run", false); anim.SetBool ("sprint", false); if (sta < stamax) { sta += idleregen; } } IEnumerator rest(){ walk (); allowsprinting = false; yield return new WaitWhile (() => sta < stamax); allowsprinting = true; sprint(); } }
Aicolorswitch
using UnityEngine; using System.Collections; using System.Collections.Generic; public class aicolorswitch : MonoBehaviour { //public bool isnotrandom;
public GameObject parent; public GameObject gm; //public GameObject team; matlister ml; int i; public Material[] mats; SkinnedMeshRenderer ren; // Use this for initialization void Start () { //team = parent.GetComponent<aiteamrecognizer> ().team; gm = GameObject.Find ("GAMEMASTER"); ml = gm.GetComponent<matlister> (); ren = GetComponent<SkinnedMeshRenderer> (); mats = ren.materials; i = Random.Range (0, ml.colorsfur.Count); mats [0] = ml.colorsfur [i]; i = Random.Range(0,ml.colorsteam.Count); mats [3] = ml.colorsteam[i]; ren.materials = mats; Destroy (this); } // Update is called once per frame void Update () { } }
Aiselector
using UnityEngine; using System.Collections; public class aiselector : MonoBehaviour { int i;
// Use this for initialization void Start () { } // Update is called once per frame void Update () { if (GameObject.Find ("GAMEMASTER").GetComponent<checkpointlister> ().ready == true) { i = Random.Range (1, 3); if (i == 1) { GetComponent<aibehavioursprinter> ().enabled = true; } if (i == 2) { GetComponent<aibehavioursmart> ().enabled = true; } Destroy (this); } } }
Aispawner
using UnityEngine; using System.Collections; public class aispawner : MonoBehaviour { int i=0; public GameObject ai; float xloc; float zloc; float yrot; public int aimax; //teammanager tm; checkpointspawner cs; public GameObject control; public GameObject loading;
public GameObject ready; // Use this for initialization void Start () { //tm = GetComponent<teammanager> (); cs = GetComponent<checkpointspawner> (); } // Update is called once per frame void Update () { if (i < aimax) { xloc = Random.Range (-3, 3); zloc = Random.Range (-3, 3); yrot = Random.Range (0, 360); Vector3 desiredlocation = new Vector3 (xloc, 0, zloc); Quaternion desiredrotation = Quaternion.Euler (0, yrot, 0); Instantiate (ai, desiredlocation, desiredrotation); //tm.teammembers.Add(Instantiate (ai, desiredlocation, desiredrotation) as GameObject); //tm.teammembers [i].GetComponent<aiteamrecognizer> ().team = this.gameObject; //if (tm.includeplayer == true) { // tm.teammembers[i].tag="Ally"; //} i++; } else { control.SetActive (true); loading.SetActive (false); ready.SetActive(true); //cs.enabled = true; Destroy (this); } } }
Bgmchange
using UnityEngine; using System.Collections;
using System.Collections.Generic; public class bgmchange : MonoBehaviour { public List<AudioClip> bgm; int i; GameObject sound; // Use this for initialization void Start () { sound = GameObject.Find ("sound"); if (bgm.Count > 1) { i = Random.Range (0, bgm.Count - 1); } else { i = 0; } sound.GetComponent<AudioSource> ().clip = bgm [i]; sound.GetComponent<AudioSource> ().Play (); } // Update is called once per frame void Update () { } }
Bgmcontrol
using UnityEngine; using System.Collections; public class bgmcontrol : MonoBehaviour { // Use this for initialization void Awake () { DontDestroyOnLoad (this.gameObject); } // Update is called once per frame void Update () { } }
Checkpointcontrol
using UnityEngine; using System.Collections; using System.Collections.Generic; using UnityEngine.UI; public class checkpointcontrol : MonoBehaviour { public bool islast; public GameObject nextcp; //GameObject guide; GameObject gm; checkpointlister cl; positionrecorder pr; public GameObject finish; public string debugtag; //cpcounter cc; // Use this for initialization void Start () { //guide = GameObject.FindGameObjectWithTag ("guide"); gm = GameObject.Find ("GAMEMASTER"); cl = gm.GetComponent<checkpointlister> (); pr = gm.GetComponent<positionrecorder> (); finish = GameObject.Find("Canvas").transform.GetChild(3).gameObject; //cc = GameObject.FindGameObjectWithTag ("cpcounter").GetComponent<cpcounter> (); } // Update is called once per frame void Update () { } void OnTriggerEnter(Collider other){ if (islast == false) { if (other.tag == "Player") { GetComponent<AudioSource> ().Play (); debugtag = other.tag; //GameObject.FindGameObjectWithTag("Player").G
etComponent<PlayerMove> ().team.GetComponent<teammanager> ().teamvariable++; //cl.cps[GameObject.FindGameObjectWithTag("Player").GetComponent<PlayerMove> ().team.GetComponent<teammanager> ().teamvariable].SetActive(true); //cc.curcpi++; nextcp.SetActive (true); //guide.GetComponent<guidecontrol> ().target = cl.cps[GameObject.FindGameObjectWithTag("Player").GetComponent<PlayerMove> ().team.GetComponent<teammanager> ().teamvariable++]; //guide.GetComponent<guidecontrol> ().target = nextcp; this.gameObject.SetActive (false); //Destroy (this.gameObject); } } else { if (other.tag == "Player") { GetComponent<AudioSource> ().Play (); //cc.curcpi++; pr.racer.Add (other.gameObject); //guide.SetActive (false); //int pos = pr.racer.IndexOf (other.gameObject) + 1; finish.SetActive (true); this.gameObject.SetActive (false); } } } }
Closeapp
using UnityEngine; using System.Collections; public class closeapp : MonoBehaviour { // Use this for initialization void Start () {
} // Update is called once per frame void Update () { } void close(){ Application.Quit (); } }
Cooldown
using UnityEngine; using System.Collections; using UnityEngine.UI; public class cooldown : MonoBehaviour { public float cool; public Text timer; // Use this for initialization void Start () { } // Update is called once per frame void Update () { timer.text = cool.ToString (); if (cool > 0) { cool -= Time.deltaTime; } else { this.gameObject.SetActive (false); } } }
Countdowntostart
using UnityEngine; using System.Collections; using UnityEngine.UI; public class countdowntostart : MonoBehaviour { GameObject gm; checkpointlister cl; public Text countdown; // Use this for initialization void Start () { gm = GameObject.Find ("GAMEMASTER"); cl = gm.GetComponent<checkpointlister> (); StartCoroutine ("counterdown"); } // Update is called once per frame void Update () { } IEnumerator counterdown(){ countdown.text = "3"; yield return new WaitForSeconds (1); countdown.text = "2"; yield return new WaitForSeconds (1); countdown.text = "1"; yield return new WaitForSeconds (1); countdown.text = "GO"; cl.ready = true; yield return new WaitForSeconds (1); Destroy (this.gameObject); } }
Cpcounter
using UnityEngine; using System.Collections; using UnityEngine.UI; public class cpcounter : MonoBehaviour {
public Text curcp; public Text totcp; public int curcpi; public int totcpi; // Use this for initialization void Start () { } // Update is called once per frame void LateUpdate () { curcp.text = curcpi.ToString(); } }
Finisher
using UnityEngine; using System.Collections; using System.Collections.Generic; public class finisher : MonoBehaviour { setuprace setup; plyrstat ps; positionrecorder pr; checkpointlister cl; // Use this for initialization void Start () { setup = GameObject.Find ("setup").GetComponent<setuprace> (); ps = GameObject.Find ("plyrstat").GetComponent<plyrstat> (); pr = GameObject.Find ("GAMEMASTER").GetComponent<positionrecorder> (); cl = GameObject.Find ("GAMEMASTER").GetComponent<checkpointlister> (); int i = pr.racer.IndexOf (GameObject.FindGameObjectWithTag("Player")); ps.exp += ((setup.aicount + (cl.cps.Count*10)) * setup
.dif)/(i + 1); ps.save (); } // Update is called once per frame void Update () { } }
Followplayer
using UnityEngine; using System.Collections; public class followplayer : MonoBehaviour { public GameObject target; Vector3 desiredloc; float speed=0.5f; // Use this for initialization void Start () { //player = GameObject.FindGameObjectWithTag ("Player"); } // Update is called once per frame void Update () { } void LateUpdate(){ desiredloc = target.transform.position; transform.position = Vector3.Slerp (transform.position, desiredloc, speed); } }
Leveler
using UnityEngine; using System.Collections; using UnityEngine.UI; public class leveler : MonoBehaviour { public Text needed; public Text exp; public Text lvl; public Text sp; public float expf; public float neededf; public int lvli; public int spi; // Use this for initialization void Start () { expf = float.Parse (exp.text); neededf = float.Parse (needed.text); lvli = int.Parse (lvl.text); spi = int.Parse (sp.text); } // Update is called once per frame void LateUpdate () { } void lvlup(){ if (expf >= neededf) { expf -= neededf; lvli++; neededf = 100 * lvli; spi++; exp.text = expf.ToString(); needed.text = neededf.ToString (); lvl.text = lvli.ToString(); sp.text = spi.ToString(); expf = float.Parse (exp.text); neededf = float.Parse (needed.text); lvli = int.Parse (lvl.text); spi = int.Parse (sp.text); } } }
Matlister
using UnityEngine; using System.Collections; using System.Collections.Generic; public class matlister : MonoBehaviour { public List<Material>colorsfur; public List<Material>colorsteam; // Use this for initialization void Start () { } // Update is called once per frame void Update () { } }
Neededexp
using UnityEngine; using System.Collections; using UnityEngine.UI; public class neededexp : MonoBehaviour { public Text level; public Text needed; int lvl; int expneed; // Use this for initialization void Start () { } // Update is called once per frame void LateUpdate () { lvl = int.Parse (level.text);
expneed = 100 * lvl; needed.text = expneed.ToString(); } }
Noisemaker
using UnityEngine; using System.Collections; public class noisemaker : MonoBehaviour { public AudioClip audi; AudioSource auso; // Use this for initialization void Start () { auso = GetComponent<AudioSource> (); } // Update is called once per frame void Update () { } void noise(){ auso.clip = audi; auso.Play (); //auso.clip = null; } }
PlayerMove
using UnityEngine; using System.Collections; using UnityStandardAssets.CrossPlatformInput; using UnityEngine.UI; public class PlayerMoveSkripsiVersion : MonoBehaviour {
public GameObject team; public Transform cam; public Vector3 camfor; public Vector3 move; public Animator anim; public float movingturnspeed=360; public float stationaryturnspeed=180; public float forwardamount; public float turnamount; public float speed; //public CharacterController ccon; NavMeshAgent nav; public float walkspeed; public float runspeed; public float sprintspeed; public float sta; public float staregen; public float stamax; public float staregenidle; public float staregenwalk; public float staregenrun; public float staconsume; bool allowstaregen =true; public float vit; public float vitregen; public float vitmax; public float vitregenidle; public float vitregenwalk; public float vitregenrun; public float vitconsume; bool allowvitregen =true; public Slider staslide; public Slider vitslide; public Slider tapslide;
public bool tired = false; public float tap; checkpointlister cl; public int i; public float distance; Vector3 curdest; // Use this for initialization void Start () { //team = GameObject.Find ("team (Clone)"); anim = this.GetComponent<Animator> (); //ccon = this.GetComponent<CharacterController> (); nav=GetComponent<NavMeshAgent>(); //speed = runspeed; staslide.maxValue = stamax; vitslide.maxValue = vitmax; sta = stamax; vit = vitmax; cl = GameObject.Find ("GAMEMASTER").GetComponent<checkpointlister> (); curdest = cl.cps [0].transform.position; nav.destination = curdest; speed = 0; tap = 0; } // Update is called once per frame /*void FixedUpdate () { float h = CrossPlatformInputManager.GetAxis ("Horizontal"); float v = CrossPlatformInputManager.GetAxis ("Vertical"); camfor = Vector3.Scale (cam.forward, new Vector3 (1, 0, 1)).normalized; move = v * camfor + h * cam.right; if (move.magnitude > 1f) move.Normalize(); move = transform.InverseTransformDirection(move); turnamount = Mathf.Atan2 (move.x, move.z); forwardamount = move.z; Vector3 forward = transform.TransformDirection (Vector
3.forward); //ccon.SimpleMove (forward * (forwardamount * speed)); float turnSpeed = Mathf.Lerp(stationaryturnspeed, movingturnspeed, forwardamount); transform.Rotate(0, turnamount * turnSpeed * Time.deltaTime, 0); anim.SetFloat("Forward", forwardamount, 0.1f, Time.deltaTime); }*/ void Update(){ distance = Vector3.Distance (transform.position, curdest); changedest (); tap -= 0.25f; nav.speed = speed; if (tap <= 0) { speed = 0; tap = 0; } else if (tap < 10f) { walk (); } else if (tap < 20f) { if (tired == false) { run (); } } else { if (tired == false) { sprint (); } } if (tap > 21f) { tap = 21f; } tapslide.value = tap; if (allowstaregen == true && sta < stamax) { sta += staregen;
} if (allowvitregen == true && vit < vitmax) { vit += vitregen; } if (nav.speed <= 0) { anim.SetFloat ("Forward", 0); staregen = staregenidle; allowstaregen = true; vitregen = vitregenidle; allowvitregen = true; } else if (anim.GetBool ("Walking") == true && anim.GetBool ("Sprinting") == false) { allowstaregen = true; staregen = staregenwalk; allowvitregen = true; vitregen = vitregenwalk; } else if (anim.GetBool ("Walking") == false && anim.GetBool ("Sprinting") == false) { staregen = staregenrun; allowstaregen = true; allowvitregen = true; vitregen = vitregenrun; } else if (anim.GetBool ("Walking") == false && anim.GetBool ("Sprinting") == true) { if (sta > 0) { allowstaregen = false; vitregen = vitregenrun; sta -= staconsume; } else { sta = 0; allowvitregen = false; vit -= vitconsume; } } if (vit <= 0) { tired = true; } else if (vit >= vitmax) { tired = false; }
if (tired == true) { walk (); } if (sta < 0) { sta = 0; } if (vit < 0) { vit = 0; } } void LateUpdate(){ staslide.value = sta; vitslide.value = vit; if (sta > stamax) { sta = stamax; } if (vit > vitmax) { vit = vitmax; } } void walk(){ anim.SetBool ("Walking", true); anim.SetBool ("Sprinting", false); anim.SetFloat ("Forward", 1f); speed = walkspeed; } void sprint(){ anim.SetBool ("Walking", false); anim.SetBool ("Sprinting", true); anim.SetFloat ("Forward", 1f); vitregen = vitregenrun; speed = sprintspeed; } void run(){ anim.SetBool ("Walking", false); anim.SetBool ("Sprinting", false);
anim.SetFloat ("Forward", 1f); speed = runspeed; } void tapped(){ tap += 1f; } void changedest(){ if (distance < 2f) { i++; if (i < cl.cps.Count) { curdest = cl.cps [i].transform.position; } else { i = 0; curdest = cl.cps [i].transform.position; } nav.destination = curdest; } } }
Playerskill
using UnityEngine; using System.Collections; public class Playerskill : MonoBehaviour { PlayerMoveSkripsiVersion pm; public GameObject cooldownls; public GameObject cooldownc; public GameObject cooldownb; // Use this for initialization void Start () { pm = GetComponent<PlayerMoveSkripsiVersion> (); } // Update is called once per frame void Update () {
} IEnumerator booster(){ cooldownb.GetComponent<cooldown> ().cool = 10; cooldownb.SetActive (true); float sta = pm.staconsume; float vit = pm.vitconsume; pm.tap = 21; pm.staconsume = 0; pm.vitconsume = 0; yield return new WaitForSeconds (5); pm.staconsume = sta; pm.vitconsume = vit; } IEnumerator concentrator(){ cooldownc.GetComponent<cooldown> ().cool = 30; cooldownc.SetActive (true); float staidle = pm.staregenidle; float stawalk = pm.staregenwalk; float starun = pm.staregenrun; float vitidle = pm.vitregenidle; float vitwalk = pm.vitregenwalk; float vitrun = pm.vitregenrun; pm.staregenidle = staidle * 5; pm.staregenwalk = stawalk * 5; pm.staregenrun = starun * 5; pm.vitregenidle = vitidle * 5; pm.vitregenwalk = vitwalk * 5; pm.vitregenrun = vitrun * 5; yield return new WaitForSeconds (5); pm.staregenidle = staidle; pm.staregenwalk = stawalk; pm.staregenrun = starun; pm.vitregenidle = vitidle; pm.vitregenwalk = vitwalk; pm.vitregenrun = vitrun; } IEnumerator laster(){ cooldownls.GetComponent<cooldown> ().cool = 60; cooldownls.SetActive (true); float speed = pm.sprintspeed; pm.sprintspeed = speed * 2;
yield return new WaitForSeconds (5); pm.sprintspeed = speed; } void boost(){ StartCoroutine ("booster"); } void con(){ StartCoroutine ("concentrator"); } void spurt(){ StartCoroutine ("laster"); } }
Plyrstat
using UnityEngine; using System.Collections; using System; using System.Runtime.Serialization.Formatters.Binary; using System.IO; public class plyrstat : MonoBehaviour { public float exp; public int lvl; public int sp; public int ws; public int rs; public int ss; public int sm; public int sr; public int sc; public int vm; public int vr; public int vc;
// Use this for initialization void Awake () { DontDestroyOnLoad (this.gameObject); } // Update is called once per frame void Update () { } public void save(){ BinaryFormatter bf = new BinaryFormatter (); FileStream file = File.Create (Application.persistentDataPath + "/plyrstat.nya"); playerstatus stats = new playerstatus (); stats.exp = exp; stats.lvl = lvl; stats.sp = sp; stats.ws = ws; stats.rs = rs; stats.ss = ss; stats.sm = sm; stats.sr = sr; stats.sc = sc; stats.vm = vm; stats.vr = vr; stats.vc = vc; bf.Serialize (file, stats); file.Close(); } public void load(){ if (File.Exists (Application.persistentDataPath + "/plyrstat.nya")) { BinaryFormatter bf = new BinaryFormatter (); FileStream file = File.Open (Application.persistentDataPath + "/plyrstat.nya", FileMode.Open); playerstatus stats = (playerstatus) bf.Deserialize (file); file.Close(); exp = stats.exp;
lvl = stats.lvl; sp = stats.sp; ws = stats.ws; rs = stats.rs; ss = stats.ss; sm = stats.sm; sr = stats.sr; sc = stats.sc; vm = stats.vm; vr = stats.vr; vc = stats.vc; } } } [Serializable] class playerstatus{ public float exp; public int lvl; public int sp; public int ws; public int rs; public int ss; public int sm; public int sr; public int sc; public int vm; public int vr; public int vc; }
Poisitionrecorder
using UnityEngine; using System.Collections; using System.Collections.Generic; public class positionrecorder : MonoBehaviour { public List<GameObject> racer;
// Use this for initialization void Start () { } // Update is called once per frame void Update () { } }
Racereadsetupatstart
using UnityEngine; using System.Collections; public class racereadsetupatstart : MonoBehaviour { public setuprace sr; aispawner ais; checkpointspawner cs; buildingspawner bs; public int dif; checkpointlister cl; // Use this for initialization void Start () { sr = GameObject.Find ("setup").GetComponent<setuprace> (); ais = GetComponent<aispawner> (); cs = GetComponent<checkpointspawner> (); bs = GetComponent<buildingspawner> (); cl = GetComponent<checkpointlister> (); ais.aimax = sr.aicount; cs.cpmax = sr.cpcount; bs.buildingmax = sr.tercount; if (sr.dist == "100 meter") { cl.cps [1].gameObject.SetActive (true); cl.cps.RemoveRange (2, 6); } else if (sr.dist == "400 meter") { cl.cps [4].gameObject.SetActive (true); cl.cps.RemoveRange (5, 3);
} else if (sr.dist == "700 meter") { cl.cps [7].gameObject.SetActive (true); } dif = sr.dif; ais.enabled = true; } // Update is called once per frame void Update () { } }
Readplyrstatforplayer
using UnityEngine; using System.Collections; public class readplyrstatforplayer : MonoBehaviour { public plyrstat ps; public PlayerMoveSkripsiVersion pm; public float ws; public float rs; public float ss; public float sm; public float sridle; public float srwalk; public float srrun; public float sc; public float vm; public float vridle; public float vrwalk; public float vrrun; public float vc; // Use this for initialization void Start () { ps = GameObject.Find ("plyrstat").GetComponent<plyrstat> (); pm = GetComponent<PlayerMoveSkripsiVersion> (); pm.walkspeed = ws + ps.ws /10f;
pm.runspeed = rs + ps.rs/10f; pm.sprintspeed = ss + ps.ss/10f; pm.stamax = sm + ps.sm*10f; pm.staregenidle = sridle + ps.sr/10f; pm.staregenwalk = srwalk + ps.sr/20f; pm.staregenrun = srrun + ps.sr / 30f; pm.staconsume = sc - ps.vc / 100f; pm.vitmax = vm + ps.vm * 5f; pm.vitregenidle = vridle + ps.vr / 10f; pm.vitregenwalk = vrwalk + ps.vr / 20f; pm.vitregenrun = vrrun + ps.vr / 30f; pm.vitconsume = vc - ps.vc / 100f; //pm.speed = pm.runspeed; } // Update is called once per frame void Update () { } }
Readplyrstatfortexts
using UnityEngine; using System.Collections; using UnityEngine.UI; public class readplyrstatfortexts : MonoBehaviour { plyrstat ps; public Text exp; public Text lvl; public Text sp; public Text ws; public Text rs; public Text ss; public Text sm; public Text sr; public Text sc; public Text vm; public Text vr; public Text vc;
public Text needed; // Use this for initialization void Start () { ps = GameObject.Find ("plyrstat").GetComponent<plyrstat> (); exp.text = ps.exp.ToString (); lvl.text = ps.lvl.ToString (); sp.text = ps.sp.ToString (); ws.text = ps.ws.ToString (); rs.text = ps.rs.ToString (); ss.text = ps.ss.ToString (); sm.text = ps.sm.ToString (); sr.text = ps.sr.ToString (); sc.text = ps.sc.ToString (); vm.text = ps.vm.ToString (); vr.text = ps.vr.ToString (); vc.text = ps.vc.ToString (); needed.text = (ps.lvl * 100).ToString (); } // Update is called once per frame void Update () { } void back(){ ps.exp = float.Parse (exp.text); ps.lvl = int.Parse (lvl.text); ps.sp = int.Parse (sp.text); ps.ws = int.Parse (ws.text); ps.rs = int.Parse (rs.text); ps.ss = int.Parse (ss.text); ps.sm = int.Parse (sm.text); ps.sr = int.Parse (sr.text); ps.sc = int.Parse (sc.text); ps.vm = int.Parse (vm.text); ps.vr = int.Parse (vr.text); ps.vc = int.Parse (vc.text); //plyrstat ps = GameObject.Find ("plyrstat").GetComponent<plyrstat> (); ps.save (); Application.LoadLevel (1);
} }
Restart
using UnityEngine; using System.Collections; public class restart : MonoBehaviour { // Use this for initialization void Start () { } // Update is called once per frame void Update () { } void clicked(){ Application.LoadLevel (Application.loadedLevel); } }
Scenechanger
using UnityEngine; using System.Collections; public class scenechanger : MonoBehaviour { public int i; // Use this for initialization void Start () { } // Update is called once per frame void Update () {
} void change(){ Application.LoadLevel (i); } }
Setuprace
using UnityEngine; using System.Collections; public class setuprace : MonoBehaviour { public int cpcount; public int aicount; public int tercount; public int dif; public string dist; // Use this for initialization void Start () { } // Update is called once per frame void Update () { } void Awake(){ DontDestroyOnLoad (this.gameObject); } }
Startrace
using UnityEngine; using System.Collections; using UnityEngine.UI;
public class startrace : MonoBehaviour { public Text cpinput; public Text aiinput; public Text terinput; public Text dif; public Dropdown dist; public int cpcount; public int aicount; public int tercount; public int diflvl; GameObject setup; setuprace sr; public int raceindex; // Use this for initialization void Start () { setup = GameObject.Find ("setup"); sr = setup.GetComponent<setuprace> (); } // Update is called once per frame void Update () { } void strt(){ if (cpinput.text != "") { cpcount = int.Parse (cpinput.text); } else { cpcount = 0; } if (aiinput.text != "") { aicount = int.Parse (aiinput.text); } else { aicount = 0; } if (terinput.text != "") { tercount = int.Parse (terinput.text); } else { tercount = 0;
} if (dif.text != "") { diflvl = int.Parse (dif.text); } else { diflvl = 0; } if (cpcount <= 0) { cpcount = 2; } if (aicount <= 0) { aicount = 5; } if (tercount <= 0) { tercount = 100; } if (diflvl <= 0) { diflvl = 1; } sr.cpcount = cpcount; sr.aicount = aicount; sr.tercount = tercount; sr.dif = diflvl; sr.dist = dist.captionText.text; Application.LoadLevel (raceindex); } }
Startthegame
using UnityEngine; using System.Collections; public class startthegame : MonoBehaviour { // Use this for initialization void Start () {
plyrstat stat = GameObject.Find ("plyrstat").GetComponent<plyrstat> (); stat.load (); Application.LoadLevel (1); } // Update is called once per frame void Update () { } }
Statmin
using UnityEngine; using System.Collections; using UnityEngine.UI; public class statmin : MonoBehaviour { public Text target; public Text sp; int spi; int targeti; // Use this for initialization void Start () { } // Update is called once per frame void Update () { } void stat(){ spi = int.Parse (sp.text); targeti = int.Parse (target.text); if (targeti > 0) { targeti--; spi++; sp.text = spi.ToString (); target.text = targeti.ToString ();
} } }
Statplus
using UnityEngine; using System.Collections; using UnityEngine.UI; public class statplus : MonoBehaviour { public Text target; public Text sp; public int spi; public int targeti; // Use this for initialization void Start () { } // Update is called once per frame void Update () { } void stat(){ spi = int.Parse (sp.text); targeti = int.Parse (target.text); if (spi > 0) { targeti++; spi--; sp.text = spi.ToString (); target.text = targeti.ToString (); } } }
top related