Membuat game catur Pion & Queen dengan Strawberry Prolog

Instalasi Prolog

Strawberry Prolog merupakan sebuah bahasa pemrograman logika. Memiliki object oriented language. Pada prolog ini tidak terdapat prosedur, hanya terdapat kumpulan data yang akan diolah. Untuk menggunakan strawberry prolog tidak dilakukan instalasi. Programmer dapat meng-unduhnya secara gratis di website resminya. Namun karena penggunaannya yang gratis, pada strawberry prolog ini, games chess tidak dapat membentuk sebuah file execute (exe). Jadi program dapat dijalankan dengan membuka file strawberry prolog (spj) didalam strawberry prolog itu sendiri

Untuk membuka file spj-nya, pilih pada menu bar FILE ¡÷ OPEN kemudian pilih file Chess.spj.

Untuk menjalankan game dapat menggunakan shortcut F5

. Atau pada menu bar pilih RUN ¡÷ RUN

Tema Game

Dalam pembuatan Project menggunakan Strawberry Prolog saya membuat game dengan nama Pion & Queen dimana dalam permainan ini sama dengan permainan catur hanya saja disini hanya menggunakan bidak Pion,queen,dan raja tidak seperti game catur pada umumnya yang menggunakan lebih banyak jenis bidak.

Initial State

Permainan divisualisasikan di atas media ( papan ) yang terdiri dari 8 lajur dan 8 baris. Kotak/petak berwarna coklat muda dan coklat tua (atau terang dan gelap) secara berselang seling. Permainan dimulai dengan menggunakan 24 buah perlengkapaan permainan yang terdapat pada masing-masing bidang permainan yang disusun berbaris secara khusus pada sisi papan catur secara berhadap-hadapan. Satu buah hanya bisa menempati satu petak. Pada bagian terdepan masing-masing barisan - terdapat 8 pion , diikuti di belakangnya 4 pion dan 4 queen dimana 4 queen tersebut berada ditengah,kemudian dibagian paling belakang terdapat 7 pion dan 1 raja. User dapat memilih melawan komputer (CPU) ataupun user lainnya. User juga dapat memilih warna buah yang akan dimainkan, apakah putih atau hitam. Pemegang buah putih memulai langkah pertama, yang selanjutnya diikuti oleh pemegang buah hitam secara bergantian.

Goal

Game ini dimenangkan apabila dimana kondisi dari raja lawan dalam keadaan terdesak dan tidak bisa melarikan diri lagi,maka anda akan dinyatakan sebagai pemenang.bila keadaan yang sama dialami raja anda maka anda yang akan kalah.

Rule

Langkah pertama pion dapat melangkah maksimal dua langkah ke depan, dengan satu langkah seterusnya. Pion dapat memakan buah lawan yang berada tepat satu kotak di depan kiri atau depan kanan bidak.

 Ratu/menteri bisa berjalan bebas ke segala arah, baik ketika bergerak maupun ketika menangkap buah catur lawan.

 Raja bisa berjalan ke segala arah, baik ketika bergerak maupun ketika menangkap buah catur lawan, dengan maksimal satu langkah.

AI

Kecerdasan buatan atau artificial intelligence (AI) dalam permainan catur ini adalah ketika user selesai menggerakkan buah caturnya, lawan (CPU) akan membaca seluruh kemungkinan langkah yang dapat kita lakukan pada giliran berikutnya. Jika buah raja CPU akan mendapat ancaman dalam beberapa langkah ke depan maka CPU akan membuat langkah antisipasi untuk menggagalkan serangan lawan. Namun jika CPU merasa tidak dalam ancaman maka ia akan membangun serangan untuk meng-skak mat lawannya.

Batas Usia

Dalam bermain game Pion & Queen yang saya buat tidak ada batas usia tertentu kepada para pemainya,asal pemain sudah bisa memainkanya,.Game ini juga mendidik untuk anak-anak untuk mengasa otak dan juga agar anak terbiasa dengan strategi dimana dibiasakan dalam game ini.

Level

Level adalah tingkat kesulitan permainan. Dalam permainan ini terdapat empat tingkat kesulitan, yaitu,Beginner, Pemula,Normal,Advenced dan Expert. Kita dapat memilih tingkat kesulitan permainan yang akan dimainkan.

Algoritma Game

I.Algoritma Minimax

Algoritma Minimax merupakan basis dari semua permainan berbasis AI seperti permainan catur misalnya. AI permainan catur tentunya sudah sangat terkenal dimana AI tersebut bahkan dapat mengalahkan juara dunia sekalipun.

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. Biasanya pada permainan tic tac toe ini digunakan nilai 1,0,-1 untuk mewakilkan hasil akhir permainan berupa menang, seri, dan kalah. Dari nilai-nilai heuristic inilah komputer akan menentukan simpul mana dari pohon permainan yang akan dipilih, tentunya simpul yang akan dipilih tersebut adalah simpul dengan nilai heuristic yang akan menuntun permainan ke hasil akhir yang menguntungkan bagi komputer.

