trucoshi 1.0.0 → 2.0.1

package/src/lib/trucoshi.ts

@@ -1,342 +0,0 @@
-import { CARDS } from "./constants";
-import { EHandPlayCommand, ICard, IDeck, IHand, IPlayInstance, IMatch, IPlayedCard, IPlayer, IPoints, IRound, ITable, ITeam } from "./types";
-import { checkHandWinner, checkMatchWinner, getCardValue, shuffleArray } from "./utils";
-
-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
-}
-
-function Table(teams: Array<ITeam>, size: number): ITable {
-    const _table: ITable = {
-        players: [],
-        cards: [],
-        forehandIdx: 0,
-        nextTurn() {
-            if (_table.forehandIdx < (size * 2) - 1) {
-                _table.forehandIdx++
-            } else {
-                _table.forehandIdx = 0
-            }
-            return _table.player()
-        },
-        getPlayerPosition(id: string) {
-            return _table.players.findIndex(p => p.id === id)
-        },
-        player(idx?: number) {
-            if (idx !== undefined) {
-                return _table.players[idx]
-            }
-            return _table.players[_table.forehandIdx]
-        }
-    }
-
-    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;
-}
-
-function Round(): IRound {
-    const _round: IRound = {
-        highest: -1,
-        winner: null,
-        cards: [],
-        tie: false,
-        play({ card, player }: IPlayedCard) {
-            const value = getCardValue(card)
-            if (_round.highest > -1 && value === _round.highest) {
-                _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
-}
-
-export function Match(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.addPoints(hand.points)
-            _match.setCurrentHand(null)
-
-            const hasWinner = checkMatchWinner(teams, matchPoint)
-
-            if (hasWinner !== null) {
-                _match.setWinner(hasWinner)
-                _match.setCurrentHand(null)
-            }
-            _match.table.nextTurn()
-        }
-        yield _match
-    }
-
-    const handsGenerator = handsGeneratorSequence()
-
-    const _match: IMatch = {
-        winner: null,
-        teams: teams as [ITeam, ITeam],
-        hands: [],
-        table: Table(teams, size),
-        currentHand: null,
-        play() {
-            _match.getNextTurn()
-            if (!_match.currentHand) {
-                return;
-            }
-            return _match.currentHand.play()
-        },
-        addPoints(points: IPoints) {
-            _match.teams[0].addPoints(points[0])
-            _match.teams[1].addPoints(points[1])
-        },
-        pushHand(hand: IHand) {
-            _match.hands.push(hand)
-        },
-        setCurrentHand(hand: IHand) {
-            _match.currentHand = hand
-            return _match.currentHand
-        },
-        setWinner(winner: ITeam) {
-            _match.winner = winner
-        },
-        getNextTurn() {
-            return handsGenerator.next()
-        }
-    }
-
-    return _match;
-}
-
-function PlayInstance(hand: IHand) {
-
-    const _instance: IPlayInstance = {
-        handIdx: hand.idx,
-        roundIdx: hand.rounds.length,
-        player: hand.currentPlayer,
-        commands: [],
-        rounds: hand.rounds,
-        use(idx: number) {
-            const player = hand.currentPlayer
-            const round = hand.currentRound
-            if (!player || !round) {
-                return null
-            }
-
-            const card = player.useCard(idx)
-            if (card) {
-                return round.play({ player, card })
-            }
-
-            return null
-        },
-        say(command: EHandPlayCommand) {
-            if (!hand.currentPlayer) {
-                return null
-            }
-            return hand
-        }
-    }
-
-    return _instance
-}
-
-function Hand(match: IMatch, deck: IDeck, idx: number) {
-
-    const truco = 1;
-
-    match.teams.forEach((team) => {
-        team.players.forEach(player => {
-            const playerHand = [deck.takeCard(), deck.takeCard(), deck.takeCard()]
-            player.setHand(playerHand)
-            // 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) {
-
-            let i = 0
-
-            const round = Round()
-            _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 (i < match.table.players.length) {
-                _hand.setCurrentPlayer(match.table.player(_hand.turn))
-                
-                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)
-
-            if (teamIdx !== null) {
-                _hand.addPoints(teamIdx, truco)
-                _hand.setFinished(true)
-            }
-            currentRoundIdx++;
-        }
-        yield _hand
-    }
-
-    const roundsGenerator = roundsGeneratorSequence()
-
-    const _hand: IHand = {
-        idx,
-        turn: Number(match.table.forehandIdx),
-        rounds: [],
-        finished: false,
-        points: {
-            0: 0,
-            1: 0
-        },
-        currentRound: null,
-        currentPlayer: null,
-        play() {
-            return PlayInstance(_hand)
-        },
-        pushRound(round: IRound) {
-            _hand.rounds.push(round)
-            return round
-        },
-        setTurn(turn: number) {
-            _hand.turn = turn
-            return match.table.player(_hand.turn)
-        },
-        addPoints(team: 0 | 1, points: number) {
-            _hand.points[team] = _hand.points[team] + points
-        },
-        setCurrentRound(round: IRound | null) {
-            _hand.currentRound = round
-            return _hand.currentRound
-        },
-        setCurrentPlayer(player: IPlayer | null) {
-            _hand.currentPlayer = player
-            return _hand.currentPlayer
-        },
-        setFinished(finshed: boolean) {
-            _hand.finished = finshed
-            return _hand.finished
-        },
-        getNextPlayer() {
-            return roundsGenerator.next();
-        },
-    }
-
-    return _hand
-}
-
-export function Player(id: string, teamIdx: number) {
-    const _player: IPlayer = {
-        id,
-        teamIdx,
-        hand: [],
-        usedHand: [],
-        setHand(hand: Array<ICard>) {
-            _player.hand = hand
-            _player.usedHand = []
-            return hand
-        },
-        useCard(idx: number) {
-            if (_player.hand[idx]) {
-                const card = _player.hand.splice(idx, 1)[0]
-                _player.usedHand.push(card)
-                return card;
-            }
-            return null
-        }
-    }
-
-    return _player;
-}
-
-export function Team(color: string, players: Array<IPlayer>) {
-    const _team = {
-        _players: new Map<string, IPlayer>(),
-        get players() {
-            return Array.from(_team._players.values())
-        },
-        color,
-        points: 0,
-        addPoints(points: number) {
-            _team.points += points
-            return _team.points
-        },
-    }
-
-    players.forEach(player => _team._players.set(player.id, player))
-
-    return _team;
-}

package/src/lib/types.ts

@@ -1,110 +0,0 @@
-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>,
-    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
-}
-
-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,
-}
-
-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
-}
-
-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>
-}
-
-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>
-    play(playedCard: IPlayedCard): ICard
-}

