Skenario Game : Squares Game (Strawberry Prolog)

Nama : Dwi Jayanti Purwantini

NPM : 52412286

Kelas : 3ia17

Jurusan : Teknik Informatika

Fakultas : Teknologi Industri

Universitas Gunadarma

• Initial State

Initial State Yang digunakan sebagai acuan untuk membuat game squares ini adalah, pembuatan papan permainannya dan penentuan posisi awal AI. Untuk papan permainan saya menggunakan papan 2 dimensi yang memiliki ukuran 6 x 6. Papan pada permainan ini hanya terdiri dari titik-titik yang sejajar. Dalam permainan ini baik kita maupun komputer akan membuat garis dengan warna yang sama yaitu hitam, hal ini saya rasa akan membuat permainan menjadi menarik dimana selain berusaha untuk menang kita juga harus mengingat garis yang mana saja yang telah kita buat dan mana yang dibuat oleh komputer.Langkah yang bisa kita maupun komputer lakukan hanyalah menghubungkan titik-titik yang ada secara horizontal maupun vertikal dengan garis. Untuk dapat melakukan ini kita hanya perlu mengklik di tengah-tengah posisi antar titik yang ingin kita hubungkan.

Dalam game ini juga saya mambahkan menu bar yang dapat dipilih user, ada mulai baru yang akan membuat dapat kembali ke set awal dari permainan, cara bermain merupakan menu yang aka mengeluarkan pesan mengenai cara bermain dan keluar merupakan menu untuk mengakhiri program.

Gambar 1.1 tampilan awal permainan

1.2. Rules

Aturan main (Rule) yang digunakan pada games square ini adalah sebagai berikut :

1. Kita berjalan dengan cara mengklik diantara dua titik yang tersedia
2. Kedua titik yangakan membuat garis bisa berupa horizontal maupun vertical garisnya
3. Dari garis yang telah dibuat akan saling terhubung dan menciptakan blok persegi
4. Kita tidak bisa mengklik di sembarang tempat, melainkan di tengah-tengah antara kedua titik.
5. Kita bermain secara bergantian dengan pemain lawan (komputer), 1 langkah kita dan 1

langkah komputer.

6. Berikutnya adalah lawan, dan itu berlangsung secara terus-menerus sampai membuat banyak

kotak.

7. Dalam hal ini, pemain yang dapat menciptakan blok persegi yang paling banyak adalah

pemenangnya kita kotak warna oranye, komputer berawarna biru tua.

Gambar 2.2 warna blok persegi komputer

Gambar 2.3 warna blok persegi kita

Gambar 2.1 ketika mulai bermain

1.3. Goals

Goals atau tujuan dalam game ini adalah berusaha untuk bisa membuat blok persegi kita lebih banyak dari lawan atau komputer. User harus pintar-pintar menyambungkan titik-titik di papan agar tidak dikecohkan komputer dalam pembuatan blok persegi. Dalam Game ini  terdapat jumlah titik hubung adalah sebanyak 36 , blok persegi yang dapat dibuat sebanyak 25 blok yang dibentuk dari titik hubung tersebut. Tetapi hampir tidak mungkin untuk bisa memenuhi papan hanya dengan blog persegi kita maksimal hanya 1 kurang dari penuh. Pergerakan Ai dalam game ini masih cukup mudah ditebak sehingga, setelah mempelajarinya kita dapat mudah menang.

Gambar 3.1 kondisi user kalah                                    Gambar 3.2 kondisi user kalah

Gambar 3.3 kondisi user menang                                Gambar 3.4 kondisi user menang

Tentu selain kondisi kalah dan menang yang ditunjukan gambar diatas masih ada beberapa lagi, Yang menjadi point untama sekali lagi dalam game ini hanya yang membuat blog persegi dengan menyambung titik-titik yang ada terbanyak dialah yang menang.

1.4. Konsep AI

