[CC] stratego

-- Stratego version B2.1 by KnightMiner
-- check if we are hosting or joining a game
local args = { ... }
if #args > 3 or #args < 2 or ( args[1] ~= 'host' and args[1] ~= 'join' ) then
  print( 'Usages:' )
  print( 'stratego host [save-game] <name>' )
  print( 'stratego join <name>' )
  return
end

-- find a modem to host/join a game on
local openedModem, foundModem
for _, modem in ipairs( peripheral.getNames() ) do
  if peripheral.getType( modem ) == "modem" then
    if not rednet.isOpen( modem ) then
      rednet.open( modem )
      openedModem = modem
    end
    foundModem = true
    break
  end
end
if not foundModem then
  print( "No modems found" )
  return
end

-- function for shutdown, including closing the modem and clearing the screen
-- it also prints an optional message before the "Thanks" message
function shutdown( msg )
  shell.run( 'clear' )
  if openedModem then
    rednet.close( openedModem )
  end
  if msg then
    print( msg )
  end
  print( 'Thank you for playing Stratego by KnightMiner' )
end

-- load the config from the file "stratego.cfg"
-- note that the file needs to be in the current directory to load,
-- getting it to load from the same directory as the game proves quite hard
local config, configMsg
local cfgFile = shell.resolve( 'stratego.cfg' )
if fs.exists( cfgFile ) then
  local file = fs.open( cfgFile, 'r' )
  config = textutils.unserialize( file.readAll() )
  file.close()
  if not config then
    -- we write the message as a variable as the writeLog function requires the config to load,
    -- and any print will be overwritten in the next step
    configMsg = 'Failed to load config'
  else
    configMsg = 'Successfully loaded config'
  end
end
-- if the config table is invalid or we didn't load one, replace it with a blank table
config = config or {}

-- define display stuff based on computer type
shell.run( 'clear' )
local display
-- pocket computers, which define an empty "pocket" table
if pocket then
  display = {
    write = {
      '+----------+-------------+',
      '|          |             |',
      '|          |   Stratego  |',
      '|          |             |',
      '|          |             |',
      '|          +-------------+',
      '|          |             |',
      '|          |             |',
      '|          |             |',
      '+----------+-------------+',
      '|                        |',
      '|                        |',
      '|                        |',
      '|                        |',
      '|                        |',
      '|                        |',
      '|                        |',
      '|                        |',
      '|                        |',
      '|                        |'
    },
    input = { 13, 7, 13 },
    log   = { 2, 11, 24, 11 },
    board = { 2, 2 }
  }
-- turtle computers, with the "turtle" api
elseif turtle then
  display = {
    write = {
      '+----------+----------+---------------+',
      '|          |          |               |',
      '|          | Stratego |               |',
      '|          |          |               |',
      '|          +----------+---------------+',
      '|          |                          |',
      '|          |                          |',
      '|          |                          |',
      '|          |                          |',
      '+----------+                          |',
      '+----------+                          |',
      '+----------+                          |',
      '+----------+                          |'
    },
    input = { 24, 2, 15 },
    log   = { 13, 6, 26, 9 },
    board = { 2, 2 }
  }
-- standard computers
else
  display = {
    write = {
      '+--------------------+----------+-----------------+',
      '|                    |          |                 |',
      '|                    | Stratego |                 |',
      '|                    |          |                 |',
      '|                    +----------+-----------------+',
      '|                    |                            |',
      '|                    |                            |',
      '|                    |                            |',
      '|                    |                            |',
      '|                    |                            |',
      '|                    |                            |',
      '|                    |                            |',
      '|                    |                            |',
      '|                    |                            |',
      '|                    |                            |',
      '|                    |                            |',
      '|                    |                            |',
      '+--------------------+                            |',
      '+--------------------+                            |'
    },
    input = { 34, 2, 17 },
    log   = { 23, 6, 28, 15 },
    board = { 2, 2, large = true }
  }
end
-- if there is config display stuff to load, overwrite any values with ones from the config
if config.display then
  for k in pairs( config.display ) do
    display[k] = config.display[k]
  end
end

-- fixes for multishell
if multishell and multishell.getCount() > 1 then
  table.remove( display.write )
  display.log[4] = display.log[4] - 1
end

-- draw the game board's borders
write( table.concat( display.write, '\n' ) )

-- create the output log as a window
local logBox = window.create( term.current(), display.log[1], display.log[2], display.log[3], display.log[4] )
function writeLog( ... )
  local prev = term.redirect( logBox )
  print( ... )
  term.redirect( prev )
end

-- write the config message from eariler
-- helps with debug in case you are wondering why your config is not working
if configMsg then
  writeLog( configMsg )
end
-- create the input box as a window
local inputBox = window.create( term.current(), display.input[1], display.input[2], display.input[3], 3 )

-- function to clear the input box
function inputClear( n )
  inputBox.setCursorPos( 1, 1 + ( n or 0 ) )
  inputBox.clearLine()
end

-- function to get user input
function input( msg )
  inputBox.setCursorPos( 1, 2 )
  inputBox.clearLine()
  if msg then
    inputBox.write( msg )
  end
  return read()
end

-- function to write to the input box
function inputWrite( msg, n )
  inputClear( n )
  inputBox.setCursorPos( 1, 1 + ( n or 0 ) )
  inputBox.clearLine()
  inputBox.write( msg )
end

-- define the pieces table, pieces will be added later
local pieces = {
  [1] = {},
  [2] = {},
  [3] = {},
  [4] = {},
  [5] = {},
  [6] = {},
  [7] = {},
  [8] = {}
}

-- check if a click is valid
-- used within the main click function, which is defined based on whether a mouse exists
local myTeam, notMyTeam, options, rows
function validClick( x, y, mode, px, py )
  -- location is out of bounds
  if x > 10 or x < 1 or y > 8 or y < 1 then
    writeLog( 'Invalid location' )
    return false
  -- location is beyond the legal columns to set up pieces
  -- note that "rows" and "options" are both defined later, but the click function is needed before they are defined
  elseif mode == 'setup' and options.rotate and ( myTeam == 'red' and ( x > rows ) or myTeam == 'blue' and ( x < ( 11 - rows ))) then
    writeLog( 'Cannot place pieces beyond first ' .. rows .. ' columns' )
    return false
  -- location is beyond the legal rows to set up pieces
  elseif mode == 'setup' and not options.rotate and ( myTeam == 'red' and ( y < ( 9 - rows ) ) or myTeam == 'blue' and ( y > rows )) then
    writeLog( 'Cannot place pieces beyond first ' .. rows .. ' rows' )
    return false
  -- check here if we are deselecting the piece, as otherwise it fails later as being the same team
  elseif mode == 'attack' and x == px and y == py then
    return 'cancel'
  else
    -- check reasons we are not allowed to move
    local piece = pieces[y][x]
    -- if no piece exists, then
    if not piece then
      -- if we are setting up or attacking, that is fine
      if mode then
        return true
      else
        -- otherwise we are moving, where we must start at a piece
        writeLog( 'No piece here' )
        return false
      end
    -- if the piece is a lake
    elseif piece[1] == 'lake' then
      if mode == 'setup' then
        writeLog( 'Cannot place pieces on lakes' )
      elseif mode == 'attack' then
        writeLog( 'Cannot move onto lakes' )
      else
        writeLog( 'Cannot move lakes' )
      end
      return false
    -- if the mode is not "attack" and the piece is not my team
    elseif mode ~= 'attack' and piece[1] == notMyTeam then
      writeLog( 'Cannot move other team' )
      return false
    -- if
    elseif mode == 'attack' and piece[1] == myTeam then
      writeLog( 'Cannot move on to own team' )
      return false
    -- if the piece cannot move, either flags or bombs
    elseif not mode and ( piece[2] == 'F' or piece[2] == '*' ) then
      writeLog( 'Immovable piece' )
      return false
    -- if all cases pass as false, return movable
    else
      return true
    end
  end
end

-- determine if we are using an advance system or a regular one
-- then define the colors and the click() function based on that
local names = {
  ['*'] = 'bomb',
  ['!'] = 10,
  S = 'spy',
  F = 'flag',
  [1] = 'spotter'
}
local color = {}
local size = term.getSize()
local click, button
local isColor = term.isColor()
if isColor then
  names.red  = 'red'
  names.blue = 'blue'
  color = {
    red        = colors.red,
    redSelect  = colors.orange,
    blue       = colors.blue,
    blueSelect = colors.purple,
    textSelect = colors.white,
    lake       = colors.lightBlue,
    lakeBg     = colors.blue,
    pos        = colors.lime,
    neg        = colors.green
  }
  term.setCursorPos( size, 1 )
  term.blit( '+', '0', 'e' )
  function click( mode, px, py )
    while true do
      inputWrite( 'Click pos', 1 )
      local _, _, x, y = os.pullEvent( 'mouse_click' )
      if mode == 'setup' and x == size and y == 1 then
        return 'done'
      elseif not mode and x == size and y == 1 then
        return button()
      elseif display.board.large then
        x = math.floor( x / 2 )
        y = math.floor( y / 2 )
      else
        x = x - 1
        y = y - 1
      end
      local valid = validClick( x, y, mode, px, py )
      if valid == 'cancel' then
        return 'cancel'
      elseif valid then
        return x, y
      end
    end
  end
else
  names.red  = 'white'
  names.blue = 'black'
  color = {
    red        = colors.white,
    redSelect  = colors.white,
    blue       = colors.black,
    blueSelect = colors.black,
    textSelect = colors.gray,
    lake       = colors.lightGray,
    lakeBg     = colors.black,
    pos        = colors.lightGray,
    neg        = colors.gray
  }
  function click( mode, px, py )
    while true do
      local x, y
      while true do
        local data = input( 'Pos: ' )
        if mode == 'setup' and data == 'done' then
          return 'done'
        elseif not mode and ( data == 'menu' or data == 'button' ) then
          return button()
        end
        x, y = data:match( '(%d+),%s*(%d+)' )
        if x and y then
          break
        else
          writeLog( 'Invalid location' )
        end
      end
      x = tonumber( x )
      y = tonumber( y )
      local valid = validClick( x, y, mode, px, py )
      if valid == 'cancel' then
        return 'cancel'
      elseif valid then
        return x, y
      end
    end
  end
end

-- override defaults with any configured names
if config.names then
  for k in pairs( config.names ) do
    names[k] = config.names[k]
  end
end

-- and colors
if config.color then
  for k in pairs( config.color ) do
    color[k] = colors[config.color[k]]
  end
end

-- table which converts colors.n into a hexidecimal value to be used by term.blit
local hexColor = {}
for n=1,16 do
    hexColor[2^(n-1)] = string.sub( "0123456789abcdef", n, n )
end

-- data to draw the board
local boardData
if display.board.large then
  local pos = string.rep( hexColor[color.pos], 2 )
  local neg = string.rep( hexColor[color.neg], 2 )
  boardData = {
    row  = '                    ',
    pos = string.rep( pos .. neg, 5 ),
    neg = string.rep( neg .. pos, 5 ),
    size = { 20, 16 }
  }
else
  local pos = hexColor[color.pos]
  local neg = hexColor[color.neg]
  boardData = {
    row = '          ',
    pos = string.rep( pos .. neg, 5 ),
    neg = string.rep( neg .. pos, 5 ),
    size = { 10, 8 }
  }
end

-- draw the board using the data from above
-- note that "row" is an string of just spaces
local board = window.create( term.current(), display.board[1], display.board[2], boardData.size[1], boardData.size[2] )
board.setCursorPos( 1, 1 )
if display.board.large then
  board.blit( boardData.row, boardData.pos, boardData.pos ) board.setCursorPos( 1, 2 )
  board.blit( boardData.row, boardData.pos, boardData.pos ) board.setCursorPos( 1, 3 )
  board.blit( boardData.row, boardData.neg, boardData.neg ) board.setCursorPos( 1, 4 )
  board.blit( boardData.row, boardData.neg, boardData.neg ) board.setCursorPos( 1, 5 )
  board.blit( boardData.row, boardData.pos, boardData.pos ) board.setCursorPos( 1, 6 )
  board.blit( boardData.row, boardData.pos, boardData.pos ) board.setCursorPos( 1, 7 )
  board.blit( boardData.row, boardData.neg, boardData.neg ) board.setCursorPos( 1, 8 )
  board.blit( boardData.row, boardData.neg, boardData.neg ) board.setCursorPos( 1, 9 )
  board.blit( boardData.row, boardData.pos, boardData.pos ) board.setCursorPos( 1, 10 )
  board.blit( boardData.row, boardData.pos, boardData.pos ) board.setCursorPos( 1, 11 )
  board.blit( boardData.row, boardData.neg, boardData.neg ) board.setCursorPos( 1, 12 )
  board.blit( boardData.row, boardData.neg, boardData.neg ) board.setCursorPos( 1, 13 )
  board.blit( boardData.row, boardData.pos, boardData.pos ) board.setCursorPos( 1, 14 )
  board.blit( boardData.row, boardData.pos, boardData.pos ) board.setCursorPos( 1, 15 )
  board.blit( boardData.row, boardData.neg, boardData.neg ) board.setCursorPos( 1, 16 )
  board.blit( boardData.row, boardData.neg, boardData.neg )
else
  board.blit( boardData.row, boardData.pos, boardData.pos ) board.setCursorPos( 1, 2 )
  board.blit( boardData.row, boardData.neg, boardData.neg ) board.setCursorPos( 1, 3 )
  board.blit( boardData.row, boardData.pos, boardData.pos ) board.setCursorPos( 1, 4 )
  board.blit( boardData.row, boardData.neg, boardData.neg ) board.setCursorPos( 1, 5 )
  board.blit( boardData.row, boardData.pos, boardData.pos ) board.setCursorPos( 1, 6 )
  board.blit( boardData.row, boardData.neg, boardData.neg ) board.setCursorPos( 1, 7 )
  board.blit( boardData.row, boardData.pos, boardData.pos ) board.setCursorPos( 1, 8 )
  board.blit( boardData.row, boardData.neg, boardData.neg )
end

