Battleship game in Kotlin

activity_game.xml

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout
	xmlns:android="http://schemas.android.com/apk/res/android"
	xmlns:app="http://schemas.android.com/apk/res-auto"
	xmlns:tools="http://schemas.android.com/tools"
	android:layout_width="match_parent"
	android:layout_height="match_parent"
	tools:context="com.fenchtose.battleship.GameActivity">

	<android.support.v7.widget.RecyclerView
		android:id="@+id/recyclerview"
		android:background="@color/cell_background"
		android:layout_width="match_parent"
		android:layout_height="wrap_content"
		tools:listitem="@layout/square_cell_itemview"/>

	<TextView
		android:id="@+id/gamestate_info"
		android:layout_width="match_parent"
		android:layout_height="wrap_content"
		android:layout_gravity="bottom"
		android:layout_margin="16dp"
		android:textSize="21sp"
		android:gravity="center"
		tools:text="Your turn!"/>

</FrameLayout>

BattleshipActivity.kt

class BattleshipActivity: AppCompatActivity() {
  
  private lateinit var gridAdpater: UiCellAdapter
  
  private lateinit var myBoard: Board
  private lateinit var otherBoard: Board
  
  private val width: Int = 10
  
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_game);
    
    gridAdapter = UiCellAdapter(this, { playMove(it.point) })
    gridAdapter.setHasStableIds(true)
    val recyclerview = findViewById<RecyclerView>(R.id.recyclerview).apply {
      layoutManager = GridLayoutManager(this@BattleshipActivity, width)
      adapter = gridAdpater
    }
    
    setupGame()
    updateUI()
  }
  
  private fun updateUI() {
    val cells = convert(myBoard)
    adapter.cells.clear()
    adapter.cells.addAll(cells)
    adapter.cells.notifyDataSetChanged()
  }
  
  private fun playMove(p: Point) {
    // check if already played
    if (p in otherBoard.hits || p in otherBoard.misses) {
      return
    }
    
    var missed = true
    var hitShip: Ship? = null
    for (ship in otherBoard.ships) {
      if (p in ship) {
        // we hit the ship
        hitShip = ship.copy(hits=ship.hits.plus(p))
        missed = false
        break
      }
    }
    
    if (missed) {
      myBoard = myBoard.copy(misses = myBoard.misses.plus(p))
      otherBoard = otherBoard.copy(
        ships = if (hitShip) != null ? otherBoard.ships.update(hitShip),
        opponentMisses = otherBoard.opponentMisses.plus(p))
    }
    
    updateUI()
  }
  
  private fun convert(board: Board): List<Cell> {
    val cells = ArrayList<Cell>(board.width * board.height)
      for (i in 0 until board.height) {
        for (j in 0 until board.width) {
          val point = Point(j, i)
            cells.add(Cell(
                  point = point,
                  hasShip = board.ships.contains(point),
                  direction = board.ships.getShipDirection(point),
                  userHit = board.hits.contains(point),
                  userMissed = board.misses.contains(point),
                  opponentMissed = board.opponentMisses.contains(point),
                  opponentHit = board.opponentHits.contains(point)
            ))
          }
      }
    return cells
  }
  
  private fun setupGame() {
    myBoard = Board(0, User("Player 1"), width, width, getRandomShips(0))
    otherBoard = Board(1, User("Player 2"), width, width, getRandomShips(1))
  }
  
  private fun getRandomShips(startId: Int) {
    val ships = ArrayList<Ship>()
    for (i in 1..5) {
      ships.add(Ship(startId + i, i, Point(i, i), (if (i%2 == 0) Direction.HORIZONTAL else Direction.VERTICAL )))
    }
    
    return ships
  }
  
}

BattleshipModels.kt

data class Point(val col: Int, val row: Int) {

    fun isValid() = col >= 0 && row >= 0

    operator fun plus(wd: WeighedDirection) = when (wd.d) {
        Direction.HORIZONTAL -> Point(col + wd.len, row)
        Direction.VERTICAL -> Point(col, row + wd.len)
    }

}

