trucoshi 0.0.8 → 0.0.10

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "trucoshi",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "main": "build/lib/trucoshi.js",
   "license": "GPL-3.0",
   "scripts": {
-    "prepare": "yarn build",
+    "prepublishOnly": "yarn build",
     "dev": "nodemon",
     "test:autoplay": "yarn run ts-node src/test/autoplay",
     "test:play": "yarn run ts-node src/test/play",
@@ -15,7 +15,9 @@
     "@types/node": "^18.11.18",
     "nodemon": "^2.0.20"
   },
-
+  "files": [
+    "build"
+  ],
   "dependencies": {
     "rimraf": "^4.1.1",
     "socket.io": "^4.5.4",

package/.prettierrc.json

@@ -1,7 +0,0 @@
-{
-    "trailingComma": "es5",
-    "tabWidth": 2,
-    "semi": false,
-    "singleQuote": false,
-    "printWidth": 100
-}

package/nodemon.json

@@ -1,6 +0,0 @@
-{
-    "watch": ["src"],
-    "ext": ".ts,.js",
-    "ignore": [],
-    "exec": "yarn run ts-node ./src/server/index.ts"
-}

package/src/lib/classes/Deck.ts

@@ -1,25 +0,0 @@
-import { CARDS } from "../constants"
-import { ICard, IDeck } from "../types"
-import { shuffleArray } from "../utils"
-
-export function Deck(): IDeck {
-  const deck: IDeck = {
-    cards: Object.keys(CARDS) as Array<ICard>,
-    usedCards: [],
-    takeCard() {
-      const card = deck.cards.shift() as ICard
-      deck.usedCards.push(card)
-      return card
-    },
-    shuffle() {
-      deck.cards = deck.cards.concat(deck.usedCards)
-      deck.usedCards = []
-      deck.cards = shuffleArray(deck.cards)
-      if (deck.cards.length !== 40) {
-        throw new Error("This is not good")
-      }
-      return deck
-    },
-  }
-  return deck
-}

package/src/lib/classes/Hand.ts

@@ -1,207 +0,0 @@
-import {
-  EEnvidoCommand,
-  EHandState,
-  ESayCommand,
-  IDeck,
-  IHand,
-  IHandCommands,
-  IMatch,
-} 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"])
-    })
-  })
-
-  function* roundsGeneratorSequence() {
-    let currentRoundIdx = 0
-    let forehandTeamIdx = match.table.player(hand.turn).teamIdx as 0 | 1
-
-    while (currentRoundIdx < 3 && !hand.finished()) {
-      const round = Round(0)
-      hand.setCurrentRound(round)
-      hand.pushRound(round)
-
-      let previousRound = hand.rounds[currentRoundIdx - 1]
-
-      // Put previous round winner as forehand
-      if (previousRound && previousRound.winner && !previousRound.tie) {
-        const newTurn = match.table.getPlayerPosition(previousRound.winner.id)
-        if (newTurn !== -1) {
-          hand.setTurn(newTurn)
-        }
-      }
-
-      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 (player.disabled) {
-          hand.setCurrentPlayer(null)
-        }
-
-        yield hand
-      }
-
-      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 (winnerTeamIdx !== null) {
-        hand.addPoints(winnerTeamIdx, hand.truco.state)
-        hand.setState(EHandState.FINISHED)
-      }
-
-      currentRoundIdx++
-    }
-    yield hand
-  }
-
-  const roundsGenerator = roundsGeneratorSequence()
-
-  const commands: IHandCommands = {
-    [ESayCommand.MAZO]: (player) => {
-      hand.disablePlayer(player)
-    },
-    [ESayCommand.TRUCO]: (player) => {
-      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]: () => {},
-    [ESayCommand.CONTRAFLOR]: () => {},
-    [EEnvidoCommand.ENVIDO]: () => {},
-    [EEnvidoCommand.ENVIDO_ENVIDO]: () => {},
-    [EEnvidoCommand.REAL_ENVIDO]: () => {},
-    [EEnvidoCommand.FALTA_ENVIDO]: () => {},
-  }
-
-  const hand: IHand = {
-    idx,
-    turn: Number(match.table.forehandIdx),
-    state: EHandState.WAITING_PLAY,
-    rounds: [],
-    truco: Truco(),
-    envido: {
-      accept: 1,
-      decline: 2,
-      teamIdx: null,
-    },
-    points: [0, 0],
-    currentRound: 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) {
-      match.teams[player.teamIdx].disable(player)
-    },
-    addPoints(team, points) {
-      hand.points[team] = hand.points[team] + points
-    },
-    pushRound(round) {
-      hand.rounds.push(round)
-      return round
-    },
-    setTurn(turn) {
-      hand.turn = turn
-      return match.table.player(hand.turn)
-    },
-    setCurrentRound(round) {
-      hand.currentRound = round
-      return hand.currentRound
-    },
-    setCurrentPlayer(player) {
-      hand._currentPlayer = player
-      return hand._currentPlayer
-    },
-    setState(state) {
-      hand.state = state
-      return hand.state
-    },
-    finished: () => {
-      return hand.state === EHandState.FINISHED
-    },
-  }
-
-  return hand
-}

