node/card_svr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
zhl 2021-03-16 14:43:27 +08:00
parent 3980e35d13
commit 747259977a
7 changed files with 95 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/cfg/RoomOptions.ts
View File

@ -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())
}
}

2
src/global.d.ts vendored
View File

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

4
src/rooms/GeneralRoom.ts
View File

@ -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]
}

1
src/rooms/commands/DiscardCommand.ts
View File

@ -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)
}
/**

2
src/rooms/commands/EatConfirmCommand.ts
View File

@ -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);
}

105
src/rooms/commands/TurnEndCommand.ts
View File

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

5
src/rooms/schema/Card.ts
View File

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