trucoshi 1.0.0

package/.prettierrc.json

@@ -0,0 +1,3 @@
+{
+    "tabWidth": 2,
+}

package/build/lib/constants.d.ts

@@ -0,0 +1,43 @@
+export declare const CARDS: {
+    '1e': number;
+    '1b': number;
+    '7e': number;
+    '7o': number;
+    '3e': number;
+    '3o': number;
+    '3b': number;
+    '3c': number;
+    '2e': number;
+    '2o': number;
+    '2b': number;
+    '2c': number;
+    '1o': number;
+    '1c': number;
+    re: number;
+    ro: number;
+    rb: number;
+    rc: number;
+    ce: number;
+    co: number;
+    cb: number;
+    cc: number;
+    pe: number;
+    po: number;
+    pb: number;
+    pc: number;
+    '7b': number;
+    '7c': number;
+    '6e': number;
+    '6o': number;
+    '6b': number;
+    '6c': number;
+    '5e': number;
+    '5o': number;
+    '5b': number;
+    '5c': number;
+    '4e': number;
+    '4o': number;
+    '4b': number;
+    '4c': number;
+};
+export declare const COLORS: string[];

package/build/lib/constants.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COLORS = exports.CARDS = void 0;
+exports.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
+};
+exports.COLORS = ["#9b111", "#17c6c6", "#8c1d1d", "#9f9b9b", "#a5a5a5", "#f5a623", "#f44336", "#c2185b"];

package/build/lib/trucoshi.d.ts

@@ -0,0 +1,10 @@
+import { IMatch, IPlayer, ITeam } from "./types";
+export declare function Match(teams?: Array<ITeam>, matchPoint?: number): IMatch;
+export declare function Player(id: string, teamIdx: number): IPlayer;
+export declare function Team(color: string, players: Array<IPlayer>): {
+    _players: Map<string, IPlayer>;
+    readonly players: IPlayer[];
+    color: string;
+    points: number;
+    addPoints(points: number): number;
+};

package/build/lib/trucoshi.js

