trucoshi 0.0.2 → 0.0.5

package/src/lib/classes/Table.ts

@@ -0,0 +1,32 @@
+import { GAME_ERROR, TEAM_SIZE_VALUES } from "../constants"
+import { IPlayer, ITable, ITeam } from "../types"
+import { Match } from "./Match"
+import { Player } from "./Player"
+import { Team } from "./Team"
+
+export function Table(players: Array<IPlayer>, teams: Array<ITeam>): ITable {
+  const table: ITable = {
+    players,
+    cards: [],
+    forehandIdx: 0,
+    nextTurn() {
+      if (table.forehandIdx < table.players.length - 1) {
+        table.forehandIdx++
+      } else {
+        table.forehandIdx = 0
+      }
+      return table.player()
+    },
+    getPlayerPosition(id) {
+      return table.players.findIndex((p) => p.id === id)
+    },
+    player(idx) {
+      if (idx !== undefined) {
+        return table.players[idx]
+      }
+      return table.players[table.forehandIdx]
+    },
+  }
+
+  return table
+}

package/src/lib/classes/Team.ts

@@ -0,0 +1,41 @@
+import { IPlayer, ITeam } from "../types"
+
+export function Team(players: Array<IPlayer>) {
+  const team: ITeam = {
+    _players: new Map<string, IPlayer>(),
+    get players() {
+      return Array.from(team._players.values())
+    },
+    points: {
+      buenas: 0,
+      malas: 0,
+      winner: false,
+    },
+    isTeamDisabled() {
+      return team.players.reduce((prev, curr) => prev && curr.disabled, true)
+    },
+    disable(player) {
+      team._players.get(player.id)?.disable()
+      return team.isTeamDisabled()
+    },
+    addPoints(matchPoint, points) {
+      const malas = team.points.malas + points
+      const diff = malas - matchPoint
+      if (diff > 0) {
+        team.points.malas = matchPoint
+        team.points.buenas += diff
+        if (team.points.buenas >= matchPoint) {
+          team.points.winner = true
+        }
+      } else {
+        team.points.malas = malas
+      }
+
+      return team.points
+    },
+  }
+
+  players.forEach((player) => team._players.set(player.id, player))
+
+  return team
+}

package/src/lib/classes/Truco.ts

@@ -0,0 +1,72 @@
+import { ITruco } from "../types"
+
+export function Truco() {
+  function* trucoAnswerGeneratorSequence() {
+    let i = 0
+    while (i < truco.players.length && truco.answer === null) {
+      const player = truco.players[truco.turn]
+      truco.setCurrentPlayer(player)
+      if (player.disabled) {
+        truco.setCurrentPlayer(null)
+      }
+
+      if (truco.turn >= truco.players.length - 1) {
+        truco.setTurn(0)
+      } else {
+        truco.setTurn(truco.turn + 1)
+      }
+
+      i++
+
+      yield truco
+    }
+    yield truco
+  }
+
+  const truco: ITruco = {
+    turn: 0,
+    state: 1,
+    teamIdx: null,
+    answer: null,
+    currentPlayer: null,
+    generator: trucoAnswerGeneratorSequence(),
+    players: [],
+    sayTruco(teamIdx, players) {
+      truco.teamIdx = teamIdx
+      truco.answer = null
+      truco.players = players
+      truco.generator = trucoAnswerGeneratorSequence()
+      return truco
+    },
+    setPlayers(players) {
+      truco.players = players
+    },
+    setAnswer(answer) {
+      if (answer) {
+        truco.state++
+      }
+      if (answer !== null) {
+        truco.teamIdx = null
+      }
+      truco.answer = answer
+      return truco
+    },
+    setTeam(idx: 0 | 1) {
+      truco.teamIdx = idx
+      return truco.teamIdx
+    },
+    setTurn(turn) {
+      truco.turn = turn
+      return truco.turn
+    },
+    setCurrentPlayer(player) {
+      truco.currentPlayer = player
+      return truco.currentPlayer
+    },
+    getNextPlayer() {
+      return truco.generator.next()
+    },
+  }
+
+  return truco
+}

