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-02-22 17:53:48 +08:00
parent 3bdfeaec64
commit ff5cce11da
5 changed files with 450 additions and 423 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

143
src/common/DataParser.ts
View File

@ -1,84 +1,83 @@
import * as jetpack from "fs-jetpack"; import * as jetpack from 'fs-jetpack'
import {singleton} from "./Singleton"; import { GameEnv } from '../cfg/GameEnv'
import {GameEnv} from "../cfg/GameEnv"; import { BaseConst } from '../constants/BaseConst'
import {BaseConst} from "../constants/BaseConst"; import { error } from './Debug'
import {error} from "./Debug";
const $cfg = new Map(); const $cfg = new Map()
const jsonPath = 'config'; const jsonPath = 'config'
export var DataParser = (function (){ export var DataParser = (function () {
const parsers: { [index: string]: ConfigDataParser } = {}; const parsers: { [index: string]: ConfigDataParser } = {}
return { return {
regParser, regParser,
regCommonParser(key: string, CfgCreator: { new (): Cfg }, idkey = "id") { regCommonParser(key: string, CfgCreator: { new(): Cfg }, idkey = 'id') {
regParser(key, (data: any[]): any => { regParser(key, (data: any[]): any => {
if (!data) return; if (!data) return
let dict = new Map(); let dict = new Map()
for (let i = 0, len = data.length; i < len; i++) { for (let i = 0, len = data.length; i < len; i++) {
let obj = data[i]; let obj = data[i]
if (!obj[idkey]) { if (!obj[idkey]) {
error(`配置${key}的数据有误，唯一标识 ${idkey} 值为0或者没有${idkey}`); error(`配置${ key }的数据有误，唯一标识 ${ idkey } 值为0或者没有${ idkey }`)
continue; continue
} }
let to = new CfgCreator(); let to = new CfgCreator()
to.decode(obj); to.decode(obj)
if (dict.has(to.id)) { if (dict.has(to.id)) {
error(`配置${key}的数据有误，唯一标识 id 有重复值：${to.id}`) error(`配置${ key }的数据有误，唯一标识 id 有重复值：${ to.id }`)
process.abort(); process.abort()
} }
dict.set(to.id, to); dict.set(to.id, to)
} }
return dict; return dict
}); })
}, },
loadAll() { loadAll() {
let fileArr = jetpack.list(jsonPath); let fileArr = jetpack.list(jsonPath)
for (let f of fileArr) { for (let f of fileArr) {
let key = f.replace('_tbl.json', ''); let key = f.replace('_tbl.json', '')
let parser = parsers[key]; let parser = parsers[key]
let json = jetpack.read(`${jsonPath}/${f}`, 'json'); let json = jetpack.read(`${ jsonPath }/${ f }`, 'json')
if (parser && json){ if (parser && json) {
if (Array.isArray(json)) { if (Array.isArray(json)) {
let data = parser(json); let data = parser(json)
if (data) { // 支持一些void的情况 if (data) { // 支持一些void的情况
$cfg.set(key, data); $cfg.set(key, data)
}
} else {
$cfg.set(key, json);
}
}
} }
new GameEnv().init($cfg.get(BaseConst.COMPOUND)); } else {
Object.assign(global, { $cfg.set(key, json)
$cfg: $cfg }
}) }
}, }
new GameEnv().init($cfg.get(BaseConst.COMPOUND))
Object.assign(global, {
$cfg: $cfg
})
} }
/** }
* 注册配置解析
* @param key 配置的标识 /**
* @param parser 解析器 * 注册配置解析
*/ * @param key 配置的标识
function regParser(key: string, parser: ConfigDataParser) { * @param parser 解析器
parsers[key] = parser; */
} function regParser(key: string, parser: ConfigDataParser) {
})(); parsers[key] = parser
}
})()
/** /**
* 配置数据解析函数 * 配置数据解析函数
*/ */
export interface ConfigDataParser { export interface ConfigDataParser {
(data: any): any; (data: any): any;
} }
export interface Cfg export interface Cfg {
{ /**
/** * 解析配置
* 解析配置 * @param {*} data
* @param {*} data * @param {*} [local] 没有接口，但是需要本地赋值的数据
* @param {*} [local] 没有接口，但是需要本地赋值的数据 */
*/ decode?: { (local?: any): void };
decode?: { (local?: any):void }; id?: number;
id?: number;
} }

