UNIVERSITAS GUNADARMA

PRAKTIKUM PENGANTAR KECERDASAN BUATAN

MANUAL BOOK
Droid of War (Othello 9x9)

Nama
NPM
Jurusan
Fakultas
PJ

: Eka Ashar Maulana

: 52412397
: Teknik Informatika
: Teknologi Industri
: Ade Mulyanto

DIAJUKAN GUNA MELENGKAPI

SEBAGIAN SYARAT PRAKTIKUM PKB
2014/2015

DAFTAR ISI
Daftar Isi ......2
Sejarah........................................................................................................................3
Bahasa dan Program Editor........................................................................................3
Initial States ........4
Rules ...............6
Goals ...........7
Konsep AI.....8
Algoritma yang Dipakai.........8
Listing Program ........ ....9
Daftar Pustaka...17
Glosarium ..17

Sejarah Permainan Othello

Sejarah othello berawal tahun 1945, setelah bom

atom dijatuhkan di

Hiroshima dan Nagasaki. September 1945, Hasegawa Goro yang tengah duduk di
kelas satu SMP menerima pelajaran sembari duduk di tanah di bawah langit biru.
Mito juga menjadi sasaran pengeboman hingga kastil dan bangunan bersejarah lain
ikut habis dalam kobaran api. Dalam suasana seperti itulah permainan ini dilahirkan.
Permainan othello dimainkan pada arena papan kotak-kotak persegi dengan koin
hitam dan putih diatas arena. Pada awal permainan diletakkan dua koin hitam dan
dua koin putih pada pusat arena. Koin warna hitam harus melewati koin warna putih
agar koin putih dapat diubah menjadi koin hitam, dan sebaliknya. Permainan akan
berakhir jika semua kotak arena sudah terisi koin, atau seluruh koin yang ada di atas
arena berwarna sama. Pemenang adalah pemain yang memiliki jumlah koin lebih
banyak di atas arena. Permainan ini di luar negeri lebih dikenal dengan nama
Reversi. Saat ini Othello tidak hanya dimainkan secara tradisional, namun sudah
banyak dibuat dalam bentuk animasi pada komputer.

Bahasa dan Program Editor

Permainan othello menggunakan bahasa pemrograman Prolog. Prolog
adalah bahasa pemrograman logika atau disebut juga sebagai bahasa nonprocedural. Namanya diambil dari bahasa Perancis programmation en logique
(pemrograman logika). Bahasa ini diciptakan oleh Alain Colmerauer dan Robert
Kowalski sekitar tahun 1972 dalam upaya untuk menciptakan suatu bahasa
pemrograman yang memungkinkan pernyataan logika alih-alih rangkaian perintah
untuk dijalankan komputer.
Dalam hal ini saya menggunakan Strawberry Prolog sebagai program editor.
Alasan kami menggunakan strawberry prolog ini karena menurut kami editor ini
mudah untuk digunakan dan mudah untuk mengimplementasikan AI secara
sederhana dan merupakan aplikasi light edition yang artinya program ini dapat
dijalankan langsung tanpa perlu diinstal. Strawberry Prolog dihasilkan oleh Institut
Matematika dan Informatika pada Akademi Ilmu Pengetahuan Bulgaria . Versi
pertama dirilis pada tahun 1996. Pemimpin tim Strawberry Dimiter Dobrev.

INITIAL STATES
Game dengan judul othello Droid of War ini di buat demi memenuhi tugas
praktikum Pengantar Kecerdasan Buatan. Game ini di buat dengan menggunakan
bahasa pemrograman strawberry prolog. Othello adalah permainan papan yang
melibatkan strategi. Pada game othello kali ini papan Othellonya memiliki 81 kotak
yang dimainkan oleh dua pemain di atas papan dengan 9 baris dan 9 kolom. Pada
saat memulai permainan anda akan melihat sebuah tampilan deangan ikon android
dan IOS sebagai bidak othellonya. Pada permainan sudah menentukan playernya
yaitu anda sebagai Android dan komputer sebagai IOS.
Permainan ini dapat melatih daya strategi seseorang dalam memperebutkan
daerah dengan computer (AI) sebagai lawannya. Initial state yang dibangun terlebih
dahulu adalah pembuatan papan (daerah permainan). Papan tersebut memiliki
background Android dan IOS.

Tampilan Loading:

Tampilan window utama:

Keterangan: Layar kotak-kotak dengan backggorund putih karena disesuaikan

dengan backgorund ikon dan diberi garis dengan ketebalan 5 dan berwarna
hitam.

Pada permainan Othello 9x9 terdapat tiga buah menu, dengan dua buah
menu dengan tipe normal dan satu buah menu dengan tipe pop up, yaitu Mulai baru,
Musik, dan Keluar. Menu Mulai Baru digunakan untuk memulai permainan baru.
Sementara menu Musik berisi musik yang dapat di nyalakan dan dimatikan. Menu
Keluar digunakan untuk keluar dari permainan. Dalam permainan ini, pemain tidak
dibatasi oleh limit waktu karena segala kemungkinan yang ada dalam pikiran pemain
bisa berubah, sehingga pemain dituntut untuk berpikir keras bagaimana agar bisa
memenangkan permainan. Selain itu, tidak dibutuhkan pula waktu yang lama untuk
dapat mengambil keputusan oleh pemain dalam mengambil langkah.
Othello 9x9 menggunakan bidak-bidak dengan dua gambar berbeda sebagai
penanda bidak tersebut adalah milik pemain atau milik AI. Bidak untuk pemain
menggunakan ikon Android, sementara bidak untuk AI menggunakan gambar IOS.

RULES
Aturan main (rules) yang digunakan pada permainan Othello 9x9 mirip seperti
Othello biasa. Berikut aturan permainan Othello 9x9:

Pada

awal

permainan

diletakkan

sembilan buah bidak berbentuk kotak,

yaitu empat bidak bergambar android
sebagai

user

dan

lima

bidak

bergambar IOS sebagai AI di tengahtengah papan dengan susunan seperti

ini.

Pemain dengan bidak Android, mulai

terlebih

dulu.

Bidak

android

ini

dijalankan oleh user. Bidak Android

hanya boleh ditempatkan pada posisi
kotak sedemikian sehingga sepasang
bidak Android akan mengapit seluruh
bidak bergambar IOS, yang ada dalam
satu baris secara vertikal, horizontal,
atau diagonal.

Setelah penempatan bidak android yang

mengapit bidak bergambar ios, maka seluruh
bidak ios yang diapit oleh bidak android akan
berubah menjadi bidak android.
Sebagai contoh, bidak android diletakkan
pada lokasi paling atas, maka semua bidak ios
yang diapit oleh bidak android tersebut dibalikkan
menjadi bidak android, sehingga keadaan papan
6

adalah seperti di samping ini:

Sekarang

giliran

bidak

ios

bermain.

Kemungkinan penempatan bidak ios oleh

AI adalah seperti gambar di samping ini:

GOALS
Goals untuk menyelesaikan permainan Othello 9x9 adalah jika kotak sudah
terisi 61 buah dan salah satu ada yang lebih besar mendapatkan kotak tersebeut
maka user atau AI tersbut akan memenangkan permainan. Jika seorang pemain
(user) tidak dapat meletakan bidak karena 61 kotak telah terisi atau tidak ada posisi
yang

diperbolehkan

untuk

meletakkan

bidak,

maka

permainan

berakhir.

Pemenangnya adalah pemain yang memiliki bidak paling banyak di atas papan.
disini tidak ada kondisi seri.

Kondisi kalah user

Kondisi menang, score player lebih besar dari pada musuh

7

KONSEP AI
AI (Artificial Intelligence) adalah salah satu bagian ilmu komputer yang
membuat agar mesin/komputer dapat melakukan pekerjaan seperti layaknya dan
sebaik yang dilakukan oleh manusia. Permainan ini berbasis Artificial Intelligience
(kecerdasan buatan). Pada permainan Mini Othello, kecerdasan buatan yang
terkandung di dalamnya adalah AI yang dibuat untuk menjadi lawan user.