enum class Direction {
    HORIZONTAL, VERTICAL;

    operator fun times(n: Int): WeighedDirection {
        return WeighedDirection(this, n)
    }
}

data class WeighedDirection(val d: Direction, val len: Int)

data class Ship(
        val id: Int,
        val size: Int, val start: Point, val direction: Direction,
        val hits: Set<Point> = setOf()) {

    val end = start + direction*(size-1)
    val destroyed = hits.size == size

    // check for overlaps
    operator fun contains(other: Ship): Boolean {
        if (other.direction == direction) {
            return other.start in this || other.end in this
        }

        val vertical = if (other.direction == Direction.VERTICAL) other else this
        val horizontal = if (other.direction == Direction.HORIZONTAL) other else this

        return horizontal.start.row in vertical.start.row..vertical.end.row
                && vertical.start.col in horizontal.start.col..horizontal.end.col
    }

    operator fun contains(p: Point): Boolean {
        return when(direction) {
            Direction.HORIZONTAL -> start.row == p.row && start.col <= p.col && end.col >= p.col
            Direction.VERTICAL -> start.col == p.col && start.row <= p.row && end.row >= p.row
        }
    }

}

data class Board(
        val id: Int, val user: User,
        val width: Int, val height: Int,
        val ships: List<Ship> = listOf(),
        val hits: Set<Point> = setOf(),
        val misses: Set<Point> = setOf(),
        val opponentHits: Set<Point> = setOf(),
        val opponentMisses: Set<Point> = setOf()) {

    val activeShips = ships.filter { !it.destroyed }.map { it.id }
    val destroyedShips = ships.filter { it.destroyed }.map { it.id }
    val lost = ships.isNotEmpty() && activeShips.isEmpty()

    fun fits(ship: Ship) = ship.start in this && ship.end in this

    fun isOverlap(ship: Ship): Boolean {
        return ships.any { ship in it }
    }

    operator fun contains(p: Point) = p.isValid() && p.col < width && p.row < height
}

// Extension function to update the ship (based on id) and return new list
fun List<Ship>.update(ship: Ship): List<Ship> {
    var index = -1
    forEachIndexed { i, s ->
        if (s.id == ship.id) {
            index = i
            return@forEachIndexed
        }
    }

    if (index != -1) {
        val mutable = ArrayList(this)
        mutable.removeAt(index)
        mutable.add(index, ship)
        return mutable
    }

    return this
}

// Extension function to check if any of the ships are at the given point
fun List<Ship>.contains(p: Point): Boolean {
    forEach {
        if (p in it) {
            return true
        }
    }

    return false
}

// Extension function to check the direction of the ship at the given point
fun List<Ship>.getShipDirection(p: Point): Direction? {
    forEach {
        if (p in it) {
            return it.direction
        }
    }

    return null
}

BattleshipUi.kt

data class Cell(
  val point: Point,
  val hasShip: Boolean = false, 
  val direction: Direction? = null,
  val userHit: Boolean = false, 
  val userMissed: Boolean = false,
  val opponentHit: Boolean = false, 
  val opponentMissed: Boolean = false)

class SquareCell: View {

    private var cell: Cell? = null

    private val shipPaint: Paint
    private val shipHitPaint: Paint
    private val hitPaint: Paint
    private val missedPaint: Paint
    private val opponentHitPaint: Paint
    private val opponentMissedPaint: Paint
    private val borderPaint: Paint

    private val rect: Rect = Rect()

    constructor(context: Context) : this(context, null)
    constructor(context: Context, attrs: AttributeSet?) : this(context, attrs, 0)
    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(context, attrs, defStyleAttr) {
        shipPaint = initPaint(R.color.cell_my_ship, cap = Paint.Cap.ROUND)
        shipHitPaint = initPaint(R.color.cell_my_ship_hit)
        hitPaint = initPaint(R.color.cell_ship_hit)
        opponentMissedPaint = initPaint(R.color.cell_opponent_miss)
        opponentHitPaint = initPaint(R.color.cell_ship_hit)
        missedPaint = initPaint(R.color.cell_ship_miss)
        borderPaint = initPaint(R.color.cell_border, Paint.Style.STROKE, 2f)

        if (isInEditMode) {
            hasShip = true
            shipDirection = Direction.HORIZONTAL
        }
    }

    private fun initPaint(@ColorRes color: Int, style: Paint.Style = Paint.Style.FILL, width: Float? = null, cap: Paint.Cap? = null): Paint {
        return Paint(Paint.ANTI_ALIAS_FLAG).apply {
            this.color = ContextCompat.getColor(context, color)
            this.style = style
            width?.let { this.strokeWidth = it }
            cap?.let { this.strokeCap = it }
        }
    }

    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec)
        setMeasuredDimension(widthMeasureSpec, widthMeasureSpec)
    }

    override fun onDraw(canvas: Canvas) {
        rect.left = 0
        rect.top = 0
        rect.bottom = canvas.height
        rect.right = canvas.width

        canvas.drawRect(rect, borderPaint)

        cell?.apply {
            if (hasShip && direction != null) {
                when (direction) {
                    Direction.HORIZONTAL -> {
                        rect.bottom = canvas.height - 64
                        rect.right = canvas.width
                    }

                    Direction.VERTICAL -> {
                        rect.bottom = canvas.height
                        rect.right = canvas.width - 64
                    }
                }
                val paint = if (!opponentHit) shipPaint else shipHitPaint
                canvas.drawRect(rect, paint)
            }

            if (userHit) {
                canvas.drawCircle((canvas.width - 24).toFloat(), (canvas.height - 24).toFloat(), 16f, hitPaint)
            } else if (userMissed) {
                canvas.drawCircle((canvas.width - 24).toFloat(), (canvas.height - 24).toFloat(), 16f, missedPaint)
            }

            if (opponentHit) {
                canvas.drawCircle(24f, 24f, 16f, opponentHitPaint)
            } else if (opponentMissed) {
                canvas.drawCircle(24f, 24f, 16f, opponentMissedPaint)
            }
        }
    }
  
    fun bind(cell: Cell) {
        this.cell = cell
        invalidate()
    }
}

class UiCellAdapter(context: Context, private val onClick: ((Cell) -> Unit)): RecyclerView.Adapter<RecyclerView.ViewHolder>() {

    val cells = ArrayList<Cell>()
    private val inflater = LayoutInflater.from(context)

    override fun getItemCount(): Int {
        return cells.size
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
        return UiCellViewHolder(inflater.inflate(R.layout.square_cell_itemview, parent, false), onClick)
    }

    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
        holder as UiCellViewHolder
        holder.bind(cells[position])
    }

    override fun getItemId(position: Int): Long {
        return cells[position].hashCode().toLong()
    }

    class UiCellViewHolder(itemView: View, onClick: (Cell) -> Unit) : RecyclerView.ViewHolder(itemView) {
        private val view = itemView as SquareCell
        private var cell: Cell? = null

        init {
            view.setOnClickListener {
                cell?.let(onClick)
            }
        }

        fun bind(cell: Cell) {
            this.cell = cell
            view.bind(cell)
        }
    }
}

BoardReducers.kt

fun Board.reduceOffense(action: Action): Board {
  return when(action) {
    is GeneratedAction.MissedMove -> copy(misses = misses.plus(action.point))
    is GeneratedAction.DefinitiveAction -> copy(hits = hits.plus(action.point))
    else -> this
  }
}

fun Board.reduceDefense(action: Action): Board {
  return when(action) {
    is GeneratedAction.MissedMove -> copy(opponentMisses = opponentMisses.plus(action.point))
    is GeneratedAction.DefinitiveAction -> {
      val ship = ships.getById(action.ship.id)
      if (ship != null) {
        val updated = ship.reduce(action)
        copy(opponentHits = opponentHits.plus(action.point), ships = ships.update(updated))
      } else {
        this
      }
    }
    else -> this
  }
}

fun Board.reduceSetup(action: Action): Board {
    return when(action) {
        is AddShip -> copy(ships = ships.add(action.ship))
        else -> this
    }
}

fun Ship.reduce(action: Action): Ship {
  return when(action) {
    is GeneratedAction.DefinitiveAction -> copy(hits = hits.plus(action.point))
    else -> this
  }
}

Destroy-LostMiddleware.kt

fun destroyMiddleware(state: GameState, action: Action, dispatch: Dispatch, next: Next<GameState>): Action {
  if (action is GeneratedAction.DefinitiveAction.HitMove) {
    if (action.ship.hits.size + 1 == action.ship.size) {
      return next(state, GeneratedAction.DefinitiveAction.DestroyShip(action.offense, action.defense, action.point, action.ship), dispatch)
    }
  }

  return next(state, action, dispatch)
}

fun lostMiddleware(state: GameState, action: Action, dispatch: Dispatch, next: Next<GameState>): Action {
  if (action is GeneratedAction.DefinitiveAction.DestroyShip) {
    if (state.boardById(action.defense).activeShips.size == 1) {
      return next(state, GeneratedAction.DefinitiveAction.LostGame(action.offense, action.defense, action.point, action.ship), dispatch)
    }
  }

  return next(state, action, dispatch)
}

GameActivity.kt

class GameActivity : AppCompatActivity() {

  private lateinit var adapter: UiCellAdapter
  private lateinit var gamestateInfo: TextView

  private lateinit var handler: Handler

  private lateinit var store: Gamestore
  private lateinit var myBoard: Board
  private lateinit var otherBoard: Board

  private var unsubscribe: Unsubscribe? = null
  private var dispatch: Dispatch? = null

  private var gameOver: Boolean = false

  private val width: Int = 10

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_game)

    handler = Handler()

    gamestateInfo = findViewById(R.id.gamestate_info)

    val recyclerview = findViewById<RecyclerView>(R.id.recyclerview)
    adapter = UiCellAdapter(this, {
        if (gameOver) {
            return@UiCellAdapter
        }
        dispatch?.invoke(Move(myBoard.id, otherBoard.id, it.point))
    })

    adapter.setHasStableIds(true)

    recyclerview.layoutManager = GridLayoutManager(this, width)
    recyclerview.adapter = adapter
    adapter.notifyDataSetChanged()


    myBoard = Board(0, User("Player 1"), width, width)
    otherBoard = Board(1, User("Player 2"), width, width)

    val initState = GameState(
            board1 = myBoard,
            board2 = otherBoard,
            lastPlayed = otherBoard.id
    )

    store = Gamestore(initState)
    setupGame()
  }

  override fun onResume() {
    super.onResume()
    unsubscribe = store.subscribe({ state, dispatch ->
      this.dispatch = dispatch
      myBoard = state.board1
      otherBoard = state.board2

      val cells = generateCells(myBoard)

      adapter.cells.clear()
      adapter.cells.addAll(cells)
      adapter.notifyDataSetChanged()

      gamestateInfo.text = if (state.lastPlayed == otherBoard.id) "Your turn" else "Player 2 turn"
      gameOver = state.gameOver

      if (state.gameOver) {
          gamestateInfo.text = "Game over!"
      }

      if(state.lastPlayed == myBoard.id && !state.gameOver) {
          handler.postDelayed({
              playOther()
          }, 300)
      }

  })

  }

  override fun onPause() {
    super.onPause()
    unsubscribe?.invoke()
  }

  private fun setupGame() {
    for (i in 1..5) {
      store.dispatch(AddShip(myBoard.id, Ship(i, i, Point(i, i), (if (i%2 == 0) Direction.HORIZONTAL else Direction.VERTICAL ))))
      store.dispatch(AddShip(otherBoard.id, Ship(10 + i, i, Point(i, i), (if (i%2 == 0) Direction.HORIZONTAL else Direction.VERTICAL ))))
    }
  }

  private fun playOther() {
    val random =  Random()
    while(true) {
      val point = Point(random.nextInt(width), random.nextInt(width))
      if (point !in otherBoard.hits && point !in otherBoard.misses) {
        dispatch?.invoke(Move(otherBoard.id, myBoard.id, point))
        break
      }
    }
  }

  private fun generateCells(board: Board): ArrayList<Cell> {
    val cells = ArrayList<Cell>(board.width * board.height)
    for (i in 0 until board.height) {
      for (j in 0 until board.width) {
        val point = Point(j, i)
        cells.add(Cell(
            point = point,
            hasShip = board.ships.contains(point),
            direction = board.ships.getShipDirection(point),
            userHit = board.hits.contains(point),
            userMissed = board.misses.contains(point),
            opponentMissed = board.opponentMisses.contains(point),
            opponentHit = board.opponentHits.contains(point)
        ))
      }
    }

    return cells
  }
}

GameplayReducers.kt

fun GameState.reduceSetup(action: Action): GameState {
  return when(action) {
    is AddShip -> reduceChildState(this, boardById(action.offense), action, Board::reduceSetup, { state, board -> state.updateBoard(board) })
    else -> this
  }
}

fun GameState.reduceGameplay(action: Action): GameState {
  return when(action) {
      is GeneratedAction -> {
          val offense = boardById(action.offense).reduceOffense(action)
          val defense = boardById(action.defense).reduceDefense(action)
          copy(board1 = whichBoard(board1, offense, defense),
                board2 = whichBoard(board2, offense, defense),
                gameOver = action is GeneratedAction.DefinitiveAction.LostGame)

        }
      is SwitchAction -> {
        reduceGameplay(action.last).copy(lastPlayed = action.offense)
      }
      else -> this
  }
}

fun<State, Child> reduceChildState(
  state: State,
  child: Child,
  action: Action,
  reducer: Reducer<Child>,
  onReduced: (State, Child) -> State): State {

  val reduced = reducer.invoke(child, action)
  if (reduced === child) {
      return state
  }

  return onReduced(state, reduced)
}

private fun whichBoard(board: Board, offense: Board, defense: Board): Board {
    return when(board.id) {
        offense.id -> offense
        defense.id -> defense
        else -> board
    }
}

GameSetupMiddleware.kt

fun gameSetupMiddleware(state: GameState, action: Action, dispatch: Dispatch, next: Next<GameState>): Action {
  if (action is AddShip) {
    val board = state.boardById(action.offense)
    if (!board.fits(action.ship) || board.isOverlap(action.ship)) {
      return next(state, AddShipInvalid(action.offense, action.ship), dispatch)
    }
  }

  return next(state, action, dispatch)
}

GameState.kt

data class GameState(
  val board1: Board,
  val board2: Board,
  val lastPlayed: Int,
  val gameOver: Boolean = false) {

  fun hasBoardById(id: Int): Boolean {
    return when(id) {
      board1.id, board2.id -> true
      else -> false
    }
  }

  fun boardById(id: Int): Board {
    return when (id) {
      board1.id -> board1
      board2.id -> board2
      else -> throw RuntimeException("No such board with id: $id")
    }
  }

  fun updateBoard(board: Board): GameState {
    return when(board.id) {
      board1.id -> copy(board1 = board)
      board2.id -> copy(board2 = board)
      else -> this
    }
  }
}

GameStore.kt

class Gamestore(initialSate: GameState): SimpleStore<GameState>(
    initialState = initialSate,
    middlewares = listOf(
        ::stateValidityMiddleware,
        ::gameSetupMiddleware,
        ::moveMiddleware,
        ::hitMiddleware,
        ::destroyMiddleware,
        ::lostMiddleware,
        ::switcherMiddleware
    ),
    reducers = listOf(
        GameState::reduceSetup,
        GameState::reduceGameplay
    )
)

GeneratedActions.kt

data class AddShip(val offense: Int, val ship: Ship): Action
data class AddShipInvalid(val offense: Int, val ship: Ship): Action

sealed class GeneratedAction(val offense: Int, val defense: Int, val point: Point): Action {
  class InvalidMove(offense: Int, defense: Int, point: Point): GeneratedAction(offense, defense, point)
  class PlayMove(offense: Int, defense: Int, point: Point): GeneratedAction(offense, defense, point)
  class MissedMove(offense: Int, defense: Int, point: Point): GeneratedAction(offense, defense, point)

  sealed class DefinitiveAction(offense: Int, defense: Int, point: Point, val ship: Ship): GeneratedAction(offense, defense, point) {
    class HitMove(offense: Int, defense: Int, point: Point, ship: Ship) : DefinitiveAction(offense, defense, point, ship)
    class DestroyShip(offense: Int, defense: Int, point: Point, ship: Ship) : DefinitiveAction(offense, defense, point, ship)
    class LostGame(offense: Int, defense: Int, point: Point, ship: Ship) : DefinitiveAction(offense, defense, point, ship)
  }
}

data class SwitchAction(val offense: Int, val defense: Int, val last: GeneratedAction): Action
object InvalidState: Action

HitMiddleware.kt

fun hitMiddleware(state: GameState, action: Action, dispatch: Dispatch, next: Next<GameState>): Action {
  if (action is GeneratedAction.PlayMove) {
    val defense = state.boardById(action.defense)

    for (id in defense.activeShips) {
      defense.ships.getById(id)?.let {
        if (action.point in it) {
            return next(state, GeneratedAction.DefinitiveAction.HitMove(action.offense, action.defense, action.point, it), dispatch)
        }
      }
    }

    return next(state, GeneratedAction.MissedMove(action.offense, action.defense, action.point), dispatch)
  }

  return next(state, action, dispatch)
}

MoveMiddleware.kt

fun moveMiddleware(state: GameState, action: Action, dispatch: Dispatch, next: Next<GameState>): Action {
   if (action is Move) {
      val offense = state.boardById(action.offense)
      if (offense.hits.contains(action.point) || offense.misses.contains(action.point)) {
         return next(state, GeneratedAction.InvalidMove(action.offense, action.defense, action.point), dispatch)
      }

      return next(state, GeneratedAction.PlayMove(action.offense, action.defense, action.point), dispatch)
   }
   return next(state, action, dispatch)
}

square_cell_itemview.xml

<?xml version="1.0" encoding="utf-8"?>
<com.fenchtose.battleship.ui.SquareCell
	xmlns:android="http://schemas.android.com/apk/res/android"
	android:orientation="vertical"
	android:layout_width="match_parent"
	android:layout_height="wrap_content">

</com.fenchtose.battleship.ui.SquareCell>

StateValidityMiddleware.kt

 fun stateValidityMiddleware(state: GameState, action: Action, dispatch: Dispatch, next: Next<GameState>): Action {
  when(action) {
    is Move -> {
      if (!state.hasBoardById(action.offense) || !state.hasBoardById(action.defense)) {
        return InvalidState
      }
    }

    is GeneratedAction -> {
      if (!state.hasBoardById(action.offense) || !state.hasBoardById(action.defense)) {
        return InvalidState
      }
    }

    is AddShip -> {
      if (!state.hasBoardById(action.offense)) {
        return InvalidState
      }
    }
  }

  return next(state, action, dispatch)
}

SwitcherMiddleware.kt

fun switcherMiddleware(state: GameState, action: Action, dispatch: Dispatch, next: Next<GameState>): Action {
  if (action is GeneratedAction && action !is GeneratedAction.InvalidMove) {
    return next(state, SwitchAction(action.offense, action.defense, action), dispatch)
  }

  return next(state, action, dispatch)
}