package/src/lib/constants.ts

@@ -1,14 +1,108 @@
+import {
+  EEnvidoCommand,
+  ESayCommand,
+  IEnvidoCalculator,
+  IEnvidoCalculatorArgs,
+  ITeam,
+  TeamPoints,
+} from "./types"
+import { getMaxNumberIndex } from "./utils"
+
 export const CARDS = {
-    '1e': 14, '1b': 13, '7e': 12, '7o': 11,
-    '3e': 10, '3o': 10, '3b': 10, '3c': 10,
-    '2e': 9, '2o': 9, '2b': 8, '2c': 8,
-    '1o': 7, '1c': 7, 're': 6, 'ro': 6,
-    'rb': 6, 'rc': 6, 'ce': 5, 'co': 5,
-    'cb': 5, 'cc': 5, 'pe': 4, 'po': 4,
-    'pb': 4, 'pc': 4, '7b': 3, '7c': 3,
-    '6e': 2, '6o': 2, '6b': 2, '6c': 2,
-    '5e': 1, '5o': 1, '5b': 1, '5c': 1,
-    '4e': 0, '4o': 0, '4b': 0, '4c': 0
+  "1e": 14,
+  "1b": 13,
+  "7e": 12,
+  "7o": 11,
+  "3e": 10,
+  "3o": 10,
+  "3b": 10,
+  "3c": 10,
+  "2e": 9,
+  "2o": 9,
+  "2b": 8,
+  "2c": 8,
+  "1o": 7,
+  "1c": 7,
+  re: 6,
+  ro: 6,
+  rb: 6,
+  rc: 6,
+  ce: 5,
+  co: 5,
+  cb: 5,
+  cc: 5,
+  pe: 4,
+  po: 4,
+  pb: 4,
+  pc: 4,
+  "7b": 3,
+  "7c": 3,
+  "6e": 2,
+  "6o": 2,
+  "6b": 2,
+  "6c": 2,
+  "5e": 1,
+  "5o": 1,
+  "5b": 1,
+  "5c": 1,
+  "4e": 0,
+  "4o": 0,
+  "4b": 0,
+  "4c": 0,
+}
+
+export const COLORS = [
+  "#9b111",
+  "#17c6c6",
+  "#8c1d1d",
+  "#9f9b9b",
+  "#a5a5a5",
+  "#f5a623",
+  "#f44336",
+  "#c2185b",
+]
+
+export const TEAM_SIZE_VALUES = [1, 2, 3]
+
+export enum GAME_ERROR {
+  UNEXPECTED_TEAM_SIZE = 'UNEXPECTED_TEAM_SIZE',
+  TEAM_NOT_READY = 'TEAM_NOT_READY',
+  TEAM_IS_FULL = 'TEAM_IS_FULL',
 }
 
-export const COLORS = ["#9b111", "#17c6c6", "#8c1d1d", "#9f9b9b", "#a5a5a5", "#f5a623", "#f44336", "#c2185b"];
+export const EnvidoCalculator: IEnvidoCalculator = {
+  [EEnvidoCommand.ENVIDO]: () => ({
+    accept: 2,
+    decline: 1,
+    next: [EEnvidoCommand.ENVIDO_ENVIDO, EEnvidoCommand.REAL_ENVIDO, EEnvidoCommand.FALTA_ENVIDO],
+  }),
+  [EEnvidoCommand.ENVIDO_ENVIDO]: () => ({
+    accept: 4,
+    decline: 2,
+    next: [EEnvidoCommand.REAL_ENVIDO, EEnvidoCommand.FALTA_ENVIDO],
+  }),
+  [EEnvidoCommand.REAL_ENVIDO]: () => ({
+    accept: 3,
+    decline: 1,
+    next: [EEnvidoCommand.FALTA_ENVIDO],
+  }),
+  [EEnvidoCommand.FALTA_ENVIDO]: (args) => {
+    if (!args || !args.teams || !args.matchPoint) {
+      return {
+        accept: 1,
+        decline: 1,
+        next: [],
+      }
+    }
+    const { teams, matchPoint } = args
+    const totals = teams.map((team) => team.points.malas + team.points.buenas)
+    const higher = getMaxNumberIndex(totals)
+    const points = teams[higher].points
+    const accept = points.buenas > 0 ? matchPoint - points.buenas : matchPoint - points.malas
+    return {
+      accept,
+      decline: 2,
+      next: [],
+    }
+  },
+}

package/src/lib/index.ts

@@ -0,0 +1,135 @@
+import { Match } from "./classes/Match"
+import { Player } from "./classes/Player"
+import { Table } from "./classes/Table"
+import { Team } from "./classes/Team"
+import { GAME_ERROR, TEAM_SIZE_VALUES } from "./constants"
+import { EHandState, IMatch, IPlayInstance, IPrivateTrucoshi, ITeam, ITrucoshi } from "./types"
+
+export type IWinnerCallback = (winner: ITeam, teams: [ITeam, ITeam]) => Promise<void>
+export type ITurnCallback = (play: IPlayInstance) => Promise<void>
+export type ITrucoCallback = (play: IPlayInstance) => Promise<void>
+
+export interface IGameLoop {
+  _onTruco: ITrucoCallback
+  _onTurn: ITurnCallback
+  _onWinner: IWinnerCallback
+  onTurn: (callback: ITurnCallback) => IGameLoop
+  onWinner: (callback: IWinnerCallback) => IGameLoop
+  onTruco: (callback: ITrucoCallback) => IGameLoop
+  begin: () => void
+}
+
+const GameLoop = (match: IMatch) => {
+  let gameloop: IGameLoop = {
+    _onTruco: () => Promise.resolve(),
+    _onTurn: () => Promise.resolve(),
+    _onWinner: () => Promise.resolve(),
+    onTruco: (callback: ITrucoCallback) => {
+      gameloop._onTruco = callback
+      return gameloop
+    },
+    onTurn: (callback: ITurnCallback) => {
+      gameloop._onTurn = callback
+      return gameloop
+    },
+    onWinner: (callback: IWinnerCallback) => {
+      gameloop._onWinner = callback
+      return gameloop
+    },
+    async begin() {
+      while (!match.winner) {
+        const play = match.play()
+
+        if (!play || !play.player) {
+          continue
+        }
+
+        if (play.state === EHandState.WAITING_FOR_TRUCO_ANSWER) {
+          await gameloop._onTruco(play)
+          continue
+        }
+
+        if (play.state === EHandState.WAITING_PLAY) {
+          await gameloop._onTurn(play)
+          continue
+        }
+      }
+
+      await gameloop._onWinner(match.winner, match.teams)
+    },
+  }
+
+  return gameloop
+}
+
+export function Trucoshi(teamSize?: 1 | 2 | 3) {
+  const trucoshi: IPrivateTrucoshi = {
+    lastTeamIdx: 1,
+    _players: new Map(),
+    get players() {
+      return Array.from(trucoshi._players.values())
+    },
+    teams: [],
+    table: null,
+    maxPlayers: teamSize ? teamSize * 2 : 6,
+    full: false,
+    ready: false,
+    calculateReady() {
+      trucoshi.ready = trucoshi.players.reduce((prev, curr) => prev && curr.ready, true)
+      return trucoshi.ready
+    },
+    calculateFull() {
+      trucoshi.full = trucoshi._players.size >= trucoshi.maxPlayers
+      return trucoshi.full
+    },
+    addPlayer(id, teamIdx) {
+      const maxSize = teamSize ? teamSize : 3
+      if (trucoshi.full || trucoshi.players.filter((p) => p.teamIdx === teamIdx).length > maxSize) {
+        throw new Error(GAME_ERROR.TEAM_IS_FULL)
+      }
+      const player = Player(id, teamIdx !== undefined ? teamIdx : Number(!trucoshi.lastTeamIdx))
+      trucoshi.lastTeamIdx = Number(!trucoshi.lastTeamIdx) as 0 | 1
+      trucoshi._players.set(id, player)
+      trucoshi.calculateFull()
+      trucoshi.calculateReady()
+      return player
+    },
+    removePlayer(id) {
+      trucoshi._players.delete(id)
+      trucoshi.calculateFull()
+      trucoshi.calculateReady()
+      return trucoshi
+    },
+    startMatch(matchPoint = 9) {
+      trucoshi.calculateReady()
+      const teamSize = trucoshi._players.size / 2
+
+      if (!TEAM_SIZE_VALUES.includes(teamSize)) {
+        throw new Error(GAME_ERROR.UNEXPECTED_TEAM_SIZE)
+      }
+
+      if (!trucoshi.ready) {
+        throw new Error(GAME_ERROR.TEAM_NOT_READY)
+      }
+
+      trucoshi.teams.push(Team(trucoshi.players.filter((p) => p.teamIdx === 0)))
+      trucoshi.teams.push(Team(trucoshi.players.filter((p) => p.teamIdx === 1)))
+
+      if (
+        trucoshi.teams[0].players.length !== teamSize ||
+        trucoshi.teams[1].players.length !== teamSize
+      ) {
+        throw new Error(GAME_ERROR.UNEXPECTED_TEAM_SIZE)
+      }
+
+      trucoshi.table = Table(trucoshi.players, trucoshi.teams)
+      return GameLoop(Match(trucoshi.table, trucoshi.teams, matchPoint))
+    },
+  }
+
+  return {
+    addPlayer: trucoshi.addPlayer,
+    removePlayer: trucoshi.removePlayer,
+    startMatch: trucoshi.startMatch,
+  }
+}