ALGORITMA YANG DIPAKAI

Othello merupakan suatu permainan yang menggunakan konsep Artificial
Intelligence atau kecerdasan buatan. Kecerdasan buatan atau yang sering disebut
dengan AI pada game ini terletak pada komputer yang akan bertindak sebagai
lawan. Komputer akan selalu berusaha mengalahkan user dengan cara menutup
langkah pemain untuk membentuk sebuah garis, komputer dapat menyusun
strateginya sendiri agar menjadi pemenang. Othello 9x9 disini menjelaskan tentang
permainan dua buah benda lingkaran yang dibagi menjadi 2 ikon dengan masingmasing pemain mempunyai ikon yang berbeda yaitu ikon android yang akan
digunakan oleh pemain (player) melawan computer yang menggunakan ikon IOS.
Adapun inti dari permainan ini ialah memenangkan perlawanan dari
komputer dengan menjadikan satu baris horizontal, vertikal dan diagonal berurut
dengan pin yang sama sebanyak-banyaknya menurut warna kepemilikannya. Pada
8

permainan ini terdapat 81 kotak yang terdiri dari 9 baris dan 9 kolom yang dapat
diisi bergantian antara pemain (player) dengan lawan (computer) dengan cara
meletakkan bidak milik pemain (player) itu disamping pemain milik lawan (computer)
yang berfungsi untuk menutupi ruang gerak milik lawan (computer).
Jika salah satu dari pemain memperoleh jumlah terbanyak dari pin yang
dimiliki maka pemain itulah yang disebut dengan pemenang. Untuk memainkan
game ini, kita harus memiliki kompiler strawberry prolog terlebih dahulu.
Permainan Othello ini menggunakan sebuah algoritma untuk menemukan
solusi yang paling optimal untuk memenangkan permainan, dalam hal ini kita
menggunakan Algoritma Greedy, berikut penjelasan mengenai algoritma Greedy.

Algoritma greedy merupakan salah satu dari sekian banyak algoritma yang
sering di pakai dalam implementasi sebuah system atau program yang menyangkut
mengenai pencarian optimasi Di dalam mencari sebuah solusi (optimasi) algoritma
greedy hanya memakai 2 buah macam persoalan Optimasi,yaitu:
1.

Maksimasi(maxizimation)

2.

Minimasi(minimization)
Algoritma

greedy

merupakan

metode

yang

paling

populer

untuk

memecahkan masalah optimasi. Algoritma greedy membentuk solusi langkah per

langkah. Pendekatan yang digunakan di dalam algoritma greedy adalah membuat
pilihan yang tampak memberi perolehan terbaik, yaitu dengan membuat pilihan
optimum local pada setiap langkah dengan harapan akan mengarah ke solusi
optimum global.Prinsip algoritma greedy pada setiap langkah ialah mengambil
pilihan terbaik yang dapat diperoleh saat itu tanpa memperhatikan konsekuensi ke
depan, dan berharap bahwa dengan memilih optimum lokal pada setiap langkah
akan menghasilkan optimum global pada akhir proses.

LISTING PROGRAM
?G_X is server("MediaPlayer.MediaPlayer.1"),

%Tampilan window
9

set(sit([[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,b,w,b,n,n,n],[n,n,n,w,b,
w,n,n,n],[n,n,n,b,w,b,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n]])),
font(10,25,"Arial"),
pen(5,rgb(0,0,0)),
window(G_pertama,_,window_pertama(_),"Droid Of War",165,50,920,650).

window_pertama(init):G_batas := 1,
G_waktu is set_timer(_,1.0,fungsi_timer),
bitmap(_, _, fail(_), "image\\loading.bmp", 0,0).

fungsi_timer(end):text_out(400,550,print("Loading ....")),
G_batas := G_batas + 1,
(G_batas = 6-> close_window(G_pertama),
window(_,_,win_func(_),"Droid Of War",165,50,920,650)).

%Kotak othello 9x9