package/src/lib/classes/Match.ts

@@ -1,79 +0,0 @@
-import { IHand, IMatch, ITable, ITeam } from "../types"
-import { Deck } from "./Deck"
-import { Hand } from "./Hand"
-
-export function Match(table: ITable, teams: Array<ITeam> = [], matchPoint: number = 9): IMatch {
-  const deck = Deck().shuffle()
-
-  const size = teams[0].players.length
-
-  if (size !== teams[1].players.length) {
-    throw new Error("Team size mismatch")
-  }
-
-  function* handsGeneratorSequence() {
-    while (!match.winner) {
-      deck.shuffle()
-      const hand = match.setCurrentHand(Hand(match, deck, match.hands.length + 1)) as IHand
-      match.pushHand(hand)
-      while (!hand.finished()) {
-        const { value } = hand.getNextPlayer()
-        if (value && value.finished()) {
-          continue
-        }
-        match.setCurrentHand(value as IHand)
-        yield match
-      }
-
-      match.setCurrentHand(null)
-
-      const teams = match.addPoints(hand.points)
-      const winner = teams.find((team) => team.points.winner)
-
-      if (winner) {
-        match.setWinner(winner)
-        match.setCurrentHand(null)
-        break
-      }
-      match.table.nextTurn()
-    }
-    yield match
-  }
-
-  const handsGenerator = handsGeneratorSequence()
-
-  const match: IMatch = {
-    winner: null,
-    teams: teams as [ITeam, ITeam],
-    hands: [],
-    table,
-    currentHand: null,
-    play() {
-      match.getNextTurn()
-      if (!match.currentHand) {
-        return null
-      }
-      return match.currentHand.play()
-    },
-    addPoints(points) {
-      match.teams[0].addPoints(matchPoint, points[0])
-      match.teams[1].addPoints(matchPoint, points[1])
-      return match.teams
-    },
-    pushHand(hand) {
-      match.hands.push(hand)
-    },
-    setCurrentHand(hand) {
-      match.currentHand = hand
-      return match.currentHand
-    },
-    setWinner(winner) {
-      match.winner = winner
-    },
-    getNextTurn() {
-      return handsGenerator.next()
-    },
-  }
-
-  return match
-}

package/src/lib/classes/Play.ts

