Showing Posts From

游戏开发

用js写卡牌游戏(十)

用js写卡牌游戏(十)

没想到,上一篇这个系列的文章 居然是 2023年6月,现在2026年1月了,又一次破了我鸽的记录! 这次想起来更新这个卡牌游戏是因为我最近刷POE2非常上头,无数的天赋树和装备的组合,给这个游戏带来了无限的灵活性。如果有了解过游戏开发,一定知道虚幻引擎,它有一套 GAS 系统,通过这套系统能够让游戏的技能系统做起来又快又灵活,所以我想把这套系统的部分设计引入到我的卡牌游戏里来。 关于GAS GAS就是Gameplay Ability System,游戏玩法技能系统,但我不介绍这个完整的系统,我只介绍这个系统中的一部分,其实拆开来看,就是几个经典的设计模式组合在一起的产物。 这个GAS里有两个很重要的概念,Tag和Effect,Tag顾名思义就是标签,描述一件衣服,就可以用各种Tag来表示,比如红色、格子、长袖、尼龙等。如果有这套Tag系统,那么我只要多实现一些Tag然后进行排列组合,就能得到全新的一件物品,比如我把红色改为黑色,那么我将得到黑色的衬衫:然后就是Effect效果,从Tag可以推理出来,如果Tag对应的是状态,那么Effect对应的是改变状态的方法,如果我开发了一个“折叠效果”,对应的方法的内容是:添加 “不可折叠” Tag、添加 “可展开” Tag改变面积为原来的四分之一我就可以将这个Effect应用到衣服上,这时衣服的属性就会自动发生改变,并且神奇的是,这个Effect也可以应用到一切有“服装”Tag的物品上,我以后开发了“裤子”、“裙子”、“毛衣”全部都可以直接用。 在这些内容里,你可以看到命令模式、策略模式、状态模式等等经典设计模式的影子,他将开发的“复利”效应做到了极致,POE就是这样设计的,同样你可以在Dota2里也看到这样的设计: // 这是一个非常简单的技能,他是一个被动技能,给单位添加了一个粒子特效。 "fx_test_ability" { // General //--------------------------------------------------------- "BaseClass" "ability_datadriven" "AbilityBehavior" "DOTA_ABILITY_BEHAVIOR_PASSIVE" "AbilityTextureName" "axe_battle_hunger" // Modifiers //--------------------------------------------------------- "Modifiers" { "fx_test_modifier" { "Passive" "1" "OnCreated" { "AttachEffect" { "Target" "CASTER" "EffectName" "particles/econ/generic/generic_buff_1/generic_buff_1.vpcf" "EffectAttachType" "follow_overhead" "EffectLifeDurationScale" "1" "EffectColorA" "255 255 0" } } } } }通过定义 bahavior、modifier、"OnCreated"这样的钩子、"AttachEffect" 这样的Effect,就能配置出一个技能,无需编写代码,并且添加或者修改、组合部分属性,就是一个全新的技能。 我的设计 我的卡牌过去是这样实现的: { id: 13, name: "没毕业的天才程序员", cardType: CardType.CHARACTER, cost: 3, content: `每回合结束时,获得+1/+1`, attack: 1, life: 1, attackBase: 1, lifeBase: 1, type: [""], onMyTurnEnd: function ({thisCard, specialMethod, position}) { if (position === CardPosition.TABLE) { thisCard.attack += 1; thisCard.life += 1; specialMethod.buffCardAnimation(true, -1, -1, thisCard, thisCard) } } }并且有效果的牌都是这么实现的,可以看到每个效果都需要我单独的去写函数,或者是在对象上添加属性比如 isStrong 这种,对于代码实现不方便不优雅(还好用的是javascript),而且无法很好的保存到数据库里,只能存在代码文件中来硬编码定义。 所以想要做到像POE、Dota2那样进行配置,理想的情况下卡牌应该是这样的: { "id": 13, "name": "没毕业的天才程序员", "cost": 3, "content": "每回合结束时,获得+1/+1", "attack": 1, "life": 1, "attackBase": 1, "lifeBase": 1, "types": [], "tags": ["Tags.Character"], "effects": { "onMyTurnEnd": [ { "type": "ModifyAttribute", "target": { "type": "self" }, "params": { "attribute": "attack", "value": 1, "operation": "add" }, "conditions": [ { "type": "cardPosition", "params": { "position": "TABLE" } } ] }, { "type": "ModifyAttribute", "target": { "type": "self" }, "params": { "attribute": "life", "value": 1, "operation": "add" }, "conditions": [ { "type": "cardPosition", "params": { "position": "TABLE" } } ] } ] } }虽然说看起来内容复杂了,没有代码那么一眼看上去逻辑清晰,可是这些配置是完全能够可视化的,也就是说以后可以通过卡牌编辑器来可视化的进行卡牌配置,但是代码就无法有效的进行可视化了(对于不懂编码的人来说,比如说策划或者爱好者社区这很重要)。 所以设计任务: 1. 原来的各种属性抽象为Tag。 2. 原来的各种钩子的效果整理好,抽象为各种 Effect。 { id: 13, name: "卡牌名称", cardType: CardType.CHARACTER, // tag cost: 3, content: `卡牌内容描述`, attack: 1, life: 1, attackBase: 1, lifeBase: 1, isStrong: true, // tag isFullOfEnergy: true, // tag type: ["类型"], onMyTurnEnd: function ({thisCard, specialMethod, position}) { // effect if (position === CardPosition.TABLE) { thisCard.attack += 1; thisCard.life += 1; specialMethod.buffCardAnimation(true, -1, -1, thisCard, thisCard) } } }按照 Effect 的设想: { "onMyTurnEnd": [ { "type": "ModifyAttribute", "target": { "type": "self" }, "params": { "attribute": "attack", "value": 1, "operation": "add" }, "conditions": [ { "type": "cardPosition", "params": { "position": "TABLE" } } ] }, { "type": "ModifyAttribute", "target": { "type": "self" }, "params": { "attribute": "life", "value": 1, "operation": "add" }, "conditions": [ { "type": "cardPosition", "params": { "position": "TABLE" } } ] } ] }还是需要有过去的钩子定义,比如 onMyTurnEnd、onStart,方便我们在每个流程阶段检查卡牌是否配置了对应阶段执行的 Effect,接收 Effect 数组,方便我们进行 Effect 组合来实现非常灵活的效果。需要把所有的函数过一遍,总结一下所有的函数实现的效果,然后抽象成简单的 Effect 和对应的参数。 这样在各种流程里,比如出牌阶段,刚打出的时候可以触发卡牌的 onStart 效果 // 示意伪代码 function outCard() { // ... triggerCardEffect(card, 'onStart', baseContext); // ... }triggerCardEffect 内部简单来看可以这样设计: // 示意伪代码 function triggerCardEffect(card, trigger, baseContext) { // 获取卡牌的效果配置 const effectConfigs = card.effects?.[trigger] || []; // 构建完整上下文 const context = { ...baseContext, thisCard: card, // 还需要加各种 effect 和 tag 相关的系统环境数据 // 比如 effectRegistry、tagRegistry 用于快速获取注册了的 effect和tag,比如 effectEngine 用于执行 effect }; // 依次执行效果 effectConfigs.forEach(config => { this.executeEffect(config, context); }); }executeEffect 内部主要就是利用命令模式、策略模式来把我们实现的各种 Effect 执行逻辑应用在卡牌上: // 示意伪代码 function executeEffect(config, context) { // 获取实现的 effect 函数 const EffectClass = this.effectTypes.get(config.type); if (!EffectClass) { console.warn(`Unknown effect type: ${config.type}`); return null; } const effect = new EffectClass(config); // 检查条件 if (!effect.canExecute(context)) { return; } effect.execute(context, targets); // 处理后续效果链 if (effectConfig.then) { effectConfig.then.forEach(nextConfig => { this.executeEffect(nextConfig, context); }); } }所有的 Effect 就只需要实现预定义的各种函数,然后注册起来: /** * BaseEffect - 效果基类 * 所有具体效果类型都继承自此类 */ class BaseEffect { constructor(config) { } /** * 检查效果是否可以执行 * @param {object} context - 执行上下文 * @returns {boolean} */ canExecute(context) { return false; } /** * 执行效果 * @param {object} context - 执行上下文 * @param {Array} targets - 目标列表 */ execute(context, targets) { throw new Error("Must be implemented by subclass"); } /** * 获取效果描述文本 * @returns {string} */ getDescription() { return this.type; } }module.exports = BaseEffect;不过,都到了2026年了,我就不分享具体的代码实现过程了,我分享点别的。 实现过程 既然现在都用AI来辅助开发了,那么实际上我可以直接分享我的Prompt,这样就能够一步步的让AI在你的环境也实现相同的功能而不用是完全相同的代码。(如果AI给力的话) 我的代码编写基本是用 Claude Code(Opus4.5)和 Copilot(Opus4.5),查询资料用 Kagi Assistant 的 Research。 第一条prompt,先用Plan模式让AI做好计划: `当前的卡牌存储在 @card-game-server/cards.js 里面,可以看到卡牌的效果基本上都是用代码写的,比如 onStart onMyTurnStart 等等,这些都是钩子函数。 这种设计有一个问题,要添加卡牌,必须要能够写代码,现在需要将这个设计修改,请使用UE5的GAS的 effect tag 设计,把各种基础效果改为已经实现好的 effect 和 tag,之后的卡牌只要配置对应的 effect tag就能够实现各种能力,而新增effect tag能够让每个tag添加进来和别的tag组合成为成倍数增加的新能力。 设计需要尽可能的全面和优雅。`如果你的AI不知道UE5 GAS,那么你可能需要查询一些UE5 GAS相关的设计内容总结给AI。 AI的计划大概如下(肯定都会有不同,但没事):可以看到 Tag 带有层级,这是 组合模式 的应用,能够让我们方便的多层级进行判断,比如我们有时候只想要知道 State.Stunned 眩晕状态来让卡牌无法行动,至于是 State.Stunned.Light 还是 State.Stunned.Heavy 不重要。 Effect 也支持链式效果,能够让我们多 Effect 组合的同时,也能够链式的递归进行 Effect 调用。 这个Plan阶段可以和AI多轮讨论达到自己想要的最好情况,后续其实也能修改,但这个阶段讨论清楚是最好的。 后续就直接可以让AI开始修改,如果你是使用的Opus4.5,那么大概率这一把就能够改出八成,有可能出现下面的几种问题,这也是我碰到的。 卡牌数据没有完全迁移到新结构 有可能会出现 cards.js 还是有很多遗留数据,或者甚至就完全没有迁移,所以: `现在的卡牌已经转为使用 effect tag 来进行配置了,但是卡牌的数据 cards.js 还是使用的函数。 请把这些卡牌数据转为使用effect和tag,因为这里的数据过大,请分批次转为多个json(按照卡牌职业分类)。`AI将会分批次把 cards.js 里面的硬编码的卡牌转为新的配置的json文件:文件命名不规范 有的 Effect 会单独有一个文件夹,或者相类似能力的 Effect 会放到一起,但有的不相干的 Effect 又全部集合到了一个文件里,所以: `新增了 UtilityEffect.js 但别的effect都是单独的文件,最好这几个也用对应的文件放在一起,以后能够通过文件名来寻找对应的effect。并且请把level中的卡牌也改为effect配置的。`AI有时候因为上下文过长的问题,会出现部分代码不遵守规范的情况,这个情况也可以让AI做一份 CLAUDE.md / AGENTS.md,然后在文件里加上这个规范。 偷懒不实现缺失的Effect AI为了偷懒,创建了一个 LegacyHookEffect ,来支持用过去那种老的用函数定义效果的方法。 /** * LegacyHookEffect * 允许在 Effect 配置中调用旧版函数式卡牌效果 */ class LegacyHookEffect extends BaseEffect { constructor(config) { super(config); this.type = "LegacyHook"; } execute(context) { const { handler } = this.params; const fn = legacyCardEffects[handler]; if (typeof fn === 'function') { fn(context); } else { console.warn(`[LegacyHookEffect] handler not found: ${handler}`); } } }`LegacyHookEffect 是偷懒的行为,把这些函数定义改为effect配置就是不希望再有使用函数配置的卡牌了。 如果当前的effect设计不足以做到把所有卡牌都改为可配置effect的json表达,请告诉我哪里需要修改。如果当前的effect不足,需要新增,请告诉我要增加哪些。`并且,AI如果不够聪明,可能会出现胡乱设计的情况,所以在用AI修改的时候一定要审阅他的输出计划,并且自己对代码一定要有理解,然后及时纠正AI的错误:isStrong 等属性没有真正的用 Tag 来重构 Review代码的时候发现,AI并没有理解 Tag 这种设计(不过我们也没说),改的不够彻底,所以: `现在代码里的模仿GAS的tag系统似乎没有真正用起来,现在的tag是用ApplyTag这个Effect来模拟之前的属性做法,给卡牌加上 isStrong 这样的属性,我希望你能彻底修改为tag的做法,只需要判断卡牌的tag是否有 Status.Buff.Strong,而不需要再转回原来的属性模式,所以原来的属性模式相关的逻辑也要改为GAS的tag模式。``那这样的话,是否 cardType 其实也不需要了,直接用 tag 来实现就可以了。`这样AI会把过去的属性移除,然后用新的Tag来重构,过去判断 isStrong 的地方,都变成 hasTag(card, "Status.Buff.Strong")。 其他内容 本次还修复了一些bug,然后还增加了SQLite模式,这样大家在跑这个项目的时候就不需要再启动一个MongoDB了。 AI 实现这个 Effect 和 Tag,增加SQLite支持,外加测试和一些其他的修复bug,总共耗时1天。本来半天其实就差不多了,但是AI写的代码总是有一些不优雅,所以需要自己去微调,可以手动,也可以让AI继续改。比如 Status.Buff.Strong 这类的字符串,可以抽取常量,比如 hasTag 这类的工具方法,还有一些过去我实现过可以直接用的系统。 不过如果没有AI,这个修改起码要花好几天,大部分的代码质量也不一定有AI做的好。 下一步 翻了翻上次发的文章,说是要把AI加进去,确实可以,而且应该很简单,然后还可以做一个卡牌编辑器。 就是不知道这次要鸽多久,视频稍晚一点做完也会发。

用js写卡牌游戏(九)

用js写卡牌游戏(九)

大家好,又是好久不见。最近虽然也很忙,但还是挤了很多时间来更新这个项目。一方面,在紧张的工作之余做这个项目对我来说相当于休息,另一方面也希望在开源事业上出自己的一份力,把自己对代码的思考和大家分享探讨共同进步。 首先介绍一下对项目进行的小改动吧。修复了多个bugVue2升级到了Vue3项目的依赖全部升级到最新并且调试通过重构代码结构,将各个逻辑全部提取出来放在单独的文件中项目增加日志,并且保存日志文件新增了和好友指定开房配对的功能超时功能更加完善在项目里使用授权,用jwt作为session方案接下来对其中几个改动做详细的分享,包括:开房指定配对,超时功能,jwt授权。然后还会分享游戏中新添加的功能:职业技能。 开房指定配对 新增的和好友指定开房配对的功能是指用户可以选择与自己的好友进行一对一的匹配游戏,而不是随机匹配。这个功能实现的主要目的是为了让用户更好地和自己的朋友一起玩游戏,增加游戏的社交性。 这个功能的实现方式比较简单,之前的随机匹配创建了一个房间,只是无法指定房间号,所以这个功能只需要把之前的随机匹配稍加修改,分解为两个步骤:创建房间、加入房间。在之前的随机匹配的基础上,把房号返回给用户,但不会自动加入待匹配队列,只能通过房号进入房间。这样,用户就可以在界面上输入房号,如果房号匹配成功,后续的流程就和随机匹配一样了。 if (pvpGameMode === PvpMode.CREATE_ROOM) { // 创建房间 let roomNumber = uuidv4(); // 防止出现重复的房间号 while (getRoomData(roomNumber)) { roomNumber = uuidv4(); } console.log("create room : " + roomNumber) // r就是房间号 const seed = Math.floor(Math.random() * 10000); // 创建房间,注意这里不要设置startTime,因为还在等待对手加入 createRoomData(roomNumber, { isPve, gameMode: GameMode.PVP1, seed, rand: seedrandom(seed), round: 1 }); saveUserGameRoom(userId, roomNumber); changeRoomData(roomNumber, 'one', { userId, cardsId, socket, roomNumber, myMaxThinkTimeNumber: MAX_THINK_TIME_NUMBER }); logger.info(`roomNumber:${roomNumber} userId:${userId} cardsId:${cardsId} pvp create`); // 等待的时候把房间号发给客户端,让客户端显示在桌面 socket.emit("WAIT", { roomNumber }); socket.join(roomNumber); }// pvp部分 // 加入房间 if (pvpGameMode === PvpMode.JOIN_ROOM) { if (!r) { socket.emit("ERROR", "房间号不能为空"); return; } if (!getRoomData(r)) { socket.emit("ERROR", "房间号未找到"); return; } if (getRoomData(r).startTime) { socket.emit("ERROR", "房间游戏已经开始"); return; } // r就是房间号 const roomNumber = r; const memoryData = getRoomData(roomNumber); saveUserGameRoom(userId, roomNumber); changeRoomData(roomNumber, 'startTime', new Date()); changeRoomData(roomNumber, 'two', { userId, cardsId, socket, roomNumber, myMaxThinkTimeNumber: MAX_THINK_TIME_NUMBER }); logger.info(`roomNumber:${roomNumber} one userId1:${memoryData['one'].userId} cardsId1:${memoryData['one'].cardsId} two userId2:${userId} cardsId2:${cardsId} pvp start`); socket.join(roomNumber); memoryData['one'].socket.emit("START", { roomNumber: roomNumber, memberId: "one" }); socket.emit("START", { roomNumber: roomNumber, memberId: "two" }); initCard(roomNumber, memoryData['one'].cardsId, cardsId, memoryData['one'].userId, userId); saveUserOperator(userId, { type: UserOperatorType.playPvp, with: memoryData['one'].userId, roomNumber: roomNumber }); }超时功能 烧绳子是炉石一个非常经典的场景。在这个场景中,玩家需要在规定的时间内完成操作,否则就会触发超时机制。超时机制是保障游戏公平性的重要机制之一。但是,之前的超时机制存在一个致命的问题,就是它被放在了客户端实现。这就意味着,只要对手关闭了网页,将永远不会触发超时功能,这让游戏的公平性受到了很大的影响。 为了解决这个问题,我们将超时功能放在了服务端来统计。这样,即使对手关闭了网页,超时机制仍然会如期触发。实现的思路也很简单:在房间内设置一个定时器,并且在切换出牌玩家的时候重置定时器。 // 超时计时 memoryData.timeoutId = setTimeout(() => { logger.info(`${roomNumber} ${other} 超时 ${memoryData[other].myMaxThinkTimeNumber}秒, 自动结束回合`); endMyTurn(args, getSocket(roomNumber, other)); if (memoryData[other].timeoutTimes) { memoryData[other].timeoutTimes += 1; if (memoryData[other].timeoutTimes === 4) { logger.info(`${roomNumber} ${other} 超时 ${memoryData[other].myMaxThinkTimeNumber}秒, 达到4次, 开始超时惩罚`); memoryData[other].myMaxThinkTimeNumber = memoryData[other].myMaxThinkTimeNumber / 2; } else if (memoryData[other].timeoutTimes >= 6) { logger.info(`${roomNumber} ${other} 超时 ${memoryData[other].myMaxThinkTimeNumber}秒, 达到6次, 惩罚输掉游戏`); giveUp(args, getSocket(roomNumber, other)); } } else { memoryData[other].timeoutTimes = 1; } }, memoryData[other].myMaxThinkTimeNumber * 1000);同时,我们参考了炉石的罚时机制,如果超时到达4吃,会给超时的玩家罚时惩罚,思考时间减半。如果超时6次,直接会判对手获胜。 这样,玩家就可以放心地享受到更加公正、公平的游戏体验了。这个改进将有助于提高游戏的整体质量和玩家的游戏体验。 JWT授权 首先什么是JWT,JWT(JSON Web Token)是一个基于JSON的开放标准,用于在网络上安全地传输信息,主要用于身份验证和授权。具体jwt的细节大家可以自行在网上搜索。 加入jwt授权的目的是为了保持网站接口无状态的同时,又能够安全的进行身份验证和授权,其实在进行游戏中是不需要进行身份验证的,因为游戏中使用的是websocket进行数据交互,只要一旦连接成功服务器,就代表websocket能持续保持连接不会修改。 在最新版本中,我们将使用JWT来进行授权,通过验证JWT令牌来确保用户的身份。具体实现步骤如下:用户在进入网站时,需要先通过登录验证身份,并获取到JWT令牌。 const token = jwt.sign({id : result._id}, JWTSecret, {expiresIn: 60 * 60 * 24 * 7});用户在使用我们的服务时,需要在请求中携带JWT令牌,以便服务端进行验证和授权。 axios.defaults.headers.common['Authorization'] = "Bearer " + res.data.data.token;验证JWT令牌。服务端在接收到每个请求后,都会对JWT令牌进行验证。 app.use(jwt({ secret: JWTSecret, algorithms: ["HS256"] }).unless({ path: ["/users/login"] }))职业技能 得益于使用的是js语言,这种语言非常的随意,能够非常便捷的获取数据和传递数据或者方法,所以想要实现职业技能,就和普通卡牌的效果是一样的实现方法。难点不在于职业技能的代码框架,反而在于如何设计比较平衡的职业技能。 如果和卡牌一样单纯的模仿炉石传说,可能和当前游戏的设定不太符合,所以我对职业技能重新进行了设计,基于这个框架,职业技能不再是单一的一个技能,而是可以进行多职业技能的携带,并且根据技能耗费的增多,技能的效果也会更加强大。 我对职业技能的界面设计如图:本次文章里并不会设计所有职业技能,而是在关卡中放置了一个需要用到职业技能的关卡,这样会把复杂度降低,只关注到职业技能的实现。 首先服务端会把对战双方的技能发送到客户端,客户端展示在牌桌上。 this.gameData[first]['skillList'] = [ { name: "阅读书籍", cost: 1, isTarget: true, targetType: TargetType.MY_TABLE_CARD, description: '通过阅读书籍提高自己,选择提高牌桌上1张卡牌1点攻击力', onChooseTarget: cardEffectFactory.oneChooseCardAddAttack(1) } ]如果有多个技能,只需要发送整个技能列表到客户端就可以。 点击其中某个技能的时候,客户端会进行一次消费的计算,如果费用不够则不会进行技能的释放,如果费用够了,会交由服务端进行判断,满足所有技能释放条件时,会发送技能释放的指令到客户端进行执行。 onSkillClick(index, skill) { if (skill.cost > this.gameData.myFee) { this.showError("费用不足"); } else { this.currentSkillIndex = index; if (skill.isTarget) { let card = this.gameData.myCard[this.currentCardIndex]; if (skill.targetType === TargetType.MY_TABLE_CARD) { this.chooseCardList = this.gameData.myTableCard.slice(); } else if (skill.targetType === TargetType.OTHER_TABLE_CARD) { this.chooseCardList = this.gameData.otherTableCard.slice(); } else if (skill.targetType === TargetType.ALL_TABLE_CARD) { this.chooseCardList = this.gameData.otherTableCard.slice() .concat(this.gameData.myTableCard.slice()); } else if (skill.targetType === TargetType.ALL_TABLE_CARD_FILTER_INCLUDE) { // 全桌面卡,过滤条件包含 this.chooseCardList = this.gameData.otherTableCard .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) !== -1) && !i.isHide) .map(i => Object.assign({}, i, {name: i.name + "(敌方)"})) .concat(this.gameData.myTableCard.slice().filter(i => skill.filter.every(t => i.type.indexOf(t) !== -1))); } else if (skill.targetType === TargetType.ALL_TABLE_CARD_FILTER_EXCLUDE) { this.chooseCardList = this.gameData.otherTableCard .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) === -1) && !i.isHide) .concat(this.gameData.myTableCard .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) === -1))); } else if (skill.targetType === TargetType.MY_TABLE_CARD_FILTER_INCLUDE) { this.chooseCardList = this.gameData.myTableCard .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) !== -1)); } else if (skill.targetType === TargetType.MY_TABLE_CARD_FILTER_EXCLUDE) { this.chooseCardList = this.gameData.myTableCard .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) === -1)); } else if (skill.targetType === TargetType.OTHER_TABLE_CARD_FILTER_INCLUDE) { this.chooseCardList = this.gameData.otherTableCard .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) !== -1)); } else if (skill.targetType === TargetType.OTHER_TABLE_CARD_FILTER_EXCLUDE) { this.chooseCardList = this.gameData.otherTableCard .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) === -1)); } // 展示选择框 this.chooseDialogType = ChooseDialogType.SKILL; this.chooseDialogShow = true; } else { useSkillCommand.apply(this); } } },服务端: /** * 使用技能 * @param args * @param socket */ function useSkill(args, socket) { let roomNumber = args.r, index = args.index, targetIndex = args.targetIndex, skill; const memoryData = getRoomData(roomNumber); let belong = getSocket(roomNumber, "one").id === socket.id ? "one" : "two"; // 判断当前是哪个玩家出牌 let other = getSocket(roomNumber, "one").id !== socket.id ? "one" : "two"; if (index !== -1 && memoryData[belong]["skillList"][index].cost <= memoryData[belong]["fee"]) { skill = memoryData[belong]["skillList"][index]; if (!skill.roundMaxUseTimes) { skill.roundMaxUseTimes = 1; } if (!memoryData[belong]["useSkillRoundTimes"]) { memoryData[belong]["useSkillRoundTimes"] = 0; } if (skill.roundMaxUseTimes <= memoryData[belong]["useSkillRoundTimes"] || (skill.maxUseTimes && skill.maxUseTimes <= +memoryData[belong]["useSkillTimes"])) { error(socket, "技能使用次数超过上限"); return; } // 检查是否违反卡牌的必须选择施法对象属性(isForceTarget) let chooseCardList = []; if (skill.isTarget) { if (skill.targetType === TargetType.MY_TABLE_CARD) { chooseCardList = memoryData[belong]["tableCards"]; } else if (skill.targetType === TargetType.OTHER_TABLE_CARD) { chooseCardList = memoryData[other]["tableCards"]; } else if (skill.targetType === TargetType.ALL_TABLE_CARD) { chooseCardList = memoryData[other]["tableCards"].slice() .concat(memoryData[belong]["tableCards"].slice()); } else if (skill.targetType === TargetType.ALL_TABLE_CARD_FILTER_INCLUDE) { chooseCardList = memoryData[other]["tableCards"] .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) !== -1) && !i.isHide) .concat(memoryData[belong]["tableCards"] .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) !== -1))); } else if (skill.targetType === TargetType.ALL_TABLE_CARD_FILTER_EXCLUDE) { chooseCardList = memoryData[other]["tableCards"] .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) === -1) && !i.isHide) .concat(memoryData[belong]["tableCards"] .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) === -1))); } else if (skill.targetType === TargetType.MY_TABLE_CARD_FILTER_INCLUDE) { chooseCardList = memoryData[belong]["tableCards"] .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) !== -1)); } else if (skill.targetType === TargetType.MY_TABLE_CARD_FILTER_EXCLUDE) { chooseCardList = memoryData[belong]["tableCards"] .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) === -1)); } else if (skill.targetType === TargetType.OTHER_TABLE_CARD_FILTER_INCLUDE) { chooseCardList = memoryData[other]["tableCards"] .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) !== -1)); } else if (skill.targetType === TargetType.OTHER_TABLE_CARD_FILTER_EXCLUDE) { chooseCardList = memoryData[other]["tableCards"] .slice().filter(i => skill.filter.every(t => i.type.indexOf(t) === -1)); } // 必须选择施法对象,返回错误 if (chooseCardList.length === 0 && targetIndex === -1 && skill.isForceTarget) { error(getSocket(roomNumber, belong), "请选择目标"); return; } } memoryData[belong]["fee"] -= skill.cost; let mySpecialMethod = getSpecialMethod(belong, roomNumber); getSocket(roomNumber, belong).emit("USE_SKILL", { index, skill, isMine: true, myHero: extractHeroInfo(memoryData[belong]), otherHero: extractHeroInfo(memoryData[other]) }); getSocket(roomNumber, other).emit("USE_SKILL", { index, skill, isMine: false, myHero: extractHeroInfo(memoryData[other]), otherHero: extractHeroInfo(memoryData[belong]) }) if (skill.isTarget) { skill.onChooseTarget({ myGameData: memoryData[belong], otherGameData: memoryData[other], source: skill, chooseCard: chooseCardList[targetIndex], effectIndex: args.effectIndex, fromIndex: -1, toIndex: targetIndex, specialMethod: mySpecialMethod }); } if (skill && skill.onStart) { skill.onStart({ myGameData: memoryData[belong], otherGameData: memoryData[other], source: skill, specialMethod: mySpecialMethod }); } memoryData[belong]["useSkillTimes"]++; memoryData[belong]["useSkillRoundTimes"]++; checkCardDieEvent(roomNumber); } else { error(socket, '费用不足或未选择使用的技能'); } checkPvpWin(roomNumber); checkPveWin(roomNumber); }接下来的计划 由于现在的AI很强很火(想蹭个热度),同时既然我想把这个项目做好,所以我接下来会用AI把整个游戏进行一次新的设计。 并且我希望制作一款更便于操作的工具,让卡牌对战类的游戏更方便制作。 想做的事情很多,但是奈何业余时间太少,大家如果有什么好的想法也请多多留言。

用js写卡牌游戏(八)

前言 好久不见,离发布上次分享,已经过去很久很久了,这段时间发生了很多变故,经历了跳槽、离职、创业等等,手头也一直有很多事情在忙,不过鸽这么久其实是有别的理由,有一个非常重要的功能一直卡住,没有思路,但不做这个功能我又觉得这个项目就无法继续下去,那就是:卡牌ai。 线上地址:http://cardgame.xiejingyang.com github:https://github.com/xieisabug/card-game 同样建议大家看着视频,同步看文章,会比较直观:https://www.bilibili.com/video/BV18e411P74S/ 背景为什么会在这个阶段就想要做ai呢?这个游戏相信大家看的出来,参照的就是炉石传说,炉石传说中的单机体验是非常吸引我的,不光是得益于关卡和数值设计的精彩,更是因为其中电脑对手也有丰富的随机情况出现,有神抽,也有卡手的时候,给玩家像和真人在对战一样的体验,感受的到ai也是在打牌,我相信这不是脚本所能达到的效果,也正因为这样给了玩家一次又一次挑战的动力。 我前几关的故事模式都是直接编写的脚本,在设计到第10关的时候,我希望玩家和ai开始对战,但是如果一直是编排的脚本,之后会需要编写大量重复且难以维护的脚本,我产生了制作一个会自己打牌的ai的想法,这样就能花更多的时间精力去完成数值和关卡的设计。所以,我将ai放在了很多游戏功能之前。并且在之后增加游戏功能的时候,也可以从ai的角度去进行系统设计。 无关紧要的哔哔目前这个简陋的ai已经做好了,关键技术是一个叫蒙特卡洛树搜索的算法。接下来我会按照:寻找合适的技术 ⇒ 设计算法 ⇒ 编码完成ai,这几个步骤来进行分享,并且同时会顺带简单介绍一下蒙特卡洛树搜索。 寻找合适的技术 寻找技术解决方案的时候,尝试了两个方案,第一个方案是定义一个动作优先级,然后按照优先级模拟所有可以进行的动作,评分分数是上涨了还是降低了,上涨了则保留,降低了则回退动作,这个方案很像贪心算法,可惜这种卡牌游戏并不能使用贪心算法来求最优解,动作的顺序和卡牌的配合非常重要,要赢下比赛并不是某一个动作决定的,而是整个回合的配合运营,不过这个方案有蒙特卡洛树的影子了,也为后来改成蒙特卡洛树提供了很多思路。 第二个方法企图使用机器学习,使用类似决策森林的方式来获取最佳行动,如果将足够多的对局放到模型中进行训练,会生成许多决策树,在决策树中模拟动作之后投票选择出最佳方案。但是我也说了,需要足够多的对局来进行模型训练,因为缺少训练集,而且游戏的动作量化难度非常高,所以也这个方案也失败了。 当我一筹莫展的时候,有天闲来无事逛b站,我看到了一个up主的科普视频(https://www.bilibili.com/video/BV1qR4y1J7hthttps://www.bilibili.com/video/BV1qR4y1J7ht),提到了这个蒙特卡洛树,我才了解到在对于这种对弈游戏或者非对称信息游戏的ai,一般都是使用这个算法来解决,而且alpha go的一部分就是用到这个算法。 简单介绍一下蒙特卡洛树。蒙特卡洛是一座著名的赌城,相传最开始蒙特卡洛方法就是在某个数学家玩扑克的时候发明的,蒙特卡洛方法解释起来很容易理解,不停的模拟对局,并且在模拟的基础上进行一些统计方法,在模拟的框架内对于统计的数据又进行反向传递来影响模拟路径的选择,从而实现比普通的模拟要更加有效率更加准确的效果。 可以用我们的卡牌游戏来举个例子,能更生动的理解它。 设计算法 当前的场景下,我们可以操作的动作有:出牌、攻击卡牌、攻击英雄,这时,蒙特卡洛会生成根节点,然后根据这三个动作拓展根节点的分支,对所有分支进行模拟对战,然后对于对战的结果进行统计,对拓展的分支重复这个操作,直到某个停止的条件达成,这个条件可以是模拟10000次,也可以是200ms等等,最后对于模拟的对战进行统计对比,选择最适合的动作集。 听起来挺简单的对吧,蒙特卡洛的难点在于将整个游戏转化为它的框架中的步骤,它分为:选择、拓展、模拟、反向传播,四个阶段,蒙特卡洛会不停的重复这四个阶段来进行游戏模拟,只要将获取结果的过程转化为这四个步骤就行了。 编码完成ai 由于我们的游戏是类炉石的卡牌游戏,和棋类这种信息对称的游戏使用蒙特卡洛树的方式不同,类炉石的卡牌游戏在一个回合内自己是可以连续做许多动作,并且对方拥有的卡牌也是未知的,棋类的蒙特卡洛树可以模拟互相对弈的过程来复现人类对弈时的思考,也就是模拟出对方可能会怎么做,而类炉石卡牌游戏只能将蒙特卡洛树用来模拟人类对当前场面的思考,也就是只能模拟出我们自己的行动。所以我们需要将整个算法的过程,映射到这一回合的多个动作之中,进行模拟来选出当前使用哪一个动作能够达到最佳。 首先需要定义好蒙特卡洛的四个阶段对应的函数,select、expand、simulate、backPropagation,并且定义一个对外接口 getBestAction,然后将蒙特卡洛树的搜索过程填入到这个接口中。 class MonteCarloTreeSearch { // 根据当前游戏状态返回最佳行动。 getBestAction(myTableCard, otherTableCard, myHandCard, myRemainingCard, fee, myLife, otherLife) { } // 使用蒙特卡洛树搜索算法选择下一个要探索的节点。 select(state) { } // 扩展给定节点,通过向树中添加它的可能子节点。 expand(node) { } // 从给定节点模拟随机游戏,以估计其潜在价值。 simulate(node) { } // 根据模拟的结果,反向传播给定节点的值和访问次数。 backPropagation(node, win) { } }为了让ai更快,我们需要对ai每次思考的时间进行限制,所以先将ai的模拟运行时间,限制在我们可控制的范围内: getBestAction(myTableCard, otherTableCard, myHandCard, myRemainingCard, fee, myLife, otherLife) { // 初始化cacheTree this.cacheTree = {}; // 初始化state let state = { myTableCard, otherTableCard, myHandCard, myRemainingCard, fee, myLife, otherLife }; // 计算规定时间 let end = Date.now() + this.maxTime * 1000; let win; // 在规定时间内不断模拟 while (Date.now() < end) { // 蒙特卡洛树搜索算法... } }根据蒙特卡洛树的框架,我们将过程可以转化为:根据当前的对战状态获取模拟的节点,对节点进行扩展,从扩展之后的节点开始进行模拟,最后对模拟后的结果再进行反向传递: // 在规定时间内不断模拟 while (Date.now() < end) { // 获取模拟的节点 let node = this.select(state); if (node && !node.isLeaf() && !this.isWin(node.state)) { // 对节点进行扩展 node = this.expand(node); // 对扩展的节点进行模拟 win = this.simulate(node); } // 对模拟后的结果再进行反向传递 this.backPropagation(node, win); }”选择“的目的其实是获取一个当前最需要模拟的节点,策略是这样的:如果节点能扩展,则选择这个能扩展的节点,否则在子节点中选择一个最佳的子节点,并且继续判断子节点是否扩展,不停重复这一动作,直到找到可拓展的节点或者叶子节点。 可能在刚刚的描述中会注意到一个特殊的词,那就是“最佳”,这也是第一个使得蒙特卡洛树更加科学的秘诀,我在这里使用的是UCB算法,关于UCB算法大家可以理解为根据游玩的次数和获胜的次数得到一个分数,分数越高评价就越好。具体的UCB算法原理大家可以去网上看看别人的讲解,比我讲的要更好。 完善select函数,大部分解释我都通过注释的方式在代码里表达了: select(state) { // 用于防止无限向下寻找的情况,最大层数 let maxLevel = 0; // 从缓存中拿出当前状态对应的节点 let node = this.cacheTree[hashState(state)]; while (node.isFullyExpanded() && !node.isLeaf()) { maxLevel ++; // 获取节点所能做的所有动作 let actions = node.allActions(); let bestAction; let bestUCB1 = -Infinity; // 遍历所有动作,找到最佳评价的动作 actions.forEach(a => { let action = a.action; let child = node.childNode(action); if (child) { // 使用UCB算法对节点进行评分 let childUCB1 = child.getUCB1(this.UCB1); if (childUCB1 > bestUCB1) { bestAction = action; bestUCB1 = childUCB1; } } }); if (bestAction) { node = node.childNode(bestAction); } if (maxLevel > this.maxDeep) { break; } } return node; }在刚刚的定义中,我们为node设计了许多函数,接下来就创建node类,并且为这些函数添加上实现(这种自顶向下的设计方式也是我很喜欢的编程方式,能让我的思路更加清晰): const { range, hashState } = require('../../utils');class MonteCarloTreeSearchNode { /** * 构造函数,初始化节点 * 记录下节点的父节点、产生的动作、当前的状态 * * 为了性能更好,所以我们提前将所有的子节点缓存起来,也就是cacheAllChildren函数做的事情 */ constructor(parent, action, state) { this.parent = parent; this.action = action; this.state = state; // 用于缓存子节点 this.children = {}; // 对局数量 this.n_plays = 0; // 获胜数量 this.n_wins = 0; // 当前状态的hash值,也是为了性能提前计算好 this.hash = hashState(this.state); // 缓存当前节点能够进行的所用动作的子节点 this.cacheAllChildren(); } /** * 缓存当前节点能够进行的所用动作的子节点 */ cacheAllChildren() { if (this.action && this.action.event === "END_MY_TURN") { return; } let action; let myHandCard = this.state.myHandCard, otherTableCard = this.state.otherTableCard, myTableCard = this.state.myTableCard, fee = this.state.fee; // 缓存结束回合节点 action = { event: "END_MY_TURN" }; this.children[this.actionHash(action)] = { action, node: null }; // 出牌判断,所有在费用内可以出的牌 for (let i = 0; i < myHandCard.length; i++) { if (myHandCard[i].cost <= fee) { action = { event: "OUT_CARD", card: Object.assign({}, myHandCard[i]), i }; this.children[this.actionHash(action)] = { action, node: null }; } } // 如果有嘲讽,必须先攻击嘲讽,如果没有,则随意攻击 let dedicationIndexList = []; // 嘲讽卡牌的index let attackCardList = []; // 卡牌index对应的card元数据 // 查找所有嘲讽 otherTableCard.forEach((i, index) => { if (i.isDedication) { dedicationIndexList.push(index); attackCardList.push(i); } }); let hasDedication = true; // 如果没有嘲讽,则所有的都可攻击,为了方便,直接放在attackCardList和dedicationIndexList里 if (attackCardList.length === 0) { hasDedication = false; attackCardList = otherTableCard.slice(); dedicationIndexList = range(otherTableCard.length) } // 攻击卡牌判断 for (let i = 0; i < myTableCard.length; i++) { if (!myTableCard[i].isActionable) continue; // 行动过的不需要继续了 let attackCard = Object.assign({}, myTableCard[i]); // 如果没有嘲讽,则可以攻击对方的英雄 if (!hasDedication) { // 攻击对方英雄 action = { event: "ATTACK_HERO", k: attackCard.k }; this.children[this.actionHash(action)] = { action, node: null } } // 攻击可攻击的卡牌 for (let j = 0; j < attackCardList.length; j++) { let beAttackCard = Object.assign({}, attackCardList[j]); action = { event: "ATTACK_CARD", card: attackCard, attackCard: beAttackCard, myK: attackCard.k, attackK: beAttackCard.k, i, j: dedicationIndexList[j] }; this.children[this.actionHash(action)] = { action, node: null } } } } /** * 获取当前节点所有可执行的动作 * @returns 所有可以执行的动作 */ allActions() { return Object.values(this.children); } /** * 拓展节点 * @returns 子节点 */ expand(action, childState) { if (Object.keys(this.children).indexOf(this.actionHash(action)) == -1) { throw new Error("No such play!"); } let childNode = new MonteCarloTreeSearchNode(this, action, childState) this.children[this.actionHash(action)] = { action, node: childNode } return childNode } /** * 获取动作对应的子节点 * @returns 子节点 */ childNode(action) { let hash = this.actionHash(action); if (!this.children[hash]) { return null; } return this.children[hash].node; } /** * 获取没有被拓展的节点集合 * @returns 没有扩展的子节点集合 */ unexpandedActions() { let ret = []; Object.values(this.children).forEach(child => { if (child.node === null) { ret.push(child.action); } }); return ret; } /** * 根据是否胜利更新当前节点的对局状态 */ update(win) { this.n_plays += 1; this.n_wins += win ? 1 : 0; } /** * 动作hash * @returns 动作的hash值 */ actionHash(action) { switch(action.event) { case "OUT_CARD": return `${action.event}_${action.i}`; case "ATTACK_HERO": return `${action.event}_${action.k}`; case "ATTACK_CARD": return `${action.event}_${action.i}_${action.j}`; default: return action.event; } } /** * 是否叶子节点 */ isLeaf() { return this.allActions().length <= 1; // 只能结束回合 } /** * UCB算法 */ getUCB1(biasParam) { return (this.n_wins / this.n_plays) + Math.sqrt(biasParam * Math.log(this.parent.n_plays) / this.n_plays); } /** * 是否子节点全拓展 */ isFullyExpanded() { return this.unexpandedActions().length === 0 || (this.unexpandedActions().length === 1 && this.unexpandedActions()[0].event === "END_MY_TURN"); } }module.exports = MonteCarloTreeSearchNode;子节点所有的函数都完成了,继续完善蒙特卡洛树的框架,到了第二步expand,expand相对来说比select更好理解,就是为当前选定的节点进行向下个状态的扩展,随机选择一个还没有进行过的动作,然后模拟执行这个动作生成新的状态,通过这个状态生成节点,就完成了expand的操作: expand(node) { // 获取节点没有拓展的动作 let actions = node.unexpandedActions(); // 随机选择一个动作 let index = Math.floor(Math.random() * actions.length); let action = actions[index]; // 进行节点拓展 let childState = nextStateByAction(node.state, action); let childNode = node.expand(action, childState); // 如果是end_turn,则会造成state不变的情况,所以tree出现问题了 if (action.event !== 'END_MY_TURN') { this.cacheTree[hashState(childState)] = childNode; } return childNode }需要注意的是,在我们游戏中有一个特殊的动作,就是直接结束回合,这个动作是非常重要的,在对局中,我们有很多动作可以选择,但有时候什么都不做却是最好的选择,在蒙特卡洛树算法中由于我们是很依赖于状态的,而直接结束回合这个动作是不会改变状态的,所以对这个动作,我们要和其他的动作分开。 再下一步就是要将剩下的这个回合模拟完,和expand有些相似,随机选取动作不停向下扩展,直到没有动作了,只不过不会将这个过程真正的扩展和缓存,而是只要最终的结果。 当然模拟到回合结束的时候,需要判断这一系列的动作是否起到正向作用,这也是我们算法的重中之重,也就是:场面价值评估。 /** * 模拟打牌的过程 * @param {*} node 模拟的node * @returns 是否胜利 */ simulate(node) { let state = node.state; let tempNode = node; // 没有胜利或者没有结束完行动的情况下,不停模拟 while (!this.isWin(state) && !this.isEndMyTurn(state)) { let actions = tempNode.allActions(); let index = Math.floor(Math.random() * actions.length); let action = actions[index].action; let childState = nextStateByAction(tempNode.state, action); tempNode = new MonteCarloTreeSearchNode(tempNode, action, childState) state = childState; } // 判断是否胜利 return this.checkValue(state.myTableCard, state.otherTableCard, state.myHandCard, state.myRemainingCard, state.fee, state.myLife, state.otherLife) > this.currentValue; }checkValue就是场面评估的函数了,用于对比是否胜利的currentValue就是在ai运行的最初状态所评估出来的场面价值。 先将currentValue计算的代码写出来,并且为根节点进行初始化: getBestAction(myTableCard, otherTableCard, myHandCard, myRemainingCard, fee, myLife, otherLife) { // 初始化当前状态value this.currentValue = this.checkValue(myTableCard, otherTableCard, myHandCard, myRemainingCard, fee, myLife, otherLife); // 初始化cacheTree this.cacheTree = {}; // 初始化state let state = { myTableCard, otherTableCard, myHandCard, myRemainingCard, fee, myLife, otherLife }; // 初始化root this.cacheTree[hashState(state)] = new MonteCarloTreeSearchNode(null, null, state); // 计算规定时间 let end = Date.now() + this.maxTime * 1000; let win; // 在规定时间内不断模拟 while (Date.now() < end) { let node = this.select(state); if (node && !node.isLeaf() && !this.isWin(node.state)) { node = this.expand(node); win = this.simulate(node); } this.backPropagation(node, win); } }接下来就分析checkValue需要如何完成。 以我对卡牌游戏的理解,场面的价值会要考虑到双方场上怪物的生命值攻击力,怪物如果有特殊的词缀或者效果也需要进行考虑,如果是己方的怪物则为正相关,敌人的怪物则为负相关,两方抵消掉,就成为最终的场面价值。 进行了这些基础计算之后,还需要考虑到如果桌面的卡牌能够打出combo,那么卡牌的评价会得到提升,如果手牌中有未打出的combo牌,那么也有评价的提升,再或者说卡组中还有非常强力的牌没有抽到,那么也可以得到评价提升,所以这个checkValue函数是可以不断的去完善的,我放出我目前使用的checkValue给大家参考: /** * 计算当前场面的价值 * @param {*} myTableCard 我桌面卡组 * @param {*} otherTableCard 对方桌面卡组 * @param {*} myHandCard 我的手牌 * @param {*} myRemainingCard 我剩余卡牌 * @returns 当前场面的价值 */ checkValue(myTableCard, otherTableCard, myHandCard, myRemainingCard, fee, myLife, otherLife) { // 算法:己方场面价值 + 己方手牌价值 + 己方牌库价值 - 对手场面价值 // 目的:打出更多的combo,计算出各种出牌的顺序和各种出牌的方法中己方价值最大化的方法 // // 注: 特殊怪物属性价值计算 = 嘲讽2 + 战吼0 + 亡语1 + 每回合5 + 圣盾1 + 吸血2 + 精力充沛1 // 固定组合价值 = 固定组合设置价值 + 原卡价值 // // 己方场面价值算法 = 己方场攻 + 己方怪物生命值 + 己方特殊怪物属性 + 固定组合价值 * 1.5 固定价值乘以一个放大的数字是为了让ai更多的打出combo // 对手场面价值算法 = 对手场攻 + 对手怪物生命值 + 对手特殊怪物属性 + 固定组合价值 * 1.5 // 己方牌库价值 = 固定组合价值 // 己方手牌价值 = 固定组合价值 return (myTableCard.length ? myTableCard.reduce((pre, current) => { return pre + current.attack + current.life + this.calSpecialValue(current) }, 0) : 0) + this.comboCardValue(myTableCard) + this.calHandCardValue(myHandCard) + this.calRemainingCardValue(myHandCard, myRemainingCard) + (myLife - otherLife) - (otherTableCard.length ? otherTableCard.reduce((pre, current) => { return pre + current.attack + current.life + this.calSpecialValue(current) }, 0) : 0) }/** * 计算特殊怪物属性的价值 * 嘲讽2 战吼0 亡语1 每回合5 圣盾1 吸血2 精力充沛1 * @param {*} card 卡牌 * @returns 特殊值 */ calSpecialValue(card) { let value = 0; value += (card.isDedication ? 2 : 0); value += (card.isStrong ? 1 : 0); value += (card.isFullOfEnergy ? 1 : 0); value += (card.onEnd ? 1 : 0); value += (card.onMyTurnEnd ? 5 : 0); value += (card.onMyTurnStart ? 5 : 0); value += (card.specialValue != undefined ? card.specialValue : 0); // 因为specialValue可以为负数,所以只能直接判断undefined return value }/** * * @param {*} cardList */ comboCardValue(cardList) { return 0 }calHandCardValue(myHandCard) { myHandCard.forEach(card => { // 遍历手牌,看是否有特殊组合 }) return 0; }calRemainingCardValue(handCard, remainingCard) { return 0 }这样模拟也算是完成了,那么就剩下最后一步,也是相对来说简单的一步:反向传播,反向传播在一些机器学习的算法中也会使用到,它让每次模拟的结果都对下次模拟结果的准确率进行提升: /** * 反向传播,向上更新父节点相关的值 * @param {*} node 模拟的node * @param {*} winner 是否胜利 */ backPropagation(node, win) { let tempNode = node; // 不停向上传递,直到根节点 while (tempNode) { tempNode.update(win); tempNode = tempNode.parent; } }好了,到了这里,已经完成了蒙特卡洛树的搜索阶段,接下来就是获取当前结果了,将这些代码添加到getBestAction的后部,这样就可以直接调用getBestAction获取到蒙特卡洛树搜索得出的动作结果了: // 如果节点没有完全拓展开,那么证明模拟没有完成 if (this.cacheTree[hashState(state)].isFullyExpanded() === false) throw new Error("未能模拟完成")let node = this.cacheTree[hashState({ myTableCard, otherTableCard, myHandCard, myRemainingCard, fee, myLife, otherLife })] let allActions = node.allActions() let bestAction// 如果只有一个选择并且是结束回合,那么可以直接返回无需计算 if (allActions.length === 1 && allActions[0].action.event === 'END_MY_TURN') { return allActions[0].action }// 遍历所有的动作,对动作进行胜率计算,胜率高的动作为最佳动作 let max = -Infinity for (let a of allActions) { let action = a.action; // 当动作是直接结束回合的时候,胜率定为0.5,如果有胜率超过50%的则替换,否则执行结束回合 if (action.event === 'END_MY_TURN') { bestAction = action; if (max < 0.5) { bestAction = action max = 0.5 } } else { let childNode = node.childNode(action) if (!childNode) { console.error("childNode is null", node.children, action); } let ratio = childNode.n_wins / childNode.n_plays if (ratio > max) { bestAction = action max = ratio } } }return bestAction总结 后续的关卡如果涉及到对战的,我就会使用这个算法来进行ai对战了。 其中有很多可以改进的地方,比如checkValue可以更加科学,蒙特卡洛树的很多分支可以进行剪枝和权重调整,让搜索往更有用的分支进行等等,你们也可以自行调整这些地方,让ai能够达到更智能的效果。

用js写卡牌游戏(五)

用js写卡牌游戏(五)

前言 加紧速度,争取让教程快速跟上线上版本的速度,不然老要写两遍,太麻烦了。如果游戏整个过程中有什么不太懂的,或者特别想了解的环节,可以直接留言给我,我会专门写文章来介绍这些东西。 同样这次也录了视频,在文章的最底部,不想看文字的同学可以直接去最下面看视频。 之前设计了卡牌的基础数据,但是随着开发的深入,之前设计的基础数据仅仅只能简单显示一张卡牌,这次就完善设计一下卡牌的数据结构,并且顺便把发牌代码做了。 线上地址:http://cardgame.xiejingyang.com github:https://github.com/xieisabug/card-game 开始 首先设计卡牌的数据结构:对于每个卡牌,都需要有个id标识,保证卡牌的id是唯一的,然后有名称,费用,攻击,生命,对于卡牌类型我们要进行区分,目前我们只做人物牌和效果牌,然后卡牌需要一个描述字段用于显示卡牌的效果,还可以注意到如果卡牌扣血或者被进行强化了那么血量和攻击力都有相应的样式,这里就要记录下来卡牌基础攻击力和基础血量。 然后除了卡牌有类型,卡牌的人物也有类型,这个类型就是类似的“前端”、“服务端”这种,相当于炉石传说的“元素”“机械”。 然后卡牌需要有生命周期,用于实现各种特定的效果,那么暂定卡牌的生命周期有:打出时 别的卡牌打出时 我的回合开始时 我的回合结束时 选定目标时 死亡时 桌面卡牌变动时有了这些生命周期,能够实现绝大部分的功能了,例如战吼、亡语等,但是炉石传说还有一些词缀是无法用生命周期实现的,比如嘲讽、风怒等,所以也要设计一些词缀,硬编程在代码里。如果还需要一些生命周期也可以以后再添加,比如当攻击时,当被攻击时等等。 为了与炉石区分开,同时又要和程序员大战契合,我将词缀名称修改了,改为了:“奉献”、“精力充沛”、“坚强”对应的“嘲讽”、“冲锋”、“圣盾”。 那么一张卡牌完整的数据结构就是如下了: { id: 0, name: "xxxxxx", cardType: CardType.CHARACTER, cost: 3, content: `xxxxxxxxxx`, attack: 2, life: 1, attackBase: 2, lifeBase: 1, type: [""], isStrong: true, isFullOfEnergy: true, isDedication: true, onStart: function() {}, onOtherCardStart: function() {}, onMyTurnStart: function() {}, onMyTurnEnd: function() {}, onChooseTarget: function() {}, onEnd: function() {}, onTableCardChange: function() {}, }那现在就要设计几张卡牌,因为生命周期我们还没实现,就先设计几张简单的卡牌,在server端,创建constants.js,把这些卡牌都放进去: { id: 1, name: "励志的演说家", cardType: CardType.CHARACTER, cost: 2, content: ``, attack: 1, life: 2, attackBase: 1, lifeBase: 2, type: [""] }, { id: 5, name: "高级程序员", cardType: CardType.CHARACTER, cost: 7, content: ``, attack: 7, life: 7, attackBase: 7, lifeBase: 7, type: [""] }, { id: 6, name: "开发助理", cardType: CardType.CHARACTER, cost: 1, content: ``, attack: 1, life: 1, attackBase: 1, lifeBase: 1, type: [""] }, { id: 8, name: "丑陋的开发鼓励师", cardType: CardType.CHARACTER, cost: 1, content: `精力充沛`, attack: 1, life: 1, attackBase: 1, lifeBase: 1, type: [""], isFullOfEnergy: true }卡牌设计基本完成了,现在做一下发牌,发牌阶段看似简单,实际上涉及到了三个阶段:数据初始化,洗牌,发牌。 首先要说一个概念,就是随机数种子,这个种子是用来将随机数固定为一个序列的,魔兽争霸一盘的录像非常小,按道理说魔兽争霸小兵每一次攻击都是随机的数值,如果都要记录下来,那么录像文件会非常的大,但是如果能够用随机数种子,将每次的随机数固定为一个序列,那么所有小兵的攻击都只需要记录攻击了谁,而不需要记录那次攻击具体的数值,看录像的时候,重新用随机数种子生成一次随机数,随机数和之前玩的时候和一毛一样。我这里用的是seedrandom,大家如果有兴趣可以看看它是怎么实现的。 在开局的时候,也记录一个随机数种子seed,用seedrandom的方法保存一个随机方法,然后就可以开始进行洗牌。 let seed = Math.floor(Math.random() * 10000);memoryData[roomNumber] = { isPve, startTime: new Date(), gameMode: GameMode.PVP1, seed, // 随机数种子 rand: seedrandom(seed), // 随机方法 round: 1 };创建一个utils文件,添加洗牌shuffle方法,传进去随机方法和牌组,返回洗牌之后的牌组。 function shuffle(rand, a) { for (let i = a.length - 1; i > 0; i--) { const j = Math.floor(rand() * (i + 1)); [a[i], a[j]] = [a[j], a[i]]; } return a; }然后抽一张牌,推送卡牌给客户端,写一个抽卡函数: function getNextCard(remainingCards) { if (remainingCards.length > 0) { return remainingCards.splice(0, 1)[0] } else { return null } }初始化卡牌的代码如下,只要在connect的时候调用一下就可以了: function initCard(roomNumber) { let random = memoryData[roomNumber].rand() * 2; let first = random >= 1 ? "one" : "two"; // 判断当前是哪个玩家出牌 let second = random < 1 ? "one" : "two"; memoryData[roomNumber]["one"]["remainingCards"] = shuffle(memoryData[roomNumber].rand, Cards.map((c, index) => Object.assign({k : `one-${index}`}, c))); memoryData[roomNumber]["two"]["remainingCards"] = shuffle(memoryData[roomNumber].rand, Cards.map((c, index) => Object.assign({k : `two-${index}`}, c))); let firstRemainingCards = memoryData[roomNumber][first]["remainingCards"]; let secondRemainingCards = memoryData[roomNumber][second]["remainingCards"]; Object.assign(memoryData[roomNumber][first], { cards: [ getNextCard(firstRemainingCards), getNextCard(firstRemainingCards), ] }); Object.assign(memoryData[roomNumber][second], { cards: [ getNextCard(secondRemainingCards), ] }); sendCards(roomNumber);}客户端收到卡牌,保存下来,更新到界面上。 先在data里增加游戏数据gameData,以后游戏的展示都是用gameData中的数据为准: data() { return { // other code ... gameData: { myCard: [], // 手牌 }, }; },this.socket.on("SEND_CARD", (param) => { this.gameData = Object.assign({}, this.gameData, param); });然后,看到之前写的卡牌dom,还缺少一些小图标,缺少伤害的展示,缺少词缀的标记。 我icon都是从iconfont这个网站上面找的,用起来非常方便,我这里就不找了,直接用之前的。 修改一下Card这个文件的样式,加上攻击和血量的图标,添加一个伤害的样式,伤害我是用vue的watch来实现的,当life改变的时候,计算伤害值,展示伤害的样式:{{name}}{{cost}} {{content}}{{attack}}{{life}} {{hurtNumber > 0 ? `+${hurtNumber}` : hurtNumber}}watch: { life: function(newVal, oldVal) { if (this.$refs['cardLife']) { Velocity(this.$refs['cardLife'], { scale: 1.8 }, { duration: 150 }).then(el => { Velocity(el, { scale: 1 }, { duration: 150, delay: 250 }) }); this.hurtNumber = newVal - oldVal; Velocity(this.$refs['hurtContainer'], { scale: [1, 0] }, { duration: 200, begin: () => { this.hurtShow = true } }).then(el => { Velocity(el, { scale: 0 }, { duration: 200, delay: 600, complete: () => { this.hurtShow = false } }) }) } }, }, 然后加上几个词缀的样式。 我这里使用了一个库叫buildclassname attackClassName() { return buildClassName({ "card-attack": true, "low": this.attack < this.attackBase, "up": this.attack > this.attackBase }) }, lifeClassName() { return buildClassName({ "card-life": true, "low": this.life < this.lifeBase, "up": this.life > this.lifeBase }) }, isDedicationClassName() { return buildClassName({ "dedication": true, "hide": !this.isDedication }) }, isStrongClassName() { return buildClassName({ "strong": true, "hide": !this.isStrong }) },这样就基本实现了卡牌的数据结构和发牌。 下一章讲一下断线重连、伤害、出牌。

用js写卡牌游戏(四)

用js写卡牌游戏(四)

前言 又过了三个月,咳咳咳…… 这次我决定录一个视频,如果不想看文字的朋友,可以翻到最下面看视频,内容和文字差不多。 线上地址:http://cardgame.xiejingyang.com github:https://github.com/xieisabug/card-game 正文 首先来做攻击效果,也就是卡牌冲过去,再回来。这属于动画效果,我这里就不造轮子了,直接找一个现成的好用点的动画库,这里我用的是velocity-animate,首先进行安装。 `npm install --save velocity-animate`先取到页面上的两个卡牌容器,用于遍历双方桌面上的卡牌dom: this.myCardAreaDom = document.querySelector(".my-card-area"); this.otherCardAreaDom = document.querySelector(".other-card-area");之后要寻找出需要攻击的卡牌,思路是:在mouseup的监听事件中,如果处于选择攻击目标的状态,那么判断松开鼠标的点是在哪个卡牌的box里,就是攻击的哪个卡牌。 window.onmouseup = (e) => { if (window.isAttackDrag) { window.isAttackDrag = false; this.showCanvas = false; this.canvasContext.clearRect(0, 0, this.windowWidth, this.windowHeight); let x = e.pageX, // 鼠标松开的x y = e.pageY, // 鼠标松开的y k = -1; // 用于记录找到的卡牌的index this.otherCardAreaDom.childNodes.forEach(cd => { // 循环遍历对手的卡牌dom let top = cd.offsetTop, width = cd.offsetWidth, left = cd.offsetLeft, height = cd.offsetHeight; if (x > left && x < (left + width) && y > top && y < (top + height)) { // 边缘检测 k = cd.dataset.index; } }); } }找到要攻击的卡牌之后,写出动画代码,卡牌位移冲过去,击中后返回原位置,其中就是要找到translate的偏移量,然后做css动画:attackAnimate(from, to) { let myDom = this.myCardAreaDom.childNodes[from]; let otherDom = this.otherCardAreaDom.childNodes[to]; let h = otherDom.offsetLeft - myDom.offsetLeft; // 偏移x let v = otherDom.offsetTop + otherDom.offsetHeight - myDom.offsetTop - myDom.parentElement.offsetTop; // 偏移y Velocity(myDom, { translateX: h, translateY: v }, { easing: 'ease-in', duration: 200, begin: () => { myDom.style['transition'] = 'all 0s'; } }).then(el => { return Velocity(el, { translateX: 0, translateY: 0 }, { easing: 'ease-out', duration: 300, complete: () => { myDom.style['transition'] = 'all 0.2s'; } }) }) },在边缘检测完毕的时候,运行动画: if (x > left && x < (left + width) && y > top && y < (top + height)) { // 边缘检测 k = cd.dataset.index; this.attackAnimate(0, k); }但是这样仅仅只是单机上完成了,不仅对方不知道你进行了攻击,也将逻辑放在了客户端,这样很不安全,现在就需要服务端来进行数据的计算,客户端只做效果的展示。 那么先处理一下攻击事件,在客户端发起攻击的时候,暂时不需要做过多的处理,注释之前的动画代码,直接发送攻击事件给后端: attackCard(k) { if (this.isMyTurn && this.currentTableCardK !== -1) { this.socket.emit("COMMAND", { // 使用COMMAND,集中处理 type: "ATTACK_CARD", r: this.roomNumber, myK: this.currentTableCardK, attackK: k }); this.resetAllCurrentCard(); } },if (x > left && x < (left + width) && y > top && y < (top + height)) { // 边缘检测 k = cd.dataset.index; // this.attackAnimate(0, k); this.attackCard(k); }这里我将socket的事件,统一用"COMMAND"进行处理,这样后台进行处理的时候,代码比较好管理。 后端修改之前的代码,处理COMMAND命令: socketServer.on('connection', function (socket) { console.log("connect one on :" + new Date().toLocaleString()); socket.on('COMMAND', function () { let args = Array.prototype.slice.call(arguments); args.push(socket, socketServer); handleSynchronousClient.apply(this, args); }); // other code …… });module.exports = function handleSynchronousClient(args, socket, socketServer) { switch (args.type) { case "CONNECT": connect(args, socket, socketServer); break; case "ATTACK_CARD": attackCard(args, socket); break; } };可以看到,修改之后用COMMAND命令之后可以用switch判断type,集中的在一块地方处理对战的所有指令。connect就是将之前的CONNECT命令的处理拷贝过来,attackCard是处理攻击的逻辑,由于对战的卡牌等数据都没有设计,所以使用最简单的转发,将攻击卡牌的事件分发给对战的双方: function attackCard(args, socket) { let roomNumber = args.r, myK = args.myK, attackK = args.attackK, card, attackCard; if (!memoryData[roomNumber]) { return } let belong = memoryData[roomNumber]["one"].socket.id === socket.id ? "one" : "two"; // 判断当前是哪个玩家出牌 let other = memoryData[roomNumber]["one"].socket.id !== socket.id ? "one" : "two"; memoryData[roomNumber][belong].socket.emit("ATTACK_CARD", { k: attackK }); memoryData[roomNumber][other].socket.emit("ATTACK_CARD", { k: attackK }); }前端处理后端的转发: this.socket.on("ATTACK_CARD", (param) => { this.attackAnimate(0, param.k) });效果:这样就完成了一次攻击,但是卡牌的血量还没有扣减,这就涉及到要设计卡牌了,下一章着重讲一下卡牌的数据设计和发牌的逻辑。

用js写卡牌游戏(三)

用js写卡牌游戏(三)

废了又废话 上篇文章发了之后,有挺多朋友来注册线上地址的,受宠若惊。 然后看了看上篇文章的日期,6个月前,emmmm,为什么我这么懒。。。 开了一个交流群,532413727,大家有啥想问的想说的可以加群交流。 第三回(卡牌攻击) 接着上节所说,接下来制作卡牌的ui,首先创建一个component文件夹,在文件夹中创建我们的Card.vue,按照上一章我们的设计图:写出Card的简略dom如下:{{name}} {{cost}}{{content}}{{attack}}{{life}}export default { name: "Card", data () { return { name: "测试", cost: 5, content: "测试卡片", attack: 10, life: 10 } } }这个时候可以在GameTable.vue中引入这个组件进行一下预览,在my-card-area区域中去掉之前的{{count}},加入刚刚Card组件,记得要在script里面引入Card。这个时候就能看到一个非常丑陋的卡片了。这是因为我们还没添加组件的样式,我们为组件加上基本的样式:.card { position: relative; width: 135px; height: 170px; font-size: 12px; border: 1px solid #ccc; border-radius: 5px; background: white; }.card-name { height: 45px; background: #394950; color: white; border-top-right-radius: 5px; border-top-left-radius: 5px; text-align: center; margin-bottom: 15px; box-sizing: border-box; padding: 8px 0; font-weight: bold; }.card-cost { position: absolute; background-color: white; color: #394950; border-radius: 50%; width: 25px; height: 25px; left: 4px; top: 33px; display: flex; justify-content: center; align-items: center; box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.16), 0 0 0 1px rgba(0, 0, 0, 0.08); }.card-content { padding: 0 8px; }.card-bottom { position: absolute; bottom: 0px; width: 100%; background: #394950; display: flex; justify-content: space-between; padding: 8px 10px; color: white; box-sizing: border-box; border-bottom-right-radius: 5px; border-bottom-left-radius: 5px; }添加了这些样式之后,就能看到我们想要的卡片效果了,当然,你也可以按照自己的想法修改上面的样式,卡片的样式不会影响游戏的功能。这个时候给对手的桌面上也放上一张卡片,也就是在other-card-area中也增加一个Card。双方都有卡片了,现在要制作攻击效果了。 攻击的效果如果使用dom来制作,会非常的不方便,所以需要使用到canvas来绘制这部分的效果,我的思路是先将动画制作出来,然后再应用到卡片上,然后再实现攻击的逻辑部分,那么开始动手。 首先在页面上添加canvas,编写样式和context初始化: HTML:Javascript(GameTable文件,mounted方法的尾部): this.windowWidth = window.innerWidth; this.windowHeight = window.innerHeight;window.onresize = () => { this.windowWidth = window.innerWidth; this.windowHeight = window.innerHeight; } this.canvasContext = document.querySelector("#animationCanvas").getContext("2d");CSS: #animationCanvas { width: 100%; height: 100%; position: absolute; left: 0; top: 0; z-index: 999; }我们需要的效果是鼠标按下后,在页面上画一根线条,松开鼠标时线条消失,所以思路很简单,在按下鼠标时记录按下的点A,在鼠标移动的时候绘制点A到当前位置的一根线条,在松开鼠标的时候清除线条,所以添加下面的代码到mounted代码尾部: window.onmousedown = (e) => { window.isAttackDrag = true; this.attackStartX = e.pageX; this.attackStartY = e.pageY; }window.onmousemove = (e) => { if (window.isAttackDrag) { window.requestAnimationFrame(() => { this.canvasContext.clearRect(0, 0, this.windowWidth, this.windowHeight); this.canvasContext.strokeStyle = 'maroon'; this.canvasContext.fillStyle = 'maroon'; this.canvasContext.save(); this.canvasContext.setLineDash([40, 10]); this.canvasContext.lineWidth = 30; this.canvasContext.beginPath(); this.canvasContext.moveTo(this.attackStartX, this.attackStartY); this.canvasContext.lineTo(e.pageX, e.pageY); this.canvasContext.fill(); this.canvasContext.stroke(); this.canvasContext.restore(); }) } }window.onmouseup = () => { if (window.isAttackDrag) { window.isAttackDrag = false; this.canvasContext.clearRect(0, 0, this.windowWidth, this.windowHeight) } }保存后查看效果,恩~还不错,不过总觉得少了点什么,哦!是箭头!那么尝试画一个箭头在顶端吧,其实就是画一个三角形在顶端,绘制三角形其实很简单,但是难点就是这根直线是有角度的,所以三角形也要跟着直线的角度旋转。好在这些都是在网上能查到资料的,所以把下面这段代码加到刚刚绘制直线的代码后面,就能看到效果了: this.canvasContext.save(); this.canvasContext.beginPath(); this.canvasContext.lineCap = 'square'; this.canvasContext.translate(e.pageX, e.pageY); let getLineRadians = () => { let _a = e.pageX - this.attackStartX; let _b = e.pageY - this.attackStartY; let _c = Math.hypot(_a, _b); return Math.acos(_a / _c) * Math.sign(_b); }; this.canvasContext.rotate(getLineRadians() - Math.PI /2); this.canvasContext.moveTo(35, -40); this.canvasContext.lineTo(0, 25); this.canvasContext.lineTo(-35, -40); this.canvasContext.lineTo(35, -40); this.canvasContext.fill(); this.canvasContext.stroke(); this.canvasContext.restore();到这里,实现了第一步,但是目前在任意位置都能绘制这样一根直线,而我们的目标是只有在我们的卡牌上才可以进行攻击操作,所以要修改一下我们刚刚的代码。 首先将原来的window.mousedown事件注释掉,将mousedown事件绑定到Card组件中,在Card的最外层的div上加入mouseDown事件,在事件里emit事件到外层: mouseDown(e) { this.$emit('onAttackStart', { startX: e.pageX, startY: e.pageY }) }外层中GameTable页面写一个onAttackStart的方法来接收事件,这个事件其实就是之前的mousedown事件,只是多了一个控制canvas是否显示的变量: onAttackStart({startX, startY}) { this.showCanvas = true; window.isAttackDrag = true; this.attackStartX = startX; this.attackStartY = startY; }有显示canvas就要能隐藏,在之前的onmouseup方法里,加入this.showCanvas = false 与此同时,在GameTable组件中的my-card-area里的Card组件,传入刚刚写好的onAttackStart,这样就实现了只能在Card上面拖拽进行攻击了。 下一回我计划做卡牌攻击的效果和服务端的一些事情,感兴趣的同学请继续留意吧。 github地址在这里,这篇文章的代码tag是a-3。

用js写卡牌游戏(二)

用js写卡牌游戏(二)

直接看代码的点这 又废话(前言) 别看这个游戏现在这个垃圾样,我可是摸索了将近半年才写出来的,所以我现在理解一个好游戏要是想做出来,为啥要两三年了。 目前最新进度游戏线上地址 ,欢迎大家注册了之后体验(如果没有人对战,可以单人剧情体验),希望大家多提建议! 第二回合(对战通信) 采购完项目的材料,要开始建地基了。 如果把我们的游戏中的概念日常化,那么对战其实就是两个人进入了一个聊天室(匹配),用我指定的语言(卡牌)在聊天(对战)。所以我们先按照聊天室来编写我们的程序。 首先先给两个人开个房,emmmm……正规房。 作为一个在线对战游戏,需要保证两个人能连到一个房间,并且不掉线,掉线的时候自动重连,听起来这一步就很费功夫了,好在这些需求socket.io都已经实现了,我们就聚焦在怎么实现游戏系统上就ok。进入房间下一步就开始进行广播,当我发送一条消息的时候,由服务器接收这个消息,然后进行处理后再广播给包括我在内的房间里的用户。 这个地方要解释一下为什么要广播给自己,而不只广播给别人在本地处理自己。这个地方我是这么考虑的:能够统一的处理所有人的同类消息。 游戏是时序重要的,也就是说,每张牌一定要按照打出的顺序处理,不然会有截然不同的结果。 不能在客户端本地做操作,在服务器上做统一的处理以防止本地作弊。定一个初步的目标是两个人能够进入房间并且同步增加一个计数器。 客户端的连接可以直接使用之前的代码,先做服务端的处理,将恰好两人放入同一个房间。 这里我使用的方法是先使用一个数组保存待匹配的用户,一个缓存保存每个用户当前的房间号码,再使用一个缓存保存每个房间里的游戏数据。在app.js中插入下列代码: const waitPairQueue = []; // 等待排序的队列 const memoryData = {}; // 缓存的房间游戏数据,key => 房间号,value => 游戏数据 const existUserGameRoomMap = {}; // 缓存用户的房间号, key => 用户标识,value => 房间号这样,当某个用户加入进来的时候,我们进行下列操作:对用户先发送连接成功请等待的命令。 查看是否有等待匹配的用户,没有则将当前用户加入队列,如果有则取出队列中的一个用户。 生成一个房间号码,将用户的信息缓存起来,将通过房间号初始化游戏数据。 用户连入同一个socket服务,并且缓存用户的socket实例。 告诉用户连接完成,同时发送初始化游戏数据。在原connection事件里,新监听一个连接事件。 socket.on('CONNECT', function () { let args = Array.prototype.slice.call(arguments); // 将arguments转为真数组 const {userId} = args; });在这个连接事件里,进行上面列出的5步操作: socket.emit("WAITE"); // 不管三七二十一,先给老子等起在匹配队列里寻找对手,为了简单,我暂时先直接取队列里的第0个,以后会完善一套科学的匹配机制。 if (waitPairQueue.length === 0) { // 如果当前没有等待的玩家,则将自己加入等待队列 waitPairQueue.push({ userId, socket }); } else { let waitPlayer = waitPairQueue.splice(0, 1)[0]; // 随便拉个小伙干一架 // 下一步从这继续 }我决定用uuid来作为房间号码,所以需要安装一个uuid库,执行: npm i uuid --save记得引入uuid: const uuidv4 = require('uuid/v4');在一局游戏中,玩家需要标识在这局游戏中的唯一身份,我就用one和two来表示了。 let roomNumber = uuidv4(); // 生成房间号码// 初始化游戏数据 waitPlayer.roomNumber = roomNumber; memoryData[roomNumber] = { "one": waitPlayer, "two": { userId, socket, roomNumber }, count: 0 }; existUserGameRoomMap[userId] = roomNumber; existUserGameRoomMap[waitPlayer.userId] = roomNumber;socketio加入房间使用join方法: // 进入房间 socket.join(roomNumber); waitPlayer.socket.join(roomNumber);初始化游戏数据,我们还没有设计具体的游戏数据结构,就使用个简单的计数器先来做测试。 // 游戏初始化完成,发送游戏初始化数据 waitPlayer.socket.emit("START", { start: 0, memberId: "one" }); socket.emit("START", { start: 0, memberId: "two" });同时我们还需要监听客户端的操作,比如增加计数器,增加一个事件ADD,处理count的增加后再广播给所有用户: socket.on("ADD", function() { let args = Array.prototype.slice.call(arguments); let roomNumber = existUserGameRoomMap[args.userId]; memoryData[roomNumber].count += 1; memoryData[roomNumber]["one"].socket.emit("UPDATE", { count: memoryData[roomNumber].count }); memoryData[roomNumber]["two"].socket.emit("UPDATE", { count: memoryData[roomNumber].count }); })完整的代码如下: socket.on('CONNECT', function () { let args = Array.prototype.slice.call(arguments); // 将arguments转为真数组 const {userId} = args; socket.emit("WAITE"); // 不管三七二十一,先给老子等起 if (waitPairQueue.length === 0) { waitPairQueue.push({ userId, socket }); socket.emit("WAITE"); } else { let waitPlayer = waitPairQueue.splice(0, 1)[0]; // 随便拉个小伙干一架 let roomNumber = uuidv4(); // 生成房间号码 // 初始化游戏数据 waitPlayer.roomNumber = roomNumber; memoryData[roomNumber] = { "one": waitPlayer, "two": { userId, socket, roomNumber }, start: 0 }; existUserGameRoomMap[userId] = roomNumber; existUserGameRoomMap[waitPlayer.userId] = roomNumber; // 进入房间 socket.join(roomNumber); waitPlayer.socket.join(roomNumber); // 游戏初始化完成,发送游戏初始化数据 waitPlayer.socket.emit("START", { start: 0, memberId: "one" }); socket.emit("START", { start: 0, memberId: "two" }); } }); socket.on("ADD", function() { let args = Array.prototype.slice.call(arguments); let roomNumber = existUserGameRoomMap[args.userId]; memoryData[roomNumber].count += 1; memoryData[roomNumber]["one"].socket.emit("UPDATE", { count: memoryData[roomNumber].count }); memoryData[roomNumber]["two"].socket.emit("UPDATE", { count: memoryData[roomNumber].count }); });接下来就是处理前端的响应了,首先在接收到WAIT的时候,需要显示匹配中,在接收到START的时候,初始化游戏并且把我们的计数器显示在页面上。 首先在data里添加三个变量,一个用作匹配窗口是否显示,一个作为计数器,一个作为暂时的用户id(后续会实现用户系统再进行替换): data() { return { matchDialogShow: false, count: 0, userId: new Date().getTime() }; },更改mounted方法,添加连接成功后通知服务器匹配,再原来的事件监听删除,换成下面三个: this.socket.emit("COMMAND", { type: "CONNECT", userId: this.userId });this.socket.on("WAITE", args => { this.matchDialogShow = true; });this.socket.on("START", args => { this.count = args.start; this.matchDialogShow= false; });this.socket.on("UPDATE", args => { this.count = args.count; });在页面上添加匹配对话框dom,并且添加计数器显示和计数器增加按钮,同时添加一点样式: {{count}} +1 正在匹配,请等待.match-dialog-container { position: absolute; width: 100%; height: 100%; left: 0; top: 0; display: flex; justify-content: center; align-items: center; font-size: 20px; background: rgba(0, 0, 0, 0.5); color: white; }添加一个方法add,用于发送增加事件给服务器: methods: { add() { this.socket.emit("ADD", { userId: this.userId }); } }将代码跑起来,打开两个浏览器,点击按钮,就可以看到同一个房间的用户可以控制同一个计数器了。在这个浏览器点击4下,在另外一个浏览器点击4下 游戏的基本数据交互方法已经实现了,接下来要设计一下游戏的卡牌了,采用卡牌游戏的经典设计:那么一张卡牌的最基础的数据结构应该如下: 字段描述id 卡牌的唯一idname卡牌的名称cardType卡牌类型,如:伙伴,魔法效果等cost卡牌费用content卡牌描述attack卡牌攻击life卡牌生命 游戏的背景,就选择编程界,一来是熟悉,二来目前文章前阅读的大家也都能懂,那我们先来设计一张最简单的卡牌吧。最近互联网寒冬,那就设计一个被开除的程序员吧: { id: 1, name: "被开除的员工", cardType: 1, cost: 3, content: "", attack: 4, life: 4 }接下来,就要使用这个数据制作卡牌了,那就留到下一章吧~ 再提一次,目前最新进度游戏线上地址 ,欢迎大家注册了之后体验(如果没有人对战,可以单人剧情体验),希望大家多提建议! 下一章或许我会把三章一起开始录制视频(取决于我懒不懒)

用js写卡牌游戏(一)

用js写卡牌游戏(一)

不想看废话的点这&nbsp; 直接看代码的点这 废话(前言) 现在游戏多了,不过总是感觉不太对自己的口味,每个游戏都感觉和自己想象中的要差了那么一点点,所以我决定尝试着自己写一个游戏。 因为从来没做过游戏开发,所以所有游戏机制的实现都只能是在网上查或者自己摸索,如果大家在看文章( 或视频 )的时候有更好的实现方法,请一定要告诉我。 那么策划下这个游戏吧,我的口味是怎样的呢:随时可以玩。由于我上班的时候有时候觉得很无聊,也许想放松一下,所以最好这个游戏是网页版的,随时打开随时玩。 最好是要用到脑子玩。哼,大家辣么聪明,肯定要靠智力虐人的对吧,那么应该是一个能让人越动脑就越厉害的游戏。 不要氪金。消费内容一定不能影响游戏平衡,或者干脆没有消费内容,装备全靠打。 有没有伙伴,有多少伙伴,都能玩。希望喜欢单机挑战的小伙伴能玩,情侣能玩,宿舍能玩,很多朋友一起也能玩。综上所述,我决定做的这个游戏就是!!!——炉石传说的网页版,emmmmmm……,没事,先模仿再提高吧。 然后再说一下这个视频的受众和需要的基础,因为这个视频没有使用高深的技术,所以想学习到很底层技术的同学可能会失望,这是游戏线上beta版本的地址,大家可以去试玩一下,如果觉得感兴趣,自己也想开发一款这样的游戏,那么你可以继续看了。 我会将代码按批次开源,这个项目在视频出完之前,暂时不接受贡献,因为会打乱我视频的节奏,希望大家理解,等项目出完之后,会接受pull request,所以现阶段对项目想改善的可以直接向我提意见。 由于是网页版本的游戏,那么需要一定的前端基础,当然没有基础的你也可以图个乐子。既然是个网络游戏,那么肯定是有后端的,所以需要掌握一点后端思想。最次,你也要知道编程是个什么东西,然后才能享受看别人敲代码的乐趣。 下面就是正文内容,我们就先进行技术选型,把框架搭起来,数据交互能够联通。 第一回合(准备开始) 先安装需要的库,不使用多厉害的游戏引擎了,就使用最方便开发的技术来实现。那我就选择了vue,如果有同学想用react或者angular或者jquery,都可以的。那我们先安装vue,vue-router,先把游戏的页面搭建出来。 这里我就使用vue-cli,这个呢是vue官方出的一个脚手架,就是帮你初始化一个项目的。那我们先在命令行里执行: `npm install -g @vue/cli`先在全局安装好vue-cli,然后执行vue-cli的命令: `vue create card-game-client`选择Manually select features,会有一些选项要求选择,我们只需要:vue-router,vuex,babel vue-router为了以后发布方便不使用history模式。 然后再要初始化一个后台项目,创建文件夹card-game-server,为了方便,我就直接用nodejs作为游戏后台了,先初始化一个express项目,在目录下执行: `npm init`初始化npm,然后再安装需要的库: `npm i express body-parser cors log4js --save`不过作为一个游戏来说,肯定数据交互是不能用http请求的,那就使用websocket技术来和后台进行数据交互,我就使用socketio这个库了,继续在命令行执行: `npm i socket.io --save`好。那么就开始激动人心的第一步,hello world。 首先大家在client项目的src文件夹下把原来的views删除,创建一个叫pages的文件夹,存放我们的页面,这一步很重要,它主要目的是——我比较喜欢pages这个单词。创建以后游戏主要场景页面,GameTable.vue: `export default { name: "GameTable" } `在GameTable加载的完成后,安装socketio客户端。 `npm i socket.io-client --save`自动连接服务器,并发送一个hello的消息,并监听即将收到的服务器的消息,显示在页面: `{{message}}import * as io from 'socket.io-client';export default { name: "GameTable", data() { return { message: "" } }, mounted() { this.socket = io.connect('http://localhost:4001'); this.socket.emit('hello'); this.socket.on("world", args => { this.message = args.message; }); } } `页面写好之后,不要忘记修改router,打开router.js,删除之前默认配置,把我们的新页面加进去: `import Vue from 'vue' import Router from 'vue-router' import GameTable from './pages/GameTable.vue'Vue.use(Router)export default new Router({ routes: [ { path: '/', name: 'gameTable', component: GameTable } ] })`App.vue中也有一些默认生成的dom和css,删除掉不需要的: `#app { font-family: 'Avenir', Helvetica, Arial, sans-serif; -webkit-font-smoothing: antialiased; -moz-osx-font-smoothing: grayscale; text-align: center; color: #2c3e50; margin-top: 60px; } `客户端发送写好了,来写一下服务端处理程序,首先在server的文件夹下创建app.js文件,在app.js文件中初始化服务器: `let http = require('http'); let express = require('express'); let cors = require('cors'); let bodyParser = require('body-parser'); let socket = require("socket.io"); let app = express();app.use(cors()); app.use(bodyParser.json()); app.use(bodyParser.urlencoded({extended: false}));let server = http.createServer(app); let socketServer = socket(server);server.listen(4001, function () { console.log("listen"); }); socketServer.on('connection', function (socket) { console.log("connect one on :" + new Date().toLocaleString()); socket.on('hello', function () { // 监听hello事件 socket.emit('world', { message: 'hello world' }) }); socket.on('disconnect', function () { console.log("disconnect one on :" + new Date().toLocaleString()); });});`let socketServer = socket(server);这行代码创建了一个socket服务,然后通过监听事件和发送消息来和客户端互动。 接下来就在server目录运行node app.js,在client目录运行npm run serve,就能运行前端和后端,如果在页面上看到hello world,就证明框架搭建完成了。 接下来,继续下一步,对战界面的绘制。 根据市面上的卡牌游戏设计,对战最基本是有两个角色栏(对战双方),两个手牌区(对战双方),一张对战桌。所以,我们的对战区域就长这样:先把桌面和己方手牌区域画出来,在GameTable.vue中,添加下面的代码: ``为了让界面更加容易区分,我们给各个区域加上鲜明的颜色: `.app { width: 100%; height: 100%; overflow: hidden; user-select: none; }.my-card { position: absolute; bottom: 20px; width: 100%; min-height: 170px; display: flex; justify-content: center; background: #f00; }.table { width: 100%; height: 100%; }.my-card-area { width: 100%; height: 33%; min-height: 170px; position: absolute; bottom: 210px; display: flex; padding: 10px; box-sizing: border-box; justify-content: center; background-color: #0f0; }.other-card-area { width: 100%; min-height: 170px; padding: 10px; display: flex; justify-content: center; box-sizing: border-box; flex-wrap: wrap; background-color: #00f; }`那么看到的效果应该是这样的:做到这一步,相信大家也能看出这个游戏的雏形了吧……emmmmmm,下一章进度加快吧。 再发一次游戏最新进度的线上beta版地址,大家看了有兴趣的,就等更新吧~