Black Knight - a BlitzMax game

good luck then. A chess program is a formidable task, make one and you will know for sure you are a good programmer.

The one I did some time ago computed all possible moves chessboard positions N moves ahead, remembering from which sequence they came from, then used a kind of recursive minimax scoring approach to solve the game backwards, terribly inefficient, but in theory it could calculate to any depth.

Crazy thing is I wrote it in matlab as an exercise to learn it: it had many cool features that made the programming simpler, but was pretty slow

here is the code, if you ever happen to get on matlab (though it doesn't have an interface, it just generates a random position, shows it as a 8x8 matrix, and then tells you which move he would do)

%1=pawn
%3=knight
%4=alfiere
%5=torre
%9=regina
%88=re
%
%la variabile servono varie variabili "contamosse": una di una dimensione


% incateni sulla prima dimensione le mosse e fai un vettore delle mosse unidimensionale...
% poi incateni 

function matteochessprogram2

depth=3;


mosseprime=zeros(4,50);
mosseseconde=zeros(4,50,50);
mosseterze=zeros(4,50,50,50);
mossequarte=zeros(4,50,50,50,50);


board=zeros(8,8);

contamosse=0;

for i=1:8
    board(2,i)=1;
    board(7,i)=-1;
end

board(1,1)=5;board(1,2)=3;board(1,3)=4;board(1,4)=88;board(1,5)=9;board(1,6)=4;board(1,7)=3;board(1,8)=5;
board(8,1)=-5;board(8,2)=-3;board(8,3)=-4;board(8,4)=-88;board(8,5)=-9;board(8,6)=-4;board(8,7)=-3;board(8,8)=-5;


%for i=1:8
%for j=1:2
%    board(j,i)=randompiece(1);
%     board(9-j,i)=randompiece(-1);
%end
%end

player=1

for t=1:40
    t
    ottimo=evaluate(board,player,depth);
    mossafatta=ottimo(1:4);
    board=applymove(mossafatta,board);
    board
    player=-player;
end



function ra=randompiece(player)
y=rand(1)*100;
if y<50
    ra=1;
elseif y<60 
    ra=5;
elseif y<70 
    ra=3;
elseif y<80 
    ra=4;
elseif y<90 
    ra=9;
else
    ra=88;
end
ra=ra*player;
    
    







function ottimo=evaluate(board,player,depth)

if depth==1
ottimo=evaluate1(board,player);
end

if depth>1

posizioni1=zeros(8,8,27,8,8);
rispottima=zeros(5,27,8,8);

for row1=1:8
    for column1=1:8
        
        
        if (sign (board(row1,column1))==player)
            mosse1(:,:,row1,column1)=computemovesperpiece(player,board,[row1,column1]);
            s1=1;
            while mosse1(s1,1,row1,column1)>0
                posizioni1(:,:,s1,row1,column1)=applymove([row1,column1,mosse1(s1,1,row1,column1),mosse1(s1,2,row1,column1)],board);
                s1=s1+1 ;
            end
        end
    end
end


for row1=1:8
    for column1=1:8
        for s1=1:27
            if any (posizioni1(:,:,s1,row1,column1))
                rispottima(:,s1,row1,column1)=evaluate(posizioni1(:,:,s1,row1,column1),-player,depth-1);
                rating=-rispottima(5,:,:,:)-(rispottima(5,:,:,:)==0)*10000;
            end
        end
    end
end

rating;

[C,I] = max(rating);

[C2,I2]=max(C);

[C3,I3]=max(C2);

C3;

colottima=I3;
rowottima=I2(I3);
mossaottima=I(1,1,rowottima,colottima);

arrivoottimo=mosse1(mossaottima,:,rowottima,colottima);



rating(1,mossaottima,rowottima,colottima);        


ottimo=[rowottima colottima arrivoottimo(1) arrivoottimo(2) rating(1,mossaottima,rowottima,colottima)];



end


function ottimo=evaluate1(board,player)

rating=zeros(27,8,8);

for row=1:8
    for column=1:8
        if (sign (board(row,column))==player)
            mosse(:,:,row,column)=computemovesperpiece(player,board,[row,column]);
            s=1;
            while mosse(s,1,row,column)>0
                posizioni(:,:,s,row,column)=applymove([row,column,mosse(s,1,row,column),mosse(s,2,row,column)],board);
                rating (s,row,column)=sum(sum(posizioni(:,:,s,row,column)))*player+1000;
                s=s+1 ;
            end
        end
    end
end

[C,I] = max(rating);

[C2,I2]=max(C);

[C3,I3]=max(C2);

colottima=I3;
rowottima=I2(I3);
mossaottima=I(1,rowottima,colottima);

arrivoottimo=mosse(mossaottima,:,rowottima,colottima);

ottimo=[rowottima colottima arrivoottimo(1) arrivoottimo(2) rating(mossaottima,rowottima,colottima)];

rating(mossaottima,rowottima,colottima);

function newboard=applymove(move,board)
newboard=board;
newboard(move(1),move(2))=0;
newboard(move(3),move(4))=board(move(1),move(2));





function possiblemoves=computemovesahead(player,board,position,direction,range)

possiblemoves=zeros(0,2);

i=0;
numberofmoves=0;
blocked=0;

while blocked==0 & i<range
    i=i+1;
    
    if (position(1)+direction(1)*i<1) | (position(1)+direction(1)*i>8) | (position(2)+direction(2)*i<1) | (position(2)+direction(2)*i>8)
        blocked=1;
    else
        if board(position(1)+direction(1)*i,position(2)+direction(2)*i)==0
            numberofmoves=numberofmoves+1;
            %possiblemoves(numberofmoves,:)=position+direction*i;
            possiblemoves=vertcat(possiblemoves,position+direction*i);
        elseif sign (board(position(1)+direction(1)*i,position(2)+direction(2)*i))~=player
            numberofmoves=numberofmoves+1;
            %possiblemoves(numberofmoves,:)=position+direction*i;
            possiblemoves=vertcat(possiblemoves,position+direction*i);
            blocked=1;
        elseif sign (board(position(1)+direction(1)*i,position(2)+direction(2)*i))==player
            blocked=1;
        end
    end
end


function possiblemoves=computemovesperpiece(player,board,position)

possiblemoves=zeros(0,2);

totalmoves=0;

if abs(board(position(1),position(2)))==88 %RE
    for i=-1:1
        for j=-1:1
            possiblemoves=vertcat(possiblemoves, computemovesahead(player,board,position,[i,j],1) );
        end
    end
end

if abs(board(position(1),position(2)))==9 %REGINA
    for i=-1:1
        for j=-1:1
            possiblemoves=vertcat(possiblemoves, computemovesahead(player,board,position,[i,j],8) );
        end
    end
end

if abs(board(position(1),position(2)))==1 %pedone
    
    if position(2)<8 & position(2)>1 & sign ( board(position(1)+player,position(2)+1) )==-player & sign ( board(position(1)+player,position(2)-1) )== -player & board(position(1)+player,position(2))==0
        for j=-1:1
            possiblemoves=vertcat(possiblemoves, computemovesahead(player,board,position,[player,j],1) );
        end
    elseif position(2)<8 & position(2)>1 & sign ( board(position(1)+player,position(2)+1) )==-player & sign ( board(position(1)+player,position(2)-1) )== -player
        for j=-1:2:1
            possiblemoves=vertcat(possiblemoves, computemovesahead(player,board,position,[player,j],1) );
        end
        
        
        
        
    elseif position(2)<8 & sign ( board(position(1)+player,position(2)+1) )==-player & board(position(1)+player,position(2))==0
        for j=0:1
            possiblemoves=vertcat(possiblemoves, computemovesahead(player,board,position,[player,j],1) );
        end
    elseif position(2)<8 & sign ( board(position(1)+player,position(2)+1) )==-player 
        for j=1:1
            possiblemoves=vertcat(possiblemoves, computemovesahead(player,board,position,[player,j],1) );
        end
        
        
        
    elseif position(2)>1 & sign ( board(position(1)+player,position(2)-1) )== -player & board(position(1)+player,position(2))==0
        for j=-1:0
            possiblemoves=vertcat(possiblemoves, computemovesahead(player,board,position,[player,j],1) );
        end
    elseif position(2)>1 & sign ( board(position(1)+player,position(2)-1) )== -player
        for j=-1:-1
            possiblemoves=vertcat(possiblemoves, computemovesahead(player,board,position,[player,j],1) );
        end
        
        
        
    else if (board(position(1)+player,position(2))==0) 
            possiblemoves=vertcat(possiblemoves, computemovesahead(player,board,position,[player,0],1) );
        end
    end
end
    
    if abs(board(position(1),position(2)))==5 %torre
        for i=-1:1
            for j=-1:1
                if i*j==0
                    possiblemoves=vertcat(possiblemoves, computemovesahead(player,board,position,[i,j],8) );
                end
            end
        end
    end
    
    
    if abs(board(position(1),position(2)))==4 %alfio
        for i=-1:1
            for j=-1:1
                if i*j~=0
                    possiblemoves=vertcat(possiblemoves, computemovesahead(player,board,position,[i,j],8) );
                end
            end
        end
    end
    
    if abs(board(position(1),position(2)))==3 %cavallo
        for i=-2:2
            for j=-2:2
                if abs(i*j)==2
                    possiblemoves=vertcat(possiblemoves, computemovesahead(player,board,position,[i,j],1) );
                end
            end
        end
    end
    
    
    if size(possiblemoves,1)<28
        possiblemoves=vertcat(possiblemoves,zeros( 28-size(possiblemoves,1),2));
    end

    
    
    
    function rate(board,player)
    

btw, are you a good chess player? I have around 1600 elo on yahoo