515
src/global.d.ts vendored
View File

@ -1,299 +1,308 @@
import {IMsg} from "./message/IMsg"; import { IMsg } from './message/IMsg'
import {Client, Room} from "colyseus"; import { Client } from 'colyseus'
import {PetInfo, PetInfoMsg} from "./message/PetInfo"; import { PetInfo, PetInfoMsg } from './message/PetInfo'
import {BattleHandler} from "./rooms/logic/Handler/BattleHandler"; import { BattleHandler } from './rooms/logic/Handler/BattleHandler'
import {SkillInfoMsg} from "./message/SkillInfo"; import { SkillInfoMsg } from './message/SkillInfo'
import {PartResultMsg} from "./message/PartResult"; import { PartResultMsg } from './message/PartResult'
import {RemovePetMsg} from "./message/RemovePetMsg"; import { RemovePetMsg } from './message/RemovePetMsg'
import {Dispatcher} from "@colyseus/command"; import { Dispatcher } from '@colyseus/command'
import {Delayed} from "@gamestdio/timer/lib/Delayed"; import { Delayed } from '@gamestdio/timer/lib/Delayed'
import {Player} from "./rooms/schema/Player"; import { Player } from './rooms/schema/Player'
import {RobotClient} from "./robot/RobotClient"; import { RobotClient } from './robot/RobotClient'
export {}; export {}
declare global { declare global {
namespace NodeJS { namespace NodeJS {
interface Global { interface Global {
NODE_ENV: string NODE_ENV: string
ROOT_PATH: string ROOT_PATH: string
$cfg: any $cfg: any
isProd: boolean isProd: boolean
}
} }
}
} }
/** /**
* GeneralRoom 扩展方法 * GeneralRoom 扩展方法
*/ */
declare module "colyseus" { declare module 'colyseus' {
interface Room { interface Room {
battleMan: BattleHandler; battleMan: BattleHandler;
dispatcher: Dispatcher; dispatcher: Dispatcher;
mainClock: Delayed; mainClock: Delayed;
robotCount: number; robotCount: number;
match: string | undefined ; match: string | undefined;
score: number; score: number;
/**
* 根据sessionId获取client
* @param player 玩家id或者玩家的对象
*/
getClient(player: string | Player): Client;
/** /**
* 获取当前room的client数量 * 根据sessionId获取client
*/ * @param player 玩家id或者玩家的对象
clientCount(): number; */
// >>>>>>>>> Begin of extend send message <<<<<<<<<<<<< getClient(player: string | Player): Client;
/**
* 广播玩家加入房间
* @param data
* @param options
*/
bUserJoin(data?: any, options?: any): void;
/** /**
* 广播玩家离开 * 获取当前room的client数量
* @param data */
*/ clientCount(): number;
bUserLeft(data?: any): void;
/** // >>>>>>>>> Begin of extend send message <<<<<<<<<<<<<
* 给指定用户下发英雄选择结果 /**
* @param client * 广播玩家加入房间
* @param data * @param data
*/ * @param options
sSelectHero(client: Client, data?: any):void; */
bUserJoin(data?: any, options?: any): void;
/** /**
* 广播英雄选择结果 * 广播玩家离开
* @param data * @param data
*/ */
bSelectHero(data?: any):void; bUserLeft(data?: any): void;
/** /**
* 下发抽牌信息 * 给指定用户下发英雄选择结果
* @param client * @param client
* @param data * @param data
*/ */
sDrawCard(client: Client, data?: any):void; sSelectHero(client: Client, data?: any): void;
/**
* 广播英雄选择结果
* @param data
*/
bSelectHero(data?: any): void;
/**
* 下发抽牌信息
* @param client
* @param data
*/
sDrawCard(client: Client, data?: any): void;
/** /**
* 增加一个随从 * 增加一个随从
* @param data * @param data
*/ */
bAddPet(data?: PetInfoMsg): void; bAddPet(data?: PetInfoMsg): void;
/** /**
* 施放一个技能 * 施放一个技能
* @param data * @param data
*/ */
bCastSkill(data?: SkillInfoMsg): void; bCastSkill(data?: SkillInfoMsg): void;
/** /**
* 广播偷卡信息 * 广播偷卡信息
* @param data * @param data
* @param options * @param options
*/ */
bStealCard(data?: any, options?: any):void; bStealCard(data?: any, options?: any): void;
/** /**
* 单独下发一个偷卡信息 * 单独下发一个偷卡信息
* @param data * @param data
*/ */
sStealCard(data?: any):void; sStealCard(data?: any): void;
/** /**
* 广播一个抽卡信息 * 广播一个抽卡信息
* @param data * @param data
* @param options * @param options
*/ */
bDrawCard(data?: any, options?: any):void; bDrawCard(data?: any, options?: any): void;
/** /**
* 广播一个弃卡信息 * 广播一个弃卡信息
* @param data * @param data
* @param options * @param options
*/ */
bRemoveCard(data?: any, options?: any):void; bRemoveCard(data?: any, options?: any): void;
/** /**
* 移除随从 * 移除随从
* @param data * @param data
* @param options * @param options
*/ */
bRemovePet(data?: RemovePetMsg, options?: any): void; bRemovePet(data?: RemovePetMsg, options?: any): void;
/**
* 广播游戏进行中的决斗结果
* @param data
* @param options
*/
bPartResult(data?: PartResultMsg, options?: any): void;
/** /**
* 广播游戏最终结果 * 广播游戏进行中的决斗结果
* @param data * @param data
* @param options * @param options
*/ */
bGameResult(data?: any, options?: any): void; bPartResult(data?: PartResultMsg, options?: any): void;
/** /**
* 发送换卡消息 * 广播游戏最终结果
* @param client * @param data
* @param data * @param options
*/ */
sChangeCard(client: Client, data?: any):void; bGameResult(data?: any, options?: any): void;
/** /**
* 发需要替换随从的消息给客户端 * 发送换卡消息
* @param player * @param client
* @param data * @param data
*/ */
sNeedChangePet(player: string | Player, data?: any): void; sChangeCard(client: Client, data?: any): void;
/** /**
* 发送给个人的消息列表 * 发需要替换随从的消息给客户端
* @param client * @param player
* @param data * @param data
*/ */
sMsgQueue(client: Client, data: IMsg[]): void; sNeedChangePet(player: string | Player, data?: any): void;
/**
* 发送给个人的消息列表
* @param client
* @param data
*/
sMsgQueue(client: Client, data: IMsg[]): void;
/** /**
* 广播的消息列表 * 广播的消息列表
* 例: * 例:
* let datas:IMsg[] = []; * let datas:IMsg[] = [];
* datas.push({errcode: 0, type: '消息类型', data: {pid: 1}}); * datas.push({errcode: 0, type: '消息类型', data: {pid: 1}});
* this.room.bMsgQueue(datas); * this.room.bMsgQueue(datas);
* @param datas * @param datas
* @param options * @param options
*/ */
bMsgQueue(datas: IMsg[], options?: any): void; bMsgQueue(datas: IMsg[], options?: any): void;
send(client: Client, type: string, data?: any): void; send(client: Client, type: string, data?: any): void;
// >>>>>>>>> End of extend send message <<<<<<<<<<<<< // >>>>>>>>> End of extend send message <<<<<<<<<<<<<
// >>>>>>>>> Begin of extend functions <<<<<<<<<<<<< // >>>>>>>>> Begin of extend functions <<<<<<<<<<<<<
/** /**
* 随机从一个玩家那里抽一定数量的卡, 并将抽卡信息广播出去 * 随机从一个玩家那里抽一定数量的卡, 并将抽卡信息广播出去
* @param srcplayer * @param srcplayer
* @param dstplayer 目标玩家 * @param dstplayer 目标玩家
* @param count 抽卡数量 * @param count 抽卡数量
*/ */
drawCardFromPlayer(srcplayer: string, dstplayer: string, count: number) :number; drawCardFromPlayer(srcplayer: string, dstplayer: string, count: number): number;
/** /**
* 弃卡, 并广播消息 * 弃卡, 并广播消息
* @param dstplayer 目标玩家 * @param dstplayer 目标玩家
* @param count * @param count
* @param fromplayer * @param fromplayer
*/ */
giveUpCard(dstplayer: string, count: number, fromplayer?: string): number; giveUpCard(dstplayer: string, count: number, fromplayer?: string): number;
/** /**
* 补卡, 并广播消息 * 补卡, 并广播消息
* @param dstplayer 目标玩家 * @param dstplayer 目标玩家
* @param count 补多少张, 该值和max_count至少一个不为0 * @param count 补多少张, 该值和max_count至少一个不为0
* @param max_count 补到多少张, 如果count和max_count都不为0, 则抽 Math.min(count, (max_count - 当前手牌数)) * @param max_count 补到多少张, 如果count和max_count都不为0, 则抽 Math.min(count, (max_count - 当前手牌数))
* @param source 0: 正常抽卡, 1: 技能, 2: gm命令抽的卡 * @param source 0: 正常抽卡, 1: 技能, 2: gm命令抽的卡
* @param fromplayer * @param fromplayer
* @param extData 将抽到的卡变成特定的效果 * @param extData 将抽到的卡变成特定的效果
*/ */
addCard(dstplayer: string, count: number, max_count: number, source?: number, fromplayer?: string, extData?: {}): number; addCard(dstplayer: string, count: number, max_count: number, source?: number, fromplayer?: string, extData?: {}): number;
/** /**
* 更新玩家血量 * 更新玩家血量
* @param dstplayer * @param dstplayer
* @param hp * @param hp
* @param reason * @param reason
* @param fromplayer * @param fromplayer
*/ */
updateHp(dstplayer: string, hp: number, reason?: string, fromplayer?: string): number; updateHp(dstplayer: string, hp: number, reason?: string, fromplayer?: string): number;
/** /**
* 更新随从信息 * 更新随从信息
* @param datas * @param datas
* @param fromplayer * @param fromplayer
*/ */
updatePet(datas: PetInfo[], fromplayer?: string): void; updatePet(datas: PetInfo[], fromplayer?: string): void;
/**
* 更新随从信息, 统计用
* @param datas
* @param fromplayer
*/
updatePetStat(datas: PetInfo[], fromplayer?: string): void;
/** /**
* 给room.mainClock设定任务 * 更新随从信息, 统计用
* mainClock任何时候只有一个可执行的任务 * @param datas
* @param millisecond * @param fromplayer
* @param handler */
* @param name updatePetStat(datas: PetInfo[], fromplayer?: string): void;
*/
beginSchedule(millisecond: number, handler: Function, name: string): void;
/** /**
* 取消当前room.mainClock的任务 * 给room.mainClock设定任务
* mainClock任何时候只有一个可执行的任务 * mainClock任何时候只有一个可执行的任务
* 返回当前剩余的毫秒数 * @param millisecond
* @param name * @param handler
*/ * @param name
stopSchedule(name: string): number; */
/** beginSchedule(millisecond: number, handler: Function, name: string): void;
* 给room.mainClock增加n秒
* @param name
* @param millisecond
* @param reason
*/
addScheduleTime(millisecond: number, reason?: string, name?: string, ): void;
/** /**
* 为一个玩家生产n张指定效果id的卡 * 取消当前room.mainClock的任务
* @param effectId * mainClock任何时候只有一个可执行的任务
* @param count * 返回当前剩余的毫秒数
* @param player * @param name
* @param fromplayer */
*/ stopSchedule(name: string): number;
generateCard({player, count, effectId, fromplayer, options}
: {player: string | Player,
count: number,
effectId: number,
fromplayer?: string | Player,
options?: any}): number;
/**
* 添加一个机器人
* @param playerId
*/
addRobot(playerId?: string):void;
/** /**
* 添加一个辅助机器人 * 给room.mainClock增加n秒
* @param sessionId * @param name
*/ * @param millisecond
addAssistClient(sessionId: string): void; * @param reason
/** */
* 获取当前session的辅助机器人 addScheduleTime(millisecond: number, reason?: string, name?: string): void;
* @param sessionId
*/
getAssistClient(sessionId: string): RobotClient;
/** /**
* 获取对位玩家 * 为一个玩家生产n张指定效果id的卡
* @param srcPlayer * @param effectId
*/ * @param count
getOppositePlayer(srcPlayer: string|Player): Player; * @param player
* @param fromplayer
*/
generateCard({ player, count, effectId, fromplayer, options }
: {
player: string | Player,
count: number,
effectId: number,
fromplayer?: string | Player,
options?: any
}): number;
/** /**
* 根据index获取玩家 * 添加一个机器人
* @param {number} idx * @param playerId
* @return {Player} */
*/ addRobot(playerId?: string): void;
getPlayerByIdx(idx: number): Player;
} /**
* 添加一个辅助机器人
* @param sessionId
*/
addAssistClient(sessionId: string): void;
/**
* 获取当前session的辅助机器人
* @param sessionId
*/
getAssistClient(sessionId: string): RobotClient;
/**
* 获取对位玩家
* @param srcPlayer
*/
getOppositePlayer(srcPlayer: string | Player): Player;
/**
* 根据index获取玩家
* @param {number} idx
* @return {Player}
*/
getPlayerByIdx(idx: number): Player;
}
} }

