[JagoVB]

mohon bantuannya para sesepuhh.. ini berkaitan dengan swi prolog... ane dah coba perbaiki dan akhirnya tersisa 4 yg masih error... mohon bantuanya .



codingannya


Spoiler for :




#!/usr/bin/pl -g "main." -s

% 5x5 tic-tac-toe by Remigiusz 'lRem' Modrzejewski

% Distributed under the GPL, for more details see:

% http://lrem.net/pages/view/prolog_tic_tac_toe



boardsize(5).

opponent(o,x).

opponent(x,o).

unfold(M, X, Y) :-

boardsize(S),

X is M mod S,

Y is (M-X)/S.

% Initialize the board% {{{

/*board(['.', '.', '.', '.', '.', '.',

'.', '.', '.', '.', '.', '.',

'.', '.', '.', '.', '.', '.',

'.', '.', '.', '.', '.', '.',

'.', '.', '.', '.', '.', '.',

'.', '.', '.', '.', '.', '.' ]).*/

board(B) :-

boardsize(S),

F is S*S,

board(B, F).

board([], 0) :- !.

board(['.'|T], N) :-

N1 is N-1,

board(T, N1).

% }}}

% Show the board% {{{

show(B) :- write(' 0123456'), nl, write(0), showloop(B, 0), write('0123456'), nl.

showloop([], _).

showloop([H|T], I) :-

boardsize(S),

I mod S =:= S-1,

L is (I-S+1)/S,

NL is (I+1)/S,

write(H), write(L), nl, write(NL),

I1 is I + 1,

showloop(T, I1), !.

showloop([H|T], I) :-

write(H),

I1 is I + 1,

showloop(T, I1).



% }}}

% Gets an index of array% {{{

get([H|_], 0, H) :- !.

get([_|T], N, R) :-

N1 is N-1,

get(T, N1, R).

% }}}

% Gets a position on board% {{{

get(B, X, Y, R) :-

boardsize(S),

-1 < X, X < S, % Check whether inside the board

-1 < Y, Y < S,

N is X + S*Y,

get(B, N, R).

% }}}

% Sets an index of array% {{{

set([_|T], 0, X, [X|T]) :- !.

set([H|T], N, X, [H|R]) :-

N1 is N-1,

set(T, N1, X, R).

% }}}

% Sets a position on board% {{{

set(B, X, Y, M, NB) :-

boardsize(S),

N is X + S*Y,

set(B, N, M, NB).

% }}}

% Counts how much points player P gets for the mark% {{{

points(B, X, Y, P, R) :-

get(B, X, Y, M), M == '.', % Asserting it's legal to put it there

points(B, X, Y, P, 1, 0, R1),

points(B, X, Y, P, 0, 1, R2),

points(B, X, Y, P, 1, 1, R3),

points(B, X, Y, P, 1, -1, R4),

R is R1 + R2 + R3 + R4.

points(B, X, Y, P, DX, DY, R) :-

points(B, X, Y, P, DX, DY, 1, R1),

MDX is -DX, MDY is -DY,

points(B, X, Y, P, MDX, MDY, 1, R2),

RS is R1 + R2 + 1,

points(RS, R).

points(_, _, _, _, _, _, 3, 0) :- !. % Search for half-lines no longer than 2

points(B, X, Y, P, DX, DY, D, R) :-

X1 is X + DX*D,

Y1 is Y + DY*D,

get(B, X1, Y1, M),

M == P,

D1 is D+1,

points(B, X, Y, P, DX, DY, D1, R1),

R is R1 + 1, !.

points(_, _, _, _, _, _, _, 0).

points(1, 0) :- !.

points(N, R) :- R is N-2.

% }}}

