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 (); } } }