Game.H2048.Gameplay

Game implementation on top of Game.H2048.Core. This module is formally the API for this package, please avoid using Game.H2048.Core directly if possible.

Documentation

data Gameplay

A Gameplay is an obscure data type to keep track of information necessary for a single game play. Its fields can be accessed through functions with _gp prefix.

_gpRule :: Gameplay -> GameRule

Encodes rule of this game. This field must not change after creation.

_gpScore :: Gameplay -> Int

Total score currently collected.

_gpBoard :: Gameplay -> GameBoard

The Game board. If this field is an empty map, that means the game is not yet started.

_gpGen :: Gameplay -> TFGen

Random generator.

randomOp :: (TFGen -> (a, TFGen)) -> Gameplay -> (a, Gameplay)

Lift a function that mutates a TFGen to produce some results to work on Gameplay.

mkGameplay :: TFGen -> GameRule -> Gameplay

Create a Gameplay. Note that the return value must be passed to newGame before it can accept any game moves.

The purpose of this two-step approach (i.e. mkGameplay then newGame) is to separate data type creation from the effect of mutating random generator, which is required at the beginning of a game.

spawnNewCell :: Gameplay -> Set Coord -> Maybe (((Coord, Cell), Set Coord), Gameplay)

spawnNewCell gameplay emptyCells picks an empty cell from emptyCells, and assign it with a cell value. The operation will fail if and only if emptyCells is empty.

Upon successful return, the value wrapped in Just is (sepResult, gameplay') where sepResult indicates coordinate and cell value chosen, and remaining part of emptyCells.

The reason for explicitly passing emptyCells on this operation is to make it easier to pick multiple cells while not touching most parts of Gameplay. In fact you can expect this operation to only mutate the TFGen inside Gameplay.

type GameBoard = Map Coord Cell

A GameBoard is a map from coordinates to Cells for a game.

Note that the map could be empty to indicate that a new game is not started yet.

type CellTier = Int

A CellTier is simply a positive Int. Every time two cell merges, the tier of the resulting cell increases by one relative to cell tier prior to the merge.

data Cell

An obscure data type that wraps CellTier.

Instances

Eq Cell

Defined in Game.H2048.Core

Methods

(==) :: Cell -> Cell -> Bool

(/=) :: Cell -> Cell -> Bool

Ord Cell

Defined in Game.H2048.Core

Methods

compare :: Cell -> Cell -> Ordering

(<) :: Cell -> Cell -> Bool

(<=) :: Cell -> Cell -> Bool

(>) :: Cell -> Cell -> Bool

(>=) :: Cell -> Cell -> Bool

max :: Cell -> Cell -> Cell

min :: Cell -> Cell -> Cell

Show Cell

Defined in Game.H2048.Core

Methods

showsPrec :: Int -> Cell -> ShowS

show :: Cell -> String

showList :: [Cell] -> ShowS

_cTier :: Cell -> CellTier

Tier of this cell.

data Dir

Moves that a user could do.

Constructors

DUp

DDown

DLeft

DRight

Instances

Bounded Dir

Defined in Game.H2048.Core

Methods

minBound :: Dir

maxBound :: Dir

Enum Dir

Defined in Game.H2048.Core

Methods

succ :: Dir -> Dir

pred :: Dir -> Dir

toEnum :: Int -> Dir

fromEnum :: Dir -> Int

enumFrom :: Dir -> [Dir]

enumFromThen :: Dir -> Dir -> [Dir]

enumFromTo :: Dir -> Dir -> [Dir]

enumFromThenTo :: Dir -> Dir -> Dir -> [Dir]

Eq Dir

Defined in Game.H2048.Core

Methods

(==) :: Dir -> Dir -> Bool

(/=) :: Dir -> Dir -> Bool

Ord Dir

Defined in Game.H2048.Core

Methods

compare :: Dir -> Dir -> Ordering

(<) :: Dir -> Dir -> Bool

(<=) :: Dir -> Dir -> Bool

(>) :: Dir -> Dir -> Bool

(>=) :: Dir -> Dir -> Bool

max :: Dir -> Dir -> Dir

min :: Dir -> Dir -> Dir

Show Dir

Defined in Game.H2048.Core

Methods

showsPrec :: Int -> Dir -> ShowS

show :: Dir -> String

showList :: [Dir] -> ShowS

type Distrib = Distrib' Int

A Distrib is a non-empty Vector whose each element (a,b) satisfies:

• a, when taken in sequence, is positive and strictly increasing.
• b, when taken in sequence, is strictly increasing.

Think this data type as a precomputation result for making weighted random choice.

You can use computeDistrib to generate a value of this.

data GameRule

A data type for encoding game rules that do not necessarily needs to be hard-coded into core logic.

You can use standardGameRule for a standard game rule, or make changes using it as the base.

Constructors

GameRule

Fields

• _grDim :: (Int, Int)

  Dimension of the board. (numOfRows, numOfCols)

• _grMergeAward :: CellTier -> Int

  Score awarded given CellTier before the merge has happened.

• _grNewCellDistrib :: Distrib

  Stores precomputation result that encodes distribution of tiers of newly spawned cells.

• _grInitSpawn :: Int

  How many initial cells should be spawned when starting the game.

  Note this value should not exceed number of cells that the board can contain.

• _grHasWon :: Int -> GameBoard -> Bool

  A predicate to tell whether the current game has been won.

newGame :: Gameplay -> Gameplay

Initialize a Gameplay so that it's ready to play.

This function should only fail when its GameRule dictates too many initial cells for the whole board to contain.

stepGame :: Dir -> Gameplay -> Maybe Gameplay

stepGame d gp tries to apply move d on current state of the game gp, returns:

• Nothing if this move is invalid (failed to apply the move).
• Just moves if this move is valid, also returns all possible moves after the board is fully updated (meaning new cell has been spawned).

standardGameRule :: GameRule

The standard game rule. This value can be used as a base for customized game rules.

hasWon :: Gameplay -> Bool

Whether the Gameplay should be considered already won. Queries GameRule embeded in Gameplay.

isAlive :: Gameplay -> Bool

A Gameplay is considered alive if and only if there are still possible moves.

cellToInt :: Cell -> Int

Convert Cell back into a power of 2.

intToCell :: Int -> Maybe Cell

Safely convert a power of two into Cell.

computeDistrib :: IntMap Int -> Distrib

Computes Distrib for weighted random cell tier spawns.

The input must be a non-empty map from cell tiers to their corresponding weight. All weights must be positive.