Membuat game catur Pion & Queen dengan Strawberry Prolog

Thursday 25 April 20130 comments



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




Donasi Pada Blog Ini Cukup Mengklik Iklan Yang Ada, Klik Anda Sangat Berguna Untuk Kelangsungan Blog Ini. Terima Kasih

Post a Comment

 
Support : Creating Website | Johny Template | Mas Template
Copyright © 2011. BANYAK HAL - All Rights Reserved
Template Created by Creating Website Published by Mas Template
Proudly powered by Blogger