Minggu, 30 Maret 2014
Jumat, 28 Maret 2014
GAME CATUR DC & MARVEL
Initial State :
Aplikasi
permainan “The Alliance Marvel VS DC strategic game” adalah sebuah aplikasi
yang telah di modifikasi dan dikembangkan dari permainan catur 5x5 dimana
berkonsep dua tim yang akan saling menyerang didalam waktu 1800 detik dengan
karakter King, Queen, Pion, dan Benteng. Didalam aplikasi ini tim pertama
disebut “DC Team” yaitu tim komputer sebagai kondisi default dan tim kedua disebut “Marvel Team” ,User
dapat mengganti alur permainan dengan memilih tim lawan dengan cara memilih tim
didalam menu Options. Di dalam permainan ini diberikan waktu sebagai tambahan
tantangan sebanyak 1800 detik yang berjalan mundur. Didalam game ini juga
terdapat bantuan menu kepada user seperti menu :
Undo,Redo,Help,Options,Difficulty,dan Author
Berikut penjelasan didalam karakter permainan ini :
-DC Team :
- Superman sebagai King
- WonderWoman sebagai Queen
- Batman sebagai Benteng
- Green Lantern sebagai Pion
-Marvel team :
1. Iron
Man sebagai King
2. Black
Widow sebagai Queeen
3. Hulk
sebagai Benteng
4. Spiderman
sebagai Pion
RULE :
Aturan
main (Rule) yang digunakan pada games The Alliance Marvel VS DC strategic game ini
adalah sebagai berikut:
1.
Pada awal permainan anda dapat menuliskan nama
anda di menu Player Name
2.
Kemudian anda dapat memilih jagoan (character).
Pada awal permainan ketika dijalankan anda dapat memilih ingin bermain melawan
komputer .
3.
Lalu anda dapat memilih tingat kesusahan yaitu
tingkat beginner dan expert
4.
Kalahkan lawan seperti bermain catur dengan cara
berbalapan dengan time running
5.
Jika anda kalah atau waktu habis maka harus diulangi lagi.
6.
Cara bermain didalam permainan ini sama halnya
jika anda bermain catur hanya saja dengan karakter yang berbeda.
Goal
Goal dalam permainan ini adalah
ketika anda telah menyelesaikan dalam mengalahkan musuh anda bermain catur
yaitu mengalahkan komputer. Permainan ini akan selesai dan anda akan dianggap
menang ketika anda berhasil memenangkan dengan memakan raja atau ratu
lawan,yaitu mengalahkan bidak ke 3 dan ke 4 dari belakang dengan waktu yang
tepat tanpa kehabisan waktu. Di dalam Game ini terdapat 3 Tipe Hasil keputusan
yaitu :Menang,Draw /Seri, dan Kalah,
Tampilan Menu Awal
Gambar
1. Tampilan Awal
Tampilan Inputan nama
bagi User
Gambar
2 . Tampilan Penginputan Nama User
Tampilan Pemilihan Level didalam Permainan
Gambar
3. Tampilan pemilihan level tingkat kesulitan.
Tampilan Options untuk
mengganti Karakter pemain
Gambar
4. Tampilan saat pemilihan permainan pemilihan player
Tampilan Help didalam
permainan
Gambar
5(a). Tampilan Help
Gambar
5(b). Tampilan Help
Tampilan Goals : User
menang
Gambar
6 .Tampilan saat memenangkan permainan
Tampilan Jika user
kalah dalam menghadapi komputer
Gambar
6. Tampilan saat kalah dari permainan
Tampilan Kondisi dimana
User dan Komputer Imbang
Gambar 7. Tampilan saat draw dari permainan
Tampilan jika user
kehabisan waktu
Gambar 8. Tampilan saat kalah karena waktu habis
Konsep AI
Artificial Intelligence merupakan salah satu bagian ilmu
komputer yang membuat agar mesin atau komputer dapat melakukan pekerjaan
seperti layaknya dan sebaik yang dilakukan oleh manusia. Kecerdasan buatan
dapat diterapkan atau dimplementasikan kedalam berbagai bentuk
aplikasi. Bentuk implementasi yang paling mudah untuk diukur tingkat
keberhasilan dan cukup digemari oleh sebagian besar publik yaitu pada games atau
permainan. Permainan yang digunakan sebagai media pengimplementasian
pada kasus ini adalah permainan Chess. Game Chess merupakan sebuah game yang
berbasis AI (Artificial Intelliginece) atau kecerdasan buatan. Game ini mampu
berfikir layaknya seorang manusia hingga dapat dikatakan “cerdas” (anggapan
manusia).
The Alliance Marvel VS
DC strategic game merupakan suatu permainan sederhana yang menggunakan
konsep Artificial Intelligence atau yang bisa
disebut kecerdasan buatan. AI pada game ini terletak pada komputer yang akan bertindak
sebagai lawan yang akan mengalahkan kita. Komputer akan selalu berusaha
mengalahkan user dengan cara memakan bidak catur dan menutup jalan akses agar
Ratu atau Raja lawan tidak terkalahkan oleh User, komputer mempunyai strategi
didalam memenangkan permainan tergantung dari pilihan level di layar utama.. The
Alliance Marvel VS DC strategic game disini adalah bagaimana didalam catur User
harus mengalahkan AI dari komputer dan melawan waktu juga.
Jika didalam Team yang
sudah mengalahkan Raja maka Team tersebut lah yang menang.
Agar game ini dapat di
mainkan,User harus mempunyai Compiler Strawberry Prolog. Penulis membuat
aplikasi ini didalam Strawberry Prolog yang tidak berbayar maka dari itu
aplikasi ini tidak dapat dibuat menjadi executable.
Listing
Program
level(1, 2, 1, 5).
level(2, 3, 3, 15).
%============Pendeklarasian
Awal========================================
?-
G_waktu:=3,
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),
%============gambar
& background========================================
G_chessboard is
bitmap_image("gambar\\papancatur22.bmp",_),
G_squareW is
bitmap_image("gambar\\squareW.bmp",_),
G_squareB is
bitmap_image("gambar\\squareB.bmp",_),
G_PawnW1 is
bitmap_image("gambar\\WPawn1.bmp",_),
G_PawnW2 is
bitmap_image("gambar\\WPawn2.bmp",_),
G_PawnB1 is
bitmap_image("gambar\\BPawn1.bmp",_),
G_PawnB2 is
bitmap_image("gambar\\BPawn2.bmp",_),
G_KingW1 is
bitmap_image("gambar\\KingWChoco1.bmp",_),
G_KingW2 is
bitmap_image("gambar\\KingWChoco2.bmp",_),
G_KingB1 is
bitmap_image("gambar\\KingBChoco2.bmp",_),
G_KingB2 is
bitmap_image("gambar\\KingBChoco1.bmp",_),
G_QueenW1 is bitmap_image("gambar\\QueenWChoco1.bmp",_),
G_QueenW2 is
bitmap_image("gambar\\QueenWChoco2.bmp",_),
G_QueenB1 is
bitmap_image("gambar\\QueenBChoco1.bmp",_),
G_QueenB2 is
bitmap_image("gambar\\QueenBChoco2.bmp",_),
G_RookW1 is bitmap_image("gambar\\WRook1.bmp",_),
G_RookW2 is
bitmap_image("gambar\\WRook2.bmp",_),
G_RookB1 is
bitmap_image("gambar\\BRook1.bmp",_),
G_RookB2 is
bitmap_image("gambar\\BRook2.bmp",_),
window(G_Win,_,chess_func(_),"=================The Alliance Marvel
VS DC==============",200,125,515,540).
%============menu
level========================================
levelm(init):-
G_timer is
set_timer(_,1,time_func),
menu(normal,_,_,l2(_),"&Beginner"),
menu(checked,_,_,l3(_),"&Expert"),
menu(separator, _,_,fail(_),_).
l2(press):-change_level(1),
G_waktu:=1801.
l3(press):-change_level(2),
G_waktu:=1801.
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,_).
%============menu
options========================================
changem(init):-
menu(normal,_,_,play_with_blacks(_),"&Using DC Heroes"),
menu(checked,_,_,play_with_computer(_),"&Againts
DC Heroes(Computer)").
play_with_blacks(press):-
G_waktu:=1801,
(G_Play_with_Computer=0->
beep("gambar\\beat_it_hippy.wav"),
message("", "You only can
change your Team when you against the Computer", 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,_)
).
%============menu
pemilihan karakter========================================
play_with_computer(press):-
G_waktu:=1801,
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,_)
).
%============Menu
Undo========================================
back(press):-
G_waktu:=G_waktu + 3,
G_Move:=G_Move - 1,
(G_Move=0->
modify_menu(G_Win,4,grayed,_),
draw_menu_bar(_)
),
(G_Forward=0->
modify_menu(G_Win,5,normal,_),
draw_menu_bar(_)
),
G_Forward:=G_Forward + 1,
set_some_text,
update_window(_).
%============Menu
Redo========================================
forward(press):-
G_waktu:=G_waktu - 3,
(G_Move=0->
modify_menu(G_Win,4,normal,_),
draw_menu_bar(_)
),
G_Move:=G_Move + 1,
G_Forward:=G_Forward - 1,
(G_Forward=0->
modify_menu(G_Win,5,grayed,_),
draw_menu_bar(_)
),
set_some_text,
update_window(_).
%============Menu Nama
Window========================================
set_some_text:-
pos(G_Move, C, _, _),
(G_Play_with_Blacks=\=true_value(C=b)->
change_side
),
(C=b->
set_text("Using DC Teams", _)
else (C=w->
set_text("Using Marvel Teams", _)
else
set_text("You Lose!!", _)
)).
set_pos(C, Pos) :-
(G_Move=0->
modify_menu(G_Win,4,normal,_),
draw_menu_bar(_)
),
(G_Forward>0->
modify_menu(G_Win,5,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)).
%============ Menu
Bar========================================
menu_name(press) :-
read(X, "Who are you??", s),
set_text(X, _).
menu_help(init):-
menu(normal,_,_,awal_help(_),"&The
Game"),
menu(normal,_,_,petunjuk(_),"&How
to").
petunjuk(press):-
beep("gambar\\child_hi.wav"),
message(" How To","Anda dapat
memilih Team di pilihan Options,dan
mengganti tingkat
kesulitan Game di Difficulty", i).
awal_help(press) :-
beep("gambar\\child_hi.wav"),
message(" The Game","Game ini
merupakan pertempuran MARVEL vs DC dalam bentuk catur.
Catur ini hanya tedapat
King, Queen, Benteng dan Pion ,dalam waktu 1800 detik anda harus mengalahkan lawan
agar menang", i).
menu_about(press) :-
message("Author","Created
by Radityo Eko Yoviarno
Gunadarma University 2012", i).
menu_exit(press) :-
ask.
ask:-
yes_no( "EXIT",
"Do you want to EXIT your GAME mas
beroh??", ?),
!,
yes_no( "EXIT",
"Matatih ??", ?),
!,
yes_no( "EXIT",
"Enelan??", ?),
!,
beep("gambar\\goodbye_2.wav"),
message("Yes", "Allright ,See
you later beroh!!!",!),
close_window(_).
ask:-
message("No", "Let's Do That
Again beroh", s).
chess_func(init):-
menu( normal, _, _, menu_name(_),
"&Player Name"),
menu(pop_up,
G_Menu1,_,levelm(_),"&Difficulty"),
menu(pop_up,
G_Menu2,_,changem(_),"&Options"),
menu( right, _, _, back(_),
"&Undo"),
menu( right, _, _, forward(_),
"&Redo"),
modify_menu(G_Win,4,grayed,_),
modify_menu(G_Win,5,grayed,_),
menu( pop_up, _, _, menu_help(_),
"&Help"),
menu( normal, _, _, menu_about(_),
"&Author"),
menu( normal, _, _, menu_exit(_),
"&Exit").
%============Penggambaran Menu
Utama========================================
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.
%============Perubahan
Lokasi Bidak (Menu Utama Permainan)========================================
chess_func(mouse_click(X,Y)):-
I :=X//50,
J :=Y//50,
I>0, I=<8,
J>0, J=<8,
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)->
beep("gambar\\klaxon.wav"),
message("Warning", "Wrong
Turn,check", !),
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("Congratulations", _),
beep("gambar\\gomer_congrats.wav"),
message("Congratulations",
"You beat me up Dude", !),close_window(_),
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
)).
%============AI
Movement================================================================================
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("gambar\\All right then_ now it_s
my turn!.wav"),
write(maximum(G_Deep)+" for
"+Time/1000+" seconds ("+Steps+" steps)"),nl,
(G_AuCh=1->
level(G_Level,_,Minimum,Maximun),
(Time<1000*Minimum->
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("Lucky", _),
beep("gambar\\wow.wav"),
message("Lucky", "Just
Draw ?", !),
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
%============Menu
Dialog Apabila User
Kalah===================================================================
set_pos(n, Pos3),
set_text("Mission Failed",
_),
beep("gambar\\evilaff.wav"),
message("you're LOSE,LOSER!",
"Goodbye LOSER", s), close_window(_),
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]))->
%============Menu
Dialog Apabila User Seri (Draw)
===========================================================
set_pos(n, Pos3),
set_text("Lucky", _),
beep("gambar\\wow.wav"),
message("Lucky", "Just
Draw ?", !),close_window(_),
fail
),
(not(mem(Row4,Pos3,_), mem([F2|_],Row4,_),
F2\=k)->
set_pos(n, Pos3),
set_text("Lucky", _),
beep("gambar\\wow.wav"),
message("Lucky", "Just
Draw ?", !),close_window(_),
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)<val(Deep)-maximum(Deep1)-> % =< ============Menu algoritma AI dalam
mencari poin terbesar
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)<val(Deep+1)-maximum(Deep)-> % =< ============Menu algoritma AI dalam
mencari poin terbesar
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))<Val2->
index(Moves2):=index(MovesP),
find_the_right_place(Val2,Moves,MovesP,Place)
else
Moves2=Place
).
can_hit([Fig|C1],I,J,Pos,_,Try,Sum):-
%============Menu apabila karakter didalam Bidak menyerang sasaran
can_move([Fig|C1],I,J,_,_,Pos,F),
(F=[Fig2|C]->
(C=C1->
Sum:=Sum+8
else
val([Fig2|_],Val2),
val([Fig|_],Val1),
(Val1<Val2->
(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):-
%============Menu apabila karakter lawan didalam Bidak menyerang sasaran
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<J2->
move_down(I2,J2,_,_,Pos,Fig)
else
move_up(I2,J2,_,_,Pos,Fig)
)
else (J1=J2->
(I1<I2->
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<I2->
move_right_up(I2,J2,_,_,Pos,Fig)
else
move_left_down(I2,J2,_,_,Pos,Fig)
)
else (I1-J1=:=I2-J2->
(I1<I2->
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<Val2->
(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).
%============Menu
perhitungan poin didalam AI======================================================================================
val(f,0).
val(p,18). % Pawn move
val(d,35). % Pawn
double move = 2*val(p)-1
val([p|_],100).
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)
)).
%============Menu
Posisi Awal bidak
catur========================================================================================================================================================
%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,
[[rb,rb,qb,kb,rb,rb],
[pb,pb,pb,pb,pb,pb],
[f,f,f,f,f,f],
[f,f,f,f,f,f],
[pw,pw,pw,pw,pw,pw],
[rw,rw,qw,kw,rw,rw]]).
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(rb, 1, G_RookB1).
fig(rw, 1, G_RookW1).
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).
fig(rb, 2, G_RookB2).
fig(rw, 2, G_RookW2).
R is xy(X, Y):-
R:=string_from_ASCII(X+first_ASCII("A")- 1)+ (9-Y).
mem(E,[E,_,_,_,_,_],2).
mem(E,[_,E,_,_,_,_],3).
mem(E,[_,_,E,_,_,_],4).
mem(E,[_,_,_,E,_,_],5).
mem(E,[_,_,_,_,E,_],6).
mem(E,[_,_,_,_,_,E],7).
replace(X,[_,B,C,D,E,F],[X,B,C,D,E,F],2).
replace(X,[B,_,C,D,E,F],[B,X,C,D,E,F],3).
replace(X,[B,C,_,D,E,F],[B,C,X,D,E,F],4).
replace(X,[B,C,D,_,E,F],[B,C,D,X,E,F],5).
replace(X,[B,C,D,E,_,F],[B,C,D,E,X,F],6).
replace(X,[B,C,D,E,F,_],[B,C,D,E,F,X],7).
%===============================AI
Movement=================================================
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([h|_],
X1,Y1,X2,Y2,Pos,Fig):-
(X2 is X1+1; X2 is X1 - 1),
(Y2 is Y1+2; Y2 is Y1 - 2),
mem(Row,Pos,Y2),
mem(Fig,Row,X2).
can_move([h|_],
X1,Y1,X2,Y2,Pos,Fig):-
(X2 is X1+2; X2 is X1 - 2),
(Y2 is Y1+1; Y2 is Y1 - 1),
mem(Row,Pos,Y2),
mem(Fig,Row,X2).
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([r|_],
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).
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
).
%============Menu Waktu
atau timer didalam permainan=======================
time_func(end):-
G_waktu:=G_waktu-1,
W:= printq(G_waktu),
font(10,25,"Times New
Roman"),
text_out(45,442,W),
(G_waktu=0-> kill_timer(_, G_timer),
beep("gambar\\evilaff.wav"),
message("You
Lose","You fast but not fast enough,TRY AGAIN LATER",i),
close_window(_)).
Algoritma
Pada game ini digunakan algoritma Minimax.
Pada algoritma minimax, pengecekan akan seluruh kemungkinan yang ada sampai
akhir permainan dilakukan. Algoitma ini
diterapkan dalam permainan yang melibatkan dua pemain seperti halnya Chess. Algoritma Minimax itu sendiri merupakan basis dari semua permainan yang berbasis AI. 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.
Daftar
Pustaka
waktu
akses: 7 November 2012 jam 16:32 wib
waktu akses: 7 November 2012 jam 13:50 wib
waktu akses: 7 November 2012 jam 16:10 wib
waktu akses: 7 November 2012 jam 16:20 wib
waktu akses: 7 November 2012 jam 13:20 wib
waktu akses: 7 November 2012 jam 19:50 wib
waktu akses: 7 November 2012 jam 15:50 wib
waktu akses: 7 November 2012 jam 16:30 wib
waktu akses: 7 November 2012 jam 16:40 wib
waktu akses: 7 November 2012 jam 11:30 wib
waktu akses: 7 November 2012 jam 14:50 wib
waktu akses: 7 November 2012 jam 16:40 wib
waktu akses: 7 November 2012 jam 18:20 wib
waktu akses: 7 November 2012 jam 12:30 wib
Glosarium
Algoritma
Minimax
Algoritma Minimax merupakan algoritma yang digunakan untuk
menentukan pilihan agar memperkecil kemungkinan kehilangan nilai maksimal.Pada algoritma minimax, pengecekan akan seluruh
kemungkinan yang ada sampai akhir permainan dilakukan. Pengecekan tersebut akan
menghasilkan pohon permainan yang berisi semua kemungkinan tersebut. 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.
Algoritma
Algoritma
adalah urutan langkah-langkah logis penyelesaian masalah yang disusun secara
sistematis dan logis.
Artificial Intelligence
Artificial Intelligence adalah sesuatu buatan atau suatu tiruan
yang cerdas. Cerdas di sini kemungkinan maksudnya adalah kepandaian atau
ketajaman dalam berpikir, seperti halnya otak manusia dalam menyelesaikan suatu
masalah.
Langganan:
Postingan (Atom)