trucoshi 0.0.9 → 0.0.11

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()
-})()