@@ -1,40 +0,0 @@
-import { EEnvidoCommand, EHandState, ESayCommand, IHand, IPlayInstance, ITeam } from "../types"
-
-export function PlayInstance(hand: IHand, teams: [ITeam, ITeam]) {
-  const instance: IPlayInstance = {
-    state: hand.state,
-    teams,
-    truco: hand.truco,
-    envido: hand.envido,
-    handIdx: hand.idx,
-    roundIdx: hand.rounds.length,
-    player: hand.currentPlayer,
-    commands: [],
-    rounds: hand.rounds,
-    use(idx) {
-      return hand.use(idx)
-    },
-    say(command) {
-      if (!hand._currentPlayer || !instance.commands?.includes(command)) {
-        return null
-      }
-
-      hand.commands[command](hand._currentPlayer)
-
-      return command
-    },
-  }
-
-  instance.commands?.push(ESayCommand.MAZO)
-  instance.commands?.push(ESayCommand.TRUCO)
-
-  if (hand.rounds.length === 1) {
-    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,37 +0,0 @@
-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 = []
-      return hand
-    },
-    useCard(idx) {
-      if (player.hand[idx]) {
-        const card = player.hand.splice(idx, 1)[0]
-        player.usedHand.push(card)
-        return card
-      }
-      return null
-    },
-  }
-
-  return player
-}

package/src/lib/classes/Round.ts

@@ -1,30 +0,0 @@
-import { IRound } from "../types"
-import { getCardValue } from "../utils"
-
-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) {
-        round.tie = true
-      }
-      if (value > round.highest) {
-        round.tie = false
-        round.highest = value
-        round.winner = player
-      }
-      round.cards.push({ card, player })
-      return card
-    },
-  }
-
-  return round
-}

package/src/lib/classes/Table.ts

@@ -1,32 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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,108 +0,0 @@
-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,
-}
-
-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 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

