Quoridor

Documentation

type Cell = (Int, Int)

A tile on the board. Direction of X and Y axis are right and down respectively.

type HalfGate = (Cell, Cell)

type Gate = (HalfGate, HalfGate)

type HalfGates = Set HalfGate

type BoardSize = Int

Size of the board in one dimension. The board is a square

type ValidMoves = [Cell]

List of valid moves for a player

newtype Game m a

The monad used for running the game. Basically adds layers of ReaderT for configuration, StateT for state, and some monad for the rest (currently just IO monad).

Constructors

Game (ReaderT GameConfig (StateT GameState m) a)

Instances

MonadTrans Game

Monad m => MonadReader GameConfig (Game m)

Monad m => MonadState GameState (Game m)

Monad m => Monad (Game m)

Functor m => Functor (Game m)

(Monad m, Functor m) => Applicative (Game m)

MonadThrow m => MonadThrow (Game m)

MonadCatch m => MonadCatch (Game m)

MonadMask m => MonadMask (Game m)

MonadIO m => MonadIO (Game m)

runGame :: Functor m => Game m a -> GameConfig -> m ()

To run the Game monad

runGameWithGameState :: Game m a -> GameState -> GameConfig -> m (a, GameState)

Same as runGame, but allows to start from a given GameState, instead of from the beginning

data Player

Constructors

Player

Fields

color :: Color

pos :: Cell

gatesLeft :: Int

Instances

Eq Player

Read Player

Show Player

data Turn

Represents a turn, can be either a Gate put, a Player move or a ShortCutMove which is specified by an index from the given valid moves for a player at the current turn

Constructors

PutGate Gate

Move Cell

ShortCutMove Int

Instances

Read Turn

Show Turn

data Color

Colors to distinguish between Players

Constructors

Blue

White

Red

Green

Instances

Enum Color

Eq Color

Ord Color

Read Color

Show Color

data Direction

The orientation (perhaps a better name?) of the Gate, it can be either vertical or horizontal

Constructors

H

V

Instances

Read Direction

Show Direction

data GameState

Represents the game state. With a list of Players (the head is the current player), maybe a winner, and a map of the Gates, which actually breaks them into Halfgates.

Constructors

GameState

Fields

playerList :: [Player]

halfGates :: HalfGates

winner :: Maybe Color

Instances

Read GameState

Show GameState

Monad m => MonadState GameState (Game m)

data GameConfig

Constructors

GameConfig

Fields

gatesPerPlayer :: Int

boardSize :: Int

numOfPlayers :: Int

Instances

Read GameConfig

Show GameConfig

Monad m => MonadReader GameConfig (Game m)

initialGameState :: GameConfig -> GameState

An initial state. All players begin at the firstlast rowcolumn

defaultGameConfig :: GameConfig

startPos :: Int -> Map Color Cell

Initial positions for the different Colors

modifyCurrP :: (Player -> Player) -> GameState -> GameState

Applies f on the current player

currP :: GameState -> Player

Returns the current player

distance :: Cell -> Cell -> Int

isAdj :: Cell -> Cell -> Bool

getAdj :: Int -> Cell -> [Cell]

Returns adjacent cells that are within the ranger of the board

isWithinRange :: Int -> Cell -> Bool

Is cell within board range

align :: HalfGate -> HalfGate

Coerces HalfGates so that left item is less than or equal to the right item.

isHalfGateSpaceClear :: HalfGate -> HalfGates -> Bool

Equivalent to, given cells a and b (a,b) is the space between them open for movement?

isGateSpaceClear :: Gate -> HalfGates -> Bool

gateToCells :: Gate -> [Cell]

Breaks a gate into it's cell components. Used, for example, to make sure a gate is placed within bounds of the board.

gateUpperLeft :: Cell -> Direction -> Gate

Given a cell, returns a gate. That gate, the upper left corner of it's encompassing 2x2 square is at the given cell.

insertGate :: Gate -> HalfGates -> HalfGates

isVacant :: Cell -> GameState -> Bool

Is the cell empty (i.e. no player is standing there)

isWinningCell :: Int -> Player -> Cell -> Bool

Given a cell and a player, is that a cell that if the player reaches it, the game ends. Used with dfs, to make sure placing a gate still leaves at least one cell which is a winning cell, for every player.

coerceTurn :: (Monad m, Functor m) => Turn -> Game m (Maybe Turn)

Basically, translates a ShortCutMove into the Move that it is a shortcut of, using the integral index that is the index of the shortcut character in the list of validMovesChars

getValidMoves :: Cell -> Int -> GameState -> [Cell]

Gets a list of possible cells which the current player can move to.

dfs :: Cell -> (Cell -> Bool) -> Int -> GameState -> Bool

Checks if from a given cell, another cell, which satisfies the given predicate, can be reached. Used in gate placement, to make sure a cell which is a winning cell for a player can still be reached.

changeCurrPlayer :: Monad m => Game m ()

Rotates the Player list to change the current player. The player at the had of the player list is the current player.

isValidTurn :: (Monad m, Functor m) => Turn -> Game m Bool

Checks if a given Turn is valid, rule-wise. It does it by perusing getCurrentValidMovess returned list of all possible valid moves.

actTurn :: Monad m => Turn -> Game m ()

Acts upon a single Turn. The difference with MakeTurn, is that MakeTurn calls this function and does more, like changing currentPlayer and checking for a winner.

checkAndSetWinner :: Monad m => Game m (Maybe Color)

Checks if there's a winner, returning it if there is and sets the winner in the GameState.

makeTurn :: (Monad m, Functor m) => Turn -> Game m (Maybe Turn)

Makes a single Turn in a game. Changes the state (GameState) accordingly and returns whether or not a valid turn was requested. If an invalid turn was requested, it can be safely assumed that the GameState did not change.

getCurrentValidMoves :: (Monad m, Functor m) => Game m [Cell]

A Game monad wrapper for the unmonadic getValidMoves