JUDUL

DASAR-DASAR PEMROGRAMAN GIM BERORIENTASI

OBJEK DENGAN CSHARP DAN UNITY

BASICS OF OBJECT-ORIENTED GAME

PROGRAMMING WITH CSHARP AND UNITY

Oleh

Reynaldy Sentosa

Indonesia

10 April 2024
 DAFTAR ISI

JUDUL .......................................................................................................................... i

DAFTAR ISI ................................................................................................................ ii

TINJAUAN PUSTAKA ............................................................................................... 1

1. C# ......................................................................................................................... 1

1.1. Variabel ......................................................................................................... 1

1.2. Ekspresi dan Operator ................................................................................... 1

1.3. Pernyataan Kondisional ................................................................................ 2

1.4. Perulangan ..................................................................................................... 2

1.5. Larik .............................................................................................................. 3

1.6. Metode .......................................................................................................... 3

1.7. Kelas dan Objek ............................................................................................ 4

1.8. Lebih Lanjut tentang Kelas ........................................................................... 5

1.9. Struktur Data ................................................................................................. 6

1.10. Kamus ......................................................................................................... 8

1.11. Pemrograman Berorientasi Objek ............................................................... 8

1.12. Ekspresi Lambda ....................................................................................... 11

2. Prinsip SOLID .................................................................................................... 12

2.1. Tanggung Jawab Tunggal ............................................................................ 12

2.2. Buka-Tutup.................................................................................................. 13

2.3. Substitusi Liskov ......................................................................................... 13

2.4. Segregasi Antarmuka .................................................................................. 13

2.5. Inversi Dependensi ...................................................................................... 14

3. Pola Desain......................................................................................................... 14

3.1. Factory......................................................................................................... 15

3.2. Object Pool .................................................................................................. 16

ii
 3.3. Singleton ..................................................................................................... 16

3.4. Command .................................................................................................... 17

3.5. State ............................................................................................................. 18

3.6. Observer ...................................................................................................... 18

3.7. Model-View-Presenter ................................................................................ 19

DAFTAR PUSTAKA ................................................................................................. 21

iii
iv
 TINJAUAN PUSTAKA
1. C#
1.1. Variabel
Variabel merupakan sebuah tempat dalam RAM (atau Memori Akses Acak)
komputer untuk menyimpan dan memproses data masukan yang kerap berubah atau
bervariasi selama berjalannya suatu program. Karakteristik variabel terdiri dari nama,
nilai, dan tipe data. Nama variabel harus unik karena berperan sebagai identitas memori
dan identitas bertujuan. Nama variabel disebut identitas memori karena merujuk ke
sebuah alamat memori yang membedakannya dengan alamat memori lainnya dalam
memori stack. Sebaliknya, nama variabel disebut identitas bertujuan karena
melambangkan kegunaannya atau manfaatnya saat diakses dalam kode program
(Nakov, 2013, hal. 111 dan 123-126).

Tipe data variabel dapat dibedakan antara tipe data primitif (atau tipe nilai) dan
tipe (data) referensi. Tipe nilai terdiri dari bool (atau benar-salah), char (atau karakter),
float (atau bilangan desimal), int (atau bilangan bulat), dan sebagainya. Sebaliknya, tipe
referensi terdiri dari array/larik (atau sekumpulan variabel), class/kelas (atau cetakan
objek), interface/antarmuka (atau kelas abstrak murni), string (atau sekumpulan
karakter), dan lain-lain. Variabel dengan tipe nilai bersifat primitif/statis karena
menyimpan nilainya secara langsung dalam memori stack, sedangkan variabel dengan
tipe referensi bersifat dinamis karena menggunakan memori stack untuk menyimpan
alamat yang menunjukkan lokasi penyimpanan nilainya dalam memori heap. Itulah
mengapa variabel bertipe nilai harus memiliki literal (atau nilai tertentu) saat
dideklarasikan (atau didaftarkan dalam program), sedangkan variabel bertipe referensi
dapat bernilai null saat dideklarasikan (Nakov, 2013, hal. 128-131).

1.2. Ekspresi dan Operator

Ekspresi merupakan sebuah runtunan yang terdiri dari operan dan operator.
Dalam hal ini, operan dapat berupa literal atau variabel. Sebaliknya, operator
merupakan sebuah simbol atau tanda dengan hak/prioritas yang dapat digunakan untuk
melakukan sebuah proses atau tindakan dari suatu operan sebagai masukan ke operan
lain sebagai keluarannya. Operator dapat dibedakan antara jumlah argumennya dan

1
2

kategorinya. Berdasarkan jumlah argumennya, operator dapat dibedakan antara

operator uner (dengan satu operan), operator biner (dengan dua operan), dan operator
terner (dengan tiga operan). Berdasarkan kategorinya, operator dapat dibedakan antara
operator aritmetis, operator bitwise, operator konversi, operator logis, operator
penugasan, operator perbandingan, dan operator lainnya (Nakov, 2013, hal. 139-141
dan 158).

1.3. Pernyataan Kondisional

Pernyataan kondisional merupakan sebuah kendali yang digunakan untuk
mengatur pengeksekusian seruntun perintah atau kode program berdasarkan kondisi
tertentu. Pernyataan kondisional terdiri dari pernyataan if, pernyataan if-else,
pernyataan if bersarang, dan pernyataan switch-case. Jika sebuah pernyataan
kondisional berupa switch-case, maka ia tidak dapat menggunakan ekspresi boolean.
Ekspresi boolean dapat terdiri dari operator kondisional, operator logis, ataupun
operator perbandingan (Nakov, 2013, hal. 150, 195, 199-204, dan 206).

1.4. Perulangan
Perulangan merupakan sebuah kendali yang digunakan untuk mengulang
pengeksekusian seruntun perintah atau kode program. Perulangan terdiri dari
perulangan kondisional dan perulangan foreach. Perulangan kondisional merupakan
sebuah perulangan yang terus dilakukan hingga memenuhi kondisi (atau hasil ekspresi
boolean) tertentu secara benar/tepat. Perulangan kondisional terdiri dari perulangan
while, perulangan do-while, perulangan for, dan perulangan bersarang. Perulangan
foreach merupakan perluasan dari perulangan for yang digunakan untuk menelusuri
setiap elemen (tanpa perlu mengetahui indeksnya) dalam (sebuah) koleksi. Dalam
istilah perulangan, terdapat operator break dan operator continue. Operator break
digunakan untuk menghentikan sebuah perulangan secara langsung, sedangkan
operator continue digunakan untuk melewati sebuah iterasi tanpa menghentikan
perulangan (Nakov, 2013, hal. 211, 215-216, 221, dan 225-226).
 3

