trucoshi 0.0.2 → 0.0.5

package/build/lib/types.d.ts

@@ -1,3 +1,4 @@
+import { IGameLoop } from ".";
 import { CARDS } from "./constants";
 export type ICard = keyof typeof CARDS;
 export interface IDeck {
@@ -14,16 +15,23 @@ 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 {
-    color: string;
     _players: Map<string, IPlayer>;
     players: Array<IPlayer>;
-    points: number;
-    addPoints(points: number): number;
+    points: TeamPoints;
+    isTeamDisabled(): boolean;
+    disable(player: IPlayer): boolean;
+    addPoints(matchPoint: number, points: number): TeamPoints;
 }
 export interface IMatch {
     teams: [ITeam, ITeam];
@@ -31,59 +39,128 @@ export interface IMatch {
     winner: ITeam | null;
     currentHand: IHand | null;
     table: ITable;
-    play(): IPlayInstance | undefined;
-    addPoints(points: IPoints): void;
+    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 type IPoints = {
+export interface TeamPoints {
+    buenas: number;
+    malas: number;
+    winner: boolean;
+}
+export interface HandPoints {
     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 RoundPoints {
+    0: number;
+    1: number;
+    ties: number;
+}
+export declare enum ESayCommand {
+    QUIERO = "QUIERO",
+    NO_QUIERO = "NO_QUIERO",
+    TRUCO = "TRUCO",
+    MAZO = "MAZO",
+    FLOR = "FLOR",
+    CONTRAFLOR = "CONTRAFLOR"
+}
+export declare 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<EHandPlayCommand> | null;
+    commands: Array<ECommand> | null;
     rounds: Array<IRound> | null;
     use(idx: number): ICard | null;
-    say(command: EHandPlayCommand): IHand | null;
+    say(command: ECommand): ECommand | null;
+}
+export declare 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;
-    finished: boolean;
-    points: IPoints;
+    points: HandPoints;
+    truco: ITruco;
+    envido: EnvidoState;
     rounds: Array<IRound>;
-    currentPlayer: IPlayer | null;
+    _currentPlayer: IPlayer | null;
+    get currentPlayer(): IPlayer | null;
+    set currentPlayer(player: IPlayer | null);
     currentRound: IRound | null;
-    play(): IPlayInstance;
+    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;
-    setFinished(finshed: boolean): boolean;
+    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>>;
@@ -97,5 +174,19 @@ export interface IRound {
     winner: IPlayer | null;
     highest: number;
     cards: Array<IPlayedCard>;
-    play(playedCard: IPlayedCard): ICard;
+    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/build/lib/types.js

@@ -1,14 +1,26 @@
 "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 = {}));
+exports.EHandState = exports.EEnvidoCommand = exports.ESayCommand = void 0;
+var ESayCommand;
+(function (ESayCommand) {
+    ESayCommand["QUIERO"] = "QUIERO";
+    ESayCommand["NO_QUIERO"] = "NO_QUIERO";
+    ESayCommand["TRUCO"] = "TRUCO";
+    ESayCommand["MAZO"] = "MAZO";
+    ESayCommand["FLOR"] = "FLOR";
+    ESayCommand["CONTRAFLOR"] = "CONTRAFLOR";
+})(ESayCommand = exports.ESayCommand || (exports.ESayCommand = {}));
+var EEnvidoCommand;
+(function (EEnvidoCommand) {
+    EEnvidoCommand["ENVIDO"] = "ENVIDO";
+    EEnvidoCommand["ENVIDO_ENVIDO"] = "ENVIDO_ENVIDO";
+    EEnvidoCommand["REAL_ENVIDO"] = "REAL_ENVIDO";
+    EEnvidoCommand["FALTA_ENVIDO"] = "FALTA_ENVIDO";
+})(EEnvidoCommand = exports.EEnvidoCommand || (exports.EEnvidoCommand = {}));
+var EHandState;
+(function (EHandState) {
+    EHandState["WAITING_PLAY"] = "WAITING_PLAY";
+    EHandState["WAITING_FOR_TRUCO_ANSWER"] = "WAITING_FOR_TRUCO_ANSWER";
+    EHandState["WAITING_ENVIDO_ANSWER"] = "WAITING_ENVIDO_ANSWER";
+    EHandState["FINISHED"] = "FINISHED";
+})(EHandState = exports.EHandState || (exports.EHandState = {}));

package/build/lib/utils.d.ts

@@ -1,5 +1,5 @@
-import { ICard, IRound, ITeam } from "./types";
+import { ICard, IRound } from "./types";
+export declare function getMaxNumberIndex<T = number>(array: Array<T>): number;
 export declare function getCardValue(card: ICard): number;
-export declare function shuffleArray<T = never>(array: Array<T>): T[];
+export declare function shuffleArray<T = unknown>(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

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkMatchWinner = exports.checkHandWinner = exports.shuffleArray = exports.getCardValue = void 0;
+exports.checkHandWinner = exports.shuffleArray = exports.getCardValue = exports.getMaxNumberIndex = void 0;
 var constants_1 = require("./constants");
+function getMaxNumberIndex(array) {
+    return array.reduce(function (accumulator, current, index) {
+        return current > array[accumulator] ? index : accumulator;
+    }, 0);
+}
+exports.getMaxNumberIndex = getMaxNumberIndex;
 function getCardValue(card) {
     return constants_1.CARDS[card] || -1;
 }
@@ -12,9 +18,7 @@ function shuffleArray(array) {
     while (currentIndex != 0) {
         randomIndex = Math.floor(Math.random() * currentIndex);
         currentIndex--;
-        _a = [
-            array[randomIndex], array[currentIndex]
-        ], array[currentIndex] = _a[0], array[randomIndex] = _a[1];
+        _a = [array[randomIndex], array[currentIndex]], array[currentIndex] = _a[0], array[randomIndex] = _a[1];
     }
     return array;
 }
@@ -24,14 +28,14 @@ function checkHandWinner(rounds, forehandTeamIdx) {
     var roundsWon = {
         0: 0,
         1: 0,
-        2: 0 // tied rounds
+        ties: 0,
     };
     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;
+            roundsWon.ties = roundsWon.ties + 1;
             continue;
         }
         if (((_a = round.winner) === null || _a === void 0 ? void 0 : _a.teamIdx) === 0) {
@@ -41,8 +45,7 @@ function checkHandWinner(rounds, forehandTeamIdx) {
             roundsWon[1] += 1;
         }
     }
-    var ties = roundsWon[2] || 0;
-    if ((roundsWon[0] > 2 && roundsWon[1] > 2) || (rounds.length > 2 && ties > 0)) {
+    if ((roundsWon[0] > 2 && roundsWon[1] > 2) || (rounds.length > 2 && roundsWon.ties > 0)) {
         return forehandTeamIdx;
     }
     if (roundsWon[0] >= 2 && roundsWon[1] < 2) {
@@ -54,13 +57,3 @@ function checkHandWinner(rounds, forehandTeamIdx) {
     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.js

@@ -2,18 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var http_1 = require("http");
 var socket_io_1 = require("socket.io");
+var types_1 = require("./types");
 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"]
-    }
+        methods: ["GET", "POST"],
+    },
 });
+var sessions = new Map();
 io.on("connection", function (socket) {
-    socket.on('ping', function (msg) {
-        io.emit('pong', msg);
+    socket.on(types_1.EClientEvent.PING, function (msg) {
+        io.emit(types_1.EServerEvent.PONG, msg);
+    });
+    socket.on(types_1.EClientEvent.CREATE_MATCH, function (msg) {
+    });
+    socket.on(types_1.EClientEvent.SET_PLAYER_ID, function (msg) {
+        if (typeof msg === 'string' && msg.length < 32) {
+        }
     });
 });
 httpServer.listen(PORT);
-console.log('Listening on port', PORT);
+console.log("Listening on port", PORT);

package/build/server/match.js

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

package/build/server/types.d.ts

@@ -0,0 +1,11 @@
+export declare enum EClientEvent {
+    PING = "PING",
+    CREATE_MATCH = "CREATE_MATCH",
+    JOIN_MATCH = "JOIN_MATCH",
+    START_MATCH = "START_MATCH",
+    SET_PLAYER_ID = "SET_PLAYER_ID"
+}
+export declare enum EServerEvent {
+    SET_SESSION_ID = "SET_SESSION_ID",
+    PONG = "PONG"
+}

package/build/server/types.js

@@ -1 +1,16 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EServerEvent = exports.EClientEvent = void 0;
+var EClientEvent;
+(function (EClientEvent) {
+    EClientEvent["PING"] = "PING";
+    EClientEvent["CREATE_MATCH"] = "CREATE_MATCH";
+    EClientEvent["JOIN_MATCH"] = "JOIN_MATCH";
+    EClientEvent["START_MATCH"] = "START_MATCH";
+    EClientEvent["SET_PLAYER_ID"] = "SET_PLAYER_ID";
+})(EClientEvent = exports.EClientEvent || (exports.EClientEvent = {}));
+var EServerEvent;
+(function (EServerEvent) {
+    EServerEvent["SET_SESSION_ID"] = "SET_SESSION_ID";
+    EServerEvent["PONG"] = "PONG";
+})(EServerEvent = exports.EServerEvent || (exports.EServerEvent = {}));

package/build/test/autoplay.js

@@ -36,38 +36,59 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var constants_1 = require("../lib/constants");
-var trucoshi_1 = require("../lib/trucoshi");
+var lib_1 = require("../lib");
 (function () { return __awaiter(void 0, void 0, void 0, function () {
-    var player1, player2, player3, player4, player5, player6, team1, team2, match, play, name, randomIdx, card;
-    var _a;
-    return __generator(this, function (_b) {
-        player1 = (0, trucoshi_1.Player)('lukini', 0);
-        player2 = (0, trucoshi_1.Player)('guada', 0);
-        player3 = (0, trucoshi_1.Player)('denoph', 1);
-        player4 = (0, trucoshi_1.Player)('juli', 1);
-        player5 = (0, trucoshi_1.Player)('fran', 1);
-        player6 = (0, trucoshi_1.Player)('day', 0);
-        team1 = (0, trucoshi_1.Team)(constants_1.COLORS[0], [player1, player2, player6]);
-        team2 = (0, trucoshi_1.Team)(constants_1.COLORS[1], [player3, player4, player5]);
-        match = (0, trucoshi_1.Match)([team1, team2], 9);
-        while (!match.winner) {
-            play = match.play();
-            if (!play || !play.player) {
-                break;
-            }
-            name = play.player.id.toUpperCase();
-            console.log("=== Mano ".concat(play.handIdx, " === Ronda ").concat(play.roundIdx, " === Turno de ").concat(name, " ==="));
-            match.teams.map(function (team, id) { return console.log("=== Team ".concat(id, " = ").concat(team.points, " Puntos ===")); });
-            console.log(play.rounds && play.rounds.length ? (play.rounds.map(function (round) { return round.cards.length ? round.cards.map(function (c) { return [c.player.id, c.card]; }) : ''; })) : '');
-            randomIdx = Math.round(Math.random() * (play.player.hand.length - 1));
-            card = play.use(randomIdx);
-            console.log("\n".concat(JSON.stringify(play.player.hand), "\nUsing ").concat(card));
-            console.log(play.rounds && play.rounds.length ? (play.rounds.map(function (round) { return round.cards.length ? round.cards.map(function (c) { return [c.player.id, c.card]; }) : ''; })) : '');
-        }
-        console.log('\n');
-        match.teams.map(function (t, i) { return console.log("Equipo ".concat(i, ": ").concat(t.players.map(function (p) { return " ".concat(p.id); }), " === ").concat(t.points, " puntos")); });
-        console.log("\nEquipo Ganador:".concat((_a = match.winner) === null || _a === void 0 ? void 0 : _a.players.map(function (p) { return " ".concat(p.id); })));
+    var trucoshi;
+    return __generator(this, function (_a) {
+        trucoshi = (0, lib_1.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(function (play) { return __awaiter(void 0, void 0, void 0, function () {
+            var name, randomIdx, handString, card;
+            var _a;
+            return __generator(this, function (_b) {
+                if (!play.player) {
+                    return [2 /*return*/];
+                }
+                name = (_a = play.player) === null || _a === void 0 ? void 0 : _a.id.toUpperCase();
+                console.log("=== Mano ".concat(play.handIdx, " === Ronda ").concat(play.roundIdx, " === Turno de ").concat(name, " ==="));
+                play.teams.map(function (team, id) {
+                    return console.log("=== Team ".concat(id, " = ").concat(team.points.malas, " malas ").concat(team.points.buenas, " buenas ==="));
+                });
+                console.log(play.rounds && play.rounds.length
+                    ? play.rounds.map(function (round) {
+                        return round.cards.length ? round.cards.map(function (c) { return [c.player.id, c.card]; }) : "";
+                    })
+                    : "");
+                randomIdx = Math.round(Math.random() * (play.player.hand.length - 1));
+                handString = JSON.stringify(play.player.hand);
+                card = play.use(randomIdx);
+                console.log("\n".concat(handString, "\nUsing ").concat(card));
+                console.log(play.rounds && play.rounds.length
+                    ? play.rounds.map(function (round) {
+                        return round.cards.length ? round.cards.map(function (c) { return [c.player.id, c.card]; }) : "";
+                    })
+                    : "");
+                return [2 /*return*/];
+            });
+        }); })
+            .onWinner(function (winner, teams) { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                console.log("\n");
+                teams.map(function (t, i) {
+                    return console.log("Equipo ".concat(i, ": ").concat(t.players.map(function (p) { return " ".concat(p.id); }), " === ").concat(t.points.malas, " malas ").concat(t.points.buenas, " buenas"));
+                });
+                console.log("\nEquipo Ganador:".concat(winner.players.map(function (p) { return " ".concat(p.id); })));
+                return [2 /*return*/];
+            });
+        }); })
+            .begin();
         return [2 /*return*/];
     });
 }); })();