Haverer

Implementation of the rules of Love Letter.

Documentation

data Game playerId

Instances

Show playerId => Show (Game playerId)

makeGame :: Ord playerId => PlayerSet playerId -> Game playerId

Create a new game for the given set of players.

newRound :: (Functor m, MonadRandom m, Ord playerId, Show playerId) => Game playerId -> m (Round playerId)

Start a new round of the game, shuffling the deck cards ourselves.

newRound' :: (Ord playerId, Show playerId) => Game playerId -> FullDeck -> Round playerId

Start a new round of the game with an already-shuffled deck of cards.

players :: Game playerId -> PlayerSet playerId

Return the set of all players

roundsPlayed :: Game playerId -> Int

Return the number of rounds played.

finalScores :: Ord playerId => Outcome playerId -> [(playerId, Int)]

Get the final scores at the end of the game.

scores :: Ord playerId => Game playerId -> [(playerId, Int)]

Return the current scores of all the players.

winners :: Ord playerId => Outcome playerId -> [playerId]

Get the winners of the game.

data Round playerId

Instances

Show playerId => Show (Round playerId)

data BadAction playerId

Instances

Show playerId => Show (BadAction playerId)

data Result playerId

The result of a turn.

Constructors

BustedOut playerId Card Card

The player whose turn it was "busted out", they held the Minister and another high card, and thus didn't get to play.

Played (Action playerId) (Event playerId)

The player performed an Action resulting in Event.

Instances

Eq playerId => Eq (Result playerId)

Show playerId => Show (Result playerId)

data Event playerId

A change to the Round that comes as result of a player's actions.

Constructors

NoChange

Nothing happened. What the player did had no effect.

Protected playerId

The player is now protected.

SwappedHands playerId playerId

The first player has been forced to swap hands with the second.

Eliminated playerId

The player has been eliminated from the round.

ForcedDiscard playerId

The player has been forced to discard their hand.

ForcedReveal playerId playerId Card

The second player has been forced to show their hand to the first.

Instances

Eq playerId => Eq (Event playerId)

Show playerId => Show (Event playerId)

playTurn :: (Ord playerId, Show playerId) => Round playerId -> Either (ActionM playerId (Result playerId, Round playerId)) (Card -> Play playerId -> ActionM playerId (Result playerId, Round playerId))

Play a turn in a Round.

This is the main function in this module.

A turn has two steps. First, the player draws a card. If their hand "busts out" (due to holding the Minister and another high card), then they are eliminated and play proceeds to the next player. This is the Left return value, which returns the new Round and a Result indicating the player bust out.

Second, the player plays one of these two cards. This is the Right return value, a function that takes the players chosen card and play, and returns either a BadAction or a new Round together with the Result of the play.

playTurn' :: (Ord playerId, Show playerId) => Round playerId -> Maybe (Card, Play playerId) -> ActionM playerId (Result playerId, Round playerId)

Play a turn in a Round

Similar to playTurn, except that instead of splitting the turn into two phases, there is a single, optional play. If the hand is a busting hand, then the play must be Nothing; if not, the play must be specified.

getPlayers :: Round playerId -> [playerId]

The IDs of all of the players.

getPlayerMap :: Round playerId -> Map playerId Player

A map of player IDs to players.

currentPlayer :: Round playerId -> Maybe playerId

The ID of the current player. If the Round is over or not started, this will be Nothing.

currentTurn :: Ord playerId => Round playerId -> Maybe (playerId, (Card, Card))

data Card

Constructors

Soldier

Clown

Knight

Priestess

Wizard

General

Minister

Prince

Instances

Enum Card

Eq Card

Ord Card

Show Card

data Deck a

Instances

Eq (Deck a)

Ord (Deck a)

Show (Deck a)

data DeckSize

Constructors

Incomplete

Complete

type FullDeck = Deck Complete

newDeck :: MonadRandom m => m (Deck Complete)

data Play target

A thing that can be done with a card.

Constructors

NoEffect

Attack target

Guess target Card

Instances

Eq target => Eq (Play target)

Show target => Show (Play target)

viewAction :: Action target -> (target, Card, Play target)

data Player

Instances

Eq Player

Show Player

getDiscards :: Player -> [Card]

getHand :: Player -> Maybe Card

isProtected :: Player -> Maybe Bool

data PlayerSet a

Instances

Functor PlayerSet

Foldable PlayerSet

Traversable PlayerSet

Eq a => Eq (PlayerSet a)

Show a => Show (PlayerSet a)

data PlayerSetError a

Constructors

InvalidNumPlayers Int

DuplicatePlayers [a]

Instances

Eq a => Eq (PlayerSetError a)

Show a => Show (PlayerSetError a)

toPlayers :: PlayerSet a -> [a]

toPlayerSet :: Ord a => [a] -> Either (PlayerSetError a) (PlayerSet a)