II.Algoritma NegaMax

NegaMax adalah struktur fundamental di mana menjadi dasar bagi setiap algoritma pencarian terhadap chess tree. NegaMax mengimplementasikan pemikiran bahwa semakin buruk langkah yang dilakukan oleh lawan artinya langkah yang kita lakukan semakin baik.Mengimplementasikan pemikiran ini sebenarnya mudah. Pemikiran ini menggunakan dasar bahwa catur adalah sebuah

permainan symmetrical, oleh sebab itu maka fungsi analisis haruslah mengeluarkan nilai yang simetris. Jadi pada setiap posisi nilai dari langkah yang dilakukan oleh putih adalah negasi dari langkah yang dilakukan oleh hitam, atau bisa dibilang bahwa jumlah dari nilai keduanya adalah 0. Apabila putih unggul satu pion maka sudah jelas bahwa hitam tertinggal sebanyak jumlah yang sama.Prinsip yang sama dapat diperluas ke dalam keunggulan posisi,

Dasar dari algoritma ini adalah bahwa chess tree search merupakan pergantian antara maksimalisasi dan minimalisasi nilai dari posisi pada pohon; biasa disebut dengan proses minimax. Untuk membedakan posisi antara pemain dengan lawannya, nilai dari suatu posisi selalu dievaluasi dari sudut pandang pemain yang akan berjalan, hal ini dilakukan dengan melakukan negasi terhadap nilai yang dilihat oleh lawan ini disebut dengan proses negamax.

OUTPUT

Raja terdesak tidak bisa melarikan diri,sehingga anda kalah

Kondisi Seri 

Listing Program

% If you want to understand this program look at

% its rough variant "chess rough.pro".

% It is easier to understand because

% "Chess.spj" contains too many details.

level(1, 2, 1, 5).

level(2, 3, 3, 15).

level(3, 4, 6, 30).

level(4, 5, 30, 150).

?-

G_AuCh=0,

G_Level=2,

G_Deep=0,

G_Move=0,

G_Forward=0,

G_I=0,

G_Play_with_Blacks=0,

G_Play_with_Computer=1,

array(val,100,0),

array(maximum,100,0),

array(i,1000,0),

array(j,1000,0),

array(x,1000,0),

array(y,1000,0),

array(val2,1000,0),

array(index,1000,0),

G_chessboard is bitmap_image("chess_pic\\chessboard.bmp",_),

G_squareW is bitmap_image("chess_pic\\squareW.bmp",_),

G_squareB is bitmap_image("chess_pic\\squareB.bmp",_),

G_KingW1 is bitmap_image("chess_pic\\KingW1.bmp",_),

G_KingW2 is bitmap_image("chess_pic\\KingW2.bmp",_),

G_PawnW1 is bitmap_image("chess_pic\\PawnW1.bmp",_),

G_PawnW2 is bitmap_image("chess_pic\\PawnW2.bmp",_),

G_KingB1 is bitmap_image("chess_pic\\KingB1.bmp",_),

G_KingB2 is bitmap_image("chess_pic\\KingB2.bmp",_),

G_QueenW1 is bitmap_image("chess_pic\\QueenW1.bmp",_),

G_QueenW2 is bitmap_image("chess_pic\\QueenW2.bmp",_),

G_QueenB1 is bitmap_image("chess_pic\\QueenB1.bmp",_),

G_QueenB2 is bitmap_image("chess_pic\\QueenB2.bmp",_),

G_PawnB1 is bitmap_image("chess_pic\\PawnB1.bmp",_),

G_PawnB2 is bitmap_image("chess_pic\\PawnB2.bmp",_),

window(G_Win,_,chess_func(_),"PION & QUEEN)",10,150,512,550).

levelm(init):-

menu(normal,_,_,l2(_),"&Pemula"),

menu(checked,_,_,l3(_),"&Normal"),

menu(normal,_,_,l4(_),"&Lanjutan"),

menu(normal,_,_,l5(_),"&Profesional"),

menu(separator, _,_,fail(_),_),

menu(normal,_,_,automatic_change(_),"Otomatis perubahan Deep ").

l2(press):-change_level(1).

l3(press):-change_level(2).

l4(press):-change_level(3).

l5(press):-change_level(4).

automatic_change(press):-

G_AuCh:=1-G_AuCh,

(G_AuCh=0->

modify_menu(G_Menu1,6,normal,_)

else

modify_menu(G_Menu1,6,checked,_)

).

change_level(M):-

G_Deep:=0,

modify_menu(G_Menu1,G_Level,normal,_),

G_Level:=M, modify_menu(G_Menu1,M,checked,_).

changem(init):-

menu(normal,_,_,play_with_blacks(_),"&Gunakan bidak Hitam"),

menu(checked,_,_,play_with_computer(_),"&Bermain dengan komputer").

play_with_blacks(press):-

