chess by NF

--[[                MINECRAFT CHESS

Written by Nitrogen Fingers
Version: 0.85

Acknowledgements:
    ASCII art by David Moeser (1995), Alefith (1995) and Anonyoums (1998)
]]--

version = 0.85

--[[            CHESS ENGINE REGION
    The code within this region handles the logic of playing
    the chess game, including the main engine itself.       ]]--

local var w,h = term.getSize()
--Whether or not the player is white
local var youAreWhite = true
--If it's white's turn (default is yes)
local var whiteTurn = true
--Whether or not the player is still in the game interface
local playing = true
--Whether or not the player is still able to make moves (not checkmate etc.)
local gameOver = true
--Whether or not the black pieces are visible (flashes on and off)
local blackVisible = false

--The position of the white king
local whiteKing = { x = 5, y = 1 }
--The position of the black king
local blackKing = { x = 5, y = 8 }

--A concatenation of the letters typed during the parsing phase
local lastQuery = ""

--Whether the game is playing locally or network
local isLocal = true
--The address of the other player (if there is one)
local opponentID = 1
--The list of all monitors
local monitorList = {}
--The side the monitor is on
local side = nil

-- Board consists of 2D array of strings
-- String format = <sign><piece> where sign is + for white, - for black
--[[
Pieces: K = KING
        Q = QUEEN
        B = BISHOP
        N = KNIGHT
        C = CASTLE
        p = PAWN
--]]

board = {
  --        a     b     c     d     e     f     g     h
  [8] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
  [7] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
  [6] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
  [5] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
  [4] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
  [3] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
  [2] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
  [1] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " }
  --        a     b     c     d     e     f     g     h
}

