trucoshi 0.0.9 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trucoshi",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "main": "build/lib/trucoshi.js",
   "license": "GPL-3.0",
   "scripts": {
@@ -9,13 +9,15 @@
     "test:autoplay": "yarn run ts-node src/test/autoplay",
     "test:play": "yarn run ts-node src/test/play",
     "test:legacy": "yarn run ts-node src/test/legacy",
-    "build": "yarn run rimraf ./build && yarn run tsc --project ."
+    "build": "yarn run rimraf ./dist && yarn run tsc --project ."
   },
   "devDependencies": {
     "@types/node": "^18.11.18",
     "nodemon": "^2.0.20"
   },
-
+  "files": [
+    "dist"
+  ],
   "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
-}