Dalam game squares ini, konsep Ai yang digunakan adalah algoritma minimax yang merupakan algoritma yang menjadi basis dari permainan yang menggunakan Ai.  Pada algoritma minimax, pengecekan akan seluruh kemungkinan yang ada sampai akhir permainan dilakukan. Pengecekan tersebut akan menghasilkan pohon permainan yang berisi semua kemungkinan tersebut. Tentunya dibutuhkan resource yang berskala besar untuk menangani komputasi pencarian pohon solusi tersebut berhubung kombinasi kemungkinan untuk sebuah permainan catur pada setiap geraknya sangat banyak sekali. Keuntungan yang didapat dengan menggunakan algoritma minimax yaitu algoritma minimax mampu menganalisis segala kemungkinan posisi permainan untuk menghasilkan keputusan yang terbaik karena algoritma minimax ini bekerja secara rekursif dengan mencari langkah yang akan membuat lawan mengalami kerugian minimum. Semua strategi lawan akan dihitung dengan algoritma yang sama dan seterusnya. Ini berarti, pada langkah pertama komputer akan menganalisis seluruh pohon permainan. Dan untuk setiap langkahnya, komputer akan memilih langkah yang paling membuat lawan mendapatkan keuntungan minimum, dan yang paling membuat komputer itu sendiri mendapatkan keuntungan maksimum. Dalam penentuan keputusan tersebut dibutuhkan suatu nilai yang merepresentasikan kerugian atau keuntungan yang akan diperoleh jika langkah tersebut dipilih. Untuk itulah disini digunakan sebuah fungsi heurisitic untuk mengevaluasi nilai sebagai nilai yang merepresentasikan hasil permainan yang akan terjadi jika langkah tersebut dipilih. Dengan menggunakan algoritma ini komputer akan dapat menganalisa dimana titik yang bila ditambahkan satu garis lagi maka komputer akan dapat membuat blok persegi.

Selain algoritma minimax disini juga digunakan algoritma greedy yang merupakan algoritma yang mengambil solusi atau metode dengan cara menyelesaikan langkah per langkah untuk mendapatkan solusi optimal tanpa memikirkan apa konsekunsi yang terjadi di depannya. Karena menggunakan algortima ini cara komputer melangkah menjadi mudah di tebak.

1.5. Instalasi Strawberry Prolog

• Download atau dapatkan software strawberry prolog.
• Ekstrak ke direktori yang diinginkan, semisal di direktori system atau C.
• Lalu klik software strawberry prolog dengan bentuk icon strawberry, dan program siap dijalankan.
• Ketika icon strawberry di klik dan di jalankan, maka tampilan dari strawberry prolog itu sendiri akan muncul dengan tampilan blank output apabila belum pernah digunakan sebelumnya.
• Apabila sudah ada pernah menjalankan program, maka ada listing program yang dipakai sebelumnya.

1.6. Listing

?-

pen(2,rgb(0,0,0)), % warna dot dan garis, angka 2 ketebalan

retractall(my(_,_)),

retractall(your(_,_)),

set(pos([[y,n,n],[n,n,n],[n,n,n],[n,n,n]],[[n,n,n,n],[n,n,n,n],[n,n,n,n]],0)), % posisi awal Ai 3 horizontal 4 vertikal

window(_,_,func(_),”Squares”,500,100,430,470).

func(init):-

menu(pop_up, _, _, myPopUpGame(_), “&Mulai baru”),

menu( normal, _, _, menu_help(_), “&Cara Bermain”),

menu( normal, _, _, menu_exit(_), “&Keluar”).

menu_help(press) :-

message(“Cara Bermain”,” “,_).

menu_exit(press) :-

close_window(_).

mem3([E,_,_],E,0).

mem3([_,E,_],E,1).

mem3([_,_,E],E,2).

replace3([E,A,B],[_,A,B],E,0).

replace3([A,E,B],[A,_,B],E,1).