-- The file is the second parameter, but only use it if the third is also set
-- as otherwise the second parameter is the host name
local fileName = ( args[3] and args[2] or config.file )
-- and apply the optional file extension from the config (don't apply it if the filename is nil)
fileName = fileName and fileName .. ( config.ext or '' )
local file = {}
-- if the file is set does not exist, skip it
if fileName and not fs.exists( fileName ) then
  writeLog( 'Save file does not exist' )
  fileName = nil
-- otherwise load the file
elseif fileName then
  local f = fs.open( fileName, 'r' )
  local data = textutils.unserialize( f.readAll() )
  f.close()
  -- validate the date
  if type( data ) == 'table' then
    writeLog( 'Loaded save file ' .. fileName )
    file = data
  else
    writeLog( 'Invalid save file' )
    fileName = nil
  end
end

local friend, host
local name = args[3] or args[2]
-- if we are the host, load options from the file and host the game on rednet
if args[1] == 'host' then
  host = true
  options = file.options or {}
  writeLog( 'Hosting game with name "' .. name .. '"' )
  rednet.host( 'stratego', name )
  writeLog( 'Waiting for a friend. ' .. ( isColor and 'Click the + to cancel' or 'Press "end" to cancel' ) )
  while true do
    -- wait for either a message from the guest, or a prompt from the user to cancel
    local event, data, x, y = os.pullEvent()
    -- a message means start the game, so send the options to the other player
    if event == 'rednet_message' and y == 'stratego' then
      writeLog( 'Friend found, sending options' )
      -- store the ID for later
      friend = data
      rednet.send( friend, options, 'stratego-options' )
      writeLog( 'Starting game' )
      break
    -- user's prompt (click on advance systems and "end" on normal ones) means cancel
    elseif isColor and ( event == 'mouse_click' and x == size and y == 1 ) or ( event == 'key' and data == keys['end'] ) then
      shutdown( 'Canceled game' )
      return
    end
  end
  -- the host is always red, and it helps to have these for later
  myTeam = 'red'
  notMyTeam = 'blue'
else
  -- if we are the guest, loop up the host
  writeLog( 'Looking up host ' .. name )
  local ID = rednet.lookup( 'stratego', name )
  if ID then
    -- once we find them, send a blank message so they get our ID
    writeLog( 'Found host with an ID of ' .. ID )
    -- store the ID of the host for later
    friend = ID
    rednet.send( friend, '', 'stratego' )
    writeLog( 'Waiting for options' )
    while true do
      -- then wait for the options
      local ID, data = rednet.receive( 'stratego-options' )
      if ID == friend then
        options = data
        break
      end
    end
    writeLog( 'Starting game' )
  else
    -- if it times out, shutdown the game
    shutdown( 'Host name ' .. name .. ' not found on network' )
    return
  end
  -- the guest is always blue, and it helps to have these for later
  myTeam = 'blue'
  notMyTeam = 'red'
end

-- define the rows for the setup click
rows = math.min( options.rows or 3, ( options.rotate and 5 or 4 ) )

-- how to draw large pieces
local largePieces = {
  ['*'] = { '\\ ', '**' }, -- bomb
  ['!'] = { '^^',  '10' }, -- 10
    S   = { '^^',  'S ' }, -- spy
    F   = { '|>',  '| ' }, -- flag

  ['?'] = { '??',  '??' }, -- unknown opponent

  [' '] = { '  ',  '  ' }, -- empty space
  ['~'] = { '~~',  '~~' }  -- lake
}

-- function to draw a piece
function writePiece( x, y, team, piece, sel )
  -- if a piece is given, then add it to the board
  if piece then
    pieces[y][x] = { team, piece }
    -- set the text to the team color, or the selection color if we are selecting
    board.setTextColor( sel and color.textSelect or color[team] )
    -- but don't show us the piece if it's an opponent
    if team == notMyTeam then
      piece = '?'
    end
  -- otherwise clear the space
  else
    pieces[y][x] = nil
    piece = ' '
  end
  -- if the piece is a lake (used on startup), set the background as the lake color
  if team == 'lake' then
    board.setBackgroundColor( color.lakeBg )
  -- if we are selecting it, set the background color as the team color
  elseif sel then
    board.setBackgroundColor( color[team .. 'Select'] )
  -- otherwise apply the "pos" and "neg" colors in a checkerboard
  elseif ( x + y ) % 2 == 0 then
    board.setBackgroundColor( color.pos )
  else
    board.setBackgroundColor( color.neg )
  end
  -- if we are using a large board, use double sized pieces
  if display.board.large then
    local draw = largePieces[piece] or { '^^', ' ' .. piece }
    -- and double the draw coordinates
    x = ( x * 2 ) - 1
    y = ( y * 2 ) - 1
    board.setCursorPos( x, y )
    board.write( draw[1] )
    board.setCursorPos( x, y + 1 )
    board.write( draw[2] )
  else
    -- otherwise just write as is
    board.setCursorPos( x, y )
    board.write( piece )
  end
  -- for some reason the text color gets used by term later...
  term.setTextColor( colors.white )
end

-- where to place lakes, in pairs
local lakes = options.lakes or {
  x = { 3, 4, 7, 8, 3, 4, 7, 8 },
  y = { 4, 4, 4, 4, 5, 5, 5, 5 }
}
-- place the lakes
for i, x in pairs( lakes.x ) do
  writePiece( x, lakes.y[i], 'lake', '~' )
end

-- function to save a game
local turn = options.blueFirst and 'blue' or 'red'
function save()
  -- we are running a loop inside a loop, so use a variable to break this one
  local finished
  while not finished do
    -- prompt for the file name to save at
    inputWrite( 'Filename' )
    local data = input() .. config.ext or ''
    -- we are finished unless tole otherwise later
    finished = true
    -- if it exists, prompt to overwrite
    if fs.exists( data ) then
      inputWrite( 'Overwrite?' )
      while true do
        local data = input( '(Y/N): ' ):upper()
        -- if we choose to overwrite, we are done
        if data == 'Y' then
          break
        -- otherwise restart
        elseif data == 'N' then
          finished = false
          break
        end
      end
    end
    -- only run this stuff if we choose to overwrite or no conflict existed
    if finished then
      local f = fs.open( data, 'w' )
      f.write( textutils.serialize( { options = { rotate = options.rotate }, turn = turn, pieces = pieces } ) )
      f.close()
    end
  end
end

-- function for when the button is pressed
function button()
  while true do
    -- prompt for options
    local data = input( 'Menu: ' ):lower()
    -- "save" means we save the game, then go right back into it
    if host and ( data == 'save' or data == 's' ) then
      save()
      return click()
    -- "quit" will prompt for saving if you are the host, then will end the game
    elseif data == 'quit' or data == 'q' then
      if host then
        while true do
          local data = input( 'Save? ' ):lower()
          if data == 'yes' or data == 'y' then
            save()
            return 'save'
          elseif data == 'no' or 'n' then
            break
          end
        end
      end
      return 'quit'
    -- "forfeit" will cause you to be the loser, needed if you run out of moves
    elseif data == 'forfeit' or data == 'f' then
      return 'forfeit'
    -- a blank call means close the menu
    elseif data:gsub( ' ', '' ) == '' then
      return click()
    end
  end
end

-- some pieces are not numerical, so give them numerical ranks
-- note the flag has no battle value, as it just overrides things later
local battleValues = {
  ['*'] = 11,
  ['!'] = 10,
  S = 0
}

local done, winner, canSpot
-- function for when two pieces battle
function battle( attacker, defender )
  local team1 = attacker[1]
  local team2 = defender[1]
  local attacker = attacker[2]
  local defender = defender[2]
  -- if the flag was captured, set victory to our team
  if defender == 'F' then
    writeLog( 'The ' .. names[team2] .. ' flag has been captured' )
    done = true
    winner = team1
    return 'victory'
  -- miners defuse bombs
  elseif attacker == 3 and defender == '*' then
    writeLog( 'The ' .. names[team1] .. ' 3 has defused the ' .. names[team2] .. ' bomb' )
    return true
  -- the spy can kill the 10, but only as the attacker
  elseif attacker == 'S' and defender == '!' then
    writeLog( 'The ' .. names[team1] .. ' spy has killed the ' .. names[team2] .. ' 10' )
    return true
  else
    local attackerName = names[attacker] or attacker
    local defenderName = names[defender] or defender
    local attacker = battleValues[attacker] or attacker
    local defender = battleValues[defender] or defender
    if attacker == defender then
      writeLog( 'The ' .. names[team1] .. ' ' .. attackerName .. ' has met his match, both pieces were killed' )
      return 'tie'
    elseif attacker > defender then
      writeLog( 'The ' .. names[team1] .. ' ' .. attackerName .. ' killed the ' .. names[team2] .. ' ' .. defenderName )
      return true
    elseif attacker < defender then
      writeLog( 'The ' .. names[team1] .. ' ' .. attackerName .. ' was killed by the ' .. names[team2] .. ' ' .. defenderName )
      return false
    end
  end
end

-- a list of all valid piece calls. Used for the spotter and game setup
local validPiece = {
  S     = 'S', SPY  = 'S',
  F     = 'F', FLAG = 'F',
  ['*'] = '*', BOMB = '*', B = '*',
  ['!'] = '!', [10] = '!',
  [9] = 9,
  [8] = 8,
  [7] = 7,
  [6] = 6,
  [5] = 5,
  [4] = 4,
  [3] = 3,
  [2] = 2,
  [1] = 1, SPOTTER = 1
}
-- function for an attack with the spotter
function spotter( x, y, override )
  local team = pieces[y][x][1]
  local rotate = options.rotate
  local y2 = rotate and y or ( y + ( team == 'red' and -1 or 1 ) )
  local x2 = rotate and ( x + ( team == 'red' and 1 or -1 ) ) or x
  local defender = pieces[y2][x2]
  if not defender or defender[1] ~= ( team == 'red' and 'blue' or 'red' ) then
    return false
  end
  writeLog( 'The ' .. names[team] .. ' spotter is attempting to snipe the piece at ' .. x2 .. ',' .. y2 )
  while true do
    local call
    if override then
      call = override
    else
      inputWrite( 'Spotter' )
      call = input( 'Call: ' )
      if call:gsub( ' ', '' ) == '' then
        return false
      elseif tonumber( call ) then
        call = tonumber( call )
      else
        call = call:upper()
      end
      call = validPiece[call]
    end
    if call then
      local notteam = ( team == 'red' and 'blue' or 'red' )
      if defender[2] == call then
        writeLog( 'The ' .. names[team] .. ' spotter has sniped the ' .. names[notteam] .. ' ' .. ( names[defender[2]] or defender[2] ) )
        if defender[2] == 'F' then
          done = true
          winner = team
        end
        writePiece( x2, y2 )
      else
        writeLog( 'The ' .. names[team] .. ' spotter failed to snipe the ' .. names[notteam] .. ' ' .. ( names[defender[2]] or defender[2] ) )
      end
      return call
    else
      writeLog( 'Invalid call, recall' )
    end
  end
end

-- function to move a piece
function move( x1, y1, x2, y2 )
  local piece = pieces[y1][x1]
  -- scout movement
  if not piece then
    writeLog( 'No piece' )
  elseif piece[2] == 2 then
    -- check that the scout only moved in one direction
    if not (( x1 == x2 ) or ( y1 == y2 )) then
      writeLog( 'Invalid move' )
      return false
    else
      -- and that no pieces or lakes are in the way
      -- we use the temporary variables "c1" and "c2" to make it easier to loop through x or y
      local c1, c2, s
      if x1 == x2 then
        c1 = math.min( y1, y2 )
        c2 = math.max( y1, y2 )
      else
        c1 = math.min( x1, x2 )
        c2 = math.max( x1, x2 )
      end
      for c = c1, c2 do
        local piece
        -- ignore the start and end points
        if c == c1 or c == c2 then
          piece = false
        -- and check again of if we are using x or y, as the c variables don't keep track of which one
        elseif x1 == x2 then
          piece = pieces[c][x1]
        else
          piece = pieces[y1][c]
        end
        if piece then
          writeLog( 'Invalid move' )
          return false
        end
      end
    end
  -- for everyone else, check that we only moved one space
  elseif math.abs( x2 - x1 ) + math.abs( y2 - y1 ) ~= 1 then
    writeLog( 'Invalid move' )
    return false
  end
  -- state the action, but make sure not to state the piece rank
  writeLog( names[piece[1]]:gsub( '^%l', string.upper ) .. ' moved from ' .. x1 .. ',' .. y1 .. ' to ' .. x2 .. ',' .. y2 )
  local destination = pieces[y2][x2]
  local result
  -- if someone already exists at the target, then battle
  if destination then
    result = battle( piece, destination )
  end
  -- if the battle was a tie, kill the target space's piece
  if result == 'tie' then
    writePiece( x2, y2 )
  -- otherwise if we won or there was no battle, place the current piece at the target
  elseif result or not destination then
    writePiece( x2, y2, piece[1], piece[2] )
  end
  -- clear the current space anyways and return success
  writePiece( x1, y1 )
  return result or true
end

local maxPieces = options.maxPieces or {
  S = 1, F = 1, ['!'] = 1, [9] = 1, [8] = 1, [7] = 1,
  [6] = 2, [5] = 2, [4] = 2, [1] = 2,
  [3] = 5, [2] = 5,
  ['*'] = 6
}
-- set maximums for pieces and flags
local maxRequiredPieces = rows * ( options.rotate and 8 or 10 )
local requiredPieces = math.min( options.requiredPieces or maxRequiredPieces, maxRequiredPieces )
local requiredFlags = math.min( options.requiredFlags or 1, 10 )

-- called with a file to load the file or run by both side to load piece setup
function setup()
  writeLog( 'Place pieces in the first ' .. rows .. ( options.rotate and ' columns. ' or ' rows. ' ) .. ( isColor and 'Press the + when finished' or 'Type "done" when finished' ) )
  -- tell the user how many flags are required, normally is just 1
  local flagText
  if requiredFlags > 0 then
    flagText = requiredFlags .. ( requiredFlags == 1 and ' flag is required' or ' flags are required' )
    writeLog( flagText )
  end
  -- keep track of pieces for the sake of the "done" button and not placing too many
  local usedPieces = {}
  local placedPieces = 0
  inputWrite( 'Place pieces' )
  while true do
    -- wait for a space to be clicked
    local x,y = click( 'setup' )
    -- if the user clicked the done button, check if they placed enough pieces and flags
    if x == 'done' then
      if placedPieces == requiredPieces then
        if ( usedPieces.F or 0 ) < requiredFlags then
          while true do
            -- if they are not equal, loop until the user does something other than press the done button
            writeLog( flagText )
            x,y = click( 'setup' )
            if x ~= 'done' then
              break
            end
          end
        else
          inputClear()
          inputClear(1)
          inputClear(2)
          break
        end
      else
        while true do
          -- if there is not enough, loop until the user does something other than press the done button
          writeLog( 'Not enough pieces placed' )
          x,y = click( 'setup' )
          if x ~= 'done' then
            break
          end
        end
      end
    end
    -- show selected space
    inputWrite( x .. ',' .. y, 2 )
    -- if a piece is already there, remove it from the count (we will remove it from the board with the selection later
    if pieces[y][x] then
      local piece = pieces[y][x][2]
      usedPieces[piece] = usedPieces[piece] - 1
      placedPieces = placedPieces - 1
    end
    -- don't allow a piece to be placed if we are out of pieces
    if placedPieces == requiredPieces then
      writeLog( 'Out of pieces' )
    else
      -- select the space
      writePiece( x, y, myTeam, nil, true )
      -- tell the user how many pieces remain
      -- TODO: make it display properly on smaller screens
      writeLog( 'Available: (place ' .. requiredPieces - placedPieces .. ' more)' )
      for k, v in pairs( maxPieces ) do
        local remaining = v - ( usedPieces[k] or 0 )
        if remaining ~= 0 then
          writeLog( '* ' .. ( names[k] or k ) .. ': ' .. remaining )
        end
      end
      while true do
        -- if we passed all other steps, ask the user what piece to place
        local data = input( 'Piece: ' )
        -- turn strings into numbers or uppercase (as that is how it's stored
        if tonumber( data ) then
          data = tonumber( data )
        else
          data = data:upper()
        end
        -- if the piece is valid
        local piece = validPiece[data]
        if piece then
          -- if we are out of the piece, ask the user to type the name again
          if usedPieces[piece] == maxPieces[piece] then
            writeLog( 'Out of ' .. ( names[piece] or piece ) .. "s" )
          else
            -- otherwise place the piece and increase the counters for that piece and total pieces
            writePiece( x, y, myTeam, piece )
            usedPieces[piece] = ( usedPieces[piece] or 0 ) + 1
            placedPieces = placedPieces + 1
            break
          end
        -- if the input is blank or only contains spaces, then just remove the selection
        elseif data:gsub( ' ', '' ) == '' then
          writePiece( x, y )
          break
        else
          writeLog( 'Invalid piece' )
        end
      end
      inputClear(2)
    end
  end
  -- once done, host the name under "stratego-done" so the other user sees it upon finishing
  writeLog( 'Waiting for other player' )
  rednet.host( 'stratego-done', name .. ( host and 1 or 0 ) )
  while true do
    local found = rednet.lookup( 'stratego-done', name .. ( host and 0 or 1 ) )
    if found == friend then
      -- once we find the other user is done, start sending pieces back and fourth
      if not host then
        -- the guest sends its pieces to the host
        writeLog( 'Sending pieces to host' )
        os.sleep( 2 ) -- delay to compensate for rednet.lookup
        rednet.send( friend, pieces, 'stratego-pieces-guest' )
        writeLog( 'Waiting for combined pieces' )
        -- then waits to get the host's combination
        while true do
          local ID, data = rednet.receive( 'stratego-pieces-host' )
          if ID == friend then
            writeLog( 'Received pieces from host' )
            pieces = data
            break
          end
        end
      else
        -- the host waits to receive the guest's pieces
        writeLog( 'Waiting for pieces from guest' )
        while true do
          local ID, data = rednet.receive( 'stratego-pieces-guest' )
          if ID == friend then
            writeLog( 'Received pieces from guest' )
            -- then combines the two and sends them back to the guest
            -- if for some reason a value exists in both the guest and host, the host's piece is kept
            -- though this should never happen except for lakes (which are in the same spots on both sides already)
            for x = 1, 10 do
              for y = 1, 8 do
                pieces[y][x] = pieces[y][x] or data[y][x]
              end
            end
            writeLog( 'Sending combined pieces to guest' )
            rednet.send( friend, pieces, 'stratego-pieces-host' )
            break
          end
        end
      end
      -- wait to unhost until after we finished everything, as otherwise lag can cause both systems to be stuck waiting
      rednet.unhost( 'stratego-done', name .. ( host and 1 or 0 ) )
      break
    end
  end
  writeLog( 'Setup complete, starting game' )
end

-- startup
if host then
  -- if we loaded a file and it contains pieces, load it instead of running setup
  if file and file.pieces then
    rednet.send( friend, file, 'stratego-setup' )
    pieces = file.pieces
    turn = file.turn or turn
  else
    -- otherwise send a message to the guest indicating we are running setup
    -- a blank string is used, since the guest uses the type of data to determine the action
    rednet.send( friend, '', 'stratego-setup' )
    setup()
  end
else
  -- wait for the host to tell us whether we already have pieces, or still need to load them
  while true do
    local ID, file = rednet.receive( 'stratego-setup' )
    if ID == friend then
      -- if the file is a table, we know it is the pieces
      if type( file ) == 'table' then
        writeLog( 'Loading pieces from host' )
        pieces = file.pieces
        turn = file.turn or turn
      else
        setup()
      end
      break
    end
  end
end

-- after setting up, write all pieces to the board
-- as we either loaded setup pieces from the guest/host, or from a file
for y = 1, 8 do
  for x = 1, 10 do
    local piece = pieces[y][x]
    -- if we don't have a piece, we need to draw a blank space to make sure any improperly added pieces are overwritten
    -- shouldn't happen, but just in case
    if piece then
      writePiece( x, y, pieces[y][x][1], pieces[y][x][2] )
    else
      writePiece( x, y, nil, nil )
    end
  end
end

-- main loop, using the variable "done" to determine completion (as we use multiple loops inside)
while not done do
  -- if its our turn
  if turn == myTeam then
    -- collecting data of the turn
    local act = {}
    inputWrite( 'Move piece' )
    while true do
      while true do
        local x, y = click()
        -- if we choose to quit, then quit the game and end the program
        if x == 'quit' or x == 'save' then
          rednet.send( friend, 'quit', 'stratego-action' )
          if x == 'save' then
            shutdown( 'Game saved and quit' )
          else
            shutdown( 'Quit game' )
          end
          return
        -- if we choose to forfeit, then set the winner to the opponent and break the loop
        elseif x == 'forfeit' then
          act[1] = 'forfeit'
          writeLog( 'You forfeited' )
          winner = notMyTeam
          done = true
          break
        -- if the piece cannot move, don't select it
        elseif  ( y + 1 >  8 or ( pieces[y + 1][x] and pieces[y + 1][x][1] ~= notMyTeam ) )
        and ( y - 1 <  1 or ( pieces[y - 1][x] and pieces[y - 1][x][1] ~= notMyTeam ) )
        and ( x + 1 > 10 or ( pieces[y][x + 1] and pieces[y][x + 1][1] ~= notMyTeam ) )
        and ( x - 1 <  1 or ( pieces[y][x - 1] and pieces[y][x - 1][1] ~= notMyTeam ) ) then
          writeLog( 'Piece cannot move' )
        -- otherwise select it
        else
          -- display selection
          inputWrite( x .. ',' .. y, 2 )
          writePiece( x, y, myTeam, pieces[y][x][2], true )
          -- and set the data for later use
          act[1] = x
          act[2] = y
          break
        end
      end
      -- if we forfeited, our turn is over
      if act[1] == 'forfeit' then
        break
      -- otherwise if we are a spotter, run the spotter function
      elseif pieces[act[2]][act[1]][2] == 1 then
        act[3] = spotter( act[1], act[2] )
      end
      -- if the spotter could spot and spotted, then the turn is done
      if act[3] then
        -- deselect the piece
        writePiece( act[1], act[2], myTeam, 1 )
        break
      -- otherwise proceed with movement
      else
        local canSpot
        while true do
          -- another click, but this time check for deselection
          local x, y = click( 'attack', act[1], act[2] )
          -- if we cancel, deselect the piece and go back to the first loop
          if x == 'cancel' then
            inputClear(2)
            writePiece( act[1], act[2], myTeam, pieces[act[2]][act[1]][2] )
            break
          -- need to check if we can spot before moving, as the target data gets replaced later on
          elseif not pieces[y][x] and pieces[act[2]][act[1]][2] == 1 then
            canSpot = true
          else
            canSpot = false
          end
          -- move the piece
          local success = move( act[1], act[2], x, y )
          -- if the move was successful, set the data, otherwise we retry the click
          if success then
            act[3] = x
            act[4] = y
            break
          end
          -- no need to use the spotter's ability if we just won
          if success == 'victory' then
            canSpot = false
          end
        end
        -- if we can spot and successfully moved, then run the spotter
        if canSpot and act[3] and pieces[act[4]][act[3]] then
          act[5] = spotter( act[3], act[4] )
          break
        -- otherwise just stop if we successfully moved, or restart the whole loop if not
        elseif act[3] then
          break
        end
      end
    end
    -- turn is over, so send the results to the other player and set the turn to them
    rednet.send( friend, act, 'stratego-action' )
    turn = notMyTeam
  else
    --if it's not our turn, wait for information on the opponents turn
    inputWrite( 'Waiting...' )
    inputClear(1)
    inputClear(2)
    while true do
      local ID, act = rednet.receive( 'stratego-action' )
      if ID == friend then
        -- found information
        -- if the opponent choose to quit, then quit as well
        if act == 'quit' then
          -- and prompt to save the game if we are the host
          if host then
            writeLog( 'Game quit by guest' )
            inputWrite( 'Save game?' )
            while true do
              local data = input( '(Y/N): ' ):upper()
              if data == 'Y' then
                save()
                break
              elseif data == 'N' then
                break
              end
            end
            shutdown()
          else
            shutdown( 'Game quit by host' )
          end
          return
        -- if the opponent forfeited, then set the winner to us, tell the player, and exit the main loop
        elseif act[1] == 'forfeit' then
          winner = myTeam
          writeLog( 'Opponent forfeited' )
          done = true
        -- otherwise check if the opponent used a spotter, and if so run the spotter function
        elseif not act[4] and pieces[act[2]][act[1]][2] == 1 then
          spotter( act[1], act[2], act[3] )
        -- otherwise, assume a movement
        else
          -- need to check if we can spot before moving, as the target data gets replaced later on
          -- this is mainly an anti-cheat thing, to prevent a player from both moving and spotting
          local canSpot
          if not pieces[act[4]][act[3]] and pieces[act[2]][act[1]][2] == 1 then
            canSpot = true
          end
          -- move the piece, then if we can spot, run the spotter function
          move( act[1], act[2], act[3], act[4] )
          if canSpot and act[5] then
            spotter( act[3], act[4], act[5] )
          end
        end
        -- since we found something, break out of the loop
        break
      end
    end
    -- and it's our turn next time
    turn = myTeam
  end
end

-- at the end of the game, state the winner then delay a bit for both sides to read it
writeLog( winner:gsub( '^%l', string.upper ) .. ' is the winner' )
os.sleep( 5 )

-- if we are the host and the file is a save game, prompt to delete it
if host and fileName and file.pieces then
  inputWrite( 'Delete game?' )
  while true do
    local data = input( '(Y/N): ' ):upper()
    if data == 'Y' then
      fs.delete( fileName )
      break
    elseif data == 'N' then
      break
    end
  end
end

-- and final shutdown stuff
shutdown()