package/src/lib/utils.ts

@@ -1,69 +0,0 @@
-import { CARDS } from "./constants";
-import { ICard, IPoints, IRound, ITeam } from "./types";
-
-export function getCardValue(card: ICard) {
-    return CARDS[card] || -1
-}
-
-export function shuffleArray<T = never>(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: IPoints = {
-        0: 0,
-        1: 0,
-        2: 0 // tied rounds
-    }
-
-    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;
-        }
-    }
-
-    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 (roundsWon[1] >= 2 && roundsWon[0] < 2) {
-        return 1
-    }
-
-    return null
-}
-
-export function checkMatchWinner(teams: Array<ITeam>, matchPoint: number): ITeam | null {
-    if (teams[0].points >= matchPoint) {
-        return teams[0]
-    }
-    if (teams[1].points >= matchPoint) {
-        return teams[1]
-    }
-    return null
-}

package/src/server/index.ts

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

package/src/test/autoplay.ts

@@ -1,41 +0,0 @@
-import { COLORS } from '../lib/constants';
-import { Match, Player, Team } from "../lib/trucoshi";
-import { ICard, IRound } from '../lib/types';
-
-(async () => {
-    const player1 = Player('lukini', 0)
-    const player2 = Player('guada', 0)
-    const player3 = Player('denoph', 1)
-    const player4 = Player('juli', 1)
-    const player5 = Player('fran', 1)
-    const player6 = Player('day', 0)
-
-    const team1 = Team(COLORS[0], [player1, player2, player6])
-    const team2 = Team(COLORS[1], [player3, player4, player5])
-
-    const match = Match([team1, team2], 9);
-
-    while(!match.winner) {
-        const play = match.play()
-
-        if (!play || !play.player) {
-            break;
-        }
-
-        const name = play.player.id.toUpperCase()
-        console.log(`=== Mano ${play.handIdx} === Ronda ${play.roundIdx} === Turno de ${name} ===`)
-        match.teams.map((team, id) => console.log(`=== Team ${id} = ${team.points} Puntos ===`))
-        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 card = play.use(randomIdx)
-
-        console.log(`\n${JSON.stringify(play.player.hand)}\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]) : '')) : '')
-    }
-
-    console.log('\n')
-    match.teams.map((t, i) => console.log(`Equipo ${i}: ${t.players.map(p => ` ${p.id}`)} === ${t.points} puntos`))
-    console.log(`\nEquipo Ganador:${match.winner?.players.map(p => ` ${p.id}`)}`)
-
-})();

package/src/test/legacy.ts

@@ -1,68 +0,0 @@
-import * as readline from 'readline'
-import { COLORS } from '../lib/constants';
-import { Match, Player, Team } from "../lib/trucoshi";
-import { ICard, IPlayer, IRound } from '../lib/types';
-
-(async () => {
-    const player1 = Player('lukini', 0)
-    const player2 = Player('guada', 0)
-    const player3 = Player('denoph', 1)
-    const player4 = Player('juli', 1)
-
-    const team1 = Team(COLORS[0], [player1, player2])
-    const team2 = Team(COLORS[1], [player3, player4])
-
-    const match = Match([team1, team2], 9);
-
-    while(!match.winner) {
-        if (match.currentHand?.finished) {
-            console.log(match.currentHand && match.currentHand.rounds.length ? (match.currentHand.rounds.map((round: IRound) => round.cards.length ? round.cards.map(c => [c.player.id, c.card]) : '')) : '')
-        }
-        const { value } = match.getNextTurn()
-        if (value && value.currentHand && value.currentHand.currentPlayer) {
-            //  const card = value.currentPlayer.useCard(Math.round(Math.random() * 2))
-            //  value.currentRound?.play({ card, player: value.currentPlayer })
-            const prom = () => new Promise<void>((resolve) => {
-
-                // process.stdout.write('\u001B[2J\u001B[0;0f');
-                const rl = readline.createInterface(process.stdin, process.stdout);
-
-                const currentHand: any = value.currentHand;
-                const name = value.currentHand?.currentPlayer?.id.toUpperCase()
-
-                console.log(`=== Mano ${currentHand.idx + 1} === Ronda ${currentHand.rounds.length} === Turno de ${name} ===\n`)
-
-                match.teams.map((team, id) => console.log(`=== Team ${id} = ${team.points} Puntos ===\n`))
-
-                console.log(currentHand && currentHand.rounds.length ? (currentHand.rounds.map((round: IRound) => round.cards.length ? round.cards.map(c => [c.player.id, c.card]) : '')) : '')
-
-                rl.setPrompt(`\n${name} elije una carta [1, 2, 3]: ${JSON.stringify(value.currentHand?.currentPlayer?.hand)}\n`);
-                rl.prompt();
-                rl.on('line', (idx: string) => {
-                    const index = Number(idx) - 1
-                    let playedCard: ICard | null | undefined = null
-                    if (index >= 0 && index < 3) {
-                        playedCard = value.currentHand?.currentPlayer?.useCard(index)
-                    }
-                    if (!playedCard) {
-                        rl.close();
-                        return (async () => {
-                            await prom()
-                            resolve()
-                        })();
-                    }
-                    value.currentHand?.currentRound?.play({ player: value.currentHand?.currentPlayer as IPlayer, card: playedCard as ICard })
-                    console.log(currentHand && currentHand.rounds.length ? (currentHand.rounds.map((round: IRound) => round.cards.length ? round.cards.map(c => [c.player.id, c.card]) : '')) : '')
-                    rl.close();
-                    resolve()
-                });
-            });
-
-            await prom()
-        }
-
-    }
-
-    console.log(match.teams.map(t => [t.points, t.players[0].id]))
-
-})();