package/src/lib/types.ts

@@ -1,110 +1,216 @@
+import { IGameLoop } from "."
 import { CARDS } from "./constants"
 
 export type ICard = keyof typeof CARDS
 
 export interface IDeck {
-    cards: Array<ICard>
-    usedCards: Array<ICard>
-    takeCard(): ICard
-    shuffle(): IDeck
+  cards: Array<ICard>
+  usedCards: Array<ICard>
+  takeCard(): ICard
+  shuffle(): IDeck
 }
 
 export interface IPlayedCard {
-    player: IPlayer
-    card: ICard
+  player: IPlayer
+  card: ICard
 }
 
 export interface IPlayer {
-    teamIdx: number
-    id: string
-    hand: Array<ICard>,
-    usedHand: Array<ICard>
-    setHand(hand: Array<ICard>): Array<ICard>
-    useCard(idx: number): ICard | null
+  teamIdx: number
+  id: string
+  hand: Array<ICard>
+  commands: Array<ECommand>
+  usedHand: Array<ICard>
+  disabled: boolean
+  ready: boolean
+  enable(): void
+  disable(): void
+  setReady(ready: boolean): void
+  setHand(hand: Array<ICard>): Array<ICard>
+  useCard(idx: number): ICard | null
 }
 
 export interface ITeam {
-    color: string
-    _players: Map<string, IPlayer>
-    players: Array<IPlayer>
-    points: number
-    addPoints(points: number): number
+  _players: Map<string, IPlayer>
+  players: Array<IPlayer>
+  points: TeamPoints
+  isTeamDisabled(): boolean
+  disable(player: IPlayer): boolean
+  addPoints(matchPoint: number, points: number): TeamPoints
 }
 
 export interface IMatch {
-    teams: [ITeam, ITeam]
-    hands: Array<IHand>
-    winner: ITeam | null
-    currentHand: IHand | null
-    table: ITable
-    play(): IPlayInstance | undefined
-    addPoints(points: IPoints): void
-    pushHand(hand: IHand): void
-    setCurrentHand(hand: IHand | null): IHand | null
-    setWinner(winner: ITeam): void
-    getNextTurn(): IteratorResult<IMatch | null, IMatch | null | void>
-}
-
-export type IPoints = {
-    0: number // team 0
-    1: number // team 1
-    2?: number // number of tied rounds
-}
-
-export type IGetNextPlayerResult = { currentPlayer?: IPlayer, currentRound?: IRound, points?: IPoints }
-
-export enum EHandPlayCommand {
-    TRUCO,
-    ENVIDO,
-    ENVIDO_ENVIDO,
-    REAL_ENVIDO,
-    FALTA_ENVIDO,
-    MAZO,
-    FLOR,
-    CONTRAFLOR,
+  teams: [ITeam, ITeam]
+  hands: Array<IHand>
+  winner: ITeam | null
+  currentHand: IHand | null
+  table: ITable
+  play(): IPlayInstance | null
+  addPoints(points: HandPoints): [ITeam, ITeam]
+  pushHand(hand: IHand): void
+  setCurrentHand(hand: IHand | null): IHand | null
+  setWinner(winner: ITeam): void
+  getNextTurn(): IteratorResult<IMatch | null, IMatch | null | void>
+}
+
+export interface TeamPoints {
+  buenas: number
+  malas: number
+  winner: boolean
+}
+
+export interface HandPoints {
+  0: number
+  1: number
+}
+
+export interface RoundPoints {
+  0: number
+  1: number
+  ties: number
+}
+
+export enum ESayCommand {
+  QUIERO = "QUIERO",
+  NO_QUIERO = "NO_QUIERO",
+  TRUCO = "TRUCO",
+  MAZO = "MAZO",
+  FLOR = "FLOR",
+  CONTRAFLOR = "CONTRAFLOR",
+}
+
+export enum EEnvidoCommand {
+  ENVIDO = "ENVIDO",
+  ENVIDO_ENVIDO = "ENVIDO_ENVIDO",
+  REAL_ENVIDO = "REAL_ENVIDO",
+  FALTA_ENVIDO = "FALTA_ENVIDO",
+}
+
+export type ECommand = ESayCommand | EEnvidoCommand
+
+export interface ITruco {
+  state: 1 | 2 | 3 | 4
+  teamIdx: 0 | 1 | null
+  answer: boolean | null
+  turn: number
+  players: Array<IPlayer>
+  currentPlayer: IPlayer | null
+  generator: Generator<ITruco, void, unknown>
+  sayTruco(teamIdx: 0 | 1, players: Array<IPlayer>): ITruco
+  setPlayers(players: Array<IPlayer>): void
+  setAnswer(answer: boolean | null): ITruco
+  setTurn(turn: number): number
+  setTeam(idx: 0 | 1): 0 | 1
+  setCurrentPlayer(player: IPlayer | null): IPlayer | null
+  getNextPlayer(): IteratorResult<ITruco, ITruco | void>
+}
+
+export interface EnvidoState {
+  accept: number
+  decline: number
+  teamIdx: 0 | 1 | null
 }
 
 export interface IPlayInstance {
-    handIdx: number
-    roundIdx: number
-    player: IPlayer | null
-    commands: Array<EHandPlayCommand> | null
-    rounds: Array<IRound> | null
-    use(idx: number): ICard | null
-    say(command: EHandPlayCommand): IHand | null
+  teams: [ITeam, ITeam]
+  handIdx: number
+  roundIdx: number
+  state: EHandState
+  truco: ITruco
+  envido: EnvidoState
+  player: IPlayer | null
+  commands: Array<ECommand> | null
+  rounds: Array<IRound> | null
+  use(idx: number): ICard | null
+  say(command: ECommand): ECommand | null
+}
+
+export enum EHandState {
+  WAITING_PLAY = "WAITING_PLAY",
+  WAITING_FOR_TRUCO_ANSWER = "WAITING_FOR_TRUCO_ANSWER",
+  WAITING_ENVIDO_ANSWER = "WAITING_ENVIDO_ANSWER",
+  FINISHED = "FINISHED",
+}
+
+export type IHandCommands = {
+  [key in ECommand]: (player: IPlayer) => void
 }
 
 export interface IHand {
-    idx: number
-    turn: number
-    finished: boolean
-    points: IPoints
-    rounds: Array<IRound>
-    currentPlayer: IPlayer | null
-    currentRound: IRound | null
-    play(): IPlayInstance
-    pushRound(round: IRound): IRound
-    setTurn(turn: number): IPlayer
-    addPoints(team: 0 | 1, points: number): void
-    setCurrentRound(round: IRound | null): IRound | null
-    setCurrentPlayer(player: IPlayer | null): IPlayer | null
-    setFinished(finshed: boolean): boolean
-    getNextPlayer(): IteratorResult<IHand, IHand | void>
+  idx: number
+  state: EHandState
+  turn: number
+  points: HandPoints
+  truco: ITruco
+  envido: EnvidoState
+  rounds: Array<IRound>
+  _currentPlayer: IPlayer | null
+  get currentPlayer(): IPlayer | null
+  set currentPlayer(player: IPlayer | null)
+  currentRound: IRound | null
+  commands: IHandCommands
+  finished: () => boolean
+  play(): IPlayInstance | null
+  nextTurn(): void
+  use(idx: number): ICard | null
+  pushRound(round: IRound): IRound
+  setTurn(turn: number): IPlayer
+  addPoints(team: 0 | 1, points: number): void
+  disablePlayer(player: IPlayer): void
+  setCurrentRound(round: IRound | null): IRound | null
+  setCurrentPlayer(player: IPlayer | null): IPlayer | null
+  setState(state: EHandState): EHandState
+  getNextPlayer(): IteratorResult<IHand, IHand | void>
+}
+
+export interface IPrivateTrucoshi {
+  lastTeamIdx: 0 | 1
+  _players: Map<string, IPlayer>
+  get players(): Array<IPlayer>
+  teams: Array<ITeam>
+  maxPlayers: number
+  table: ITable | null
+  ready: boolean
+  full: boolean
+  addPlayer(id: string, teamIdx?: 0 | 1): IPlayer
+  removePlayer(id: string): ITrucoshi
+  calculateReady(): boolean
+  calculateFull(): boolean
+  startMatch(matchPoint?: 9 | 12 | 15): IGameLoop
 }
 