replace3([A,B,E],[A,B,_],E,2).

mem4([E,_,_,_],E,0).

mem4([_,E,_,_],E,1).

mem4([_,_,E,_],E,2).

mem4([_,_,_,E],E,3).

replace4([E,A,B,C],[_,A,B,C],E,0).

replace4([A,E,B,C],[A,_,B,C],E,1).

replace4([A,B,E,C],[A,B,_,C],E,2).

replace4([A,B,C,E],[A,B,C,_],E,3).

move(Who,H1,V1,H2,V1,S2,X,Y,add_hsq):-

mem4(H1,Row,Y),

mem3(Row,n,X),

replace3(Row2,Row,y,X),

replace4(H2,H1,Row2,Y),

S2=0,

add_hsq2(X,Y,H2,V1,S2).

move(Who,H1,V1,H1,V2,S2,X,Y,add_vsq):-

mem3(V1,Row,Y),

mem4(Row,n,X),

replace3(V2,V1,Row2,Y),

S2=0,

add_vsq2(X,Y,H1,V2,S2).

mem_h(H,W,X,Y):-

mem4(H,Row,Y),

mem3(Row,W,X).

mem_v(V,W,X,Y):-

mem3(V,Row,Y),

mem4(Row,W,X).

func(paint):-

brush(rgb(255,69,0)),

my(I,J),

X is 70*I+30,

Y is 70*J+30,

X1 is X+70,

Y1 is Y+70,

rect(X,Y,X1,Y1),

fail.

func(paint):-

brush(rgb(100,149,237)),

your(I,J),

X is 70*I+30,

Y is 70*J+30,

X1 is X+70,

Y1 is Y+70,

rect(X,Y,X1,Y1),

fail.

func(paint):-

brush(rgb(0,0,0)),

for(I,0,5), %untuk menambah baris

for(J,0,5), %untuk menambah kolom

X is 70*I+27,

Y is 70*J+27,

X1 is X+6,

Y1 is Y+6,

ellipse(X,Y,X1,Y1),fail.

func(paint):-

pos(H,_,_),

mem4(H,Row,J),

mem3(Row,y,I),

X is 70*I+33,

Y is 70*J+30,

X1 is X+70,

line(X,Y,X1,Y),

fail.

func(paint):-

pos(_,V,_),

mem3(V,Row,J),

mem4(Row,y,I),

X is 70*I+30,

Y is 70*J+33,

Y1 is Y+70,

line(X,Y,X,Y1),

fail.

func(mouse_click(X,Y)):-

X<700,X>25,

Y<700,Y>25,

X1 is (X – 25) mod 70,

Y1 is (Y – 25) mod 70,

X1>=10,

X1=<70,

Y1=<10,

X2 is (X – 25)//70,

Y2 is (Y – 25)//70,

pos(H1,V,R),

mem4(H1,Row,Y2),

mem3(Row,n,X2),

replace3(Row2,Row,y,X2),

replace4(H2,H1,Row2,Y2),

set(pos(H2,V,R)),

add_hsq(X2,Y2,my),

retractall(p(_,_,_)),

play(H2,V,R),

update_window(_).

func(mouse_click(X,Y)):-

X<700,X>25,

Y<700,Y>25,

X1 is (X – 25) mod 70,

Y1 is (Y – 25) mod 70,

Y1>=10,

Y1=<70,

X1=<10,

X2 is (X – 25)//70,

Y2 is (Y – 25)//70,

pos(H,V1,R),

mem3(V1,Row,Y2),

mem4(Row,n,X2),

replace4(Row2,Row,y,X2),

replace3(V2,V1,Row2,Y2),

set(pos(H,V2,R)),

add_vsq(X2,Y2,my),

retractall(p(_,_,_)),

play(H,V2,R),

update_window(_).

add_hsq(X,Y,T):-

X1 is X+1,

Y1 is Y- 1,

pos(H,V,_),