1.5. Larik
Larik merupakan sebuah variabel bertipe referensi yang objeknya dapat
berisikan sekumpulan elemen (berupa variabel) yang bertipe data sama dan memiliki
indeks (atau urutan angka) yang berjangkau dari nol ke panjangnya (atau jumlahnya)
dikurangi satu. Larik menggunakan kata kunci new untuk mengalokasikan ruang bagi
seluruh elemennya ke dalam memori heap. Larik menugaskan nilai (variabel) bawaan
kepada setiap elemen yang nilainya tidak dilakukan inisialisasi (atau ditugaskan
pertama kali) setelah dideklarasikan. Larik memperlakukan setiap elemennya seperti
variabel yang nilainya dapat diakses (untuk dibaca ataupun diubah) melalui indeksnya.
Larik dapat menyebabkan eror (berupa pengecualian) kalau (salah satu) elemennya
diakses secara tidak valid, misalnya karena indeksnya berada di luar jangkauan. Larik
umumnya bekerja bersama (atau di dalam) perulangan for saat beberapa (atau setiap)
nilai elemennya hendak diubah, juga biasanya bekerja bersama perulangan foreach saat
beberapa nilai elemennya hanya dibaca (Nakov, 2013, hal. 235-240 dan 244-246).

1.6. Metode
Metode merupakan penerapan konsep “membagi dan menaklukan” Romawi
Kuno yang tidak terhindarkan karena dapat membantu pemisahan dari suatu
masalah/tugas (dalam hal ini adalah program) besar/kompleks ke beberapa
bagian/masalah kecil. Metode menawarkan penggunaan kembali sebuah implementasi
atau blok kode (antara tanda kurung kurawal buka dan tanda kurung kurawal tutup)
dalam tubuhnya untuk menyusun sebuah program agar lebih mudah dibaca/dipahami
oleh (rekan) pengembang lain dan menghindari (kebingungan akibat) adanya
duplikasi/pengulangan. Metode terdiri dari tipe (data) kembalian dan khas/spesifikasi
yang terdiri dari nama dan parameter (atau informasi tambahan yang berupa variabel)
untuk membedakannya dengan metode lain. Sekumpulan metode dengan kesamaan
nama dan perbedaan jumlah parameter atau perbedaan (urutan) penempatan parameter
disebut method overloading atau pembebanan metode secara berlebihan (Nakov, 2013,
hal. 293-297, 303-304, dan 321).

Argumen merupakan operan yang (nilainya) diteruskan (dengan cara disalin

atau ditetapkan) kepada parameter saat memanggil suatu metode. Argumen bertipe nilai
tidak (akan) mengubah (setiap) nilai( elemen)nya setelah diteruskan karena hanya
4

menyalin nilainya. Sebaliknya, argumen bertipe referensi dapat mengubah nilainya

setelah diteruskan karena menyalin alamat (dari variabelnya di dalam memori stack)
yang merujuk ke objeknya (di dalam memori heap). Argumen bernama memungkinkan
agar setiap penugasan nilai parameter (dalam suatu pemanggilan metode) terbebaskan
urutannya karena dilakukan berdasarkan nama parameternya. Parameter opsional
memungkinkan agar setiap argumen dapat diabaikan karena ia sudah ditugaskan sebuah
nilai bawaan saat metodenya didefinisikan (Nakov, 2013, hal. 307-310 dan 319).

Dalam istilah metode, terdapat variabel lokal, operator return dan tipe (data)
void. Variabel (dengan jangkauan/skop) lokal merupakan sebuah variabel yang hanya
dapat dideklarasikan dan hanya dapat digunakan dalam sebuah implementasi metode.
Operator return digunakan untuk menghentikan sebuah metode secara langsung dan
mengembalikan sebuah nilai (bertipe) kembalian dari metode tersebut ke metode lain
yang memanggilnya. Tipe void menandakan bahwa sebuah metode tidak
mengembalikan nilai apa pun (Nakov, 2013, hal. 300-301 dan 329-330).

1.7. Kelas dan Objek

Kelas dan objek merupakan konsep dasar untuk (paradigma) OOP (atau
Pemrograman Berorientasi Objek). Objek dalam (pemrograman) perangkat lunak
menggambarkan objek dunia nyata (seperti benda mati atau makhluk hidup) ataupun
konsep pemrograman abstrak (seperti struktur data) yang dapat dibedakan berdasarkan
keadaannya (atau ciri-cirinya) dan berdasarkan perilakunya. Objek dalam OOP
menggabungkan (anggota) data (sebagai keadaannya) dan metode (sebagai
perilakunya) menjadi satu kesatuan tubuh (Nakov, 2013, hal. 385-386).

Kelas merupakan sebuah blok bangunan yang tidak terpisahkan dalam OOP
karena (berperan sebagai cetak biru atau struktur yang) menggambarkan suatu objek
(yang berperan sebagai contohnya/turunannya). Kelas dapat terdiri dari (beberapa
elemen, seperti) atribut/bidang sebagai (variabel) datanya, properti (sebagai perluasan
fungsionalitas terhadap atributnya), ataupun metode (untuk memanipulasi datanya)
(Nakov, 2013, hal. 386-388).

Dalam istilah kelas dan objek, terdapat operator titik, konstruktor, dan anggota
statis. Operator titik digunakan untuk mengakses (sebuah) elemen kelas dari (sebuah)
objek di luar implementasi metode yang berada di dalam kelas yang sama. Konstruktor
 5

merupakan sebuah metode khusus tanpa nama dan tanpa nilai kembalian yang langsung
dipanggil saat (program) membuat (sebuah) objek dari suatu kelas. Anggota statis
merupakan elemen kelas yang tidak mewakili (atau tidak dimiliki oleh) objeknya, tetapi
hanya mewakili kelas itu sendiri (Nakov, 2013, hal. 393-394 dan 396-397).

1.8. Lebih Lanjut tentang Kelas

Dalam istilah kelas, terdapat kata kunci this, pengubah (dan tingkat) akses,
konstanta, properti, struktur, enumerasi, dan generik. Kata kunci this berperan sebagai
referensi objek saat mengakses elemen di dalam kelasnya dan sebagai prioritas yang
digunakan untuk membedakan antara (nama) elemen kelas milik objek dan (nama)
parameter metode (Nakov, 2013, hal. 511-512, 543-545, dan 547).

Pengubah akses terdiri dari tingkatan publik dan tingkatan privat. Tingkat akses
publik (yang dinyatakan dengan kata kunci public) merupakan tingkatan yang tidak
terbatas karena memungkinkan agar (sebuah) elemen kelas dapat diakses di seluruh
kelas lainnya. Sebaliknya, tingkat akses privat (yang dinyatakan dengan kata kunci
private) merupakan tingkatan yang paling ketat karena membatasi agar (suatu) elemen
kelas hanya dapat diakses di dalam kelas itu sendiri (Nakov, 2013, hal. 508-509).

Konstanta merupakan atribut kelas yang nilainya hanya dapat ditugaskan saat
ia dideklarasikan (dengan kata kunci const atau kata kunci readonly). Jika konstanta
dideklarasikan dengan kata kunci const, maka sifatnya mirip dengan sifat anggota statis.
Jika konstanta dideklarasikan dengan kata kunci readonly, maka inisialisasi nilainya
dapat dilakukan di dalam konstruktor (Nakov, 2013, hal. 516-517).