(G_Play_with_Computer=0->

message("", "Kamu hanya bisa mengganti jika memilih Bermain dengan komputer!", s)

else

change_side,

pos(G_Move, C1, WantsStalemate, Pos),

G_WantsStalemate:=0-WantsStalemate,

opposite(C1, C2),

computer(C1,C2,Pos)

).

change_side:-

G_Play_with_Blacks:=1-G_Play_with_Blacks,

(G_Play_with_Blacks=0->

modify_menu(G_Menu2,1,normal,_)

else

modify_menu(G_Menu2,1,checked,_)

).

play_with_computer(press):-

G_Play_with_Computer:=1-G_Play_with_Computer,

(G_Play_with_Computer=0->

modify_menu(G_Menu2,2,normal,_)

else

modify_menu(G_Menu2,2,checked,_)

).

back(press):-

G_Move:=G_Move - 1,

(G_Move=0->

modify_menu(G_Win,3,grayed,_),

draw_menu_bar(_)

),

(G_Forward=0->

modify_menu(G_Win,4,normal,_),

draw_menu_bar(_)

),

G_Forward:=G_Forward + 1,

set_some_text,

update_window(_).

forward(press):-

(G_Move=0->

modify_menu(G_Win,3,normal,_),

draw_menu_bar(_)

),

G_Move:=G_Move + 1,

G_Forward:=G_Forward - 1,

(G_Forward=0->

modify_menu(G_Win,4,grayed,_),

draw_menu_bar(_)

),

set_some_text,

update_window(_).

set_some_text:-

pos(G_Move, C, _, _),

(G_Play_with_Blacks=\=true_value(C=b)->

change_side

),

(C=b->

set_text("Play with Blacks", _)

else (C=w->

set_text("Play with Whites", _)

else

set_text("Game Over", _)

)).

set_pos(C, Pos) :-

(G_Move=0->

modify_menu(G_Win,3,normal,_),

draw_menu_bar(_)

),

(G_Forward>0->

modify_menu(G_Win,4,grayed,_),

draw_menu_bar(_)

),

G_Move:=G_Move+1,

G_Forward:=0,

write(pos(G_Move, C, G_WantsStalemate, Pos)),nl,

retractall(pos(G_Move,_,_,_)),

assert(pos(G_Move,C,G_WantsStalemate,Pos)).

chess_func(init):-

menu(pop_up, G_Menu1,_,levelm(_),"&Level"),

menu(pop_up, G_Menu2,_,changem(_),"&Ubah"),

menu(normal, _, _, menu_about(_), "&Pembuat"),

menu(normal, _, _, menu_bantuan(_), "&Bantuan"),

menu(normal,_,_,menu_exit(_),"Keluar").

chess_func(paint):-

draw_bitmap(0,0,G_chessboard,_,_),

fail.

chess_func(paint):-

pos(G_Move, _, _, Pos),

mem(Row, Pos,J),

mem(Fig, Row,I),

draw_fig(Fig,I,J),

fail.

menu_new(press) :-

window( _, 0, chess_func(_),"Pion & Queen",10,150,512,550).

menu_exit(press):-

close_window(_).

menu_about(press):-

shell_execute("datadiri.txt").

menu_bantuan(press):-

shell_execute("MANUAL_BOOK.PDF").

chess_func(close) :-

not( yes_no("","Yakin anda ingin keluar??", ?)).

chess_func(mouse_click(X,Y)):-

I :=X//50,

J :=Y//50,

I>0, I=<8 span="">

J>0, J=<8 span="">

pos(G_Move, C1, WantsStalemate, Pos),

opposite(C1, C2),

mem(Row,Pos,J),

mem(Fig,Row,I),

(G_I=0 ->

Fig=[_|C1],

G_Fig:=Fig,

clean_field(I, J),

G_I:=I,

G_J:=J

else (can_move(G_Fig,G_I,G_J,I,J,Pos,Fig2), not(Fig2=[_|C1])->

move0(G_I,G_J,Pos,I,J,Pos2),

(check(C1, C2, Pos2)->

message("Salah Langkah", "Gunakan langkah lain atau raja anda mati!! ", !),

draw_fig(G_Fig,G_I,G_J),

G_I:=0,

fail

),

(J/\6=:=0->

(G_Fig=[p|C1]->

draw_fig([q|C1],I,J)

else (G_Fig=[k|C1], abs(G_I-I)=:=2 ->

(I=3, Xm=4, Xf=1; I=7, Xm=6, Xf=8),

clean_field(Xf, J),

draw_fig([r|C1],Xm,J),

draw_fig([k|C1],I,J)

else

draw_fig(G_Fig,I,J)

))

else

draw_fig(G_Fig,I,J)

),

val(Fig2,Val),

G_WantsStalemate:=WantsStalemate+Val,

(check(C2, C1, Pos2), not(not_mate(C2, C1, Pos2))->

set_pos(n,Pos2),

set_text("Mate. You won!", _),

message("Congratulations", "You won!", !),

fail

),

(G_Play_with_Computer=1->

computer(C2,C1,Pos2)

else

change_side,

G_WantsStalemate:=0-G_WantsStalemate,

set_pos(C2, Pos2),

set_text(xy(G_I, G_J)+":"+xy(I, J)+ (G_Play_with_Blacks=1-> " (Play with Blacks)" else ""), _),

G_I:=0

)

else

draw_fig(G_Fig,G_I,G_J),

G_I:=0

)).

computer(C2,C1,Pos2):-

G_I:=0,

set_text("...", _),

G_I1:=0,

(G_Deep=0->level(G_Level,Deep,_,_), G_Deep:=Deep),

write("Deep="+G_Deep),nl,

chronometer(_),

chronometer_steps(_),

maximum(G_Deep):= -20000,

Moves:=0,

(play(C2,C1,Pos2,G_Deep,Moves); true),

chronometer(Time),

chronometer_steps(Steps),

beep,

write(maximum(G_Deep)+" for "+Time/1000+" seconds ("+Steps+" steps)"),nl,

(G_AuCh=1->

level(G_Level,_,Minimum,Maximun),

(Time<1000 inimum-="">

G_Deep:=G_Deep+1,

write("Deep+1="+G_Deep),nl

else (Time>1000*Maximun, G_Deep>2->

G_Deep:=G_Deep- 1,

write("Deep-1="+G_Deep),nl

))

),

(G_I1=0->

set_pos(n, Pos2),

set_text("JALAN BUNTU", _),

message("Jalan buntu ","Anda mengalamijalan buntu. Permainan ini seri. ", !),

fail

),

mem(Row1,Pos2,G_J1),

mem(Fig,Row1,G_I1),

can_move(Fig,G_I1,G_J1,G_I2,G_J2,Pos2,Fig2),

val(Fig2,Val),

G_WantsStalemate:=G_WantsStalemate-Val,

move0(G_I1,G_J1,Pos2,G_I2,G_J2,Pos3),

clean_field(G_I1, G_J1),

mem(Row2,Pos3,G_J2),

mem(BFig,Row2,G_I2),

(BFig=[k|C2], abs(G_I1-G_I2)=:=2 ->

(G_I2=3, XXm=4, XXf=1; G_I2=7, XXm=6, XXf=8),

clean_field(XXf, G_J2),

draw_fig([r|C2],XXm,G_J2),

draw_fig([k|C2],G_I2,G_J2)

else

draw_fig(BFig,G_I2,G_J2)

),

(check(C1, C2, Pos3)->

(not_mate(C1, C2, Pos3)->

set_text("Check", _)

else

set_pos(n, Pos3),

set_text("KAMU KALAH!", _),

message("END", "Mav anda kalah!!.", s),

fail

)

else

set_text(xy(G_I1, G_J1)+":"+xy(G_I2, G_J2)+ (G_Play_with_Blacks=1-> " (Play with Blacks)" else ""), _)

),

(not(mem(Row3,Pos3,J1), mem([F1|C1],Row3,I1), can_move([F1|C1],I1,J1,_,_,Pos3,Fig3), not(Fig3=[_|C1]))->

set_pos(n, Pos3),

set_text("JALAN BUNTU", _),

message("Jalan buntu","Permainan seri.", !),

fail

),

(not(mem(Row4,Pos3,_), mem([F2|_],Row4,_), F2\=k)->

set_pos(n, Pos3),

set_text("Tie", _),

message("Tie", "Permainan Seri.", !),

fail

),

set_pos(C1, Pos3).

play(C1,C2,Pos,Deep,Moves):-

Deep1 is Deep - 1,

(Deep1=0->

(val(Deep):=35;

mem(Row,Pos,J),

mem([Fig|C1],Row,I),

can_move([Fig|C1],I,J,X,Y,Pos,[Fig2|C2]),

take_val(Fig,Fig2,Val2,C1,C2,X,Y,Pos),

val(Deep):=Val2)

else

Moves2:=Moves,

all_moves(C1,Pos,Deep,I,J,X,Y,Val2,Moves,Moves2),

move(I,J,Pos,X,Y,Pos2,Val2),

val(Deep):=Val2,

(Val2>5000->

(Deep=:=G_Deep- 1, check(C2, C1, Pos)->

maximum(Deep1):= -5000

else

maximum(Deep1):=0

)

else

maximum(Deep1):= -20000,

(play(C2,C1,Pos2,Deep1,Moves2); true),

(maximum(Deep1) =:= -20000->

(check(C2, C1, Pos2)->

maximum(Deep1):= -10000-Deep

else

maximum(Deep1):= (1 - 2* ((G_Deep-Deep1) mod 2))*G_WantsStalemate

)

)

)

),

%(Deep=G_Deep-> write(xy(I,J)+":"+xy(X,Y)+" is "+ (val(Deep)-maximum(Deep1))), nl),

