1825 lines
64 KiB
TypeScript
1825 lines
64 KiB
TypeScript
/** 时机 */
|
||
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<Player, string, Target[], void>;
|
||
}
|
||
|
||
/** 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;
|
||
canBeReplaced?(card: Card, source: Player, player: Player): 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 | GeneratorContentFuncByAll | OldContentFuncByAll;
|
||
|
||
//无懈相关：主要在_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 | boolean;
|
||
|
||
/** 对特定角色使用牌的次数限制（用于优化【对特定角色使用牌无次数限制】的机制）【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;
|
||
|
||
maxHandcardBase?(player: Player, num: number): number | 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<string>;
|
||
/** 强制播放音频 */
|
||
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<Trigger, Player, number | boolean>;
|
||
/**
|
||
* 此技能是否可以被设置为自动发动2
|
||
*
|
||
* 可以细分当前技能强制发动选项，（应该是为了细分子技能），保存到lib.config.autoskilllist，
|
||
*
|
||
* 在ui.click.autoskill2中执行,
|
||
*
|
||
* 取值为子技能的名字（注：目前，看来，只是在UI上作用，自动发动，更多是依赖frequent参数）
|
||
*/
|
||
subfrequent?: string[];
|
||
/**
|
||
* 自动延迟的时间
|
||
*
|
||
* 可以影响技能触发响应时间（主要影响loop之间的时间,即game.delayx的调用情况）
|
||
*/
|
||
autodelay?: boolean | number | TwoParmFun<Trigger, Player, number>;
|
||
/** 第一时刻执行？（将发动顺序前置到列表前） */
|
||
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 | GeneratorContentFuncByAll | OldContentFuncByAll;
|
||
/**
|
||
* 在content之前触发内容
|
||
*
|
||
* 在useSkill中使用，主动触发技能content之前
|
||
*/
|
||
contentBefore?: ContentFuncByAll | GeneratorContentFuncByAll | OldContentFuncByAll;
|
||
/**
|
||
* 触发内容（技能内容）
|
||
*
|
||
* 作为被动触发技能：
|
||
* 在createTrigger，step3中创建当前技能的事件，设置该content为事件content作为触发内容；
|
||
*
|
||
* 作为主动触发技能：
|
||
* 在useSkill中创建当前技能的事件
|
||
* 分步执行(通过step x分割开执行逻辑步骤)
|
||
*
|
||
* 注：此时的content，已经为触发该技能的效果而创建的，该技能执行中的事件，此时的event一般是不具备
|
||
* 触发信息，触发的信息，主要在trigger触发事件中获取。
|
||
*/
|
||
content?: ContentFuncByAll | GeneratorContentFuncByAll | OldContentFuncByAll;
|
||
/**
|
||
* 在content之后触发内容
|
||
*
|
||
* 在useSkill中使用，主动触发技能content之后
|
||
*/
|
||
contentAfter?: ContentFuncByAll | GeneratorContentFuncByAll | OldContentFuncByAll;
|
||
|
||
//技能初始化与移除：
|
||
/**
|
||
* 获得技能时发动，初始化技能
|
||
*
|
||
* 技能的话，则在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<Player, string, void> | 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<Skill>;
|
||
/**
|
||
* 全局技能?:
|
||
*
|
||
* 你拥有此技能时，所有角色拥有此技能（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<any>, player: Player): string;
|
||
/** 延迟的时间 */
|
||
delay?: number | boolean;
|
||
/**
|
||
* 锁定技
|
||
*
|
||
* 若取值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<Dialog, GameStorageItem, Player, string | void>;
|
||
/** 用于info.mark为“character”，添加，移除标记时，log显示的标记名（好像意义不大） */
|
||
name?: string | TwoParmFun<GameStorageItem, Player, string>;
|
||
name2?: string | TwoParmFun<GameStorageItem, Player, string>;
|
||
/**
|
||
* 标记显示内容？
|
||
* 为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<GameStorageItem, Player, string, string>;
|
||
/**
|
||
* 标记数
|
||
*
|
||
* 主要在player.updateMark时使用，实际顶替this.storage[i+'_markcount']获取标记数
|
||
*/
|
||
markcount?: number | TwoParmFun<GameStorageItem, Player, number | string> | string;
|
||
/** 是否不启用技能标记计数 */
|
||
nocount?: boolean;
|
||
/**
|
||
* 移除该标记时，在unmarkSkill执行
|
||
*
|
||
* 若值为字符串“throw”，该玩家缓存中该技能标记的为牌时，播放丢牌动画；
|
||
*
|
||
* 若是方法，则直接使用该回调方法处理。
|
||
*
|
||
* 注：该参数原本只在把整个标记移除时执行，后续可能自己扩展；
|
||
*/
|
||
onunmark?: TwoParmFun<GameStorageItem, Player, void> | 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<Trigger, boolean>;
|
||
/**
|
||
* 是否显示弹出该技能使用卡牌的文字
|
||
*
|
||
* useCard中使用，
|
||
*
|
||
* 若为true的话，则执行player.popup
|
||
*
|
||
* 例如：player.popup({使用卡牌名name，使用卡牌nature}，'metal')
|
||
*/
|
||
popname?: boolean;
|
||
|
||
//视为技（转换卡牌的技能）
|
||
/**
|
||
* (视为)目标卡牌
|
||
*
|
||
* 一般用于视为技能
|
||
*
|
||
* 【v1.9.102】扩展：可以使用函数式viewAs，目前核心支持使用地方：backup,ok;
|
||
*/
|
||
viewAs?: string | CardBaseUIData | TwoParmFun<Card[], Player, string | VCard>;
|
||
/**
|
||
* 视为技按钮出现条件（即发动条件）
|
||
* @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<Card[], Player, Target[], string>;
|
||
/** 在lose事件中使用，触发执行“lose_卡牌名”事件的content */
|
||
onLose?: ContentFunc | ContentFunc[];
|
||
/**
|
||
* 在lose事件中使用，必须要失去的卡牌为“equips”（装备牌），有onLose才生效。
|
||
* 若符合以上条件，则检测该牌是否需要后续触发执行“lose_卡牌名”事件，既上面配置的onLose
|
||
*/
|
||
filterLose?: TwoParmFun<Card, Player, boolean>;
|
||
/** 在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 | null;
|
||
/**
|
||
* 选择的目标武将牌上出现什么字。
|
||
*
|
||
* 使用地方：ui.click.target/player，....
|
||
*
|
||
* 如果是数组第几元素对应第几个目标；
|
||
*
|
||
* 如果是方法，则直接根据入参target，判断返回的文本；
|
||
*
|
||
* 例子：
|
||
* targetprompt:['出杀','出闪'],依次就是你点击第一个角色后在其旁边显示出杀，第二个角色显示出闪
|
||
*/
|
||
targetprompt?: string | string[] | OneParmFun<Target, string>;
|
||
/**
|
||
* 是否每个目标都结算一次(多个目标)
|
||
*
|
||
* 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<number | Select>;
|
||
/**
|
||
* 需要选择多少个目标才能发动
|
||
*
|
||
* 选择的目标数：
|
||
*
|
||
* 为-1时，选择全部人
|
||
*
|
||
* 为数组时，这个数组就是选择目标数的区间
|
||
*/
|
||
selectTarget?: number | Select | NoneParmFum<number | Select>;
|
||
/**
|
||
* 选择的牌需要满足的条件
|
||
*
|
||
* 可以使用键值对的简便写法
|
||
*
|
||
* 也可以使用函数返回值（推荐）
|
||
*
|
||
* 都是通过get.filter处理成事件的filterCard的方法；
|
||
*
|
||
* 直接填true，则有些地方，会优先触发过滤可使用的卡牌，例如ui.click.skill,ai.basic.chooseCard
|
||
*
|
||
* 注：game.check时，如果当前时viewAs“视为技”，则其过滤技能时filterCard,作为方法，多入参一个event参数，需要时可以使用；
|
||
* （一般没有）
|
||
*/
|
||
filterCard?: boolean | CardBaseUIData | TwoParmFun<Card, Player, boolean> | 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<Trigger, Player, String>;
|
||
//| TwoParmFun<Trigger, Player, String> | TwoParmFun<Links, Player, string> //好像没见到用
|
||
/**
|
||
* 二次提示
|
||
*
|
||
* 主要在createTrigger，step1中，设置event.prompt2
|
||
*
|
||
* 若是boolean类型，则取值false,不显示prompt2，默认使用lib.translate[“技能名_info”]的描述
|
||
*
|
||
* 注：即发动技能时，prompt提示下的提示（默认显示技能描述）；
|
||
*/
|
||
prompt2?: string | TwoParmFun<Trigger, Player, String> | boolean;
|
||
/**
|
||
* 在ui.click.skill中使用，若当前event.skillDialog不存在，可以用该方法生成的文本的dialog作为skillDialog；
|
||
*
|
||
* 若没有该方法，可以使用翻译中该技能的info信息代替。
|
||
*/
|
||
promptfunc?: TwoParmFun<Trigger, Player, String>;
|
||
/** 表示这次描述非常长(涉及用了h5文本)，设置为true，重新执行ui.update()，设置skillDialog.forcebutton为true */
|
||
longprompt?: boolean;
|
||
|
||
//补充game.check相关参数的声明：
|
||
/** 过滤不可选择按钮 */
|
||
filterButton?(button: Button, player: Player): boolean;
|
||
/** 按钮的可选数量，大多数情况下，默认1 */
|
||
selectButton?: number | Select | NoneParmFum<number | Select>;
|
||
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<Trigger, Player, string | Player>;
|
||
/**
|
||
* 是否通过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<Card, number | boolean>;
|
||
check?: TwoParmFun<GameEventPromise, Player, number | boolean>;
|
||
check?: NoneParmFum<number | boolean>;
|
||
// check?(...any:any):number|boolean;
|
||
// /** ai用于检测的方法：用于主动使用触发技能 */
|
||
// check?(card:Card):number|boolean;
|
||
// /** ai用于检测的方法：用于事件触发技能 */
|
||
// check?(event:GameEventPromise,player:Player):number|boolean;
|
||
// check?():number|boolean;
|
||
// check?:OneParmFun<Card,number|boolean> | OneParmFun<Button,number|boolean> | OneParmFun<Player,number|boolean> | TwoParmFun<GameEventPromise,Player,number|boolean>;
|
||
|
||
//event.addTrigger,默认对于技能优先度的标记：rule<card<equip（注：silent默认比同级多1优先度）
|
||
/** 装备技能 */
|
||
equipSkill?: boolean;
|
||
/** 卡牌技能 */
|
||
cardSkill?: boolean;
|
||
/** 规则技能 */
|
||
ruleSkill?: boolean;
|
||
|
||
//日后还有很多属性要添加的
|
||
[key: string]: any;
|
||
}
|
||
|
||
/** ai的配置信息 */
|
||
declare interface SkillAI {
|
||
//****************************技能标签 start****************************** */
|
||
//技能标签(告诉ai的细致的信息，用来自己处理时使用，甚至可以视为一般标记使用)
|
||
/*
|
||
player.hasSkillTag('xxxx') 检测是否有指定技能标签：
|
||
|
||
在流程中，优先检测
|
||
info.ai.skillTagFilter
|
||
若有这个，先用它过滤检测的技能标记，通过后，
|
||
再检测ai[tag],
|
||
若是字符串，则info.ai[tag]==arg；
|
||
非字符串，则，只有true才可以成功（其实按代码，可以判定非0数字）
|
||
*/
|
||
|
||
//无视防具系列：
|
||
/**
|
||
* 无防具（无视防具1）
|
||
*
|
||
* 在某些防具的filter中有所实现，拥有该技能标签，有些防具的效果不能发动
|
||
*/
|
||
unequip?: boolean;
|
||
/**
|
||
* 无视防具2
|
||
*
|
||
* 同样也是作为无视防具的效果的标签，
|
||
* 这个更直接，无需任何判定条件，直接无视
|
||
*/
|
||
unequip2?: boolean;
|
||
/** 无视防具3 */
|
||
unequip_ai?: boolean;
|
||
|
||
/**
|
||
* 【响应闪】
|
||
* 作用是告诉AI手里没『闪』也可能出『闪』,防止没『闪』直接掉血;
|
||
* 常用于视为技；
|
||
*/
|
||
respondShan?: boolean;
|
||
/**
|
||
* 【响应杀】
|
||
* 作用是告诉AI手里没『杀』也可能出『杀』,防止没『杀』直接掉血;
|
||
* 常用于视为技；
|
||
*/
|
||
respondSha?: boolean;
|
||
/**
|
||
* 在createTrigger中使用，可以指示技能不强制发动，暂无用；
|
||
*/
|
||
nofrequent?: boolean;
|
||
/**
|
||
* 【卖血】
|
||
* 用于其他AI检测是否是卖血流(if(target.hasSkillTag('maixie')))。并非加了这个AI就会卖血。
|
||
*/
|
||
maixie?: boolean;
|
||
/**
|
||
* 【卖血2】
|
||
* 用于chooseDrawRecover 选择抽牌还是回血，即表示该角色血量重要，告诉AI主动优先选择回血。
|
||
*/
|
||
maixie_hp?: boolean;
|
||
/**
|
||
* 【卖血3】
|
||
*/
|
||
maixie_defend?: boolean;
|
||
/**
|
||
* 【无护甲】
|
||
* 视为无护甲，用于damage，作用是告诉AI，即使有护甲，也不不使用护甲抵扣伤害；
|
||
*/
|
||
nohujia?: boolean;
|
||
/**
|
||
* 【失去装备正收益】
|
||
* 视为失去装备正收益，即失去装备可以发动某些效果，用于get.buttonValue中,
|
||
* 影响ui的选择项；
|
||
*/
|
||
noe?: boolean;
|
||
/**
|
||
* 【无手牌】
|
||
* 视为无手牌，用于get.buttonValue中，目前只出现在“连营”和“伤逝”中,用于其它AI检测是否含有标签『无牌』,从而告诉其他AI不要拆迁(因为生生不息)。
|
||
* 应该是影响ui的选择项
|
||
*/
|
||
noh?: boolean;
|
||
/**
|
||
* 【不能发起拼点】
|
||
* 用于player.canCompare 检测玩家是否能发起拼点（作为来源），可用于常规判定；
|
||
*/
|
||
noCompareSource?: boolean;
|
||
/**
|
||
* 【不能成为拼点目标】
|
||
* 用于player.canCompare 检测目标是否能成为拼点的目标，可用于常规判定；
|
||
*/
|
||
noCompareTarget?: boolean;
|
||
/**
|
||
* 用于lib.filter.cardRespondable,检测是否可以响应卡牌（这个竟然参加逻辑中）；
|
||
*/
|
||
norespond?: boolean;
|
||
/**
|
||
* 【不能自动无懈】
|
||
* 影响lib.filter.wuxieSwap的检测；
|
||
*/
|
||
noautowuxie?: boolean;
|
||
/**
|
||
* 【可救助】
|
||
* 在_save全局技能中检测，标记该技能是可用于濒死阶段救助；（即此技能可以用于自救）
|
||
* 现在参数3为寻求帮助的濒死角色【v1.9.108.2.1】。
|
||
*/
|
||
save?: boolean;
|
||
/**
|
||
* 【响应桃】
|
||
* 此技能可以用于救人，
|
||
* 一般用于视为技
|
||
*/
|
||
respondTao?: boolean;
|
||
/**
|
||
* 【不明置】
|
||
* 影响game.check的检测；
|
||
*/
|
||
nomingzhi?: boolean;
|
||
/**
|
||
* 反转装备的优先值，用于设置装备卡牌card.ai.basic.order的默认优先度；
|
||
*/
|
||
reverseEquip?: boolean;
|
||
/** 非身份，国战使用，濒死阶段，有该标记，可以强行进行复活求帮助 */
|
||
revertsave?: boolean;
|
||
/** 改变判定 */
|
||
rejudge?: boolean;
|
||
|
||
//inRange方法相关标记，影响距离计算
|
||
/** 逆时针计算距离 */
|
||
left_hand?: boolean;
|
||
/** 顺时针计算距离 */
|
||
right_hand?: boolean;
|
||
/** 计算距离时，无视本单位 */
|
||
undist?: boolean;
|
||
|
||
//其余一些有些少出场的：
|
||
/** 不会受到火焰伤害 */
|
||
nofire?: boolean;
|
||
/** 不会受到雷电伤害 */
|
||
nothunder?: boolean;
|
||
/** 不会受到伤害 */
|
||
nodamage?: boolean;
|
||
/** 使用毒会有收益 */
|
||
usedu?: boolean;
|
||
/** 不受毒影响 */
|
||
nodu?: boolean;
|
||
notrick?: boolean;
|
||
notricksource?: boolean;
|
||
useShan?: boolean;
|
||
noShan?: boolean;
|
||
nolose?: boolean;
|
||
nodiscard?: boolean;
|
||
|
||
/** 玩家不响应无懈 */
|
||
playernowuxie?: boolean;
|
||
|
||
/** 【响应酒】当你需要使用“酒”时，标记技能可响应 */
|
||
jiuOther?: boolean;
|
||
|
||
/** 【伤害减免】当你收到伤害时，伤害会减免 */
|
||
filterDamage?: boolean;
|
||
|
||
//个人额外扩展：
|
||
/** 不能被横置 */
|
||
noLink?: boolean;
|
||
/** 不能被翻面 */
|
||
noTurnover?: boolean;
|
||
|
||
//【v1.9.102】
|
||
/**
|
||
* 用于观看其他角色的手牌
|
||
*
|
||
* 令其他角色的手牌对自己可见；
|
||
* 只需令自己拥有viewHandcard的技能标签即可，通过调整skillTagFilter即可实现对特定角色的手牌可见；
|
||
* 例：
|
||
* ai:{
|
||
viewHandcard:true,
|
||
skillTagFilter:function(player,tag,arg){ //arg为目标，通过调整skillTagFilter即可实现对特定角色的手牌可见；
|
||
if(player==arg) return false;
|
||
}, //可看见除自己外所有人的手牌；
|
||
}
|
||
*/
|
||
viewHandcard?: boolean;
|
||
|
||
/**
|
||
* 是否忽略技能检测
|
||
*
|
||
* 用于get.effect，处理target时，检测是否处理target的result；
|
||
*/
|
||
ignoreSkill?: boolean;
|
||
//********************************技能标签 end********************************** */
|
||
|
||
|
||
//ai基础属性值
|
||
/**
|
||
* ai发动技能的优先度 【也用于卡牌的优先度】
|
||
* 要具体比什么先发发动，可以使用函数返回结果
|
||
*/
|
||
order?: number | TwoParmFun<SkillOrCard, Player, number | void>;
|
||
/**
|
||
* 发动技能是身份暴露度（0~1，相当于概率）
|
||
* 取值范围为0~1,用于帮助AI判断身份,AI中未写expose其他AI将会无法判断其身份
|
||
*/
|
||
expose?: number;
|
||
/**
|
||
* 嘲讽值：
|
||
* 嘲讽值越大的角色越容易遭受到敌方的攻击,默认为1,一般在0~4中取值即可(缔盟threaten值为3)
|
||
*/
|
||
threaten?: number | TwoParmFun<Player, Target, number>;
|
||
/**
|
||
* 态度：
|
||
* 态度只由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<Player, Target, Card, number> | number;
|
||
/**
|
||
* 主要用于get.effect_use中，优先于上面的target；
|
||
*/
|
||
target_use?: ThreeParmFun<Player, Target, Card, number> | number;
|
||
/**
|
||
* ai是否发动此技能（对玩家（自身）的收益）：
|
||
* 返回正，发动，否则不发动;
|
||
* 注：最终
|
||
*/
|
||
player?: ThreeParmFun<Player, Target, Card, number> | number;
|
||
/**
|
||
* 主要用于get.effect_use中，优先于上面的player；
|
||
*/
|
||
player_use?: ThreeParmFun<Player, Target, Card, number> | 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<Player, any, number>;
|
||
/** 该装备的价值 */
|
||
equipValue?: number | TwoParmFun<Card, Player, number>;
|
||
/** 主要是使用在card的ai属性，武将技能可以无视 */
|
||
basic?: {
|
||
/** 该装备的价值，同equipValue，优先使用equipValue，没有则ai.basic.equipValue */
|
||
equipValue?: number | TwoParmFun<Card, Player, number>;
|
||
/** 优先度 */
|
||
order?: number | TwoParmFun<Card, Player, number>;
|
||
/** 回合外留牌的价值(该牌可用价值),number为当前事件玩家的手牌的下标 */
|
||
useful?: SAAType<number> | TwoParmFun<Card, number, SAAType<number>>;
|
||
/** 该牌的使用价值 */
|
||
value?: SAAType<number> | FourParmFun<Card, Player, number, any, SAAType<number>>;
|
||
|
||
[key: string]: SAAType<number> | 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<Card, string, boolean | number> | OneParmFun<Card, boolean | number>; |