Properti merupakan pencampuran elemen kelas antara atribut dan metode yang
bertujuan untuk menjamin enkapsulasi. Properti mirip atribut karena memiliki nilai dan
tipe data, juga mirip metode karena dapat memiliki (atau menjalankan) beberapa
metode pengakses khusus (dalam mencapai tujuannya). Properti dalam menjamin
enkapsulasi berarti memvalidasi ataupun mengizinkan (atau menentukan boleh atau
tidaknya) pembacaan ataupun pengubahan data (dari nilainya atau nilai atribut lain yang
diwakilkan) di dalam kelas lainnya. Metode pengakses khusus properti dapat dibedakan
antara getter (yang didefinisikan dengan kata kunci get untuk membaca data) dan setter
(yang didefinisikan dengan kata kunci set untuk mengubah data) (Nakov, 2013, hal.
549-550 dan 555-558).
6

Struktur (atau struct) merupakan (pengimplementasian) kelas yang (elemen-

elemennya pun sebaiknya) bertipe nilai. Enumerasi/Pencacahan (atau enum)
merupakan struktur yang (elemennya) hanya terdiri dari konstanta. Enumerasi hanya
dapat ditugaskan nilai( variabel)nya dari pengambilan (salah satu) nilai konstanta yang
tercantum dalam pendeklarasiannya. Enumerasi hanya ditentukan atau menentukan
(setiap) nilai konstantanya dengan bilangan bulat, yaitu penambahan nilai satu terhadap
nilai konstanta sebelumnya, atau nol (kalau konstanta berada di urutan pertama dan
tidak ditentukan nilainya). Enumerasi (umumnya) dapat digunakan untuk
meningkatkan keamanan dan kesederhanaan (atau kemudahan membaca) dalam (suatu)
pernyataan switch-case (Nakov, 2013, hal. 584-589).

Generik merupakan parameter kelas yang bersifat misterius karena dapat

mewakili (sebuah) tipe data apa pun. Generik awalnya dideklarasikan di sebelah kanan
nama kelas dengan tanda lebih kecil, beberapa pengganti yang namanya (atau biasanya
hanya berupa T) harus unik, dan tanda lebih besar. Generik selanjutnya dapat
dideklarasikan sebagai pengganti tipe data elemen kelas, termasuk parameter metode
(generik yang dideklarasikan antara nama dan tanda kurung buka), kecuali konstruktor
dan properti. Generik menggunakan konstruk default untuk mengembalikan nilai
bawaan tipe data tertentu. Generik dapat digunakan untuk meningkatkan fleksibilitas
atau kinerja pemrograman karena memungkinkan kode program agar dapat digunakan
kembali. Generik juga dapat meningkatkan keamanan pemrograman meskipun dapat
menyulitkan (rekan) pemrogram lainnya (Nakov, 2013, hal. 599-602 dan 604-609).

1.9. Struktur Data

Struktur data bukanlah struktur (atau struct), melainkan ialah sekumpulan objek
(atau elemen) yang dapat diproses dengan cara ditambah, dihapus, diurutkan, dan
sebagainya. Struktur data yang (terpilih dan) digunakan pada kasus yang tepat dapat
menghemat (penulisan) kode program, memori program, dan waktu eksekusi program.
Struktur data dapat dibedakan antara struktur data linier, struktur data kamus, dan
struktur data lainnya. Struktur data yang paling umum digunakan ialah struktur data
linier (atau lis) yang menggambarkan berbagai baris(an) atau berbagai deret di dunia
nyata secara abstrak dan terdiri dari lis, tumpukan, dan struktur data linier lainnya
(Nakov, 2013, hal. 641-642).
 7

Lis (atau daftar) merupakan sebaris elemen yang saling berurutan. Lis sama
seperti larik, yaitu memiliki panjang (yang dinyatakan dengan properti Count). Lis
dapat menjalankan beberapa metode, seperti Add (untuk menambahkan sebuah elemen
baru yang diposisikan setelah indeks elemen terakhir), Insert (untuk menambahkan
sebuah elemen baru di indeks tertentu), Clear (untuk menghapus semua elemen),
Contains (untuk memeriksa ada atau tidaknya suatu elemen), Remove (untuk
menghapus sebuah elemen tertentu), RemoveAt (untuk menghapus sebuah elemen di
indeks tertentu), IndexOf (untuk mengembalikan indeks elemen tertentu), dan this
(untuk mengakses sebuah elemen di indeks tertentu) (Nakov, 2013, hal. 642-643 dan
655-656).

Koleksi generik merupakan struktur data yang menjamin kesamaan tipe data
bagi setiap elemennya. Koleksi generik bertujuan untuk mengatasi lambatnya waktu
eksekusi program akibat pengaksesan (setiap) elemen lis. Dalam hal ini, pengaksesan
(sebuah) elemen lis memerlukan perubahan tipe data elemen dari tipe data objek ke tipe
data yang diinginkan (atau tipe data yang seharusnya) (Nakov, 2013, hal. 661-662).

List<T> merupakan kelas lis generik yang dideklarasikan dengan menggantikan

T ke (sebuah) tipe data tertentu. List<T> menggunakan larik yang mengalokasikan
sebagian ruangnya untuk menyimpan (atau menampung) setiap elemennya, juga
sebagian ruang (memori) lainnya yang (mungkin kosong karena) akan digunakan untuk
menyimpan elemen baru. List<T> sangatlah cepat saat melaksanakan metode Add dan
metode this, tetapi lambat saat melaksanakan metode Contains, metode Insert, metode
Remove, dan metode RemoveAt (Nakov, 2013, hal. 662-663).

Tumpukan merupakan (salah satu) struktur data klasik yang umum digunakan.
Tumpukan menerapkan konsep LIFO (atau Masuk Terakhir dan Keluar Pertama), yaitu
hanya dapat melaksanakan metode Push (yang mirip dengan metode Add pada lis),
metode Pop (yang mirip dengan metode RemoveAt di indeks terakhir pada lis), dan
metode Peek (yang mirip dengan metode this di indeks terakhir pada lis). Tumpukan
yang diimplementasikan dengan kelas generik Stack<T> dapat menjalankan beberapa
metode tambahan, seperti Count, Clear, dan Contains (yang ketiganya mirip dengan
metode-metode di lis), serta ToArray (untuk mengembalikan sebuah larik yang
berisikan seluruh elemennya) (Nakov, 2013, hal. 669-671).
8