@@ -0,0 +1,363 @@
+"use strict";
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Team = exports.Player = exports.Match = void 0;
+var constants_1 = require("./constants");
+var utils_1 = require("./utils");
+function Deck() {
+    var _deck = {
+        cards: Object.keys(constants_1.CARDS),
+        usedCards: [],
+        takeCard: function () {
+            var card = _deck.cards.shift();
+            _deck.usedCards.push(card);
+            return card;
+        },
+        shuffle: function () {
+            _deck.cards = _deck.cards.concat(_deck.usedCards);
+            _deck.usedCards = [];
+            _deck.cards = (0, utils_1.shuffleArray)(_deck.cards);
+            if (_deck.cards.length !== 40) {
+                throw new Error("This is not good");
+            }
+            return _deck;
+        }
+    };
+    return _deck;
+}
+function Table(teams, size) {
+    var _table = {
+        players: [],
+        cards: [],
+        forehandIdx: 0,
+        nextTurn: function () {
+            if (_table.forehandIdx < (size * 2) - 1) {
+                _table.forehandIdx++;
+            }
+            else {
+                _table.forehandIdx = 0;
+            }
+            return _table.player();
+        },
+        getPlayerPosition: function (id) {
+            return _table.players.findIndex(function (p) { return p.id === id; });
+        },
+        player: function (idx) {
+            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 (var i = 0; i < size; i++) {
+        _table.players.push(teams[0].players[i]);
+        _table.players.push(teams[1].players[i]);
+    }
+    return _table;
+}
+function Round() {
+    var _round = {
+        highest: -1,
+        winner: null,
+        cards: [],
+        tie: false,
+        play: function (_a) {
+            var card = _a.card, player = _a.player;
+            var value = (0, utils_1.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: card, player: player });
+            return card;
+        }
+    };
+    return _round;
+}
+function Match(teams, matchPoint) {
+    if (teams === void 0) { teams = []; }
+    if (matchPoint === void 0) { matchPoint = 9; }
+    var deck = Deck().shuffle();
+    var size = teams[0].players.length;
+    if (size !== teams[1].players.length) {
+        throw new Error("Team size mismatch");
+    }
+    function handsGeneratorSequence() {
+        var hand, value, hasWinner;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!!_match.winner) return [3 /*break*/, 4];
+                    deck.shuffle();
+                    hand = _match.setCurrentHand(Hand(_match, deck, _match.hands.length + 1));
+                    _match.pushHand(hand);
+                    _a.label = 1;
+                case 1:
+                    if (!!hand.finished) return [3 /*break*/, 3];
+                    value = hand.getNextPlayer().value;
+                    if (value && value.finished) {
+                        return [3 /*break*/, 1];
+                    }
+                    _match.setCurrentHand(value);
+                    return [4 /*yield*/, _match];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 1];
+                case 3:
+                    _match.addPoints(hand.points);
+                    _match.setCurrentHand(null);
+                    hasWinner = (0, utils_1.checkMatchWinner)(teams, matchPoint);
+                    if (hasWinner !== null) {
+                        _match.setWinner(hasWinner);
+                        _match.setCurrentHand(null);
+                    }
+                    _match.table.nextTurn();
+                    return [3 /*break*/, 0];
+                case 4: return [4 /*yield*/, _match];
+                case 5:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }
+    var handsGenerator = handsGeneratorSequence();
+    var _match = {
+        winner: null,
+        teams: teams,
+        hands: [],
+        table: Table(teams, size),
+        currentHand: null,
+        play: function () {
+            _match.getNextTurn();
+            if (!_match.currentHand) {
+                return;
+            }
+            return _match.currentHand.play();
+        },
+        addPoints: function (points) {
+            _match.teams[0].addPoints(points[0]);
+            _match.teams[1].addPoints(points[1]);
+        },
+        pushHand: function (hand) {
+            _match.hands.push(hand);
+        },
+        setCurrentHand: function (hand) {
+            _match.currentHand = hand;
+            return _match.currentHand;
+        },
+        setWinner: function (winner) {
+            _match.winner = winner;
+        },
+        getNextTurn: function () {
+            return handsGenerator.next();
+        }
+    };
+    return _match;
+}
+exports.Match = Match;
+function PlayInstance(hand) {
+    var _instance = {
+        handIdx: hand.idx,
+        roundIdx: hand.rounds.length,
+        player: hand.currentPlayer,
+        commands: [],
+        rounds: hand.rounds,
+        use: function (idx) {
+            var player = hand.currentPlayer;
+            var round = hand.currentRound;
+            if (!player || !round) {
+                return null;
+            }
+            var card = player.useCard(idx);
+            if (card) {
+                return round.play({ player: player, card: card });
+            }
+            return null;
+        },
+        say: function (command) {
+            if (!hand.currentPlayer) {
+                return null;
+            }
+            return hand;
+        }
+    };
+    return _instance;
+}
+function Hand(match, deck, idx) {
+    var truco = 1;
+    match.teams.forEach(function (team) {
+        team.players.forEach(function (player) {
+            var playerHand = [deck.takeCard(), deck.takeCard(), deck.takeCard()];
+            player.setHand(playerHand);
+            // player.setHand(["5c", "4c", "6c"])
+        });
+    });
+    function roundsGeneratorSequence() {
+        var currentRoundIdx, forehandTeamIdx, i, round, previousRound, newTurn, teamIdx;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    currentRoundIdx = 0;
+                    forehandTeamIdx = match.table.player(_hand.turn).teamIdx;
+                    _a.label = 1;
+                case 1:
+                    if (!(currentRoundIdx < 3 && !_hand.finished)) return [3 /*break*/, 5];
+                    i = 0;
+                    round = Round();
+                    _hand.setCurrentRound(round);
+                    _hand.pushRound(round);
+                    previousRound = _hand.rounds[currentRoundIdx - 1];
+                    // Put previous round winner as forehand
+                    if (previousRound && previousRound.winner && !previousRound.tie) {
+                        newTurn = match.table.getPlayerPosition(previousRound.winner.id);
+                        if (newTurn !== -1) {
+                            _hand.setTurn(newTurn);
+                        }
+                    }
+                    _a.label = 2;
+                case 2:
+                    if (!(i < match.table.players.length)) return [3 /*break*/, 4];
+                    _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++;
+                    return [4 /*yield*/, _hand];
+                case 3:
+                    _a.sent();
+                    return [3 /*break*/, 2];
+                case 4:
+                    teamIdx = (0, utils_1.checkHandWinner)(_hand.rounds, forehandTeamIdx);
+                    if (teamIdx !== null) {
+                        _hand.addPoints(teamIdx, truco);
+                        _hand.setFinished(true);
+                    }
+                    currentRoundIdx++;
+                    return [3 /*break*/, 1];
+                case 5: return [4 /*yield*/, _hand];
+                case 6:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }
+    var roundsGenerator = roundsGeneratorSequence();
+    var _hand = {
+        idx: idx,
+        turn: Number(match.table.forehandIdx),
+        rounds: [],
+        finished: false,
+        points: {
+            0: 0,
+            1: 0
+        },
+        currentRound: null,
+        currentPlayer: null,
+        play: function () {
+            return PlayInstance(_hand);
+        },
+        pushRound: function (round) {
+            _hand.rounds.push(round);
+            return round;
+        },
+        setTurn: function (turn) {
+            _hand.turn = turn;
+            return match.table.player(_hand.turn);
+        },
+        addPoints: function (team, points) {
+            _hand.points[team] = _hand.points[team] + points;
+        },
+        setCurrentRound: function (round) {
+            _hand.currentRound = round;
+            return _hand.currentRound;
+        },
+        setCurrentPlayer: function (player) {
+            _hand.currentPlayer = player;
+            return _hand.currentPlayer;
+        },
+        setFinished: function (finshed) {
+            _hand.finished = finshed;
+            return _hand.finished;
+        },
+        getNextPlayer: function () {
+            return roundsGenerator.next();
+        },
+    };
+    return _hand;
+}
+function Player(id, teamIdx) {
+    var _player = {
+        id: id,
+        teamIdx: teamIdx,
+        hand: [],
+        usedHand: [],
+        setHand: function (hand) {
+            _player.hand = hand;
+            _player.usedHand = [];
+            return hand;
+        },
+        useCard: function (idx) {
+            if (_player.hand[idx]) {
+                var card = _player.hand.splice(idx, 1)[0];
+                _player.usedHand.push(card);
+                return card;
+            }
+            return null;
+        }
+    };
+    return _player;
+}
+exports.Player = Player;
+function Team(color, players) {
+    var _team = {
+        _players: new Map(),
+        get players() {
+            return Array.from(_team._players.values());
+        },
+        color: color,
+        points: 0,
+        addPoints: function (points) {
+            _team.points += points;
+            return _team.points;
+        },
+    };
+    players.forEach(function (player) { return _team._players.set(player.id, player); });
+    return _team;
+}
+exports.Team = Team;

