% !TEX program = xelatex
\documentclass{article}
\usepackage{chessboard}
\usepackage[LSBC4,T1]{fontenc}
\let\clipbox\relax
\usepackage{../styles/style}
\usepackage{../styles/langs}
\usepackage{disclaimer}
\usepackage{ulem}
%\usepackage{tipauni}



\tikzset 
{%
  pics/piece/.style n args={1}{ 
    code={%
      \fill[rounded corners]                  (-0.1,-0.1) rectangle (-0.9, -0.9);
      \fill[left color=white,rounded corners,
            right color=gray,
            opacity=0.7]      (-0.1,-0.1) rectangle (-0.9, -0.9);
      \draw[line width=0.4mm,rounded corners] (-0.1,-0.1) rectangle (-0.9, -0.9);
      \draw[line width=0.2mm,rounded corners] (-0.2,-0.2) rectangle (-0.8, -0.8);
      \draw[anchor=mid] (-0.5,-0.6) node {#1};
    }},
  pics/king/.style n args={1}{ 
    code={%
      \fill[rounded corners]                  (-0.1,-0.1) rectangle (-0.9, -0.9);
      \fill[left color=white,rounded corners,
            right color=gray,
            opacity=0.7]      (-0.1,-0.1) rectangle (-0.9, -0.9);
      \draw[line width=0.4mm,rounded corners] (-0.1,-0.1) rectangle (-0.9, -0.9);
      \draw[line width=0.2mm,rounded corners] (-0.2,-0.2) rectangle (-0.8, -0.8);
      \draw[anchor=mid] (-0.5,-0.6) node {#1};
      \draw[anchor=center] (-0.5,-0.25) node {\includegraphics[scale=0.015]{crown.png}};
    }}
}


\begin{document}

\setchessboard{smallboard,
               zero,
               showmover=false,
               boardfontencoding=LSBC4,
               hlabelformat=\arabic{ranklabel},
               vlabelformat=\arabic{filelabel}}

\mbox{}\\[-18mm]\mbox{}

\section*{Main Part 4:\\ Implementing the Shogun Board Game (8 Marks)}

\mbox{}\hfill\textit{``The problem with object-oriented languages is they’ve got all this implicit,}\\
\mbox{}\hfill\textit{environment that they carry around with them. You wanted a banana but}\\
\mbox{}\hfill\textit{what you got was a gorilla holding the banana and the entire jungle.''}\smallskip\\
\mbox{}\hfill\textit{ --- Joe Armstrong (creator of the Erlang programming language)}\medskip\bigskip


\noindent
You are asked to implement a Scala program for playing the Shogun
board game.\medskip

%The deadline for your submission is on 26th July at
%16:00. There will be no automated tests for the resit, but there are
%many testcases in the template and the task description.  Make sure
%you use Scala \textbf{2.13.XX} for the resit---the same version as
%during the lectures.  \medskip

\IMPORTANTNONE{}

\noindent
Also note that the running time of each task will be restricted to a
maximum of 30 seconds on my laptop: If you calculate a result once,
try to avoid to calculate the result again. 

\DISCLAIMER{}

\subsection*{Background}

Shogun
(\faVolumeUp\,[shōgoon]) is a game played by two players on a chess board and is somewhat
similar to chess and checkers. A real Shogun board looks
like in the pictures on the left.


\begin{center}
\begin{tabular}{@{}ccc@{}}
\raisebox{2mm}{\includegraphics[scale=0.1]{shogun2.jpeg}}
&     
\raisebox{2mm}{\includegraphics[scale=0.14]{shogun.jpeg}}
&  
\begin{tikzpicture}[scale=0.45,every node/.style={scale=0.45}]    
% chessboard
\draw[very thick,gray] (0,0) rectangle (8,8);
\foreach\x in {0,...,7}\foreach\y in {7,...,0}
{
  \pgfmathsetmacro\blend{Mod(\x+\y,2)==0?75:25} 
  \fill[gray!\blend] (\x,\y) rectangle ++ (1,1);
}
% black pieces
\foreach\x/\y/\e in {1/1/1,2/1/3,3/1/2,4/1/3,6/1/3,7/1/1,8/1/2}
  \pic[fill=white] at (\x,\y) {piece={\e}};
% white pieces
\foreach\x/\y/\e in {1/8/4,2/8/2,3/8/4,5/8/4,6/8/2,7/8/3,8/8/1}
  \pic[fill=red] at (\x,\y)     {piece={\e}};
\pic[fill=white] at (5.0,1.0) {king={1}};
\pic[fill=red]   at (4.0,8.0) {king={2}};
% numbers
\foreach\x in {1,...,8}
{\draw (\x - 0.5, -0.4) node {\x};
}
\foreach\y in {1,...,8}
{\draw (-0.4, \y - 0.6, -0.4) node {\y};
}
\end{tikzpicture}
\end{tabular}
\end{center}


\noindent
In what follows we shall use board illustrations as shown on the right.  As
can be seen there are two colours in Shogun for the pieces, red and white. Each
player has 8 pieces, one of which is a king (the piece with the crown)
and seven are pawns. At the beginning the pieces are lined up as shown
above.  What sets Shogun apart from chess and checkers is that each
piece has, what I call, a kind of \textit{energy}---which for pawns is
a number between 1 and 4, and for kings between 1 and 2. The energy
determines how far a piece has to move. In the physical version of
Shogun, the pieces and the board have magnets that can change the
energy of a piece from move to move---so a piece on one field can have
energy 2 and on a different field the same piece might have energy
3. There are some further constraints on legal moves, which are
explained below.  The point of this part is to implement functions
about moving pieces on the Shogun board.\medskip\medskip

%and testing for when a
%checkmate occurs---i.e.~the king is attacked and cannot move
%anymore to an ``unattacked'' field (to simplify matters for
%the resit we leave out the case where the checkmate can be averted by capturing
%the attacking piece).\medskip

\noindent
Like in chess, in Shogun the players take turns of moving and
possibly capturing opposing pieces.
There are the following rules on how pieces can move:

\begin{itemize}
\item The energy of a piece determines how far, that is how many
  fields, a piece has to move (remember pawns have an energy between 1 --
  4, kings have an energy of only 1 -- 2). The energy of a piece might
  change when the piece moves to new field.
\item Pieces can move in straight lines (up, down, left, right), or in
  L-shape moves, meaning a move can make a single
  90$^{\circ}$-turn. S-shape moves with more than one turn are not
  allowed. Also in a single move a piece cannot go forward and then
  go backward---for example with energy 3 you cannot move 2 fields up and
  then 1 field down. A piece can never move diagonally.
\item A piece cannot jump over another piece and cannot stack up on top of your own pieces.
  But you can capture an opponent's piece if you move to an occupied field. A captured
  piece is removed from the board.
\end{itemize}  

\noindent
Like in chess, checkmate is determined when the king of a player cannot
move anymore to a field that is not attacked, or a player cannot
capture or block the attacking piece, or the king is the only
piece left for a player. A board that is checkmate is the following:

\begin{center}
\begin{tikzpicture}[scale=0.5,every node/.style={scale=0.5}]    
% chessboard
\draw[very thick,gray] (0,0) rectangle (8,8);
\foreach\x in {0,...,7}\foreach\y in {7,...,0}
{
  \pgfmathsetmacro\blend{Mod(\x+\y,2)==0?75:25} 
  \fill[gray!\blend] (\x,\y) rectangle ++ (1,1);
}
% redpieces
\pic[fill=red]   at (4,2) {king={2}};
\pic[fill=red]   at (6,1) {piece={3}};
\pic[fill=red]   at (4,4) {piece={4}};
\pic[fill=red]   at (5,3) {piece={4}};
% white pieces
\pic[fill=white] at (7,1) {king={2}};
\pic[fill=white] at (8,5) {piece={2}};
\pic[fill=white] at (4,1) {piece={2}};
% numbers
\foreach\x in {1,...,8}
{\draw (\x - 0.5, -0.4) node {\x};
}
\foreach\y in {1,...,8}
{\draw (-0.4, \y - 0.6, -0.4) node {\y};
}
\end{tikzpicture}
\end{center}

\noindent
The reason for the checkmate is that the white king on field (7, 1) is
attacked by the red pawn on \mbox{(5, 3)}. There is nowhere for the
white king to go, and no white pawn can be moved into the way of this
red pawn and white can also not capture it. When determining a possible
move, you need to be careful with pieces that might be in the
way. Consider the following position:

\begin{equation}\label{moves}
\begin{tikzpicture}[scale=0.5,every node/.style={scale=0.5}]    
% chessboard
\draw[very thick,gray] (0,0) rectangle (8,8);
\foreach\x in {0,...,7}\foreach\y in {7,...,0}
{
  \pgfmathsetmacro\blend{Mod(\x+\y,2)==0?75:25} 
  \fill[gray!\blend] (\x,\y) rectangle ++ (1,1);
}
% redpieces
\fill[blue!50] (0,2) rectangle ++ (1,1);
\fill[blue!50] (1,1) rectangle ++ (1,1);
\fill[blue!50] (0,4) rectangle ++ (1,1);
\fill[blue!50] (1,5) rectangle ++ (1,1);
\fill[blue!50] (2,6) rectangle ++ (1,1);
%%\fill[blue!50] (3,7) rectangle ++ (1,1);
\fill[blue!50] (4,6) rectangle ++ (1,1);
\fill[blue!50] (5,5) rectangle ++ (1,1);
\fill[blue!50] (6,4) rectangle ++ (1,1);
\fill[blue!50] (6,2) rectangle ++ (1,1);
\fill[blue!50] (7,3) rectangle ++ (1,1);
\fill[blue!50] (4,0) rectangle ++ (1,1);
\fill[blue!50] (2,0) rectangle ++ (1,1);
\pic[fill=red]   at (4,4) {piece={4}};
\pic[fill=red]   at (4,8) {piece={4}};
\pic[fill=white] at (2,5) {piece={3}};
\pic[fill=white] at (4,3) {piece={2}};
\pic[fill=white] at (6,3) {piece={1}};
\pic[fill=white] at (8,4) {piece={1}};
% numbers
\foreach\x in {1,...,8}
{\draw (\x - 0.5, -0.4) node {\x};
}
\foreach\y in {1,...,8}
{\draw (-0.4, \y - 0.6, -0.4) node {\y};
}
\end{tikzpicture}
\end{equation}

\noindent
The red piece in the centre on field (4, 4) can move to all the blue fields.
In particular it can move to (2, 6), because it can move 2 fields up
and 2 fields to the left---it cannot reach this field by moving two
fields to the left and then two up, because jumping over the white
piece at (2, 5) is not allowed. Similarly, the field at (6, 2) is
unreachable for the red piece because of the two white pieces at (4,
3) and (6, 3) are in the way and no S-shape move is allowed in
Shogun. The red piece on (4, 4) cannot move to the field (4, 8) at the
top, because a red piece is already there; but it can move to (8, 4)
and capture the white piece there. The moral is we always have to
explore all possible ways in order to determine whether a piece can be
moved to a field or not: in general there might be several ways and some of
them might be blocked.


\subsection*{Hints}

Useful functions about pieces and boards are defined at the beginning
of the template file. The function \texttt{.map} applies a function to
each element of a list or set; \texttt{.flatMap} works like
\texttt{map} followed by a \texttt{.flatten}---this is useful if a
function returns a set of sets, which need to be ``unioned up''.  Sets
can be partitioned according to a predicate with the function
\texttt{.partition}.  For example

\begin{lstlisting}
val (even, odd) = Set(1,2,3,4,5).partition(_ % 2 == 0)
// --> even = Set(2,4)
//     odd  = Set(1,3,5)
\end{lstlisting}

\noindent
The function \texttt{.toList} transforms a set into a list. The function
\texttt{.count} counts elements according to a predicate. For example

\begin{lstlisting}
Set(1,2,3,4,5).count(_ % 2 == 0)
// --> 2  
\end{lstlisting}

%% \newpage

\subsection*{Tasks}

You are asked to implement how pieces can move on a Shogun board.  Let
us first fix the basic datastructures for the implementation.  A
\emph{position} (or field) is a pair of integers, like $(3, 2)$. The
board's dimension is always 8 $\times$ 8.  A \emph{colour} is either
red (\texttt{Red}) or white (\texttt{Wht}).  A \emph{piece} is either
a pawn or a king, and has a position, a colour and an energy (an
integer).  In the template file there are functions \texttt{incx},
\texttt{decx}, \texttt{incy} and \texttt{decy} for incrementing and
decrementing the x- and y-coordinates of positions of pieces.

A \emph{board} consists of a set of pieces. We always assume that we
start with a consistent board and every move generates another
consistent board. In this way we do not need to check, for example,
whether pieces are stacked on top of each other or located outside the
board, or have an energy outside the permitted range. There are
functions \texttt{-} and \texttt{+} for removing, respectively adding,
single pieces to a board.  The function \texttt{occupied} takes a
position and a board as arguments, and returns an \texttt{Option} of a
piece when this position is occupied, otherwise \texttt{None}. The
function \texttt{occupied\_by} returns the colour of a potential piece
on that position. The function \texttt{is\_occupied} returns a boolean
for whether a position is occupied or not; \texttt{print\_board} is a
rough function that prints out a board on the console. This function
is meant for testing purposes.



\begin{itemize}
\item[(1)] You need to calculate all possible moves for a piece on a Shogun board. In order to
  make sure no piece moves forwards and backwards at the same time,
  and also exclude all S-shape moves, the data-structure \texttt{Move}
  is introduced. A \texttt{Move} encodes all simple moves (up, down, left,
  right) and L-shape moves (first right, then up and so on). This is defined
  as follows:

{\small\begin{lstlisting}
abstract class Move
case object U extends Move    // up
case object D extends Move    // down
case object R extends Move    // right
case object L extends Move    // left
case object RU extends Move   // ...
case object LU extends Move
case object RD extends Move
case object LD extends Move
case object UR extends Move
case object UL extends Move
case object DR extends Move
case object DL extends Move
\end{lstlisting}}

You need to implement an \texttt{eval} function that takes a piece
\texttt{pc}, a move \texttt{m}, an energy \texttt{en} and a board
\texttt{b} as arguments. The idea is to recursively calculate all
fields that can be reached by the move \texttt{m} (there might be more than
one). The energy acts as a counter and decreases in each recursive
call until 0 is reached (the final field). The function \texttt{eval} for a piece \texttt{pc}
should behave as follows:

\begin{itemize}
\item If the position of a piece is outside the board, then no field can be reached (represented by
  the empty set \texttt{Set()}).
\item If the energy is 0 and the position of the piece is \textit{not} occupied, then the field can be reached
  and the set \texttt{Set(pc)} is returned whereby \texttt{pc} is the piece given as argument.
\item If the energy is 0 and the position of the piece \textit{is} occupied, but occupied by a piece
  of the opposite colour, then also the set \texttt{Set(pc)} is returned.
\item In case the energy is > 0 and the position of the piece
  \texttt{pc} is occupied, then this move is blocked and the set
  \texttt{Set()} is returned.  
\item In all other cases we have to analyse the move
  \texttt{m}. First, the simple moves (that is \texttt{U}, \texttt{D},
  \texttt{L} and \texttt{R}) we only have to increment / decrement the
  x- or y-position of the piece, decrease the energy and call eval
  recursively with the updated arguments. For example for \texttt{U}
  you need to increase the y-coordinate:

  \begin{center}
  \texttt{U} $\quad\Rightarrow\quad$ new arguments: \texttt{incy(pc)}, \texttt{U}, energy - 1, same board  
  \end{center}

  The move \texttt{U} here acts like a ``mode'', meaning if you move
  up, you can only move up; the mode never changes. Similarly for the other simple moves: if
  you move right, you can only move right and so on. In this way it is
  prevented to go first to the right, and then change direction in order to go
  left (same with up and down).
  
  For the L-shape moves (\texttt{RU}, \texttt{LU}, \texttt{RD} and so on) you need to calculate two
  sets of reachable fields. Say we analyse \texttt{RU}, then we first have to calculate all fields
  reachable by moving to the right; then we have to calculate all moves by changing the mode to \texttt{U}.
  That means there are two recursive calls to \texttt{eval}:

  \begin{center}
  \begin{tabular}{@{}lll@{}}  
  \texttt{RU} & $\Rightarrow$ & new args for call 1: \texttt{incx(pc)}, \texttt{RU}, energy - 1, same board\\  
              &               & new args for call 2: \texttt{pc}, \texttt{U}, same energy, same board
  \end{tabular}  
  \end{center}

  In each case we receive some new piece(s) on reachable fields and therefore we return the set
  containing all these fields. Similarly in the other cases.
\end{itemize}

For example in the left board below, \texttt{eval} is called with the white
piece in the centre and the move \texttt{RU} generates then a set of
new pieces corresponding to the blue fields. The difference with the
right board is that \texttt{eval} is called with a red piece and therefore the
field (4, 8) is not reachable anymore because it is already occupied by
another red piece. But (7, 5) becomes reachable because it is occupied
by a piece of the opposite colour.

\begin{center}
\begin{tabular}{cc}  
\begin{tikzpicture}[scale=0.45,every node/.style={scale=0.45}]    
% chessboard
\draw[very thick,gray] (0,0) rectangle (8,8);
\foreach\x in {0,...,7}\foreach\y in {7,...,0}
{
  \pgfmathsetmacro\blend{Mod(\x+\y,2)==0?75:25} 
  \fill[gray!\blend] (\x,\y) rectangle ++ (1,1);
}
\fill[blue!50] (5,5) rectangle ++ (1,1);
\fill[blue!50] (3,7) rectangle ++ (1,1);
\fill[blue!50] (4,6) rectangle ++ (1,1);
%\fill[blue!50] (6,4) rectangle ++ (1,1);
\fill[blue!50] (7,3) rectangle ++ (1,1);

% black pieces
\foreach\x/\y/\e in {2/1/3,3/1/2,4/1/3,6/1/3,7/1/1,7/5/2}
  \pic[fill=white] at (\x,\y) {piece={\e}};
% white pieces
\foreach\x/\y/\e in {1/8/4,2/8/2,3/8/4,5/8/4,6/8/2,7/8/3,8/8/1}
  \pic[fill=red] at (\x,\y)     {piece={\e}};
\pic[fill=white] at (5.0,1.0) {king={1}};
\pic[fill=red]   at (4.0,8.0) {king={2}};

\pic[fill=white] at (4,4) {piece={4}};
% numbers
\foreach\x in {1,...,8}
{\draw (\x - 0.5, -0.4) node {\x};
}
\foreach\y in {1,...,8}
{\draw (-0.4, \y - 0.6, -0.4) node {\y};
}
\end{tikzpicture}
&
\begin{tikzpicture}[scale=0.45,every node/.style={scale=0.45}]    
% chessboard
\draw[very thick,gray] (0,0) rectangle (8,8);
\foreach\x in {0,...,7}\foreach\y in {7,...,0}
{
  \pgfmathsetmacro\blend{Mod(\x+\y,2)==0?75:25} 
  \fill[gray!\blend] (\x,\y) rectangle ++ (1,1);
}
\fill[blue!50] (5,5) rectangle ++ (1,1);
\fill[blue!50] (4,6) rectangle ++ (1,1);
\fill[blue!50] (6,4) rectangle ++ (1,1);
\fill[blue!50] (7,3) rectangle ++ (1,1);

% black pieces
\foreach\x/\y/\e in {1/1/1,2/1/3,3/1/2,4/1/3,6/1/3,7/1/1,7/5/2}
  \pic[fill=white] at (\x,\y) {piece={\e}};
% white pieces
\foreach\x/\y/\e in {1/8/4,2/8/2,3/8/4,5/8/4,6/8/2,7/8/3}
  \pic[fill=red] at (\x,\y)     {piece={\e}};
\pic[fill=white] at (5.0,1.0) {king={1}};
\pic[fill=red]   at (4.0,8.0) {king={2}};

\pic[fill=red] at (4,4) {piece={4}};
% numbers
\foreach\x in {1,...,8}
{\draw (\x - 0.5, -0.4) node {\x};
}
\foreach\y in {1,...,8}
{\draw (-0.4, \y - 0.6, -0.4) node {\y};
}
\end{tikzpicture}
\\[-5mm]                    
\end{tabular}                    
\end{center}\hfill[3 Marks]

\item[(2)] Implement an \texttt{all\_moves} function that calculates for a
  piece and a board, \textit{all} possible onward positions. For this
  you have to call \texttt{eval} for all possible moves \texttt{m} (that is \texttt{U},
  \texttt{D}, \ldots, \texttt{DL}). An example for all moves for the red piece on (4, 4) is
  shown in \eqref{moves} on page \pageref{moves}. Be careful about possible modifications
  you need to apply to the board  before you call the \texttt{eval} function.
  Also for this task ignore the fact that a king cannot move onto an attacked field.\\ 
  \mbox{}\hfill[1 Mark]

\item[(3)] Implement a function \texttt{attacked} that takes a colour and a board
  and calculates all pieces of the opposite side that are attacked. For example
  below in the left board are all the attacked pieces by red, and on the right all for white:

\begin{center}
\begin{tabular}{cc}      
\begin{tikzpicture}[scale=0.45,every node/.style={scale=0.45}]    
% chessboard
\draw[very thick,gray] (0,0) rectangle (8,8);
\foreach\x in {0,...,7}\foreach\y in {7,...,0}
{
  \pgfmathsetmacro\blend{Mod(\x+\y,2)==0?75:25} 
  \fill[gray!\blend] (\x,\y) rectangle ++ (1,1);
}
\fill[blue!50] (7,3) rectangle ++ (1,1);
\fill[blue!50] (6,0) rectangle ++ (1,1);


% red pieces
\foreach\x/\y/\e in {6/1/3,4/4/4,5/3/4,6/5/3}
  \pic[fill=red] at (\x,\y) {piece={\e}};
% white pieces
\foreach\x/\y/\e in {8/4/1,4/1/2,8/7/3,6/7/2}
  \pic[fill=white] at (\x,\y)     {piece={\e}};

\pic[fill=red] at (4,2) {king={2}};
\pic[fill=white] at (7,1) {king={2}};

% numbers
\foreach\x in {1,...,8}
{\draw (\x - 0.5, -0.4) node {\x};
}
\foreach\y in {1,...,8}
{\draw (-0.4, \y - 0.6, -0.4) node {\y};
}
\end{tikzpicture}
&
\begin{tikzpicture}[scale=0.45,every node/.style={scale=0.45}]    
% chessboard
\draw[very thick,gray] (0,0) rectangle (8,8);
\foreach\x in {0,...,7}\foreach\y in {7,...,0}
{
  \pgfmathsetmacro\blend{Mod(\x+\y,2)==0?75:25} 
  \fill[gray!\blend] (\x,\y) rectangle ++ (1,1);
}
\fill[blue!50] (5,0) rectangle ++ (1,1);
\fill[blue!50] (5,4) rectangle ++ (1,1);

% red pieces
\foreach\x/\y/\e in {6/1/3,4/4/4,5/3/4,6/5/3}
  \pic[fill=red] at (\x,\y) {piece={\e}};
% white pieces
\foreach\x/\y/\e in {8/4/1,4/1/2,8/7/3,6/7/2}
  \pic[fill=white] at (\x,\y)     {piece={\e}};

\pic[fill=red] at (4,2) {king={2}};
\pic[fill=white] at (7,1) {king={2}};

% numbers
\foreach\x in {1,...,8}
{\draw (\x - 0.5, -0.4) node {\x};
}
\foreach\y in {1,...,8}
{\draw (-0.4, \y - 0.6, -0.4) node {\y};
}
\end{tikzpicture}
\\[-5mm]                       
\end{tabular}
\end{center}\mbox{}\hfill[1 Mark]

\item[(4)] Implement a function \texttt{attackedN} that takes a piece and a board
  and calculates the number of times this pieces is attacked by pieces of the opposite colour.
  For example the piece on field (8, 4) above is attacked by 3 red pieces, and
  the piece on (6, 1) by 1 white piece.
  \\
  \mbox{}\hfill[1 Mark]

\item[(5)] Implement a function \texttt{protectedN} that takes a piece and a board
  and calculates the number of times this pieces is protected by pieces of the same colour.
  For example the piece on field (8, 4) above is protected by 1 white pieces (the one on (8, 7)),
  and the piece on (5, 3) is protected by three red pieces ((6, 1), (4, 2), and (6, 5)).
  \\
  \mbox{}\hfill[1 Mark]

\item[(6)] Implement a function \texttt{legal\_moves} that behaves like \texttt{all\_moves} from (2) for
  pawns, but for kings, in addition, makes sure that they do not move to an attacked field.
  For example in the board below on the left, there are three possible fields the white king can
  reach, but all of them are attacked by red pieces. In the board on the right where the
  white king has an energy of 1, there is only one legal move, namely to move to field (8, 1).
  The field (7, 2) is reachable, but is attacked; similarly capturing the red piece on field (6, 1) is
  not possible because it is protected by at least another red piece.

  \begin{center}
  \begin{tabular}{cc}    
  \begin{tikzpicture}[scale=0.45,every node/.style={scale=0.45}]    
% chessboard
\draw[very thick,gray] (0,0) rectangle (8,8);
\foreach\x in {0,...,7}\foreach\y in {7,...,0}
{
  \pgfmathsetmacro\blend{Mod(\x+\y,2)==0?75:25} 
  \fill[gray!\blend] (\x,\y) rectangle ++ (1,1);
}
\fill[blue!50] (5,1) rectangle ++ (1,1);
\fill[blue!50] (6,2) rectangle ++ (1,1);
\fill[blue!50] (7,1) rectangle ++ (1,1);


% red pieces
\foreach\x/\y/\e in {6/1/3,4/4/4,5/3/4,6/5/3}
  \pic[fill=red] at (\x,\y) {piece={\e}};
% white pieces
\foreach\x/\y/\e in {8/4/1,4/1/2,8/7/3,6/7/2}
  \pic[fill=white] at (\x,\y)     {piece={\e}};

\pic[fill=red] at (4,2) {king={2}};
\pic[fill=white] at (7,1) {king={2}};

% numbers
\foreach\x in {1,...,8}
{\draw (\x - 0.5, -0.4) node {\x};
}
\foreach\y in {1,...,8}
{\draw (-0.4, \y - 0.6, -0.4) node {\y};
}
\end{tikzpicture}  &
 \begin{tikzpicture}[scale=0.45,every node/.style={scale=0.45}]    
% chessboard
\draw[very thick,gray] (0,0) rectangle (8,8);
\foreach\x in {0,...,7}\foreach\y in {7,...,0}
{
  \pgfmathsetmacro\blend{Mod(\x+\y,2)==0?75:25} 
  \fill[gray!\blend] (\x,\y) rectangle ++ (1,1);
}
\fill[blue!50] (5,0) rectangle ++ (1,1);
\fill[blue!50] (6,1) rectangle ++ (1,1);
\fill[blue!50] (7,0) rectangle ++ (1,1);


% red pieces
\foreach\x/\y/\e in {6/1/3,4/4/4,5/3/3,6/5/3}
  \pic[fill=red] at (\x,\y) {piece={\e}};
% white pieces
\foreach\x/\y/\e in {8/4/1,4/1/2,8/7/3,6/7/2}
  \pic[fill=white] at (\x,\y)     {piece={\e}};

\pic[fill=red] at (4,2) {king={2}};
\pic[fill=white] at (7,1) {king={1}};

% numbers
\foreach\x in {1,...,8}
{\draw (\x - 0.5, -0.4) node {\x};
}
\foreach\y in {1,...,8}
{\draw (-0.4, \y - 0.6, -0.4) node {\y};
}
\end{tikzpicture}                      
\end{tabular}                     
\end{center}
\mbox{}\\ \mbox{}\hfill[1 Mark]

\end{itemize}

\end{document}

%%% Local Variables: 
%%% mode: latex
%%% TeX-master: t
%%% End: