Backgammon Classic: Moves Calculation Logic

Source files

Other files

Usage

In general, you need only to require main.js which provides a function for calculation. Then provide gid, state, and params to get a result. Please see for example calc.js (used for demo).

Basic example

/* Create function to get output */

const Board = require('./board')

const boardState = async (gid, state, params) => {
    const board = new Board(gid, state, params)
    await board.defMoves()
    return board.output
})

/* OR simply require main.js  */
const boardState = require('<path to main.js>')

/* Get actual state and send it to client */
const result = boardState(gid, state, params)

// ... do something with `result` ...

Position numbers

Note that position numbers here are used for calculation purposes only: the start is #1 and the end is #24. Blacks' drop-zone is #0 and whites' drop-zone is #25. If desired, these position numbers may be changed/converted after obtaining board output. If so, input to calculation should be re-converted too (pieces only).

Classes (prototypes)

Board

This is a core for calculation. The instance of the Board class is instantiated per request. It allows providing a state for each calculation making whole calculation process versatile. Also, due to the Board being stateless, it does calculations according to the provided state and parameters. For example, a state can be retrieved from a database in case of accidental disconnection.

In the normal way, the state should be seen as a snapshot of the board on client side and client-server communication can be as follows:

1. Client receives initial board state, i. e. all pieces are on respective heads. To obtain such initial state instantiate Board with no dice points;
2. A user does some moves: the modified state is sent for calculation;
3. The new Board instance is instantiated on the server with the actual state and calculations are performed;
4. A client receives an updated state with data on pieces and moves.

If no dice points are provided, heads will be set, i. e. all white pieces will be on position #1, and all black pieces will be on position #13 (for white color player view).
To get calculation results, use Board.output getter, which has the following properties:

Board output respects the view of each player and is suitable for immediate display. It means, for instance, that a white color player will see the 'home' of a black player as positions starting at #7 and a black color player will see his own 'home' starting at position #19.

Board.output.pieces
The structure of pieces exposed to output is as follows:

{
    '<user id #1>': { /* This is sutable for user #1 UI display. */
        self: Object{ '<piece ID>': Piece },
        opp: Object{ '<piece ID>': Piece } /* user #1 opponent's pieces */
    },

    '<user id #2>': { /* This is sutable for user #2 UI display. */
        self: Object{ '<piece ID>': Piece },
        opp: Object{ '<piece ID>': Piece } /* user #2 opponent's pieces */
    }
}

In Board.output.pieces object there are two representations of board layout, i.e. for each player. Each player piece layout respects the corresponding view: for a white color player the 'head' is on the top-right board section and the 'home' is on the bottom-right board section. At the same time, the black color player will see, for example, the white color player's 'home' at the top-left board section. So board layout is reversed for each player's view.

Piece

Class to work with pieces. The Piece instance is exposed in board output, so can be used for UI purposes. It has the following properties exposed to Board.output:

Position

Class for representing a particular board position. Used for internal purposes only. For more information see source: position.js.

Parameters for calculation

These parameters are passed to the main function (which initializes Board and returns output, i. e. main.js) to produce a result. For usage examples please see calc.js and test.js. A general description is provided below.

gid
Type: String | Number

ID of in-progress game. Can be used to identify the current game and/or retrieve data from database to restore the game state.

state
Type: Object

Includes all information about actual game state which will be used for calculation.

params
Type: Object

All parameters are optional and defaults to false.

Please see the source files for additional information.