win_func(paint) :G_image is bitmap_image("image\\appvsandr.bmp",_),
draw_bitmap(0,0,G_image,_,_),
brush(rgb(255,255,255)),
rect(50,50,500,500),
for(I,0,9),
X is I * 50 + 50,
line(X,50,X,500),
line(50,X,500,X),
fail.
%Membuat ikon IOS
win_func(paint) :%brush(rgb(250,0,0)),
G_ios is bitmap_image("image\\ios.bmp",_),
sit(K),
for(J,0,7),
for(I,0,7),
take(K,Line,J),
take(Line,b,I),
X is I*50 + 55,
Y is J*50 + 55,
X1 is X + 40,
Y1 is Y + 40,
%rect(X,Y,X1,Y1),
draw_bitmap(X,Y,G_ios,_,_),
fail.
10

%Membuat ikon Android

win_func(paint) :%brush(rgb(250,250,0)),
G_andro is bitmap_image("image\\andro1.bmp",_),
sit(K),
for(J,0,9),
for(I,0,9),
take(K,Line,J),
take(Line,w,I),
X is I*50 + 55,
Y is J*50 + 55,
X1 is X + 40,
Y1 is Y + 40,
%ellipse(X,Y,X1,Y1),
draw_bitmap(X,Y,G_andro,_,_),
fail.
%Menu
win_func(init) :G_Br=0,
menu(normal, _, _, menu_baru(_), "&Mulai Baru"),
menu(pop_up,_,_,menu_musik(_),"&Musik"),
menu(normal, _, _, menu_keluar(_), "&Keluar").

%%mengaktifan tampilan musik%%

menu_musik(init):menu(normal,_,_,ya(),"&Nyala"),
menu(normal,_,_,tidak(),"&Mati").
ya(press):- G_X.'Open'("divide.wav").
tidak(press):- G_X.'Stop'(), menu_baru.
%%mengaktifan deklarasi yang jalan duluan%%
turn_1(press):set(sit([[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,b,w,b,n,n,n],[n,n,n,w,b,
w,n,n,n],[n,n,n,b,w,b,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n]])),
update_window(_).
turn_2(press):set(sit([[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,b,w,b,n,n,n],[n,n,n,w,b,
w,n,n,n],[n,n,n,b,b,b,n,n,n],[n,n,n,n,b,n,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n]])),
update_window(_).
%%mengaktifan tampilan deklarasi menu baru%%
menu_baru(press) :set(sit([[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,b,w,b,n,n,n],[n,n,n,w,b,
w,n,n,n],[n,n,n,b,w,b,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n],[n,n,n,n,n,n,n,n,n]])),
pen(5,rgb(0,0,0)),
11

update_window(_).

%%mengaktifan tampilan deklarasi menu keluar%%

menu_keluar(press) :beep("image\\igu.wav"),
close_window(_).
win_func(close):not( yes_no("","Apakah kamu yakin?", ?)).
%%pembuatan kondisi menang,kalah %%
win_func(paint) :brush(rgb(100,250,250)),
sit(M),
N1 is count_successes(victory(w,M)),
N2 is count_successes(victory(b,M)),
color_text(_, rgb(0, 0, 0)),
color_text_back(_, rgb(179,162,174)),
text_out(550, 219, " Android (YOU) : "+print(N1)),
text_out(550, 269, " IOS (COM) : "+print(N2)),
(N1>N2, N1+N2=:=61->
ask1
else (N1<N2, N1+N2=:=61->
ask2
)),
(N2=:=0->
ask1
else (N1=:=0->
ask2
)),
(N1>N2,N2>N1->
ask1
),
fail.

win_func(paint).

win_func(mouse_click(X,Y)) :X1 is (X - 40) // 50,

Y1 is (Y - 40) // 50,
X1 >= 0,
X1 =< 9,
Y1 >= 0,
Y1 =< 9,
sit(Sit1),
insert(X1,Y1,w),
sit(Sit2),
12

