trucoshi 0.0.4 → 0.0.5

package/src/lib/classes/Hand.ts

@@ -6,17 +6,18 @@ import {
   IHand,
   IHandCommands,
   IMatch,
-  IPlayer,
 } from "../types"
 import { checkHandWinner } from "../utils"
 import { PlayInstance } from "./Play"
 import { Round } from "./Round"
+import { Truco } from "./Truco"
 
 export function Hand(match: IMatch, deck: IDeck, idx: number) {
   match.teams.forEach((team) => {
     team.players.forEach((player) => {
       const playerHand = [deck.takeCard(), deck.takeCard(), deck.takeCard()]
       player.setHand(playerHand)
+      player.enable()
       // player.setHand(["5c", "4c", "6c"])
     })
   })
@@ -26,9 +27,7 @@ export function Hand(match: IMatch, deck: IDeck, idx: number) {
     let forehandTeamIdx = match.table.player(hand.turn).teamIdx as 0 | 1
 
     while (currentRoundIdx < 3 && !hand.finished()) {
-      let i = 0
-
-      const round = Round()
+      const round = Round(0)
       hand.setCurrentRound(round)
       hand.pushRound(round)
 
@@ -42,30 +41,45 @@ export function Hand(match: IMatch, deck: IDeck, idx: number) {
         }
       }
 
-      while (i < match.table.players.length) {
+      while (round.turn < match.table.players.length) {
+
+        while (hand.state === EHandState.WAITING_FOR_TRUCO_ANSWER) {
+          const { value } = hand.truco.getNextPlayer()
+          if (value && value.currentPlayer) {
+            console.log({ value: value.currentPlayer })
+            hand.setCurrentPlayer(value.currentPlayer)
+            yield hand
+          }
+        }
+
         const player = match.table.player(hand.turn)
         hand.setCurrentPlayer(player)
-        if (hand.disabledPlayerIds.includes(player.id)) {
+        if (player.disabled) {
           hand.setCurrentPlayer(null)
         }
 
-        if (hand.turn >= match.table.players.length - 1) {
-          hand.setTurn(0)
-        } else {
-          hand.setTurn(hand.turn + 1)
-        }
-
-        i++
-
         yield hand
       }
 
-      const teamIdx = checkHandWinner(hand.rounds, forehandTeamIdx, hand.disabledPlayerIds, match.teams)
+      if (match.teams[0].isTeamDisabled() && match.teams[1].isTeamDisabled()) {
+        hand.setState(EHandState.FINISHED)
+        break
+      }
+
+      let winnerTeamIdx = checkHandWinner(hand.rounds, forehandTeamIdx)
+
+      if (match.teams[0].isTeamDisabled()) {
+        winnerTeamIdx = 1
+      }
+      if (match.teams[1].isTeamDisabled()) {
+        winnerTeamIdx = 0
+      }
 
-      if (teamIdx !== null) {
-        hand.addPoints(teamIdx, hand.truco.state)
+      if (winnerTeamIdx !== null) {
+        hand.addPoints(winnerTeamIdx, hand.truco.state)
         hand.setState(EHandState.FINISHED)
       }
+
       currentRoundIdx++
     }
     yield hand
@@ -81,6 +95,19 @@ export function Hand(match: IMatch, deck: IDeck, idx: number) {
       const { teamIdx } = hand.truco
       if (teamIdx === null || teamIdx !== player.teamIdx) {
         hand.setState(EHandState.WAITING_FOR_TRUCO_ANSWER)
+        hand.truco.sayTruco(player.teamIdx as 0 | 1, match.teams[Number(!player.teamIdx)].players)
+      }
+    },
+    [ESayCommand.QUIERO]: () => {
+      if (hand.state === EHandState.WAITING_FOR_TRUCO_ANSWER) {
+        hand.truco.setAnswer(true)
+        hand.setState(EHandState.WAITING_PLAY)
+      }
+    },
+    [ESayCommand.NO_QUIERO]: (player) => {
+      if (hand.state === EHandState.WAITING_FOR_TRUCO_ANSWER) {
+        hand.truco.setAnswer(false)
+        hand.setState(EHandState.WAITING_PLAY)
       }
     },
     [ESayCommand.FLOR]: () => {},
@@ -96,28 +123,57 @@ export function Hand(match: IMatch, deck: IDeck, idx: number) {
     turn: Number(match.table.forehandIdx),
     state: EHandState.WAITING_PLAY,
     rounds: [],
-    truco: {
-      state: 1,
-      teamIdx: null,
-    },
+    truco: Truco(),
     envido: {
       accept: 1,
       decline: 2,
       teamIdx: null,
     },
     points: [0, 0],
-    disabledPlayerIds: [],
     currentRound: null,
-    currentPlayer: null,
+    _currentPlayer: null,
+    set currentPlayer(player) {
+      hand._currentPlayer = player
+    },
+    get currentPlayer() {
+      if (hand.state === EHandState.WAITING_FOR_TRUCO_ANSWER) {
+        return hand.truco.currentPlayer
+      }
+      return hand._currentPlayer
+    },
     commands,
     play() {
       return PlayInstance(hand, match.teams)
     },
+    use(idx: number) {
+      const player = hand.currentPlayer
+      const round = hand.currentRound
+      if (!player || !round) {
+        return null
+      }
+
+      const card = player.useCard(idx)
+      if (card) {
+        hand.nextTurn()
+        return round.use({ player, card })
+      }
+
+      return null
+    },
+    nextTurn() {
+      if (hand.turn >= match.table.players.length - 1) {
+        hand.setTurn(0)
+      } else {
+        hand.setTurn(hand.turn + 1)
+      }
+
+      hand.currentRound?.nextTurn()
+    },
     getNextPlayer() {
       return roundsGenerator.next()
     },
     disablePlayer(player) {
-      hand.disabledPlayerIds.push(player.id)
+      match.teams[player.teamIdx].disable(player)
     },
     addPoints(team, points) {
       hand.points[team] = hand.points[team] + points
@@ -135,8 +191,8 @@ export function Hand(match: IMatch, deck: IDeck, idx: number) {
       return hand.currentRound
     },
     setCurrentPlayer(player) {
-      hand.currentPlayer = player
-      return hand.currentPlayer
+      hand._currentPlayer = player
+      return hand._currentPlayer
     },
     setState(state) {
       hand.state = state

package/src/lib/classes/Match.ts

@@ -1,9 +1,8 @@
-import { IHand, IMatch, ITeam } from "../types"
+import { IHand, IMatch, ITable, ITeam } from "../types"
 import { Deck } from "./Deck"
 import { Hand } from "./Hand"
-import { Table } from "./Table"
 
-export function Match(teams: Array<ITeam> = [], matchPoint: number = 9): IMatch {
+export function Match(table: ITable, teams: Array<ITeam> = [], matchPoint: number = 9): IMatch {
   const deck = Deck().shuffle()
 
   const size = teams[0].players.length
@@ -47,7 +46,7 @@ export function Match(teams: Array<ITeam> = [], matchPoint: number = 9): IMatch
     winner: null,
     teams: teams as [ITeam, ITeam],
     hands: [],
-    table: Table(teams, size),
+    table,
     currentHand: null,
     play() {
       match.getNextTurn()

package/src/lib/classes/Play.ts

@@ -1,7 +1,6 @@
-import { EEnvidoCommand, ESayCommand, IHand, IPlayInstance, ITeam } from "../types"
+import { EEnvidoCommand, EHandState, ESayCommand, IHand, IPlayInstance, ITeam } from "../types"
 
 export function PlayInstance(hand: IHand, teams: [ITeam, ITeam]) {
-
   const instance: IPlayInstance = {
     state: hand.state,
     teams,
@@ -13,30 +12,19 @@ export function PlayInstance(hand: IHand, teams: [ITeam, ITeam]) {
     commands: [],
     rounds: hand.rounds,
     use(idx) {
-      const player = hand.currentPlayer
-      const round = hand.currentRound
-      if (!player || !round) {
-        return null
-      }
-
-      const card = player.useCard(idx)
-      if (card) {
-        return round.use({ player, card })
-      }
-
-      return null
+      return hand.use(idx)
     },
     say(command) {
-      if (!hand.currentPlayer || !instance.commands?.includes(command)) {
+      if (!hand._currentPlayer || !instance.commands?.includes(command)) {
         return null
       }
 
-      hand.commands[command](hand.currentPlayer)
+      hand.commands[command](hand._currentPlayer)
 
       return command
     },
   }
-  
+
   instance.commands?.push(ESayCommand.MAZO)
   instance.commands?.push(ESayCommand.TRUCO)
 
@@ -44,5 +32,9 @@ export function PlayInstance(hand: IHand, teams: [ITeam, ITeam]) {
     instance.commands?.push(EEnvidoCommand.ENVIDO)
   }
 
+  if (hand.state === EHandState.WAITING_FOR_TRUCO_ANSWER) {
+    instance.commands = [ESayCommand.TRUCO, ESayCommand.QUIERO, ESayCommand.NO_QUIERO]
+  }
+
   return instance
 }

package/src/lib/classes/Player.ts

@@ -1,11 +1,23 @@
-import { ICard, IPlayer } from "../types"
+import { IPlayer } from "../types"
 
 export function Player(id: string, teamIdx: number) {
   const player: IPlayer = {
     id,
     teamIdx,
     hand: [],
+    commands: [],
     usedHand: [],
+    disabled: false,
+    ready: false,
+    enable() {
+      player.disabled = false
+    },
+    disable() {
+      player.disabled = true
+    },
+    setReady(ready) {
+      player.ready = ready
+    },
     setHand(hand) {
       player.hand = hand
       player.usedHand = []

package/src/lib/classes/Round.ts

@@ -1,12 +1,16 @@
 import { IRound } from "../types"
 import { getCardValue } from "../utils"
 
-export function Round(): IRound {
+export function Round(turn: number): IRound {
   const round: IRound = {
+    turn,
     highest: -1,
     winner: null,
     cards: [],
     tie: false,
+    nextTurn() {
+      round.turn++
+    },
     use({ card, player }) {
       const value = getCardValue(card)
       if (value === round.highest && player.teamIdx !== round.winner?.teamIdx) {

package/src/lib/classes/Table.ts

@@ -1,12 +1,16 @@
-import { ITable, ITeam } from "../types"
+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(teams: Array<ITeam>, size: number): ITable {
+export function Table(players: Array<IPlayer>, teams: Array<ITeam>): ITable {
   const table: ITable = {
-    players: [],
+    players,
     cards: [],
     forehandIdx: 0,
     nextTurn() {
-      if (table.forehandIdx < size * 2 - 1) {
+      if (table.forehandIdx < table.players.length - 1) {
         table.forehandIdx++
       } else {
         table.forehandIdx = 0
@@ -24,14 +28,5 @@ export function Table(teams: Array<ITeam>, size: number): ITable {
     },
   }
 
-  if (teams[0].players.length != size || teams[1].players.length != size) {
-    throw new Error("Unexpected team size")
-  }
-
-  for (let i = 0; i < size; i++) {
-    table.players.push(teams[0].players[i])
-    table.players.push(teams[1].players[i])
-  }
-
   return table
 }

package/src/lib/classes/Team.ts

@@ -11,6 +11,13 @@ export function Team(players: Array<IPlayer>) {
       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

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

@@ -62,6 +62,14 @@ export const COLORS = [
   "#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 EnvidoCalculator: IEnvidoCalculator = {
   [EEnvidoCommand.ENVIDO]: () => ({
     accept: 2,

package/src/lib/index.ts

@@ -1,23 +1,33 @@
 import { Match } from "./classes/Match"
 import { Player } from "./classes/Player"
+import { Table } from "./classes/Table"
 import { Team } from "./classes/Team"
-import { IMatch, IPlayInstance, ITeam } from "./types"
+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 = (match: IPlayInstance) => Promise<void>
+export type ITurnCallback = (play: IPlayInstance) => Promise<void>
+export type ITrucoCallback = (play: IPlayInstance) => Promise<void>
 
 export interface IGameLoop {
-  _onTurn: (match: IPlayInstance) => Promise<void>
-  _onWinner: (winner: ITeam, teams: [ITeam, ITeam]) => Promise<void>
+  _onTruco: ITrucoCallback
+  _onTurn: ITurnCallback
+  _onWinner: IWinnerCallback
   onTurn: (callback: ITurnCallback) => IGameLoop
   onWinner: (callback: IWinnerCallback) => IGameLoop
-  start: () => void
+  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
@@ -26,7 +36,7 @@ const GameLoop = (match: IMatch) => {
       gameloop._onWinner = callback
       return gameloop
     },
-    async start() {
+    async begin() {
       while (!match.winner) {
         const play = match.play()
 
@@ -34,7 +44,15 @@ const GameLoop = (match: IMatch) => {
           continue
         }
 
-        await gameloop._onTurn(play)
+        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)
@@ -44,14 +62,74 @@ const GameLoop = (match: IMatch) => {
   return gameloop
 }
 
-export function Trucoshi(
-  idsTeam0: Array<string>,
-  idsTeam1: Array<string>,
-  matchPoint: 9 | 12 | 15
-) {
-  const teams = [
-    Team(idsTeam0.map((id) => Player(id, 0))),
-    Team(idsTeam1.map((id) => Player(id, 1))),
-  ]
-  return GameLoop(Match(teams, matchPoint))
+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,
+  }
 }