mem_v(V,y,X,Y1),

mem_h(H,y,X,Y1),

mem_v(V,y,X1,Y1),

assert(T(X,Y1)),

fail.

add_hsq(X,Y,T):-

X1 is X+1,

Y1 is Y+1,

pos(H,V,_),

mem_v(V,y,X,Y),

mem_h(H,y,X,Y1),

mem_v(V,y,X1,Y),

assert(T(X,Y)),

fail.

add_hsq(X,Y,T).

add_vsq(X,Y,T):-

X1 is X- 1,

Y1 is Y+1,

pos(H,V,_),

mem_h(H,y,X1,Y),

mem_v(V,y,X1,Y),

mem_h(H,y,X1,Y1),

assert(T(X1,Y)),

fail.

add_vsq(X,Y,T):-

X1 is X+1,

Y1 is Y+1,

pos(H,V,_),

mem_h(H,y,X,Y),

mem_v(V,y,X1,Y),

mem_h(H,y,X,Y1),

assert(T(X,Y)),

fail.

add_vsq(X,Y,T).

add_hsq2(X,Y,H,V,R):-

X1 is X+1,

Y1 is Y- 1,

mem_v(V,y,X,Y1),

mem_h(H,y,X,Y1),

mem_v(V,y,X1,Y1),

R:=R+1,

fail.

add_hsq2(X,Y,H,V,R):-

X1 is X+1,

Y1 is Y+1,

mem_v(V,y,X,Y),

mem_h(H,y,X,Y1),

mem_v(V,y,X1,Y),

R:=R+1,

fail.

add_hsq2(X,Y,H,V,R).

add_vsq2(X,Y,H,V,R):-

X1 is X- 1,

Y1 is Y+1,

mem_h(H,y,X1,Y),

mem_v(V,y,X1,Y),

mem_h(H,y,X1,Y1),

R:=R+1,

fail.

add_vsq2(X,Y,H,V,R):-

X1 is X+1,

Y1 is Y+1,

mem_h(H,y,X,Y),

mem_v(V,y,X1,Y),

mem_h(H,y,X,Y1),

R:=R+1,

fail.

add_vsq2(X,Y,H,V,R).

play(H1,V1,R1):-%trace,

Max= -100,

move(o,H1,V1,H2,V2,R2,X,Y,A),

R3=100,

min_max(H2,V2,R2,R3,1),

R3>Max,

Max:=R3,

set(pos(H2,V2,R2)),

set(p(X,Y,A)),

fail.

play(H1,V1,R1):-

p(X,Y,A),!,

A(X,Y, your).

play(H1,V1,R1).

min_max(H1,V1,R1,Min,0):-!, Min:=R1.

min_max(H1,V1,R1,Min,Deep):-

Deep1 is Deep – 1,

move(x,H1,V1,H2,V2,S|_),

R2 is R1-S,

R3= -100,

max_min(H2,V2,R2,R3,Deep1),

R3<Min,

Min:=R3,

fail.

min_max(H1,V1,R1,Min,Deep).

max_min(H1,V1,R1,Max,0):- !, Max:=R1.

max_min(H1,V1,R1,Max,Deep):-

Deep1 is Deep – 1 ,

move(x,H1,V1,H2,V2,S|_),

R2 is R1+S,

R3=100,

min_max(H2,V2,R2,R3,Deep1),

R3>Max,

Max:=R3,

fail.

max_min(H1,V1,R1,Max,Deep).

1.7. Kesimpulan

Dalam game squares ini terdapat 2 pemain yang satu user dan satu lagi komputer. Pada permainan ini kedua pihak saling berusaha untuk mengalahkan lawanya dengan membuat blok persegi lebih banyak dari lawannya. Tentu untuk dapat memenangkan game ini dari komputer terdapat banyak kemungkinan. Dan selain itu, algoritma yang dipakai dalam game ini adalah algortima greedy dan algoritma minimax.