not(Sit1=Sit2),
win_func(paint),
wait(1),
take3(Sit2,n,X2,Y2),
insert(X2,Y2,b),
sit(Sit3),
not(Sit2=Sit3),
win_func(paint).
insert(X,Y,Who):-%trace,
sit(Sit),
take2(Sit,n,X,Y),
opposit(Who,NewWho),
for(WayX,-1,1),
for(WayY,-1,1),
sit(Sit2),
neighbour(NewWho,X,Y,Sit2,WayX,WayY),
jump(NewWho,X,Y,Sit2,WayX,WayY,NewX,NewY),
replace3(Result,Sit2,Who,X,Y,NewX,NewY,WayX,WayY),
set(sit(Result)),
fail.
insert(X,Y,Who).
neighbour(Who,X,Y,Sit,WayX,WayY):X1 is X+ WayX,
Y1 is Y+ WayY,
take2(Sit,Who,X1,Y1).
jump(Who,X,Y,Sit,WayX,WayY,X2,Y2):X1 is X+ WayX,
Y1 is Y+ WayY,
opposit(Who,NewWho),
neighbour(NewWho,X1,Y1,Sit,WayX,WayY),
X2 is X1+ WayX,
Y2 is Y1+ WayY.
jump(Who,X,Y,Sit,WayX,WayY,NewX,NewY):X1 is X+ WayX,
Y1 is Y+ WayY,
neighbour(Who,X1,Y1,Sit,WayX,WayY),
jump(Who,X1,Y1,Sit,WayX,WayY,NewX,NewY).
take3(Sit,El,0,0):take2(Sit,El,0,0).
take3(Sit,El,0,9):take2(Sit,El,0,9).
take3(Sit,El,9,0):take2(Sit,El,9,0).
13

take3(Sit,El,9,9):take2(Sit,El,9,9).
take3(Sit,El,X,Y):take2(Sit,El,X,Y).
take2(Sit,El,X,Y):take(Sit,Row,Y),
take(Row,El,X).
replace2(Result,Sit,El,X,Y):take(Sit,Line,Y),
replace(NewLine,Line,El,X),
replace(Result,Sit,NewLine,Y).
replace3(Result,Result,Who,X,Y,X,Y,WayX,WayY).
replace3(Result,Sit,Who,X,Y,ToX,ToY,WayX,WayY):replace2(ResultP,Sit,Who,X,Y),
X1 is X + WayX,
Y1 is Y + WayY,
replace3(Result,ResultP,Who,X1,Y1,ToX,ToY,WayX,WayY).
replace([New,B,C,D,E,F,G,H,K],[_,B,C,D,E,F,G,H,K],New,0).
replace([A,New,C,D,E,F,G,H,K],[A,_,C,D,E,F,G,H,K],New,1).
replace([A,B,New,D,E,F,G,H,K],[A,B,_,D,E,F,G,H,K],New,2).
replace([A,B,C,New,E,F,G,H,K],[A,B,C,_,E,F,G,H,K],New,3).
replace([A,B,C,D,New,F,G,H,K],[A,B,C,D,_,F,G,H,K],New,4).
replace([A,B,C,D,E,New,G,H,K],[A,B,C,D,E,_,G,H,K],New,5).
replace([A,B,C,D,E,F,New,H,K],[A,B,C,D,E,F,_,H,K],New,6).
replace([A,B,C,D,E,F,G,New,K],[A,B,C,D,E,F,G,_,K],New,7).
replace([A,B,C,D,E,F,G,H,New],[A,B,C,D,E,F,G,H,_],New,8).

take([El,_,_,_,_,_,_,_,_],El,0).
take([_,El,_,_,_,_,_,_,_],El,1).
take([_,_,El,_,_,_,_,_,_],El,2).
take([_,_,_,El,_,_,_,_,_],El,3).
take([_,_,_,_,El,_,_,_,_],El,4).
take([_,_,_,_,_,El,_,_,_],El,5).
take([_,_,_,_,_,_,El,_,_],El,6).
take([_,_,_,_,_,_,_,El,_],El,7).
take([_,_,_,_,_,_,_,_,El],El,8).
victory(Who,[[Who,_,_,_,_,_,_,_,_],_,_,_,_,_,_,_,_]).
victory(Who,[[_,Who,_,_,_,_,_,_,_],_,_,_,_,_,_,_,_]).
victory(Who,[[_,_,Who,_,_,_,_,_,_],_,_,_,_,_,_,_,_]).
victory(Who,[[_,_,_,Who,_,_,_,_,_],_,_,_,_,_,_,_,_]).
victory(Who,[[_,_,_,_,Who,_,_,_,_],_,_,_,_,_,_,_,_]).
victory(Who,[[_,_,_,_,_,Who,_,_,_],_,_,_,_,_,_,_,_]).
14