1.10. Kamus
Kamus di dunia nyata menggambarkan (setiap) kata sebagai (sebuah) kunci dan
keterangan (yang berkaitan dengan) kata (tersebut) sebagai (sebuah) nilai. Kamus/Peta
(dalam istilah struktur data) merupakan larik asosiatif karena setiap elemennya
mewakili sebuah pasangan antara kunci (yang unik untuk mencari sebuah nilai) dan
nilai (sebagai data yang disimpan). Kamus dapat menjalankan beberapa metode, seperti
Add (untuk menambahkan sebuah elemen baru), Remove (untuk mengembalikan bisa
atau tidaknya penghapusan sebuah elemen dari kunci tertentu), ContainsKey (untuk
memeriksa ada atau tidaknya suatu elemen dari kunci tertentu), Count (untuk
mengembalikan jumlah elemen), this (untuk membaca atau menambahkan sebuah
elemen dari kunci tertentu), dan TryGetValue (untuk mengembalikan bisa atau tidaknya
pengembalian sebuah nilai elemen dari kunci tertentu). Kamus akan mengembalikan
pengecualian kalau pemanggilan Add dilakukan dengan (menentukan) kunci dari salah
satu elemen atau pengaksesan this tidak menemukan (suatu) elemen yang (ingin) dicari.
Kamus menggunakan antarmuka IDictionary<TKey, TValue> untuk
mengimplementasikan kelas Dictionary<TKey, TValue> (Nakov, 2013, hal. 727-730
dan 737).

1.11. Pemrograman Berorientasi Objek

Pemrograman Prosedural/Struktural merupakan (salah satu) paradigma
pemrograman yang menggambarkan sebuah program sebagai kumpulan dari beberapa
baris kode (berupa fungsi/prosedur) yang dapat digunakan kembali karena dapat saling
memanggil dengan menerima (beberapa) masukan (dari argumen ke parameter)
ataupun mengembalikan (sebuah) keluaran. Kekurangan Pemrograman Prosedural
terletak pada sifatnya yang (dapat dikatakan) kurang fleksibel atau (sangat) terbatas
karena belum dapat mengimplementasikan berbagai struktur data (yang bersifat)
abstrak (Nakov, 2013, hal. 807-808).

OOP (atau Pemrograman Berorientasi Objek) merupakan (salah satu)

paradigma pemrograman yang menggambarkan sebuah program sebagai kumpulan dari
beberapa entitas (berupa objek ataupun peristiwa) dengan karakteristik (berupa
properti) ataupun perilaku (berupa metode) di kehidupan nyata. OOP bertujuan untuk
mempercepat pengembangan dan mempermudah pemeliharaan suatu perangkat lunak.
 9

OOP juga memungkinkan penggunaan beberapa baris kode melalui keempat prinsip
dasarnya: Pewarisan, Abstraksi, Enkapsulasi, dan Polimorfisme (Nakov, 2013, hal.
808).

Pewarisan merupakan (salah satu) prinsip dasar OOP yang memungkinkan

(sebuah) kelas (anak) untuk memiliki (beberapa) elemen dari suatu kelas lain (sebagai
induknya atau dapat disebut) sebagai kelas dasar/super. Pewarisan memerlukan kata
kunci base saat mengakses/menggunakan elemen kelas induk (virtual) yang hendak
diganti di dalam kelas anak, juga untuk menjelaskan bahwa (suatu) elemen kelas induk
sedang diakses/digunakan di dalam kelas anak. Pewarisan menggunakan pengubah
akses tingkat terlindung (yang dinyatakan dengan kata kunci protected) untuk
membatasi agar (suatu) elemen kelas (leluhur) hanya dapat diakses (secara transitif atau
turun-temurun) dari dalam dirinya sendiri ke seluruh turunannya (termasuk anak
cucunya) (Nakov, 2013, hal. 809-810, 812, dan 820).

Abstraksi (dalam kehidupan sehari-hari) berarti menggunakan suatu benda

(untuk menyelesaikan masalah) tanpa perlu mengetahui cara kerja internalnya (atau di
balik layarnya). Abstraksi (dalam pemrograman) dapat terasa saat menggunakan
berbagai struktur data (seperti larik, lis, tumpukan, ataupun kamus) tanpa terlalu
memusingkan (penulisan) kode di baliknya. Abstraksi memungkinkan pemrogram
untuk mendefinisikan sesuatu yang dapat digunakan kembali karena bersifat abstrak
dan terkesan seperti sebuah tipe data baru. Abstraksi (dalam OOP) contohnya yaitu saat
mendeklarasikan (sebuah) objek (dari) kelas dasar dan melakukan inisialisasi nilainya
dengan (sebuah) objek (dari) kelas turunan (Nakov, 2013, hal. 824-825).

Antarmuka (atau Kontrak) merupakan penentuan (sebuah) peran kepada setiap

objek dari kelas yang mengimplementasikannya. Antarmuka hanya dapat (didefinisikan
dengan) mengandung beberapa elemen abstrak, seperti konstanta abstrak ataupun
metode (termasuk properti) abstrak. Antarmuka yang diimplementasikan berarti (hanya
dapat) menentukan implementasi (atau isi dari tubuh) elemen abstraknya (secara tidak
langsung) di dalam kelas yang mewarisinya. Antarmuka termasuk salah satu aturan
dasar untuk menulis kode (program) berkualitas tinggi karena implementasinya (dapat
dikatakan sangat) tahan terhadap (berbagai) perubahan (Nakov, 2013, hal. 825-828).

Enkapsulasi (dalam kehidupan sehari-hari) merupakan penyembunyian

informasi (ataupun cara kerja) suatu benda (yang tidak perlu diketahui oleh
10

penggunanya) secara internal. Enkapsulasi (dalam pemrograman) umumnya diterapkan

dengan mendeklarasikan (suatu) elemen kelas (dengan pengubah akses tingkat) privat
untuk meminimalkan pengaksesan yang tidak diperlukan di dalam kelas lain.
Enkapsulasi (dalam OOP) contohnya yaitu saat memanggil (beberapa) metode privat
(yang tidak perlu diketahui) di dalam (suatu) metode publik yang implementasinya
(dapat terus) diubah dari kelas induknya (Nakov, 2013, hal. 828-830).

Polimorfisme merupakan (salah satu) prinsip dasar OOP yang (seakan-akan)

memperlakukan objek dari kelas turunan sebagai objek dari kelas dasar. Polimorfisme
termasuk salah satu aturan dasar saat bekerja dengan kelas yang umumnya diterapkan
(untuk mengubah perilaku) dengan menggantikan implementasi metode dari kelas
dasar ke kelas turunan. Polimorfisme (kemudian) dapat diterapkan (secara bersamaan)
dengan konsep Kelas Abstrak (Murni) dan konsep Metode Virtual (Nakov, 2013, hal.
830 dan 836).

Kelas Abstrak merupakan (sebuah) kelas yang (seakan-akan) belum siap

digunakan karena tidak dapat mencetak/menurunkan sebuah objek. Kelas Abstrak
didefinisikan dengan kata kunci abstract sebelum namanya. Kelas Abstrak (dapat
dikatakan) berada di antara antarmuka dan kelas karena dapat mengandung metode
(termasuk properti) abstrak (yang tidak dapat diimplementasikan secara langsung)
ataupun metode non abstrak. Kelas Abstrak (yang bersifat) Murni (sangatlah) mirip
dengan antarmuka karena hanya mengandung beberapa elemen abstrak, seperti metode
abstrak ataupun properti abstrak (Nakov, 2013, hal. 830 dan 833).