%Counts open lines in the neighbourhood{{{

nonblocking('.', _).

nonblocking(A, A).

open(B, X, Y, P, R) :-

get(B, X, Y, M), M == '.', % Asserting starting point is open

open(B, X, Y, P, 1, 0, R1),

open(B, X, Y, P, 0, 1, R2),

open(B, X, Y, P, 1, 1, R3),

open(B, X, Y, P, 1, -1, R4),

R is R1 + R2 + R3 + R4.

open(B, X, Y, P, DX, DY, R) :-

open(B, X, Y, P, DX, DY, 1, R1),

MDX is -DX, MDY is -DY,

open(B, X, Y, P, MDX, MDY, 1, R2),

RS is R1 + R2 + 1,

open(RS, R).

open(_, _, _, _, _, _, 3, 0) :- !. % Search for half-lines no longer than 2

open(B, X, Y, P, DX, DY, D, R) :-

X1 is X + DX*D,

Y1 is Y + DY*D,

get(B, X1, Y1, M),

nonblocking(M, P),

D1 is D+1,

open(B, X, Y, P, DX, DY, D1, R1),

R is R1 + 1, !.

open(_, _, _, _, _, _, _, 0).

open(1, 0) :- !.

open(N, R) :- R is N-2.

%}}}

%The value function {{{

value(B, P, M, R) :-

unfold(M, X, Y),

points(B, X, Y, P, RPM),

open(B, X, Y, P, ROM),

opponent(P, O),

points(B, X, Y, O, RPO),

open(B, X, Y, O, ROO),

R is 9*RPM + 9*RPO + 3*ROM + 1*ROO.

nice(B, P, M) :-

value(B, P, M, R),

R > 17.

%}}}

%Moves generator{{{

free(B, M) :-

get(B, M, R),

R == '.'.

genmoves(B, P, ML) :-

genmoves(B, P, 0, ML, MC),

%write([MC, 'nice moves']), nl,

MC > 0, !.

genmoves(B, P, ML) :-

%write('finding all free'), nl,

findfree(B, 0, ML).

%genmoves(_, _, 36, [], 0) :- !.

genmoves(_, _, N, [], 0) :-

boardsize(S),

N =:= S*S, !.

genmoves(B, P, N, [N|T], MC) :-

nice(B, P, N),

N1 is N+1,

genmoves(B, P, N1, T, MC1),

MC is MC1+1, !.

genmoves(B, P, N, T, MC) :-

N1 is N+1,

genmoves(B, P, N1, T, MC).

findfree([], _, []).

findfree([H|T], N, [N|RT]) :-

H == '.',

N1 is N+1,

findfree(T, N1, RT), !.

findfree([H|T], N, RT) :-

N1 is N+1,

findfree(T, N1, RT).

%}}}

%Openings base{{{

minimax(B, _, _, 12, 0) :-

boardsize(5),

free(B, 12), !.

/*minimax(B, _, _, 7, 0) :-

boardsize(5),

free(B, 7), !.*/

%}}}

%The minimax search {{{

%Board, player, depth, next best move, value

minimax(B, P, 0, _, 0) :- !.

minimax(B, P, D, M, V) :-

genmoves(B, P, ML),

choose(B, P, D, ML, M, V).

choose(_, _, _, [], _, -999).

choose(B, P, D, [H|T], M, V) :-

value(B, P, H, V1),

set(B, H, P, NB),

opponent(P, O),

D1 is D-1,

minimax(NB, O, D1, _, V2),

VH is V1 - V2,

choose(B, P, D, T, MT, VT),

max(VH, H, VT, MT, V, M).

max(VH, H, VT, MT, VH, H) :-

VH > VT, !.

max(_, _, VT, MT, VT, MT).

%}}}

turn(B, x, RX, RO) :-

show(B),

write('x coord:'), read(X),

write('y coord:'), read(Y),

points(B, X, Y, x, RX1),

set(B, X, Y, x, NB),

turn(NB, o, RX2, RO),

RX is RX1 + RX2, !.



turn(B, o, RX, RO) :-

show(B),

%write('x coord:'), read(X),

%write('y coord:'), read(Y),

minimax(B, o, 4, M, _),

unfold(M, X, Y),

points(B, X, Y, o, RO1),

set(B, X, Y, o, NB),

turn(NB, x, RX, RO2),

RO is RO1 + RO2, !.



turn(_, _, 0, 0).



main :-

board(B),

turn(B, x, RX, RO),

write([x, RX, points, o, RO, points]), nl,

/*set(B, 2, 0, o, NB1),

set(NB1, 2, 1, o, NB2),

points(NB2, 2, 2, o, R),

write(R), nl,

show(NB2),*/

halt.

main :-

write(nowai),

halt.