Game.Werewolf.Game

A game is not quite as simple as players! Roughly speaking though, this engine is stateful. The game state only changes when a command is issued (see Game.Werewolf.Command). Thus, this module defines the Game data structure and any fields required to keep track of the current state.

It also has a few additional functions for manipulating and querying the game state.

Game

data Game

There are a few key pieces of information that a game always needs to hold. These are:

• the stage,
• the round number,
• the players and
• the events.

Any further fields on the game are specific to one or more roles (and their respective turns!). Some of the additional fields are reset each round (e.g., the Seer's see) while others are kept around for the whole game (e.g., the Orphan's roleModel).

In order to advance a game's state, a Command from a user needs to be received. Afterwards the following steps should be performed:

1. apply the Command.
2. run checkStage.
3. run checkGameOver.

checkStage will perform any additional checks and manipulations to the game state before advancing the game's stage. It also runs any relevant events. checkGameOver will check to see if any of the win conditions are met and if so, advance the game's stage to GameOver.

Instances

Eq Game

Read Game

Show Game

stage :: Lens' Game Stage

round :: Lens' Game Int

players :: Lens' Game [Player]

events :: Lens' Game [Event]

boots :: Lens' Game (Map Text [Text])

allowedVoters :: Lens' Game [Text]

heal :: Lens' Game Bool

healUsed :: Lens' Game Bool

hunterRetaliated :: Lens' Game Bool

jesterRevealed :: Lens' Game Bool

passed :: Lens' Game Bool

poison :: Lens' Game (Maybe Text)

poisonUsed :: Lens' Game Bool

priorProtect :: Lens' Game (Maybe Text)

protect :: Lens' Game (Maybe Text)

roleModel :: Lens' Game (Maybe Text)

scapegoatBlamed :: Lens' Game Bool

see :: Lens' Game (Maybe Text)

votes :: Lens' Game (Map Text Text)

data Stage

Most of these are fairly self-sufficient (the turn stages). Sunrise and Sunset are provided as meaningful breaks between the day and night as, for example, a VillagesTurn may not always be available (curse that retched Scapegoat).

Once the game reaches a turn stage, it requires a Command to help push it past. Often only certain roles and commands may be performed at any given stage.

Constructors

FerinasGrunt

GameOver

HuntersTurn1

HuntersTurn2

Lynching

OrphansTurn

ProtectorsTurn

ScapegoatsTurn

SeersTurn

Sunrise

Sunset

VillageDrunksTurn

VillagesTurn

WerewolvesTurn

WitchsTurn

Instances

Eq Stage

Read Stage

Show Stage

Humanise Stage

_FerinasGrunt :: Prism' Stage ()

_GameOver :: Prism' Stage ()

_HuntersTurn1 :: Prism' Stage ()

_HuntersTurn2 :: Prism' Stage ()

_Lynching :: Prism' Stage ()

_OrphansTurn :: Prism' Stage ()

_ProtectorsTurn :: Prism' Stage ()

_ScapegoatsTurn :: Prism' Stage ()

_SeersTurn :: Prism' Stage ()

_Sunrise :: Prism' Stage ()

_Sunset :: Prism' Stage ()

_VillageDrunksTurn :: Prism' Stage ()

_VillagesTurn :: Prism' Stage ()

_WerewolvesTurn :: Prism' Stage ()

_WitchsTurn :: Prism' Stage ()

allStages :: [Stage]

All of the Stages in the order that they should occur.

stageCycle :: [Stage]

An infinite cycle of all Stages in the order that they should occur.

stageAvailable :: Game -> Stage -> Bool

Checks whether the stage is available for the given Game. Most often this just involves checking if there is an applicable role alive, but sometimes it is more complex.

One of the more complex checks here is for the VillagesTurn. If the Fallen Angel is in play, then the VillagesTurn is available on the first day rather than only after the first night.

data Event

Events occur after a Stage is advanced. This is automatically handled in checkStage, while an event's specific behaviour is defined by eventAvailable and applyEvent.

For the most part events are used to allow something to happen on a Stage different to when it was triggered. E.g., the DeovurEvent occurs after the village wakes up rather than when the Werewolves' vote, this gives the Witch a chance to heal the victim.

Constructors

DevourEvent Text

Werewolves

NoDevourEvent

Protector, Werewolves and Witch

PoisonEvent Text

Witch

Instances

Eq Event

Read Event

Show Event

_DevourEvent :: Prism' Event Text

_NoDevourEvent :: Prism' Event ()

_PoisonEvent :: Prism' Event Text

newGame :: [Player] -> Game

Creates a new Game with the given players. No validations are performed here, those are left to startGame.

Manipulations

killPlayer :: Text -> Game -> Game

Kills the given player! This function should be used carefully as it doesn't clear any state that the player's role may use. If you're after just removing a player from a game for a test, try using a quitCommand instead.

Searches

getAllowedVoters :: Game -> [Player]

Gets all the allowedVoters in a game (which is names only) and maps them to their player.

getPendingVoters :: Game -> [Player]

Gets all Alive players that have yet to vote.

getVoteResult :: Game -> [Player]

Gets all players that had the highest vote count. This could be 1 or more players depending on whether the votes were in conflict.

Queries

isFirstRound :: Game -> Bool

isFirstRound game = game ^. round == 0

isThirdRound :: Game -> Bool

isThirdRound game = game ^. round == 2

doesPlayerExist :: Text -> Game -> Bool

Queries whether the player is in the game.

hasAnyoneWon :: Game -> Bool

Queries whether anyone has won.

hasFallenAngelWon :: Game -> Bool

Queries whether the Fallen Angel has won. The Fallen Angel wins if they manage to get themselves killed on the first round.

N.B., we check that the Fallen Angel isn't a villager as the Fallen Angel's role is altered if they don't win.

hasVillagersWon :: Game -> Bool

Queries whether the Villagers have won. The Villagers win if they are the only players surviving.

hasWerewolvesWon :: Game -> Bool

Queries whether the Werewolves have won. The Werewolves win if they are the only players surviving.