Metode Virtual bukanlah metode (yang terdefinisi secara) bawaan, melainkan

ialah metode non abstrak di dalam kelas dasar yang didefinisikan dengan kata kunci
virtual. Metode Virtual kemudian dapat diganti dengan mengubah implementasi
metode non abstrak yang didefinisikan dengan kata kunci override di dalam kelas
turunan. Metode Virtual (sesungguhnya) mencakup metode abstrak karena metode
abstrak (secara tidak langsung) ialah Metode Virtual yang hanya dideklarasikan (atau
tidak memiliki implementasi) (Nakov, 2013, hal. 833-834).

Kohesi merupakan prinsip OOP lanjutan yang menunjukkan seberapa kuat

hubungan antara beberapa tanggung jawab atau tugas dalam suatu komponen (yang
berupa kelas ataupun metode). Kohesi dalam suatu kelas berarti seberapa kuat
hubungan antara beberapa metode sebagai elemennya dalam melaksanakan tugasnya.
 11

Kohesi dalam suatu metode berarti seberapa kuat hubungan antara beberapa baris kode
sebagai bagian dari implementasinya dalam melaksanakan tugasnya. Kohesi Kuat
merupakan salah satu aturan dasar untuk menulis kode berkualitas tinggi (yang dapat
dicapai) dengan memastikan agar suatu komponen hanya melaksanakan satu tugas
(Nakov, 2013, hal. 836-837).

Kopling merupakan prinsip OOP lanjutan yang menentukan seberapa bebas

hubungan antara beberapa komponen. Kopling Longgar merupakan salah satu aturan
dasar untuk menulis kode berkualitas tinggi dengan mengusahakan agar setiap
komponen dapat berdiri sendiri dan dapat (disalin atau) digunakan kembali. Kopling
Ketat dapat menyebabkan kode program semakin sulit dipahami (alurnya) dan semakin
mudah memunculkan eror ataupun serangga karena suatu komponen (yang mengubah
nilai elemen statis) dapat memengaruhi komponen lain yang bergantung dengannya
(setelah membaca perubahan nilai elemen statis tersebut) (Nakov, 2013, hal. 838-840).

1.12. Ekspresi Lambda

Metode Ekstensi merupakan perluasan fungsionalitas yang dapat ditambahkan
ke suatu variabel. Metode Ekstensi bertujuan agar pemrogram tidak perlu
mendefinisikan sebuah kelas turunan yang hanya digunakan untuk mendefinisikan
metode baru. Metode Ekstensi didefinisikan dengan kata kunci static di dalam kelas
statis. Metode Ekstensi menggunakan kata kunci this pada pendeklarasian parameter
pertamanya (sebagai variabel yang diperluas) untuk membedakannya dengan metode
statis lainnya (Nakov, 2013, hal. 915).

Tipe Anonim merupakan suatu variabel yang (umumnya) hanya digunakan

sekali. Tipe Anonim mempersingkat pendeklarasiannya untuk menghindari
ketidaknyamanan akibat pengonsumsian waktu (yang berlebihan) dan penulisan
redundan (yang kepanjangan atau terkesan duplikat). Tipe Anonim menggunakan kata
kunci var untuk menentukan tipe datanya secara otomatis berdasarkan ekspresinya
(atau literalnya) (Nakov, 2013, hal. 918).

Ekspresi Lambda merupakan (suatu) ekspresi yang mengandung (sebuah)

operator lambda. Ekspresi Lambda dapat menggunakan operan di sebelah/sisi kiri
operator lambda sebagai parameter masukan. Ekspresi Lambda dapat menggunakan
ekspresi (sebagai predikat) atau implementasi metode anonim (sebagai pengganti
12

delegasi) di sebelah/sisi kanan operator lambda untuk bekerja dengan parameter

masukan ataupun mengembalikan sebuah keluaran. Ekspresi Lambda dapat digunakan
bersama Metode Ekstensi ataupun Tipe Anonim (Nakov, 2013, hal. 920-922).

2. Prinsip SOLID
SOLID merupakan (sekumpulan) prinsip desain yang dapat memengaruhi cara
kerja Pola Desain. SOLID dapat membantu pemrogram agar kode yang ia tulis lebih
sederhana (atau lebih mudah dipahami dan lebih mudah disesuaikan). SOLID terdiri
atas lima konsep, yaitu SRP (atau Prinsip Tanggung Jawab Tunggal), OCP (atau Prinsip
Buka-Tutup), LSP (atau Prinsip Substitusi Liskov), ISP (atau Prinsip Segregasi
Antarmuka), dan DIP (atau Prinsip Inversi Dependensi) (Krogh-Jacobsen, 2022, hal.
8).

2.1. Tanggung Jawab Tunggal

SRP merupakan prinsip desain yang (dapat dikatakan hendak mewujudkan
Kohesi Kuat dengan) menyatakan bahwa setiap kelas ataupun metode hanya berfokus
atau bertanggung jawab atas satu hal. SRP bukan berarti bahwa suatu kelas harus
memiliki satu metode, melainkan bermaksud untuk memisahkan dari sebuah kelas
monolit (yang mengurus banyak hal sendirian) dengan baris kode yang (sangat) panjang
ke beberapa kelas kecil (yang mengurus satu hal berbeda) dengan baris kode yang
(terkesan) pendek (atau sedikit) agar setiap metode (di dalamnya) lebih mudah
dipahami dan lebih mudah ditentukan implementasinya. SRP bertujuan untuk mencapai
Keterbacaan (yang umumnya membatasi setiap kelas dengan hanya dua ratus hingga
tiga ratus baris kode), Ekstensibilitas (yang merupakan kemudahan untuk mewarisi
kelas lain dan mengganti ataupun mengubah suatu kelas tanpa mengkhawatirkan
adanya kekacauan internal yang berarti), dan Penggunaan Kembali. SRP dapat
dirasakan (secara tidak langsung) penerapannya melalui berbagai komponen di setiap
objek gim yang dapat saling berinteraksi atau berkomunikasi dalam sebuah adegan di
Unity (Krogh-Jacobsen, 2022, hal. 8 dan 11).
 13

2.2. Buka-Tutup
OCP merupakan prinsip desain yang menyatakan bahwa (suatu bagian dari)
sebuah kelas harus terbuka (atau bersedia) untuk diperluas (dengan berbagai bentuk
yang berupa kelas dan mewarisi sebuah kelas abstrak) dan (bagian-bagian lainnya yang
bersifat internal harus) tertutup (atau tidak terpengaruh) untuk dimodifikasi (atau
diganti ataupun diubah). OCP dapat menyederhanakan perluasan (atau berbagai
penambahan bentuk baru) dengan menghindari penggunaan (sekumpulan) pernyataan
kondisional (yang memproses setiap bentuk baru tersebut). OCP (juga) dapat
mempermudah pengawakutuan karena berbagai eror ataupun serangga dapat ditemukan
pada kode program di dalam setiap bentuk (baru) secara terpisah (Krogh-Jacobsen,
2022, hal. 12 dan 14).

