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 2020-12-11 20:15:54 +08:00
parent 54c161a8e1
commit ee488c85e5
6 changed files with 135 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/index.ts
View File

@ -23,7 +23,7 @@ const server = http.createServer(app);
const gameServer = new Server({
server,
// driver: new MongooseDriver('mongodb://127.0.0.1/card-development'),
driver: new MongooseDriver('mongodb://192.168.100.24/card-development-x'),
driver: new MongooseDriver('mongodb://192.168.100.24/card-development-y'),
});
// register your room handlers

127
src/robot/RobotClient.ts
View File

@ -9,6 +9,9 @@ import {Card} from "../rooms/schema/Card";
import {BaseConst} from "../constants/BaseConst";
import arrUtil from "../utils/array.util";
import {HeroCfg} from "../cfg/parsers/HeroCfg";
import {EffectCardCfg} from "../cfg/parsers/EffectCardCfg";
import CfgMan from '../rooms/logic/CfgMan';
import {SkillTargetType} from "../rooms/logic/skill/SkillConst";
export class RobotClient implements Client {
id: string;
@ -27,6 +30,7 @@ export class RobotClient implements Client {
this.sessionId = sessionId;
this.svrstate = state;
this.clock = clock;
this.ref = new EventEmitter();
this.onMessageHandlers = onMessageHandlers;
let self = this;
let time = Math.random() * 2500 | 0;
@ -46,11 +50,11 @@ export class RobotClient implements Client {
self.selectHero();
break;
case GameStateConst.STATE_CHANGE_CARD:
self.changeCard([]);
self.changeCard();
break;
case GameStateConst.STATE_BEGIN_EAT:
if (!self.myTurn) {
setTimeout(self.giveup.bind(self), 1000);
self.eatOrGiveUp();
}
break;
case GameStateConst.STATE_ROUND_RESULT:
@ -77,6 +81,7 @@ export class RobotClient implements Client {
}
leave(code?: number, data?: string): void {
}
raw(data: ArrayLike<number>, options?: ISendOptions): void {
@ -84,13 +89,19 @@ export class RobotClient implements Client {
public send(messageOrType: any, messageOrOptions?: any | ISendOptions, options?: ISendOptions) {
log(`receive server msg: ${messageOrType}, ${messageOrOptions}`);
let self = this;
let data = messageOrOptions;
switch (messageOrType) {
case 'draw_card_s2c':
break;
case 'player_ready_s2c':
break;
case 'steal_card_s2c':
break;
case 'eat_card_s2c':
if (data.errcode == 0 && data.player == self.sessionId) {
self.selectPet();
}
break;
}
}
@ -103,23 +114,79 @@ export class RobotClient implements Client {
}
}
private checkTriple(cardArr: Card[], card?: Card): Card[] {
if (card) cardArr.push(card);
let cards = cardArr.filter(o => o.type == 1);
cards.sort((a, b) => a.number - b.number);
let result = [];
for (let i = 0, length = cards.length; i < length; i ++) {
let cur = cards[i];
i == 0 && result.push(cur);
if (i > 0) {
let isSame = false;
if (result.length > 1) {
if (result[result.length - 1].number == result[result.length - 2].number) {
isSame = true;
}
}
if ((result[result.length - 1].number == cur.number) && (isSame || result.length == 1)) {
result.push(cur);
} else if ((result[result.length - 1].number + 1 == cur.number) && (!isSame || result.length == 1)) {
result.push(cur);
} else {
result.length = 0;
result.push(cur);
}
}
}
if (result.length < 3) {
return [result[0]];
} else {
return result;
}
}
// >>>>>>>>>>>>>>>>>> begin
private discard() {
let card;
for (let [key, d] of this.cards) {
card = d;
break;
}
if (!card) {
let self = this;
let next = function () {
let cardArr = [...self.cards.values()];
// cardArr.sort((a, b) => a.number - b.number);
let cards = self.checkTriple(cardArr);
if (!cards) {
return;
}
this.reply('discard_card_c2s', {
cards: [card.id]
let cardIds = cards.map(o => o.id);
self.reply('discard_card_c2s', {
cards: cardIds
});
}
this.clock.setTimeout(next, 1500);
}
private eatOrGiveUp() {
let targetCard = [...this.svrstate.cards.values()][0];
let cardArr = [...this.cards.values()];
let tmpCards = this.checkTriple(cardArr, targetCard);
let next = this.giveup.bind(this);
if (tmpCards.length > 1) {
let cardIds: number[] = [];
for (let card of tmpCards) {
if (card.id !== targetCard.id) {
cardIds.push(card.id);
}
}
next = this.eatCard.bind(this, cardIds, targetCard.id);
}
this.clock.setTimeout(next, 1500);
}
private eatCard(cardIds: number[], target: number) {
log(`${this.sessionId} 吃牌 ${cardIds} -> ${target}`);
this.reply('eat_card_c2s', {
cards: cardIds,
target
});
}
private giveup () {
this.reply('give_up_eat_c2s', {});
}
@ -132,10 +199,44 @@ export class RobotClient implements Client {
heroId: hero[0].id
});
}
private changeCard(cardIds: number[]) {
private changeCard() {
let cardIds: number[] = [];
this.reply('change_card_c2s', {
cards: cardIds
});
}
private selectPet() {
let cards = [...this.svrstate.cards.values()];
let result;
let effectMap: Map<number, EffectCardCfg> = global.$cfg.get(BaseConst.EFFECTCARD);
for (let card of cards) {
let effect = effectMap.get(card.effect);
if (effect.type_id == 1) {
result = card;
break;
}
}
if (!result) {
result = arrUtil.randomGet(cards, 1)[0];
}
let targetType: SkillTargetType = CfgMan.getTargetByCard(result.id);
switch (targetType) {
case SkillTargetType.ENEMY_PLAYER:
break;
case SkillTargetType.ENEMY_PET:
break;
case SkillTargetType.FRIEND_PET:
break;
case SkillTargetType.SELF_PET:
break;
}
this.reply('select_pet_c2s', {
card: result.id,
player: null,
pos: null,
effCards: []
})
}
}

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

@ -79,6 +79,7 @@ export class DiscardCommand extends Command<CardGameState, { client: Client, car
this.room.battleMan.onCardLinkOver(player, cardArr);
this.state.updateGameState(GameStateConst.STATE_PICK_PET);
let self = this;
client.send('eat_card_s2c', {player: player.id, errcode: 0, errmsg: ''});
let time = singleton(GameEnv).playerActTime * 1000 + player.extraTime;
// 开启选随从计时, 计时结束后结束当前轮
let timeOverSelectPet = function () {

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

@ -64,6 +64,9 @@ export class EatConfirmCommand extends Command<CardGameState, { timeUp: boolean
* 否则继续等待
*/
// 吃牌逻辑
if (player) {
debugRoom(`有人吃牌了: ${player}, 场上牌: ${this.state.cards.size}, isFirst: ${isFirst}, timeUp: ${timeUp}`);
}
if (player != null && (isFirst || timeUp)) {
// 如果有吃牌计时的话,停止吃牌计时
this.room.stopSchedule();
@ -87,12 +90,7 @@ export class EatConfirmCommand extends Command<CardGameState, { timeUp: boolean
self.room.dispatcher.dispatch(new TurnEndCommand());
}
self.room.beginSchedule(time, timeOverSelectPet, `select_pet_${player.id}`);
// this.room.mainClock = this.clock.setTimeout(function () {
// player.extraTime = 0;
// self.room.mainClock.clear();
// debugRoom('选随从或者法术时间到, 自动出牌, 自动进入下一轮');
// self.room.dispatcher.dispatch(new TurnEndCommand());
// }, time);
let fromPlayer = this.state.players.get(this.state.currentTurn);
if (fromPlayer.id !== player.id) {
this.room.battleMan.onCardLinkOver(player, cardArr, fromPlayer);
@ -100,7 +98,9 @@ export class EatConfirmCommand extends Command<CardGameState, { timeUp: boolean
this.room.battleMan.onCardLinkOver(player, cardArr);
}
// 成功后广播吃牌成功消息
this.room.broadcast('eat_card_s2c', {player: player.id, errocode: 0, errmsg: ''});
let client = this.room.getClient(player.id);
this.room.broadcast('eat_card_s2c', {player: player.id, errcode: 0, errmsg: ''}, {except: client});
client.send('eat_card_s2c', {player: player.id, errcode: 0, errmsg: ''});
// 向其他玩家发送吃卡失败的消息
for (let [key, val] of tmpActionMap) {
if (typeof val != 'number' && key !== player.id) {

15
src/rooms/commands/GameResultCommand.ts
View File

@ -5,7 +5,7 @@ import {PlayerStateConst} from "../../constants/PlayerStateConst";
import {Pet} from "../schema/Pet";
import {singleton} from "../../common/Singleton";
import {GameEnv} from "../../cfg/GameEnv";
import {error} from "../../common/Debug";
import {debugRoom, error} from "../../common/Debug";
/**
* 游戏结束
@ -21,19 +21,18 @@ export class GameResultCommand extends Command<CardGameState, {}> {
let resultTimeOver = async function () {
let restartCount = 0;
// 踢出没离开并没点击重新开始的玩家
debugRoom(`restart_schedule 倒计时结束, 有 ${restartCount} 人点击重玩`)
if (self.state.restartCount == 0) {
// 没有任何人点重新开始, 则解散房间
await self.room.disconnect();
} else if (self.state.restartCount < self.room.maxClients){
// 如果点击重开的玩家少于房间最大人数, 则把房间设为公开, 等待其他玩家匹配进来
for (let [,player] of self.state.players) {
if (player.state !== PlayerStateConst.PLAYER_READY) {
let client = self.room.getClient(player);
client.leave();
} else {
restartCount ++;
}
}
if (restartCount == 0) {
// 没有任何人点重新开始, 则解散房间
await self.room.disconnect();
} else if (restartCount < self.room.maxClients){
// 如果点击重开的玩家少于房间最大人数, 则把房间设为公开, 等待其他玩家匹配进来
await self.room.unlock();
await self.room.setPrivate(false);
} else { // 如果4个人都点击了重开, 理论上不存在这种情况

17
src/rooms/commands/ReStartCommand.ts
View File

@ -1,17 +0,0 @@
import {Command} from "@colyseus/command";
import {CardGameState} from "../schema/CardGameState";
import {GameStateConst} from "../../constants/GameStateConst";
/**
* TODO::游戏重新开始
* 某玩家点击再来一次后, 发起确认投票
* 如果所有玩家通过, 则直接进入 选英雄阶段
* 如果有玩家退出或掉线, 则??
*/
export class ReStartCommand extends Command<CardGameState, {}> {
execute() {
}
}