Dominion.Internal

Documentation

Note: You shouldn't need to import this module...the interesting functions are re-exported by the Dominion module.

Use any other functions in here at your own risk.

currentHand :: PlayerId -> Dominion [Card]

see all of the cards in a player's hand.

cards <- currentHand playerId

has :: PlayerId -> Card -> Dominion Bool

see if a player has a card in his hand.

hasCard <- playerId `has` chapel

countNum :: PlayerId -> Card -> Dominion Int

see how many of this card a player has.

numMarkets <- countNum playerId market

coinValue :: Card -> Int

What this card is worth in money.

getRound :: Dominion Int

Get the current round number.

handValue :: PlayerId -> Dominion Int

How much money this player's hand is worth (also counts any money you get from action cards, like +1 from market).

pileEmpty :: Card -> Dominion Bool

Check if this card's pile is empty. Returns True is the card is not in play.

getCard :: Card -> Dominion (Maybe Card)

Returns the card, or Nothing if that pile is empty. Useful because it automatically checks whether the pile is empty, and modifies state to subtract a card from the pile correctly.

log :: PlayerId -> String -> Dominion ()

Convenience function. Prints out a line if verbose, AND prints out info about the related player...name, money, of actions.

log_ :: String -> Dominion ()

Like log but doesn't print out info about a player

gameOver :: Map Card Int -> Bool

drawFromDeck :: PlayerId -> Int -> Dominion [Card]

Given a player id and a number of cards to draw, draws that many cards from the deck, shuffling if necessary.

modifyPlayer :: PlayerId -> (Player -> Player) -> Dominion ()

Like modify for the State monad, but works on players. Takes a player id and a function that modifies the player.

modifyOtherPlayers :: PlayerId -> (Player -> Player) -> Dominion ()

Like modifyPlayer, but modifies every player *except* the one specified with the player id.

setupForTurn :: PlayerId -> Dominion ()

playTurn :: PlayerId -> Strategy -> Dominion ()

makeGameState :: [Option] -> [Player] -> IO GameState

game :: [Strategy] -> Dominion ()

run :: GameState -> [Strategy] -> IO Result

returnResults :: GameState -> IO Result

isAction :: Card -> Bool

isAttack :: Card -> Bool

isReaction :: Card -> Bool

isTreasure :: Card -> Bool

isVictory :: Card -> Bool

countPoints :: Player -> Int

getPlayer :: PlayerId -> Dominion Player

Get player from game state specified by this id. This is useful sometimes:

import qualified Dominion.Types as T
import Control.Lens

player <- getPlayer playerId

-- How many buys does this player have?
player ^. T.buys

-- How many actions does this player have?
player ^. T.actions

cardsOf :: Int -> a -> [a]

Convenience function. 4 `cardsOf` estate is the same as take 4 . repeat $ estate

eitherToBool :: Either String () -> Bool

shuffleDeck :: PlayerId -> Dominion ()

Move this players discards + hand into his deck and shuffle the deck.

shuffleDeck_ :: Player -> Player

validateBuy :: PlayerId -> Card -> Dominion (PlayResult ())

Check that this player is able to purchase this card. Returns a Right if they can purchase the card, otherwise returns a Left with the reason why they can't purchase it.

validatePlay :: PlayerId -> Card -> Dominion (PlayResult ())

Check that this player is able to play this card. Returns a Right if they can play the card, otherwise returns a Left with the reason why they can't play it.

discardHand :: PlayerId -> Dominion ()

findIteration :: [Option] -> Maybe Int

findLog :: [Option] -> Maybe Bool

findCards :: [Option] -> Maybe [Card]

drawsUntil :: PlayerId -> ([Card] -> Dominion Bool) -> Dominion [Card]

Keep drawing a card until the provided function returns true. The function gets a list of the cards drawn so far, most recent first. Returns a list of all the cards drawn (these cards are also placed into the player's hand)

drawsUntil_ :: [Card] -> PlayerId -> ([Card] -> Dominion Bool) -> Dominion [Card]

trashThisCard :: Card -> Bool

trashesCard :: PlayerId -> Card -> Dominion ()

Player trashes the given card.

discardsCard :: PlayerId -> Card -> Dominion ()

Player discards the given card.

returnsCard :: PlayerId -> Card -> Dominion ()

discardTopCard :: [Card] -> Player -> Player

returnVPCard :: Player -> Player

discardsTo :: Player -> Int -> Player

Player discards down to x cards.

usesEffect :: PlayerId -> CardEffect -> Dominion (Maybe Followup)

Used internally by the plays function. Each card has a list of effects (like smithy has `PlusCard 3`). This function applies the given effect. It returns Nothing if the effect doesn't need a Followup, or it returns a `Just Followup`.

makePlayer :: String -> Player

Given a name, creates a player with that name.

gainCardUpTo :: PlayerId -> Int -> Card -> Dominion (PlayResult (Maybe [Followup]))