--[[
The following is tracked under movesMade:
- player: Which player moved (+ for white, - for black)
- piece: What kind of piece moved (p, Q, N, C etc)
- oldx, oldy, newx, newy: Coordinates (numbers please)
- capture: Whether or not the move resulted in a capture (Bf4xe5 for example)
- castle: If the move was a castle - 0 for none, -1 for QS and 1 for KS
- promotion: A string. Empty if no promotion, or the piece promoted to
- ep: Whether or not the capture was an en passant
- check: Whether or not the move resulted in a check (Bf3-g2+ for example)
- mate: Whether or not the move resulted in a mate (Bf3-g2# for example)
- stale: Whether or not the move resulted in a stalemate (Bf3-g2$ for example)
]]--
movesMade = { }

--Prints the player's color and the current turn
function printHeader()
  term.setCursorPos(2, 1)
  if youAreWhite then term.write("You are WHITE")
  else term.write("You are BLACK") end

  term.setCursorPos(28, 1)
  if whiteTurn then term.write("White to play")
  else term.write("Black to play") end

  term.setCursorPos(1, 2)
  term.write(string.rep("-", w))
end

--Prints a list of the last 10 moves made
function printMovesMade()
  local var min = 1
  local var max = #movesMade
  if #movesMade > 9 then min = #movesMade - 9 end
  for i = min,max do
    term.setCursorPos(2, 3 + (i - min + 1))
    term.clearLine()
    --We convert the movesMade entry to a string here using long notation- B3exf2+ ect.
    local entry = convertCoordinateToLetter(movesMade[i].oldx)..movesMade[i].oldy


    if movesMade[i].castle == 0 then
        --This is the standard, non-castling notation used
        if movesMade[i].piece ~= "p" then entry = movesMade[i].piece..entry end
        if movesMade[i].capture then entry = entry.." x "
        else entry = entry.." - " end

        entry = entry..convertCoordinateToLetter(movesMade[i].newx)..movesMade[i].newy

        if movesMade[i].promotion ~= "" then entry = entry.."="..movesMade[i].promotion end
        if movesMade[i].ep then entry  = entry.."e.p." end
        if movesMade[i].check then entry = entry.."+"
        elseif movesMade[i].mate then entry = entry.."#"
        elseif movesMade[i].stale then entry = entry.."$" end

    elseif movesMade[i].castle == 1 then entry = "O-O"
    elseif movesMade[i].castle == -1 then entry = "O-O-O" end

    term.write(i..": "..string.rep(" ", 3 - #tostring(i))..entry)
  end
end

--Prints the board.
function printBoard()
    for i = 1,8 do
        local idx = i
        if youAreWhite then idx = 9 - i end
        term.setCursorPos(25, 3 + i)
        term.write(idx.." |")
        for j=1,8 do
            local jdx = j
            if not youAreWhite then jdx = 9 - j end
            local str = board[idx][jdx]
            if term.isColour() then
                if string.sub(str, 1, 1)== "-" then
                    term.setTextColour(colours.black)
                    str = string.sub(str, 2)
                elseif string.sub(str, 1, 1) == "+" then
                    term.setTextColour(colours.white)
                    str = string.sub(str, 2)
                end
                if idx%2 == jdx%2 then
                    term.setBackgroundColour(colours.brown)
                else
                    term.setBackgroundColour(colours.yellow)
                end
                term.write(" "..str)
                term.setTextColour(colours.white)
                term.setBackgroundColour(colours.black)
            else
                if string.sub(str, 1, 1)== "-" and not blackVisible then str = " " end
                if str ~= " " then str = string.sub(str, 2) end
                if str == " " and idx%2 == jdx%2 then str = "*" end
                term.write(" "..str)
            end
        end
    end
    term.setCursorPos(25, 12)
    term.write("   "..string.rep("-", 16))
    term.setCursorPos(25, 13)
    if youAreWhite then term.write("    a b c d e f g h")
    else term.write("    h g f e d c b a") end
end

--This method determines whether a specific move made by a player is legal
--If not an error will have details (so these methods are long)
--Note we use AmWhite here to test for checking
function isLegal(oldx,oldy,newx,newy,amWhite)
  if not coordinatesSensible(oldx, oldy, newx, newy) then return false end
  local piece = string.sub(board[oldy][oldx], 2)

  local isLegal = false
  if piece=="p" then isLegal = isLegalPawn(oldx,oldy,newx,newy,amWhite,false,false)
  elseif piece=="C" then isLegal = isLegalCastle(oldx,oldy,newx,newy,amWhite,false)
  elseif piece=="N" then isLegal = isLegalKnight(oldx,oldy,newx,newy,amWhite,false)
  elseif piece=="B" then isLegal = isLegalBishop(oldx,oldy,newx,newy,amWhite,false)
  elseif piece=="Q" then isLegal = isLegalQueen(oldx,oldy,newx,newy,amWhite,false)
  elseif piece=="K" then isLegal = isLegalKing(oldx,oldy,newx,newy,amWhite,false,false) end

  if isLegal then
    if amWhite then
        if piece=="K" then isLegal = not isInCheck(newx,newy,amWhite)
        else
            local oldsrc = board[oldy][oldx]
            local olddest = board[newy][newx]
            -- I'm a bit worried about this... test!
            board[newy][newx] = board[oldy][oldx]
            board[oldy][oldx] = " "

            isLegal = not isInCheck(whiteKing.x,whiteKing.y,amWhite)

            board[oldy][oldx] = oldsrc
            board[newy][newx] = olddest
        end
    else
        if piece=="K" then isLegal = not isInCheck(newx,newy,amWhite)
        else
            local oldsrc = board[oldy][oldx]
            local olddest = board[newy][newx]
            -- I'm a bit worried about this... test!
            board[newy][newx] = board[oldy][oldx]
            board[oldy][oldx] = " "

            isLegal = not isInCheck(blackKing.x,blackKing.y,amWhite)

            board[oldy][oldx] = oldsrc
            board[newy][newx] = olddest
        end
    end

    if not isLegal then printMessage("That move leaves your king in check.") end
  end

  return isLegal
end

--This loops through every position on the board, and where enemy pieces are
--found, determines if any place the king in check.
function isInCheck(posx,posy,amWhite)
    local takeable = "+"
    if amWhite then takeable = "-" end

    for i=1,8 do
        for j=1,8 do
            if string.sub(board[j][i], 1, 1) == takeable then
                local piece = string.sub(board[j][i], 2)
                local legal = false
                if piece=="p" then legal = isLegalPawn(i,j,posx,posy,not amWhite,true,true)
                elseif piece=="C" then legal = isLegalCastle(i,j,posx,posy,not amWhite,true)
                elseif piece=="N" then legal = isLegalKnight(i,j,posx,posy,not amWhite,true)
                elseif piece=="B" then legal = isLegalBishop(i,j,posx,posy,not amWhite,true)
                elseif piece=="Q" then legal = isLegalQueen(i,j,posx,posy,not amWhite,true)
                elseif piece=="K" then legal = isLegalKing(i,j,posx,posy,not amWhite,true,true) end
                if legal then return true end
            end
        end
    end
    return false
end

--Legal for a pawn. Color dependent. Manages movement and capturing (including en passant)
--The forking exception means the pawn will ONLY accept diagonals, not forwards
function isLegalPawn(oldx,oldy,newx,newy,amWhite,suppress,forKing)
    if amWhite then
        local takeable = "-"
        if newy-oldy == 1 and newx-oldx == 0 and board[newy][newx] == " " and not forKing
            then return true
        elseif newy-oldy == 2 and newx-oldx == 0 and board[newy][newx] == " " and
          board[newy-1][newx] == " " and oldy == 2 and not forKing
            then return true
        elseif newy-oldy == 1 and math.abs(newx-oldx) == 1 then
            if string.sub(board[newy][newx], 1, 1) == takeable or forKing then return true
            elseif board[newy-1][newx] == takeable.."p" and
            movesMade[#movesMade].newy == newy-1 and movesMade[#movesMade].newx == newx and
              math.abs(movesMade[#movesMade].newy - movesMade[#movesMade].oldy) == 2 then
                return true
            end
            if not suppress then printMessage("You cannot take that space with the pawn.") end
        end
        if not suppress then printMessage("Your pawn can't move there.") end
    else
        local takeable = "+"
        if newy-oldy == -1 and newx-oldx == 0 and board[newy][newx] == " " and not forKing
            then return true
        elseif newy-oldy == -2 and newx-oldx == 0 and board[newy][newx] == " " and
          board[newy+1][newx] == " " and oldy == 7 and not forKing
            then return true
        elseif newy-oldy == -1 and math.abs(newx-oldx) == 1 then
            if string.sub(board[newy][newx], 1, 1) == takeable or forKing then return true
            elseif board[newy+1][newx] == takeable.."p" and
              math.abs(movesMade[#modesMade].newy - movesMade[#movesMade].oldy) == 2 then
                return true
            end
            if not suppress then printMessage("You cannot take that space with the pawn.") end
        end
        if not suppress then printMessage("Your pawn can't move there.") end
    end

    return false
end

--Legal for a castle. Manages movement and capturing
function isLegalCastle(oldx,oldy,newx,newy,amWhite,suppress)
    local takeable = "+"
    if amWhite then takeable = "-" end

    if newy == oldy then
        local inc = 1
        if newx < oldx then inc = -1 end
        for i = oldx+inc, newx-inc, inc do
            if board[newy][i] ~= " " then
                if not suppress then printMessage("The castle's path is blocked to that space.") end
                return false
            end
        end
        piece = board[newy][newx]
        if piece == " " or string.sub(piece, 1, 1) == takeable then return true end
        if not suppress then printMessage("Your castle can't take that piece.") end
        return false

    elseif newx == oldx then
        local inc = 1
        if newy < oldy then inc = -1 end
        for i = oldy+inc, newy-inc, inc do
            if board[i][newx] ~= " " then
                if not suppress then printMessage("The castle's path is blocked to that space.") end
                return false
            end
        end
        piece = board[newy][newx]
        if piece == " " or string.sub(piece, 1, 1) == takeable then return true end
        if not suppress then printMessage("Your castle can't take that piece.") end
        return false
    end
    if not suppress then printMessage(oldx..","..oldy.." can only move along ranks or files.") end
    return false
end

--Legal for a knight. Manages movement and capturing
function isLegalKnight(oldx,oldy,newx,newy,amWhite,suppress)
    local takeable = "+"
    if amWhite then takeable = "-" end

    if (math.abs(oldx-newx) == 1 and math.abs(oldy-newy) == 2) or
      (math.abs(oldx-newx) == 2 and math.abs(oldy-newy) == 1) then
        if board[newy][newx] == " " or string.sub(board[newy][newx], 1, 1) == takeable then
            return true
        end
    end

    if not suppress then printMessage("Your knight can't move there.") end
    return false
end

--Legal for a bishop. Manages movement and capturing
function isLegalBishop(oldx,oldy,newx,newy,amWhite,suppress)
    local takeable = "+"
    if amWhite then takeable = "-" end

    if math.abs(oldx-newx) == math.abs(oldy-newy) then
        local xmp = 1
        local ymp = 1
        if newx < oldx then xmp = -1 end
        if newy < oldy then ymp = -1 end
        for i = 1,math.abs(oldx-newx) - 1 do
            if board[oldy + (i * ymp)][oldx + (i * xmp)] ~= " " then
                printMessage("The bishop's path is blocked to that space.")
                return false
            end
        end
        piece = board[newy][newx]
        if piece == " " or string.sub(piece, 1, 1) == takeable then return true end
        printMessage("Your bishop can't take that piece.")
        return false
    end
    if not suppress then printMessage("Bishops can only move along diagonals.") end
    return false
end

--Legal for a queen. Manages movement and capturing
function isLegalQueen(oldx,oldy,newx,newy,amWhite,suppress)
    local possible = isLegalBishop(oldx,oldy,newx,newy,amWhite,suppress) or
      isLegalCastle(oldx,oldy,newx,newy,amWhite,suppress)
    if not possible and not suppress then printMessage("Your queen can't move there.") end
    return possible
end

--Legal for a king. Managed movement and capturing
-- The forking exception excludes the ability to castle
function isLegalKing(oldx,oldy,newx,newy,amWhite,suppress,forKing)
    local takeable = "+"
    if amWhite then takeable = "-" end

    if newx - oldx == 2 and newy-oldy == 0 and not forKing then return isLegalCastling("king", amWhite)
    elseif newx - oldx == -2 and newy-oldy == 0 and not forKing then return isLegalCastling("queen", amWhite)
    elseif math.abs(oldx-newx) > 1 or math.abs(oldy-newy) > 1 then
        if not suppress then printMessage("Your king can only move one tile in any direction") end
        return false
    end

    piece = board[newy][newx]
    if piece == " " or string.sub(piece, 1, 1) == takeable then return true end
    if not suppress then printMessage("Your king can't take that piece.") end
    return false
end

--This isLegal method is aimed specifically at castling, with the string being
--passed "king" or "queen" to indicate kingside or queenside castling.
function isLegalCastling(side,amWhite)
    if amWhite then
        if side == "king" then
            if board[1][6]~= " " or board[1][7] ~= " " then
                printMessage("You cannot castle- the path is blocked")
                return false
            end

            for i=1,#movesMade do
                local move = movesMade[i]
                if move.piece == "K" and move.player == "+" then
                    printMessage("You cannot castle- your king has moved before.")
                    return false
                elseif move.piece == "C" and move.player == "+"
                  and move.oldx == 8 and move.oldy == 1 then
                    printMessage("You cannot castle- your ks castle has moved before.")
                    return false
                end
            end
            return true
        elseif side == "queen" then
            if board[1][2] ~= " " or board[1][3] ~= " " or board[1][4] ~= " " then
                printMessage("You cannot castle- the path is blocked")
                return false
            end

            for i=1,#movesMade do
                local move = movesMade[i]
                if move.piece == "K" and move.player == "+" then
                    printMessage("You cannot castle- your king has moved before.")
                    return false
                elseif move.piece == "C" and move.player == "+"
                  and move.oldx == 1 and move.oldy == 1 then
                    printMessage("You cannot castle- your qs castle has moved before.")
                    return false
                end
            end
            return true
        end

    else

        if side == "king" then
            if board[8][6]~= " " or board[8][7] ~= " " then
                printMessage("You cannot castle- the path is blocked")
                return false
            end

            for i=1,#movesMade do
                local move = movesMade[i]
                if move.piece == "K" and move.player == "-" then
                    printMessage("You cannot castle- your king has moved before.")
                    return false
                elseif move.piece == "C" and move.player == "-" and
                  move.oldx == 8 and move.oldy == 8 then
                    printMessage("You cannot castle- your ks castle has moved before.")
                    return false
                end
            end
            return true
        elseif side == "queen" then
            if board[8][2] ~= " " or board[8][3] ~= " " or board[8][4] ~= " " then
                printMessage("You cannot castle- the path is blocked")
                return false
            end

            for i=1,#movesMade do
                local move = movesMade[i]
                if move.piece == "K" and move.player == "-" then
                    printMessage("You cannot castle- your king has moved before.")
                    return false
                elseif move.piece == "C" and move.player == "-" and
                  move.oldx == 1 and move.oldy == 8 then
                    printMessage("You cannot castle- your qs castle has moved before.")
                    return false
                end
            end
            return true
        end
    end
end

--Submethod of isLegal, determines whether or not the choice of piece and
--destination square make sense within the game
function coordinatesSensible(oldx, oldy, newx, newy)
  if oldx == newx and oldy == newy then
    printMessage("Each piece must move at least 1 square.")
    return false
  end

  if oldx < 1 or oldx > 8 or newx < 1 or newx > 8 or oldy < 1 or oldy > 8
    or newy < 1 or newy > 8 then
    printMessage("The coordinates you provided were invalid")
    return false
  end
  local piece = board[oldy][oldx]
  if piece == " " then
    printMessage("There isn't a piece on that space")
    return false
  elseif (string.sub(piece, 1, 1) == "+") ~= youAreWhite then
    printMessage("There's an enemy piece on that space")
    return false end
  return true
end

--This actually acts upon the move made. It moves the piece on the board, adds
--an entry to the moves list, tells the other commputer the move is made and
--refreshes everything.
function makeMove(oldx,oldy,newx,newy,amWhite)
    local player = "+"
    local foe = "-"
    if not amWhite then
        player = "-"
        foe = "+"
    end

    local capture = false
    local ep = false

    if board[newy][newx] ~= " " then capture = true end
    if board[newy][newx] == " " and math.abs(oldx-newx) == 1 and
      board[oldy][oldx]:sub(2) == "p" and board[oldy][newx]:sub(2) == "p" then
        capture = true
        ep = true
        board[oldy][newx] = " "
    end

    board[newy][newx] = board[oldy][oldx]
    board[oldy][oldx] = " "
    local piece = string.sub(board[newy][newx], 2)

    --We handle updating king positions and CASTLING here
    castle = 0
    if board[newy][newx] == "+K" then
        whiteKing = { x = newx, y = newy }
        if newx - oldx == 2 then
            board[1][6] = board[1][8]
            board[1][8] = " "
            castle = 1
        elseif newx - oldx == -2 then
            board[1][4] = board[1][1]
            board[1][1] = " "
            castle = -1
        end
    end
    if board[newy][newx] == "-K" then
        blackKing = { x = newx, y = newy }
        if newx - oldx == 2 then
            board[8][6] = board[8][8]
            board[8][8] = " "
            castle = 1
        elseif newx - oldx == -2 then
            board[8][4] = board[8][1]
            board[8][1] = " "
            castle = -1
        end
    end

    --Promotion is handled here
    promotion = ""
    if piece == "p" then
        if (youAreWhite and player == "+" and newy == 8) or
          (not youAreWhite and player == "-" and newy == 1) then
            handlePawnPromotion(newx, newy, youAreWhite)
            promotion = string.sub(board[newy][newx], 2)
            if not isLocal then
                rednet.send(opponentID, "#P"..newx..newy..board[newy][newx])
                sendToMonitors("#P"..newx..newy..board[newy][newx])
            end
        end
    end

    local check = false
    --Again, needs to be debugged
    if not amWhite then
        check = isInCheck(whiteKing.x, whiteKing.y, true)
    else
        check = isInCheck(blackKing.x, blackKing.y, false)
    end


    table.insert(movesMade, {
      player = player,
      piece = piece,
      oldx = oldx,
      oldy = oldy,
      newx = newx,
      newy = newy,
      capture = capture,
      castle = castle,
      promotion = promotion,
      ep = ep,
      check = check,
      mate = false,
      stale = false
    })
end

--A specialized function that reads input to determine a pawn promotion
--This is called in makeMove, but only if it's the same player
function handlePawnPromotion(x,y,amWhite)
    printMessage("Promote: (Q)ueen, (C)astle, k(N)ight or (B)ishop")
    term.setCursorPos(1, 16)
    term.clearLine()
    term.write("> ")

    local ptype = "+"
    if not amWhite then ptype = "-" end

    local id,key = os.pullEvent("char")
    if string.upper(key) == "C" then
        board[y][x] = ptype.."C"
    elseif string.upper(key) == "N" then
        board[y][x] = ptype.."N"
    elseif string.upper(key) == "B" then
        board[y][x] = ptype.."B"
    else
        --We do this by default... easier this way
        board[y][x] = ptype.."Q"
    end

    printMessage("Pawn promoted")
    --Restarts that timer we so rudely interrupted
    os.startTimer(0.1)
end

--This promotes a pawn from a network message
function handleRemotePawnPromotion(msg)
    local x = tonumber(string.sub(msg, 1, 1))
    local y = tonumber(string.sub(msg, 2, 2))
    local piece = string.sub(msg, 3)

    board[y][x] = piece
    movesMade[#movesMade].promotion = string.sub(msg, 4)
end

--Takes in an input string and converts it to a chess query.
--The input method is EXTREMELY strict. This ensures it conforms
--The input string must be 5 characters long- the first two are the X and Y of
--the piece to move, followed by a space character and the second two coordinates.
--Example of a legal input: e5-b7 a1 a6 f3xg2
--Example of illegal input: 55 b3 a4  h8 f3xg2+
--This will return true if the move occurred, false otherwise
function parseInput(input,amWhite)
    if input == "quit" or input == "exit" then
        if not isLocal then
            rednet.send(opponentID, "#E")
        end
        playing = false
        return true
    end
    if (input == "reset" or input == "restart") and isLocal then
        resetGame(true)
        return true
    end
    if input == "draw" then
        printMessage("Waiting for response...")
        rednet.send(opponentID, "#D")
        while true do
            local id,key,msg = os.pullEvent("rednet_message")
            if msg == "#Y" then
                printMessage("Game result: 1/2 - 1/2")
                os.pullEvent("key")
                playing = false
                return true
            elseif msg == "#N" then
                printMessage("Draw rejected.")
                os.startTimer(0.2)
                return false
            end
        end
    end

    if gameOver then
        printMessage("Game is over- you can \'exit\' or \'restart\'.")
        return false
    end

    local oldx = convertLetterToCoordinate(string.sub(input, 1, 1))
    local oldy = tonumber(string.sub(input, 2, 2))
    if not oldy then oldy = -1 end
    local newx = convertLetterToCoordinate(string.sub(input, 4, 4))
    local newy = tonumber(string.sub(input, 5, 5))
    if not newy then newy = -1 end

    if isLegal(oldx,oldy,newx,newy,amWhite) then
        printMessage("Making move...")
        makeMove(oldx,oldy,newx,newy,amWhite)
        return true
    end
    return false
end

--Runs on the OS timer and uses it to update the black pieces flashing on and off
function updateBlackFlashing()
  blackVisible = not blackVisible
  printBoard()

  local length = 0.2
  if not blackVisible then length = 0.15 end
  os.startTimer(length)
end

--This prints the oneline message above the command prompt
function printMessage(message)
  term.setCursorPos(1, 15)
  term.clearLine()
  term.write(message)
end

--This converts a letter coordinate like a or f to a number
function convertLetterToCoordinate(input)
  if input=="a" then return 1
  elseif input=="b" then return 2
  elseif input=="c" then return 3
  elseif input=="d" then return 4
  elseif input=="e" then return 5
  elseif input=="f" then return 6
  elseif input=="g" then return 7
  elseif input=="h" then return 8
  else return -1 end
end

--The reverse operation. Converts a number to a letter coordiante.
function convertCoordinateToLetter(input)
  if input==1 then return "a"
  elseif input==2 then return "b"
  elseif input==3 then return "c"
  elseif input==4 then return "d"
  elseif input==5 then return "e"
  elseif input==6 then return "f"
  elseif input==7 then return "g"
  elseif input==8 then return "h"
  else return -1 end
end

--An update function for the input display- displaying the latest string
function updateInputDisplay()
    term.setCursorPos(1, 16)
    term.clearLine()
    term.write("> "..lastQuery)
end

--Restores the board to it's original state, and clears all moves.
function resetGame(amWhite)
    term.clear()
    youAreWhite = amWhite
    whiteTurn = true
    movesMade = {}
    gameOver = false
    --[[
    board = {
        --        a     b     c     d     e     f     g     h
        [8] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
        [7] = { " ",  " ",  " ",  " ",  "+p",  " ",  " ",  " " },
        [6] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
        [5] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
        [4] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
        [3] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
        [2] = { " ",  " ",  " ",  " ",  "-p",  " ",  " ",  " " },
        [1] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " }
        --        a     b     c     d     e     f     g     h
    }]]--
    board = {
        --       a     b     c     d     e     f     g     h
        [8] = { "-C", "-N", "-B", "-Q", "-K", "-B", "-N", "-C"},
        [7] = { "-p", "-p", "-p", "-p", "-p", "-p", "-p", "-p"},
        [6] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
        [5] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
        [4] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
        [3] = { " ",  " ",  " ",  " ",  " ",  " ",  " ",  " " },
        [2] = { "+p", "+p", "+p", "+p", "+p", "+p", "+p", "+p"},
        [1] = { "+C", "+N", "+B", "+Q", "+K", "+B", "+N", "+C"}
        --       a     b     c     d     e     f     g     h
    }
end

--This manages the game logic. It runs in an infinite loop (of course)
function playGame()
    term.clear()
    os.startTimer(0.2)
    while playing do
        printMovesMade()
        printBoard()
        printHeader()
        term.setCursorPos(1, 16)
        term.clearLine()
        term.write("> ")

        if not isLocal and youAreWhite ~= whiteTurn then
            local proMsg = nil
            while true do
                local id,  key, msg = os.pullEvent()
                if id == "timer" then updateBlackFlashing()
                elseif id == "rednet_message" and key == opponentID then
                    if msg == "#E" then
                        playing = false
                        break
                    elseif msg == "#D" then
                        printMessage("Draw offered- accept? (Y)es or (N)o")
                        local id,key = os.pullEvent("char")
                        if key == "Y" or key == "y" then
                            playing = false
                            printMessage("Game result: 1/2 - 1/2")
                            rednet.send(opponentID, "#Y")
                            os.pullEvent("key")
                            break
                        else
                            printMessage("Draw rejected.")
                            rednet.send(opponentID, "#N")
                            os.startTimer(0.2)
                        end
                    elseif string.find(msg, "#P") == 1 then
                        proMsg = string.gsub(msg, "#P", "")
                    else
                        local oldx = convertLetterToCoordinate(string.sub(msg, 1, 1))
                        local oldy = tonumber(string.sub(msg, 2, 2))
                        local newx = convertLetterToCoordinate(string.sub(msg, 4, 4))
                        local newy = tonumber(string.sub(msg, 5, 5))

                        makeMove(oldx,oldy,newx,newy,not youAreWhite)

                        if proMsg then handleRemotePawnPromotion(proMsg) end
                        break
                    end
                end
            end
        else
            local noMoves = #movesMade
            while noMoves == #movesMade do
                local id,key = os.pullEvent()
                if id == "timer" then updateBlackFlashing()
                elseif id == "key" then
                    if key == 14 then
                        if #lastQuery > 1 then lastQuery = string.sub(lastQuery, 1, #lastQuery-1)
                        else lastQuery = "" end
                    elseif key == 28 then
                        local occ = parseInput(lastQuery, youAreWhite)
                        if occ and not isLocal then
                            rednet.send(opponentID, lastQuery)
                            sendToMonitors(lastQuery)
                        end

                        if (lastQuery == "reset" or lastQuery == "restart") then
                            lastQuery = ""
                            break
                        end
                        lastQuery = ""
                        if not playing then break end
                    end
                    updateInputDisplay()
                elseif id == "char" then
                    lastQuery = lastQuery..key
                    updateInputDisplay()
                end
            end
        end

        if isLocal then youAreWhite = not youAreWhite end
        whiteTurn = not whiteTurn
    end
    --With the menu system, we allow the player to return to the main menu
    --This can be turned off to make an exit quit chess altogether
    playing = true
    sendToMonitors("#Q")
end

--Finds the side the modem is on, and opens it
function openModem()
    for i=1,#rs.getSides() do
        if peripheral.isPresent(rs.getSides()[i]) and peripheral.getType(rs.getSides()[i]) == "modem" then
            side = rs.getSides()[i]
            rednet.open(side)
            return true
        end
    end
    return false
end

--Sends a message to each monitor hooked up to the network
function sendToMonitors(msg)
    for k,v in pairs(monitorList) do
        rednet.send(v, msg)
    end
end

--[[                    GUI REGION
        This code handles the visual interface for the
        menu system and network play of the Chess system        ]]--

--The error message displayed when a network error has occurred
local networkErrorMessage = ""
--The currently selected menu option
local menuSel = 1
--Which help page is currently being viewed
local helpPage = 1

--Draws the main menu
function drawMainInterface()
    term.clear()
    drawASCIIKing(w-12,h-14)
    drawASCIIRook(5, h-9)

    term.setCursorPos(4, 3)
    term.write("Minecraft Chess")
    term.setCursorPos(4, 4)
    term.write("===============")

    printCentered("Local Game", 7)
    printCentered("Network Game", 10)
    printCentered("Instructions", 13)
    printCentered("Quit Game", 16)

    printCentered("------------", 5 + menuSel * 3)
end

--Draws the "host network game" menu interface
function drawNetworkInterface()
    term.clear()
    drawASCIIBishop(w - 10, h - 12)
    drawASCIIPawn(3, h - 7)
    drawASCIIPawn(5, h - 6)

    printCentered("Network Game", 2)
    printCentered("============", 3)

    printCentered("Host", 7)
    printCentered("Join", 10)
    printCentered("Back", 13)
    printCentered("------", 5 + menuSel * 3)
end

--Draws the screen that requests an computer ID
function drawIDRequest()
    term.clear()
    drawASCIIBishop(w - 10, h - 12)
    drawASCIIPawn(3, h - 7)
    drawASCIIPawn(5, h - 6)

    term.setCursorPos(4, 5)
    term.write("Enter the host's computer ID: ")
end

--In the event players can't connet, by timeout or no modem or something this says so
function drawNetworkError()
    term.clear()
    drawASCIIBishop(w - 10, h - 12)
    drawASCIIPawn(3, h - 7)
    drawASCIIPawn(5, h - 6)

    printCentered(networkErrorMessage, 5)
    printCentered("Press any key to go back.", 10)
end

--Draws the "wait for connection" interface
function drawWaitForConnection()
    term.clear()
    drawASCIIBishop(w - 10, h - 12)
    drawASCIIPawn(3, h - 7)
    drawASCIIPawn(5, h - 6)

    printCentered("Waiting for connection...", 5)
    printCentered("(Your ID is "..os.getComputerID()..")", 6)
    printCentered("Press enter to cancel", 8)
end

--Draws the tutorial help functions
function drawHelp()
    term.clear()
    drawASCIIKnight(3, h - 7)
    drawASCIIPawn(13, h - 6)

    local nextstr = "Next"
    local prevstr = "Prev"
    local offset = 0

    for i=1,#helpText[helpPage] do
        term.setCursorPos(2,1 + i)
        term.write(helpText[helpPage][i])
    end

    if helpPage == 1 then
        prevstr = string.rep(" ", 4)
        offset = 12
    end
    if helpPage == #helpText then nextstr = string.rep(" ", 4) end

    term.setCursorPos(20, 15)
    term.write(prevstr..string.rep(" ", 8).."Back"..string.rep(" ", 8)..nextstr)
    term.setCursorPos(8 + offset + menuSel * 12, 16)
    term.write("----")
    term.setCursorPos(35, 18)
    term.write("Page "..helpPage.." of "..#helpText)
end

--Starts a local game
function startLocalGame()
    resetGame(true)
    isLocal = true
    playGame()
    currentInterface = interfaces["main"]
end

--Starts a network game
function startNetworkGame(amWhite)
    resetGame(amWhite)
    isLocal = false
    playGame()
    currentInterface = interfaces["main"]
end

--[[The following methods are tiny stubs to fix the variable no access issue]]--
--Necessary to set the interface back to main(no access from inside a list)
function returnToMainMenu()
    currentInterface = interfaces["main"]
end
--Necessary to update the help pages
function updateHelpPage(value)
    helpPage = value
    if helpPage ~= 1 then menuSel = 2 end
end

--Prints the provided string in the centre of the screen at the y coordinate specified
function printCentered(str,y)
    term.setCursorPos(w/2 - #str/2, y)
    term.write(str)
end

--Draws an ASCII king at the desired coordinates. Dimensions are (10,14) characters
function drawASCIIKing(x,y)
    local kingList = {
        "   _||_   ",
        "   _||_   ",
        " _/____\\_ ",
       " \\      / ",
       "  \\____/  ",
        "  (____)  ",
        "   |  |   ",
        "   |  |   ",
        "   |  |   ",
        "   |  |   ",
        "   |__|   ",
        "  /    \\  ",
        " (______) ",
        "(________)",
    }

    for i=1,#kingList do
        term.setCursorPos(x, y + i - 1)
        term.write(kingList[i])
    end
end

--Draws an ASCII rook at the desired coordinates. Dimensions are (8,9) characters
function drawASCIIRook(x,y)
    local rookList = {
        " |'-'-'|",
        "  \\   / ",
        "  |   |  ",
        "  |   |  ",
        "  |   |  ",
        "  |   |  ",
        "  |___|  ",
        " /_____\\ ",
        "(_______)"
    }

    for i=1,#rookList do
        term.setCursorPos(x, y + i - 1)
        term.write(rookList[i])
    end
end

--Draws an ASCII pawn at the desired coordinates. Dimensions are (6,6) characters
function drawASCIIPawn(x,y)
    local pawnList = {
        "  __  ",
        " (  ) ",
        "  ||  ",
        "  ||  ",
        " /__\\ ",
        "(____)"
    }

    for i=1,#pawnList do
        term.setCursorPos(x, y + i - 1)
        term.write(pawnList[i])
    end
end

--Draws an ASCII knight at the desired coordinates. Dimensions are (7,9) characters
function drawASCIIKnight(x,y)
    local knightList = {
        " __/\"\"\"\\     ",
        "]___ O  }",
        "    /   }",
        "  /~    }",
       "  \\____/ ",
        "  /____\\ ",
        " (______)"
    }

    for i=1,#knightList do
        term.setCursorPos(x, y + i - 1)
        term.write(knightList[i])
    end
end

--Draws an ASCII bishop at the desired coordinates. Dimensions are (8,11) characters
function drawASCIIBishop(x,y)
    local bishopList = {
        "   _<>  ",
        " /\\\\  \\",
        " \\ \\) /",
       "  \\__/  ",
        " (____) ",
        "  |  |  ",
        "  |  |  ",
        "  |  |  ",
        "  |__|  ",
        " /____\\ ",
        "(______)"
    }

    for i=1,#bishopList do
        term.setCursorPos(x, y + i - 1)
        term.write(bishopList[i])
    end
end


--Requests an ID for the enemy computer
function inputOpponentID()
    opponentID = tonumber(io.read())
    if not opponentID then
        networkErrorMessage = "The ID you entered is invalid"
        currentInterface = interfaces["networkerror"]
    else
        currentInterface = interfaces["join"]
    end
end


--[WOLVAN, your code goes here]--

--Attempts to join a hosted game
function waitForHost()
    currentInterface = interfaces["main"]
    if not openModem() then
        networkErrorMessage = "Your computer doesn't have a modem!"
        currentInterface = interfaces["networkerror"]
        return
    end

    rednet.send(opponentID, "#C")
    while true do
        local id,msg = rednet.receive(5)
        currentInterface = interfaces["main"]
        if id == opponentID and msg == "#C" then
            currentInterface = interfaces["waittostart"]
            return
        end
        if id == nil then break end
    end
    networkErrorMessage = "The connection timed out."
    currentInterface = interfaces["networkerror"]
end

--Waits on a user to join the game
function waitForClient()
    if not openModem() then
        networkErrorMessage = "Your computer doesn't have a modem!"
        currentInterface = interfaces["networkerror"]
        return
    end

    while true do
        local evt,id,msg = os.pullEvent()
        if evt == "rednet_message" and msg == "#C" then
            opponentID = id
            rednet.send(opponentID, "#C")
            currentInterface = interfaces["addmonitors"]
            return
        elseif evt == "key" and id == 28 then
            currentInterface = interfaces["main"]
            return
        end
    end
    networkErrorMessage = "The connection timed out."
    currentInterface = interfaces["networkerror"]
end

--Draws the request to add more monitors or just move on
function drawAddMonitors()
    term.clear()
    drawASCIIBishop(w - 10, h - 12)
    drawASCIIPawn(3, h - 7)
    drawASCIIPawn(5, h - 6)

    printCentered("Connection established- add monitors now", 5)
    printCentered("(Your ID is "..os.getComputerID()..")", 6)
    printCentered("Press any key to start the game", 8)
end

--Waits for any monitors to connect to the network, and starts a new game when ready
function addMonitors()
    while true do
        local id,key,value = os.pullEvent()
        if id == "rednet_message" and value=="#M" then
            table.insert(monitorList, key)
            rednet.send(opponentID, "#M"..key)
            rednet.send(key, "#Y")
        elseif id == "key" and key == 28 then
            rednet.send(opponentID, "#S")
            startNetworkGame(true)
            currentInterface = interfaces["main"]
            return
        end
    end
end

--Displays a simple "waiting to start"  message
function drawWaitingToStart()
    term.clear()
    drawASCIIBishop(w - 10, h - 12)
    drawASCIIPawn(3, h - 7)
    drawASCIIPawn(5, h - 6)

    printCentered("Connection Established!", 5)
    printCentered("Waiting for host...", 6)
    printCentered("The game will start shortly", 8)
end

--Listens for any monitors that may be received and when #S appears the game starts
function waitToStart()
    while true do
        local id, key, value = os.pullEvent("rednet_message")
        if key == opponentID then
            if string.find(value, "#M") == 1 then
                value = string.sub(value, 3)
                if tonumber(value) then table.insert(monitorList, (tonumber(value))) end
            elseif value == "#S" then
                startNetworkGame(false)
                currentInterface = interfaces["main"]
                return
            end
        end
    end
 end

--[[
    Construction of an interface menu has the following requirements:
    the index should be the string identifying that menu element
    options - A list of all menu options in order of selection
    draw - a function that draws the menu
    setup - a function that organizes the setup (this may include starting a new game)
    nextKeyCode - the key the user must strike to move to the next menu option
    prevKeyCode - the key the user must strike to move to the previous menu option
    input - overrides the standard key handler, if the interface has one.
]]--
interfaces = {
    ["main"] = {
        options = {"local", "network", "page1", "quit"},
        draw = drawMainInterface,
        nextKeyCode = 208,
        prevKeyCode = 200
    },
    ["local"] = {
        setup = startLocalGame
    },
    ["network"] = {
        options = {"host", "hostidinput", "main"},
        draw = drawNetworkInterface,
        nextKeyCode = 208,
        prevKeyCode = 200
    },
    ["host"] = {
        draw = drawWaitForConnection,
        input = waitForClient
    },
    ["hostidinput"] = {
        draw = drawIDRequest,
        input = inputOpponentID
    },
    ["addmonitors"] = {
        draw = drawAddMonitors,
        input = addMonitors
    },
    ["waittostart"] = {
        draw = drawWaitingToStart,
        input = waitToStart
    },
    ["join"] = {
        draw = drawWaitForConnection,
        input = waitForHost
    },
    ["networkerror"] = {
        draw = drawNetworkError,
        input = function()
            os.pullEvent("key")
            returnToMainMenu()
        end
    },
    ["unimplemented"] = {
        draw = drawUnimplementedInterface,
        input = function()
            os.pullEvent("key")
            returnToMainMenu()
        end
    },
    ["timeout"] = {
        draw = drawTimeout
    },
    --The help pages
    ["page1"] = {
        setup = function() updateHelpPage(1) end,
        options = {"main", "page2"},
        draw = drawHelp,
        nextKeyCode = 205,
        prevKeyCode = 203
    },
    ["page2"] = {
        setup = function() updateHelpPage(2) end,
        options = {"page1", "main", "page3"},
        draw = drawHelp,
        nextKeyCode = 205,
        prevKeyCode = 203
    },
    ["page3"] = {
        setup = function() updateHelpPage(3) end,
        options = {"page2", "main", "page4"},
        draw = drawHelp,
        nextKeyCode = 205,
        prevKeyCode = 203
    },
    ["page4"] = {
        setup = function() updateHelpPage(4) end,
        options = {"page3", "main", "page5"},
        draw = drawHelp,
        nextKeyCode = 205,
        prevKeyCode = 203
    },
    ["page5"] = {
        setup = function() updateHelpPage(5) end,
        options = {"page4", "main", "page6"},
        draw = drawHelp,
        nextKeyCode = 205,
        prevKeyCode = 203
    },
    ["page6"] = {
        setup = function() updateHelpPage(6) end,
        options = {"page5", "main", "page7"},
        draw = drawHelp,
        nextKeyCode = 205,
        prevKeyCode = 203
    },
    ["page7"] = {
        setup = function() updateHelpPage(7) end,
        options = {"page6", "main", "page8"},
        draw = drawHelp,
        nextKeyCode = 205,
        prevKeyCode = 203
    },
    ["page8"] = {
        setup = function() updateHelpPage(8) end,
        options = {"page7", "main", "page9"},
        draw = drawHelp,
        nextKeyCode = 205,
        prevKeyCode = 203
    },
    ["page9"] = {
        setup = function() updateHelpPage(9) end,
        options = {"page8", "main", "page10"},
        draw = drawHelp,
        nextKeyCode = 205,
        prevKeyCode = 203
    },
    ["page10"] = {
        setup = function() updateHelpPage(10) end,
        options = {"page9", "main", "page11"},
        draw = drawHelp,
        nextKeyCode = 205,
        prevKeyCode = 203

    },
    ["page11"] = {
        setup = function() updateHelpPage(11) end,
        options = {"page10", "main", "page12"},
        draw = drawHelp,
        nextKeyCode = 205,
        prevKeyCode = 203

    },
    ["page12"] = {
        setup = function() updateHelpPage(12) end,
        options = {"page11", "main", "page13"},
        draw = drawHelp,
        nextKeyCode = 205,
        prevKeyCode = 203

    },
    ["page13"] = {
        setup = function() updateHelpPage(13) end,
        options = {"page12", "main"},
        draw = drawHelp,
        nextKeyCode = 205,
        prevKeyCode = 203

    },
    ["quit"] = {
        draw = function() print("Do nothing") end,
        setup = function ()
            if side then rednet.close(side) end
            playing = false
            term.clear()
            term.setCursorPos(1,1)
        end
    }
}

helpText = {
    [1] = {                                                   --E"
        "Moving on the board:",
        "",
        "Chess is taken in turns between black and white, with",
        "white always starting first. To move your piece, enter",
        "the desired space with the following notation:",
        "",
        "   <file><rank>-<file><rank>"
    }, [2] = {
        "Example 1:",
        "The following move :",
        "",
        "                           4 |   *   ",
        "                           3 | *   * ",
        "                           2 | p p p ",
        "                           1 | Q K B ",
        "                              -------",
        "            > e2-e4        ... d e f "
    }, [3] = {
        "Example 1:",
        "Will move white's pawn forward 2 squares.",
        "",
        " 1. e2 - e4                4 |   p   ",
        "                           3 | *   * ",
        "                           2 | p * p ",
        "                           1 | Q K B ",
        "                              -------",
        "            > e2-e4        ... d e f "
    }, [4] = {
        "Moving on the board (CONT):",
        "",
        "Unlike standard chess notation, you do not need",
        "to specify the piece that is being moved.",
        "Taking pieces works in the same way as moving,",
        "with a few exceptions."
    }, [5] = {
        "En Passant:",
        "",
        "In taking a pawn en passant, the game assumes the",
        "pawn has only moved one square- hence the player",
        "should move his pawn as though it is on the",
        "diagonal square rather than the horizontal."
    }, [6] = {
        "Example 2:",
        "The following move (c5 is a white pawn):",
        "",
        " ...                       7 | p * K * p ",
        " 11. c4 - c5               6 | *   *   * ",
        " 12. d7 - d5               5 | p p   *   ",
        "                           4 | *   *   Q ",
        "                              -----------",
        "            > c5-d6        ... c d e f g "
    }, [7] = {
        "Example 2:",
        "Will capture d5 en passant and check e7.",
        "",
        " ...                       7 | p   K * p ",
        " 11. c4 - c5               6 | * p *   * ",
        " 12. d7 - d5               5 |   *   *   ",
        " 13. c5 x d6 e.p.+         4 | *   *   Q ",
        "                              -----------",
        "            > c5-d6        ... c d e f g "
    }, [8] = {
        "Castling:",
        "",
        "To castle your king, simply move him to the left",
        "two spaces (to castle queenside), or two spaces",
        "right (to castle kingside). This will move your",
        "castle automatically."
    }, [9] = {
        "Example 3:",
        "The following move:",
        "",
        " ...                       4 |   *   *   ",
        " 7. Bc1 - a3               3 | B p N   * ",
        " 8. d5 - d7                2 | p * p p   ",
        "                           1 | C   *   K ",
        "                              -----------",
        "            > e1-c1        ... a b c d e "
    }, [10] = {
        "Example 3:",
        "Will castle white queenside.",
        "",
        " ...                       4 |   *   *   ",
        " 7. Bc1 - a3               3 | B p N   * ",
        " 8. d5 - d7                2 | p * p p   ",
        " 9. O-O-O                  1 | * K C   * ",
        "                              -----------",
        "            > e1-c1        ... a b c d e "
    }, [11] = {
        "Other commands:",
        "",
        "exit: will leave the current game",
        "reset: starts a fresh game (local only)",
        "draw: offer your opponent a draw (network only)"
    }, [12] = {
        "Monitor Display:",
        "",
        "For network play, hook a computer up to a 6x6",
        "monitor and run monitorchess.lua. You can add",
        "the monitor just before starting, for a bigscreen",
        "display!"
    }, [13] = {
        "Acknowledgements:",
        "",
        "Written by Nitrogen Fingers",
        "Art: Moeser(1995), Alefith (1995) and NN(1998)",
        "Rednet Support: Wolvan"
    }
}
--The board, for tutorials
--[[
        "",
        "                           7 |   *   *   ",
        "                           6 | *   *   * ",
        "                           5 |   *   *   ",
        "                           4 | *   *   * ",
        "                              -----------",
        "            > e2-e4        ... c d e f g "
]]--

--The currently active interface
currentInterface = interfaces["main"]

--The core GUI logic- this runs the main menu and has a default method for passing
--through the interface. It also runs setup and draw methods of each interface.
function runMenu()
    --currentInterface = interfaces["main"]
    while playing do
        currentInterface.draw()
        if currentInterface.input then currentInterface.input()
        else
            local id,key = os.pullEvent("key")
            if key == currentInterface.prevKeyCode and menuSel > 1 then
                menuSel = menuSel - 1
            elseif key == currentInterface.nextKeyCode and
              menuSel < #currentInterface.options then
                menuSel = menuSel + 1
            elseif key == 28 then
                local setupname = currentInterface.options[menuSel]
                currentInterface = interfaces[currentInterface.options[menuSel]]
                menuSel = 1
                if currentInterface.setup then
                    currentInterface.setup()
                end
            end
        end
    end
end

gameOver = true
runMenu()

--gameOver = false
--playGame()