增加选项以控制可吃的牌是否可以延续下去

src/cfg/RoomOptions.ts

@@ -25,6 +25,18 @@ export const RULE_CANEAT = 'caneat'
  */
 export const RULE_SINGLEEAT = 'singleeat'
 
+/**
+ * 可吃的牌是否延续至下个回合, 直至被替换
+ * @type {string}
+ */
+export const RULE_EATFLOW = 'eatflow'
+
+/**
+ * 自己能不能吃自己上一轮出的牌
+ * @type {string}
+ */
+export const RULE_EATSELF = 'eatself'
+
 @singleton
 export class RoomOptions {
   /**
@@ -67,17 +79,33 @@ export class RoomOptions {
     return 0
   }
 
+  /**
+   * 可吃的牌是否延续至下个回合
+   * @param opt
+   */
+  public eatFlow(opt?: any) {
+    return 0
+  }
+
+  public eatSelf(opt?: any) {
+    return 0
+  }
+
   public initGameRule(state: CardGameState, val: number) {
     if (val) {
       state.rules.set(RULE_CANEAT, checkBitNumber(val, 1))
       state.rules.set(RULE_MULTIPLEEAT, checkBitNumber(val, 2))
       state.rules.set(RULE_DROPCARD, checkBitNumber(val, 3))
       state.rules.set(RULE_SINGLEEAT, checkBitNumber(val, 4))
+      state.rules.set(RULE_EATFLOW, checkBitNumber(val, 5))
+      state.rules.set(RULE_EATSELF, checkBitNumber(val, 6))
     } else {
       state.rules.set(RULE_CANEAT, this.canEat({advMode: state.advMode}))
       state.rules.set(RULE_MULTIPLEEAT, this.multipleEat())
       state.rules.set(RULE_DROPCARD, this.autoDiscard())
       state.rules.set(RULE_SINGLEEAT, this.singleEat())
+      state.rules.set(RULE_EATFLOW, this.eatFlow())
+      state.rules.set(RULE_EATSELF, this.eatSelf())
     }
   }
 

src/global.d.ts

@@ -333,7 +333,7 @@ declare module 'colyseus' {
     /**
      * 获取下一个玩家
      */
-    nextPlayer(): string;
+    nextPlayer(currentPlayer: string): string;
   }
 }
 

src/rooms/GeneralRoom.ts

@@ -422,11 +422,11 @@ export class GeneralRoom extends Room {
     return results
   }
 