@@ -1,135 +0,0 @@
-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,216 +0,0 @@
-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
-}
-
-export interface IPlayedCard {
-  player: IPlayer
-  card: ICard
-}
-
-export interface IPlayer {
-  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 {
-  _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 | 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 {
-  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
-  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
-}
-
-export interface IRound {
-  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
-}

package/src/lib/utils.ts

@@ -1,66 +0,0 @@
-import { CARDS } from "./constants"
-import { ICard, IRound, ITeam, RoundPoints } from "./types"
-
-export function getMaxNumberIndex<T = number>(array: Array<T>) {
-  return array.reduce((accumulator, current, index) => {
-    return current > array[accumulator] ? index : accumulator
-  }, 0)
-}
-
-export function getCardValue(card: ICard) {
-  return CARDS[card] || -1
-}
-
-export function shuffleArray<T = unknown>(array: Array<T>) {
-  let currentIndex = array.length,
-    randomIndex
-
-  while (currentIndex != 0) {
-    randomIndex = Math.floor(Math.random() * currentIndex)
-    currentIndex--
-    ;[array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]]
-  }
-
-  return array as Array<T>
-}
-
-export function checkHandWinner(
-  rounds: Array<IRound>,
-  forehandTeamIdx: 0 | 1
-): null | 0 | 1 {
-  const roundsWon: RoundPoints = {
-    0: 0,
-    1: 0,
-    ties: 0,
-  }
-
-  for (let i = 0; i < rounds.length; i++) {
-    const round = rounds[i]
-    if (round.tie) {
-      roundsWon[0] += 1
-      roundsWon[1] += 1
-      roundsWon.ties = roundsWon.ties + 1
-      continue
-    }
-    if (round.winner?.teamIdx === 0) {
-      roundsWon[0] += 1
-    }
-    if (round.winner?.teamIdx === 1) {
-      roundsWon[1] += 1
-    }
-  }
-
-  if ((roundsWon[0] > 2 && roundsWon[1] > 2) || (rounds.length > 2 && roundsWon.ties > 0)) {
-    return forehandTeamIdx
-  }
-
-  if (roundsWon[0] >= 2 && roundsWon[1] < 2) {
-    return 0
-  }
-
-  if (roundsWon[1] >= 2 && roundsWon[0] < 2) {
-    return 1
-  }
-
-  return null
-}

package/src/server/index.ts

@@ -1,34 +0,0 @@
-import { createServer } from "http"
-import { Server } from "socket.io"
-import { EClientEvent, EServerEvent } from "./types"
-
-const PORT = 4001
-
-const httpServer = createServer()
-const io = new Server(httpServer, {
-  cors: {
-    origin: "http://localhost:3000",
-    methods: ["GET", "POST"],
-  },
-})
-
-const sessions = new Map<string, string>()
-
-io.on("connection", (socket) => {
-  socket.on(EClientEvent.PING, (msg) => {
-    io.emit(EServerEvent.PONG, msg)
-  })
-
-  socket.on(EClientEvent.CREATE_MATCH, (msg) => {
-
-  })
-  
-  socket.on(EClientEvent.SET_PLAYER_ID, (msg) => {
-    if (typeof msg === 'string' && msg.length < 32) {
-    }
-  })
-})
-
-httpServer.listen(PORT)
-
-console.log("Listening on port", PORT)

package/src/server/types.ts

@@ -1,12 +0,0 @@
-export enum EClientEvent {
-  PING = "PING",
-  CREATE_MATCH = "CREATE_MATCH",
-  JOIN_MATCH = "JOIN_MATCH",
-  START_MATCH = "START_MATCH",
-  SET_PLAYER_ID = "SET_PLAYER_ID",
-}
-
-export enum EServerEvent {
-  SET_SESSION_ID = "SET_SESSION_ID",
-  PONG = "PONG",
-}

package/src/test/autoplay.ts

@@ -1,57 +0,0 @@
-import { Trucoshi } from "../lib"
-import { IRound } from "../lib/types"
-;(async () => {
-  const trucoshi = Trucoshi()
-
-  trucoshi.addPlayer("lukini").setReady(true)
-  trucoshi.addPlayer("denoph").setReady(true)
-  trucoshi.addPlayer("guada").setReady(true)
-  trucoshi.addPlayer("juli").setReady(true)
-  trucoshi.addPlayer("day").setReady(true)
-  trucoshi.addPlayer("fran").setReady(true) 
-
-  trucoshi
-    .startMatch()
-    .onTurn(async (play) => {
-      if (!play.player) {
-        return
-      }
-      const name = play.player?.id.toUpperCase()
-      console.log(`=== Mano ${play.handIdx} === Ronda ${play.roundIdx} === Turno de ${name} ===`)
-      play.teams.map((team, id) =>
-        console.log(`=== Team ${id} = ${team.points.malas} malas ${team.points.buenas} buenas ===`)
-      )
-      console.log(
-        play.rounds && play.rounds.length
-          ? play.rounds.map((round: IRound) =>
-              round.cards.length ? round.cards.map((c) => [c.player.id, c.card]) : ""
-            )
-          : ""
-      )
-
-      const randomIdx = Math.round(Math.random() * (play.player.hand.length - 1))
-      const handString = JSON.stringify(play.player.hand)
-      const card = play.use(randomIdx)
-
-      console.log(`\n${handString}\nUsing ${card}`)
-      console.log(
-        play.rounds && play.rounds.length
-          ? play.rounds.map((round: IRound) =>
-              round.cards.length ? round.cards.map((c) => [c.player.id, c.card]) : ""
-            )
-          : ""
-      )
-    })
-    .onWinner(async (winner, teams) => {
-      console.log("\n")
-      teams.map((t, i) =>
-        console.log(
-          `Equipo ${i}: ${t.players.map((p) => ` ${p.id}`)} === ${t.points.malas} malas ${
-            t.points.buenas
-          } buenas`
-        )
-      )
-      console.log(`\nEquipo Ganador:${winner.players.map((p) => ` ${p.id}`)}`)
-    })
-    .begin()
-})()

package/src/test/play.ts

@@ -1,122 +0,0 @@
-import * as readline from "readline"
-import { Trucoshi } from "../lib"
-import { IPlayInstance, IRound, ITeam } from "../lib/types"
-
-const command = (
-  title: string,
-  onLine: (line: string, close: () => void) => Promise<void>
-): (() => Promise<void>) => {
-  const promise = () =>
-    new Promise<void>((resolve) => {
-      const rl = readline.createInterface(process.stdin, process.stdout)
-      rl.setPrompt(title)
-      rl.prompt()
-      rl.on("line", async (line) => {
-        try {
-          await onLine(line, () => rl.close())
-          rl.close()
-          resolve()
-        } catch (e) {
-          rl.close()
-          return (async () => {
-            await promise()
-            resolve()
-          })()
-        }
-      })
-    })
-
-  return promise
-}
-
-const playCommand = (play: IPlayInstance) =>
-  command(
-    `${play.player?.id} elije una carta [${play.player?.hand.map(
-      (_c, i) => i + 1
-    )}]: ${JSON.stringify(play.player?.hand)}\n`,
-    async (idx) => {
-      const playedCard = play.use(Number(idx) - 1)
-      if (!playedCard) {
-        return Promise.reject()
-      }
-      const handString = JSON.stringify(play.player?.hand)
-      console.log(`\n${handString}\nUsing ${playedCard}`)
-      console.log(
-        play.rounds && play.rounds.length
-          ? play.rounds.map((round: IRound) =>
-              round.cards.length ? round.cards.map((c) => [c.player.id, c.card]) : ""
-            )
-          : ""
-      )
-      return Promise.resolve()
-    }
-  )
-
-const sayCommand = (play: IPlayInstance, canPlay: boolean) =>
-  command(
-    `${play.player?.id} elije una accion [${canPlay ? "0," : ""}${play.commands?.map(
-      (_c, i) => i + 1
-    )}]: ${
-      canPlay ? JSON.stringify(["CARTA", ...(play.commands || [])]) : JSON.stringify(play.commands)
-    }\n`,
-    async (idx, close) => {
-      const selectedCommand = play.commands?.[Number(idx) - 1]
-
-      if (selectedCommand) {
-        play.say(selectedCommand)
-        return Promise.resolve()
-      }
-
-      if (idx === "0" && canPlay) {
-        close()
-        await playCommand(play)()
-        return Promise.resolve()
-      }
-
-      return Promise.reject()
-    }
-  )
-
-;(async () => {
-  const trucoshi = Trucoshi()
-
-  trucoshi.addPlayer("lukini", 0).setReady(true)
-  trucoshi.addPlayer("guada", 0).setReady(true)
-  trucoshi.addPlayer("denoph", 1).setReady(true)
-  trucoshi.addPlayer("juli", 1).setReady(true)
-
-  trucoshi
-    .startMatch()
-    .onTruco(async (play) => {
-      await sayCommand(play, false)()
-    })
-    .onTurn(async (play) => {
-      const name = play.player?.id.toUpperCase()
-      console.log(`=== Mano ${play.handIdx} === Ronda ${play.roundIdx} === Turno de ${name} ===`)
-
-      play.teams.map((team, id) =>
-        console.log(`=== Team ${id} = ${team.points.malas} malas ${team.points.buenas} buenas`)
-      )
-
-      console.log(
-        play.rounds && play.rounds.length
-          ? play.rounds.map((round: IRound) =>
-              round.cards.length ? round.cards.map((c) => [c.player.id, c.card]) : ""
-            )
-          : ""
-      )
-
-      await sayCommand(play, true)()
-    })
-    .onWinner(async (winner: ITeam, teams: [ITeam, ITeam]) => {
-      teams.map((t, i) =>
-        console.log(
-          `Equipo ${i}: ${t.players.map((p) => ` ${p.id}`)} === ${t.points.malas} malas ${
-            t.points.buenas
-          } buenas`
-        )
-      )
-      console.log(`\nEquipo Ganador:${winner?.players.map((p) => ` ${p.id}`)}`)
-    })
-    .begin()
-})()

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es5",                          
-    "module": "commonjs",                    
-    "lib": ["es6"],                     
-    "allowJs": true,
-    "outDir": "build",                          
-    "rootDir": "src",
-    "strict": true,         
-    "noImplicitAny": true,
-    "esModuleInterop": true,
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "declaration": true
-  },
-  "include": [
-    "src/**/*"
-  ]
-}