victory(Who,[[_,_,_,_,_,_,Who,_,_],_,_,_,_,_,_,_,_]).
victory(Who,[[_,_,_,_,_,_,_,Who,_],_,_,_,_,_,_,_,_]).
victory(Who,[[_,_,_,_,_,_,_,_,Who],_,_,_,_,_,_,_,_]).
victory(Who,[_,[Who,_,_,_,_,_,_,_,_],_,_,_,_,_,_,_]).
victory(Who,[_,[_,Who,_,_,_,_,_,_,_],_,_,_,_,_,_,_]).
victory(Who,[_,[_,_,Who,_,_,_,_,_,_],_,_,_,_,_,_,_]).
victory(Who,[_,[_,_,_,Who,_,_,_,_,_],_,_,_,_,_,_,_]).
victory(Who,[_,[_,_,_,_,Who,_,_,_,_],_,_,_,_,_,_,_]).
victory(Who,[_,[_,_,_,_,_,Who,_,_,_],_,_,_,_,_,_,_]).
victory(Who,[_,[_,_,_,_,_,_,Who,_,_],_,_,_,_,_,_,_]).
victory(Who,[_,[_,_,_,_,_,_,_,Who,_],_,_,_,_,_,_,_]).
victory(Who,[_,[_,_,_,_,_,_,_,_,Who],_,_,_,_,_,_,_]).
victory(Who,[_,_,[Who,_,_,_,_,_,_,_,_],_,_,_,_,_,_]).
victory(Who,[_,_,[_,Who,_,_,_,_,_,_,_],_,_,_,_,_,_]).
victory(Who,[_,_,[_,_,Who,_,_,_,_,_,_],_,_,_,_,_,_]).
victory(Who,[_,_,[_,_,_,Who,_,_,_,_,_],_,_,_,_,_,_]).
victory(Who,[_,_,[_,_,_,_,Who,_,_,_,_],_,_,_,_,_,_]).
victory(Who,[_,_,[_,_,_,_,_,Who,_,_,_],_,_,_,_,_,_]).
victory(Who,[_,_,[_,_,_,_,_,_,Who,_,_],_,_,_,_,_,_]).
victory(Who,[_,_,[_,_,_,_,_,_,_,Who,_],_,_,_,_,_,_]).
victory(Who,[_,_,[_,_,_,_,_,_,_,_,Who],_,_,_,_,_,_]).
victory(Who,[_,_,_,[Who,_,_,_,_,_,_,_,_],_,_,_,_,_]).
victory(Who,[_,_,_,[_,Who,_,_,_,_,_,_,_],_,_,_,_,_]).
victory(Who,[_,_,_,[_,_,Who,_,_,_,_,_,_],_,_,_,_,_]).
victory(Who,[_,_,_,[_,_,_,Who,_,_,_,_,_],_,_,_,_,_]).
victory(Who,[_,_,_,[_,_,_,_,Who,_,_,_,_],_,_,_,_,_]).
victory(Who,[_,_,_,[_,_,_,_,_,Who,_,_,_],_,_,_,_,_]).
victory(Who,[_,_,_,[_,_,_,_,_,_,Who,_,_],_,_,_,_,_]).
victory(Who,[_,_,_,[_,_,_,_,_,_,_,Who,_],_,_,_,_,_]).
victory(Who,[_,_,_,[_,_,_,_,_,_,_,_,Who],_,_,_,_,_]).
victory(Who,[_,_,_,_,[Who,_,_,_,_,_,_,_,_],_,_,_,_]).
victory(Who,[_,_,_,_,[_,Who,_,_,_,_,_,_,_],_,_,_,_]).
victory(Who,[_,_,_,_,[_,_,Who,_,_,_,_,_,_],_,_,_,_]).
victory(Who,[_,_,_,_,[_,_,_,Who,_,_,_,_,_],_,_,_,_]).
victory(Who,[_,_,_,_,[_,_,_,_,Who,_,_,_,_],_,_,_,_]).
victory(Who,[_,_,_,_,[_,_,_,_,_,Who,_,_,_],_,_,_,_]).
victory(Who,[_,_,_,_,[_,_,_,_,_,_,Who,_,_],_,_,_,_]).
victory(Who,[_,_,_,_,[_,_,_,_,_,_,_,Who,_],_,_,_,_]).
victory(Who,[_,_,_,_,[_,_,_,_,_,_,_,_,Who],_,_,_,_]).
victory(Who,[_,_,_,_,_,[Who,_,_,_,_,_,_,_,_],_,_,_]).
victory(Who,[_,_,_,_,_,[_,Who,_,_,_,_,_,_,_],_,_,_]).
victory(Who,[_,_,_,_,_,[_,_,Who,_,_,_,_,_,_],_,_,_]).
victory(Who,[_,_,_,_,_,[_,_,_,Who,_,_,_,_,_],_,_,_]).
victory(Who,[_,_,_,_,_,[_,_,_,_,Who,_,_,_,_],_,_,_]).
victory(Who,[_,_,_,_,_,[_,_,_,_,_,Who,_,_,_],_,_,_]).
15