1
src/index.ts
View File

@ -4,7 +4,6 @@ import cors from 'cors'
import { RedisPresence, Server } from 'colyseus' import { RedisPresence, Server } from 'colyseus'
import { monitor } from '@colyseus/monitor' import { monitor } from '@colyseus/monitor'
import rateLimit from 'express-rate-limit' import rateLimit from 'express-rate-limit'
// import socialRoutes from "@colyseus/social/express"
import { GeneralRoom } from './rooms/GeneralRoom' import { GeneralRoom } from './rooms/GeneralRoom'
import { initData } from './common/GConfig' import { initData } from './common/GConfig'
import { Config } from './cfg/Config' import { Config } from './cfg/Config'

43
src/rooms/RankedLobbyRoom.ts
View File

@ -2,7 +2,7 @@ import { Client, generateId, matchMaker, Room, ServerError } from 'colyseus'
import { BaseConst } from '../constants/BaseConst' import { BaseConst } from '../constants/BaseConst'
import { IncomingMessage } from 'http' import { IncomingMessage } from 'http'
import { checkMatchTicket } from '../common/WebApi' import { checkMatchTicket } from '../common/WebApi'
import { error, matchlog } from '../common/Debug' import { matchlog } from '../common/Debug'
import { retry } from 'colyseus/lib/Utils' import { retry } from 'colyseus/lib/Utils'
import { RoomListingData } from 'colyseus/lib/matchmaker/drivers/Driver' import { RoomListingData } from 'colyseus/lib/matchmaker/drivers/Driver'
@ -30,15 +30,12 @@ interface ClientStat {
export class RankedLobbyRoom extends Room { export class RankedLobbyRoom extends Room {
/** /**
* If `allowUnmatchedGroups` is true, players inside an unmatched group (that * 如果该值为true, 而且玩家所在组的等待时间已经达到maxWaitingTime, 那么系统就会匹配机器人给该组
* did not reached `numClientsToMatch`, and `maxWaitingTime` has been
* reached) will be matched together. Your room should fill the remaining
* spots with "bots" on this case.
*/ */
allowUnmatchedGroups: boolean = true allowUnmatchedGroups: boolean = true
/** /**
* Evaluate groups for each client at interval * 检查是否满足匹配条件的间隔时间
*/ */
evaluateGroupsInterval = 1000 evaluateGroupsInterval = 1000
@ -48,12 +45,12 @@ export class RankedLobbyRoom extends Room {
groups: MatchmakingGroup[] = [] groups: MatchmakingGroup[] = []
/** /**
* name of the room to create * 匹配成功后创建的房间
*/ */
roomToCreate = 'general_room' roomToCreate = 'general_room'
/** /**
* 最大匹配时间 * 最大匹配时间, 在房间建立时, 会从配置文件中获取
*/ */
maxWaitingTime = 15 * 1000 maxWaitingTime = 15 * 1000
/** /**
@ -62,28 +59,34 @@ export class RankedLobbyRoom extends Room {
*/ */
groupAddOneTime = 10 * 1000 groupAddOneTime = 10 * 1000
/**
* after this time, try to fit this client with a not-so-compatible group
*/
maxWaitingTimeForPriority?: number = 10 * 1000
/** /**
* number of players on each match * number of players on each match
*/ */
numClientsToMatch = 4 numClientsToMatch = 4
// /**
// * after a group is ready, clients have this amount of milliseconds to confirm
// * connection to the created room
// */
// cancelConfirmationAfter = 5000;
/** /**
* rank and group cache per-player * rank and group cache per-player
*/ */
stats: ClientStat[] = [] stats: ClientStat[] = []
/**
* 组队成员匹配分增值幅度
* @type {number}
*/
rank_mpa = 0.2 rank_mpa = 0.2
/**
* 同分高于平均分幅度
* @type {number}
*/
fair_ir = 1.2 fair_ir = 1.2
/**
* 跨分高于平均分幅度
* @type {number}
*/
step_ir = 1.3 step_ir = 1.3
/**
* 匹配比赛的id
* @type {string}
*/
matchid = '100001' matchid = '100001'
async onAuth(client: Client, options: any, request: IncomingMessage) { async onAuth(client: Client, options: any, request: IncomingMessage) {
@ -94,7 +97,7 @@ export class RankedLobbyRoom extends Room {
try { try {
await checkMatchTicket(accountid, this.matchid) await checkMatchTicket(accountid, this.matchid)
} catch (err) { } catch (err) {
let code = isNaN(err.message) ? 9: parseInt(err.message) let code = isNaN(err.message) ? 9 : parseInt(err.message)
throw new ServerError(code, 'not enough ticket') throw new ServerError(code, 'not enough ticket')
} }
return true return true
@ -410,7 +413,7 @@ export class RankedLobbyRoom extends Room {
Object.assign(options, matchData) Object.assign(options, matchData)
data.client.send('match_success', options) data.client.send('match_success', options)
const mdata = data.options const mdata = data.options
matchlog(`${mdata.accountid}:${mdata.score}:${mdata.rank}:${data.seat}:${client.waitingTime}`) matchlog(`${ mdata.accountid }:${ mdata.score }:${ mdata.rank }:${ data.seat }:${ client.waitingTime }`)
} }
})) }))

