trucoshi 0.0.2 → 0.0.4

package/src/lib/constants.ts

@@ -1,14 +1,100 @@
+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 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,57 @@
+import { Match } from "./classes/Match"
+import { Player } from "./classes/Player"
+import { Team } from "./classes/Team"
+import { IMatch, IPlayInstance, ITeam } from "./types"
+
+export type IWinnerCallback = (winner: ITeam, teams: [ITeam, ITeam]) => Promise<void>
+export type ITurnCallback = (match: IPlayInstance) => Promise<void>
+
+export interface IGameLoop {
+  _onTurn: (match: IPlayInstance) => Promise<void>
+  _onWinner: (winner: ITeam, teams: [ITeam, ITeam]) => Promise<void>
+  onTurn: (callback: ITurnCallback) => IGameLoop
+  onWinner: (callback: IWinnerCallback) => IGameLoop
+  start: () => void
+}
+
+const GameLoop = (match: IMatch) => {
+  let gameloop: IGameLoop = {
+    _onTurn: () => Promise.resolve(),
+    _onWinner: () => Promise.resolve(),
+    onTurn: (callback: ITurnCallback) => {
+      gameloop._onTurn = callback
+      return gameloop
+    },
+    onWinner: (callback: IWinnerCallback) => {
+      gameloop._onWinner = callback
+      return gameloop
+    },
+    async start() {
+      while (!match.winner) {
+        const play = match.play()
+
+        if (!play || !play.player) {
+          continue
+        }
+
+        await gameloop._onTurn(play)
+      }
+
+      await gameloop._onWinner(match.winner, match.teams)
+    },
+  }
+
+  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))
+}

package/src/lib/types.ts

@@ -3,108 +3,168 @@ 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>
+  usedHand: Array<ICard>
+  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
+  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 {
+  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 TrucoState {
+  state: 1 | 2 | 3 | 4
+  teamIdx: 0 | 1 | null
+}
+
+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: TrucoState
+  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: TrucoState
+  envido: EnvidoState
+  rounds: Array<IRound>
+  currentPlayer: IPlayer | null
+  currentRound: IRound | null
+  disabledPlayerIds: Array<string>
+  commands: IHandCommands
+  finished: () => boolean
+  play(): IPlayInstance | 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 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>
+  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,69 +1,87 @@
-import { CARDS } from "./constants";
-import { ICard, IPoints, IRound, ITeam } from "./types";
+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
+  return CARDS[card] || -1
 }
 
-export function shuffleArray<T = never>(array: Array<T>) {
-    let currentIndex = array.length, randomIndex;
+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]];
-    }
+  while (currentIndex != 0) {
+    randomIndex = Math.floor(Math.random() * currentIndex)
+    currentIndex--
+    ;[array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]]
+  }
 
-    return array as Array<T>;
+  return array as Array<T>
 }
 
-export function checkHandWinner(rounds: Array<IRound>, forehandTeamIdx: 0 | 1): null | 0 | 1 {
-    const roundsWon: IPoints = {
-        0: 0,
-        1: 0,
-        2: 0 // tied rounds
-    }
+export function checkHandWinner(
+  rounds: Array<IRound>,
+  forehandTeamIdx: 0 | 1,
+  disabledPlayerIds: Array<string>,
+  teams: [ITeam, ITeam]
+): null | 0 | 1 {
+  let winningTeamIdx = null
 
-    for (let i = 0; i < rounds.length; i++) {
-        const round = rounds[i];
-        if (round.tie) {
-            roundsWon[0] += 1;
-            roundsWon[1] += 1;
-            roundsWon[2] = (roundsWon[2] || 0) + 1;
-            continue;
-        }
-        if (round.winner?.teamIdx === 0) {
-            roundsWon[0] += 1;
-        }
-        if (round.winner?.teamIdx === 1) {
-            roundsWon[1] += 1;
-        }
+  // End hand if all players in one team go MAZO
+  if (disabledPlayerIds.length) {
+    const disabledTeams = teams.map((team) => {
+      const forfeited = team.players.filter((player) => disabledPlayerIds.includes(player.id))
+      return forfeited.length === team.players.length
+    })
+    if (disabledTeams[0] && disabledTeams[1]) {
+      return forehandTeamIdx
     }
-
-    const ties = roundsWon[2] || 0
-    
-    if ((roundsWon[0] > 2 && roundsWon[1] > 2) || (rounds.length > 2 && ties > 0)) {
-        return forehandTeamIdx
-    }
-
-    if (roundsWon[0] >= 2 && roundsWon[1] < 2) {
-        return 0
+    if (disabledTeams[0]) {
+      return 1
     }
-
-    if (roundsWon[1] >= 2 && roundsWon[0] < 2) {
-        return 1
+    if (disabledTeams[1]) {
+      return 0
     }
+  }
 
-    return null
-}
+  const roundsWon: RoundPoints = {
+    0: 0,
+    1: 0,
+    ties: 0,
+  }
 
-export function checkMatchWinner(teams: Array<ITeam>, matchPoint: number): ITeam | null {
-    if (teams[0].points >= matchPoint) {
-        return teams[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 (teams[1].points >= matchPoint) {
-        return teams[1]
+    if (round.winner?.teamIdx === 0) {
+      roundsWon[0] += 1
     }
-    return null
+    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,22 +1,34 @@
-import { createServer } from "http";
-import { Server } from "socket.io";
-
-const PORT = 4001
-
-const httpServer = createServer();
-const io = new Server(httpServer, {
-    cors: {
-        origin: "http://localhost:3000",
-        methods: ["GET", "POST"]
-    }
-});
-
-io.on("connection", (socket) => {
-    socket.on('ping', (msg) => {
-        io.emit('pong', msg);
-    });
-});
-
-httpServer.listen(PORT);
-
-console.log('Listening on port', PORT)
+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

@@ -0,0 +1,12 @@
+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",
+}