ritchie - v0.0.1

ritchie/game

Top-level module that manages an entire game, from beginning to end, across rounds, keeping track of everything. This is the one type you should hold.

Types

Game

opaque </>

A match in progress.

pub opaque type Game

GameError

</> 
pub type GameError {
  GameFinished
  RoundAlreadyStarted
}

Constructors 

  • GameFinished
  • RoundAlreadyStarted

GameStatus

</> 
pub type GameStatus {
  NotStarted
  InRound
  BetweenRounds
  Finished
}

Constructors 

  • NotStarted
  • InRound
  • BetweenRounds
  • Finished

GameStepOutcome

</>

Result of advancing one turn.

pub type GameStepOutcome {
  GameStepOutcome(
    game: Game,
    game_step: history.GameStep,
    round_end: option.Option(boundary.RoundEnd),
  )
}

Constructors

Values

all_reactions

</> 
pub fn all_reactions(
  game: Game,
) -> List(#(player.Player, List(reaction.Reaction)))

completed_rounds

</> 
pub fn completed_rounds(game: Game) -> List(history.RoundHistory)

current_state

</> 
pub fn current_state(game: Game) -> option.Option(state.State)

is_finished

</> 
pub fn is_finished(game: Game) -> Bool

jump_to_state

</> 
pub fn jump_to_state(
  game: Game,
  current: state.State,
) -> Result(Game, error.EngineError)

Replaces the current round state. Lets you jump around, for things like replay or reconnect.

</> 
pub fn legal_actions(game: Game) -> List(action.Action)
</> 
pub fn legal_reactions(
  game: Game,
  reactor: player.Player,
) -> List(reaction.Reaction)

new

</> 
pub fn new(ruleset: rules.Ruleset, points: List(Int)) -> Game

Starts a new game with the provided rules and starting points.

new_at

</> 
pub fn new_at(
  ruleset: rules.Ruleset,
  points: List(Int),
  round_id: boundary.RoundId,
  pot: Int,
) -> Game

Starts a game with rules, points, and additionally a round ID, and pot. Mostly there so you can “jump” to a specific round in progress, perhaps when reconstructing a game from nothing.

new_default

</> 
pub fn new_default() -> Game

pending_action

</> 
pub fn pending_action(game: Game) -> option.Option(action.Action)

points

</> 
pub fn points(game: Game) -> List(Int)

pot

</> 
pub fn pot(game: Game) -> Int

register_action

</> 
pub fn register_action(
  game: Game,
  act: action.Action,
) -> Result(Game, error.EngineError)

Small wrapper over engine.register_action.

register_reaction

</> 
pub fn register_reaction(
  game: Game,
  reactor: player.Player,
  reaction: reaction.Reaction,
) -> Result(Game, error.EngineError)

Small wrapper over engine.register_reaction.

round_begin

</> 
pub fn round_begin(
  game: Game,
) -> option.Option(boundary.RoundBegin)

round_end

</> 
pub fn round_end(game: Game) -> option.Option(boundary.RoundEnd)

round_history

</> 
pub fn round_history(
  game: Game,
) -> option.Option(history.RoundHistory)

round_id

</> 
pub fn round_id(game: Game) -> boundary.RoundId

ruleset

</> 
pub fn ruleset(game: Game) -> rules.Ruleset

start_round

</> 
pub fn start_round(
  game: Game,
  wall: wall.Wall,
) -> Result(Game, GameError)

Starts the current round with the supplied (already shuffled) wall.

status

</> 
pub fn status(game: Game) -> GameStatus

step

</> 
pub fn step(
  game: Game,
) -> Result(GameStepOutcome, error.EngineError)

Advances the round by one turn. When the round ends, updates points, pot, round id, and status for the next round.

✨ Search Document