-  nextPlayer(): string {
+  nextPlayer(currentPlayer: string): string {
     const players = [...this.state.players.values()];
     players.sort((a, b) => a.idx - b.idx);
     const sessionIds = players.map(p => p.id);
-    return (this.state.currentTurn)
+    return (currentPlayer)
       ? sessionIds[(sessionIds.indexOf(this.state.currentTurn) + 1) % sessionIds.length]
       : sessionIds[0]
   }

src/rooms/commands/DiscardCommand.ts

@@ -132,6 +132,7 @@ export class DiscardCommand extends Command<CardGameState, { client: Client, car
         this.state.cards.delete(key)
       }
       let card = tmpCards[0]
+      card.round = this.state.round
       this.state.cards.set(card.id + '', card)
     }
     /**

src/rooms/commands/EatConfirmCommand.ts

@@ -84,7 +84,7 @@ export class EatConfirmCommand extends Command<CardGameState, { timeUp: boolean
                     continue;
                 }
                 let card = player.cards.get(id + '').clone();
-                this.state.cards.set(id + '', card);
+                // this.state.cards.set(id + '', card);
                 player.cardQueue.push(card);
                 gameUtil.deleteCardFromPlayer(player, id);
             }

src/rooms/commands/TurnEndCommand.ts

@@ -1,61 +1,70 @@
-import {Command} from "@colyseus/command";
+import { Command } from '@colyseus/command'
-import {CardGameState} from "../schema/CardGameState";
+import { CardGameState } from '../schema/CardGameState'
-import {NextTurnCommand} from "./NextTurnCommand";
+import { NextTurnCommand } from './NextTurnCommand'
-import {GameResultCommand} from "./GameResultCommand";
+import { GameResultCommand } from './GameResultCommand'
-import gameUtil from "../../utils/game.util";
+import gameUtil from '../../utils/game.util'
-import {StateTypeEnum} from "../enums/StateTypeEnum";
+import { StateTypeEnum } from '../enums/StateTypeEnum'
+import { RULE_EATFLOW, RULE_EATSELF } from '../../cfg/RoomOptions'
 
 /**
  * 一轮结束
  */
 export class TurnEndCommand extends Command<CardGameState, {}> {
 
-    async execute(): Promise<Command[]> {
+  async execute(): Promise<Command[]> {
-        if (this.state.currentTurn) {
+    if (this.state.currentTurn) {
-            let player = this.state.players.get(this.state.currentTurn);
+      let player = this.state.players.get(this.state.currentTurn)
-            if (player) {
+      if (player) {
-                let delay = this.room.battleMan.onPlayerRoundEnd(player);
+        let delay = this.room.battleMan.onPlayerRoundEnd(player)
-                await this.delay(delay);
+        await this.delay(delay)
-            }
+      }
-        }
+    }
-        // if (this.state.currentTurn
+    // if (this.state.currentTurn
-        //     && sessionIds.indexOf(this.state.currentTurn) == (sessionIds.length - 1)) {
+    //     && sessionIds.indexOf(this.state.currentTurn) == (sessionIds.length - 1)) {
-        //     // 每n轮结束的时候结算一次
+    //     // 每n轮结束的时候结算一次
-        //     const roundNum = new GameEnv().duelRoundNum;
+    //     const roundNum = new GameEnv().duelRoundNum;
-        //     if (this.state.round % roundNum == (roundNum - 1)) {
+    //     if (this.state.round % roundNum == (roundNum - 1)) {
-        //         return [new PartResultCommand()];
+    //         return [new PartResultCommand()];
-        //     }
+    //     }
-        // }
+    // }
 
-        // 记录pet的maxap(最高ap) 和 maxsap(最高单体ap)
+    // 记录pet的maxap(最高ap) 和 maxsap(最高单体ap)
-        for (let [,player] of this.state.players) {
+    for (let [, player] of this.state.players) {
-            let maxAp = player.statData.get(StateTypeEnum.MAXAP) || 0;
+      let maxAp = player.statData.get(StateTypeEnum.MAXAP) || 0
-            let maxsAp = player.statData.get(StateTypeEnum.MAXSAP) || 0;
+      let maxsAp = player.statData.get(StateTypeEnum.MAXSAP) || 0
-            let totalAp = 0;
+      let totalAp = 0
-            for (let [, pet] of player.pets) {
+      for (let [, pet] of player.pets) {
-                totalAp += (pet.ap || 0 + pet.extAp || 0);
+        totalAp += (pet.ap || 0 + pet.extAp || 0)
-                maxsAp = Math.max(maxsAp, (pet.ap || 0 + pet.extAp || 0));
+        maxsAp = Math.max(maxsAp, (pet.ap || 0 + pet.extAp || 0))
-            }
+      }
-            maxAp = Math.max(maxAp, totalAp);
+      maxAp = Math.max(maxAp, totalAp)
-            player.statData.set(StateTypeEnum.MAXAP, maxAp);
+      player.statData.set(StateTypeEnum.MAXAP, maxAp)
-            player.statData.set(StateTypeEnum.MAXSAP, maxsAp);
+      player.statData.set(StateTypeEnum.MAXSAP, maxsAp)
+    }
+    // 20200316 添加
+    if (this.state.cards.size > 0 && !this.state.rules.get(RULE_EATFLOW)) {
+      const targetCard = [...this.state.cards.values()][0]
+      if (this.state.rules.get(RULE_EATSELF)) {
+        //如果可以吃自己出的牌, 那么等到下一轮自己出完牌再清空
+        if (targetCard.owner === this.state.currentTurn && targetCard.round != this.state.round) {
+          this.state.cards.clear()
         }
-        // 如果state.cards中有卡, 且卡的owner是下一轮的玩家, 那么清空cards
+      } else {
-        // 20200316 添加
+        // 如果不能吃自己的牌, 那么在下一回合自己轮开始前清空自己的牌
-        if (this.state.cards.size > 0) {
+        const nextPid = this.room.nextPlayer(this.state.currentTurn)
-            const nextPid = this.room.nextPlayer()
+        if (targetCard.owner == nextPid) {
-            const targetCard = [...this.state.cards.values()][0]
+          this.state.cards.clear()
-            if (targetCard.owner == nextPid) {
-                this.state.cards.clear()
-            }
         }
+      }
 
-        // 判断是否胜利
-        let result = gameUtil.checkGameEnd(this.state);
-        if (result) {
-            return [new GameResultCommand()];
-        }
-        return [new NextTurnCommand()]
     }
 
+    // 判断是否胜利
+    let result = gameUtil.checkGameEnd(this.state)
+    if (result) {
+      return [new GameResultCommand()]
+    }
+    return [new NextTurnCommand()]
+  }
+
 }

src/rooms/schema/Card.ts

@@ -44,4 +44,9 @@ export class Card extends Schema {
      */
     @type("number")
     effect: number;
+    /**
+     * 牌被使用的轮数
+     * @type {number}
+     */
+    round: number;
 }