2.3. Substitusi Liskov

LSP (atau Penggantian Liskov) merupakan prinsip desain yang menyatakan
bahwa setiap kelas turunan (yang mendapatkan warisan) harus dapat menggantikan
sebuah kelas dasar (yang mewariskannya). LSP dapat terpenuhi melalui beberapa hal,
yaitu tidak terhapusnya (beberapa) metode pada kelas dasar hanya karena membuat
sebuah bentuk (sebagai kelas turunan) baru yang mewarisinya; abstraksi yang
sederhana karena kelas dasar (abstrak) hanya mewariskan beberapa elemen yang
bersifat umum kepada (atau yang pasti dimiliki) setiap kelas turunannya; kesesuaian
antara setiap elemen publik pada kelas turunan dan pada kelas dasar; pemisahan kelas
dasar di antara beberapa bentuk yang berbeda; dan penggunaan komposisi (melalui
antarmuka) daripada generalisasi (melalui pewarisan) untuk memisahkan beberapa
metode yang berbeda dan menggabungkan metode-metode tersebut kepada setiap
bentuk. LSP dapat membatasi (penggunaan berbagai) pewarisan (yang tidak
diperlukan) untuk mempermudah perluasan ataupun penyesuaian (dalam) kode
(program) (Krogh-Jacobsen, 2022, hal. 15, 18, dan 21).

2.4. Segregasi Antarmuka

ISP (atau Pemisahan Antarmuka) merupakan prinsip desain yang menyatakan
bahwa tidak boleh terdapat kelas yang mengimplementasikan (metode dari) suatu
antarmuka secara terpaksa. ISP mirip dengan SRP, yaitu bermaksud untuk memisahkan
14

dari suatu antarmuka besar ke beberapa antarmuka kecil. ISP dapat memaksimalkan
penyesuaian (dalam) kode (program) dengan menjaga agar setiap antarmuka tetap
ringkas atau singkat. ISP (juga secara tidak langsung) dapat mempermudah modifikasi
kode (program) (Krogh-Jacobsen, 2022, hal. 21 dan 24).

2.5. Inversi Dependensi

DIP (atau Pembalikan Ketergantungan) merupakan prinsip desain yang (dapat
dikatakan hendak mewujudkan Kopling Longgar dengan) menyatakan bahwa suatu
kelas (bertingkat) tinggi tidak boleh hanya bergantung (secara langsung) kepada sebuah
(bentuk sebagai) kelas (bertingkat) rendah. DIP bermaksud untuk mewujudkan
abstraksi dengan menempatkan sebuah antarmuka di antara kelas tinggi dan kelas
rendah. DIP (kemudian) dapat mendorong penggunaan kembali kode (program) di
dalam kelas tinggi dengan pendeklarasian (sebuah) objek dari (atau bertipe) antarmuka
sebagai perwakilan dari berbagai (pendefinisian) bentuk (sebagai kelas rendah) baru
yang mengimplementasikan antarmuka (Krogh-Jacobsen, 2022, hal. 24 dan 28-29).

3. Pola Desain
Pola Desain merupakan sebuah cetak biru siap pakai yang dapat disesuaikan
untuk menjawab suatu persoalan yang umumnya terjadi dalam pemrograman perangkat
lunak. Pola Desain dapat menggambarkan berbagai solusi dalam tingkatan yang lebih
tinggi (daripada sekadar algoritma) karena (urutan) penerapannya (dalam berbagai
kode program) dapat dilakukan secara berbeda. Pola Desain didasarkan pada konsep
pola yang digunakan untuk mendesain (atau menggambarkan) lingkungan perkotaan
dalam sebuah buku yang ditulis oleh Christopher Alexander dan dirilis pada 1977. Pola
Desain kemudian digagaskan oleh GoF (atau keempat penulis legendaris) yang terdiri
dari Erich Gamma, John Vlissides, Ralph Johnson, dan Richard Helm dalam sebuah
buku yang dirilis pada 1994. Pola Desain sebaiknya dipelajari pemrogram karena cara
kerjanya sudah terjamin (dari beberapa percobaan ataupun pengujian) (Shvets, 2023).

Pola Desain dapat dibedakan antara kompleksitasnya, skala (atau ukuran)

penerapannya dalam perancangan sistem, dan tingkatan detailnya. Pola Desain dengan
tingkat rendah dan hanya berlaku untuk bahasa pemrograman tertentu disebut Pola
Idiom, sedangkan Pola Desain dengan tingkat tinggi dan dapat berlaku di hampir semua
 15

bahasa pemrograman disebut Pola Arsitektur. Pola Desain juga dapat dibedakan
berdasarkan tujuannya ke dalam tiga kelompok utama, yaitu Pola Kreasi (untuk
meningkatkan kemudahan penyesuaian dan penggunaan kembali kode dalam
pembuatan objek), Pola Struktural (untuk memperbesar struktur kelas dan menjaganya
agar lebih efisien dan lebih mudah disesuaikan), dan Pola Perilaku (untuk membagi
tanggung jawab atau tugas kepada setiap objek dan untuk menjaga agar komunikasi
antar objek tetap memberikan dampak yang baik) (Shvets, 2023).

3.1. Factory
Factory merupakan Pola Kreasi yang dapat digunakan untuk (memunculkan
atau) menciptakan berbagai jenis objek gim selama berlangsungnya permainan dalam
sebuah adegan Unity. Factory dapat diterapkan dengan mendefinisikan sebuah kelas
(dasar) abstrak pabrik (Factory) dan sebuah antarmuka produk (IProduct). Factory
kemudian mendefinisikan sebuah metode produksi (GetProduct sebagai elemen
abstrak) di dalam kelas abstrak pabrik untuk menciptakan (atau menyalin cetakan dari
suatu produk tertentu yang berupa) objek gim (pada posisi tertentu), juga (dapat)
mendefinisikan sebuah metode inisialisasi (Initialize sebagai elemen abstrak) di dalam
antarmuka produk untuk melakukan sesuatu (atau hal-hal tertentu) saat metode
produksi dipanggil. Factory akhirnya dapat menurunkan kelas abstrak pabrik yang
dapat memproduksi suatu implementasi antarmuka produk, misalnya (kelas turunan)
FactoryA memproduksi (implementasi antarmuka) ProductA dan FactoryB
memproduksi ProductB, di mana ProductA mungkin merupakan (turunan dari kelas
abstrak) obat (Spell), sedangkan ProductB mungkin merupakan pasukan (Troop).
Factory menyediakan keuntungan saat tersedia banyak jenis produk yang dapat (atau
perlu) diproduksi, di mana setiap kelas (turunan) produk dapat berdiri sendiri dan tidak
(perlu) memengaruhi kelas produk lainnya ataupun kelas (turunan) pabrik( yang
memproduksi)nya, sehingga dapat mempersingkat (jumlah baris kode) kelas pabriknya.
Factory tidak cocok untuk permainan dengan produk yang jenisnya sedikit (atau
berjumlah kecil) karena mendorong pendefinisian sejumlah kelas (turunan pabrik
ataupun produk) yang sesungguhnya tidak diperlukan. Factory dapat disesuaikan atau
ditingkatkan dengan menggunakan kamus untuk mempermudah pencarian produk;
mendefinisikan suatu kelas statis manajer pabrik dan suatu koleksi statis produk sebagai
16

