From 997a5f070ecd9051b55848b9de4cb74498e91cb6 Mon Sep 17 00:00:00 2001 From: nonameShijian <2954700422@qq.com> Date: Wed, 17 Jan 2024 00:36:15 +0800 Subject: [PATCH] =?UTF-8?q?=E6=A0=87=E5=87=86=E5=8C=85=E6=AD=A6=E5=B0=86?= =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E6=8A=80=E8=83=BD=E4=BB=A3=E7=A0=81=E6=8F=90?= =?UTF-8?q?=E7=A4=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- character/standard.js | 7 +- node_modules/noname-typings/Card.d.ts | 23 + node_modules/noname-typings/Result.d.ts | 43 + node_modules/noname-typings/Skill.d.ts | 1820 ++++++++++++++++++++ node_modules/noname-typings/index.d.ts | 3 + node_modules/noname-typings/package.json | 2 +- node_modules/noname-typings/type.d.ts | 41 +- noname/get/index.js | 4 +- noname/get/is.js | 2 +- noname/library/element/gameEvent.js | 9 + noname/library/element/gameEventPromise.js | 2 +- noname/library/index.js | 15 +- noname/ui/index.js | 8 + 13 files changed, 1965 insertions(+), 14 deletions(-) create mode 100644 node_modules/noname-typings/Card.d.ts create mode 100644 node_modules/noname-typings/Result.d.ts create mode 100644 node_modules/noname-typings/Skill.d.ts diff --git a/character/standard.js b/character/standard.js index a026971f6..c9744c1fb 100755 --- a/character/standard.js +++ b/character/standard.js @@ -1,4 +1,4 @@ -'use strict'; +import { game } from '../noname.js'; game.import('character',function(lib,game,ui,get,ai,_status){ return { name:'standard', @@ -93,6 +93,9 @@ game.import('character',function(lib,game,ui,get,ai,_status){ ganning:['lingtong','xf_sufei'], guanyu:['zhangfei','liaohua'], }, + /** + * @type { { [key: string]: Skill } } + */ skill:{ //标准版甘夫人 stdshushen:{ @@ -304,7 +307,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){ logTarget:'source', preHidden:true, filter(event,player){ - return (event.source&&event.source.countGainableCards(player,event.source!=player?'he':'e')&&event.num>0); + return event.source&&event.source.countGainableCards(player,event.source!=player?'he':'e')>0&&event.num>0; }, async content(event,trigger,player){ player.gainPlayerCard(true,trigger.source,trigger.source!=player?'he':'e'); diff --git a/node_modules/noname-typings/Card.d.ts b/node_modules/noname-typings/Card.d.ts new file mode 100644 index 000000000..07d0ce051 --- /dev/null +++ b/node_modules/noname-typings/Card.d.ts @@ -0,0 +1,23 @@ +declare type CardBaseUIData = { + name?: string; + suit?: string; + number?: number; + nature?: string; + + //用于某些方法，用于过滤卡牌的额外结构 + type?: string; + subtype?: string; + color?: string; + + /** + * 是否时视为牌 + * + * 是本来的卡牌，则为true,作为视为牌则为false/undefined + * 在useCard使用时，作为视为牌，会把next.cards,设置为card.cards; + * + */ + isCard?: boolean; + + /** 真实使用的卡牌 */ + cards?: Card[]; +} \ No newline at end of file diff --git a/node_modules/noname-typings/Result.d.ts b/node_modules/noname-typings/Result.d.ts new file mode 100644 index 000000000..24bfb85aa --- /dev/null +++ b/node_modules/noname-typings/Result.d.ts @@ -0,0 +1,43 @@ +declare interface Result { + /** + * 最终结果 + * + * 大多代表该事件到达这一步骤过程中的结果; + * 一般用来标记当前事件是否按预定执行的，即执行成功 + * + * 大部分事件间接接触game.check，一般最终结果不变，大多数是这种 + * + * 其实主要是ok方法会有直接的bool，主要涉及game.check; + */ + bool?: boolean; + + //choose系 + /** 记录返回当前事件操作过程中的卡牌 */ + cards: Card[]; + /** 记录返回当前事件操作过程中的目标 */ + targets: Player[]; + /** 记录返回当前事件操作过程中的按钮 */ + buttons: Button[]; + /** 记录buttons内所有button.link(即该按钮的类型，link的类型很多，参考按钮的item) */ + links: any[]; + + //control系(直接control系列没有result.bool) + /** control操作面板的选中结果，即该按钮的link，即名字 */ + control: string; + /** 既control的下标 */ + index: number; + + //ok系 + /** 记录返回当前事件操作过程中，面板按钮的确定ok取消cancel */ + confirm: string; + /** 一般为触发的“视为”技能 */ + skill: string; + /** + * 当前事件操作的“视为”牌， + * 当前有“视为”操作，该card参数特供给视为牌，不需要cards[0]获取视为牌 ； + * 判断是否为视为牌：card.isCard，false为视为牌 + */ + card: Card; + + [key: string]: any; +} \ No newline at end of file diff --git a/node_modules/noname-typings/Skill.d.ts b/node_modules/noname-typings/Skill.d.ts new file mode 100644 index 000000000..9c1b70514 --- /dev/null +++ b/node_modules/noname-typings/Skill.d.ts @@ -0,0 +1,1820 @@ +/** 时机 */ +declare interface SkillTrigger { + /** + * 全场任意一名角色 + * + * 代表所有人 + */ + global?: string | string[]; + /** + * 玩家自己 + * + * 触发时件中，技能拥有者为事件的发起者; + * + * 注：需要是自己引发的事件； + */ + player?: string | string[]; + /** + * 你自己成为目标时 + */ + target?: string | string[]; + /** + * 来源是你自己时 + */ + source?: string | string[]; +} + +/** + * hookTrigger在不同方法中触发的方法接口 + * + * 注：似乎时用于模式，作为，游戏全局的一些每次都需要触发的方法（算是不实用的一个接口） + */ +declare interface SkillHookTrigger { + /** + * 【hookTrigger相关】 + * + * 之后处理方法 + * + * 在createTrigger中最终步骤中，需要当前没有hookTrigger配置才调用到 + * + * 若返回true时，会触发“triggerAfter” + * + * @param event + * @param player + * @param triggername + */ + after?(event: GameEventPromise, player: Player, triggername: string): boolean; + /** + * 【hookTrigger相关】 + * + * 在filterTrigger中执行，过滤发动条件，和filter有些类似，具体功能稍后分析 + */ + block?(event: GameEventPromise, player: Player, name: string, skill: string): boolean; + /** + * 【hookTrigger相关】 + * + * 在logSkill中执行，每次触发logSkill都会触发 + */ + log?: ThreeParmFun; +} + +/** mod的配置 */ +declare interface Mod { + /** + * 卡牌是否可弃置 + * @param card:Card 牌 + * @param player:Player 玩家 + */ + cardDiscardable?(card: Card, player: Player): boolean | void; + /** + * 卡牌是否可用(卡牌能否被选择) + * cardEnabled一起使用 + * + * 适用范围：player.canUse，lib.filter.cardEnabled，默认lib.filter.filterCard + * + * @param card:Card 牌 + * @param player:Player 玩家 + */ + cardEnabled?(card: Card, player: Player): boolean | void; + /** + * 卡牌是否可用（适用范围基本可以视为所有情况下） + * + * 适用范围：event.backup中技能信息触发（viewAS），cardEnabled（优先于该mod的触发），cardRespondable（优先于该mod的触发），_save（优先于cardSavable的mod触发）中均触发 + */ + cardEnabled2?(card: Card, player: Player): boolean | void; + /** + * 卡牌是否可用（改变卡牌的使用次数） + * + * 要与cardEnabled一起使用（目前看来两个效果一致） + * + * @param card Card 牌 + * @param player Player 玩家 + * @param num 使用次数 + */ + cardUsable?(card: Card, player: Player, num: number): boolean | number | void; + /** + * 卡牌是否可以响应 + * + * 要与cardEnabled一起使用（目前看来两个效果一致） + * + * @param card:Card 牌 + * @param player:Player 玩家 + */ + cardRespondable?(card: Card, player: Player): boolean | void; + /** + * 卡牌是否可以救人 + * + * 要与cardEnabled一起使用（目前看来两个效果一致） + * + * 注：还是和cardEnabled不同，设置了该mod检测，只要是在_save，濒死求救阶段，都可以触发； + * + * 不过前提，可能还是要通过该阶段的cardEnabled的检测，目前还没确定，日后再做分析 + * + * 适用范围：濒死阶段的filterCard + * + * @param card:Card 牌 + * @param player:Player 玩家 + * @param taregt:Target 当前处于濒死求救得玩家 + */ + cardSavable?(card: Card, player: Player, taregt: Player): boolean | void; + /** + * 在全局的防御范围 + * + * 注：防御距离就是要和别人的距离越远，所以，拉开距离需要增加； + */ + globalTo?(from: Player, to: Player, current): number | void; + /** + * 在全局的进攻距离 + * + * 注：进攻距离就是要和别人的距离越近，所以，增加距离需要减掉； + */ + globalFrom?(from: Player, to: Player, distance: number): number | void; + /** + * 角色的攻击范围 + * @param from + * @param to + * @param range + * + * 注：和globalFrom同理，拉近距离，减去； + */ + attackFrom?(from: Player, to: Player, range: number): number | void; + /** + * 攻击到角色的范围 + * @param from + * @param to + * @param range + * + * 注：和globalTo同理，拉开距离，增加； + */ + attackTo?(from: Player, to: Player, range: number): number | void; + /** 手牌上限 */ + maxHandcard?(player: Player, num: number): number | void; + /** + * 选择的目标 + * + * card：牌； + * + * player：玩家； + * + * range： + * range[1]：目标个数; + */ + selectTarget?(card: Card, player: Player, range: Select): void; + + /** + * 该卡牌的发动源玩家是否能使用该卡牌（该角色是否能使用该牌） + * + * @param card:Card + * + * @param player:Player 源玩家（使用牌的角色） + * + * @param target:Target 目标玩家 + */ + playerEnabled?(card: Card, player: Player, target: Player): boolean | void; + /** + * 是否能成为目标 + * + * card：牌； + * + * player：使用牌的角色； + * + * target：玩家 + */ + targetEnabled?(card: Card, player: Player, target: Player): boolean | void; + + /** + * 可以指定任意（范围内）目标 + * + * @param card:Card 牌 + * + * @param player:Player 玩家(使用牌的角色) + * + * @param target:Target 目标 + * + * @return 返回bool值可以不接受，范围检测，使用返回的结果;返回number，即计算距离是增加该距离；不返回，默认正常的范围检测 + */ + targetInRange?(card: Card, player: Player, target: Player): boolean | number | void; + /** + * 弃牌阶段时，忽略的手牌 + * + * @param card:Card + * + * @param player:Player + */ + ignoredHandcard?(card: Card, player: Player): boolean | void; + + /** 过滤可以被丢弃的牌 */ + canBeDiscarded?(card: Card, player: Player, target: Player, eventName: string): boolean | void; + /** 过滤可以获得的牌 */ + canBeGained?(card: Card, player: Player, target: Player, eventName: string): boolean | void; + + /** + * 改变花色 + */ + suit?(card: Card, suit: string): string | void; + /** + * 改变判断结果 + * + * 注：目前似乎没有用到该mod.改变结果不影响判定的牌结果，影响判定的最终结果，即之后判定牌的effect会受该结果影响 + * @param player + * @param result + */ + judge?(player: Player, result: JudgeResultData); + + //2020-2-23版本： + /** + * 为技能配置一个自定义在事件中处理的回调事件，该事件的使用需要自己使用，实际是一个自定义事件，没什么实际意义； + * + * 其设置的位置在技能content期间设置，设置在期间引发的事件中； + * + * 用于以下场合：judge，chooseToCompareMultiple，chooseToCompare + * + * 新版本的judge事件中 可以通过设置callback事件 在judgeEnd和judgeAfter时机之前对判定牌进行操作 + * + * 在判断结果出来后，若事件event.callback存在，则发送“judgeCallback”事件 + * + * 同理拼点,在拼点结果出来后，发送“compareMultiple”事件（“compare”暂时没有） + * + * callback就是作为以上事件的content使用 + */ + callback?: ContentFuncByAll; + + //无懈相关：主要在_wuxie中，（此时应时无懈询问阶段），检测触发卡牌以下对应mod + /* + 主要参数解析： + card:trigger.card 触发该无懈阶段的卡牌； + + player:当前事件的玩家（应该也是触发该阶段的玩家） + + target:trigger.target 触发该无懈阶段的卡牌的玩家； + + current:当前game.filterPlayer，遍历过滤检测可以发动无懈的每一个玩家（即当前过滤检测中的玩家） + */ + //触发阶段为:phaseJudge(判定阶段) + /** 是否能在判定阶段使用无懈 */ + wuxieJudgeEnabled?(card: Card, player: Player, current: Player): boolean | void; + /** 是否能在判定阶段响应无懈 */ + wuxieJudgeRespondable?(card: Card, player: Player, current: Player): boolean | void; + //非判定阶段触发 + /** 是否能使用无懈 */ + wuxieEnabled?(card: Card, player: Player, target: Player, current: Player): boolean | void; + /** 是否能响应无懈 */ + wuxieRespondable?(card: Card, player: Player, target: Player, current: Player): boolean | void; + + //94版本 + /** 改变卡牌名字 用于get.name*/ + cardname?(card: Card, player: Player): string | void; + /** 改变卡牌伤害属性 用于get.nature*/ + cardnature?(card: Card, player: Player): string | void; + + /** 对特定角色使用牌的次数限制（用于优化【对特定角色使用牌无次数限制】的机制）【v1.9.105】 */ + cardUsableTarget?(card: Card, player: Player, target: Player): boolean | void; + + /** 用于get.value，对最后得返回value结果做处理 */ + aiValue?(player: Player, card: Card, num: number): number | void; + /** 用于get.order，对最后得返回order结果做处理 */ + aiOrder?(player: Player, card: Card, num: number): number | void; + + //player.inRange新增： + /** 在玩家范围内,即target是否在player的攻击范围内 */ + inRange?(from: Player, to: Player): boolean | void; + /** 在目标范围内,即player是否在source的攻击范围内 */ + inRangeOf?(from: Player, to: Player): boolean | void; + + /** + * 强制判断卡牌能否重铸 + * 【v1.9.108.6~】 + */ + cardChongzhuable?(card: Card, player: Player): boolean | void; + + aiValue?(player: Player, card: Card, num: number): number | void; + aiUseful?(player: Player, card: Card, num: number): number | void; +} + +/** 技能 */ +declare interface Skill { + /** + * 技能按钮名字，不写则默认为此技能的翻译（可认为为该技能用于显示的翻译名） + * 注：用得挺少得，貌似主要是使用翻译得 + */ + name?: string; + /** + * 新版：用于记录自身名字key，希望能用于自身某些配置上直接使用......，需要测试过才肯定；【结果：失败，还是没用，屏蔽掉】 + * + * 旧版：用于解析用的key，不直接参与游戏逻辑，参与自己定义的解析流程，实质就是技能的名字，规范按技能名命名 + */ + // key?:string; + + /** + * 继承 + * + * 比较特殊的属性，继承当前技能没有的，而inherit继承技能中有的属性； + * 其中“audio”属性，尽可能直接继承赋值为inherit的名字； + * 同时，对应的翻译会覆盖成继承技能的翻译。 + */ + inherit?: string; + + //声音 + /** + * 配音： + * + * 主要分为：audioname（默认技能名），audioinfo（默认info.audio） + * + * 若为字符串时，带有“ext:”，则使用无名杀录目\extension\扩展名内的配音（扩展的配音） + * + * ，命名方法：技能名+这是第几个配音 + * + * + * 否则，该字符串指代的是另一个技能的名字，若该技能名存在，则audioinfo为该技能的audio; + * + * 若为数组，则是[audioname,audioinfo]，分布覆盖原有的值。 + * + * audioinfo为数字时，数字为配音数量索引（同一技能有多个配音），从1开始，使用无名杀目录\audio\skill内的配音（audioname1~audioinfo序号）; + * + * audioinfo为布尔值true或者字符串非空时，执行game.playSkillAudio(audioname)，使用无名杀目录\audio\skill内的配音; + * + * 否则，若为false，空字符串，null结果，则不播音， + * + * 若info.audio:true，则使用game.playSkillAudio(audioname)。 + * + * 扩展(以game.trySkillAudio为准)： + * + * 若info.audio是字符串： + * + * 1.则主要是播放扩展声音,格式：ext:扩展包的名字:额外参数； + * + * 2.直接就是技能名，即继承该技能的播放信息，audioinfo； + * + * 若info.audio是数组，则[扩展名,额外参数]； + * + * 额外参数：1."true"，则直接播放该名字的声音；2.数字，则是随机选一个该"技能名+1-数字范围"的声音播放； + * + * 若info.audio是数字，则直接就是用解析出来的"audioname+1-数字范围"; + */ + audio?: number | string | boolean | [string, number]; + /** + * 指定武将名的音频。 + * + * 强制使用该audioname覆盖上面解析出来的audioname，其解析出来的audioname为“audioname_玩家武将名”, + * + * 最终路径为：无名杀目录\audio\“audioname_玩家武将名” + * + * 扩展： + * 若info.audioname存在，且是数组，且方法参数有player，则播放"audioname_玩家名"的声音（即可同一个技能，不同人播放不同声音） + */ + audioname?: string[]; + //【v1.9.102】 + /** + * 添加audioname2机制，用于重定向特定角色的语音到特定技能 + * + * 其key值为人物的name； + */ + audioname2?: SMap; + /** 强制播放音频 */ + forceaudio?: boolean; + + + //时机与触发相关 + /** + * 触发的时机 + * + * 一般用于触发技能（被动技能） + * + * 注1：主动触发enable，是没有event._trigger; + * + * 注2：有trigger，就表示这是一个触发技能，触发技能必须要有触发内容“content”，没有会引发报错； + */ + trigger?: SkillTrigger; + + /** + * 为true时，将该技能加入到_hookTrigger + * + * 根据代码理解： + * + * 通过addSkillTrigger，挂载在player._hookTrigger中； + * + * 作为一个单独触发的方式，每次createTrigger，logSkill，filterTriggers时执行所有挂载在_hookTrigger所有对应的hookTrigger； + * + * 目前可知，其相关使用方法：after,block,log【目前只有于国战方法中，应该是作为全局执行方法的一种简约写法，实用不大】 + */ + hookTrigger?: HookTrigger; + + /** 同时机技能发动的优先度 */ + priority?: number; + + //基本都在核心createTrigger，addTrigger，trigger中逻辑触发相关，属于重要得属性 + /** + * 目前具体不知什么功能，当前所知，非常重要，和createTrigger，addTrigger，trigger相关 + * （推测，这属性是指明客户端是否显示该技能的操作按钮） + * + * 1.用于双将，若该设置不为true，该技能时在hiddenSkills隐藏技能列表中，且为“非明置”状态，结束当前“createTrigger”事件的触发； + * 即该设置，可以让隐藏技能触发； + * + * 2.用于event.addTrigger，event.trigger中，若该设置为true，默认为其priority+1，影响技能的触发顺序 + * （该顺序从代码看起来主要受priority影响，因为会*100，设置这个，会比其他同级优先一点） + * + * 3.当设置了该值为true， + * 若forced没设置到，则默认为true； + * 若popup没设置到，则默认为false； + * + * 故该设置核心功能：表明该技能是强行触发技能,并且不提示 + */ + silent?: boolean; + /** + * 目前具体不清楚什么功能，当前所知，也是个很重要得属性，估计是托管时是否触发得标记 + * + * 功能相当于forced+nopop ,会不会是被托管时的标记呢，正在验证 + * + * 用于双将，上面的silent为true，其非明置，该设置不为true，则触发“triggerHidden”； + * + * 功能好像是直接触发，在createTrigger中，直接event._result={bool:true}执行，否则可能需要（info.check进行ai检测）； + */ + direct?: boolean; + /** + * 此技能是否可以被设置为自动发动（不询问） + * + * 设置了该属性的技能，可加入到配置选项中，自己设置是否自动发动（即该技能非必发技能） + * + * 若该属性值是“check”，则调用当前技能得check方法检测 + */ + frequent?: boolean | string | TwoParmFun; + /** + * 此技能是否可以被设置为自动发动2 + * + * 可以细分当前技能强制发动选项，（应该是为了细分子技能），保存到lib.config.autoskilllist， + * + * 在ui.click.autoskill2中执行, + * + * 取值为子技能的名字（注：目前，看来，只是在UI上作用，自动发动，更多是依赖frequent参数） + */ + subfrequent?: string[]; + /** + * 自动延迟的时间 + * + * 可以影响技能触发响应时间（主要影响loop之间的时间,即game.delayx的调用情况） + */ + autodelay?: boolean | number | TwoParmFun; + /** 第一时刻执行？（将发动顺序前置到列表前） */ + firstDo?: boolean; + /** 最后一刻做？（将发动顺序置于列表后方） */ + lastDo?: boolean; + + /** + * 此技能是否能固定触发（即自动发动）。 + * + * true为固定触发（可视为一种锁定技的，锁定技实质是mod里的技能） + * 国战可以触发亮将。 + * + * 【核心】作为game.check检测用的标准属性之一，在满足条件下强制执行。 + */ + forced?: boolean; + /** + * 死亡后是否可以发动技能 + */ + forceDie?: boolean; + /** + * 是否触发可以弹出选择技能的发动 + * + * 用于在arrangeTrigger过滤出多个同时机的触发技能时，在createTrigger中，询问玩家的技能发动， + * + * 若为false，不会加入询问触发的技能列表上（只有设置false才会）; + * + * 若为字符串，则在createTrigger【step 3】触发技能时，使用player.popup弹出该提示文本； + */ + popup?: boolean | string; + /** + * player是否logSkill('此技能'). + * + * 设置true，则不弹出提示 + * + * 注：logSkill 则是在玩家确定要使用卡牌的情况下 弹出发动的技能（马里奥大佬的解释，到时看下） + * true为不 + */ + nopop?: boolean; + /** + * 取消触发后的处理 + * + * 在createTrigger中step 3处理 + * + * @param trigger + * @param player + */ + oncancel?(trigger: GameEventPromise, player: Player): void; + + //触发内容基本触发流程 + /** + * 在content之前执行 + * + * 在chooseToUse，step2中执行： + * 其执行时机和chooseButton一致，当chooseButton不存在时且game.online为false，则会执行这个 + * @param config + */ + precontent?: ContentFuncByAll; + /** + * 在content之前触发内容 + * + * 在useSkill中使用，主动触发技能content之前 + */ + contentBefore?: ContentFuncByAll; + /** + * 触发内容（技能内容） + * + * 作为被动触发技能： + * 在createTrigger，step3中创建当前技能的事件，设置该content为事件content作为触发内容； + * + * 作为主动触发技能： + * 在useSkill中创建当前技能的事件 + * 分步执行(通过step x分割开执行逻辑步骤) + * + * 注：此时的content，已经为触发该技能的效果而创建的，该技能执行中的事件，此时的event一般是不具备 + * 触发信息，触发的信息，主要在trigger触发事件中获取。 + */ + content?: ContentFuncByAll; + /** + * 在content之后触发内容 + * + * 在useSkill中使用，主动触发技能content之后 + */ + contentAfter?: ContentFuncByAll; + + //技能初始化与移除： + /** + * 获得技能时发动，初始化技能 + * + * 技能的话，则在addSkillTrigger，若第三个参数triggeronly取值为true，只设置触发，不初始化该技能； + * + * 正常在addSkill处理，this.addSkillTrigger(skill)，使用此初始化； + */ + init?(player: Player, skill: string): void; + /** + * 添加技能时，初始化技能信息 + * + * 在addSkill中调用，每次添加都会执行 + */ + init2?(player: Player, skill: string): void; + /** 在执行player.disableSkill丧失技能时，若该属性为true，则执行技能的onremove */ + ondisable?: boolean; + /** + * 失去技能时发动 + * 当值为string时: + * + * 若为“storage”，删除player.storage中该技能的缓存（用于保存标记等信息）； + * 注：失去这个技能时销毁标记。 + * + * 若为“discard”，若player.storage[skill]缓存的是卡牌时，执行game.cardsDiscard，并播放丢牌动画，然后移除player.storage[skill]； + * + * 若为“lose”，和“discard”差不多，不过不播丢牌动画； + * + * 当值为true时，直接移除player.storage[skill]； + * + * 当值为字符串集合时，则是删除集合中对应player.storage（即删除多个指定storage） + * + * 注：当前disableSkill中，若当前info.ondisable，调用onremove必须是方法，且不注入skill参数； + */ + onremove?: TwoParmFun | string | string[] | boolean; + /** 是否持续的附加技能，在removeSkill中使用 */ + keepSkill?: boolean; + + + //以下3个属性基本功能时一致：在某些模式下是否能使用，只使用一个就差不多 + /** + * 指定该技能在哪些模式下禁用 + * + * 注：在指定模式被禁用的技能，会被设置成空对象，并且“技能_info”的描述变成“此模式下不可用”。 + */ + forbid?: string[]; + /** 与forbid相反，只能在指定玩法模式下才能被使用，其他逻辑一致 */ + mode?: string[]; + /** 当前模式下是否能使用，返回false则不能使用，其实和forbid逻辑一致 */ + available?(mode: string): boolean; + + + //技能相关设置： + /** + * 技能组： + * + * 拥有这个技能时相当于拥有技能组内的技能 + * + * 注：一些特殊技能标签： + * + * “undist”：不计入距离的计算且不能使用牌且不是牌的合法目标 + * + * （被隔离玩家，目前确定的作用：player.getNext获取下一位玩家，player.getPrevious确定上一位玩家，player.distance计算玩家距离）； + */ + group?: string | string[]; + /** + * 子技能： + * + * 你不会拥有写在这里面的技能，可以调用，可以用技能组联系起来; + * + * 子技能名字：“主技能_子技能”，翻译为主技能翻译 + * + * 注：子技能，会被视为“技能_子技能”独立保存起来。 + */ + subSkill?: SMap; + /** + * 全局技能?: + * + * 你拥有此技能时，所有角色拥有此技能（global的值为技能名） + * + * 注：无论是否拥有此技能，此技能都为全局技能写法：技能名前 + _ + */ + global?: string | string[]; + /** + * 在game.addGlobalSkill中使用： + * + * 强行设置global技能； + */ + globalSilent?: boolean; + + //技能相关设置=>功能设置 + /** + * 每回合限制使用次数 + * + * （若限制使用次数为变量时需写在filter内，即通过filter与变量动态判断） + * + * 主要在createTrigger，step3中触发计数。 + * + * 触发计数，会在玩家身上添加“counttrigger”技能，计数记录在：player.storage.counttrigger[当前技能名] + */ + usable?: number; + /** + * 每一轮的使用次数 + * + * 设置了该属性，会创建一个“技能名_roundcount”技能，将其加入group（技能组）中； + * + * 该技能的触发阶段“roundStart”（一轮的开始），用于记录当前技能的在一轮中使用的次数 + */ + round?: number; + /** 用于“技能名_roundcount”技能中，当前技能不可使用时，“n轮后”xxx，中xxx的部分显示（即后面部分） */ + roundtext?: string; + /** 增加显示的信息，这部分时增加，“n轮后”前面部分 */ + addintro?(storage: SMap, player: Player): string; + /** 延迟的时间 */ + delay?: number; + /** + * 锁定技 + * + * 若取值false，则get.is.locked，直接返回就false了； + * + * （锁定技的判定：1.info.trigger&&info.forced；2.info.mod；3.info.locked） + * + * 是否可以被“封印”（内置技能“fengyin”）的技能，取值为false时，get.is.locked返回为false；true则正常逻辑 + */ + locked?: boolean; + /** 是否是旧版技能，值为true，添加到lib.config.vintageSkills中，可以实现新/旧版技能切换，如果该为true，则“原翻译名_alter”即作为当前的翻译 */ + alter?: boolean; + + + //锁定技 + /** + * mod技能的设置 + * + * 如果有，技能视为锁定技 + * */ + mod?: Mod; + + //【重点】标记的key需要和技能名一致，游戏内都是通过对应skill取得对应的标记key，即player.storage[skill] + //限定技与觉醒技与技能标记 + /* + 关于限定技规范： + 一般情况下，需要在filter中，可加入!player.storage.xxx==true判定， + 在发动后，content内设置player.storage.xxx=true，代表已经触发了； + 目前，可以采用另一种简洁的方法，即觉醒技方法： + player.awakenSkill("xxx"); + 这样就会屏蔽发动过的技能，不会发动第二次； + */ + + /** + * 限定技（标记） + * + * 该标记为true时，若没有设置以下内容，则会自动设置： + * + * mark设置为true； + * + * intro.content设置为“limited”； + * + * skillAnimation设置为true； + * + * init设置为初始化玩家缓存的该技能名标记为false； + */ + limited?: boolean; + /** + * 是否开启觉醒动画 + * + * 准备来说，常用于觉醒动画，实际是指技能动画 + * + * 字符串时取值：epic，legend + */ + skillAnimation?: boolean | string; + /** 是否只显示文字特效 */ + textAnimation?: boolean; + /** 动画文字(可用于觉醒文字) */ + animationStr?: string; + /** 动画文字颜色(觉醒文字颜色) */ + animationColor?: string; + /** + * 觉醒技标记： + * + * (目前来看，这个目前单纯是技能标记，在主逻辑上并没使用，但貌似会被某些技能本身用到，或者类似左慈判断不能获得的技能的) + */ + juexingji?: boolean; + /** + * 获得技能时是否显示此标记， + * + * 若为false，可以用 markSkill 来显示此标记， + * + * 可以用 unmarkSkill 不显示标记 + * + * mark的常量值："card","cards","image","character"，表示，标记显示的特殊形式（UI上） + * + * 注：character，只能在表示一个角色时使用，标记以角色牌形式显示； + * + * 注：取值“auto”，在updateMark时，有计数时，执行unmarkSkill(?????) + */ + mark?: boolean | string; + /** 标记显示文本，一般为一个字 */ + marktext?: string; + /** 标记显示内容 */ + intro?: { + /** 自定义mark弹窗的显示内容 */ + mark?: ThreeParmFun; + /** 用于info.mark为“character”，添加，移除标记时，log显示的标记名（好像意义不大） */ + name?: string | TwoParmFun; + /** + * 标记显示内容？ + * 为cards时显示标记内的牌. + * + * 当标记显示内容是文本: + * + * "mark":有（数）个标记； + * + * "card":一张牌； + * + * "cards":多张牌； + * + * "limited":限定技，觉醒技专用；(若没设置，在info.limited为true下回默认设置这个) + * + * "time":剩余发动次数； + * + * "turn":剩余回合数； + * + * "cardCount":牌数； + * + * "info":技能描述； + * + * "character":武将牌； + * + * "player":一个玩家； + * + * "players":多个玩家； + * + * 可以只是一个描述文本； + * + * 在get.storageintro 中使用,以上，即为该方法的type，返回标记的描述内容 + * + * 若info.mark为“character”，则一般为一个描述文本； + * + * 注:info.mark为true时，也可以使用文本描述，比较自由（按道理都可以，不过默认搭配而已）； + * + * 其中，文本可使用以下占位符： + * + * "#"：(this.storage[skill])获取对应的计数, + * + * "&"：get.cnNumber(this.storage[skill])获取对应的计数(需要使用到get.cnNumber来获取的数量), + * + * "$"：get.translation(this.storage[skill])获取对应描述(一般是描述的角色名) + * + * 也可以是个自定义的方法 + */ + content?: string | ThreeParmFun; + /** + * 标记数 + * + * 主要在player.updateMark时使用，实际顶替this.storage[i+'_markcount']获取标记数 + */ + markcount?: number | TwoParmFun | string; + /** 是否不启用技能标记计数 */ + nocount?: boolean; + /** + * 移除该标记时，在unmarkSkill执行 + * + * 若值为字符串“throw”，该玩家缓存中该技能标记的为牌时，播放丢牌动画； + * + * 若是方法，则直接使用该回调方法处理。 + * + * 注：该参数原本只在把整个标记移除时执行，后续可能自己扩展； + */ + onunmark?: TwoParmFun | string; + // id?:string; //id名字需带“subplayer”，用于特殊模式显示信息用 + }; + + //主公技 + /** + * 是否为主公技： + * + * true时，将这个技能设置为主公技 + * + * (目前来看，这个目前单纯是技能标记，在主逻辑上并没使用，但貌似会被某些技能本身用到) + */ + zhuSkill?: boolean; + + //主动技能（主动使用技能，包含技能使用的相关操作配置） + /** + * 可使用的阶段 + * + * 一般用于主动技能 + * + * 注：从这个info.enable==event.name看出，其实和trigger差不多，所有事件的发动都会阶段时点； + * + * 即，当前执行的事件，触发game.check，时，检测触发的技能的event.name，即是info.enable; + * + * 常用的阶段： + * + * phaseUse：出牌阶段使用； + * + * chooseToRespond：用以响应； + * + * chooseToUse：常用于“濒死使用”/打出使用 + */ + enable?: string | string[] | OneParmFun; + /** + * 是否显示弹出该技能使用卡牌的文字 + * + * useCard中使用， + * + * 若为true的话，则执行player.popup + * + * 例如：player.popup({使用卡牌名name，使用卡牌nature}，'metal') + */ + popname?: boolean; + + //视为技（转换卡牌的技能） + /** + * (视为)目标卡牌 + * + * 一般用于视为技能 + * + * 【v1.9.102】扩展：可以使用函数式viewAs，目前核心支持使用地方：backup,ok; + */ + viewAs?: string | CardBaseUIData | TwoParmFun; + /** + * 视为技按钮出现条件（即发动条件） + * @param player + */ + viewAsFilter?(player: Player): boolean | void; + /** + * 使用视为牌时触发内容。 + * + * result.cards是视为前的牌 + * + * 注：实际是useResult，若当前处理的是技能，则先触发这个，后面再更具具体情况执行useCard,useSkill; + * + * 一般是用于视为技作为，效果处理，作为其他处理，会显得多余，算是视为技的扩展操作 + * + * @param result + * @param player + */ + onuse?(result: BaseCommonResultData, player: Player): void; + /** + * 选择按钮（牌） + * + * 常用于视为技需要实现复杂的功能选项时使用； + * + * 当前使用范围： + * + * chooseToUse + * + * chooseToRespond + */ + chooseButton?: ChooseButtonConfigData; + /** + * 源技能 + * + * (该属性应该是动态生成的,用于记录执行backup的技能名，即执行backup的视为技能，实质是执行本技能) + * + * 在chooseToUse，step1中使用，若有，将器添加到event._aiexclude中； + * + * + * 目前来看，该字段不是配置进去的，而是chooseToUse，step3中，执行chooseButton的backup方法， + * + * 返回一个新的“视为”技能：“技能名_backup”，并设置到lib.skill中， + * + * 并且将技能名作为该技能的源技能设置到这个新技能的sourceSkill中。 + */ + sourceSkill?: string; + + + //具体功能的处理 + //弃牌，失去牌(默认不设置discard，lose，则直接player.discard弃置选择的牌) + //discard，lose其中一个false，都会为非视为技走lose事件失去卡牌，且提供丰富的参数设置； + /** + * 是否弃牌 + * + * 在useSkill中调用， + * + * 选择牌发动技能后，被选择的牌都要弃置 + * + * 取值false（因为undefined != false结果为true，故默认不填和true效果一致） + */ + discard?: boolean; + /** + * 是否失去牌（是否调用player.lose） + * + * 与discard调用时机一致，都在useSkill中， + * 取值为false + */ + lose?: boolean; + /** + * 不弃牌，准备用这些牌来干什么（用于播放动画） + * + * 其字符串枚举有： + * + * give，give2，throw，throw2 + * + * 若不是字符串，则执行该方法 + */ + prepare?: string | ThreeParmFun; + /** 在lose事件中使用，触发执行“lose_卡牌名”事件的content */ + onLose?: ContentFunc | ContentFunc[]; + /** + * 在lose事件中使用，必须要失去的卡牌为“equips”（装备牌），有onLose才生效。 + * 若符合以上条件，则检测该牌是否需要后续触发执行“lose_卡牌名”事件，既上面配置的onLose + */ + filterLose?: TwoParmFun; + /** 在lose事件中使用，取值为true，作用貌似强制延迟弃牌动画处理 */ + loseDelay?: boolean; + + /** + * 是否触发lose失去牌阶段 + * + * 取值false； + * + * 若为false，则跳过该触发 + * + * 适合lose绑定一起使用，为false时，设置丢失牌事件_triggered为null + */ + //新版本出牌阶段主动技的新参数（均仅在discard为false且lose不为false时有效），且losetrigger不为false， + //是默认情况下：执行player.lose(cards,ui.special)，以下为 + losetrigger?: boolean; + /** 让角色失去卡牌的过程中强制视为正面朝上失去(losetrigger不为false时，既默认情况下生效) */ + visible?: boolean; + /** + * 指定失去特殊区卡牌的去向 (即设置卡牌的position) + * + * 其值采用的是ui的成员，即通过ui[info.loseTo]，获取实体对象设置； + * + * 默认为："special", + * + * 取值："special","discardPile","cardPile","ordering"，"control"(这一般都不会用上,好像没看见) + */ + loseTo?: string; + /** + * 需要失去的牌的区域ui.special(默认情况是这个，受loseTo影响)， + * + * 设置lose事件的toStorage为true，失去的牌到牌记录到自己的storage中； + */ + toStorage?: boolean; + /** + * 用于将失去的牌置于某个区域的顶端（而非默认的顶端）；【v1.9.108.6】 + */ + insert?: boolean; + + /** + * 技能响应前处理(非联机时，不在线时处理，估计时用于自动响应) + * + * 在chooseToRespond中使用 + */ + prerespond?(result, player: Player): void; + /** + * 技能响应(可直接使用技能来响应，在这里进行响应的处理) + * + * 在respond中使用 + */ + onrespond?(event: GameEventPromise, player: Player): void; + /** + * 过滤发动条件，返回true则可以发动此技能 + * + * 主要在filterTrigger,game.check中处理,返回false则不处理（可以不设置该配置，相当于默认true结果） + * + * 注： + * + * 1.主动触发：一般走的是game.check,其filter,传入的event指的是当前game.check处理的事件； + * + * 2.被动触发：一般走的是lib.filter.filterTrigger,其filter,传入的event指的是当前的触发事件，其中还会把触发事件名传入第三个参数； + * @param event 事件，即event._trigger,相当于trigger时机（此时的event为触发该技能时机时的事件） + * @param player + * @param name 触发名，为event.triggername，目前只有在lib.filter.filterTrigger中才传该值，即被动触发，主动触发不检测该值，目前暂未完善 + */ + filter?(event: GameEventPromise, player: Player, name?: string): boolean | void; + /** + * 选择的目标武将牌上出现什么字。 + * + * 使用地方：ui.click.target/player，.... + * + * 如果是数组第几元素对应第几个目标； + * + * 如果是方法，则直接根据入参target，判断返回的文本； + * + * 例子： + * targetprompt:['出杀','出闪'],依次就是你点击第一个角色后在其旁边显示出杀，第二个角色显示出闪 + */ + targetprompt?: string | string[] | OneParmFun; + /** + * 是否每个目标都结算一次(多个目标) + * + * true为可选择多名目标 + */ + multitarget?: boolean | number; + /** + * 指向线的颜色枚举： + * fire（橙红色FF9244），thunder（浅蓝色8DD8FF），green（青色8DFFD8）， + */ + line?: string | { color: number[] }; + /** 是否显示多条指引线 */ + multiline?: boolean; + + /** + * 选中该技能使用时,进行处理 + * + * 在chooseToUse 的content中调用， + * + * 目前参考的例子中，大多数多是用于添加一些牌到待选择到event.set(key，收集的牌)中， + * + * 用于使用前先选牌的效果 + * + * 注：其调用时机应该远早于触发技能的，在选中牌时就开始处理。 + * @param event + */ + onChooseToUse?(event: GameEventPromise): void; + + /** + * 改变拼点用的牌 + * + * 在chooseToCompare和chooseToCompareMultiple，step2中使用，返回玩家用于的拼点的牌 + * @param player + */ + onCompare?(player: Player): Card[]; + + /** + * 在chooseToRespond时使用，会前置执行当前chooseToRespond事件player所有的技能该接口； + * + * 应该时用于chooseToRespond事件时，技能进行一些初始化处理（暂无使用实例） + * 【v1.9.106】 + * @param event + */ + onChooseToRespond?(event: GameEventPromise): void; + + //核心 + //event.bakcup设置的信息，game.check使用到的一些参数，其实就是把game.check需要的一些参数设置到技能中，作为check时的条件 + // 追加：这个主要用于game.check检测中，取代当前事件的条件；若没有主动申请检测，则其实用不上； + // 在表现上，主要用于：主动技，视为技 + /* 这些就是作为前提条件的主要属性 + filterButton + selectButton + filterTarget + selectTarget + filterCard + selectCard + position + forced + complexSelect?:boolean; + complexCard?:boolean; + complexTarget + ai1 + ai2 + */ + //目标 + /** + * 需要选择多少张牌才能发动 + * + * 选择的牌数 + * + * -1时，选择所有牌,否则就是指定数量的牌 + * + * 数组时，这个数组就是选择牌数的区间,其中任意（至少一张）：[1,Infinity] + * + * 为变量时（具体情况具体分析），例：()=>number + */ + selectCard?: number | Select | NoneParmFum; + /** + * 需要选择多少个目标才能发动 + * + * 选择的目标数： + * + * 为-1时，选择全部人 + * + * 为数组时，这个数组就是选择目标数的区间 + */ + selectTarget?: number | Select | NoneParmFum; + /** + * 选择的牌需要满足的条件 + * + * 可以使用键值对的简便写法 + * + * 也可以使用函数返回值（推荐） + * + * 都是通过get.filter处理成事件的filterCard的方法； + * + * 直接填true，则有些地方，会优先触发过滤可使用的卡牌，例如ui.click.skill,ai.basic.chooseCard + * + * 注：game.check时，如果当前时viewAs“视为技”，则其过滤技能时filterCard,作为方法，多入参一个event参数，需要时可以使用； + * （一般没有） + */ + filterCard?: boolean | CardBaseUIData | TwoParmFun | boolean; + /** + * 是否使用mod检测 + * + * 取值true; + * + * 在event.backup使用， + * + * 当info.viewAs有值的时候（即该技能为视为技）， + * + * 若没有设置filterCard，默认设置一个filterCard： + * 可以优先使用“cardEnabled2”的mod检测卡牌是否可使用； + * + * + * 已找不到，可能就是改成cardEnabled2 + * + * 则若当前事件为”chooseToUse“（选择卡牌使用）,使用”cardEnabled“卡牌是否能使用mod检测； + * + * 则若当前事件为”chooseToRespond“（选择卡牌响应），使用”cardRespondable“卡牌是否能响应mod检测； + */ + ignoreMod?: boolean; + /** + * 选择的目标需要满足的条件 + * @param card + * @param player + * @param target + */ + filterTarget?(card: Card, player: Player, target: Player): boolean; + /** + * 指定位置： + * 'h'：手牌区, 'e'：装备区, 'j'：判定区 + */ + position?: string; + /** + * 选择时弹出的提示 + * + * 单参数的方法，主要用再技能点击使用时的提示； + * + * 注：即触发技能/主动发动技能的提示描述信息； + */ + prompt?: string | TwoParmFun; + //| TwoParmFun | TwoParmFun //好像没见到用 + /** + * 二次提示 + * + * 主要在createTrigger，step1中，设置event.prompt2 + * + * 若是boolean类型，则取值false,不显示prompt2，默认使用lib.translate[“技能名_info”]的描述 + * + * 注：即发动技能时，prompt提示下的提示（默认显示技能描述）； + */ + prompt2?: string | TwoParmFun | boolean; + /** + * 在ui.click.skill中使用，若当前event.skillDialog不存在，可以用该方法生成的文本的dialog作为skillDialog； + * + * 若没有该方法，可以使用翻译中该技能的info信息代替。 + */ + promptfunc?: TwoParmFun; + /** 表示这次描述非常长(涉及用了h5文本)，设置为true，重新执行ui.update()，设置skillDialog.forcebutton为true */ + longprompt?: boolean; + + //补充game.check相关参数的声明： + /** 过滤不可选择按钮 */ + filterButton?(button: Button, player: Player): boolean; + /** 按钮的可选数量，大多数情况下，默认1 */ + selectButton?: number | Select | NoneParmFum; + complexSelect?: boolean; + /** 复合选牌：即每选完一次牌后，都会重新下一次对所有牌的过滤 */ + complexCard?: boolean; + complexTarget?: boolean; + + /** 一般作为chooseCard相关ai */ + ai1?: Function; + /** 一般作为chooseTarget相关ai */ + ai2?: Function; + + /** + * 是否检测隐藏的卡牌 + * + * 使用范围：player.hasUsableCard，player.hasWuxie + * + * 常用：让系统知道玩家“有无懈”； + * + * 例子：可以参考“muniu”（木牛流马） + * @param player + * @param name + */ + hiddenCard?(player: Player, name: string): boolean; + + /** 录像相关，game.videoContent.skill中相关 */ + video?(player: Player, data: string | any[]): void; + + process?(player: Player): void; + + //在skillDisabled中，根据以下5个属性，检测技能是否是不能使用（若其中有一个时true都排除掉），在chooseSkill,选择获得技能时筛选列表 + //在getStockSkills中，有前3个标签属性的技能也是无法获取的 + /** + * 唯一 + * + * 在skillintro中使用（左慈不能化身） + * + * 注：该技能是否为特殊技能，即左慈化身能否获取等等，常与部分锁定技、主公技、觉醒技连用 + */ + unique?: boolean; + /** 临时技能，在die死亡时，会被移除 */ + temp?: boolean; + /** 子技能标签，在subSkill的技能中，会默认标记该属性为true */ + sub?: boolean; + /** 固有技，不能被removeSkill移除 */ + fixed?: boolean; + /** 一次性技能，在resetSkills时，直接移除该技能 */ + vanish?: boolean; + + /** + * 武将特有固有技能 + * + * 从逻辑上来看，比固定技优先级还高，不会受“fengyin”，“baiban”等技能移除； + * + * 在clearSkills时，如果不是“删除所有的all为true”的情况下，不会被移除； + * + * 不会被，“化身”之类的技能获得，删除； + */ + charlotte?: boolean; + /** 在clearSkills中使用,标记此标记，永远不会被该方法删除，该标记独立使用，一般其他方法没有对其进行处理 */ + superCharlotte?: boolean; + /** 作用不明，并没有什么用，与ui相关，在skillintro中使用,值为true */ + gainable?: boolean; + /** 在nodeintro中使用，添加classname:thundertext,值为true */ + thundertext?: boolean; + + //在nodeintro中使用的（这几个配置都没什么意义） + /** 设置nodeintro的点击事件 */ + clickable?(player: Player): void; + /** 过滤点击，应该是过滤弹出面板是否能点击，具体作用日后细究 */ + clickableFilter?(player: Player): boolean; + /** 技能名不带【】括号 */ + nobracket?: boolean; + + //日志相关： + /** 是否在历史日志中显示，取值未false不显示 */ + logv?: boolean; + /** + * 显示场上日志中显示 + * + * 在useSkill时，若值为“notarget”，则不显示出对所有“对...”目标相关描述的日志; + * + * 在useCard时，若该设置未false，则不执行player.logSkill; + */ + log?: boolean | string; + /** + * 目标日志 + * + * 若是字符串，则配置一个当前处理的trigger事件的一个玩家元素，例如"player","source","target"...； + * + * 若是方法，则配置一个方法直接返回文本,或者玩家 + * + * 若没有配置prompt，显示该配置的提示 + */ + logTarget?: string | TwoParmFun; + /** + * 是否通过logTarget显示触发者的目标日志； + * + * 目的：应该是为了细节化显示日志；在createTrigger，step3中使用，取值false，不使用logTarget，显示logSkill; + */ + logLine?: boolean; + + //技能的信息显示： + /** + * 内容描述 + * + * 在addCard时，设置“技能名_info”的翻译；（addCard很少使用） + * + * 若时subSkill子技能，则设置“技能名_子技能名_info”的翻译；(主要适用于子技能描述) + * + * 该技能的描述（自定义，非子技能时和game逻辑无关,用于自己的解析逻辑） + */ + description?: string; + /** 该技能的描述（自定义，和game逻辑无关,用于自己的解析逻辑） */ + // infoDescription?:string; + /** + * 来源： + * + * 若该来源技能不存在，则当前技能会被移除； + */ + derivation?: string[] | string; + + /** + * 强制加载该card配置， + * 例如，一些原本不用于contect模式得卡，设置该值可强制加载该card + */ + forceLoad?: boolean; + + //AI相关 + /** ai的详细配置 */ + ai?: SkillAI; + + /** + * ai用于检测的方法： + * + * 第一个参数好想有些不一样：event，card,子技能button； + * + * 基本ai.basic使用的check方法(既涉及choose系列时用的ai自动选择)： + * + * 1）ai如何选牌： + * + * 在ai.basic.chooseCard中使用； + * + * 2）ai如何选按钮： + * + * 在ai.basic.chooseButton中使用； + * + * 3）ai如何选玩家： + * + * 在ai.basic.chooseTarget中使用； + * + * 注：其实这些应该都有两个参数的，既第二个参数其实当前所有选中的的数据； + * + * 有时甚至不传参，所以遇到保存，做好健壮性屏蔽； + * + * 特殊作用： + * + * 在触发createTrigger中使用,参数：trigger事件，player玩家； + * + * 1）在技能过滤触发时作为过滤条件（当前技能info.frequent=='check'）： + * + * 2）告诉ai是否发动这个技能：返回true则发动此技能，即作为createTrigger过程中，设置ai如何chooseBool这个技能； + * + * 例： + * + * a.触发技判断敌友，大于0为选择队友发动，若<=0是对敌方发动:return get.attitude(player,event.player)>0; + * + * b.选取价值小于8的牌：return 8-get.value(card); 数字越大，会选用的牌范围越广，8以上甚至会选用桃发动技能，一般为6-ai.get.value(card); + * + * 注： + * + * 两个参数，用于事件触发技能：event:GameEvent,player:Player； + * + * 一个参数，用于主动使用触发技能：card:Card； + * + * 无参，简洁写法； + */ + check?: OneParmFun | TwoParmFun | NoneParmFum; + // check?(...any:any):number|boolean; + // /** ai用于检测的方法：用于主动使用触发技能 */ + // check?(card:Card):number|boolean; + // /** ai用于检测的方法：用于事件触发技能 */ + // check?(event:GameEventPromise,player:Player):number|boolean; + // check?():number|boolean; + // check?:OneParmFun | OneParmFun | OneParmFun | TwoParmFun; + + //event.addTrigger,默认对于技能优先度的标记：rule; + /** + * 发动技能是身份暴露度（0~1，相当于概率） + * 取值范围为0~1,用于帮助AI判断身份,AI中未写expose其他AI将会无法判断其身份 + */ + expose?: number; + /** + * 嘲讽值： + * 嘲讽值越大的角色越容易遭受到敌方的攻击,默认为1,一般在0~4中取值即可(缔盟threaten值为3) + */ + threaten?: number | TwoParmFun; + /** + * 态度： + * 态度只由identity决定。不同身份对不同身份的att不同。 + * 例如：在身份局中,主对忠att值为6,忠对主att值为10; + * 注：配置不配该值； + */ + // attitude?: number; + + /** + * 效果： + * 影响ai出牌（例如什么时候不出杀）等 + * 效果值为正代表正效果,反之为负效果,AI会倾向于最大效果的目标/卡牌; + * + * 告诉ai有某技能时某牌的使用效果发生改变。 + * + * ai里面的effect是上帝视角,target不代表目标角色,player也不代表拥有此技能的玩家本身, + 因为effect是写给别的AI看的,所以target代表玩家本身,player代表其他人,可以是正在犹豫是否要杀你的任何一位玩家。 + + * 注：若不是个对象，可以直接是一个target(一种简写形式，不收录了) + * + * 应用： + * 〖主动技〗 + 如果技能发动无须指定目标: effect=result*ai.get.attitude(player,player); + 如果技能发动须指定目标 总效果=对使用者的收益值 * 使用者对自己的att+对目标的收益值 * 使用者对目标的att; 实际还会考虑嘲讽值,这里简化了; + 〖卖血技〗 + 总效果=对使用者的收益值 * 使用者对自己的att+对目标的收益值 * 使用者对目标的att; 实际还会考虑嘲讽值,这里简化了; + + 设对目标的原收益为n,对使用者的原收益为n',n>0代表正收益,n<0代表负收益; + 函数传入4个参数,分别为卡牌、使用者、目标以及n; + 返回值可有3种形式 + 1. 一个数a,对目标总的收益为a*n; + 2. 一个长度为2的数组[a,b],对目标的总收益为a*n+b; + 3. 一个长度为4的数组[a,b,c,d],对目标的总收益为a*n+b,对使用者的总收益为c*n'+d; + 假设n代表火杀对目标的效果 + 1. 技能为防止火焰伤害：return 0; + 2. 技能为防止火焰伤害并令目标摸一张牌：return [0,1]; + 3. 技能为防止火焰伤害并令使用者弃置一张牌：return [0,0,1,-1]; + + 〖倾向技〗 + 对确定的意向，反应准确的收益 + + 【收益论的检验】示例： + content:function(){ + game.log(player,'对',target,'的att是',ai.get.attitude(player,target)); + game.log(player,'对',player,'的att是',ai.get.attitude(player,player)); + game.log(player,'对',target,'发动【测试】的eff是',ai.get.effect(target,'测试',player,player)); + game.log(player,'对',target,'使用【杀】的eff是',ai.get.effect(target,{name:'sha'},player,player)); + }, + + 永远的萌新大佬的示例： + effect的返回值： + effect有3种可能的返回值,1个数字，长度为2的数组，长度为4的数组。 + 1个数字n:收益*n + 长度为2的数组[a,b]:a*收益+b + 长度为4的数组[a,b,c,d]:对目标为a*收益+b，对使用者为c*收益+d + *注意 zeroplayertarget 实际上是[0,0,0,0] zerotarget 实际上是[0,0 + "下面以target:function(){},别人对你使用杀为例，括号里为可能的技能描述" + return -1;//负影响(杀对你造成伤害时改为等量回复) + return 0;//无影响(杀对你无效) + return 2;//2倍影响(杀对你的伤害翻倍) + return 0.5;//一半影响(杀对你的伤害减半) + return [1,1];//正常影响+1(成为杀的目标摸一张牌) + return [1,-1];//正常影响-1(成为杀的目标弃一张牌) + return [0,1];//无影响+1(杀对你造成伤害时改为摸一张牌); + return [0,-1];//无影响-1(杀对你造成伤害时改为弃一张牌) + return [1,0,0,-1];//对你正常影响，对使用者无影响-1(刚烈) + return [1,1,1,1];//对双方正常影响+1(你成为杀的目标时你和使用者各摸一张牌) + */ + effect?: { + /** + * 牌对你的影响（你使用牌/技能对目标的影响） + * + * 返回结果的字符串："zeroplayer","zerotarget","zeroplayertarget",指定最终结果的:对使用者的收益值,对目标的收益值为0 + * @param result1 即当前ai.result.player的结果 + */ + player?(card: Card, player: Player, target: Player, result1: number): string | number | number[] | void; + /** + * 一名角色以你为牌的目标时对你的影响（牌/技能对你的影响） + * + * 返回结果的字符串："zeroplayer","zerotarget","zeroplayertarget",指定最终结果的:对使用者的收益值,对目标的收益值为0 + * @param result2 即当前ai.result.target的结果 + */ + target?(card: Card, player: Player, target: Player, result2: number): string | number | number[] | void; + }; + /** + * 收益： + * 收益值未在AI声明默认为0(对玩家对目标均是如此)。 + * 一般用于主动技; + * 关于收益的算法，待会再详细描述 + * + * 在get.result中使用； + * + */ + result?: { + /** + * ai如何选择目标（对目标的收益）： + * 返回负，选敌人，返回正，选队友; + * 没有返回值则不选; + * 注：写了这个就不用写player(player){}了，因为player可以在这里进行判断......先继续研究好，再下定论； + */ + target?: ThreeParmFun | number; + /** + * 主要用于get.effect_use中，优先于上面的target； + */ + target_use?: ThreeParmFun | number; + /** + * ai是否发动此技能（对玩家（自身）的收益）： + * 返回正，发动，否则不发动; + * 注：最终 + */ + player?: ThreeParmFun | number; + /** + * 主要用于get.effect_use中，优先于上面的player； + */ + player_use?: ThreeParmFun | number; + + /** + * 取值为true时，不默认为“equip（装备）”卡牌，默认设置“card.ai.result.target”方法 + */ + keepAI?: boolean, + } + /** + * 技能标签的生效限制条件 + * + * 例：视为技中使用，ai什么时候可以发动视为技（决定某些技能标签的true/false） + * 在player.hasSkillTag,player.hasGlobalTag中使用 + */ + skillTagFilter?(player: Player, tag: string, arg: any): boolean | void; + + //------------------------------主要给卡牌使用的ai配置（也共享上面一些配置）-------------------------------- + //若武将使用以下配置，一般为该武将的“视为技”时使用，其配置对应“视为”的卡牌 + + //这些时在外的简写，一般详细处理，在basic内 + /** + * 回合外留牌的价值【一般用于卡牌的ai】 + * + * 大致的价值标准： + * tao [8,6.5,5,4]>shan [7,2]>wuxie [6,4]>sha,nanman [5,1]>wuzhong 4.5>shunshou,tiesuo 4 + * wugu,wanjian,juedou,guohe,jiedao,lebu,huogong,bingliang 1>shandian 0 + * 注：当value的结果为一个数组时，则标识当前card在手牌中位置，根据该牌所处位置，获得对应下标不同的value； + */ + useful?: number; + /** + * 牌的使用价值【一般用于卡牌的ai】 + * + * 数字越大，在一些ai会选用的牌范围越广，8以上甚至会选用桃发动技能，一般为6-ai.get.value(card); + * 大致的价值标准： + * wuzhong 9.2>shunshou 9>lebu 8>tao [8,6.5,5,4]>shan [7,2]>wuxie [6,4]>juedou 5.5>guohe,nanman,wanjian 5>sha [5,1] + * tiesuo,bingliang 4>huogong [3,1]>jiedao 2>taoyuan,shandian 0 + * 注：当value的结果为一个数组时，则标识当前card在手牌中位置，根据该牌所处位置，获得对应下标不同的value； + */ + value?: number | number[] | TwoParmFun; + /** 该装备的价值 */ + equipValue?: number | TwoParmFun; + /** 主要是使用在card的ai属性，武将技能可以无视 */ + basic?: { + /** 该装备的价值，同equipValue，优先使用equipValue，没有则ai.basic.equipValue */ + equipValue?: number | TwoParmFun; + /** 优先度 */ + order?: number | TwoParmFun; + /** 回合外留牌的价值(该牌可用价值),number为当前事件玩家的手牌的下标 */ + useful?: SAAType | TwoParmFun>; + /** 该牌的使用价值 */ + value?: SAAType | FourParmFun>; + + [key: string]: SAAType | string | Function; + }; + + //ai的tag【可用于标记卡牌的属性】 + //get.tag(卡牌,标签名) 检测是否有指定卡牌标签： + /** 主要是使用在card中，独立制定的一些标记来描述自身得一些特性,有则标记1，默认是没有（实质上用bool也行），可能有少许标记参与运算 */ + tag?: { + //比较常用：（以下为自己得理解） + /** 【响应杀】：即手上没有杀时，也有可能响应杀 */ + respondSha?: CardTagType; + /** 【响应闪】：即手上没有闪时，也有可能响应闪 */ + respondShan?: CardTagType; + /** 【不会受到伤害】 */ + damage?: CardTagType; + /** 【不受元素伤害】 */ + natureDamage?: CardTagType; + /** 【不受雷属性伤害】 */ + thunderDamage?: CardTagType; + /** 【不受冰属性伤害】【v1.9.107】 */ + iceDamage?: CardTagType; + /** 【不受火属性伤害】 */ + fireDamage?: CardTagType; + /** 【可以指定多个目标】 */ + multitarget?: CardTagType; + /** 【回复体力】 */ + recover?: CardTagType; + /** 【失去体力】 */ + loseHp?: CardTagType; + /** 【可获得牌】 */ + gain?: CardTagType; + /** 【可自救】 */ + save?: CardTagType; + /** 【可弃牌】，即弃牌可以有收益 */ + discard?: CardTagType; + /** 【失去牌】 */ + loseCard?: CardTagType; + /** 【多个目标结算时（？存疑）】 */ + multineg?: CardTagType; + /** 【可多次/再次判定/改变判定】 */ + rejudge?: CardTagType; + draw?: CardTagType; + norepeat?: CardTagType; + /** 【装备替换价值】 */ + valueswap?: CardTagType; + + [key: string]: CardTagType; + } + + /** + * 是否要对“连锁”状态下的目标处理； + * + * 新增，在get.effect中使用； + * @param player + * @param target + * @param card + */ + canLink?(player: Player, target: Player, card: Card): boolean; + + //日后还有很多属性要添加的 + [key: string]: any; +} + +/** 卡牌的tag的类型，注：作为方法的第二参数很少用上（一般用于二级类型判断） */ +type CardTagType = number | TwoParmFun | OneParmFun; \ No newline at end of file diff --git a/node_modules/noname-typings/index.d.ts b/node_modules/noname-typings/index.d.ts index 0fb50a1c1..404fc9e56 100644 --- a/node_modules/noname-typings/index.d.ts +++ b/node_modules/noname-typings/index.d.ts @@ -1,8 +1,11 @@ /// +/// /// /// /// /// +/// +/// /// /// /// diff --git a/node_modules/noname-typings/package.json b/node_modules/noname-typings/package.json index 9ee543937..db42e298b 100644 --- a/node_modules/noname-typings/package.json +++ b/node_modules/noname-typings/package.json @@ -1,6 +1,6 @@ { "name": "noname-typings", - "version": "2023.12.31", + "version": "2024.01.16", "description": "Noname typings, mainly for showing type hints when creating extensions of the Sanguosha-like game Noname.", "repository": { "type": "git", diff --git a/node_modules/noname-typings/type.d.ts b/node_modules/noname-typings/type.d.ts index 2ca05dbe7..2ef629b1f 100644 --- a/node_modules/noname-typings/type.d.ts +++ b/node_modules/noname-typings/type.d.ts @@ -17,15 +17,43 @@ interface NMap { [key: number]: V } -declare type Game = import('../../noname/game/index.js').Game; -declare type Library = import('../../noname/library/index.js').Library; +//从0个参数到任意参数的方法结构声明 +type NoneParmFum = () => T; +type OneParmFun = (arg0: U) => T; +type TwoParmFun = (arg0: U1, arg1: U2) => T; +type ThreeParmFun = (arg0: U1, arg1: U2, arg2: U3) => T; +type FourParmFun = (arg0: U1, arg1: U2, arg2: U3, arg3: U4) => T; +type RestParmFun = (...args) => T; +type RestParmFun2 = (...args: U[]) => T; + +//尝试增加的符合类型声明 +/** SingleAndArrayType:单体与集合类型 */ +type SAAType = T | T[]; +/** 再价格可以返回这种类型的方法 */ +type SAAFType = T | T[] | RestParmFun; +/** 有name属性的对象 */ +type NameType = { name: string }; +/** 技能或者卡牌 */ +type SkillOrCard = string | NameType | Card; +/** 卡牌或者卡牌集合 */ +type CCards = SAAType; + +/** 技能content */ +declare type ContentFuncByAll = { + // (event: GameEventPromise, step: number, source: Player, player: Player, target: Player, targets: Player[], card: Card, cards: Card[], skill: string, forced: boolean, num: number, trigger: GameEventPromise, result: Result): any, + (event: GameEventPromise, trigger: GameEventPromise, player: Player): Promise; +} + +declare type Game = typeof import('../../noname/game/index.js').Game; +declare type Library = typeof import('../../noname/library/index.js').Library; declare type Status = typeof import('../../noname/status/index.js').status; -declare type UI = import('../../noname/ui/index.js').UI; -declare type Get = import('../../noname/get/index.js').Get; -declare type AI = import('../../noname/ai/index.js').AI; +declare type UI = typeof import('../../noname/ui/index.js').UI; +declare type Get = typeof import('../../noname/get/index.js').Get; +declare type AI = typeof import('../../noname/ai/index.js').AI; declare type Button = import('../../noname/library/index.js').Button; declare type Card = import('../../noname/library/index.js').Card; +declare type VCard = import('../../noname/library/index.js').VCard; declare type Dialog = import('../../noname/library/index.js').Dialog; declare type GameEvent = import('../../noname/library/index.js').GameEvent; declare type GameEventPromise = import('../../noname/library/index.js').GameEventPromise; @@ -39,4 +67,5 @@ declare type GameHistory = import('../../noname/game/index.js').GameHistory; declare type CodeMirror = typeof import('../../game/codemirror.js').default; declare type Sex = 'male' | 'female' | 'dobule' | 'none'; -declare type Character = [Sex, string, number | string, string[], string[]]; \ No newline at end of file +declare type Character = [Sex, string, number | string, string[], string[]]; +declare type Select = [number, number]; \ No newline at end of file diff --git a/noname/get/index.js b/noname/get/index.js index f38faf096..ce80005ff 100644 --- a/noname/get/index.js +++ b/noname/get/index.js @@ -1961,8 +1961,8 @@ export class Get extends Uninstantable { } } /** - * @param { number | [number, number] | (()=>[number, number]) } [select] - * @returns { [number, number] } + * @param { number | Select | (()=>Select) } [select] + * @returns { Select } */ static select(select) { if (typeof select == 'function') return get.select(select()); diff --git a/noname/get/is.js b/noname/get/is.js index 7d8796e0a..a5dee8a87 100644 --- a/noname/get/is.js +++ b/noname/get/is.js @@ -332,7 +332,7 @@ export class Is extends Uninstantable { } return true; } - static altered() { return false; } + static altered(skillName) { return false; } /* skill=>{ return false; diff --git a/noname/library/element/gameEvent.js b/noname/library/element/gameEvent.js index d1ff882ac..182ae82f4 100644 --- a/noname/library/element/gameEvent.js +++ b/noname/library/element/gameEvent.js @@ -45,6 +45,10 @@ export class GameEvent { }; this._aiexclude = []; this._notrigger = []; + /** + * @type { Result } + */ + // @ts-ignore this._result = {}; this._set = []; /** @@ -862,6 +866,11 @@ export class GameEvent { */ // @ts-ignore this.excludeButton; + /** + * @type { Result } + */ + // @ts-ignore + this.result; throw new Error('Do not call this method'); } } diff --git a/noname/library/element/gameEventPromise.js b/noname/library/element/gameEventPromise.js index 568b09a65..3b650cf5c 100644 --- a/noname/library/element/gameEventPromise.js +++ b/noname/library/element/gameEventPromise.js @@ -16,7 +16,7 @@ import { AsyncFunction } from '../../util/index.js'; * 且Promise的原有属性无法被修改，一切对这个类实例的属性修改，删除， * 再配置等操作都会转发到事件对应的属性中。 * - * @todo 需要完成异步事件的debugger方法 + * @template { GameEvent } T * * @example * 使用await xx()等待异步事件执行： diff --git a/noname/library/index.js b/noname/library/index.js index 3d407ab8e..610601ca4 100644 --- a/noname/library/index.js +++ b/noname/library/index.js @@ -5,7 +5,7 @@ * @typedef { InstanceType } Button * @typedef { InstanceType } Dialog * @typedef { InstanceType } GameEvent - * @typedef { InstanceType & InstanceType & typeof Promise } GameEventPromise + * @typedef { InstanceType & InstanceType> } GameEventPromise * @typedef { InstanceType } NodeWS * @typedef { InstanceType } Control */ @@ -10198,6 +10198,19 @@ export class Library extends Uninstantable { return 0; } }; + /** + * @type {{ + * global: string[]; + * globalmap: SMap; + * storage: SMap; + * undist: SMap; + * thers: SMap; + * zhu: SMap; + * zhuSkill: SMap; + * land_used: SMap; + * [key: string]: Skill; + * }} + */ static skill = { stratagem_fury: { marktext: '🔥', diff --git a/noname/ui/index.js b/noname/ui/index.js index 074869987..9a63d9894 100644 --- a/noname/ui/index.js +++ b/noname/ui/index.js @@ -14134,6 +14134,14 @@ export class UI extends Uninstantable { * @type { Control | undefined } */ static skills3; + /** + * @type { HTMLDivElement } + */ + static window; + /** + * @type { HTMLDivElement } + */ + static pause; static refresh(node) { void window.getComputedStyle(node, null).getPropertyValue("opacity"); }