Five Hundred v0.1.0

View Source FiveHundred.Game (Five Hundred v0.1.0)

Models a game of 500

TODO:

  • score

Link to this section Summary

Types

game_code()
state()
t()

Functions

advance_turn(game)
bid(game, playerBid)
bid_advance(game)
ensure_bid_is_higher(game, playerBid)
ensure_bidding(game)
ensure_can_bid(game, player_index)
ensure_last_winner_has_bid_first(game, player_bid)
ensure_turn(game, player_index)
exclude_from_bidding(game, player_index)
game_code(length \\ 5)
get_player(game, id)
join_game(game, player)
new_game(player, game_code, max_players \\ 4)
pass(game, player_index)
ready_for_bidding?(arg)
set_winning_bid(game, playerBid)

Link to this section Types

Link to this type

game_code()

View Source 
@type game_code() :: String.t()
Link to this type

state()

View Source 
@type state() :: :bidding | :playing | :waiting_for_players | :finished
Link to this type

t()

View Source 
@type t() :: %FiveHundred.Game{
  bid_exclusion: [FiveHundred.Player.t()],
  game_code: nil | game_code(),
  last_round_winner: nil | integer(),
  max_players: integer(),
  players: [FiveHundred.Player.t()],
  state: state(),
  turn: nil | integer(),
  winning_bid: nil | FiveHundred.PlayerBid.t()
}

Link to this section Functions

Link to this function

advance_turn(game)

View Source 
@spec advance_turn(t()) :: {:ok, t()}
Link to this function

bid(game, playerBid)

View Source 
@spec bid(t(), FiveHundred.PlayerBid.t()) ::
  {:ok,
   %FiveHundred.Game{
     bid_exclusion: term(),
     game_code: term(),
     last_round_winner: term(),
     max_players: term(),
     players: term(),
     state: term(),
     turn: term(),
     winning_bid: term()
   }}
  | {:error,
     :last_round_winner_must_bid_first
     | :not_bidding
     | :bid_not_high_enough
     | :cannot_bid}
Link to this function

bid_advance(game)

View Source 
@spec bid_advance(t()) :: {:ok, t()} | {:error, :not_bidding}
Link to this function

ensure_bid_is_higher(game, playerBid)

View Source 
@spec ensure_bid_is_higher(t(), FiveHundred.PlayerBid.t()) ::
  {:ok, t()} | {:error, :bid_not_high_enough}
Link to this function

ensure_bidding(game)

View Source 
@spec ensure_bidding(t()) :: {:ok, t()} | {:error, :not_bidding}
Link to this function

ensure_can_bid(game, player_index)

View Source 
@spec ensure_can_bid(t(), integer()) :: {:ok, t()} | {:error, atom()}
Link to this function

ensure_last_winner_has_bid_first(game, player_bid)

View Source 
@spec ensure_last_winner_has_bid_first(t(), %FiveHundred.PlayerBid{
  bid: term(),
  player_index: term()
}) ::
  {:ok, t()} | {:error, :last_round_winner_bid_first}
Link to this function

ensure_turn(game, player_index)

View Source 
@spec ensure_turn(t(), integer()) :: {:ok, t()} | {:error, :not_your_turn}
Link to this function

exclude_from_bidding(game, player_index)

View Source 
@spec exclude_from_bidding(t(), integer()) :: {:ok, t()} | {:error, atom()}
Link to this function

game_code(length \\ 5)

View Source 
@spec game_code(integer()) :: String.t()
Link to this function

get_player(game, id)

View Source 
@spec get_player(t(), String.t()) :: {:ok, String.t()} | {:error, atom()}
Link to this function

join_game(game, player)

View Source 
@spec join_game(t(), FiveHundred.Player.t()) :: {:ok, t()} | {:error, :max_players}
Link to this function

new_game(player, game_code, max_players \\ 4)

View Source
Link to this function

pass(game, player_index)

View Source 
@spec pass(t(), integer()) :: {:ok, t()} | {:error, :not_your_turn | :not_bidding}
Link to this function

ready_for_bidding?(arg)

View Source 
@spec ready_for_bidding?({:ok, t()}) :: {:ok, t()}
Link to this function

set_winning_bid(game, playerBid)

View Source 
@spec set_winning_bid(t(), FiveHundred.PlayerBid.t()) :: {:ok, t()} | {:error, atom()}