elemen( di dalam)nya; menerapkannya ke objek C# selain objek gim; dan

menyatukannya dengan Pola Object Pool (Krogh-Jacobsen, 2022, hal. 40-44).

3.2. Object Pool

Object Pool (atau Kumpulan Objek) merupakan Pola Kreasi yang dapat
(membantu untuk) meringankan pekerjaan CPU (atau Unit Pemrosesan Utama dalam)
komputer dengan hanya mengaktifkan atau menonaktifkan (beberapa) objek gim
daripada membuatnya atau menghancurkannya (dalam suatu adegan). Object Pool
dapat diterapkan dengan mendefinisikan sebuah kelas kumpulan (ObjectPool) yang
mengumpulkan objek dan sebuah kelas terkumpul (PooledObject) sebagai (setiap)
objek yang dikumpulkan. Object Pool dapat dimulai (alur kerjanya) dengan membuat
setiap objek sebanyak jumlah (awal) yang ditetapkan, kemudian objek tersebut
dinonaktifkan dan didorong (atau dikumpulkan) ke dalam (suatu) tumpukan. Object
Pool juga dapat mengeluarkan objek terakhir dari dalam tumpukan dan
mengaktifkannya saat dibutuhkan. Object Pool dapat diterapkan untuk beberapa hal,
seperti sistem partikel (bawaan Unity), memuat seluruh objek gim saat mengunjungi
suatu adegan, dan lainnya. Object Pool dapat dikembangkan (atau ditingkatkan) dengan
menjadikan kelas kumpulan sebagai Singleton (untuk mempermudah aksesnya);
menggunakan kamus untuk mengumpulkan beberapa objek (gim) yang berbeda kelas;
dan menggunakan kapasitas (atau jumlah maksimum objek yang dikumpulkan dalam
kelas) kumpulan agar pengumpulan (objek) tidak menghabiskan terlalu banyak memori
(Krogh-Jacobsen, 2022, hal. 46-48 dan 50).

3.3. Singleton
Singleton (atau Objek Tunggal) merupakan Pola Kreasi yang (menurut GoF)
memastikan bahwa suatu kelas hanya dapat membuat satu objek atau turunan (sebagai
Singleton) dari dirinya sendiri beserta akses global yang mudah terhadap objek
tunggalnya tersebut. Singleton cocok untuk kelas manajer yang mengatur suatu hal
(secara keseluruhan) dalam sebuah adegan di Unity. Singleton ternyata pernah
dikelompokkan sebagai Anti-Pola dan disebut bereputasi buruk (dalam sebuah buku
yang ditulis oleh Robert Nystrom) karena kemudahan akses global tersebut cenderung
mudah disalahgunakan dan (diam-diam) memunculkan ketergantungan (antar kelas)
 17

yang sesungguhnya tidak diperlukan. Singleton kemudian tidak disukai banyak

pengembang karena ketergantungan tersebut malah (mendorong kopling ketat yang)
menyulitkan pemfaktoran ulang, pengujian unit, ataupun perbaikan serangga. Singleton
memiliki beberapa manfaat (yang cocok untuk permainan berskala kecil) karena mudah
dipahami dan mudah digunakan, serta dapat bekerja lebih cepat daripada pemanggilan
variasi metode Find ataupun variasi metode GetComponent yang cenderung lambat
(Krogh-Jacobsen, 2022, hal. 54 dan 59-60).

3.4. Command
Command merupakan Pola Perilaku yang dapat digunakan untuk menyimpan
seruntun (objek dari kelas) perintah (atau tindakan) di dalam suatu (koleksi atau)
struktur data (seperti tumpukan). Command dapat diterapkan dengan mendefinisikan
sebuah antarmuka (ICommand) yang meliputi sebuah metode (Execute) untuk
melakukan perintah dan sebuah metode (Undo) untuk membatalkan (atau melakukan
sesuatu yang berlawanan dengan) perintah, kemudian mengimplementasikannya ke
berbagai kelas perintah. Command akhirnya dapat menjalankan berbagai perintah
dengan mendefinisikan sebuah kelas (CommandInvoker) yang memasukkan objek (dari
kelas) perintah (tertentu) ke dalam tumpukan pembatalan (perintah bernama
undoStack) setelah melakukan (suatu) perintah tertentu, juga menghapus objek perintah
puncak (atau terbaru) dari tumpukan pembatalan setelah membatalkan perintah
tertentu. Command menyediakan keuntungan dengan mempermudah pemutaran
(ulang) dan pengaturan kombinasi (atau kombo) tindakan, tetapi dapat memperbanyak
(atau memperbesar) struktur kode program. Command dapat diperluas atau
ditingkatkan dengan menambah implementasi (atau jenis) kelas perintah; menambah
sebuah metode (Redo) untuk mengulangi perintah dengan memasukkan objek perintah
puncak (yang dihapus) dari tumpukan pembatalan ke tumpukan pengulangan (bernama
redoStack) setelah membatalkan perintah, juga menghapus objek perintah puncak dari
tumpukan pengulangan dan menambahkannya ke tumpukan pembatalan setelah
mengulangi perintah; menggunakan koleksi berbeda (selain tumpukan) sebagai
penyangga (atau tempat penyimpanan sementara) objek perintah, seperti antrean atau
lis; dan menggunakan konstruktor pada (saat membuat sebuah) objek perintah (Krogh-
Jacobsen, 2022, hal. 62-64 dan 66-68).
18

3.5. State
State (atau Keadaan) merupakan Pola Perilaku yang mewujudkan suatu FSM
(atau Mesin dengan berbagai Keadaan dalam jumlah Terbatas dan digunakan) untuk
mengamati setiap keadaan dalam sebuah objek (yang berupa aktor ataupun benda
dalam) gim. State menggambarkan sebuah Diagram Keadaan (dengan satu keadaan
yang sedang aktif dalam suatu saat dan dapat memicu suatu transisi atau perpindahan
ke keadaan lainnya menurut kondisi tertentu). State (menurut GoF) dapat memisahkan
setiap keadaan (ke sebuah kelas) agar dapat berdiri sendiri (atau tidak saling
bergantung). State dapat diterapkan dengan (mendefinisikan) sebuah antarmuka (untuk
diimplementasikan oleh setiap keadaan) dan sebuah kelas (sebagai) FSM. State
menyediakan beberapa keuntungan dengan mematuhi Prinsip SOLID, yaitu
memisahkan sebuah kelas FSM monolit ke beberapa kelas keadaan (dengan SRP) dan
memungkinkan penambahan (berbagai) keadaan baru tanpa pernyataan kondisional
yang rumit (dengan OCP). State terasa berlebihan kalau suatu objek gim hanya
memiliki keadaan dalam jumlah yang sangat kecil atau kurang rumit. State dapat
diterapkan untuk beberapa konteks (yang lebih) rumit, yaitu dapat disertakan dengan
animasi (karakter), dapat disertakan dengan acara (atau dengan Pola Observer), dapat
berupa hierarki (dengan mendefinisikan suatu kelas keadaan induk yang mewarisi
beberapa kelas keadaan turunan), dan dapat menerapkan AI (atau Kecerdasan Buatan)
sederhana untuk berbagai karakter (dalam) gim (Krogh-Jacobsen, 2022, hal. 70, 72-74,
dan 76-78).