(maximum(Deep) % =< in order to see all best

maximum(Deep):=val(Deep)-maximum(Deep1),

(Deep=G_Deep->

write(xy(I,J)+":"+xy(X,Y)+" is "+ (val(Deep)-maximum(Deep1))), nl,

G_I1:=I, G_J1:=J,

G_I2:=X, G_J2:=Y,

fail

else (maximum(Deep+1) % =< in order to see all best

fail

%else

%write(Deep) % alpha-beta cutting

))

else

fail

),

!,

fail.

all_moves(C1,Pos,Deep,_,_,_,_,_,Moves,Moves2):-

mem(Row,Pos,J),

mem([Fig|C1],Row,I),

Sum1:=0,

can_hit([Fig|C1],I,J,Pos,shadow,no,Sum1),

can_move([Fig|C1],I,J,X,Y,Pos,Fig2),

not(Fig2=[_|C1]),

(Fig2=[p|_]->

Val is (C1=w-> 60+20*Y else 240- 20*Y)

else

val(Fig2,Val)

),

Val2 is Val-Sum1+Deep* (1+sign(Val//18- 1)), % 18 is val(p)

find_the_right_place(Val2,Moves,Moves2,Place),

i(Moves2):=I, j(Moves2):=J,

x(Moves2):=X, y(Moves2):=Y,

val2(Moves2):=Val2,

index(Place):=Moves2,

Moves2:=Moves2+1,

fail.

all_moves(_,_,_,I,J,X,Y,Val2,Moves,Moves2):-

for(N, Moves, Moves2- 1),

I is i(index(N)), J is j(index(N)),

X is x(index(N)), Y is y(index(N)),

Val2 is val2(index(N)).

find_the_right_place(Val2,M,M,M):- !.

find_the_right_place(Val2,Moves,Moves2,Place):-

MovesP is Moves2- 1,

(val2(index(MovesP))

index(Moves2):=index(MovesP),

find_the_right_place(Val2,Moves,MovesP,Place)

else

Moves2=Place

).

can_hit([Fig|C1],I,J,Pos,_,Try,Sum):- % the figure hits

can_move([Fig|C1],I,J,_,_,Pos,F),

(F=[Fig2|C]->

(C=C1->

Sum:=Sum+8

else

val([Fig2|_],Val2),

val([Fig|_],Val1),

(Val1

(Fig2=k->

(Try=no; not_mate(C, C1, Pos)->

Sum:=Sum+50

else

Sum:=Val2

)

else

Sum:=Sum+33

)

else

Sum:=Sum+12

)

)

else

Sum:=Sum+4

),

fail.

can_hit([Fig|C1],I,J,Pos,Shadow,_,Sum):- % other figures hit it

can_move([F|C_1],I,J,I0,J0,Pos,[F|C_2]),

not(F=p, C_1=C_2),

not(F=k, C_1=C_2),

(C_2=C1->

Sum:=Sum+ 4 % 8-4

else

val([F|_],Val2),

val([Fig|_],Val1),

(Val1>Val2->

(Fig=k->

Sum:=Sum- 46 % 50-4

else

Sum:=Sum- 29 % 33-4

)

else

Sum:=Sum- 8 % 12-4

)

),

throw_shadow(Shadow,[F|C_2],I0,J0,I,J,Pos,SumT),

(C_2=C1->

Sum:=Sum-SumT

else

Sum:=Sum+SumT

),

fail.

can_hit(_,_,_,_,_,_,_).

throw_shadow(shadow,[F|C_2],I1,J1,I2,J2,Pos,Sum):-

Sum:=0,

(F=r; F=q),

(I1=I2->

(J1

move_down(I2,J2,_,_,Pos,Fig)

else

move_up(I2,J2,_,_,Pos,Fig)

)

else (J1=J2->

(I1

move_right(I2,J2,_,_,Pos,Fig)

else

move_left(I2,J2,_,_,Pos,Fig)

)

else

fail

)),

hit([F|C_2],Fig,Sum).

throw_shadow(shadow,[F|C_2],I1,J1,I2,J2,Pos,Sum):-

(F=b; F=q),

(I1+J1=:=I2+J2->

(I1

move_right_up(I2,J2,_,_,Pos,Fig)

else

move_left_down(I2,J2,_,_,Pos,Fig)

)

else (I1-J1=:=I2-J2->

(I1

move_right_down(I2,J2,_,_,Pos,Fig)

else

move_left_up(I2,J2,_,_,Pos,Fig)

)

else

fail

)),

hit([F|C_2],Fig,Sum).

throw_shadow(shadow,[_|_],_,_,_,_,_,_).

hit([Fig|C1],F,Sum):-

(F=[Fig2|C]->

(C=C1->

Sum:=Sum+8

else

val([Fig2|_],Val2),

val([Fig|_],Val1),

(Val1

(Fig2=k->

Sum:=Sum+50

else

Sum:=Sum+33

)

else

Sum:=Sum+12

)

)

else

Sum:=Sum+4

),

fail.

move(I1,J1,Pos1,I2,J2,Pos2,Sum):-

mem(Row, Pos1, J1),

mem([F1|C1], Row, I1),

replace(f, Row, Row2,I1),

replace(Row2, Pos1, Pos1a, J1),

mem(Row3, Pos1a, J2),

(J2/\6=:=0->

(F1=p->

replace([q|C1], Row3, Row4, I2)

else (F1=k, abs(I1-I2)=:=2 ->

(I2=3, Xm=4, Xf=1; I2=7, Xm=6, Xf=8),

Sum:=Sum+50,

replace(f, Row3, Row3a, Xf),

replace([r|C1], Row3a, Row3b, Xm),

replace([F1|C1], Row3b, Row4, I2)

else

replace([F1|C1], Row3, Row4, I2)

))

else

replace([F1|C1], Row3, Row4, I2)

),

replace(Row4, Pos1a, Pos2,J2),

(mem([F2|C2], Row3, I2)->

Sum1:=0,

can_hit([F2|C2],I2,J2,Pos2,no,no,Sum1),

Sum:=Sum-Sum1,

can_hit([F1|C1],I2,J2,Pos2,no,try,Sum)

else

can_hit([F1|C1],I2,J2,Pos2,shadow,try,Sum)

).

move0(I1,J1,Pos1,I2,J2,Pos2):-

mem(Row, Pos1, J1),

mem([F1|C1], Row, I1),

replace(f, Row, Row2,I1),

replace(Row2, Pos1, Pos1a, J1),

mem(Row3, Pos1a, J2),

(J2/\6=:=0->

(F1=p->

replace([q|C1], Row3, Row4, I2)

else (F1=k, abs(I1-I2)=:=2 ->

(I2=3, Xm=4, Xf=1; I2=7, Xm=6, Xf=8),

replace(f, Row3, Row3a, Xf),

replace([r|C1], Row3a, Row3b, Xm),

replace([F1|C1], Row3b, Row4, I2)

else

replace([F1|C1], Row3, Row4, I2)

))

else

replace([F1|C1], Row3, Row4, I2)

),

replace(Row4, Pos1a, Pos2,J2).

val(f,0).

val(p,18). % Pawn move

val(d,35). % Pawn double move = 2*val(p)-1

val([p|_],100).

val([h|_],300).

val([b|_],300).

val([r|_],500).

val([q|_],1000).

val([n|_],600). % new queen

val([t|_],700). % new queen and take

val([k|_],10000).

take_val(p,p,60|_). take_val(p,h,250|_). take_val(p,b,250|_). take_val(p,r,450|_). take_val(p,q,950|_). take_val(p,k,10000|_).

take_val(k,p,100|_). take_val(k,h,300|_). take_val(k,b,300|_). take_val(k,r,500|_). take_val(k,q,1000|_). take_val(k,k,10000|_).

take_val(h|T):-

evaluate(300|T).

take_val(b|T):-

evaluate(300|T).

take_val(r|T):-

evaluate(500|T).

take_val(q|T):-

evaluate(1000|T).

evaluate(Val1,Fig,Val,C1,C2,X,Y,Pos):-

val([Fig|_],Val2),

(Val2>Val1->

Val is Val2 - Val1//2

else (can_move([F|C1],X,Y,_,_,Pos,[F|C2])->

Val=50

else

val([Fig|_],Val)

)).

%pos(0,w,0,[[rb,hb,bb,qb,kb,bb,hb,rb],[f,pb,f,f,f,f,pb,f],[f,f,f,pb,f,pb,f,f],[pb,f,pb,qw,f,f,f,pb],[f,f,f,f,pw,f,f,f],[f,pw,hw,f,f,hw,f,f],[pw,f,pw,f,f,pw,pw,pw],[rw,f,bw,f,kw,bw,f,rw]]).

pos(0, w, 0,

[[pb,pb,pb,kb,pb,pb,pb,pb],

[pb,pb,qb,qb,qb,qb,pb,pb],

[pb,pb,pb,pb,pb,pb,pb,pb],

[f,f,f,f,f,f,f,f],

[f,f,f,f,f,f,f,f],

[pw,pw,pw,pw,pw,pw,pw,pw],

[pw,pw,qw,qw,qw,qw,pw,pw],

[pw,pw,pw,kw,pw,pw,pw,pw]]).

clean_field(I, J):-

( (I+J) mod 2 =:= 0->

draw_bitmap(50*I,50*J,G_squareW,_,_)

else

draw_bitmap(50*I,50*J,G_squareB,_,_)

).

draw_fig(Fig,I,J):-

N is 1+ (I+J) mod 2,

fig(Fig, N, Bitmap),

draw_bitmap(I*50,J*50,Bitmap,_,_).

fig(pb, 1, G_PawnB1).

fig(pw, 1, G_PawnW1).

fig(kb, 1, G_KingB1).

fig(kw, 1, G_KingW1).

fig(qb, 1, G_QueenB1).

fig(qw, 1, G_QueenW1).

fig(pb, 2, G_PawnB2).

fig(pw, 2, G_PawnW2).

fig(kb, 2, G_KingB2).

fig(kw, 2, G_KingW2).

fig(qb, 2, G_QueenB2).

fig(qw, 2, G_QueenW2).

R is xy(X, Y):- R:=string_from_ASCII(X+first_ASCII("A")- 1)+ (9-Y).

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

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

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

mem(E,[_,_,_,E,_,_,_,_],4).

mem(E,[_,_,_,_,E,_,_,_],5).

mem(E,[_,_,_,_,_,E,_,_],6).

mem(E,[_,_,_,_,_,_,E,_],7).

mem(E,[_,_,_,_,_,_,_,E],8).

replace(X,[_,A,B,C,D,E,F,G],[X,A,B,C,D,E,F,G],1).

replace(X,[A,_,B,C,D,E,F,G],[A,X,B,C,D,E,F,G],2).

replace(X,[A,B,_,C,D,E,F,G],[A,B,X,C,D,E,F,G],3).

replace(X,[A,B,C,_,D,E,F,G],[A,B,C,X,D,E,F,G],4).

replace(X,[A,B,C,D,_,E,F,G],[A,B,C,D,X,E,F,G],5).

replace(X,[A,B,C,D,E,_,F,G],[A,B,C,D,E,X,F,G],6).

replace(X,[A,B,C,D,E,F,_,G],[A,B,C,D,E,F,X,G],7).

replace(X,[A,B,C,D,E,F,G,_],[A,B,C,D,E,F,G,X],8).

check(C1, C2, Pos):-

mem(Row,Pos,J),

mem([k|C1],Row,I),

can_move([Fig|C1],I,J,_,_,Pos,[Fig|C2]).

not_mate(C1, C2, Pos):-

mem(Row,Pos,J),

mem([Fig|C1],Row,I),

can_move([Fig|C1],I,J,X,Y,Pos,Fig2),

not(Fig2=[_|C1]),

move0(I,J,Pos,X,Y,Pos2),

not(check(C1, C2, Pos2)).

opposite(w, b).

opposite(b, w).

can_move([k|Color], X1,Y1,X2,Y2,Pos,Fig):-

(X2 is X1+1; X2 is X1 - 1; X2=X1),

(Y2 is Y1+1; Y2 is Y1 - 1;Y2=Y1),

not(X1=X2,Y1=Y2),

mem(Row,Pos,Y2),

mem(Fig,Row,X2),

opposite(Color, C2),

(Fig=[k| C2]; not(can_move([F|Color],X2,Y2,_,_,Pos,[F|C2]))).

can_move([k|Color], 5,Y,X2,Y,Pos,f):-

(Y = 1, Color=b, C2=w; Y= 8, Color=w, C2=b),

mem(Row,Pos,Y),

(X2 = 3, mem(f,Row,2), Xn=4, Xr=1; X2 = 7, Xn=6, Xr=8),

mem(f,Row,X2),

mem(f,Row,Xn),

mem([r|Color],Row,Xr),

not(can_move([Fig|Color],X2,Y,_,_,Pos,[Fig|C2])),

not(can_move([Fig|Color],Xn,Y,_,_,Pos,[Fig|C2])),

not(can_move([Fig|Color], 5,Y,_,_,Pos,[Fig|C2])).

can_move(pw, X,Y1,X,Y2,Pos,Fig):-

Yn is Y1 - 1,

mem(Row,Pos,Yn),

mem(f,Row,X),

(Y2=Yn, (Y1=2->Fig=nb else Fig=p)

;

Y1=7, mem(Row2,Pos,5), mem(f,Row2,X), Y2=5, Fig=d

).

can_move(pb, X,Y1,X,Y2,Pos,Fig):-

Yn is Y1 + 1,

mem(Row,Pos,Yn),

mem(f,Row,X),

(Y2=Yn, (Y1=7->Fig=nw else Fig=p)

;

Y1=2, mem(Row2,Pos,4), mem(f,Row2,X), Y2=4, Fig=d

).

can_move(pw, X1,Y1,X2,Y2,Pos,[F1|C]):-

Y2 is Y1 - 1,

mem(Row,Pos,Y2),

(X2 is X1+1;X2 is X1 - 1),

mem([F2|C],Row,X2),

(Y2=1, F2\=k->F1=t else F1=F2).

can_move(pb, X1,Y1,X2,Y2,Pos,[F1|C]):-

Y2 is Y1 + 1,

mem(Row,Pos,Y2),

(X2 is X1+1;X2 is X1 - 1),

mem([F2|C],Row,X2),

(Y2=8, F2\=k->F1=t else F1=F2).

can_move([q|_], X1,Y1,X2,Y2,Pos,Fig):-

move_up(X1,Y1,X2,Y2,Pos,Fig);

move_down(X1,Y1,X2,Y2,Pos,Fig);

move_left(X1,Y1,X2,Y2,Pos,Fig);

move_right(X1,Y1,X2,Y2,Pos,Fig);

move_left_up(X1,Y1,X2,Y2,Pos,Fig);

move_right_down(X1,Y1,X2,Y2,Pos,Fig);

move_left_down(X1,Y1,X2,Y2,Pos,Fig);

move_right_up(X1,Y1,X2,Y2,Pos,Fig).

move_up(X,Y1,X,Y2,Pos,Fig2):-

Y is Y1 - 1,

mem(Row,Pos,Y),

mem(Fig,Row,X),

(Fig=f ->

(Y2 =Y, Fig2=Fig; move_up(X,Y,X,Y2,Pos,Fig2))

else

Y2=Y, Fig2=Fig

).

move_down(X,Y1,X,Y2,Pos,Fig2):-

Y is Y1 + 1,

mem(Row,Pos,Y),

mem(Fig,Row,X),

(Fig=f ->

(Y2 =Y, Fig2=Fig; move_down(X,Y,X,Y2,Pos,Fig2))

else

Y2=Y, Fig2=Fig

).

move_left(X1,Y,X2,Y,Pos,Fig2):-

X is X1 - 1,

mem(Row,Pos,Y),

mem(Fig,Row,X),

(Fig=f ->

(X2=X, Fig2=Fig; move_left(X,Y,X2,Y,Pos,Fig2))

else

X2=X, Fig2=Fig

).

move_right(X1,Y,X2,Y,Pos,Fig2):-

X is X1 + 1,

mem(Row,Pos,Y),

mem(Fig,Row,X),

(Fig=f ->

(X2=X, Fig2=Fig; move_right(X,Y,X2,Y,Pos,Fig2))

else

X2=X, Fig2=Fig

).

move_left_up(X1,Y1,X2,Y2,Pos,Fig2):-

X is X1 - 1, Y is Y1 - 1,

mem(Row,Pos,Y),

mem(Fig,Row,X),

(Fig=f ->

(X2=X, Y2=Y, Fig2=Fig; move_left_up(X,Y,X2,Y2,Pos,Fig2))

else

X2=X, Y2=Y, Fig2=Fig

).

move_left_down(X1,Y1,X2,Y2,Pos,Fig2):-

X is X1 - 1, Y is Y1 + 1,

mem(Row,Pos,Y),

mem(Fig,Row,X),

(Fig=f ->

(X2=X, Y2=Y, Fig2=Fig; move_left_down(X,Y,X2,Y2,Pos,Fig2))

else

X2=X, Y2=Y, Fig2=Fig

).

move_right_up(X1,Y1,X2,Y2,Pos,Fig2):-

X is X1 + 1, Y is Y1 - 1,

mem(Row,Pos,Y),

mem(Fig,Row,X),

(Fig=f ->

(X2=X, Y2=Y, Fig2=Fig; move_right_up(X,Y,X2,Y2,Pos,Fig2))

else

X2=X, Y2=Y, Fig2=Fig

).

move_right_down(X1,Y1,X2,Y2,Pos,Fig2):-

X is X1 + 1, Y is Y1 + 1,

mem(Row,Pos,Y),

mem(Fig,Row,X),

(Fig=f ->

(X2=X, Y2=Y, Fig2=Fig; move_right_down(X,Y,X2,Y2,Pos,Fig2))

else

X2=X, Y2=Y, Fig2=Fig

)

Glosarium

Artificial Intelligence adidefinisikan sebagai kecerdasan yang ditunjukkan oleh suatu entitas buatan. Sistem seperti ini umumnya dianggap komputer. Kecerdasan diciptakan dan dimasukkan ke dalam suatu mesin agar dapat melakukan pekerjaan seperti yang dapat dilakukan manusia. Beberapa macam bidang yang menggunakan kecerdasan buatan antara lain sistem pakar, game, logika fuzzy, jaringan saraf tiruan dan robotika.Sistem AI sekarang ini sering digunakan dalam bidang ekonomi, obat-obatan, teknik dan militer, seperti yang telah dibangun dalam beberapa aplikasi perangkat lunak komputer rumah dan video game. 'Kecerdasan buatan' ini bukan hanya ingin mengerti apa itu sistem kecerdasan, tapi juga mengkonstruksinya.

 Algoritma atau algoritme merupakan kumpulan perintah untuk menyelesaikan suatu masalah. Perintah-perintah ini dapat diterjemahkan secara bertahap dari awal hingga akhir. Masalah tersebut dapat berupa apa saja, dengan catatan untuk setiap masalah, ada kriteria kondisi awal yang harus dipenuhi sebelum menjalankan algoritma. Algoritma akan dapat selalu berakhir untuk semua kondisi awal yang memenuhi kriteria, dalam hal ini berbeda dengan heuristik. Algoritma sering mempunyai langkah pengulangan (iterasi) atau memerlukan keputusan (logika Boolean dan perbandingan) sampai tugasnya selesai.

Download Strowbery Prolog&Project