Co-authored-by: 賴鴻德 <[email protected]>

Co-authored-by: Pikacnu  <[email protected]>
Co-authored-by: Tuhacrt <[email protected]>

packages/domain_layer/src/card/type.ts

@@ -15,7 +15,7 @@ export enum Status {
 }
 
 export type Card = {
-  id?: number;
+  id?: string;
   status: Status;
   creature: Creature;
 };

packages/domain_layer/src/game/deck/createDeck.ts

@@ -3,6 +3,7 @@ import { always } from 'utils/fp';
 import A from 'fp-ts/Array';
 import O from 'fp-ts/Option';
 import { pipe } from 'fp-ts/function';
+import { Game } from 'game';
 
 type NoIdCards = Omit<Card, 'id'>[];
 
@@ -39,3 +40,19 @@ export const createDeck: CreateDeck = () =>
     concatCardOfDeck(Creature.StickBug),
     concatCardOfDeck(Creature.Toad),
   );
+
+export const createIdToCardOfDeck = (game: Game): Game =>
+  pipe(
+    //
+    game,
+    (game) => ({
+      ...game,
+      deck: pipe(
+        game.deck,
+        A.mapWithIndex<Card, Card>((idx, card) => ({
+          ...card,
+          id: idx.toString(),
+        })),
+      ),
+    }),
+  );

packages/domain_layer/src/game/index.ts

@@ -1,3 +1,4 @@
 export * from './createGame';
 export * from './type';
 export * as deck from './deck';
+export * from './dealCards';

packages/domain_layer/src/lib/lookupWithNegativeNumber.ts

@@ -0,0 +1,7 @@
+import A from 'fp-ts/Array';
+import { Option } from 'fp-ts/Option';
+
+export const lookupWithNegativeIndex =
+  (index: number) =>
+  <T>(as: Array<T>): Option<T> =>
+    index >= 0 ? A.lookup(index, as) : A.lookup(as.length + index, as);

packages/domain_layer/src/player/checkPlayerHasUnrevealedCardOfHands.test.ts