3.6. Observer
Observer merupakan Pola Perilaku yang digunakan untuk mengurangi berbagai
ketergantungan saat suatu objek berkomunikasi (atau terhubung) dengan (merujuk)
objek lainnya secara berlebihan. Observer menggunakan relasi satu-ke-banyak, yaitu
sebuah objek berperan sebagai (penerbit atau) subjek dengan delegasi (atau
kemampuan) untuk menyiarkan acara (sebagai penanda bahwa sesuatu telah terjadi atau
beberapa metode telah dipanggil) ke beberapa objek lainnya sebagai (pelanggan atau
pendengar atau) pengamat dengan metode sebagai pelaksana (yang berlangganan dan
bereaksi atau memberikan respons ke) acara. Observer dapat menggunakan beberapa
 19

jenis delegasi (acara) di dalam subjeknya, salah satunya yaitu Action<T1, T2...T16>
yang bertipe (kembalian) void dan dapat menampung hingga enam belas parameter
masukan generik. Observer dapat menimbulkan eror kalau (beberapa) objek pengamat
yang masih berlangganan malah dihancurkan atau dimatikan saat adegan sedang
berjalan, sehingga objek pengamat dapat berhenti berlangganan melalui metode
OnDestroy atau metode OnDisable. Observer dapat menerapkan subjek ke berbagai hal
dalam permainan, seperti memanggil acara saat mengalahkan musuh, mengambil
barang, mengatur kondisi menang atau kalah, mengatur nilai skor, dan mengendalikan
UI (atau Antarmuka Pengguna). Observer juga dapat menerapkan pengamat untuk
bereaksi ke berbagai (pemanggilan) acara, seperti memunculkan efek partikel,
memunculkan potongan adegan, memutar suara, dan mengganti animasi. Observer
menyediakan beberapa keuntungan, yaitu memisahkan subjek dari (para) pengamatnya,
mengusahakan agar setiap pengamat merespons (acara) subjek dengan metodenya
sendiri, dan (sangat) cocok untuk dipadukan dengan Pola MVP (atau MVC). Observer
dapat menimbulkan beberapa tantangan, yaitu menambah kerumitan (dengan
menghentikan langganan dari setiap pengamatnya) saat menghapus suatu subjek, tetap
memerlukan ketergantungan oleh (setiap) pengamat terhadap (suatu) subjek, dan dapat
menimbulkan masalah (pada) performa (aplikasi) seiring banyaknya objek gim yang
berperan sebagai pengamat dalam sebuah adegan (besar) (Krogh-Jacobsen, 2022, hal.
80-84 dan 86).

3.7. Model-View-Presenter
MVC (atau Model-View-Controller) merupakan Pola Arsitektur yang umumnya
digunakan untuk mengembangkan (sesuatu yang berhubungan dengan) UI (dalam)
aplikasi. MVC bertujuan untuk mengurangi kemungkinan terjadinya kohesi rendah
(dengan menerapkan Prinsip SRP) dan kopling ketat (karena munculnya
ketergantungan yang sesungguhnya tidak diperlukan) dalam kode program aplikasi.
MVC memisahkan aplikasi ke dalam tiga lapisan, yaitu Model (sebagai tempat
penyimpanan yang bertugas untuk mengurus berbagai data dengan nilai tertentu),
Tampilan (yang bertugas untuk menyajikan data dari Model ke layar komputer agar
dapat dilihat oleh pengguna), dan Pengontrol (sebagai bagian dari otak aplikasi yang
bertugas untuk menerima input pengguna dan mengubah nilai data ke Model) (Krogh-
Jacobsen, 2022, hal. 89-90).
20

MVP (atau Model-View-Presenter) merupakan perubahan bentuk MVC yang

meletakkan Presenter (sebagai Pengontrol) di antara Model dan (mengganti tugas untuk
menerima input pengguna dari Pengontrol ke) Tampilan. MVP dapat dimulai (alur
kerjanya) saat pengguna berinteraksi dengan (berbagai) komponen UI (seperti Button
ataupun Slider) yang (secara tidak langsung) memanggil acaranya dan (secara
langsung) tersedia pada Tampilan. MVP dilanjutkan saat setiap metode pelaksana acara
(komponen) UI di Presenter memanipulasi (atau mengubah nilai) data (dengan
memanggil sebuah metode publik yang juga memanggil suatu acara) di Model. MVP
akhirnya memanggil metode pelaksana acara (Model) di Presenter untuk memperbarui
Tampilan. MVP menyediakan beberapa keuntungan untuk aplikasi besar yang
dikembangkan oleh tim besar dalam jangka waktu yang lama, yaitu dapat
mempermudah pembagian kerja (karena desain UI tetap dapat diimplementasikan tanpa
bergantung pada kode program), pengujian unit (karena objek gim yang mengandung
komponen UI tetap dapat disimulasikan atau dites kesesuaian cara kerjanya dengan
berbagai fungsi pada kode program tanpa memasuki Mode Putar untuk menghemat
waktu), dan pembacaan kode program (karena sesuai dengan Prinsip SRP). MVP dapat
memunculkan berbagai pertimbangan karena memerlukan (lebih) banyak pekerjaan
(atau perencanaan) di tahap awal pengembangan, juga karena berbagai hal (dalam
sebuah projek gim) yang belum tentu cocok (atau dapat disesuaikan) dengan pola ini
(Krogh-Jacobsen, 2022, hal. 90-94).
 DAFTAR PUSTAKA

Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of
Reusable Object-Oriented Software 1st Edition. Baarn: Addison-Wesley.

Krogh-Jacobsen, T. (2022, Oktober 13). Level Up Your Code with Game Programming
Patterns. Diambil kembali dari Unity Blog: [Link]
your-code-with-game-programming-patterns

Nakov, S. (2013). Fundamentals of Computer Programming with C#. Diambil kembali dari
Nakov's Free Books: Programming with C#, Java, JavaScript, Python and C++:
[Link]

Nordeus, E. (2023). Game Programming Patterns in Unity with C#. Diambil kembali dari
GitHub: [Link]

Nystrom, R. (2011). Game Programming Patterns. Diambil kembali dari Game Programming
Patterns: [Link]

Shvets, A. (2023). Refactoring and Design Patterns. Diambil kembali dari Refactoring Guru:
[Link]

21