+export interface ITrucoshi extends Pick<IPrivateTrucoshi, 'addPlayer' | 'removePlayer' | 'startMatch'> {}
+
 export interface ITable {
-    forehandIdx: number,
-    cards: Array<Array<IPlayedCard>>,
-    players: Array<IPlayer>,
-    nextTurn(): IPlayer,
-    player(idx?: number): IPlayer,
-    getPlayerPosition(id: string): number
+  forehandIdx: number
+  cards: Array<Array<IPlayedCard>>
+  players: Array<IPlayer>
+  nextTurn(): IPlayer
+  player(idx?: number): IPlayer
+  getPlayerPosition(id: string): number
 }
 
 export interface IRound {
-    tie: boolean,
-    winner: IPlayer | null
-    highest: number
-    cards: Array<IPlayedCard>
-    play(playedCard: IPlayedCard): ICard
+  tie: boolean
+  winner: IPlayer | null
+  highest: number
+  cards: Array<IPlayedCard>
+  turn: number,
+  nextTurn(): void
+  use(playedCard: IPlayedCard): ICard
+}
+
+export type IEnvidoCalculatorResult = {
+  accept: number
+  decline: number
+  next: Array<ECommand>
+}
+
+export type IEnvidoCalculatorArgs = {
+  teams: [ITeam, ITeam]
+  matchPoint: number
+}
+
+export type IEnvidoCalculator = {
+  [key in EEnvidoCommand]: (args?: IEnvidoCalculatorArgs) => IEnvidoCalculatorResult
 }