Game.Deterministic.GameEngine

Library for creating simple deterministic games, such as tic-tac-toe. The engine requires a minimal set of actions related to the game, and then will run the game until a terminal state is reached.

Simple generic example below. See the specs for a more detailed example.

import Game.Deterministic.GameEngine

game :: Monad m => GameEngine m [Char] [(Int, Char)]
game = GameEngine gameActions initialState

gameActions :: Monad m => GameActions m [Char] [(Int, Char)]
gameActions = GameActions {
   getPlayer  = -- find the next player from a game state,
   getMove    = -- find a move from the game state,
   getResult  = -- transitions from a state to another state,
   isTerminal = -- determines if the game is terminal,
   getScore   = -- get score from a terminal state
 }

initialState :: GameState [Char]
initialState = GameState ['x', 'x', 'x']

-- run the game engine until a terminal state is reached
playSimple game

Documentation

data GameActions m a b

Set of actions that defines how the game will be played

Constructors

GameActions

Fields

getPlayer :: GameState a -> m Player

Specifies which player has the move in the state

getMove :: GameState a -> m (Move b)

Returns a legal move in the state

getResult :: GameState a -> Move b -> m (GameState a)

The transition model, which determines the result of a move

isTerminal :: GameState a -> m Bool

True if game is over, False otherwise

getScore :: GameState a -> Player -> m Int

A utility function to determine the numeric value for a game that ends in a terminal state

data GameState a

Constructors

GameState a

Instances

Eq a => Eq (GameState a)

Show a => Show (GameState a)

data Move a

Constructors

Move a

Instances

Eq a => Eq (Move a)

Show a => Show (Move a)

data Player

Constructors

Player String

Instances

Eq Player

Show Player

data GameEngine m a b

Holds information about how the game is played, and the current state of the game.

Constructors

GameEngine

Fields

gameEngineActions :: GameActions m a b

Defines how the game will be played

gameEngineState :: GameState a

The current state of the game

play :: Monad m => GameEngine m a b -> m Int

Run the provided game engine under a monadic context until a terminal state is reached.

playSimple :: GameEngine Identity a b -> Int

Run the provided game engine without a context until a terminal state is reached.

playIO :: GameEngine IO a b -> IO Int

Run the provided game engine within an IO context until a terminal state is reached.