@@ -21,7 +21,7 @@ describe('checkPlayerHasUnrevealedCardOfHands', () => {
       createIdToPlayer,
       O.map((player) => {
         player.hands = [
-          { id: 1, status: Status.Unrevealed, creature: Creature.Bat },
+          { id: '1', status: Status.Unrevealed, creature: Creature.Bat },
         ];
         return player;
       }),

packages/domain_layer/src/player/currentPlayerSelectUnrevealedCard.test.ts

@@ -0,0 +1,66 @@
+import O from 'fp-ts/Option';
+import { Game } from 'game';
+import { Round } from 'round';
+import { Card, Creature, Status } from 'card';
+
+import { Player } from './type';
+import { currentPlayerSelectUnrevealedCard } from './currentPlayerSelectUnrevealedCard';
+
+describe('CurrentPlayerSelectUnrevealedCard', () => {
+  it(`given a game
+        contain player A B
+      and
+        player A hand [
+          { id: 9999, status: 'UNREVEALED', creature: 'BAT' }
+        ]
+      when player A selected { id: 9999, status: 'UNREVEALED', creature: 'BAT' }
+      then return round
+  `, () => {
+    // Arrange
+    const playerA: Player = {
+      id: '1',
+      uid: '1',
+      name: 'A',
+      hands: [],
+      pastReceivedCards: [],
+    };
+    const playerB: Player = {
+      id: '2',
+      uid: '2',
+      name: 'B',
+      hands: [],
+      pastReceivedCards: [],
+    };
+
+    const game: Game = {
+      id: '1',
+      players: [playerA, playerB],
+      rounds: [],
+      deck: [],
+    };
+
+    const card: Card = {
+      id: '9999',
+      status: Status.Unrevealed,
+      creature: Creature.Bat,
+    };
+
+    playerA.hands = [card];
+    game.deck = [card];
+
+    const round: Round = {
+      id: '1',
+      currentPlayer: playerA,
+      selectedCard: undefined,
+      state: undefined,
+    };
+
+    game.rounds = [round];
+
+    // Act
+    const result = currentPlayerSelectUnrevealedCard(game)(playerA)(card);
+
+    // Assert
+    expect(result).toMatchObject(O.some({ ...round, selectedCard: card }));
+  });
+});

packages/domain_layer/src/player/currentPlayerSelectUnrevealedCard.ts

@@ -0,0 +1,113 @@
+import { flow, pipe } from 'fp-ts/function';
+import A from 'fp-ts/Array';
+import O from 'fp-ts/Option';
+import L from 'monocle-ts/Lens';
+import { Card } from 'card';
+import { Game } from 'game';
+import { allPass, anyPass, prop } from 'remeda';
+import { Round, SelectedPlayerState } from 'round';
+import { P, match } from 'ts-pattern';
+import { always } from 'utils/fp';
+import { lookupWithNegativeIndex } from 'lib/lookupWithNegativeNumber';
+
+import { Player } from './type';
+
+interface CurrentPlayerSelectUnrevealedCard {
+  (game: Game): (player: Player) => (selectedCard: Card) => O.Option<Round>;
+}
+
+const checkPlayerIsCurrentPlayer = (player: Player) => (game: Game) =>
+  pipe(
+    game,
+    prop('rounds'),
+    A.last,
+    O.map(prop('currentPlayer')),
+    O.map(prop('id')),
+    O.map((id) => id === player.id),
+    O.getOrElse(always(false)),
+  );
+
+const isFirstRound = (game: Game) =>
+  pipe(
+    //
+    game,
+    prop('rounds'),
+    A.size,
+    (size) => size === 1,
+  );
+
+const checkPlayerHasTheCard = (player: Player) => (selectedCard: Card) =>
+  pipe(
+    //
+    player,
+    prop('hands'),
+    A.some((card) => card.id === selectedCard.id),
+  );
+
+const checkSelectCardIsAllowed = (selectedCard: Card) => (game: Game) =>
+  pipe(
+    //
+    game,
+    prop('rounds'),
+    lookupWithNegativeIndex(-2),
+    O.map((round) =>
+      match(round)
+        .with(
+          P.union(
+            {
+              state: SelectedPlayerState.GUESS_CARD_WIN,
+            },
+            {
+              state: SelectedPlayerState.GUESS_CARD_LOSS,
+            },
+            {
+              state: SelectedPlayerState.EVADE_NOT_LOOK_CARD,
+              selectedCard: {
+                id: selectedCard.id,
+              },
+            },
+            {
+              state: SelectedPlayerState.EVADE_LOOK_CARD,
+              selectedCard: {
+                id: selectedCard.id,
+              },
+            },
+          ),
+          always(true),
+        )
+        .otherwise(always(false)),
+    ),
+    O.getOrElse(always(false)),
+  );
+
+const setCardToRound = (selectedCard: Card) =>
+  pipe(
+    //
+    L.id<Round>(),
+    L.prop('selectedCard'),
+    L.modify(always(selectedCard)),
+  );
+
+export const currentPlayerSelectUnrevealedCard: CurrentPlayerSelectUnrevealedCard =
+  (game) => (player) => (selectedCard) =>
+    pipe(
+      //
+      game,
+      O.fromPredicate(
+        flow(
+          allPass([
+            checkPlayerIsCurrentPlayer(player),
+            always(checkPlayerHasTheCard(player)(selectedCard)),
+            anyPass([
+              // 第一回合可以選任何牌
+              isFirstRound,
+              // 第二回合之後只能視規則選牌
+              checkSelectCardIsAllowed(selectedCard),
+            ]),
+          ]),
+        ),
+      ),
+      O.map(prop('rounds')),
+      O.chain(A.last),
+      O.map(setCardToRound(selectedCard)),
+    );

packages/domain_layer/src/player/index.ts

@@ -1,3 +1,5 @@
 export * from './type';
 export * from './createPlayer';
 export * from './toPlayers';
+export * from './checkPlayerHasUnrevealedCardOfHands';
+export * from './currentPlayerSelectUnrevealedCard';

packages/domain_layer/src/round/createRound.ts

@@ -8,7 +8,7 @@ import Random from 'fp-ts/Random';
 import O from 'fp-ts/Option';
 import { always } from 'utils/fp';
 
-import { OmitIdRound, SelectedPlayerState } from './type';
+import { OmitIdRound, Round, SelectedPlayerState } from './type';
 
 interface CreateRound {
   (game: Game): OmitIdRound;
@@ -39,3 +39,12 @@ export const createRound: CreateRound = (game) =>
       }),
     ),
   );
+
+export const createIdToGame = (round: O.Option<OmitIdRound>): O.Option<Round> =>
+  pipe(
+    round,
+    O.map((round) => ({
+      ...round,
+      id: Random.randomInt(1, 1000)().toString(),
+    })),
+  );

packages/domain_layer/src/round/index.ts

@@ -1 +1,2 @@
 export * from './type';
+export * from './createRound';

packages/domain_layer/src/round/type.ts

@@ -1,3 +1,4 @@
+import { Card } from 'card';
 import { Player } from 'player';
 
 export enum SelectedPlayerState {
@@ -14,6 +15,7 @@ export type Round = {
   id: string;
   currentPlayer: Player;
   selectedPlayer?: Player;
+  selectedCard?: Card;
   state: SelectedPlayerState;
 };