victory(Who,[_,_,_,_,_,[_,_,_,_,_,_,Who,_,_],_,_,_]).
victory(Who,[_,_,_,_,_,[_,_,_,_,_,_,_,Who,_],_,_,_]).
victory(Who,[_,_,_,_,_,[_,_,_,_,_,_,_,_,Who],_,_,_]).
victory(Who,[_,_,_,_,_,_,[Who,_,_,_,_,_,_,_,_],_,_]).
victory(Who,[_,_,_,_,_,_,[_,Who,_,_,_,_,_,_,_],_,_]).
victory(Who,[_,_,_,_,_,_,[_,_,Who,_,_,_,_,_,_],_,_]).
victory(Who,[_,_,_,_,_,_,[_,_,_,Who,_,_,_,_,_],_,_]).
victory(Who,[_,_,_,_,_,_,[_,_,_,_,Who,_,_,_,_],_,_]).
victory(Who,[_,_,_,_,_,_,[_,_,_,_,_,Who,_,_,_],_,_]).
victory(Who,[_,_,_,_,_,_,[_,_,_,_,_,_,Who,_,_],_,_]).
victory(Who,[_,_,_,_,_,_,[_,_,_,_,_,_,_,Who,_],_,_]).
victory(Who,[_,_,_,_,_,_,[_,_,_,_,_,_,_,_,Who],_,_]).
victory(Who,[_,_,_,_,_,_,_,[Who,_,_,_,_,_,_,_,_],_]).
victory(Who,[_,_,_,_,_,_,_,[_,Who,_,_,_,_,_,_,_],_]).
victory(Who,[_,_,_,_,_,_,_,[_,_,Who,_,_,_,_,_,_],_]).
victory(Who,[_,_,_,_,_,_,_,[_,_,_,Who,_,_,_,_,_],_]).
victory(Who,[_,_,_,_,_,_,_,[_,_,_,_,Who,_,_,_,_],_]).
victory(Who,[_,_,_,_,_,_,_,[_,_,_,_,_,Who,_,_,_],_]).
victory(Who,[_,_,_,_,_,_,_,[_,_,_,_,_,_,Who,_,_],_]).
victory(Who,[_,_,_,_,_,_,_,[_,_,_,_,_,_,_,Who,_],_]).
victory(Who,[_,_,_,_,_,_,_,[_,_,_,_,_,_,_,_,Who],_]).

