Game.H2048.Core

This module is considered internal. Clients should use Game.H2048.Gameplay instead.

Documentation

type Coord = (Int, Int)

Zero-based (rowIndex, colIndex).

type Coords = [Coord]

List of Coord. This list is usually a complete row or column in the game board.

type CoordsGroup = [Coords]

List of Coords, expected to exact-cover the game board.

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 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.

newtype Cell

An obscure data type that wraps CellTier.

Constructors

Cell

Fields

• _cTier :: CellTier

  Tier of this cell.

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

type Distrib' a = Vector (a, Int)

The same as Distrib except parameterized on the value type.

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.

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.

randomPick :: Distrib' a -> TFGen -> (a, TFGen)

Pick a value randomly following the distribution as specified by the argument.

allCoords :: GameRule -> Coords

Return a unique, sorted list of all coordinations of a board.

applyMove :: GameRule -> Dir -> GameBoard -> Maybe (GameBoard, Int)

Apply a game move on a board. This operation fails if and only if the move results in no change to the game board.

possibleMoves :: GameRule -> GameBoard -> [(Dir, (GameBoard, Int))]

Return possible moves that can be performed on current board.

unsafeIntToCell :: Int -> Cell

Convert an integer to Cell, the input is expected to be a power of 2 but no check is enforced.

Given that standard game is based on powers of 2, it makes sense that we implement some direct support for it.

intToCell :: Int -> Maybe Cell

Safely convert a power of two into Cell.

cellToInt :: Cell -> Int

Convert Cell back into a power of 2.

standardGameRule :: GameRule

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

merge :: Cell -> Cell -> Maybe Cell

Attempt to merge two Cell s.

Only successful when two Cells are equal, resulting in a new Cell with tier increased by 1.

mergeWithScore :: GameRule -> Cell -> Cell -> Maybe (Cell, Int)

Merge two cells with a reward as specified by GameRule.

mergeLine :: GameRule -> [Cell] -> ([Cell], Int)

Merge a single line of cells, return the resulting line and scores awarded according to the GameRule.

dirToCoordsGroups :: GameRule -> Dir -> CoordsGroup

Given a game move, return rows or columns of Coords that forms the complete board.

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.

testDistrib :: Int -> [(Int, Int)] -> IO ()

Repeat the process of randomly picking elements following a distribution in IO.

This function is exported just for manual testing.

isAlive :: GameRule -> GameBoard -> Bool

A current game is consider "alive" when there are at least one valid move for the current board.

Note that since a GameBoard can be newly initiate as empty Map, it is not "alive" by definition.