171
src/rooms/commands/SelectPetCommand.ts
View File

@ -1,83 +1,100 @@
import {Command} from "@colyseus/command"; import { Command } from '@colyseus/command'
import {CardGameState} from "../schema/CardGameState"; import { CardGameState } from '../schema/CardGameState'
import {Client} from "colyseus"; import { Client } from 'colyseus'
import {TurnEndCommand} from "./TurnEndCommand"; import { TurnEndCommand } from './TurnEndCommand'
import {GameEnv} from "../../cfg/GameEnv"; import { GameEnv } from '../../cfg/GameEnv'
import gameUtil from "../../utils/game.util"; import gameUtil from '../../utils/game.util'
/** /**
* 选择随从或者法术 * 选择随从或者法术
*/ */
export class SelectPetCommand extends Command<CardGameState, {client: Client, export class SelectPetCommand extends Command<CardGameState, {
cardId: number, client: Client,
playerId: string, cardId: number,
pos: number, playerId: string,
effCards: number[], pos: number,
oldpos: number effCards: number[],
}> { oldpos: number
async execute({client, cardId, playerId, pos, effCards, oldpos} = this.payload) { }> {
let sessionId = client.sessionId; async execute({
let player = this.state.players.get(sessionId); client,
let ap = 0; cardId,
let moreAp = 0; playerId,
let count = 0; pos,
let targetCard; effCards,
let effectRate = this.room.battleMan.getTransEffCardRate(player); oldpos
// 检查效果卡, 并从玩家手牌中移除 } = this.payload) {
let eff_cnt = 0; // 效果卡数量 let sessionId = client.sessionId
let dbpt_cnt = 0; // 点数翻倍卡数量 let player = this.state.players.get(sessionId)
let transCount = 0; let ap = 0
for (let eCardId of effCards) { let moreAp = 0
if (!player.cards.has(eCardId + '')) { let count = 0
continue; let targetCard
} let effectRate = this.room.battleMan.getTransEffCardRate(player)
let card = player.cards.get(eCardId + '').clone(); // 检查效果卡, 并从玩家手牌中移除
player.cardQueue.push(card); let eff_cnt = 0 // 效果卡数量
if (card.type === 3) { let dbpt_cnt = 0 // 点数翻倍卡数量
dbpt_cnt ++; let transCount = 0
} else if (card.type === 2){ for (let eCardId of effCards) {
eff_cnt ++; if (!player.cards.has(eCardId + '')) {
} else { continue
transCount ++; }
} let card = player.cards.get(eCardId + '').clone()
} player.cardQueue.push(card)
gameUtil.deleteCardFromPlayer(player, effCards); if (card.type === 3) {
if (effectRate && transCount) { dbpt_cnt++
eff_cnt += (transCount / effectRate | 0); } else if (card.type === 2) {
} eff_cnt++
for (let card of this.state.cards.values()) { } else {
ap += card.number; transCount++
count ++; }
if (count === 3) {
moreAp += new GameEnv().baseAddScore;
} else if (count > 3) {
moreAp += new GameEnv().extraAddScore;
}
if (card.id == cardId) {
targetCard = card;
}
}
if (!targetCard) {
return;
}
//停止选随从计时, 并更新player.extraTime;
let elapsedTime = this.room.stopSchedule('select_pet');
if (elapsedTime >= 0) {
let count = elapsedTime - new GameEnv().playerActTime * 1000;
let newCount = player.extraTime - Math.min(count, 0);
player.extraTime = Math.max(newCount, 0);
}
let dstplayer = this.state.players.get(playerId);
let dstpet;
if (dstplayer && pos != undefined) {
dstpet = dstplayer.pets.get(pos+'');
}
let cardpoint = moreAp + ap;
let data = {srcplayer: player, card: targetCard.effect, cardpoint, eff_cnt, dstplayer, dstpet, dbpt_cnt, oldpos}
let time = this.room.battleMan.useCard(data);
await this.delay(time);
return [new TurnEndCommand()];
} }
gameUtil.deleteCardFromPlayer(player, effCards)
if (effectRate && transCount) {
eff_cnt += (transCount / effectRate | 0)
}
for (let card of this.state.cards.values()) {
ap += card.number
count++
if (count === 3) {
moreAp += new GameEnv().baseAddScore
} else if (count > 3) {
moreAp += new GameEnv().extraAddScore
}
if (card.id == cardId) {
targetCard = card
}
}
if (!targetCard) {
return
}
//停止选随从计时, 并更新player.extraTime;
let elapsedTime = this.room.stopSchedule('select_pet')
if (elapsedTime >= 0) {
let count = elapsedTime - new GameEnv().playerActTime * 1000
let newCount = player.extraTime - Math.min(count, 0)
player.extraTime = Math.max(newCount, 0)
}
let dstplayer = this.state.players.get(playerId)
let dstpet
if (dstplayer && pos != undefined) {
dstpet = dstplayer.pets.get(pos + '')
}
let cardpoint = moreAp + ap
let data = {
srcplayer: player,
card: targetCard.effect,
cardpoint,
eff_cnt,
dstplayer,
dstpet,
dbpt_cnt,
oldpos
}
let time = this.room.battleMan.useCard(data)
await this.delay(time)
return [new TurnEndCommand()]
}
} }