victory(Who,[_,_,_,_,_,_,_,_,[Who,_,_,_,_,_,_,_,_]]).
victory(Who,[_,_,_,_,_,_,_,_,[_,Who,_,_,_,_,_,_,_]]).
victory(Who,[_,_,_,_,_,_,_,_,[_,_,Who,_,_,_,_,_,_]]).
victory(Who,[_,_,_,_,_,_,_,_,[_,_,_,Who,_,_,_,_,_]]).
victory(Who,[_,_,_,_,_,_,_,_,[_,_,_,_,Who,_,_,_,_]]).
victory(Who,[_,_,_,_,_,_,_,_,[_,_,_,_,_,Who,_,_,_]]).
victory(Who,[_,_,_,_,_,_,_,_,[_,_,_,_,_,_,Who,_,_]]).
victory(Who,[_,_,_,_,_,_,_,_,[_,_,_,_,_,_,_,Who,_]]).
victory(Who,[_,_,_,_,_,_,_,_,[_,_,_,_,_,_,_,_,Who]]).
ask1:message("Game over","Horee Android menang",!),
beep("image\\tpuk.wav"),close_window(_).
ask2:message("Game over","Yah kali ini IOS yang menang",!),
beep("image\\ngis.wav"),close_window(_).
opposit(b,w).
opposit(w,b).

16

DAFTAR PUSTAKA
http:// informatika.org/~rinaldi/Stmik/2007-2008/Makalah2008/MakalahI
http://ewindarwin10.blogspot.com/2012/04/game-othello-9x9-spongebob.html
http://en.wikipedia.org/wiki/Greedy_algorithm
http://genethello.blogspot.com/2011/06/strategi-bermain-othello.html

GLOSSARIUM
Algoritma
Dalam matematika dan komputasi, algoritma merupakan kumpulan perintah
untuk menyelesaikan suatu masalah. Perintah-perintah ini dapat diterjemahkan
secara bertahap dari awal hingga akhir. Algoritma akan dapat selalu berakhir untuk
semua kondisi awal yang memenuhi kriteria. Algoritma sering mempunyai langkah
pengulangan

(iterasi)

atau

memerlukan

keputusan

(logika

Boolean

dan

perbandingan) sampai tugasnya selesai.

Algoritma Greedy
Algoritma greedy adalah algoritma heuristic membuat pilihan yang tepat
secara lokal pada setiap tahap dengan harapan mencari optimal global pemecahan
masalah berikut. Dalam banyak masalah, strategi serakah tidak pada umumnya
menghasilkan solusi yang optimal, tapi tetap saja heuristic serakah dapat
menghasilkan solusi optimal lokal yang perkiraan solusi optimal global dalam waktu
yang wajar.

Artificial Intelligence
Artificial Intelligince didefinisikan sebagai kecerdasan yang ditunjukkan oleh
suatu entitas buatan. Sistem seperti ini umumnya dianggap komputer. Kecerdasan
diciptakan dan dimasukkan ke dalam suatu mesin (komputer) agar dapat melakukan
pekerjaan seperti yang dapat dilakukan manusia.

Initial States
Initial States adalah sebuah kondisi awal sebuah object sebelum ada
perubahan keadaan.
17

Prolog
Prolog merupakan singkatan dari Programming in Logic. Pertama kali
dikembangkan oleh Alain Colmetrouer dan P. Roussel di Universitas Marseilles
Perancis tahun 1972. Selama tahun 70-an, prolog menjadi popular di Eropa untuk
aplikasi AI. Sedangkan di Amerika Serikat, para peneliti juga mengembangkan
bahasa lain untuk aplikasi yaitu LISP.

Reversy
Permainan yang terdapat pada Strawberry Prolog. Reversy adalah permainan
dengan memperebutkan daerah papan dengan cara membalik bidak lawan menjadi
bidak sendiri.

Strawberry Prolog
Strawberry Prolog adalah dialek dari bahasa pemrograman Prolog.
Sintaksnya sangat dekat dengan ISO-Prolog tapi itu memiliki banyak ekstensi yang
bukan bagian dari standar. Gagasan utama dari Strawberry Prolog adalah sangat
mudah digunakan dan itulah mengapa beberapa universitas menggunakannya untuk
prolog kursus mereka.

18