package/build/lib/types.d.ts

@@ -0,0 +1,101 @@
+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;
+    1: number;
+    2?: number;
+};
+export type IGetNextPlayerResult = {
+    currentPlayer?: IPlayer;
+    currentRound?: IRound;
+    points?: IPoints;
+};
+export declare enum EHandPlayCommand {
+    TRUCO = 0,
+    ENVIDO = 1,
+    ENVIDO_ENVIDO = 2,
+    REAL_ENVIDO = 3,
+    FALTA_ENVIDO = 4,
+    MAZO = 5,
+    FLOR = 6,
+    CONTRAFLOR = 7
+}
+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/build/lib/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EHandPlayCommand = void 0;
+var EHandPlayCommand;
+(function (EHandPlayCommand) {
+    EHandPlayCommand[EHandPlayCommand["TRUCO"] = 0] = "TRUCO";
+    EHandPlayCommand[EHandPlayCommand["ENVIDO"] = 1] = "ENVIDO";
+    EHandPlayCommand[EHandPlayCommand["ENVIDO_ENVIDO"] = 2] = "ENVIDO_ENVIDO";
+    EHandPlayCommand[EHandPlayCommand["REAL_ENVIDO"] = 3] = "REAL_ENVIDO";
+    EHandPlayCommand[EHandPlayCommand["FALTA_ENVIDO"] = 4] = "FALTA_ENVIDO";
+    EHandPlayCommand[EHandPlayCommand["MAZO"] = 5] = "MAZO";
+    EHandPlayCommand[EHandPlayCommand["FLOR"] = 6] = "FLOR";
+    EHandPlayCommand[EHandPlayCommand["CONTRAFLOR"] = 7] = "CONTRAFLOR";
+})(EHandPlayCommand = exports.EHandPlayCommand || (exports.EHandPlayCommand = {}));

