Bingo Master Library

The Bingo Master Library offers a unique twist on the classic Bingo game.

• In this version, players compete on randomly generated boards of a chosen size (default: 5x5, with numbers from 1 to size² arranged randomly). - Each player takes turns calling a number, and all players cancel that number on their boards.
• A point is scored for canceling a complete row, column, or diagonal.
• The first player to score points equal to the board size wins the game.
• The library supports customizable board sizes and 2 to board size players (for 5*5 board there an be 2-5 players in a match).

Table of Contents

• Overview
• Bingo Class Functions
• Board Class Functions
• Usage Example

Overview

Features

• The standard board is 5x5.
• Supports 2 to 5 players.
• Custom initialization of boards for saved game states.
• Automated or manual number cancellation.

How the Game Works

• Players take turns calling numbers.
• The board tracks canceled numbers.
• Rows, columns, and diagonals can be canceled. The player who cancels the required numbers first wins.

Bingo Class Functions

constructor(size: number = 5, count: number = 2)

Initializes the game with a given board size and number of players.

• Parameters:

  • size: Size of the board (default: 5).
  • count: Number of players (default: 2).

• Throws Errors:

  • If size is less than 2.
  • If count is less than 2 or greater than size.

getTurn(): number

Returns the current player's turn.

• Example: Player 1 starts the game, returns 0.

getBoards(): number[][][]

Returns all players' boards.

• Example: Used to inspect game boards.

getMyBoard(ind: number): number[][]

Returns the board of a specific player.

• Parameters:
  • ind: Player index (0-based).

getMyCancelCount(ind: number): number

Returns the cancel count for a specific player.

• Parameters:
  • ind: Player index (0-based).

getMyCanceledInfo(ind: number): string[]

Returns canceled rows, columns, or diagonals for a specific player.

• Parameters:
  • ind: Player index (0-based).

getCanceled(): number[]

Returns all canceled numbers so far.

getCancelCounts(): number[]

Returns the cancel counts for all players.

getWinner(): number | null

Returns the index of the winner or null if no one has won yet.

cancelNumber(num: number, turn: number)

Cancels a number for the current player's turn.

• Parameters:

  • num: Number to cancel.
  • turn: Player's turn index.

• Throws Errors:

  • If the game is over.
  • If it’s not the player's turn.
  • If the number is out of range or already canceled.

customInitialize(newBoards: number[][][], newCanceles: number[])

Initializes the game with custom boards and canceled numbers.

• Parameters:
  • newBoards: Array of custom boards for each player.
  • newCanceles: Array of canceled numbers.

Board Class Functions

constructor(size: number)

Creates a new board of the given size.

• Throws Errors:
  • If the size is less than 2.

getData(): number[][]

Returns the current board data.

getCancelCount(): number

Returns the count of canceled rows, columns, or diagonals.

getCanceldInfo(): string[]

Returns a list of canceled rows, columns, and diagonals.

cancelNumber(num: number): number

Cancels a specific number and updates the board state.

• Parameters:
  • num: Number to cancel.

customInitialize(newBoard: number[][], newCanceles: number[]): number

Reinitializes the board with a custom setup.

• Parameters:
  • newBoard: Custom board configuration.
  • newCanceles: Array of numbers to cancel.

Usage Example

Here is a complete example of a game between two players using a 3x3 board:

import { Bingo } from "bingo-master";

// Initialize a 3x3 Bingo game for 2 players
const game = new Bingo(3, 2);

// Player 1 and Player 2 boards
console.log("Player 1 Board:", game.getMyBoard(0));
console.log("Player 2 Board:", game.getMyBoard(1));

// Player 1 cancels a number
const turn = game.getTurn();
console.log("Turn:", turn); // Should be 0 (Player 1)

try {
  game.cancelNumber(5, turn); // Player 1 cancels number 5
  console.log("Canceled Numbers:", game.getCanceled());
} catch (err) {
  console.error(err.message);
}

// Player 2 cancels a number
const nextTurn = game.getTurn();
console.log("Turn:", nextTurn); // Should be 1 (Player 2)

try {
  game.cancelNumber(3, nextTurn); // Player 2 cancels number 3
  console.log("Canceled Numbers:", game.getCanceled());
} catch (err) {
  console.error(err.message);
}

// Check if there is a winner
const winner = game.getWinner();
if (winner !== null) {
  console.log(`Player ${winner + 1} wins!`);
} else {
  console.log("No winner yet, keep playing!");
}

Additional Notes

• Default Board Size: 5x5.
• Default Players: 2.
• The game ends when a player cancels an entire row, column, or diagonal.
• Use customInitialize to resume a game from a saved state.