trucoshi 0.0.2 → 0.0.5

package/build/test/play.js

@@ -58,91 +58,156 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var readline = __importStar(require("readline"));
-var constants_1 = require("../lib/constants");
-var trucoshi_1 = require("../lib/trucoshi");
-(function () { return __awaiter(void 0, void 0, void 0, function () {
-    var player1, player2, player3, player4, team1, team2, match, _loop_1, state_1;
-    var _a;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                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);
-                team1 = (0, trucoshi_1.Team)(constants_1.COLORS[0], [player1, player2]);
-                team2 = (0, trucoshi_1.Team)(constants_1.COLORS[1], [player3, player4]);
-                match = (0, trucoshi_1.Match)([team1, team2], 9);
-                _loop_1 = function () {
-                    var play, name, prom;
-                    return __generator(this, function (_c) {
-                        switch (_c.label) {
-                            case 0:
-                                play = match.play();
-                                if (!play || !play.player) {
-                                    return [2 /*return*/, "break"];
-                                }
-                                name = play.player.id.toUpperCase();
-                                process.stdout.write('\u001B[2J\u001B[0;0f');
-                                process.stdout.write('\u001B[0;0f');
-                                console.log("=== Mano ".concat(play.handIdx, " === Ronda ").concat(play.roundIdx, " === Turno de ").concat(name, " ==="));
-                                process.stdout.write('\u001B[2;0f');
-                                match.teams.map(function (team, id) { return console.log("=== Team ".concat(id, " = ").concat(team.points, " Puntos ===")); });
-                                process.stdout.write('\u001B[5;0f');
-                                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]; }) : ''; })) : '');
-                                prom = function () { return new Promise(function (resolve) {
-                                    var _a, _b;
-                                    var rl = readline.createInterface(process.stdin, process.stdout);
-                                    rl.setPrompt("\n".concat((_a = play.player) === null || _a === void 0 ? void 0 : _a.id, " elije una carta [1, 2, 3]: ").concat(JSON.stringify((_b = play.player) === null || _b === void 0 ? void 0 : _b.hand), "\n"));
-                                    rl.prompt();
-                                    rl.on('line', function (idx) {
-                                        var _a;
-                                        var playedCard = play.use(Number(idx) - 1);
-                                        if (!playedCard) {
-                                            rl.close();
-                                            return (function () { return __awaiter(void 0, void 0, void 0, function () {
-                                                return __generator(this, function (_a) {
-                                                    switch (_a.label) {
-                                                        case 0: return [4 /*yield*/, prom()];
-                                                        case 1:
-                                                            _a.sent();
-                                                            resolve();
-                                                            return [2 /*return*/];
-                                                    }
-                                                });
-                                            }); })();
+var lib_1 = require("../lib");
+var command = function (title, onLine) {
+    var promise = function () {
+        return new Promise(function (resolve) {
+            var rl = readline.createInterface(process.stdin, process.stdout);
+            rl.setPrompt(title);
+            rl.prompt();
+            rl.on("line", function (line) { return __awaiter(void 0, void 0, void 0, function () {
+                var e_1;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 2, , 3]);
+                            return [4 /*yield*/, onLine(line, function () { return rl.close(); })];
+                        case 1:
+                            _a.sent();
+                            rl.close();
+                            resolve();
+                            return [3 /*break*/, 3];
+                        case 2:
+                            e_1 = _a.sent();
+                            rl.close();
+                            return [2 /*return*/, (function () { return __awaiter(void 0, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0: return [4 /*yield*/, promise()];
+                                            case 1:
+                                                _a.sent();
+                                                resolve();
+                                                return [2 /*return*/];
                                         }
-                                        process.stdout.write('\u001B[7;0f');
-                                        console.log("\n".concat(JSON.stringify((_a = play.player) === null || _a === void 0 ? void 0 : _a.hand), "\nUsing ").concat(playedCard));
-                                        process.stdout.write('\u001B[10;0f');
-                                        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]; }) : ''; })) : '');
-                                        rl.close();
-                                        resolve();
                                     });
-                                }); };
-                                return [4 /*yield*/, prom()];
-                            case 1:
-                                _c.sent();
-                                return [2 /*return*/];
-                        }
-                    });
-                };
-                _b.label = 1;
-            case 1:
-                if (!!match.winner) return [3 /*break*/, 3];
-                return [5 /*yield**/, _loop_1()];
-            case 2:
-                state_1 = _b.sent();
-                if (state_1 === "break")
-                    return [3 /*break*/, 3];
-                return [3 /*break*/, 1];
-            case 3:
-                process.stdout.write('\u001B[2J\u001B[2;0f');
-                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); })));
+                                }); })()];
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+    };
+    return promise;
+};
+var playCommand = function (play) {
+    var _a, _b, _d;
+    return command("".concat((_a = play.player) === null || _a === void 0 ? void 0 : _a.id, " elije una carta [").concat((_b = play.player) === null || _b === void 0 ? void 0 : _b.hand.map(function (_c, i) { return i + 1; }), "]: ").concat(JSON.stringify((_d = play.player) === null || _d === void 0 ? void 0 : _d.hand), "\n"), function (idx) { return __awaiter(void 0, void 0, void 0, function () {
+        var playedCard, handString;
+        var _a;
+        return __generator(this, function (_b) {
+            playedCard = play.use(Number(idx) - 1);
+            if (!playedCard) {
+                return [2 /*return*/, Promise.reject()];
+            }
+            handString = JSON.stringify((_a = play.player) === null || _a === void 0 ? void 0 : _a.hand);
+            console.log("\n".concat(handString, "\nUsing ").concat(playedCard));
+            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*/, Promise.resolve()];
+        });
+    }); });
+};
+var sayCommand = function (play, canPlay) {
+    var _a, _b;
+    return command("".concat((_a = play.player) === null || _a === void 0 ? void 0 : _a.id, " elije una accion [").concat(canPlay ? "0," : "").concat((_b = play.commands) === null || _b === void 0 ? void 0 : _b.map(function (_c, i) { return i + 1; }), "]: ").concat(canPlay ? JSON.stringify(__spreadArray(["CARTA"], (play.commands || []), true)) : JSON.stringify(play.commands), "\n"), function (idx, close) { return __awaiter(void 0, void 0, void 0, function () {
+        var selectedCommand;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    selectedCommand = (_a = play.commands) === null || _a === void 0 ? void 0 : _a[Number(idx) - 1];
+                    if (selectedCommand) {
+                        play.say(selectedCommand);
+                        return [2 /*return*/, Promise.resolve()];
+                    }
+                    if (!(idx === "0" && canPlay)) return [3 /*break*/, 2];
+                    close();
+                    return [4 /*yield*/, playCommand(play)()];
+                case 1:
+                    _b.sent();
+                    return [2 /*return*/, Promise.resolve()];
+                case 2: return [2 /*return*/, Promise.reject()];
+            }
+        });
+    }); });
+};
+(function () { return __awaiter(void 0, void 0, void 0, function () {
+    var trucoshi;
+    return __generator(this, function (_a) {
+        trucoshi = (0, lib_1.Trucoshi)();
+        trucoshi.addPlayer("lukini", 0).setReady(true);
+        trucoshi.addPlayer("guada", 0).setReady(true);
+        trucoshi.addPlayer("denoph", 1).setReady(true);
+        trucoshi.addPlayer("juli", 1).setReady(true);
+        trucoshi
+            .startMatch()
+            .onTruco(function (play) { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, sayCommand(play, false)()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); })
+            .onTurn(function (play) { return __awaiter(void 0, void 0, void 0, function () {
+            var name;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        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]; }) : "";
+                            })
+                            : "");
+                        return [4 /*yield*/, sayCommand(play, true)()];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); })
+            .onWinner(function (winner, teams) { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                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 === null || winner === void 0 ? void 0 : winner.players.map(function (p) { return " ".concat(p.id); })));
                 return [2 /*return*/];
-        }
+            });
+        }); })
+            .begin();
+        return [2 /*return*/];
     });
 }); })();

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "trucoshi",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "main": "build/lib/trucoshi.js",
-  "license": "GPL3",
+  "license": "GPL-3.0",
   "scripts": {
     "install": "yarn build",
     "dev": "nodemon",
-    "test:autoplay": "yarn build && yarn run ts-node build/test/autoplay",
-    "test:play": "yarn build && yarn run ts-node build/test/play",
+    "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 ."
   },
   "devDependencies": {

package/src/lib/classes/Deck.ts

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

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

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

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

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

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