package/build/lib/utils.d.ts

@@ -0,0 +1,5 @@
+import { ICard, IRound, ITeam } from "./types";
+export declare function getCardValue(card: ICard): number;
+export declare function shuffleArray<T = never>(array: Array<T>): T[];
+export declare function checkHandWinner(rounds: Array<IRound>, forehandTeamIdx: 0 | 1): null | 0 | 1;
+export declare function checkMatchWinner(teams: Array<ITeam>, matchPoint: number): ITeam | null;

package/build/lib/utils.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMatchWinner = exports.checkHandWinner = exports.shuffleArray = exports.getCardValue = void 0;
+var constants_1 = require("./constants");
+function getCardValue(card) {
+    return constants_1.CARDS[card] || -1;
+}
+exports.getCardValue = getCardValue;
+function shuffleArray(array) {
+    var _a;
+    var currentIndex = array.length, randomIndex;
+    while (currentIndex != 0) {
+        randomIndex = Math.floor(Math.random() * currentIndex);
+        currentIndex--;
+        _a = [
+            array[randomIndex], array[currentIndex]
+        ], array[currentIndex] = _a[0], array[randomIndex] = _a[1];
+    }
+    return array;
+}
+exports.shuffleArray = shuffleArray;
+function checkHandWinner(rounds, forehandTeamIdx) {
+    var _a, _b;
+    var roundsWon = {
+        0: 0,
+        1: 0,
+        2: 0 // tied rounds
+    };
+    for (var i = 0; i < rounds.length; i++) {
+        var round = rounds[i];
+        if (round.tie) {
+            roundsWon[0] += 1;
+            roundsWon[1] += 1;
+            roundsWon[2] = (roundsWon[2] || 0) + 1;
+            continue;
+        }
+        if (((_a = round.winner) === null || _a === void 0 ? void 0 : _a.teamIdx) === 0) {
+            roundsWon[0] += 1;
+        }
+        if (((_b = round.winner) === null || _b === void 0 ? void 0 : _b.teamIdx) === 1) {
+            roundsWon[1] += 1;
+        }
+    }
+    var 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;
+}
+exports.checkHandWinner = checkHandWinner;
+function checkMatchWinner(teams, matchPoint) {
+    if (teams[0].points >= matchPoint) {
+        return teams[0];
+    }
+    if (teams[1].points >= matchPoint) {
+        return teams[1];
+    }
+    return null;
+}
+exports.checkMatchWinner = checkMatchWinner;

package/build/server/index.d.ts

@@ -0,0 +1 @@
+export {};

package/build/server/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var http_1 = require("http");
+var socket_io_1 = require("socket.io");
+var PORT = 4001;
+var httpServer = (0, http_1.createServer)();
+var io = new socket_io_1.Server(httpServer, {
+    cors: {
+        origin: "http://localhost:3000",
+        methods: ["GET", "POST"]
+    }
+});
+io.on("connection", function (socket) {
+    socket.on('ping', function (msg) {
+        io.emit('pong', msg);
+    });
+});
+httpServer.listen(PORT);
+console.log('Listening on port', PORT);

package/build/server/types.js

@@ -0,0 +1 @@
+"use strict";

package/build/test/autoplay.d.ts

@@ -0,0 +1 @@
+export {};