3933 lines
128 KiB
JavaScript
3933 lines
128 KiB
JavaScript
import { lib, game, ui, get, ai, _status } from '../noname.js';
|
||
game.import('card', function () {
|
||
return {
|
||
name:'standard',
|
||
connect:true,
|
||
card:{
|
||
damage:{
|
||
ai:{
|
||
result:{
|
||
target:-1.5
|
||
},
|
||
tag:{
|
||
damage:1
|
||
}
|
||
}
|
||
},
|
||
draw:{
|
||
ai:{
|
||
result:{
|
||
target:1
|
||
},
|
||
tag:{
|
||
draw:1
|
||
}
|
||
}
|
||
},
|
||
losehp:{
|
||
ai:{
|
||
result:{
|
||
target:-1.5
|
||
},
|
||
tag:{
|
||
loseHp:1
|
||
}
|
||
}
|
||
},
|
||
recover:{
|
||
ai:{
|
||
result:{
|
||
target:1.5
|
||
},
|
||
tag:{
|
||
recover:1
|
||
}
|
||
}
|
||
},
|
||
firedamage:{
|
||
ai:{
|
||
result:{
|
||
target:-1.5
|
||
},
|
||
tag:{
|
||
damage:1,
|
||
fireDamage:1,
|
||
natureDamage:1,
|
||
}
|
||
}
|
||
},
|
||
thunderdamage:{
|
||
ai:{
|
||
result:{
|
||
target:-1.5
|
||
},
|
||
tag:{
|
||
damage:1,
|
||
thunderDamage:1,
|
||
natureDamage:1,
|
||
}
|
||
}
|
||
},
|
||
icedamage:{
|
||
ai:{
|
||
result:{
|
||
target:-1.5
|
||
},
|
||
tag:{
|
||
damage:1,
|
||
iceDamage:1,
|
||
natureDamage:1,
|
||
}
|
||
}
|
||
},
|
||
respondShan:{
|
||
ai:{
|
||
result:{
|
||
target:-1.5,
|
||
},
|
||
tag:{
|
||
respond:1,
|
||
respondShan:1,
|
||
damage:1
|
||
}
|
||
}
|
||
},
|
||
sha:{
|
||
audio:true,
|
||
fullskin:true,
|
||
nature:['thunder','fire','kami','ice'],
|
||
type:'basic',
|
||
enable:true,
|
||
usable:1,
|
||
updateUsable:'phaseUse',
|
||
global:'icesha_skill',
|
||
range:function(card,player,target){
|
||
return player.inRange(target);
|
||
},
|
||
selectTarget:1,
|
||
cardPrompt:function(card){
|
||
var natures=get.natureList(Array.isArray(card)?card[3]:card);
|
||
if(lib.translate['sha_nature_'+natures[0]+'_info']) return lib.translate['sha_nature_'+natures[0]+'_info'];
|
||
var str='出牌阶段，对你攻击范围内的一名角色使用。其须使用一张【闪】，';
|
||
if(natures.includes('stab')){
|
||
str+='且在此之后需弃置一张手牌（没有则不弃）。';
|
||
}
|
||
str+='否则你对其造成1点';
|
||
var linked=lib.linked.filter(n=>natures.includes(n));
|
||
if(linked.length) str+=get.translation(get.nature(linked))+'属性';
|
||
str+='伤害。';
|
||
return str;
|
||
},
|
||
defaultYingbianEffect:'add',
|
||
filterTarget:function(card,player,target){return player!=target},
|
||
content:function(){
|
||
"step 0"
|
||
if(typeof event.shanRequired!='number'||!event.shanRequired||event.shanRequired<0){
|
||
event.shanRequired=1;
|
||
}
|
||
if(typeof event.baseDamage!='number') event.baseDamage=1;
|
||
if(typeof event.extraDamage!='number') event.extraDamage=0;
|
||
"step 1"
|
||
if(event.directHit||event.directHit2||(!_status.connectMode&&lib.config.skip_shan&&!target.hasShan())){
|
||
event._result={bool:false};
|
||
}
|
||
else if(event.skipShan){
|
||
event._result={bool:true,result:'shaned'};
|
||
}
|
||
else{
|
||
var next=target.chooseToUse('请使用一张闪响应杀');
|
||
next.set('type','respondShan');
|
||
next.set('filterCard',function(card,player){
|
||
if(get.name(card)!='shan') return false;
|
||
return lib.filter.cardEnabled(card,player,'forceEnable');
|
||
});
|
||
if(event.shanRequired>1){
|
||
next.set('prompt2','（共需使用'+event.shanRequired+'张闪）');
|
||
}
|
||
else if(game.hasNature(event.card,'stab')){
|
||
next.set('prompt2','（在此之后仍需弃置一张手牌）');
|
||
}
|
||
next.set('ai1',function(card){
|
||
if(_status.event.useShan) return get.order(card);
|
||
return 0;
|
||
}).set('shanRequired',event.shanRequired);
|
||
next.set('respondTo',[player,card]);
|
||
next.set('useShan',(()=>{
|
||
if(target.hasSkillTag('noShan',null,event)) return false;
|
||
if(target.hasSkillTag('useShan',null,event)) return true;
|
||
if(target.isLinked()&&game.hasNature(event.card)&&get.attitude(target,player._trueMe||player)>0) return false;
|
||
if(event.baseDamage+event.extraDamage<=0&&!game.hasNature(event.card,'ice')) return false;
|
||
if(event.baseDamage+event.extraDamage>=target.hp+
|
||
((player.hasSkillTag('jueqing',false,target)||target.hasSkill('gangzhi'))?target.hujia:0)) return true;
|
||
if(!game.hasNature(event.card,'ice')&&get.damageEffect(target,player,target,get.nature(event.card))>=0) return false;
|
||
if(event.shanRequired>1&&target.mayHaveShan(target,'use',null,'count')<event.shanRequired-(event.shanIgnored||0)) return false;
|
||
return true;
|
||
})());
|
||
//next.autochoose=lib.filter.autoRespondShan;
|
||
}
|
||
"step 2"
|
||
if(!result||!result.bool||!result.result||result.result!='shaned'){
|
||
event.trigger('shaHit');
|
||
}
|
||
else{
|
||
event.shanRequired--;
|
||
if(event.shanRequired>0){
|
||
event.goto(1);
|
||
}
|
||
else if(game.hasNature(event.card,'stab')&&target.countCards('h')>0){
|
||
event.responded=result;
|
||
event.goto(4);
|
||
}
|
||
else{
|
||
event.trigger('shaMiss');
|
||
event.responded=result;
|
||
}
|
||
}
|
||
"step 3"
|
||
if((!result||!result.bool||!result.result||result.result!='shaned')&&!event.unhurt){
|
||
if (!event.directHit&&!event.directHit2&&lib.filter.cardEnabled(new lib.element.VCard({name:'shan'}), target, 'forceEnable')&&
|
||
target.countCards('hs')>0&&get.damageEffect(target,player,target)<0) target.addGaintag(target.getCards('hs'),'sha_notshan');
|
||
target.damage(get.nature(event.card));
|
||
event.result={bool:true}
|
||
event.trigger('shaDamage');
|
||
}
|
||
else{
|
||
event.result={bool:false}
|
||
event.trigger('shaUnhirt');
|
||
}
|
||
event.finish();
|
||
"step 4"
|
||
target.chooseToDiscard('刺杀：请弃置一张牌，否则此【杀】依然造成伤害').set('ai',function(card){
|
||
var target=_status.event.player;
|
||
var evt=_status.event.getParent();
|
||
var bool=true;
|
||
if(get.damageEffect(target,evt.player,target,evt.card.nature)>=0) bool=false;
|
||
if(bool){
|
||
return 8-get.useful(card);
|
||
}
|
||
return 0;
|
||
});
|
||
"step 5"
|
||
if((!result||!result.bool)&&!event.unhurt){
|
||
target.damage(get.nature(event.card));
|
||
event.result={bool:true}
|
||
event.trigger('shaDamage');
|
||
event.finish();
|
||
}
|
||
else{
|
||
event.trigger('shaMiss');
|
||
}
|
||
"step 6"
|
||
if((!result||!result.bool)&&!event.unhurt){
|
||
target.damage(get.nature(event.card));
|
||
event.result={bool:true}
|
||
event.trigger('shaDamage');
|
||
event.finish();
|
||
}
|
||
else{
|
||
event.result={bool:false}
|
||
event.trigger('shaUnhirt');
|
||
}
|
||
},
|
||
ai:{
|
||
yingbian:function(card,player,targets,viewer){
|
||
if(get.attitude(viewer,player)<=0) return 0;
|
||
var base=0,hit=false;
|
||
if(get.cardtag(card,'yingbian_hit')){
|
||
hit=true;
|
||
if(targets.some(target=>{
|
||
return target.mayHaveShan(viewer,'use',target.getCards('h',i=>{
|
||
return i.hasGaintag('sha_notshan');
|
||
}))&&get.attitude(viewer,target)<0&&get.damageEffect(target,player,viewer,get.natureList(card))>0;
|
||
})) base+=5;
|
||
}
|
||
if(get.cardtag(card,'yingbian_add')){
|
||
if(game.hasPlayer(function(current){
|
||
return !targets.includes(current)&&lib.filter.targetEnabled2(card,player,current)&&get.effect(current,card,player,player)>0;
|
||
})) base+=5;
|
||
}
|
||
if(get.cardtag(card,'yingbian_damage')){
|
||
if(targets.some(target=>{
|
||
return get.attitude(player,target)<0&&(hit||!target.mayHaveShan(viewer,'use',target.getCards('h',i=>{
|
||
return i.hasGaintag('sha_notshan');
|
||
}))||player.hasSkillTag('directHit_ai',true,{
|
||
target:target,
|
||
card:card,
|
||
},true))&&!target.hasSkillTag('filterDamage',null,{
|
||
player:player,
|
||
card:card,
|
||
jiu:true,
|
||
})
|
||
})) base+=5;
|
||
}
|
||
return base;
|
||
},
|
||
canLink:function(player,target,card){
|
||
if(!target.isLinked()&&!player.hasSkill('wutiesuolian_skill')) return false;
|
||
if(player.hasSkill('jueqing')||player.hasSkill('gangzhi')||target.hasSkill('gangzhi')) return false;
|
||
return true;
|
||
},
|
||
basic:{
|
||
useful:[5,3,1],
|
||
value:[5,3,1],
|
||
},
|
||
order(item, player) {
|
||
let res = 3.2;
|
||
if (player.hasSkillTag('presha', true, null, true)) res = 10;
|
||
if (typeof item !== 'object' || !game.hasNature(item, 'linked') || game.countPlayer(cur => cur.isLinked()) < 2) return res;
|
||
//let used = player.getCardUsable('sha') - 1.5, natures = ['thunder', 'fire', 'ice', 'kami'];
|
||
let uv = player.getUseValue(item, true);
|
||
if (uv <= 0) return res;
|
||
let temp = player.getUseValue('sha', true) - uv;
|
||
if (temp < 0) return res + 0.15;
|
||
if (temp > 0) return res - 0.15;
|
||
return res;
|
||
},
|
||
result:{
|
||
target:function(player,target,card,isLink){
|
||
let eff=-1.5,odds=1.35,num=1;
|
||
if(isLink){
|
||
let cache=_status.event.getTempCache('sha_result','eff');
|
||
if(typeof cache!=='object'||cache.card!==get.translation(card)) return eff;
|
||
if(cache.odds<1.35&&cache.bool) return 1.35*cache.eff;
|
||
return cache.odds*cache.eff;
|
||
}
|
||
if(player.hasSkill('jiu')||player.hasSkillTag('damageBonus',true,{
|
||
target:target,
|
||
card:card
|
||
})){
|
||
if(target.hasSkillTag('filterDamage',null,{
|
||
player:player,
|
||
card:card,
|
||
jiu:true,
|
||
})) eff=-0.5;
|
||
else{
|
||
num=2;
|
||
if(get.attitude(player,target)>0) eff=-7;
|
||
else eff=-4;
|
||
}
|
||
}
|
||
if(!player.hasSkillTag('directHit_ai',true,{
|
||
target:target,
|
||
card:card,
|
||
},true)) odds-=0.7*target.mayHaveShan(player,'use',target.getCards('h',i=>{
|
||
return i.hasGaintag('sha_notshan');
|
||
}),'odds');
|
||
_status.event.putTempCache('sha_result','eff',{
|
||
bool:target.hp>num&&get.attitude(player,target)>0,
|
||
card:get.translation(card),
|
||
eff:eff,
|
||
odds:odds
|
||
});
|
||
return odds*eff;
|
||
},
|
||
},
|
||
tag:{
|
||
respond:1,
|
||
respondShan:1,
|
||
damage:function(card){
|
||
if(game.hasNature(card,'poison')) return;
|
||
return 1;
|
||
},
|
||
natureDamage:function(card){
|
||
if(game.hasNature(card,'linked')) return 1;
|
||
},
|
||
fireDamage:function(card,nature){
|
||
if(game.hasNature(card,'fire')) return 1;
|
||
},
|
||
thunderDamage:function(card,nature){
|
||
if(game.hasNature(card,'thunder')) return 1;
|
||
},
|
||
poisonDamage:function(card,nature){
|
||
if(game.hasNature(card,'poison')) return 1;
|
||
}
|
||
}
|
||
}
|
||
},
|
||
shacopy:{
|
||
ai:{
|
||
basic:{
|
||
useful:[5,3,1],
|
||
value:[5,3,1],
|
||
},
|
||
order:3,
|
||
result:{
|
||
target:-1.5,
|
||
},
|
||
tag:{
|
||
respond:1,
|
||
respondShan:1,
|
||
damage:function(card){
|
||
if(game.hasNature(card,'poison')) return;
|
||
return 1;
|
||
},
|
||
natureDamage:function(card){
|
||
if(game.hasNature(card)) return 1;
|
||
},
|
||
fireDamage:function(card,nature){
|
||
if(game.hasNature(card,'fire')) return 1;
|
||
},
|
||
thunderDamage:function(card,nature){
|
||
if(game.hasNature(card,'thunder')) return 1;
|
||
},
|
||
poisonDamage:function(card,nature){
|
||
if(game.hasNature(card,'poison')) return 1;
|
||
}
|
||
}
|
||
}
|
||
},
|
||
shan:{
|
||
audio:true,
|
||
fullskin:true,
|
||
type:'basic',
|
||
cardcolor:'red',
|
||
notarget:true,
|
||
nodelay:true,
|
||
defaultYingbianEffect:'draw',
|
||
content:function(){
|
||
event.result='shaned';
|
||
event.getParent().delayx=false;
|
||
game.delay(0.5);
|
||
},
|
||
ai:{
|
||
order:3,
|
||
basic:{
|
||
useful:(card,i)=>{
|
||
let player = _status.event.player, basic = [7, 5.1, 2], num = basic[Math.min(2, i)];
|
||
if(player.hp>2&&player.hasSkillTag('maixie')) num *= 0.57;
|
||
if(player.hasSkillTag('freeShan',false,null,true) || player.getEquip('rewrite_renwang')) num *= 0.8;
|
||
return num;
|
||
},
|
||
value:[7,5.1,2],
|
||
},
|
||
result:{player:1},
|
||
//expose:0.2
|
||
}
|
||
},
|
||
tao:{
|
||
fullskin:true,
|
||
type:'basic',
|
||
cardcolor:'red',
|
||
toself:true,
|
||
enable:function(card,player){
|
||
return player.hp<player.maxHp;
|
||
},
|
||
savable:true,
|
||
selectTarget:-1,
|
||
filterTarget:function(card,player,target){
|
||
return target==player&&target.hp<target.maxHp;
|
||
},
|
||
modTarget:function(card,player,target){
|
||
return target.hp<target.maxHp;
|
||
},
|
||
content:function(){
|
||
target.recover();
|
||
},
|
||
ai:{
|
||
basic:{
|
||
order:(card,player)=>{
|
||
if(player.hasSkillTag('pretao')) return 9;
|
||
return 2;
|
||
},
|
||
useful:(card,i)=>{
|
||
let player = _status.event.player;
|
||
if(!game.checkMod(card,player,'unchanged','cardEnabled2',player)) return 2/(1+i);
|
||
let fs = game.filterPlayer(current=>{
|
||
return get.attitude(player,current)>0&¤t.hp<=2;
|
||
}), damaged = 0, needs = 0;
|
||
fs.forEach(f=>{
|
||
if(f.hp>3 || !lib.filter.cardSavable(card,player,f)) return;
|
||
if(f.hp>1) damaged++;
|
||
else needs++;
|
||
});
|
||
if(needs&&damaged) return 5*needs+3*damaged;
|
||
if(needs+damaged>1 || player.hasSkillTag('maixie')) return 8;
|
||
if(player.hp/player.maxHp<0.7) return 7+Math.abs(player.hp/player.maxHp-0.5);
|
||
if(needs) return 7;
|
||
if(damaged) return Math.max(3,7.8-i);
|
||
return Math.max(1,7.2-i);
|
||
},
|
||
value:(card,player)=>{
|
||
let fs = game.filterPlayer(current=>{
|
||
return get.attitude(_status.event.player,current)>0;
|
||
}), damaged = 0, needs = 0;
|
||
fs.forEach(f=>{
|
||
if(!player.canUse('tao',f)) return;
|
||
if(f.hp<=1) needs++;
|
||
else if(f.hp==2) damaged++;
|
||
});
|
||
if(needs&&damaged || player.hasSkillTag('maixie')) return Math.max(9,5*needs+3*damaged);
|
||
if(needs || damaged>1) return 8;
|
||
if(damaged) return 7.5;
|
||
return Math.max(5,9.2-player.hp);
|
||
}
|
||
},
|
||
result:{
|
||
target:(player,target)=>{
|
||
if(target.hasSkillTag('maixie')) return 3;
|
||
return 2;
|
||
},
|
||
target_use:(player,target,card)=>{
|
||
let mode = get.mode(),
|
||
taos = player.getCards('hs',i=>get.name(i)==='tao'&&lib.filter.cardEnabled(i,target,'forceEnable'));
|
||
if(target!==_status.event.dying){
|
||
if(!player.isPhaseUsing() || player.hasSkillTag('nokeep',true,{
|
||
card:card,
|
||
target:target
|
||
},true)) return 2;
|
||
let min = 7.2-4*player.hp/player.maxHp,
|
||
nd = player.needsToDiscard(0,(i,player)=>{
|
||
return !player.canIgnoreHandcard(i)&&(taos.includes(i)||get.value(i)>=min);
|
||
}),
|
||
keep = nd?0:2;
|
||
if(nd>2 || taos.length>1&&(nd>1||nd&&player.hp<1+taos.length) || target.identity==='zhu'&&(nd||target.hp<3)&&(mode==='identity'||mode==='versus'||mode==='chess') || !player.hasFriend()) return 2;
|
||
if(game.hasPlayer(current=>{
|
||
return player!==current&¤t.identity==='zhu'&¤t.hp<3&&(mode==='identity'||mode==='versus'||mode==='chess')&&get.attitude(player,current)>0;
|
||
})) keep = 3;
|
||
else if(nd===2||player.hp<2) return 2;
|
||
if(nd===2&&player.hp<=1) return 2;
|
||
if(keep===3) return 0;
|
||
if(taos.length<=player.hp/2) keep = 1;
|
||
if(keep&&game.countPlayer(current=>{
|
||
if(player!==current&¤t.hp<3&&player.hp>current.hp&&get.attitude(player,current)>2){
|
||
keep += player.hp-current.hp;
|
||
return true;
|
||
}
|
||
return false;
|
||
})){
|
||
if(keep>2) return 0;
|
||
}
|
||
return 2;
|
||
}
|
||
if(target.isZhu2() || target===game.boss) return 2;
|
||
if(player!==target){
|
||
if(target.hp<0&&taos.length+target.hp<=0) return 0;
|
||
if(Math.abs(get.attitude(player,target))<1) return 0;
|
||
}
|
||
if(!player.getFriends().length) return 2;
|
||
let tri = _status.event.getTrigger(),
|
||
num = game.countPlayer(current=>{
|
||
if(get.attitude(current,target)>0) return current.countCards('hs',i=>get.name(i)==='tao'&&lib.filter.cardEnabled(i,target,'forceEnable'));
|
||
}),
|
||
dis = 1,
|
||
t = _status.currentPhase||game.me;
|
||
while(t!==target){
|
||
let att = get.attitude(player,t);
|
||
if(att<-2) dis++;
|
||
else if(att<1) dis += 0.45;
|
||
t = t.next;
|
||
}
|
||
if(mode==='identity'){
|
||
if(tri&&tri.name==='dying'){
|
||
if(target.identity==='fan') {
|
||
if(!tri.source&&player!==target || tri.source&&tri.source!==target&&player.getFriends().includes(tri.source.identity)){
|
||
if(num>dis || player===target&&player.countCards('hs',{type:'basic'})>1.6*dis) return 2;
|
||
return 0;
|
||
}
|
||
}
|
||
else if(tri.source&&tri.source.isZhu&&(target.identity==='zhong'||target.identity==='mingzhong')&&
|
||
(tri.source.countCards('he')>2||player===tri.source&&player.hasCard((i)=>i.name!=='tao','he'))) return 2;
|
||
//if(player!==target&&!target.isZhu&&target.countCards('hs')<dis) return 0;
|
||
}
|
||
if(player.identity==='zhu'){
|
||
if(player.hp<=1&&player!==target&&taos+player.countCards('hs','jiu')<=Math.min(dis,game.countPlayer(current=>{
|
||
return current.identity==='fan';
|
||
}))) return 0;
|
||
}
|
||
}
|
||
else if(mode==='stone'&&target.isMin()&&player!==target&&tri&&tri.name==='dying'&&player.side===target.side&&tri.source!==target.getEnemy()) return 0;
|
||
return 2;
|
||
}
|
||
},
|
||
tag:{
|
||
recover:1,
|
||
save:1,
|
||
}
|
||
}
|
||
},
|
||
bagua:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip2',
|
||
ai:{
|
||
basic:{
|
||
equipValue:7.5
|
||
}
|
||
},
|
||
skills:['bagua_skill']
|
||
},
|
||
jueying:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip3',
|
||
distance:{globalTo:1},
|
||
},
|
||
dilu:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip3',
|
||
distance:{globalTo:1},
|
||
},
|
||
zhuahuang:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip3',
|
||
distance:{globalTo:1},
|
||
},
|
||
chitu:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip4',
|
||
distance:{globalFrom:-1},
|
||
},
|
||
dawan:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip4',
|
||
distance:{globalFrom:-1},
|
||
},
|
||
zixin:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip4',
|
||
distance:{globalFrom:-1},
|
||
},
|
||
zhuge:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip1',
|
||
ai:{
|
||
order:function(){
|
||
return get.order({name:'sha'})-0.1;
|
||
},
|
||
equipValue:function(card,player){
|
||
if(player._zhuge_temp) return 1;
|
||
player._zhuge_temp=true;
|
||
var result=function(){
|
||
if(!game.hasPlayer(function(current){
|
||
return get.distance(player,current)<=1&&player.canUse('sha',current)&&get.effect(current,{name:'sha'},player,player)>0;
|
||
})){
|
||
return 1;
|
||
}
|
||
if(player.hasSha()&&_status.currentPhase==player){
|
||
if(player.getEquip('zhuge')&&player.countUsed('sha')||player.getCardUsable('sha')==0){
|
||
return 10;
|
||
}
|
||
}
|
||
var num=player.countCards('h','sha');
|
||
if(num>1) return 6+num;
|
||
return 3+num;
|
||
}();
|
||
delete player._zhuge_temp;
|
||
return result;
|
||
},
|
||
basic:{
|
||
equipValue:5
|
||
},
|
||
tag:{
|
||
valueswap:1
|
||
}
|
||
},
|
||
skills:['zhuge_skill']
|
||
},
|
||
cixiong:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip1',
|
||
distance:{attackFrom:-1},
|
||
ai:{
|
||
basic:{
|
||
equipValue:2
|
||
}
|
||
},
|
||
skills:['cixiong_skill']
|
||
},
|
||
qinggang:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip1',
|
||
distance:{attackFrom:-1},
|
||
ai:{
|
||
basic:{
|
||
equipValue:2
|
||
}
|
||
},
|
||
skills:['qinggang_skill']
|
||
},
|
||
qinglong:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip1',
|
||
distance:{attackFrom:-2},
|
||
ai:{
|
||
equipValue:function(card,player){
|
||
return Math.min(2.5+player.countCards('h','sha'),4);
|
||
},
|
||
basic:{
|
||
equipValue:3.5
|
||
}
|
||
},
|
||
skills:['qinglong_skill','qinglong_guozhan']
|
||
},
|
||
zhangba:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip1',
|
||
distance:{attackFrom:-2},
|
||
ai:{
|
||
equipValue:function(card,player){
|
||
var num=2.5+player.countCards('h')/3;
|
||
return Math.min(num,4);
|
||
},
|
||
basic:{
|
||
equipValue:3.5
|
||
}
|
||
},
|
||
skills:['zhangba_skill']
|
||
},
|
||
guanshi:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip1',
|
||
distance:{attackFrom:-2},
|
||
ai:{
|
||
equipValue:function(card,player){
|
||
var num=2.5+(player.countCards('h')+player.countCards('e'))/2.5;
|
||
return Math.min(num,5);
|
||
},
|
||
basic:{
|
||
equipValue:4.5,
|
||
}
|
||
},
|
||
skills:['guanshi_skill']
|
||
},
|
||
fangtian:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip1',
|
||
distance:{attackFrom:-3},
|
||
ai:{
|
||
basic:{
|
||
equipValue:2.5
|
||
}
|
||
},
|
||
skills:['fangtian_skill','fangtian_guozhan']
|
||
},
|
||
qilin:{
|
||
fullskin:true,
|
||
type:'equip',
|
||
subtype:'equip1',
|
||
distance:{attackFrom:-4},
|
||
ai:{
|
||
basic:{
|
||
equipValue:3
|
||
}
|
||
},
|
||
skills:['qilin_skill']
|
||
},
|
||
wugu:{
|
||
audio:true,
|
||
fullskin:true,
|
||
type:'trick',
|
||
enable:true,
|
||
cardcolor:'red',
|
||
selectTarget:-1,
|
||
filterTarget:true,
|
||
contentBefore:function(){
|
||
"step 0"
|
||
if(!targets.length){
|
||
event.finish();
|
||
return;
|
||
}
|
||
if(card.storage&&card.storage.chooseDirection||get.is.versus()){
|
||
player.chooseControl('顺时针','逆时针',function(event,player){
|
||
if(get.event('isVersus')&&player.next.side==player.side||get.attitude(player,player.next)>get.attitude(player,player.previous)) return '逆时针';
|
||
return '顺时针';
|
||
}).set('prompt','选择'+get.translation(card)+'的结算方向').set('isVersus',get.is.versus());
|
||
}
|
||
else{
|
||
event.goto(2);
|
||
}
|
||
"step 1"
|
||
if(result&&result.control=='顺时针'){
|
||
var evt=event.getParent(),sorter=(_status.currentPhase||player);
|
||
evt.fixedSeat=true;
|
||
evt.targets.sortBySeat(sorter);
|
||
evt.targets.reverse();
|
||
if(evt.targets[evt.targets.length-1]==sorter){
|
||
evt.targets.unshift(evt.targets.pop());
|
||
}
|
||
}
|
||
"step 2"
|
||
ui.clear();
|
||
var cards;
|
||
if(card.storage&&Array.isArray(card.storage.fixedShownCards)){
|
||
cards=card.storage.fixedShownCards.slice();
|
||
var lose_list=[],cards2=[];
|
||
cards.forEach(card=>{
|
||
var owner=get.owner(card);
|
||
if(owner){
|
||
var arr=lose_list.find(i=>i[0]==owner);
|
||
if(arr) arr[1].push(card);
|
||
else lose_list.push([owner,[card]]);
|
||
}
|
||
else cards2.add(card);
|
||
});
|
||
if(lose_list.length){
|
||
lose_list.forEach(list=>{
|
||
list[0].$throw(list[1]);
|
||
game.log(list[0],'将',list[1],'置于了处理区');
|
||
})
|
||
game.loseAsync({
|
||
lose_list:lose_list,
|
||
}).setContent('chooseToCompareLose');
|
||
}
|
||
if(cards2.length) game.cardsGotoOrdering(cards2);
|
||
game.delayex();
|
||
}
|
||
else{
|
||
var num;
|
||
if(event.targets){
|
||
num=event.targets.length;
|
||
}
|
||
else{
|
||
num=game.countPlayer();
|
||
}
|
||
if(card.storage&&typeof card.storage.extraCardsNum=='number') num+=card.storage.extraCardsNum;
|
||
cards=get.cards(num);
|
||
game.cardsGotoOrdering(cards).relatedEvent=event.getParent();
|
||
}
|
||
var dialog=ui.create.dialog('五谷丰登',cards,true);
|
||
_status.dieClose.push(dialog);
|
||
dialog.videoId=lib.status.videoId++;
|
||
game.addVideo('cardDialog',null,['五谷丰登',get.cardsInfo(cards),dialog.videoId]);
|
||
event.getParent().preResult=dialog.videoId;
|
||
game.broadcast(function(cards,id){
|
||
var dialog=ui.create.dialog('五谷丰登',cards,true);
|
||
_status.dieClose.push(dialog);
|
||
dialog.videoId=id;
|
||
},cards,dialog.videoId);
|
||
game.log(event.card,'亮出了',cards);
|
||
},
|
||
content:function(){
|
||
"step 0"
|
||
for(var i=0;i<ui.dialogs.length;i++){
|
||
if(ui.dialogs[i].videoId==event.preResult){
|
||
event.dialog=ui.dialogs[i];break;
|
||
}
|
||
}
|
||
if(!event.dialog || event.dialog.buttons.length == 0){
|
||
event.finish();
|
||
return;
|
||
}
|
||
if(event.dialog.buttons.length>1){
|
||
var next=target.chooseButton(true,function(button){
|
||
return get.value(button.link,_status.event.player);
|
||
});
|
||
next.set('dialog',event.preResult);
|
||
next.set('closeDialog',false);
|
||
next.set('dialogdisplay',true);
|
||
}
|
||
else{
|
||
event.directButton=event.dialog.buttons[0];
|
||
}
|
||
"step 1"
|
||
var dialog=event.dialog;
|
||
var card;
|
||
if(event.directButton){
|
||
card=event.directButton.link;
|
||
}
|
||
else{
|
||
for(var i of dialog.buttons){
|
||
if(i.link==result.links[0]){
|
||
card=i.link;
|
||
break;
|
||
}
|
||
}
|
||
if(!card) card=event.dialog.buttons[0].link;
|
||
}
|
||
var button;
|
||
for(var i=0;i<dialog.buttons.length;i++){
|
||
if(dialog.buttons[i].link==card){
|
||
button=dialog.buttons[i];
|
||
button.querySelector('.info').innerHTML=function(target){
|
||
if(target._tempTranslate) return target._tempTranslate;
|
||
var name=target.name;
|
||
if(lib.translate[name+'_ab']) return lib.translate[name+'_ab'];
|
||
return get.translation(name);
|
||
}(target);
|
||
dialog.buttons.remove(button);
|
||
break;
|
||
}
|
||
}
|
||
var capt=get.translation(target)+'选择了'+get.translation(button.link);
|
||
if(card){
|
||
target.gain(card,'visible');
|
||
target.$gain2(card);
|
||
game.broadcast(function(card,id,name,capt){
|
||
var dialog=get.idDialog(id);
|
||
if(dialog){
|
||
dialog.content.firstChild.innerHTML=capt;
|
||
for(var i=0;i<dialog.buttons.length;i++){
|
||
if(dialog.buttons[i].link==card){
|
||
dialog.buttons[i].querySelector('.info').innerHTML=name;
|
||
dialog.buttons.splice(i--,1);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
},card,dialog.videoId,function(target){
|
||
if(target._tempTranslate) return target._tempTranslate;
|
||
var name=target.name;
|
||
if(lib.translate[name+'_ab']) return lib.translate[name+'_ab'];
|
||
return get.translation(name);
|
||
}(target),capt);
|
||
}
|
||
dialog.content.firstChild.innerHTML=capt;
|
||
game.addVideo('dialogCapt',null,[dialog.videoId,dialog.content.firstChild.innerHTML]);
|
||
game.log(target,'选择了',button.link);
|
||
game.delay();
|
||
},
|
||
contentAfter:function(){
|
||
for(var i=0;i<ui.dialogs.length;i++){
|
||
if(ui.dialogs[i].videoId==event.preResult){
|
||
var dialog=ui.dialogs[i];
|
||
dialog.close();
|
||
_status.dieClose.remove(dialog);
|
||
if(dialog.buttons.length){
|
||
event.remained=[];
|
||
for(var i=0;i<dialog.buttons.length;i++){
|
||
event.remained.push(dialog.buttons[i].link);
|
||
}
|
||
event.trigger('wuguRemained');
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
game.broadcast(function(id){
|
||
var dialog=get.idDialog(id);
|
||
if(dialog){
|
||
dialog.close();
|
||
_status.dieClose.remove(dialog);
|
||
}
|
||
},event.preResult);
|
||
game.addVideo('cardDialog',null,event.preResult);
|
||
},
|
||
ai:{
|
||
wuxie:function(){
|
||
if(Math.random()<0.5) return 0;
|
||
},
|
||
basic:{
|
||
order:3,
|
||
useful:0.5,
|
||
},
|
||
result:{
|
||
target:function(player,target){
|
||
var sorter=(_status.currentPhase||player);
|
||
if(get.is.versus()){
|
||
if(target==sorter) return 1.5;
|
||
return 1;
|
||
}
|
||
if(player.hasUnknown(2)){
|
||
return 0;
|
||
}
|
||
return (1-get.distance(sorter,target,'absolute')/game.countPlayer())*get.attitude(player,target)>0?0.5:0.7;
|
||
}
|
||
},
|
||
tag:{
|
||
draw:1,
|
||
multitarget:1
|
||
}
|
||
}
|
||
},
|
||
taoyuan:{
|
||
audio:true,
|
||
fullskin:true,
|
||
type:'trick',
|
||
enable:true,
|
||
selectTarget:-1,
|
||
cardcolor:'red',
|
||
reverseOrder:true,
|
||
defaultYingbianEffect:'remove',
|
||
filterTarget:function(card,player,target){
|
||
//return target.hp<target.maxHp;
|
||
return true;
|
||
},
|
||
ignoreTarget:function(card,player,target){
|
||
return target.isHealthy();
|
||
},
|
||
content:function(){
|
||
target.recover();
|
||
},
|
||
ai:{
|
||
basic:{
|
||
order:(item,player)=>{
|
||
if(game.hasPlayer(current=>current.hp<=1&&get.recoverEffect(current,player,_status.event.player)<0)) return 1;
|
||
return 10;
|
||
},
|
||
useful:[3,1],
|
||
value:0,
|
||
},
|
||
result:{
|
||
target:function(player,target){
|
||
return (target.hp<target.maxHp)?2:0;
|
||
}
|
||
},
|
||
tag:{
|
||
recover:0.5,
|
||
multitarget:1
|
||
}
|
||
}
|
||
},
|
||
nanman:{
|
||
audio:true,
|
||
fullskin:true,
|
||
type:'trick',
|
||
enable:true,
|
||
selectTarget:-1,
|
||
defaultYingbianEffect:'remove',
|
||
filterTarget:function(card,player,target){
|
||
return target!=player;
|
||
},
|
||
reverseOrder:true,
|
||
content:function(){
|
||
"step 0"
|
||
if(typeof event.shaRequired!='number'||!event.shaRequired||event.shaRequired<0) event.shaRequired=1;
|
||
if(typeof event.baseDamage!='number') event.baseDamage=1;
|
||
"step 1"
|
||
if(event.directHit) event._result={bool:false};
|
||
else{
|
||
var next=target.chooseToRespond({name:'sha'});
|
||
if(event.shaRequired>1){
|
||
next.set('prompt2','共需打出'+event.shaRequired+'张杀');
|
||
}
|
||
next.set('ai',function(card){
|
||
var evt=_status.event.getParent();
|
||
if(get.damageEffect(evt.target,evt.player,evt.target)>=0) return 0;
|
||
if(evt.player.hasSkillTag('notricksource')) return 0;
|
||
if(evt.target.hasSkillTag('notrick')) return 0;
|
||
return get.order(card);
|
||
});
|
||
next.autochoose=lib.filter.autoRespondSha;
|
||
}
|
||
"step 2"
|
||
if(result.bool==false){
|
||
target.damage();
|
||
}
|
||
else{
|
||
event.shaRequired--;
|
||
if(event.shaRequired>0) event.goto(1);
|
||
}
|
||
},
|
||
ai:{
|
||
wuxie(target, card, player, viewer, status) {
|
||
let att = get.attitude(viewer, target), eff = get.effect(target, card, player, target);
|
||
if (Math.abs(att) < 1 || status * eff * att >= 0) return 0;
|
||
let evt = _status.event.getParent('useCard'), pri = 1, bonus = player.hasSkillTag('damageBonus', true, {
|
||
target: target,
|
||
card: card
|
||
}), damage = 1, isZhu = function (tar) {
|
||
return tar.isZhu || tar === game.boss || tar === game.trueZhu || tar === game.falseZhu;
|
||
}, canSha = function (tar, blur) {
|
||
let known = tar.getKnownCards(viewer);
|
||
if (!blur) return known.some(card => {
|
||
let name = get.name(card, tar);
|
||
return (name === 'sha' || name === 'hufu' || name === 'yuchanqian') && lib.filter.cardRespondable(card, tar);
|
||
});
|
||
if (tar.countCards('hs', i => !known.includes(i)) > 4.67 - 2 * tar.hp / tar.maxHp) return true;
|
||
if (!tar.hasSkillTag('respondSha', true, 'respond', true)) return false;
|
||
if (tar.hp <= damage) return false;
|
||
if (tar.hp <= damage + 1) return isZhu(tar);
|
||
return true;
|
||
}, self = false;
|
||
if (canSha(target)) return 0;
|
||
if (bonus && !viewer.hasSkillTag('filterDamage', null, {
|
||
player: player,
|
||
card: card
|
||
})) damage = 2;
|
||
if ((viewer.hp <= damage || viewer.hp <= damage + 1 && isZhu(viewer)) && !canSha(viewer)) {
|
||
if (viewer === target) return status;
|
||
let fv = true;
|
||
if (evt && evt.targets) for (let i of evt.targets) {
|
||
if (fv) {
|
||
if (target === i) fv = false;
|
||
continue;
|
||
}
|
||
if (viewer == i) {
|
||
if (isZhu(viewer)) return 0;
|
||
self = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
let maySha = canSha(target, true);
|
||
if (bonus && !target.hasSkillTag('filterDamage', null, {
|
||
player: player,
|
||
card: card
|
||
})) damage = 2;
|
||
else damage = 1;
|
||
if (isZhu(target)) {
|
||
if (eff < 0) {
|
||
if (target.hp <= damage + 1 || !maySha && target.hp <= damage + 2) return 1;
|
||
if (maySha && target.hp > damage + 2) return 0;
|
||
else if (maySha || target.hp > damage + 2) pri = 3;
|
||
else pri = 4;
|
||
}
|
||
else if (target.hp > damage + 1) pri = 2;
|
||
else return 0;
|
||
}
|
||
else if (self) return 0;
|
||
else if (eff < 0) {
|
||
if (!maySha && target.hp <= damage) pri = 5;
|
||
else if (maySha) return 0;
|
||
else if (target.hp > damage + 1) pri = 2;
|
||
else if (target.hp === damage + 1) pri = 3;
|
||
else pri = 4;
|
||
}
|
||
else if (target.hp <= damage) return 0;
|
||
let find = false;
|
||
if (evt && evt.targets) for (let i = 0; i < evt.targets.length; i++) {
|
||
if (!find) {
|
||
if (evt.targets[i] === target) find = true;
|
||
continue;
|
||
}
|
||
let att1 = get.attitude(viewer, evt.targets[i]), eff1 = get.effect(evt.targets[i], card, player, evt.targets[i]), temp = 1;
|
||
if (Math.abs(att1) < 1 || att1 * eff1 >= 0 || canSha(evt.targets[i])) continue;
|
||
maySha = canSha(evt.targets[i], true);
|
||
if (bonus && !evt.targets[i].hasSkillTag('filterDamage', null, {
|
||
player: player,
|
||
card: card
|
||
})) damage = 2;
|
||
else damage = 1;
|
||
if (isZhu(evt.targets[i])) {
|
||
if (eff1 < 0) {
|
||
if (evt.targets[i].hp <= damage + 1 || !maySha && evt.targets[i].hp <= damage + 2) return 0;
|
||
if (maySha && evt.targets[i].hp > damage + 2) continue;
|
||
if (maySha || evt.targets[i].hp > damage + 2) temp = 3;
|
||
else temp = 4;
|
||
}
|
||
else if (evt.targets[i].hp > damage + 1) temp = 2;
|
||
else continue;
|
||
}
|
||
else if (eff1 < 0) {
|
||
if (!maySha && evt.targets[i].hp <= damage) temp = 5;
|
||
else if (maySha) continue;
|
||
else if (evt.targets[i].hp > damage + 1) temp = 2;
|
||
else if (evt.targets[i].hp === damage + 1) temp = 3;
|
||
else temp = 4;
|
||
}
|
||
else if (evt.targets[i].hp > damage + 1) temp = 2;
|
||
if (temp > pri) return 0;
|
||
}
|
||
return 1;
|
||
},
|
||
basic: {
|
||
order: 9,
|
||
useful: [5, 1],
|
||
value: 5
|
||
},
|
||
result: {
|
||
player(player, target) {
|
||
if (player._nanman_temp || player.hasSkillTag('jueqing', false, target)) return 0;
|
||
player._nanman_temp = true;
|
||
let eff = get.effect(target, new lib.element.VCard({ name: 'nanman' }), player, target);
|
||
delete player._nanman_temp;
|
||
if (eff >= 0) return 0;
|
||
if (target.hp > 2 || target.hp > 1 && !target.isZhu && target != game.boss && target != game.trueZhu && target != game.falseZhu) return 0;
|
||
if (target.hp > 1 && target.hasSkillTag('respondSha', true, 'respond', true)) return 0;
|
||
let known = target.getKnownCards(player);
|
||
if (known.some(card => {
|
||
let name = get.name(card, target);
|
||
if (name === 'sha' || name === 'hufu' || name === 'yuchanqian') return lib.filter.cardRespondable(card, target);
|
||
if (name === 'wuxie') return lib.filter.cardEnabled(card, target, 'forceEnable');
|
||
})) return 0;
|
||
if (target.hp > 1 || target.countCards('hs', i => !known.includes(i)) > 4.67 - 2 * target.hp / target.maxHp) return 0;
|
||
let res = 0, att = get.sgnAttitude(player, target);
|
||
res -= att * (0.8 * target.countCards('hs') + 0.6 * target.countCards('e') + 3.6);
|
||
if (get.mode() === 'identity' && target.identity === 'fan') res += 2.4;
|
||
if (get.mode() === 'guozhan' && player.identity !== 'ye' && player.identity === target.identity ||
|
||
get.mode() === 'identity' && player.identity === 'zhu' && (target.identity === 'zhong' || target.identity === 'mingzhong')) res -= 0.8 * player.countCards('he');
|
||
return res;
|
||
},
|
||
target(player, target) {
|
||
let zhu = (get.mode() === 'identity' && target.isZhu) || target.identity === 'zhu';
|
||
if (!lib.filter.cardRespondable({ name: 'sha' }, target)) {
|
||
if (zhu) {
|
||
if (target.hp < 2) return -99;
|
||
if (target.hp === 2) return -3.6;
|
||
}
|
||
return -2;
|
||
}
|
||
let known = target.getKnownCards(player);
|
||
if (known.some(card => {
|
||
let name = get.name(card, target);
|
||
if (name === 'sha' || name === 'hufu' || name === 'yuchanqian') return lib.filter.cardRespondable(card, target);
|
||
if (name === 'wuxie') return lib.filter.cardEnabled(card, target, 'forceEnable');
|
||
})) return -1.2;
|
||
let nh = target.countCards('hs', i => !known.includes(i));
|
||
if (zhu && target.hp <= 1) {
|
||
if (nh === 0) return -99;
|
||
if (nh === 1) return -60;
|
||
if (nh === 2) return -36;
|
||
if (nh === 3) return -12;
|
||
if (nh === 4) return -8;
|
||
return -5;
|
||
}
|
||
if (target.hasSkillTag('respondSha', true, 'respond', true)) return -1.35;
|
||
if (!nh) return -2;
|
||
if (nh === 1) return -1.8;
|
||
return -1.5;
|
||
}
|
||
},
|
||
tag: {
|
||
respond: 1,
|
||
respondSha: 1,
|
||
damage: 1,
|
||
multitarget: 1,
|
||
multineg: 1
|
||
}
|
||
}
|
||
},
|
||
wanjian:{
|
||
audio:true,
|
||
fullskin:true,
|
||
type:'trick',
|
||
enable:true,
|
||
selectTarget:-1,
|
||
reverseOrder:true,
|
||
defaultYingbianEffect:'remove',
|
||
filterTarget:function(card,player,target){
|
||
return target!=player;
|
||
},
|
||
content:function(){
|
||
"step 0"
|
||
if(typeof event.shanRequired!='number'||!event.shanRequired||event.shanRequired<0) event.shanRequired=1;
|
||
if(typeof event.baseDamage!='number') event.baseDamage=1;
|
||
"step 1"
|
||
if(event.directHit) event._result={bool:false};
|
||
else{
|
||
var next=target.chooseToRespond({name:'shan'});
|
||
if(event.shanRequired>1){
|
||
next.set('prompt2','共需打出'+event.shanRequired+'张闪');
|
||
}
|
||
next.set('ai',function(card){
|
||
var evt=_status.event.getParent();
|
||
if(get.damageEffect(evt.target,evt.player,evt.target)>=0) return 0;
|
||
if(evt.player.hasSkillTag('notricksource')) return 0;
|
||
if(evt.target.hasSkillTag('notrick')) return 0;
|
||
if(evt.target.hasSkillTag('noShan')){
|
||
return -1;
|
||
}
|
||
return get.order(card);
|
||
});
|
||
next.autochoose=lib.filter.autoRespondShan;
|
||
}
|
||
"step 2"
|
||
if(result.bool==false){
|
||
target.damage();
|
||
}
|
||
else{
|
||
event.shanRequired--;
|
||
if(event.shanRequired>0) event.goto(1);
|
||
}
|
||
},
|
||
ai:{
|
||
wuxie(target, card, player, viewer, status) {
|
||
let att = get.attitude(viewer, target), eff = get.effect(target, card, player, target);
|
||
if (Math.abs(att) < 1 || status * eff * att >= 0) return 0;
|
||
let evt = _status.event.getParent('useCard'), pri = 1, bonus = player.hasSkillTag('damageBonus', true, {
|
||
target: target,
|
||
card: card
|
||
}), damage = 1, isZhu = function (tar) {
|
||
return tar.isZhu || tar === game.boss || tar === game.trueZhu || tar === game.falseZhu;
|
||
}, canShan = function (tar, blur) {
|
||
let known = tar.getKnownCards(viewer);
|
||
if (!blur) return known.some(card => {
|
||
let name = get.name(card, tar);
|
||
return (name === 'shan' || name === 'hufu') && lib.filter.cardRespondable(card, tar);
|
||
});
|
||
if (tar.countCards('hs', i => !known.includes(i)) > 3.67 - 2 * tar.hp / tar.maxHp) return true;
|
||
if (!tar.hasSkillTag('respondShan', true, 'respond', true)) return false;
|
||
if (tar.hp <= damage) return false;
|
||
if (tar.hp <= damage + 1) return isZhu(tar);
|
||
return true;
|
||
}, self = false;
|
||
if (canShan(target)) return 0;
|
||
if (bonus && !viewer.hasSkillTag('filterDamage', null, {
|
||
player: player,
|
||
card: card
|
||
})) damage = 2;
|
||
if ((viewer.hp <= damage || viewer.hp <= damage + 1 && isZhu(viewer)) && !canShan(viewer)) {
|
||
if (viewer === target) return status;
|
||
let fv = true;
|
||
if (evt && evt.targets) for (let i of evt.targets) {
|
||
if (fv) {
|
||
if (target === i) fv = false;
|
||
continue;
|
||
}
|
||
if (viewer == i) {
|
||
if (isZhu(viewer)) return 0;
|
||
self = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
let mayShan = canShan(target, true);
|
||
if (bonus && !target.hasSkillTag('filterDamage', null, {
|
||
player: player,
|
||
card: card
|
||
})) damage = 2;
|
||
else damage = 1;
|
||
if (isZhu(target)) {
|
||
if (eff < 0) {
|
||
if (target.hp <= damage + 1 || !mayShan && target.hp <= damage + 2) return 1;
|
||
if (mayShan && target.hp > damage + 2) return 0;
|
||
else if (mayShan || target.hp > damage + 2) pri = 3;
|
||
else pri = 4;
|
||
}
|
||
else if (target.hp > damage + 1) pri = 2;
|
||
else return 0;
|
||
}
|
||
else if (self) return 0;
|
||
else if (eff < 0) {
|
||
if (!mayShan && target.hp <= damage) pri = 5;
|
||
else if (mayShan) return 0;
|
||
else if (target.hp > damage + 1) pri = 2;
|
||
else if (target.hp === damage + 1) pri = 3;
|
||
else pri = 4;
|
||
}
|
||
else if (target.hp <= damage) return 0;
|
||
let find = false;
|
||
if (evt && evt.targets) for (let i = 0; i < evt.targets.length; i++) {
|
||
if (!find) {
|
||
if (evt.targets[i] === target) find = true;
|
||
continue;
|
||
}
|
||
let att1 = get.attitude(viewer, evt.targets[i]), eff1 = get.effect(evt.targets[i], card, player, evt.targets[i]), temp = 1;
|
||
if (Math.abs(att1) < 1 || att1 * eff1 >= 0 || canShan(evt.targets[i])) continue;
|
||
mayShan = canShan(evt.targets[i], true);
|
||
if (bonus && !evt.targets[i].hasSkillTag('filterDamage', null, {
|
||
player: player,
|
||
card: card
|
||
})) damage = 2;
|
||
else damage = 1;
|
||
if (isZhu(evt.targets[i])) {
|
||
if (eff1 < 0) {
|
||
if (evt.targets[i].hp <= damage + 1 || !mayShan && evt.targets[i].hp <= damage + 2) return 0;
|
||
if (mayShan && evt.targets[i].hp > damage + 2) continue;
|
||
if (mayShan || evt.targets[i].hp > damage + 2) temp = 3;
|
||
else temp = 4;
|
||
}
|
||
else if (evt.targets[i].hp > damage + 1) temp = 2;
|
||
else continue;
|
||
}
|
||
else if (eff1 < 0) {
|
||
if (!mayShan && evt.targets[i].hp <= damage) temp = 5;
|
||
else if (mayShan) continue;
|
||
else if (evt.targets[i].hp > damage + 1) temp = 2;
|
||
else if (evt.targets[i].hp === damage + 1) temp = 3;
|
||
else temp = 4;
|
||
}
|
||
else if (evt.targets[i].hp > damage + 1) temp = 2;
|
||
if (temp > pri) return 0;
|
||
}
|
||
return 1;
|
||
},
|
||
basic: {
|
||
order: 9,
|
||
useful: 1,
|
||
value: 5
|
||
},
|
||
result: {
|
||
player(player, target) {
|
||
if (player._wanjian_temp || player.hasSkillTag('jueqing', false, target)) return 0;
|
||
player._wanjian_temp = true;
|
||
let eff = get.effect(target, new lib.element.VCard({ name: 'wanjian' }), player, target);
|
||
delete player._wanjian_temp;
|
||
if (eff >= 0) return 0;
|
||
if (target.hp > 2 || target.hp > 1 && !target.isZhu && target != game.boss && target != game.trueZhu && target != game.falseZhu) return 0;
|
||
if (target.hp > 1 && target.hasSkillTag('respondShan', true, 'respond', true)) return 0;
|
||
let known = target.getKnownCards(player);
|
||
if (known.some(card => {
|
||
let name = get.name(card, target);
|
||
if (name === 'shan' || name === 'hufu') return lib.filter.cardRespondable(card, target);
|
||
if (name === 'wuxie') return lib.filter.cardEnabled(card, target, 'forceEnable');
|
||
})) return 0;
|
||
if (target.hp > 1 || target.countCards('hs', i => !known.includes(i)) > 3.67 - 2 * target.hp / target.maxHp) return 0;
|
||
let res = 0, att = get.sgnAttitude(player, target);
|
||
res -= att * (0.8 * target.countCards('hs') + 0.6 * target.countCards('e') + 3.6);
|
||
if (get.mode() === 'identity' && target.identity === 'fan') res += 2.4;
|
||
if (get.mode() === 'guozhan' && player.identity !== 'ye' && player.identity === target.identity ||
|
||
get.mode() === 'identity' && player.identity === 'zhu' && (target.identity === 'zhong' || target.identity === 'mingzhong')) res -= 0.8 * player.countCards('he');
|
||
return res;
|
||
},
|
||
target(player, target) {
|
||
let zhu = (get.mode() === 'identity' && target.isZhu) || target.identity === 'zhu';
|
||
if (!lib.filter.cardRespondable({ name: 'shan' }, target)) {
|
||
if (zhu) {
|
||
if (target.hp < 2) return -99;
|
||
if (target.hp === 2) return -3.6;
|
||
}
|
||
return -2;
|
||
}
|
||
let known = target.getKnownCards(player);
|
||
if (known.some(card => {
|
||
let name = get.name(card, target);
|
||
if (name === 'shan' || name === 'hufu') return lib.filter.cardRespondable(card, target);
|
||
if (name === 'wuxie') return lib.filter.cardEnabled(card, target, 'forceEnable');
|
||
})) return -1.2;
|
||
let nh = target.countCards('hs', i => !known.includes(i));
|
||
if (zhu && target.hp <= 1) {
|
||
if (nh === 0) return -99;
|
||
if (nh === 1) return -60;
|
||
if (nh === 2) return -36;
|
||
if (nh === 3) return -8;
|
||
return -5;
|
||
}
|
||
if (target.hasSkillTag('respondShan', true, 'respond', true)) return -1.35;
|
||
if (!nh) return -2;
|
||
if (nh === 1) return -1.65;
|
||
return -1.5;
|
||
}
|
||
},
|
||
tag: {
|
||
respond: 1,
|
||
respondShan: 1,
|
||
damage: 1,
|
||
multitarget: 1,
|
||
multineg: 1
|
||
}
|
||
}
|
||
},
|
||
wuzhong:{
|
||
audio:true,
|
||
fullskin:true,
|
||
type:'trick',
|
||
enable:true,
|
||
selectTarget:-1,
|
||
cardcolor:'red',
|
||
toself:true,
|
||
filterTarget:function(card,player,target){
|
||
return target==player;
|
||
},
|
||
modTarget:true,
|
||
content:function(){
|
||
if(get.is.versus()){
|
||
if(game.friend.includes(target)){
|
||
if(game.friend.length<game.enemy.length){
|
||
target.draw(3);return;
|
||
}
|
||
}
|
||
else{
|
||
if(game.friend.length>game.enemy.length){
|
||
target.draw(3);return;
|
||
}
|
||
}
|
||
}
|
||
target.draw(2);
|
||
},
|
||
ai:{
|
||
wuxie:function(target,card,player,viewer){
|
||
if(get.mode()=='guozhan'){
|
||
if(!_status._aozhan){
|
||
if(!player.isMajor()){
|
||
if(!viewer.isMajor()) return 0;
|
||
}
|
||
}
|
||
}
|
||
},
|
||
basic:{
|
||
order:7.2,
|
||
useful:4.5,
|
||
value:9.2
|
||
},
|
||
result:{
|
||
target:2,
|
||
},
|
||
tag:{
|
||
draw:2
|
||
}
|
||
}
|
||
},
|
||
juedou:{
|
||
audio:true,
|
||
fullskin:true,
|
||
type:'trick',
|
||
enable:true,
|
||
defaultYingbianEffect:'hit',
|
||
filterTarget:function(card,player,target){
|
||
return target!=player;
|
||
},
|
||
content:function(){
|
||
"step 0"
|
||
if(event.turn==undefined) event.turn=target;
|
||
if(typeof event.baseDamage!='number') event.baseDamage=1;
|
||
if(typeof event.extraDamage!='number'){
|
||
event.extraDamage=0;
|
||
}
|
||
if(!event.shaReq) event.shaReq={};
|
||
if(typeof event.shaReq[player.playerid]!='number') event.shaReq[player.playerid]=1;
|
||
if(typeof event.shaReq[target.playerid]!='number') event.shaReq[target.playerid]=1;
|
||
event.playerCards=[];
|
||
event.targetCards=[];
|
||
"step 1"
|
||
event.trigger('juedou');
|
||
event.shaRequired=event.shaReq[event.turn.playerid];
|
||
"step 2"
|
||
if(event.directHit){
|
||
event._result={bool:false};
|
||
}
|
||
else{
|
||
var next=event.turn.chooseToRespond({name:'sha'});
|
||
if(event.shaRequired>1) next.set('prompt2','共需打出'+event.shaRequired+'张杀');
|
||
next.set('ai',function(card){
|
||
let event=_status.event,player=event.splayer,target=event.starget;
|
||
if(player.hasSkillTag('notricksource')||target.hasSkillTag('notrick')) return 0;
|
||
if(event.shaRequired>1&&player.countCards('h','sha')<event.shaRequired) return 0;
|
||
if(event.player===target){
|
||
if(_status.event.tdamage>=0||player.hasSkill('naman')) return -1;
|
||
if(get.attitude(target,player)<=0||event.player.hp<=1&&_status.event.tdamage<_status.event.pdamage){
|
||
return get.order(card);
|
||
}
|
||
return -1;
|
||
}
|
||
else{
|
||
if(_status.event.pdamage>=0||target.hasSkill('naman')) return -1;
|
||
if(get.attitude(player,target)<=0||event.player.hp<=1&&_status.event.tdamage>_status.event.pdamage){
|
||
return get.order(card);
|
||
}
|
||
return -1;
|
||
}
|
||
});
|
||
next.set('splayer',player);
|
||
next.set('starget',target);
|
||
next.set('pdamage',get.damageEffect(player,target,event.turn));
|
||
next.set('tdamage',get.damageEffect(target,player,event.turn));
|
||
next.set('shaRequired',event.shaRequired);
|
||
next.autochoose=lib.filter.autoRespondSha;
|
||
if(event.turn==target){
|
||
next.source=player;
|
||
}
|
||
else{
|
||
next.source=target;
|
||
}
|
||
}
|
||
"step 3"
|
||
if(result.bool){
|
||
event.shaRequired--;
|
||
if(event.turn==target){
|
||
if(result.cards) event.targetCards.addArray(result.cards);
|
||
if(event.shaRequired>0) event.goto(2);
|
||
else{
|
||
event.turn=player;
|
||
event.goto(1);
|
||
}
|
||
}
|
||
else{
|
||
if(result.cards) event.playerCards.addArray(result.cards);
|
||
if(event.shaRequired>0) event.goto(2);
|
||
else{
|
||
event.turn=target;
|
||
event.goto(1);
|
||
}
|
||
}
|
||
}
|
||
else{
|
||
if(event.turn==target){
|
||
target.damage();
|
||
}
|
||
else{
|
||
player.damage(target);
|
||
}
|
||
}
|
||
event._result={};
|
||
},
|
||
ai:{
|
||
wuxie:function(target,card,player,viewer,status){
|
||
if(player===game.me&&get.attitude(viewer,player._trueMe||player)>0) return 0;
|
||
if(status*get.attitude(viewer,target)*get.effect(target,card,player,target)>=0) return 0;
|
||
},
|
||
basic:{
|
||
order:5,
|
||
useful:1,
|
||
value:5.5
|
||
},
|
||
result:{
|
||
player(player, target, card) {
|
||
if (player.hasSkillTag('directHit_ai', true, {
|
||
target: target,
|
||
card: card
|
||
}, true)) return 0;
|
||
if (get.damageEffect(target, player, target) >= 0) return 0;
|
||
let pd = get.damageEffect(player, target, player), att = get.attitude(player, target);
|
||
if (att > 0 && get.damageEffect(target, player, player) > pd) return 0;
|
||
let ts = target.mayHaveSha(player, 'respond', null, 'count'), ps = player.mayHaveSha(player, 'respond', player.getCards('h', i => {
|
||
return card === i || card.cards && card.cards.includes(i) || ui.selected.cards.includes(i);
|
||
}), 'count');
|
||
if (ts < 1 && ts << 3 < Math.pow(player.hp, 2)) return 0;
|
||
if (att > 0) {
|
||
if (ts < 1) return 0;
|
||
return -2;
|
||
}
|
||
if (ts - ps + Math.exp(0.8 - player.hp) < 1) return -ts;
|
||
if (pd >= 0) return pd / get.attitude(player, player);
|
||
return -2 - ts;
|
||
},
|
||
target(player, target, card) {
|
||
if (player.hasSkillTag('directHit_ai', true, {
|
||
target: target,
|
||
card: card
|
||
}, true)) return -2;
|
||
let td = get.damageEffect(target, player, target);
|
||
if (td >= 0) return td / get.attitude(target, target);
|
||
let pd = get.damageEffect(player, target, player), att = get.attitude(player, target);
|
||
if (att > 0 && get.damageEffect(target, player, player) > pd) return -2;
|
||
let ts = target.mayHaveSha(player, 'respond', null, 'count'), ps = player.mayHaveSha(player, 'respond', player.getCards('h', i => {
|
||
return card === i || card.cards && card.cards.includes(i) || ui.selected.cards.includes(i);
|
||
}), 'count');
|
||
if (ts < 1) return -1.5;
|
||
if (att > 0) return -2;
|
||
if (ts - ps < 1) return -2 - ts;
|
||
if (pd >= 0) return -1;
|
||
return -ts;
|
||
}
|
||
},
|
||
tag:{
|
||
respond:2,
|
||
respondSha:2,
|
||
damage:1,
|
||
}
|
||
}
|
||
},
|
||
shunshou:{
|
||
audio:true,
|
||
fullskin:true,
|
||
type:'trick',
|
||
enable:true,
|
||
range:{global:1},
|
||
selectTarget:1,
|
||
postAi:function(targets){
|
||
return targets.length==1&&targets[0].countCards('j');
|
||
},
|
||
filterTarget:function(card,player,target){
|
||
if(player==target) return false;
|
||
return target.hasCard(card=>lib.filter.canBeGained(card,player,target),get.is.single()?'he':'hej');
|
||
},
|
||
content:function(){
|
||
let pos=get.is.single()?'he':'hej';
|
||
if(target.countGainableCards(player,pos)) player.gainPlayerCard(pos, target, true).set('target',target).set("complexSelect",false).set('ai',lib.card.shunshou.ai.button);
|
||
},
|
||
ai:{
|
||
wuxie:function(target,card,player,viewer){
|
||
if(get.attitude(viewer,player._trueMe||player)>0) return 0;
|
||
},
|
||
basic:{
|
||
order:7.5,
|
||
useful:(card,i)=>8/(3+i),
|
||
value:(card,player)=>{
|
||
let max=0;
|
||
game.countPlayer(cur=>{
|
||
max=Math.max(max,lib.card.shunshou.ai.result.target(player,cur)*get.attitude(player,cur));
|
||
});
|
||
if(max<=0) return 2;
|
||
return 0.53*max;
|
||
}
|
||
},
|
||
button:(button)=>{
|
||
let player = _status.event.player, target = _status.event.target;
|
||
if(!lib.filter.canBeGained(button.link,player,target)) return 0;
|
||
let att = get.attitude(player, target),
|
||
val = get.value(button.link,player)/60,
|
||
btv = get.buttonValue(button),
|
||
pos = get.position(button.link),
|
||
name = get.name(button.link);
|
||
if(pos=='j'){
|
||
if(name=='lebu'){
|
||
let needs=target.needsToDiscard(2);
|
||
btv*=1.08+0.2*needs;
|
||
}
|
||
else if(name=='shandian'||name=='fulei'||name=='plague') btv/=2;
|
||
}
|
||
if(get.attitude(player,get.owner(button.link))>0) btv=-btv;
|
||
if(pos!='e'){
|
||
if(pos=='h'&&!player.hasSkillTag('viewHandcard',null,target,true)) return btv+0.1;
|
||
return btv+val;
|
||
}
|
||
let sub = get.subtype(button.link);
|
||
if(sub=='equip1') return btv*Math.min(3.6,target.hp)/3;
|
||
if(sub=='equip2'){
|
||
if(name=='baiyin'&&pos=='e'&&target.isDamaged()){
|
||
let by=3-0.6*Math.min(5,target.hp);
|
||
return get.sgn(get.recoverEffect(target,player,player))*by;
|
||
}
|
||
return 1.57*btv+val;
|
||
}
|
||
if(att<=0&&(sub=='equip3'||sub=='equip4')&&(player.hasSkill('shouli')||player.hasSkill('psshouli'))) return 0;
|
||
if(sub=='equip3'&&!game.hasPlayer((cur)=>!cur.inRange(target)&&get.attitude(cur,target)<0)) return 0.4*btv+val;
|
||
if(sub=='equip4') return btv/2+val;
|
||
return btv+val;
|
||
},
|
||
result:{
|
||
player:function(player,target){
|
||
let att=get.attitude(player,target),
|
||
hs=target.hasCard((card)=>lib.filter.canBeGained(card,player,target),'h'),
|
||
lose=hs,
|
||
gain=att>0?0.52:1.28;
|
||
if(Math.abs(att)<5.03){
|
||
let temp=0.015*att*att;
|
||
if(att<0) gain=0.9+temp;
|
||
else gain=0.9-temp;
|
||
}
|
||
target.countCards('e',function(card){
|
||
if(card.name!='jinhe'&&lib.filter.canBeGained(card,player,target)&&att*get.value(card,target)<0){
|
||
lose=true;
|
||
let val=get.value(card,player);
|
||
if(val>0) gain=Math.max(gain,val/7);
|
||
}
|
||
});
|
||
target.countCards('j',function(card){
|
||
let cardj=card.viewAs?new lib.element.VCard({name:card.viewAs}):card;
|
||
if(lib.filter.canBeGained(card,player,target)&&att*get.effect(target,cardj,target,target)<0){
|
||
lose=true;
|
||
if(cardj.name=='lebu'){
|
||
let needs=target.needsToDiscard(2);
|
||
if(att>0) gain=Math.max(gain,1.6+needs/10);
|
||
}
|
||
else if(cardj.name=='shandian'||cardj.name=='fulei'||cardj.name=='plague') gain=Math.max(gain,1.5/Math.max(1,target.hp));
|
||
else if(att>0) gain=Math.max(gain,1.7);
|
||
}
|
||
});
|
||
if(!lose) return 0;
|
||
return gain;
|
||
},
|
||
target:function(player,target){
|
||
let att=get.attitude(player,target),
|
||
hs=target.countCards('h',(card)=>lib.filter.canBeGained(card,player,target)),
|
||
es=target.countCards('e',(card)=>lib.filter.canBeGained(card,player,target)),
|
||
js=target.countCards('j',(card)=>lib.filter.canBeGained(card,player,target)),
|
||
noh=!hs||target.hasSkillTag('noh'),
|
||
noe=!es||target.hasSkillTag('noe'),
|
||
check=[-1,att>0?-1.3:1.3,att>0?-2.5:2.5],
|
||
idx=-1;
|
||
if(hs){
|
||
idx=0;
|
||
if(noh) check[0]=0.7;
|
||
}
|
||
if(es){
|
||
if(idx<0) idx=1;
|
||
if(target.getEquip('baiyin')&&target.isDamaged()&&lib.filter.canBeGained(target.getEquip('baiyin'),player,target)){
|
||
let rec=get.recoverEffect(target,player,target);
|
||
if(es==1||att*rec>0){
|
||
let val=3-0.6*Math.min(5,target.hp);
|
||
if(rec>0) check[1]=val;
|
||
else if(rec<0) check[1]=-val;
|
||
}
|
||
}
|
||
target.countCards('e',function(card){
|
||
let val=get.value(card,target);
|
||
if(card.name=='jinhe'||att*val>=0||!lib.filter.canBeGained(card,player,target)) return false;
|
||
if(att>0){
|
||
check[1]=Math.max(1.3,check[1]);
|
||
return true;
|
||
}
|
||
let sub=get.subtype(card);
|
||
if(sub=='equip2'||sub=='equip5') val+=4;
|
||
else if(sub=='equip1') val*=0.4*Math.min(3.6,target.hp);
|
||
else val*=0.6;
|
||
if(target.hp<3&&sub!='equip2'&&sub!='equip5') val*=0.4;
|
||
check[1]=Math.min(-0.16*val,check[1]);
|
||
});
|
||
if(noe) check[1]+=0.9;
|
||
}
|
||
if(js){
|
||
let func=function(num){
|
||
if(att>0) check[2]=Math.max(check[2],num);
|
||
else check[2]=Math.min(check[2],0.6-num);
|
||
};
|
||
if(idx<0) idx=2;
|
||
target.countCards('j',function(card){
|
||
let cardj=card.viewAs?new lib.element.VCard({name:card.viewAs}):card;
|
||
if(!lib.filter.canBeGained(card,player,target)||att*get.effect(target,cardj,target,target)>=0) return false;
|
||
if(cardj.name=='lebu') func(2.1+0.4*target.needsToDiscard(2));
|
||
else if(cardj.name=='bingliang') func(2.4);
|
||
else if(cardj.name=='shandian'||cardj.name=='fulei'||cardj.name=='plague') func(Math.abs(check[2])/(1+target.hp));
|
||
else func(2.1);
|
||
});
|
||
}
|
||
if(idx<0) return 0;
|
||
for(let i=idx+1;i<3;i++){
|
||
if(i==1&&!es||i==2&&!js) continue;
|
||
if(att>0&&check[i]>check[idx]||att<=0&&check[i]<check[idx]) idx=i;
|
||
}
|
||
return check[idx];
|
||
}
|
||
},
|
||
tag:{
|
||
loseCard:1,
|
||
gain:1,
|
||
}
|
||
}
|
||
},
|
||
shunshou_copy:{
|
||
ai:{
|
||
basic:{
|
||
order:7.5,
|
||
useful:4,
|
||
value:9
|
||
},
|
||
result:{
|
||
target:function(player,target,card){
|
||
let position='hej';
|
||
if(card&&card.position) position=card.position;
|
||
const hs=position.includes('h')?target.getGainableCards(player,'h'):[];
|
||
const es=position.includes('e')?target.getGainableCards(player,'e'):[];
|
||
const js=position.includes('j')?target.getGainableCards(player,'j'):[];
|
||
if(get.attitude(player,target)<=0){
|
||
if(hs.length>0) return -1.5;
|
||
return (es.some(card=>{
|
||
return get.value(card,target)>0&&card!=target.getEquip('jinhe');
|
||
})||js.some(card=>{
|
||
var cardj=card.viewAs?{name:card.viewAs}:card;
|
||
return get.effect(target,cardj,target,player)<0;
|
||
}))?-1.5:1.5;
|
||
}
|
||
return (es.some(card=>{
|
||
return get.value(card,target)<=0;
|
||
})||js.some(card=>{
|
||
var cardj=card.viewAs?{name:card.viewAs}:card;
|
||
return get.effect(target,cardj,target,player)<0;
|
||
}))?1.5:-1.5;
|
||
},
|
||
player:function(player,target,card){
|
||
let position='hej';
|
||
if(card&&card.position) position=card.position;
|
||
const hs=position.includes('h')?target.getGainableCards(player,'h'):[];
|
||
const es=position.includes('e')?target.getGainableCards(player,'e'):[];
|
||
const js=position.includes('j')?target.getGainableCards(player,'j'):[];
|
||
const att=get.attitude(player,target);
|
||
if(att<0){
|
||
if(!hs.length&&!es.some(card=>{
|
||
return get.value(card,target)>0&&card!=target.getEquip('jinhe');
|
||
})&&!js.some(card=>{
|
||
var cardj=card.viewAs?{name:card.viewAs}:card;
|
||
return get.effect(target,cardj,target,player)<0;
|
||
})) return 0;
|
||
}
|
||
else if(att>1){
|
||
return (es.some(card=>{
|
||
return get.value(card,target)<=0;
|
||
})||js.some(card=>{
|
||
var cardj=card.viewAs?{name:card.viewAs}:card;
|
||
return get.effect(target,cardj,target,player)<0;
|
||
}))?1.5:0;
|
||
}
|
||
return 1;
|
||
}
|
||
},
|
||
tag:{
|
||
loseCard:1,
|
||
gain:1,
|
||
}
|
||
}
|
||
},
|
||
shunshou_copy2:{
|
||
ai:{
|
||
basic:{
|
||
order:7.5,
|
||
useful:4,
|
||
value:9
|
||
},
|
||
result:{
|
||
target:function(player,target,card,isLink){
|
||
return lib.card.shunshou_copy.ai.result.target(player,target,{
|
||
name:'shunshou_copy',
|
||
position:'he',
|
||
},isLink)
|
||
},
|
||
player:function(player,target,card,isLink){
|
||
return lib.card.shunshou_copy.ai.result.player(player,target,{
|
||
name:'shunshou_copy',
|
||
position:'he',
|
||
},isLink)
|
||
}
|
||
},
|
||
tag:{
|
||
loseCard:1,
|
||
gain:1,
|
||
}
|
||
}
|
||
},
|
||
guohe:{
|
||
audio:true,
|
||
fullskin:true,
|
||
type:'trick',
|
||
enable:true,
|
||
selectTarget:1,
|
||
postAi:function(targets){
|
||
return targets.length==1&&targets[0].countCards('j');
|
||
},
|
||
filterTarget:function(card,player,target){
|
||
if(player==target) return false;
|
||
return target.hasCard(card=>lib.filter.canBeDiscarded(card,player,target),get.is.single()?'he':'hej');
|
||
},
|
||
defaultYingbianEffect:'add',
|
||
content:function(){
|
||
'step 0'
|
||
if(get.is.single()){
|
||
let bool1 = target.countDiscardableCards(player, 'h'),
|
||
bool2 = target.countDiscardableCards(player, 'e');
|
||
if(bool1&&bool2) player.chooseControl('手牌区','装备区').set('ai',function(){
|
||
return Math.random() < 0.5 ? 1 : 0;
|
||
}).set('prompt', '弃置'+get.translation(target)+'装备区的一张牌，或观看其手牌并弃置其中的一张牌。');
|
||
else event._result={control:bool1?'手牌区':'装备区'};
|
||
}
|
||
else event._result={control:'所有区域'};
|
||
'step 1'
|
||
let pos, vis='visible';
|
||
if(result.control=='手牌区') pos='h';
|
||
else if(result.control=='装备区') pos='e';
|
||
else{
|
||
pos='hej';
|
||
vis=undefined;
|
||
}
|
||
if(target.countDiscardableCards(player,pos)) player.discardPlayerCard(pos, target, true, vis).set('target',target).set("complexSelect",false).set('ai',lib.card.guohe.ai.button);
|
||
},
|
||
ai:{
|
||
wuxie:(target,card,player,viewer,status)=>{
|
||
if(status*get.attitude(viewer,player._trueMe||player)>0 || target.hp>2&&!target.hasCard(i=>{
|
||
let val=get.value(i,target),subtypes=get.subtypes(i);
|
||
if(val<8&&target.hp<2&&!subtypes.includes('equip2')&&!subtypes.includes('equip5')) return false;
|
||
return val>3+Math.min(5,target.hp);
|
||
},'e')&&target.countCards('h')*_status.event.getRand('guohe_wuxie')>1.57) return 0;
|
||
},
|
||
basic:{
|
||
order:9,
|
||
useful:(card,i)=>10/(3+i),
|
||
value:(card,player)=>{
|
||
let max=0;
|
||
game.countPlayer(cur=>{
|
||
max=Math.max(max,lib.card.guohe.ai.result.target(player,cur)*get.attitude(player,cur));
|
||
});
|
||
if(max<=0) return 5;
|
||
return 0.42*max;
|
||
}
|
||
},
|
||
yingbian:function(card,player,targets,viewer){
|
||
if(get.attitude(viewer,player)<=0) return 0;
|
||
if(game.hasPlayer(function(current){
|
||
return !targets.includes(current)&&lib.filter.targetEnabled2(card,player,current)&&get.effect(current,card,player,player)>0;
|
||
})) return 6;
|
||
return 0;
|
||
},
|
||
button:(button)=>{
|
||
let player = _status.event.player, target = _status.event.target;
|
||
if(!lib.filter.canBeDiscarded(button.link,player,target)) return 0;
|
||
let att = get.attitude(player, target),
|
||
val = get.buttonValue(button),
|
||
pos = get.position(button.link),
|
||
name = get.name(button.link);
|
||
if(pos==='j'){
|
||
if(name==='lebu'){
|
||
let needs=target.needsToDiscard(2);
|
||
val *= 1.08+0.2*needs;
|
||
}
|
||
else if(name=='shandian'||name=='fulei'||name=='plague') val /= 2;
|
||
}
|
||
if(get.attitude(player,get.owner(button.link))>0) val = -val;
|
||
if(pos!=='e') return val;
|
||
let sub = get.subtypes(button.link);
|
||
if(sub.includes('equip1')) return val*Math.min(3.6,target.hp)/3;
|
||
if(sub.includes('equip2')){
|
||
if(name==='baiyin'&&pos==='e'&&target.isDamaged()){
|
||
let by=3-0.6*Math.min(5,target.hp);
|
||
return get.sgn(get.recoverEffect(target,player,player))*by;
|
||
}
|
||
return 1.57*val;
|
||
}
|
||
if(att<=0&&(sub.includes('equip3')||sub.includes('equip4'))&&(player.hasSkill('shouli')||player.hasSkill('psshouli'))) return 0;
|
||
if(sub.includes('equip6')) return val;
|
||
if(sub.includes('equip4')) return val/2;
|
||
if(sub.includes('equip3')&&!game.hasPlayer((cur)=>{
|
||
return !cur.inRange(target)&&get.attitude(cur,target)<0;
|
||
})) return 0.4*val;
|
||
return val;
|
||
},
|
||
result:{
|
||
target:function(player,target){
|
||
let att=get.attitude(player, target),
|
||
hs=target.countCards('h',(card)=>lib.filter.canBeDiscarded(card,player,target)),
|
||
es=target.countCards('e',(card)=>lib.filter.canBeDiscarded(card,player,target)),
|
||
js=target.countCards('j',(card)=>lib.filter.canBeDiscarded(card,player,target)),
|
||
noh=!hs||target.hasSkillTag('noh'),
|
||
noe=!es||target.hasSkillTag('noe'),
|
||
check=[-1,att>0?-1.3:1.3,att>0?-2.5:2.5],
|
||
idx=-1;
|
||
if(hs){
|
||
idx=0;
|
||
if(noh) check[0]=0.7;
|
||
}
|
||
if(es){
|
||
if(idx<0) idx=1;
|
||
if(target.getEquip('baiyin')&&target.isDamaged()&&lib.filter.canBeDiscarded(target.getEquip('baiyin'),player,target)){
|
||
let rec=get.recoverEffect(target,player,target);
|
||
if(es==1||att*rec>0){
|
||
let val=3-0.6*Math.min(5,target.hp);
|
||
if(rec>0) check[1]=val;
|
||
else if(rec<0) check[1]=-val;
|
||
}
|
||
}
|
||
target.countCards('e',function(card){
|
||
let val=get.value(card,target);
|
||
if(card.name=='jinhe'||att*val>=0||!lib.filter.canBeDiscarded(card,player,target)) return false;
|
||
if(att>0){
|
||
check[1]=Math.max(1.3,check[1]);
|
||
return true;
|
||
}
|
||
let sub=get.subtype(card);
|
||
if(sub=='equip2'||sub=='equip5') val+=4;
|
||
else if(sub=='equip1') val*=0.4*Math.min(3.6,target.hp);
|
||
else val*=0.6;
|
||
if(target.hp<3&&sub!='equip2'&&sub!='equip5') val*=0.4;
|
||
check[1]=Math.min(-0.16*val,check[1]);
|
||
});
|
||
if(noe) check[1]+=0.9;
|
||
}
|
||
if(js){
|
||
let func=function(num){
|
||
if(att>0) check[2]=Math.max(check[2],num);
|
||
else check[2]=Math.min(check[2],0.6-num);
|
||
};
|
||
if(idx<0) idx=2;
|
||
target.countCards('j',function(card){
|
||
let cardj=card.viewAs?new lib.element.VCard({name:card.viewAs}):card;
|
||
if(!lib.filter.canBeDiscarded(card,player,target)||att*get.effect(target,cardj,target,target)>=0) return false;
|
||
if(cardj.name=='lebu') func(2.1+0.4*target.needsToDiscard(2));
|
||
else if(cardj.name=='bingliang') func(2.4);
|
||
else if(cardj.name=='shandian'||cardj.name=='fulei'||cardj.name=='plague') func(Math.abs(check[2])/(1+target.hp));
|
||
else func(2.1);
|
||
});
|
||
}
|
||
if(idx<0) return 0;
|
||
for(let i=idx+1;i<3;i++){
|
||
if(i==1&&!es||i==2&&!js) continue;
|
||
if(att>0&&check[i]>check[idx]||att<=0&&check[i]<check[idx]) idx=i;
|
||
}
|
||
return check[idx];
|
||
},
|
||
},
|
||
tag:{
|
||
loseCard:1,
|
||
discard:1
|
||
}
|
||
}
|
||
},
|
||
guohe_copy:{
|
||
ai:{
|
||
basic:{
|
||
order:9,
|
||
useful:5,
|
||
value:5,
|
||
},
|
||
result:{
|
||
target:function(player,target,card){
|
||
let position='hej';
|
||
if(card&&card.position) position=card.position;
|
||
const att=get.attitude(player,target);
|
||
const hs=position.includes('h')?target.getDiscardableCards(player,'h'):[];
|
||
const es=position.includes('e')?target.getDiscardableCards(player,'e'):[];
|
||
const js=position.includes('j')?target.getDiscardableCards(player,'j'):[];
|
||
if(!hs.length&&!es.length&&!js.length) return 0;
|
||
if(att>0){
|
||
if(js.some(card=>{
|
||
const cardj=card.viewAs?{name:card.viewAs}:card;
|
||
return get.effect(target,cardj,target,player)<0;
|
||
})) return 3;
|
||
if(target.isDamaged()&&es.some(card=>card.name=='baiyin')&&
|
||
get.recoverEffect(target,player,player)>0){
|
||
if(target.hp==1&&!target.hujia) return 1.6;
|
||
}
|
||
if(es.some(card=>{
|
||
return get.value(card,target)<0;
|
||
})) return 1;
|
||
return -1.5;
|
||
}
|
||
else{
|
||
const noh=(hs.length==0||target.hasSkillTag('noh'));
|
||
const noe=(es.length==0||target.hasSkillTag('noe'));
|
||
const noe2=(noe||!es.some(card=>{
|
||
return get.value(card,target)>0;
|
||
}));
|
||
const noj=(js.length==0||!js.some(card=>{
|
||
const cardj=card.viewAs?{name:card.viewAs}:card;
|
||
return get.effect(target,cardj,target,player)<0;
|
||
}))
|
||
if(noh&&noe2&&noj) return 1.5;
|
||
return -1.5;
|
||
}
|
||
},
|
||
},
|
||
tag:{
|
||
loseCard:1,
|
||
discard:1
|
||
}
|
||
}
|
||
},
|
||
guohe_copy2:{
|
||
ai:{
|
||
basic:{
|
||
order:9,
|
||
useful:5,
|
||
value:5,
|
||
},
|
||
result:{
|
||
target:function(player,target,card,isLink){
|
||
return lib.card.guohe_copy.ai.result.target(player,target,{
|
||
name:'guohe_copy',
|
||
position:'he',
|
||
},isLink)
|
||
},
|
||
},
|
||
tag:{
|
||
loseCard:1,
|
||
discard:1
|
||
}
|
||
}
|
||
},
|
||
jiedao:{
|
||
audio:true,
|
||
fullskin:true,
|
||
type:'trick',
|
||
enable:true,
|
||
singleCard:true,
|
||
targetprompt:['被借刀','出杀目标'],
|
||
complexSelect:true,
|
||
complexTarget:true,
|
||
multicheck:function(){
|
||
var card={name:'sha',isCard:true};
|
||
return game.hasPlayer(function(current){
|
||
if(current.getEquips(1).length>0){
|
||
return game.hasPlayer(function(current2){
|
||
return current.inRange(current2)&&lib.filter.targetEnabled(card,current,current2);
|
||
})
|
||
}
|
||
});
|
||
},
|
||
filterTarget:function(card,player,target){
|
||
var card={name:'sha',isCard:true};
|
||
return player!=target&&target.getEquips(1).length>0&&game.hasPlayer(function(current){
|
||
return target!=current&&target.inRange(current)&&lib.filter.targetEnabled(card,target,current);
|
||
});
|
||
},
|
||
filterAddedTarget:function(card,player,target,preTarget){
|
||
var card={name:'sha',isCard:true};
|
||
return target!=preTarget&&preTarget.inRange(target)&&lib.filter.targetEnabled(card,preTarget,target);
|
||
},
|
||
content:function(){
|
||
"step 0"
|
||
if(event.directHit||!event.addedTarget||(!_status.connectMode&&lib.config.skip_shan&&!target.hasSha())){
|
||
event.directfalse=true;
|
||
}
|
||
else{
|
||
target.chooseToUse('对'+get.translation(event.addedTarget)+'使用一张杀，或令'+get.translation(player)+'获得你的武器牌',function(card,player){
|
||
if(get.name(card)!='sha') return false;
|
||
return lib.filter.filterCard.apply(this,arguments);
|
||
}).set('targetRequired',true).set('complexSelect',true).set('filterTarget',function(card,player,target){
|
||
if(target!=_status.event.sourcex&&!ui.selected.targets.includes(_status.event.sourcex)) return false;
|
||
return lib.filter.filterTarget.apply(this,arguments);
|
||
}).set('sourcex',event.addedTarget).set('addCount',false).set('respondTo',[player,card]);
|
||
}
|
||
"step 1"
|
||
if(event.directfalse||result.bool==false){
|
||
var cards=target.getEquips(1);
|
||
if(cards.length) player.gain(cards,target,'give','bySelf');
|
||
}
|
||
},
|
||
ai:{
|
||
wuxie:function(target,card,player,viewer){
|
||
if(player==game.me&&get.attitude(viewer,player._trueMe||player)>0) return 0;
|
||
},
|
||
basic:{
|
||
order:8,
|
||
value:2,
|
||
useful:1,
|
||
},
|
||
result:{
|
||
player:(player,target)=>{
|
||
if(!target.hasSkillTag('noe')&&get.attitude(player,target)>0) return 0;
|
||
return (player.hasSkillTag('noe')?0.32:0.15)*target.getEquips(1).reduce((num,i)=>{
|
||
return num+get.value(i,player);
|
||
},0);
|
||
},
|
||
target:(player,target,card)=>{
|
||
let targets=[].concat(ui.selected.targets);
|
||
if(_status.event.preTarget) targets.add(_status.event.preTarget);
|
||
if(targets.length){
|
||
let preTarget=targets.lastItem,pre=_status.event.getTempCache('jiedao_result',preTarget.playerid);
|
||
if(pre&&pre.card===card&&pre.target.isIn()) return target===pre.target?pre.eff:0;
|
||
return get.effect(target,{name:'sha'},preTarget,player)/get.attitude(player,target);
|
||
}
|
||
let arms=(target.hasSkillTag('noe')?0.32:-0.15)*target.getEquips(1).reduce((num,i)=>{
|
||
return num+get.value(i,target);
|
||
},0);
|
||
if(!target.mayHaveSha(player,'use')) return arms;
|
||
let sha=game.filterPlayer(get.info({name:'jiedao'}).filterAddedTarget),addTar=null;
|
||
sha=sha.reduce((num,current)=>{
|
||
let eff=get.effect(current,{name:'sha'},target,player);
|
||
if(eff<=num) return num;
|
||
addTar=current;
|
||
return eff;
|
||
},-100);
|
||
if(!addTar) return arms;
|
||
sha/=get.attitude(player,target);
|
||
_status.event.putTempCache('jiedao_result',target.playerid,{
|
||
card:card,
|
||
target:addTar,
|
||
eff:sha
|
||
});
|
||
return Math.max(arms,sha);
|
||
}
|
||
},
|
||
tag:{
|
||
gain:1,
|
||
use:1,
|
||
useSha:1,
|
||
loseCard:1,
|
||
}
|
||
}
|
||
},
|
||
wuxie:{
|
||
audio:true,
|
||
fullskin:true,
|
||
type:'trick',
|
||
ai:{
|
||
basic:{
|
||
useful:[6,4,3],
|
||
value:[6,4,3],
|
||
},
|
||
result:{player:1},
|
||
expose:0.2
|
||
},
|
||
notarget:true,
|
||
finalDelay:false,
|
||
defaultYingbianEffect:'draw',
|
||
contentBefore:function(){
|
||
'step 0'
|
||
if(get.mode()=='guozhan'&&get.cardtag(card,'guo')){
|
||
var trigger=event.getParent(2)._trigger;
|
||
if(trigger.name!='phaseJudge'&&trigger.card.name!='wuxie'&&trigger.targets.length>1){
|
||
player.chooseControl('对单体使用','对势力使用').set('prompt','请选择'+get.translation(card)+'的使用方式').set('ai',function(){
|
||
return '对势力使用'
|
||
});
|
||
}
|
||
else event.finish();
|
||
}
|
||
else event.finish();
|
||
'step 1'
|
||
if(result.control=='对势力使用'){
|
||
player.chat('对势力使用');
|
||
event.getParent().guowuxie=true;
|
||
}
|
||
},
|
||
content:function(){
|
||
var trigger=event.getParent(2)._trigger;
|
||
if(trigger.name=='phaseJudge'){
|
||
trigger.untrigger('currentOnly');
|
||
trigger.cancelled=true;
|
||
}
|
||
else{
|
||
trigger.neutralize();
|
||
if(event.getParent().guowuxie==true){
|
||
trigger.getParent().excluded.addArray(game.filterPlayer(function(current){
|
||
return current.isFriendOf(trigger.target);
|
||
}));
|
||
}
|
||
}
|
||
/*
|
||
event.result={
|
||
wuxied:true,
|
||
directHit:evt.directHit||[],
|
||
nowuxie:evt.nowuxie,
|
||
};*/
|
||
if(player.isOnline()){
|
||
player.send(function(player){
|
||
if(ui.tempnowuxie&&!player.hasWuxie()){
|
||
ui.tempnowuxie.close();
|
||
delete ui.tempnowuxie;
|
||
}
|
||
},player);
|
||
}
|
||
else if(player==game.me){
|
||
if(ui.tempnowuxie&&!player.hasWuxie()){
|
||
ui.tempnowuxie.close();
|
||
delete ui.tempnowuxie;
|
||
}
|
||
}
|
||
}
|
||
},
|
||
lebu:{
|
||
audio:true,
|
||
fullskin:true,
|
||
type:'delay',
|
||
filterTarget:function(card,player,target){
|
||
return (lib.filter.judge(card,player,target)&&player!=target);
|
||
},
|
||
judge:function(card){
|
||
if(get.suit(card)=='heart') return 1;
|
||
return -2;
|
||
},
|
||
judge2:function(result){
|
||
if(result.bool==false) return true;
|
||
return false;
|
||
},
|
||
effect:function(){
|
||
if(result.bool==false){
|
||
player.skip('phaseUse');
|
||
}
|
||
},
|
||
ai:{
|
||
basic:{
|
||
order:1,
|
||
useful:1,
|
||
value:8,
|
||
},
|
||
result:{
|
||
ignoreStatus:true,
|
||
target:(player,target)=>{
|
||
if(target===_status.currentPhase&&target.skipList.includes('phaseUse')){
|
||
let evt=_status.event.getParent('phase');
|
||
if(evt&&evt.phaseList.indexOf('phaseJudge')<=evt.num) return 0;
|
||
}
|
||
let num=target.needsToDiscard(3),cf=Math.pow(get.threaten(target,player),2);
|
||
if(!num) return -0.01*cf;
|
||
if(target.hp>2) num--;
|
||
let dist=Math.sqrt(get.distance(player,target,'absolute'));
|
||
if(dist<1) dist=1;
|
||
if(target.isTurnedOver()) dist++;
|
||
return Math.min(-0.1,-num)*cf/dist;
|
||
}
|
||
},
|
||
tag:{
|
||
skip:'phaseUse'
|
||
}
|
||
}
|
||
},
|
||
shandian:{
|
||
audio:true,
|
||
fullskin:true,
|
||
type:'delay',
|
||
cardnature:'thunder',
|
||
modTarget:function(card,player,target){
|
||
return lib.filter.judge(card,player,target);
|
||
},
|
||
enable:function(card,player){
|
||
return player.canAddJudge(card);
|
||
},
|
||
filterTarget:function(card,player,target){
|
||
return (lib.filter.judge(card,player,target)&&player==target);
|
||
},
|
||
selectTarget:[-1,-1],
|
||
toself:true,
|
||
judge:function(card){
|
||
if(get.suit(card)=='spade'&&get.number(card)>1&&get.number(card)<10) return -5;
|
||
return 1;
|
||
},
|
||
judge2:function(result){
|
||
if(result.bool==false) return true;
|
||
return false;
|
||
},
|
||
effect:function(){
|
||
if(result.bool==false){
|
||
player.damage(3,'thunder','nosource');
|
||
}
|
||
else{
|
||
player.addJudgeNext(card);
|
||
}
|
||
},
|
||
cancel:function(){
|
||
player.addJudgeNext(card);
|
||
},
|
||
ai:{
|
||
basic:{
|
||
order:1,
|
||
useful:0,
|
||
value:0,
|
||
},
|
||
result:{
|
||
target:function(player,target){
|
||
var num=game.countPlayer(function(current){
|
||
//var skills=current.getSkills();
|
||
for(var j=0;j<current.skills.length;j++){
|
||
var rejudge=get.tag(current.skills[j],'rejudge',current);
|
||
if(rejudge!=undefined){
|
||
if(get.attitude(target,current)>0&&
|
||
get.attitude(current,target)>0){
|
||
return rejudge;
|
||
}
|
||
else{
|
||
return -rejudge;
|
||
}
|
||
}
|
||
}
|
||
});
|
||
if(num>0) return num;
|
||
if(num==0){
|
||
var mode=get.mode();
|
||
if(mode=='identity'){
|
||
if(target.identity=='nei') return 1;
|
||
var situ=get.situation();
|
||
if(target.identity=='fan'){
|
||
if(situ>1) return 1;
|
||
}
|
||
else{
|
||
if(situ<-1) return 1;
|
||
}
|
||
}
|
||
else if(mode=='guozhan'){
|
||
if(target.identity=='ye') return 1;
|
||
if(game.hasPlayer(function(current){
|
||
return current.identity=='unknown';
|
||
})){
|
||
return -1;
|
||
}
|
||
if(get.population(target.identity)==1){
|
||
if(target.maxHp>2&&target.hp<2) return 1;
|
||
if(game.countPlayer()<3) return -1;
|
||
if(target.hp<=2&&target.countCards('he')<=3) return 1;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
},
|
||
tag:{
|
||
damage:0.16,
|
||
natureDamage:0.16,
|
||
thunderDamage:0.16,
|
||
}
|
||
}
|
||
},
|
||
hanbing:{
|
||
fullskin:true,
|
||
type:"equip",
|
||
subtype:"equip1",
|
||
distance:{attackFrom:-1},
|
||
skills:['hanbing_skill'],
|
||
ai:{
|
||
basic:{
|
||
equipValue:2
|
||
}
|
||
},
|
||
},
|
||
renwang:{
|
||
fullskin:true,
|
||
type:"equip",
|
||
subtype:"equip2",
|
||
skills:['renwang_skill'],
|
||
ai:{
|
||
basic:{
|
||
equipValue:7.5
|
||
},
|
||
},
|
||
},
|
||
},
|
||
skill:{
|
||
qinglong_guozhan:{
|
||
equipSkill:true,
|
||
trigger:{player:'useCard'},
|
||
forced:true,
|
||
audio:'qinglong_skill',
|
||
filter:function(event,player){
|
||
return get.mode()=='guozhan'&&event.card.name=='sha';
|
||
},
|
||
content:function(){
|
||
if(!_status.qinglong_guozhan) _status.qinglong_guozhan=[];
|
||
_status.qinglong_guozhan.add(trigger);
|
||
game.countPlayer2(function(current){
|
||
current.addTempSkill('qinglong_guozhan_mingzhi');
|
||
});
|
||
game.broadcast(function(list){
|
||
_status.qinglong_guozhan=list;
|
||
},_status.qinglong_guozhan.map(function(i){
|
||
return {targets:i.targets};
|
||
}))
|
||
var next=game.createEvent('qinglong_guozhan');
|
||
event.next.remove(next);
|
||
trigger.after.add(next);
|
||
next.setContent(function(){
|
||
_status.qinglong_guozhan.remove(event.parent);
|
||
game.broadcast(function(list){
|
||
_status.qinglong_guozhan=list;
|
||
},_status.qinglong_guozhan.map(function(i){
|
||
return {targets:i.targets};
|
||
}));
|
||
});
|
||
}
|
||
},
|
||
qinglong_guozhan_mingzhi:{
|
||
ai:{
|
||
nomingzhi:true,
|
||
skillTagFilter:function(player){
|
||
if(_status.qinglong_guozhan){
|
||
for(var i=0;i<_status.qinglong_guozhan.length;i++){
|
||
if(_status.qinglong_guozhan[i].targets.includes(player)) return true;
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
}
|
||
},
|
||
hanbing_skill:{
|
||
equipSkill:true,
|
||
trigger:{source:'damageBegin2'},
|
||
//direct:true,
|
||
audio:true,
|
||
filter:function(event){
|
||
return event.card&&event.card.name=='sha'&&event.notLink()&&event.player.getCards('he').length>0;
|
||
},
|
||
//priority:1,
|
||
check:function(event,player){
|
||
var target=event.player;
|
||
var eff=get.damageEffect(target,player,player,event.nature);
|
||
if(get.attitude(player,target)>0){
|
||
if(eff>=0) return false;
|
||
return true;
|
||
}
|
||
if(eff<=0) return true;
|
||
if(target.hp==1) return false;
|
||
if(event.num>1||player.hasSkill('tianxianjiu')||
|
||
player.hasSkill('luoyi2')||player.hasSkill('reluoyi2')) return false;
|
||
if(target.countCards('he')<2) return false;
|
||
var num=0;
|
||
var cards=target.getCards('he');
|
||
for(var i=0;i<cards.length;i++){
|
||
if(get.value(cards[i])>6) num++;
|
||
}
|
||
if(num>=2) return true;
|
||
return false;
|
||
},
|
||
logTarget:"player",
|
||
content:function(){
|
||
"step 0"
|
||
trigger.cancel();
|
||
"step 1"
|
||
if(trigger.player.countDiscardableCards(player,'he')){
|
||
player.line(trigger.player);
|
||
player.discardPlayerCard('he',trigger.player,true);
|
||
}
|
||
"step 2"
|
||
if(trigger.player.countDiscardableCards(player,'he')){
|
||
player.line(trigger.player);
|
||
player.discardPlayerCard('he',trigger.player,true);
|
||
}
|
||
}
|
||
},
|
||
icesha_skill:{
|
||
inherit:'hanbing_skill',
|
||
trigger:{source:'damageBegin3'},
|
||
equipSkill:false,
|
||
ruleSkill:true,
|
||
filter:function(event){
|
||
return event.hasNature('ice')&&event.notLink()&&event.player.getCards('he').length>0;
|
||
},
|
||
},
|
||
renwang_skill:{
|
||
equipSkill:true,
|
||
trigger:{target:'shaBegin'},
|
||
forced:true,
|
||
priority:6,
|
||
audio:true,
|
||
filter:function(event,player){
|
||
if(player.hasSkillTag('unequip2')) return false;
|
||
if(event.player.hasSkillTag('unequip',false,{
|
||
name:event.card?event.card.name:null,
|
||
target:player,
|
||
card:event.card
|
||
})) return false;
|
||
return (event.card.name=='sha'&&get.color(event.card)=='black')
|
||
},
|
||
content:function(){
|
||
trigger.cancel();
|
||
},
|
||
ai:{
|
||
effect:{
|
||
target:function(card,player,target){
|
||
if(typeof card!=='object'||target.hasSkillTag('unequip2')) return;
|
||
if(player.hasSkillTag('unequip',false,{
|
||
name:card?card.name:null,
|
||
target:target,
|
||
card:card
|
||
})||player.hasSkillTag('unequip_ai',false,{
|
||
name:card?card.name:null,
|
||
target:target,
|
||
card:card
|
||
})) return;
|
||
if(card.name=='sha'&&get.color(card)=='black') return 'zeroplayertarget';
|
||
}
|
||
}
|
||
}
|
||
},
|
||
zhuge_skill:{
|
||
equipSkill:true,
|
||
audio:true,
|
||
firstDo:true,
|
||
trigger:{player:'useCard1'},
|
||
forced:true,
|
||
filter:function(event,player){
|
||
return !event.audioed&&event.card.name=='sha'&&player.countUsed('sha',true)>1&&event.getParent().type=='phase';
|
||
},
|
||
content:function(){
|
||
trigger.audioed=true;
|
||
},
|
||
mod:{
|
||
cardUsable:function(card,player,num){
|
||
var cards=player.getEquips('zhuge')
|
||
if(card.name=='sha'){
|
||
if(!cards.length||player.hasSkill('zhuge_skill',null,false)||cards.some(card=>(card!=_status.zhuge_temp&&!ui.selected.cards.includes(card)))){
|
||
if(get.is.versus()||get.is.changban()){
|
||
return num+3;
|
||
}
|
||
return Infinity;
|
||
}
|
||
}
|
||
},
|
||
cardEnabled2:function(card,player){
|
||
if(!_status.event.addCount_extra||player.hasSkill('zhuge_skill',null,false)) return;
|
||
var cards=player.getEquips('zhuge');
|
||
if(card&&cards.includes(card)){
|
||
try{
|
||
var cardz=get.card();
|
||
}
|
||
catch(e){
|
||
return;
|
||
}
|
||
if(!cardz||cardz.name!='sha') return;
|
||
_status.zhuge_temp=card;
|
||
var bool=lib.filter.cardUsable(get.autoViewAs({name:'sha'},ui.selected.cards.concat([card])),player);
|
||
delete _status.zhuge_temp;
|
||
if(!bool) return false;
|
||
}
|
||
},
|
||
},
|
||
},
|
||
cixiong_skill:{
|
||
equipSkill:true,
|
||
trigger:{player:'useCardToPlayered'},
|
||
audio:true,
|
||
logTarget:'target',
|
||
check:function(event,player){
|
||
if(get.attitude(player,event.target)>0) return true;
|
||
var target=event.target;
|
||
return target.countCards('h')==0||!target.hasSkillTag('noh');
|
||
},
|
||
filter:function(event,player){
|
||
if(event.card.name!='sha') return false;
|
||
return player.differentSexFrom(event.target);
|
||
},
|
||
content:function(){
|
||
"step 0"
|
||
if(!trigger.target.countCards('h')) event._result={bool:false};
|
||
else trigger.target.chooseToDiscard('弃置一张手牌，或令'+get.translation(player)+'摸一张牌').set('ai',function(card){
|
||
var trigger=_status.event.getTrigger();
|
||
return -get.attitude(trigger.target,trigger.player)-get.value(card)-Math.max(0,4-trigger.target.hp)*2;
|
||
});
|
||
"step 1"
|
||
if(result.bool==false) player.draw();
|
||
}
|
||
},
|
||
qinggang_skill:{
|
||
equipSkill:true,
|
||
audio:true,
|
||
trigger:{
|
||
player:'useCardToPlayered',
|
||
},
|
||
filter:function(event){
|
||
return event.card.name=='sha';
|
||
},
|
||
forced:true,
|
||
logTarget:'target',
|
||
content:function(){
|
||
trigger.target.addTempSkill('qinggang2');
|
||
trigger.target.storage.qinggang2.add(trigger.card);
|
||
trigger.target.markSkill('qinggang2');
|
||
},
|
||
ai:{
|
||
unequip_ai:true,
|
||
skillTagFilter:function(player,tag,arg){
|
||
if(arg&&arg.name=='sha') return true;
|
||
return false;
|
||
}
|
||
}
|
||
},
|
||
qinggang2:{
|
||
firstDo:true,
|
||
ai:{unequip2:true},
|
||
init:function(player,skill){
|
||
if(!player.storage[skill]) player.storage[skill]=[];
|
||
},
|
||
onremove:true,
|
||
trigger:{
|
||
player:['damage','damageCancelled','damageZero'],
|
||
source:['damage','damageCancelled','damageZero'],
|
||
target:['shaMiss','useCardToExcluded','useCardToEnd','eventNeutralized'],
|
||
global:['useCardEnd'],
|
||
},
|
||
charlotte:true,
|
||
filter:function(event,player){
|
||
return player.storage.qinggang2&&event.card&&player.storage.qinggang2.includes(event.card)&&(event.name!='damage'||event.notLink());
|
||
},
|
||
silent:true,
|
||
forced:true,
|
||
popup:false,
|
||
priority:12,
|
||
content:function(){
|
||
player.storage.qinggang2.remove(trigger.card);
|
||
if(!player.storage.qinggang2.length) player.removeSkill('qinggang2');
|
||
},
|
||
marktext:'※',
|
||
intro:{content:'当前防具技能已失效'},
|
||
},
|
||
qinglong_skill:{
|
||
equipSkill:true,
|
||
trigger:{player:['shaMiss','eventNeutralized']},
|
||
direct:true,
|
||
filter:function(event,player){
|
||
if(get.mode()=='guozhan'||!event.card||event.card.name!='sha') return false;
|
||
return event.target.isIn()&&player.canUse('sha',event.target,false)&&(player.hasSha()||_status.connectMode&&player.countCards('hs'));
|
||
},
|
||
content:function(){
|
||
"step 0"
|
||
player.chooseToUse(get.prompt('qinglong',trigger.target),function(card,player,event){
|
||
if(get.name(card)!='sha') return false;
|
||
if(!player.hasSkill('qinglong_skill',null,false)){
|
||
var cards=player.getEquips('qinglong');
|
||
if(!cards.some(card2=>card2!=card&&!ui.selected.cards.includes(card2))) return false;
|
||
}
|
||
return lib.filter.filterCard.apply(this,arguments);
|
||
},trigger.target,-1).set('addCount',false).logSkill='qinglong_skill';
|
||
}
|
||
},
|
||
zhangba_skill:{
|
||
equipSkill:true,
|
||
enable:['chooseToUse','chooseToRespond'],
|
||
filterCard:true,
|
||
selectCard:2,
|
||
position:'hs',
|
||
viewAs:{name:'sha'},
|
||
complexCard:true,
|
||
filter:function(event,player){
|
||
return player.countCards('hs')>=2;
|
||
},
|
||
audio:true,
|
||
prompt:'将两张手牌当杀使用或打出',
|
||
check:function(card){
|
||
let player=_status.event.player;
|
||
if(player.hasCard(function(card){
|
||
return get.name(card)=='sha';
|
||
})) return 0;
|
||
if(_status.event&&_status.event.name=='chooseToRespond'&&player.hp<3&&!player.countCards('hs',function(card){
|
||
return get.name(card)!='tao'&&get.name(card)!='jiu';
|
||
})) return (player.hp>1?10:8)-get.value(card);
|
||
return Math.max(5,8-0.7*player.hp)-get.value(card);
|
||
},
|
||
ai:{
|
||
respondSha:true,
|
||
skillTagFilter:function(player){
|
||
return player.countCards('hs')>=2;
|
||
},
|
||
}
|
||
},
|
||
guanshi_skill:{
|
||
equipSkill:true,
|
||
trigger:{
|
||
player:['shaMiss','eventNeutralized'],
|
||
},
|
||
direct:true,
|
||
audio:true,
|
||
filter:function(event,player){
|
||
if(event.type!='card'||event.card.name!='sha'||!event.target.isIn()) return false;
|
||
var min=2;
|
||
if(!player.hasSkill('guanshi_skill',null,false)) min+=get.sgn(player.getEquips('guanshi').length)
|
||
return player.countCards('he')>=min;
|
||
},
|
||
content:function(){
|
||
"step 0"
|
||
//装备区内可能有多个贯石斧 或者玩家可能通过其他渠道获得贯石斧技能 只要留一张贯石斧不扔掉即可
|
||
var next=player.chooseToDiscard(get.prompt('guanshi'),2,'he',function(card,player){
|
||
if(_status.event.ignoreCard) return true;
|
||
var cards=player.getEquips('guanshi');
|
||
if(!cards.includes(card)) return true;
|
||
return cards.some(cardx=>(cardx!=card&&!ui.selected.cards.includes(cardx)));
|
||
}).set('ignoreCard',player.hasSkill('guanshi_skill',null,false)).set('complexCard',true)
|
||
next.logSkill='guanshi_skill';
|
||
next.set('ai',function(card){
|
||
var evt=_status.event.getTrigger();
|
||
if(get.attitude(evt.player,evt.target)<0){
|
||
if(evt.player.needsToDiscard()) return 15-get.value(card);
|
||
if(evt.baseDamage+evt.extraDamage>=Math.min(2,evt.target.hp)) return 8-get.value(card);
|
||
return 5-get.value(card);
|
||
}
|
||
return -1;
|
||
});
|
||
"step 1"
|
||
if(result.bool){
|
||
if(event.triggername=='shaMiss'){
|
||
trigger.untrigger();
|
||
trigger.trigger('shaHit');
|
||
trigger._result.bool=false;
|
||
trigger._result.result=null;
|
||
}
|
||
else{
|
||
trigger.unneutralize();
|
||
}
|
||
}
|
||
},
|
||
ai:{
|
||
directHit_ai:true,
|
||
skillTagFilter:function(player,tag,arg){
|
||
if(player._guanshi_temp) return;
|
||
player._guanshi_temp=true;
|
||
var bool=(get.attitude(player,arg.target)<0&&arg.card&&arg.card.name=='sha'&&player.countCards('he',function(card){
|
||
return card!=player.getEquip('guanshi')&&card!=arg.card&&(!arg.card.cards||!arg.card.cards.includes(card))&&get.value(card)<5;
|
||
})>1);
|
||
delete player._guanshi_temp;
|
||
return bool;
|
||
},
|
||
},
|
||
},
|
||
fangtian_skill:{
|
||
equipSkill:true,
|
||
audio:true,
|
||
trigger:{player:'useCard1'},
|
||
forced:true,
|
||
firstDo:true,
|
||
filter:function(event,player){
|
||
if(event.card.name!='sha'||get.mode()=='guozhan') return false;
|
||
var card=event.card;
|
||
var range;
|
||
var select=get.copy(get.info(card).selectTarget);
|
||
if(select==undefined){
|
||
if(get.info(card).filterTarget==undefined) return false;
|
||
range=[1,1];
|
||
}
|
||
else if(typeof select=='number') range=[select,select];
|
||
else if(get.itemtype(select)=='select') range=select;
|
||
else if(typeof select=='function') range=select(card,player);
|
||
game.checkMod(card,player,range,'selectTarget',player);
|
||
return range[1]!=-1&&event.targets.length>range[1];
|
||
},
|
||
content:function(){},
|
||
mod:{
|
||
selectTarget:function(card,player,range){
|
||
if(card.name!='sha') return;
|
||
if(get.mode()=='guozhan') return;
|
||
if(range[1]==-1) return;
|
||
var cards=player.getCards('h');
|
||
if(!cards.length) return;
|
||
for(var i=0;i<cards.length;i++){
|
||
if(cards[i].classList.contains('selected')==false)
|
||
return;
|
||
}
|
||
range[1]+=2;
|
||
}
|
||
}
|
||
},
|
||
fangtian_guozhan:{
|
||
equipSkill:true,
|
||
trigger:{player:'useCard2'},
|
||
filter:function(event,player){
|
||
if(get.mode()!='guozhan') return false;
|
||
if(event.card.name!='sha') return false;
|
||
return game.hasPlayer(function(target){
|
||
if(event.targets.includes(target)) return false;
|
||
if(!lib.filter.filterTarget(event.card,player,target)) return false;
|
||
if(target.identity=='ye'||target.identity=='unknown') return true;
|
||
for(var i=0;i<event.targets.length;i++){
|
||
if(target.identity==event.targets[i].identity) return false;
|
||
}
|
||
return true;
|
||
});
|
||
},
|
||
direct:true,
|
||
content:function(){
|
||
'step 0'
|
||
player.chooseTarget(get.prompt2('fangtian'),[1,Infinity],function(card,player,target){
|
||
var cardx=_status.event.cardx;
|
||
if(!lib.filter.filterTarget(cardx,player,target)) return false;
|
||
var targets=_status.event.targets.slice(0).concat(ui.selected.targets);
|
||
if(targets.includes(target)) return false;
|
||
if(target.identity=='ye'||target.identity=='unknown') return true;
|
||
for(var i=0;i<targets.length;i++){
|
||
if(target.identity==targets[i].identity) return false;
|
||
}
|
||
return true;
|
||
}).set('promptbar','none').set('cardx',trigger.card).set('targets',trigger.targets).set('ai',function(target){
|
||
var player=_status.event.player;
|
||
return get.effect(target,_status.event.cardx,player,player)
|
||
});
|
||
'step 1'
|
||
if(result.bool){
|
||
player.logSkill('fangtian_skill',result.targets);
|
||
if(!player.storage.fangtian_guozhan_trigger) player.storage.fangtian_guozhan_trigger=[];
|
||
player.storage.fangtian_guozhan_trigger.add(trigger.card);
|
||
trigger.targets.addArray(result.targets);
|
||
player.addTempSkill('fangtian_guozhan_trigger');
|
||
}
|
||
},
|
||
},
|
||
fangtian_guozhan_trigger:{
|
||
trigger:{player:'shaMiss'},
|
||
silent:true,
|
||
onremove:true,
|
||
content:function(){
|
||
if(player.storage[event.name].includes(trigger.card)) trigger.getParent().excluded.addArray(trigger.getParent().targets);
|
||
},
|
||
group:'fangtian_guozhan_remove',
|
||
},
|
||
fangtian_guozhan_remove:{
|
||
trigger:{player:['useCardAfter','useCardCancelled']},
|
||
silent:true,
|
||
filter:function(event,player){
|
||
return player.storage.fangtian_guozhan_trigger&&player.storage.fangtian_guozhan_trigger.includes(event.card);
|
||
},
|
||
content:function(){
|
||
player.storage.fangtian_guozhan_trigger.remove(trigger.card);
|
||
}
|
||
},
|
||
qilin_skill:{
|
||
equipSkill:true,
|
||
trigger:{source:'damageBegin2'},
|
||
filter:function(event,player){
|
||
return event.card&&event.card.name=='sha'&&event.notLink()&&event.player.getCards('e',{subtype:['equip3','equip4','equip6']}).length>0
|
||
},
|
||
direct:true,
|
||
audio:true,
|
||
content:function(){
|
||
"step 0"
|
||
var att=(get.attitude(player,trigger.player)<=0);
|
||
var next=player.chooseButton();
|
||
next.set('att',att);
|
||
next.set('createDialog',['是否发动【麒麟弓】，弃置'+get.translation(trigger.player)+'的一张坐骑牌？',trigger.player.getCards('e',{subtype:['equip3','equip4','equip6']})]);
|
||
next.set('ai',function(button){
|
||
if(_status.event.att) return get.buttonValue(button);
|
||
return 0;
|
||
});
|
||
"step 1"
|
||
if(result.bool){
|
||
player.logSkill('qilin_skill',trigger.player);
|
||
trigger.player.discard(result.links[0]);
|
||
}
|
||
}
|
||
},
|
||
bagua_skill:{
|
||
equipSkill:true,
|
||
trigger:{player:['chooseToRespondBegin','chooseToUseBegin']},
|
||
filter:function(event,player){
|
||
if(event.responded) return false;
|
||
if(event.bagua_skill) return false;
|
||
if(!event.filterCard||!event.filterCard({name:'shan'},player,event)) return false;
|
||
if(event.name=='chooseToRespond'&&!lib.filter.cardRespondable({name:'shan'},player,event)) return false;
|
||
if(player.hasSkillTag('unequip2')) return false;
|
||
var evt=event.getParent();
|
||
if(evt.player&&evt.player.hasSkillTag('unequip',false,{
|
||
name:evt.card?evt.card.name:null,
|
||
target:player,
|
||
card:evt.card
|
||
})) return false;
|
||
return true;
|
||
},
|
||
audio:true,
|
||
check:function(event,player){
|
||
if(!event) return true;
|
||
if(event.ai){
|
||
var ai=event.ai;
|
||
var tmp=_status.event;
|
||
_status.event=event;
|
||
var result=ai({name:'shan'},_status.event.player,event);
|
||
_status.event=tmp;
|
||
return result>0;
|
||
}
|
||
let evt=event.getParent();
|
||
if(player.hasSkillTag('noShan',null,evt)) return false;
|
||
if(!evt||!evt.card||!evt.player||player.hasSkillTag('useShan',null,evt)) return true;
|
||
if(evt.card&&evt.player&&player.isLinked()&&game.hasNature(evt.card)&&get.attitude(player,evt.player._trueMe||evt.player)>0) return false;
|
||
return true;
|
||
},
|
||
content:function(){
|
||
"step 0"
|
||
trigger.bagua_skill=true;
|
||
player.judge('bagua',function(card){return (get.color(card)=='red')?1.5:-0.5}).judge2=function(result){
|
||
return result.bool;
|
||
};
|
||
"step 1"
|
||
if(result.judge>0){
|
||
trigger.untrigger();
|
||
trigger.set('responded',true);
|
||
trigger.result={bool:true,card:{name:'shan',isCard:true}}
|
||
}
|
||
},
|
||
ai:{
|
||
respondShan:true,
|
||
freeShan:true,
|
||
skillTagFilter(player,tag,arg){
|
||
if(tag!=='respondShan'&&tag!=='freeShan') return;
|
||
if(player.hasSkillTag('unequip2')) return false;
|
||
if(!arg||!arg.player) return true;
|
||
if(arg.player.hasSkillTag('unequip',false,{
|
||
target:player
|
||
})) return false;
|
||
return true;
|
||
},
|
||
effect:{
|
||
target:function(card,player,target,effect){
|
||
if(target.hasSkillTag('unequip2')) return;
|
||
if(player.hasSkillTag('unequip',false,{
|
||
name:card?card.name:null,
|
||
target:target,
|
||
card:card
|
||
})||player.hasSkillTag('unequip_ai',false,{
|
||
name:card?card.name:null,
|
||
target:target,
|
||
card:card
|
||
})) return;
|
||
if(get.tag(card,'respondShan')) return 0.5;
|
||
}
|
||
}
|
||
}
|
||
},
|
||
_wuxie:{
|
||
trigger:{player:['useCardToBegin','phaseJudge']},
|
||
priority:5,
|
||
popup:false,
|
||
forced:true,
|
||
silent:true,
|
||
filter:function(event,player){
|
||
if(event.card.storage&&event.card.storage.nowuxie) return false;
|
||
var card=event.card;
|
||
if(event.name=='phaseJudge'&&card.viewAs) card={name:card.viewAs};
|
||
var info=get.info(card);
|
||
if(info.wuxieable===false) return false;
|
||
if(event.name!='phaseJudge'){
|
||
if(event.getParent().nowuxie) return false;
|
||
if(event.player.hasSkillTag('playernowuxie',false,event.card)) return false;
|
||
if(get.type(event.card)!='trick'&&!info.wuxieable) return false;
|
||
}
|
||
return true;
|
||
},
|
||
forceLoad:true,
|
||
forceDie:true,
|
||
content:function(){
|
||
'step 0'
|
||
delete event.wuxieresult;
|
||
delete event.wuxieresult2;
|
||
//创建map存储各种信息，用于hasHiddenWuxie判断
|
||
var map={};
|
||
event._info_map=map;
|
||
var card=trigger.card;
|
||
var state=true;
|
||
if(trigger.name=='phaseJudge'){
|
||
if(get.itemtype(card)=='card'&&card.viewAs) card=get.autoViewAs({name:card.viewAs},[card]);
|
||
map.target=trigger.player;
|
||
map.isJudge=true;
|
||
}
|
||
else{
|
||
map.player=trigger.player;
|
||
if(trigger.multitarget) map.multitargets=true;
|
||
map.target=trigger.target;
|
||
map.targets=trigger.targets;
|
||
map.tempnowuxie=(trigger.targets&&trigger.targets.length>1&&!trigger.multitarget);
|
||
map.noai=Boolean(trigger.getParent().noai);
|
||
//如果对拼无懈，获取历史数据
|
||
if(card.name=='wuxie'){
|
||
var evt=event;
|
||
while(true){
|
||
evt=evt.getParent(5);
|
||
if(evt&&evt.name=='_wuxie'){
|
||
state=!state;
|
||
var evtmap=evt._info_map;
|
||
if(evtmap.card.name!='wuxie'){
|
||
map._source=evtmap;
|
||
}
|
||
}
|
||
else break;
|
||
}
|
||
}
|
||
}
|
||
map.card=card;
|
||
map.state=state?1:-1;
|
||
map.id2=trigger.getParent().id;
|
||
event._global_waiting=true;
|
||
//发送函数
|
||
event.send=function(player,map,skillState){
|
||
//获取技能数据
|
||
if(skillState){
|
||
player.applySkills(skillState);
|
||
}
|
||
//生成描述提示
|
||
var prompt='',evtmap=map,state=map.state;
|
||
if(map._source) evtmap=map._source;
|
||
if(evtmap.isJudge){
|
||
prompt+=(get.translation(evtmap.target)+'的'+get.translation(evtmap.card)+'即将'+(state>0?'生':'失')+'效。');
|
||
}
|
||
else{
|
||
prompt+=get.translation(evtmap.player);
|
||
if(evtmap.multitarget){
|
||
if(evtmap.targets.length){
|
||
prompt+='对';
|
||
prompt+=get.translation(evtmap.targets);
|
||
}
|
||
}
|
||
else if(evtmap.target){
|
||
prompt+='对';
|
||
prompt+=(evtmap.target==evtmap.player?'自己':get.translation(evtmap.target));
|
||
}
|
||
prompt+=('使用的'+get.translation(evtmap.card));
|
||
prompt+=('即将'+(state>0?'生':'失')+'效。');
|
||
}
|
||
prompt+='是否使用【无懈可击】？';
|
||
if(player.isUnderControl(true)&&!_status.auto&&!ui.tempnowuxie&&map.tempnowuxie){
|
||
var translation=get.translation(map.card.name);
|
||
if(translation.length>=4){
|
||
translation=lib.translate[map.card.name+'_ab']||translation.slice(0,2);
|
||
}
|
||
ui.tempnowuxie=ui.create.control('不无懈'+translation,ui.click.tempnowuxie,'stayleft');
|
||
ui.tempnowuxie._origin=map.id2;
|
||
}
|
||
var next=player.chooseToUse({
|
||
filterCard:function(card,player){
|
||
if(get.name(card)!='wuxie') return false;
|
||
return lib.filter.cardEnabled(card,player,'forceEnable');
|
||
},
|
||
prompt:prompt,
|
||
type:'wuxie',
|
||
_global_waiting:true,
|
||
ai1:function(){
|
||
if(map.isJudge){
|
||
var card=evtmap.card,source=evtmap.target;
|
||
var name=card.viewAs||card.name;
|
||
var info=lib.card[name];
|
||
if(info&&info.ai&&info.ai.wuxie){
|
||
var aiii=info.ai.wuxie(source,card,source,_status.event.player,state);
|
||
if(typeof aiii=='number') return aiii;
|
||
}
|
||
if(Math.abs(get.attitude(_status.event.player,source))<3) return 0;
|
||
if(source.hasSkillTag('nowuxie_judge')||source.hasSkillTag('guanxing')&&(source!=player||!source.hasSkill('guanxing_fail'))) return 0;
|
||
if(name!='lebu'&&name!='bingliang'){
|
||
if(source!=_status.event.player){
|
||
return 0;
|
||
}
|
||
}
|
||
if(name=='bingliang'&&source.countCards('j')>0&&source.countCards('h')>=source.hp-1){
|
||
return 0;
|
||
}
|
||
var card2;
|
||
if(name!=card.name){
|
||
card2={name:name};
|
||
}
|
||
else{
|
||
card2=card;
|
||
}
|
||
var eff=get.effect(source,card2,source,source);
|
||
if(eff>=0) return 0;
|
||
return state*get.attitude(_status.event.player,source);
|
||
}
|
||
else if(evtmap.target){
|
||
var triggerevent=_status.event.getTrigger();
|
||
if(triggerevent&&triggerevent.parent&&
|
||
triggerevent.parent.postAi&&
|
||
triggerevent.player.isUnknown(_status.event.player)){
|
||
return 0;
|
||
}
|
||
var card=evtmap.card,target=evtmap.target,source=evtmap.player;
|
||
var info=get.info(card);
|
||
if(info.ai&&info.ai.wuxie){
|
||
var aiii=info.ai.wuxie(target,card,source,_status.event.player,state);
|
||
if(typeof aiii=='number') return aiii;
|
||
}
|
||
if(info.multitarget&&targets){
|
||
var eff=0;
|
||
for(var i=0;i<targets.length;i++){
|
||
eff+=get.effect(targets[i],card,source,_status.event.player)
|
||
}
|
||
return -eff*state;
|
||
}
|
||
if(Math.abs(get.attitude(_status.event.player,target))<3) return 0;
|
||
return -get.effect(target,card,source,_status.event.player)*state;
|
||
}
|
||
else{
|
||
var triggerevent=_status.event.getTrigger();
|
||
if(triggerevent&&triggerevent.parent&&
|
||
triggerevent.parent.postAi&&
|
||
triggerevent.player.isUnknown(_status.event.player)){
|
||
return 0;
|
||
}
|
||
var card=evtmap.card,source=evtmap.player;
|
||
var info=get.info(card);
|
||
if(info.ai&&info.ai.wuxie){
|
||
var aiii=info.ai.wuxie(target,card,source,_status.event.player,state);
|
||
if(typeof aiii=='number') return aiii;
|
||
}
|
||
if(Math.abs(get.attitude(_status.event.player,source))<3) return 0;
|
||
return -get.attitude(_status.event.player,source)*state;
|
||
}
|
||
},
|
||
source:evtmap.target,
|
||
source2:evtmap.targets,
|
||
id:map.id,
|
||
id2:map.id2,
|
||
state:state,
|
||
info_map:map,
|
||
});
|
||
if(map.card&&map.player) next.respondTo=[map.player,map.card]
|
||
if(game.online){
|
||
_status.event._resultid=map.id;
|
||
game.resume();
|
||
}
|
||
else{
|
||
next.nouse=true;
|
||
}
|
||
};
|
||
'step 1'
|
||
//判断谁有无懈
|
||
var map=event._info_map;
|
||
var list=game.filterPlayer(function(current){
|
||
if(event.triggername=='phaseJudge'){
|
||
if(game.checkMod(map.card,map.target,current,'unchanged','wuxieJudgeEnabled',current)==false) return false;
|
||
if(game.checkMod(map.card,map.target,current,'unchanged','wuxieJudgeRespondable',map.target)==false) return false;
|
||
}
|
||
else{
|
||
if(trigger.getParent().directHit.includes(current)) return false;
|
||
if(game.checkMod(map.card,map.player,map.target,current,'unchanged','wuxieEnabled',current)==false) return false;
|
||
if(game.checkMod(map.card,map.player,map.target,current,'unchanged','wuxieRespondable',map.player)==false) return false;
|
||
}
|
||
return current.hasWuxie(map);
|
||
});
|
||
event.list=list;
|
||
event.id=get.id();
|
||
map.id=event.id;
|
||
list.sortBySeat(_status.currentPhase);
|
||
'step 2'
|
||
if(event.list.length==0){
|
||
event.finish();
|
||
}
|
||
else if(_status.connectMode&&(event.list[0].isOnline()||event.list[0]==game.me)){
|
||
event.goto(4);
|
||
}
|
||
else{
|
||
event.current=event.list.shift();
|
||
event.send(event.current,event._info_map);
|
||
}
|
||
'step 3'
|
||
if(result.bool){
|
||
event.wuxieresult=event.current;
|
||
event.wuxieresult2=result;
|
||
event.goto(8);
|
||
}
|
||
else{
|
||
event.goto(2);
|
||
}
|
||
'step 4'
|
||
var id=event.id;
|
||
var sendback=function(result,player){
|
||
if(result&&result.id==id&&!event.wuxieresult&&result.bool){
|
||
event.wuxieresult=player;
|
||
event.wuxieresult2=result;
|
||
game.broadcast('cancel',id);
|
||
return (function(){
|
||
if(_status.event.id==id&&_status.event.name=='chooseToUse'&&_status.paused) event.resultOL=_status.event.resultOL;
|
||
if(_status.event._parent_id==id){
|
||
ui.click.cancel();
|
||
}
|
||
if(_status.event.id==id){
|
||
if(_status.event._backup) ui.click.cancel();
|
||
ui.click.cancel();
|
||
if(ui.confirm){
|
||
ui.confirm.close();
|
||
}
|
||
if(_status.event.result){
|
||
_status.event.result.id=id;
|
||
}
|
||
}
|
||
});
|
||
}
|
||
else{
|
||
if(_status.event.id==id&&_status.event.name=='chooseToUse'&&_status.paused){
|
||
return (function(){
|
||
event.resultOL=_status.event.resultOL;
|
||
});
|
||
}
|
||
}
|
||
};
|
||
|
||
var withme=false;
|
||
var withol=false;
|
||
var list=event.list;
|
||
for(var i=0;i<list.length;i++){
|
||
if(list[i].isOnline()){
|
||
withol=true;
|
||
list[i].wait(sendback);
|
||
list[i].send(event.send,list[i],event._info_map,get.skillState(list[i]));
|
||
list.splice(i--,1);
|
||
}
|
||
else if(list[i]==game.me){
|
||
withme=true;
|
||
event.send(list[i],event._info_map);
|
||
list.splice(i--,1);
|
||
}
|
||
}
|
||
if(!withme){
|
||
event.goto(6);
|
||
}
|
||
if(_status.connectMode){
|
||
if(withme||withol){
|
||
for(var i=0;i<game.players.length;i++){
|
||
game.players[i].showTimer();
|
||
}
|
||
}
|
||
}
|
||
event.withol=withol;
|
||
'step 5'
|
||
if(result&&result.bool&&!event.wuxieresult){
|
||
game.broadcast('cancel',event.id);
|
||
event.wuxieresult=game.me;
|
||
event.wuxieresult2=result;
|
||
}
|
||
'step 6'
|
||
if(event.withol&&!event.resultOL){
|
||
game.pause();
|
||
}
|
||
'step 7'
|
||
for(var i=0;i<game.players.length;i++){
|
||
game.players[i].hideTimer();
|
||
}
|
||
'step 8'
|
||
if(event.wuxieresult2&&event.wuxieresult2._sendskill) lib.skill[event.wuxieresult2._sendskill[0]]=event.wuxieresult2._sendskill[1];
|
||
if(event.wuxieresult&&event.wuxieresult2&&event.wuxieresult2.skill){
|
||
var info=get.info(event.wuxieresult2.skill);
|
||
if(info&&info.precontent&&!game.online){
|
||
var next=game.createEvent('pre_'+event.wuxieresult2.skill);
|
||
next.setContent(info.precontent);
|
||
next.set('result',event.wuxieresult2);
|
||
next.set('player',event.wuxieresult);
|
||
}
|
||
}
|
||
'step 9'
|
||
if(event.wuxieresult){
|
||
var next=event.wuxieresult.useResult(event.wuxieresult2);
|
||
if(event.triggername!='phaseJudge'){
|
||
next.respondTo=[trigger.player,trigger.card];
|
||
}
|
||
}
|
||
},
|
||
},
|
||
/*
|
||
_wuxie:{
|
||
trigger:{player:['useCardToBegin','phaseJudge']},
|
||
priority:5,
|
||
popup:false,
|
||
forced:true,
|
||
filter:function(event,player){
|
||
if(event.card.storage&&event.card.storage.nowuxie) return false;
|
||
var card=event.card;
|
||
if(event.name=='phaseJudge'&&card.viewAs) card={name:card.viewAs};
|
||
var info=get.info(card);
|
||
if(info.wuxieable===false) return false;
|
||
if(event.name!='phaseJudge'){
|
||
if(event.getParent().nowuxie) return false;
|
||
if(!event.target){
|
||
if(info.wuxieable) return true;
|
||
return false;
|
||
}
|
||
if(event.player.hasSkillTag('playernowuxie',false,event.card)) return false;
|
||
if(get.type(event.card)!='trick'&&!info.wuxieable) return false;
|
||
}
|
||
return true;
|
||
},
|
||
forceLoad:true,
|
||
content:function(){
|
||
'step 0'
|
||
delete event.wuxieresult;
|
||
delete event.wuxieresult2;
|
||
if(trigger.multitarget){
|
||
event.targets=trigger.targets;
|
||
}
|
||
event.target=trigger.target;
|
||
if(event.triggername=='phaseJudge'){
|
||
event.target=trigger.player;
|
||
}
|
||
event.sourcex=event.targets||event.target;
|
||
if(!event.targets&&trigger.targets&&trigger.targets.length==1){
|
||
event.sourcex2=trigger.player;
|
||
}
|
||
event.source=trigger.player;
|
||
if(event.state==undefined) event.state=true;
|
||
event.card=trigger.card;
|
||
event._global_waiting=true;
|
||
event.tempnowuxie=(trigger.targets&&trigger.targets.length>1&&!trigger.multitarget);
|
||
event.filterCard=function(card,player){
|
||
if(get.name(card)!='wuxie') return false;
|
||
return lib.filter.cardEnabled(card,player,'forceEnable');
|
||
};
|
||
event.send=function(player,state,isJudge,card,source,target,targets,id,id2,tempnowuxie,skillState,respondInfo){
|
||
if(skillState){
|
||
player.applySkills(skillState);
|
||
}
|
||
state=state?1:-1;
|
||
var str='';
|
||
if(isJudge){
|
||
str+=get.translation(source)+'的';
|
||
}
|
||
if(isJudge){
|
||
str+=get.translation(card,'viewAs');
|
||
}
|
||
else{
|
||
str+=get.translation(card);
|
||
}
|
||
if((targets||target)&&!isJudge){
|
||
str+='对'+get.translation(targets||target);
|
||
}
|
||
str+='将'+(state>0?'生效':'失效')+'，是否无懈？';
|
||
|
||
if(player.isUnderControl(true)&&!_status.auto&&!ui.tempnowuxie&&tempnowuxie){
|
||
var translation=get.translation(card.name);
|
||
if(translation.length>=4){
|
||
translation=lib.translate[card.name+'_ab']||translation.slice(0,2);
|
||
}
|
||
ui.tempnowuxie=ui.create.control('不无懈'+translation,ui.click.tempnowuxie,'stayleft');
|
||
ui.tempnowuxie._origin=id2;
|
||
}
|
||
var next=player.chooseToUse({
|
||
filterCard:function(card,player){
|
||
if(get.name(card)!='wuxie') return false;
|
||
return lib.filter.cardEnabled(card,player,'forceEnable');
|
||
},
|
||
prompt:str,
|
||
type:'wuxie',
|
||
state:state,
|
||
_global_waiting:true,
|
||
ai1:function(){
|
||
if(isJudge){
|
||
var name=card.viewAs||card.name;
|
||
var info=lib.card[name];
|
||
if(info&&info.ai&&info.ai.wuxie){
|
||
var aiii=info.ai.wuxie(source,card,source,_status.event.player,state);
|
||
if(typeof aiii=='number') return aiii;
|
||
}
|
||
if(Math.abs(get.attitude(_status.event.player,source))<3) return 0;
|
||
if(source.hasSkillTag('nowuxie_judge')||source.hasSkillTag('guanxing')&&(source!=player||!source.hasSkill('guanxing_fail'))) return 0;
|
||
if(name!='lebu'&&name!='bingliang'){
|
||
if(source!=_status.event.player){
|
||
return 0;
|
||
}
|
||
}
|
||
var card2;
|
||
if(name!=card.name){
|
||
card2={name:name};
|
||
}
|
||
else{
|
||
card2=card;
|
||
}
|
||
var eff=get.effect(source,card2,source,source);
|
||
if(eff>=0) return 0;
|
||
return state*get.attitude(_status.event.player,source);
|
||
}
|
||
else if(target){
|
||
var triggerevent=_status.event.getTrigger();
|
||
if(triggerevent&&triggerevent.parent&&
|
||
triggerevent.parent.postAi&&
|
||
triggerevent.player.isUnknown(_status.event.player)){
|
||
return 0;
|
||
}
|
||
var info=get.info(card);
|
||
if(info.ai&&info.ai.wuxie){
|
||
var aiii=info.ai.wuxie(target,card,source,_status.event.player,state);
|
||
if(typeof aiii=='number') return aiii;
|
||
}
|
||
if(info.multitarget&&targets){
|
||
var eff=0;
|
||
for(var i=0;i<targets.length;i++){
|
||
eff+=get.effect(targets[i],card,source,_status.event.player)
|
||
}
|
||
return -eff*state;
|
||
}
|
||
if(Math.abs(get.attitude(_status.event.player,target))<3) return 0;
|
||
return -get.effect(target,card,source,_status.event.player)*state;
|
||
}
|
||
else{
|
||
var triggerevent=_status.event.getTrigger();
|
||
if(triggerevent&&triggerevent.parent&&
|
||
triggerevent.parent.postAi&&
|
||
triggerevent.player.isUnknown(_status.event.player)){
|
||
return 0;
|
||
}
|
||
var info=get.info(card);
|
||
if(info.ai&&info.ai.wuxie){
|
||
var aiii=info.ai.wuxie(target,card,source,_status.event.player,state);
|
||
if(typeof aiii=='number') return aiii;
|
||
}
|
||
if(Math.abs(get.attitude(_status.event.player,source))<3) return 0;
|
||
return -get.attitude(_status.event.player,source)*state;
|
||
}
|
||
},
|
||
source:target,
|
||
source2:targets,
|
||
id:id,
|
||
id2:id2,
|
||
respondInfo:respondInfo,
|
||
});
|
||
if(event.stateplayer&&event.statecard) next.set('respondTo',[event.stateplayer,event.statecard]);
|
||
else if(!isJudge){
|
||
next.set('respondTo',[source,card]);
|
||
}
|
||
if(game.online){
|
||
_status.event._resultid=id;
|
||
game.resume();
|
||
}
|
||
else{
|
||
next.nouse=true;
|
||
}
|
||
};
|
||
event.settle=function(){
|
||
if(event.respondWuxie) event.trigger('eventNeutralized');
|
||
if(!event.state){
|
||
if(event.triggername=='phaseJudge'){
|
||
trigger.untrigger();
|
||
trigger.cancelled=true;
|
||
}
|
||
else{
|
||
trigger.neutralize();
|
||
if(event.guowuxie==true){
|
||
trigger.getParent().excluded.addArray(game.filterPlayer(function(current){
|
||
return current.isFriendOf(trigger.target);
|
||
}));
|
||
}
|
||
}
|
||
}
|
||
event.finish();
|
||
};
|
||
'step 1'
|
||
var info={};
|
||
if(event.statecard){
|
||
info.player=event.stateplayer;
|
||
info.card=event.statecard;
|
||
}
|
||
else if(event.triggername=='phaseJudge'){
|
||
info.card=trigger.card;
|
||
info.target=trigger.player;
|
||
}
|
||
else{
|
||
info.player=trigger.player;
|
||
info.card=trigger.card;
|
||
if(trigger.multitarget){
|
||
info.targets=trigger.targets;
|
||
}
|
||
else info.target=trigger.target;
|
||
}
|
||
event.respond_info=info;
|
||
var list=game.filterPlayer(function(current){
|
||
if(event.nowuxie) return false;
|
||
if(event.directHit&&event.directHit.includes(current)) return false;
|
||
if(event.triggername=='phaseJudge'){
|
||
if(game.checkMod(trigger.card,player,current,'unchanged','wuxieJudgeEnabled',current)==false) return false;
|
||
if(game.checkMod(trigger.card,player,current,'unchanged','wuxieJudgeRespondable',player)==false) return false;
|
||
if(event.stateplayer&&event.statecard&&(game.checkMod(event.statecard,event.stateplayer,player,current,'unchanged','wuxieRespondable',event.stateplayer)==false)) return false;
|
||
}
|
||
else{
|
||
if(!event.statecard&&trigger.getParent().directHit.includes(current)) return false;
|
||
if(game.checkMod(trigger.card,player,trigger.target,current,'unchanged','wuxieEnabled',current)==false) return false;
|
||
if(game.checkMod(trigger.card,player,trigger.target,current,'unchanged','wuxieRespondable',player)==false) return false;
|
||
if(event.stateplayer&&event.statecard&&(game.checkMod(event.statecard,event.stateplayer,trigger.player,current,'unchanged','wuxieRespondable',event.stateplayer)==false)) return false;
|
||
}
|
||
return current.hasWuxie(info);
|
||
});
|
||
event.list=list;
|
||
event.id=get.id();
|
||
list.sort(function(a,b){
|
||
return get.distance(event.source,a,'absolute')-get.distance(event.source,b,'absolute');
|
||
});
|
||
'step 2'
|
||
if(event.list.length==0){
|
||
event.settle();
|
||
}
|
||
else if(_status.connectMode&&(event.list[0].isOnline()||event.list[0]==game.me)){
|
||
event.goto(4);
|
||
}
|
||
else{
|
||
event.current=event.list.shift();
|
||
event.send(event.current,event.state,event.triggername=='phaseJudge',
|
||
event.card,event.source,event.target,event.targets,event.id,trigger.parent.id,event.tempnowuxie,null,event.respond_info);
|
||
}
|
||
'step 3'
|
||
if(result.bool){
|
||
event.wuxieresult=event.current;
|
||
event.wuxieresult2=result;
|
||
event.goto(8);
|
||
}
|
||
else{
|
||
event.goto(2);
|
||
}
|
||
'step 4'
|
||
var id=event.id;
|
||
var sendback=function(result,player){
|
||
if(result&&result.id==id&&!event.wuxieresult&&result.bool){
|
||
event.wuxieresult=player;
|
||
event.wuxieresult2=result;
|
||
game.broadcast('cancel',id);
|
||
return (function(){
|
||
if(_status.event.id==id&&_status.event.name=='chooseToUse'&&_status.paused) event.resultOL=_status.event.resultOL;
|
||
if(_status.event._parent_id==id){
|
||
ui.click.cancel();
|
||
}
|
||
if(_status.event.id==id){
|
||
if(_status.event._backup) ui.click.cancel();
|
||
ui.click.cancel();
|
||
if(ui.confirm){
|
||
ui.confirm.close();
|
||
}
|
||
if(_status.event.result){
|
||
_status.event.result.id=id;
|
||
}
|
||
}
|
||
});
|
||
}
|
||
else{
|
||
if(_status.event.id==id&&_status.event.name=='chooseToUse'&&_status.paused){
|
||
return (function(){
|
||
event.resultOL=_status.event.resultOL;
|
||
});
|
||
}
|
||
}
|
||
};
|
||
var withme=false;
|
||
var withol=false;
|
||
var list=event.list;
|
||
for(var i=0;i<list.length;i++){
|
||
if(list[i].isOnline()){
|
||
withol=true;
|
||
list[i].wait(sendback);
|
||
list[i].send(event.send,list[i],event.state,event.triggername=='phaseJudge',
|
||
event.card,event.source,event.target,event.targets,event.id,trigger.parent.id,event.tempnowuxie,get.skillState(list[i]),event.respond_info);
|
||
list.splice(i--,1);
|
||
}
|
||
else if(list[i]==game.me){
|
||
withme=true;
|
||
event.send(list[i],event.state,event.triggername=='phaseJudge',
|
||
event.card,event.source,event.target,event.targets,event.id,trigger.parent.id,event.tempnowuxie,null,respondInfo);
|
||
list.splice(i--,1);
|
||
}
|
||
}
|
||
if(!withme){
|
||
event.goto(6);
|
||
}
|
||
if(_status.connectMode){
|
||
if(withme||withol){
|
||
for(var i=0;i<game.players.length;i++){
|
||
game.players[i].showTimer();
|
||
}
|
||
}
|
||
}
|
||
event.withol=withol;
|
||
'step 5'
|
||
if(result&&result.bool&&!event.wuxieresult){
|
||
game.broadcast('cancel',event.id);
|
||
event.wuxieresult=game.me;
|
||
event.wuxieresult2=result;
|
||
}
|
||
'step 6'
|
||
if(event.withol&&!event.resultOL){
|
||
game.pause();
|
||
}
|
||
'step 7'
|
||
for(var i=0;i<game.players.length;i++){
|
||
game.players[i].hideTimer();
|
||
}
|
||
'step 8'
|
||
if(event.wuxieresult2&&event.wuxieresult2._sendskill) lib.skill[event.wuxieresult2._sendskill[0]]=event.wuxieresult2._sendskill[1];
|
||
if(event.wuxieresult&&event.wuxieresult2&&event.wuxieresult2.skill){
|
||
var info=get.info(event.wuxieresult2.skill);
|
||
if(info&&info.precontent&&!game.online){
|
||
var next=game.createEvent('pre_'+event.wuxieresult2);
|
||
next.setContent(info.precontent);
|
||
next.set('result',event.wuxieresult2);
|
||
next.set('player',event.wuxieresult);
|
||
}
|
||
}
|
||
'step 9'
|
||
if(event.wuxieresult){
|
||
var next=event.wuxieresult.useResult(event.wuxieresult2);
|
||
if(event.stateplayer&&event.statecard){
|
||
event.respondWuxie=true;
|
||
next.respondTo=[event.stateplayer,event.statecard];
|
||
}
|
||
else if(event.triggername!='phaseJudge'){
|
||
next.respondTo=[trigger.player,trigger.card];
|
||
}
|
||
}
|
||
'step 10'
|
||
if(event.wuxieresult){
|
||
if(result.wuxied){
|
||
event.nowuxie=result.nowuxie;
|
||
event.directHit=result.directHit;
|
||
event.stateplayer=event.wuxieresult;
|
||
if(event.wuxieresult2&&event.wuxieresult2.used){
|
||
event.statecard=event.wuxieresult2.used;
|
||
}
|
||
else{
|
||
event.statecard=true;
|
||
}
|
||
event.state=!event.state;
|
||
event.goto(1);
|
||
}
|
||
else event.settle();
|
||
}
|
||
else if(event.list.length){
|
||
event.goto(2);
|
||
}
|
||
else{
|
||
event.settle();
|
||
}
|
||
delete event.resultOL;
|
||
delete event.wuxieresult;
|
||
delete event.wuxieresult2;
|
||
}
|
||
},*/
|
||
},
|
||
translate:{
|
||
sha:'杀',
|
||
huosha:'火杀',
|
||
leisha:'雷杀',
|
||
icesha:'冰杀',
|
||
kamisha:'神杀',
|
||
cisha:'刺杀',
|
||
shan:'闪',
|
||
tao:'桃',
|
||
bagua:'八卦阵',
|
||
bagua_bg:'卦',
|
||
bagua_skill:'八卦阵',
|
||
jueying:'绝影',
|
||
dilu:'的卢',
|
||
zhuahuang:'爪黄飞电',
|
||
jueying_bg:'+马',
|
||
dilu_bg:'+马',
|
||
zhuahuang_bg:'+马',
|
||
chitu:'赤兔',
|
||
chitu_bg:'-马',
|
||
dawan:'大宛',
|
||
dawan_bg:'-马',
|
||
zixin:'紫骍',
|
||
zixin_bg:'-马',
|
||
zhuge:'诸葛连弩',
|
||
cixiong:'雌雄双股剑',
|
||
zhuge_bg:'弩',
|
||
cixiong_bg:'双',
|
||
qinggang:'青釭剑',
|
||
qinglong:'青龙偃月刀',
|
||
zhangba:'丈八蛇矛',
|
||
qinglong_bg:'偃',
|
||
zhangba_bg:'蛇',
|
||
guanshi:'贯石斧',
|
||
fangtian:'方天画戟',
|
||
qilin:'麒麟弓',
|
||
qilin_bg:'弓',
|
||
zhuge_skill:'诸葛连弩',
|
||
cixiong_skill:'雌雄双股剑',
|
||
qinggang_skill:'青釭剑',
|
||
qinglong_skill:'青龙偃月刀',
|
||
qinglong_guozhan:'青龙偃月刀',
|
||
zhangba_skill:'丈八蛇矛',
|
||
guanshi_skill:'贯石斧',
|
||
fangtian_skill:'方天画戟',
|
||
qilin_skill:'麒麟弓',
|
||
wugu:'五谷丰登',
|
||
taoyuan:'桃园结义',
|
||
nanman:'南蛮入侵',
|
||
wanjian:'万箭齐发',
|
||
wuzhong:'无中生有',
|
||
juedou:'决斗',
|
||
wugu_bg:'谷',
|
||
taoyuan_bg:'园',
|
||
nanman_bg:'蛮',
|
||
wanjian_bg:'箭',
|
||
wuzhong_bg:'生',
|
||
juedou_bg:'斗',
|
||
shunshou:'顺手牵羊',
|
||
guohe:'过河拆桥',
|
||
guohe_bg:'拆',
|
||
jiedao:'借刀杀人',
|
||
wuxie:'无懈可击',
|
||
wuxie_bg:'懈',
|
||
lebu:'乐不思蜀',
|
||
shandian:'闪电',
|
||
shandian_bg:'电',
|
||
hanbing:'寒冰剑',
|
||
renwang:'仁王盾',
|
||
hanbing_bg:'冰',
|
||
renwang_bg:'盾',
|
||
hanbing_skill:'寒冰剑',
|
||
renwang_skill:'仁王盾',
|
||
hanbing_info:'当你因执行【杀】的效果而造成伤害时，若目标角色有能被弃置的牌，则你可以防止此伤害，然后依次弃置目标角色的两张牌。',
|
||
hanbing_skill_info:'当你因执行【杀】的效果而造成伤害时，若目标角色有能被弃置的牌，则你可以防止此伤害，然后依次弃置目标角色的两张牌。',
|
||
renwang_info:'锁定技，黑色【杀】对你无效。',
|
||
renwang_skill_info:'锁定技，黑色【杀】对你无效。',
|
||
sha_info:'出牌阶段，对你攻击范围内的一名角色使用。其须使用一张【闪】，否则你对其造成1点伤害。',
|
||
shan_info:'抵消一张【杀】。',
|
||
tao_info:'①出牌阶段，对自己使用，目标角色回复1点体力。②当有角色处于濒死状态时，对该角色使用。目标角色回复1点体力。',
|
||
bagua_info:'当你需要使用或打出一张【闪】时，你可以进行判定。若结果为红色，则你视为使用或打出一张【闪】。',
|
||
bagua_skill_info:'当你需要使用或打出一张【闪】时，你可以进行判定。若结果为红色，则你视为使用或打出一张【闪】。',
|
||
jueying_info:'锁定技，其他角色计算与你的距离+1。',
|
||
dilu_info:'锁定技，其他角色计算与你的距离+1。',
|
||
zhuahuang_info:'锁定技，其他角色计算与你的距离+1。',
|
||
chitu_info:'锁定技，你计算与其他角色的距离-1。',
|
||
dawan_info:'锁定技，你计算与其他角色的距离-1。',
|
||
zixin_info:'锁定技，你计算与其他角色的距离-1。',
|
||
zhuge_skill_info:'锁定技，你于出牌阶段内使用【杀】无次数限制。',
|
||
zhuge_info:'锁定技，你于出牌阶段内使用【杀】无次数限制。',
|
||
cixiong_skill_info:'当你使用【杀】指定一名异性的目标角色后，你可以令其选择一项：1.弃置一张手牌；2.令你摸一张牌。',
|
||
cixiong_info:'当你使用【杀】指定一名异性的目标角色后，你可以令其选择一项：1.弃置一张手牌；2.令你摸一张牌。',
|
||
qinggang_skill_info:'锁定技，当你使用【杀】指定一名目标角色后，你令其防具技能无效直到此【杀】被抵消或造成伤害。',
|
||
qinggang_info:'锁定技，当你使用【杀】指定一名目标角色后，你令其防具技能无效直到此【杀】被抵消或造成伤害。',
|
||
qinglong_skill_info:'当你使用的【杀】被目标角色使用的【闪】抵消时，你可以对其使用一张【杀】（无距离限制）。',
|
||
qinglong_guozhan_info:'锁定技，当你使用【杀】指定目标后，所有目标角色不能明置武将牌直到此【杀】结算完毕为止。',
|
||
qinglong_info:'当你使用的【杀】被目标角色使用的【闪】抵消时，你可以对其使用一张【杀】（无距离限制）。',
|
||
qinglong_info_guozhan:'锁定技，当你使用【杀】指定目标后，所有目标角色不能明置武将牌直到此【杀】结算完毕为止。',
|
||
zhangba_skill_info:'你可以将两张手牌当【杀】使用或打出。',
|
||
zhangba_info:'你可以将两张手牌当【杀】使用或打出。',
|
||
guanshi_skill_info:'当你使用的【杀】被目标角色使用的【闪】抵消时，你可以弃置两张牌，令此【杀】依然对其造成伤害。',
|
||
guanshi_info:'当你使用的【杀】被目标角色使用的【闪】抵消时，你可以弃置两张牌，令此【杀】依然对其造成伤害。',
|
||
fangtian_skill_info:'你使用的【杀】若是你最后的手牌，你可以额外选择至多两个目标。',
|
||
fangtian_info:'你使用的【杀】若是你最后的手牌，你可以额外选择至多两个目标。',
|
||
fangtian_info_guozhan:'你使用【杀】可以指定任意名角色为目标（不能包含势力相同的角色），若任意一名目标角色使用【闪】抵消了此【杀】，则此【杀】对剩余的目标角色无效。',
|
||
qilin_skill_info:'当你使用【杀】对目标角色造成伤害时，你可以弃置其装备区里的一张坐骑牌。',
|
||
qilin_info:'当你使用【杀】对目标角色造成伤害时，你可以弃置其装备区里的一张坐骑牌。',
|
||
wugu_info:'出牌阶段，对所有角色使用。（选择目标后）你从牌堆顶亮出等同于目标数量的牌，每名目标角色获得这些牌中（剩余的）的任意一张。',
|
||
taoyuan_info:'出牌阶段，对所有角色使用。每名目标角色回复1点体力。',
|
||
nanman_info:'出牌阶段，对所有其他角色使用。每名目标角色需打出一张【杀】，否则受到1点伤害。',
|
||
wanjian_info:'出牌阶段，对所有其他角色使用。每名目标角色需打出一张【闪】，否则受到1点伤害。',
|
||
wuzhong_info:'出牌阶段，对你使用。你摸两张牌。',
|
||
juedou_info:'出牌阶段，对一名其他角色使用。由其开始，其与你轮流打出一张【杀】，直到其中一方未打出【杀】为止。未打出【杀】的一方受到另一方对其造成的1点伤害。',
|
||
shunshou_info:'出牌阶段，对距离为1且区域里有牌的一名其他角色使用。你获得其区域里的一张牌。',
|
||
guohe_info:'出牌阶段，对区域里有牌的一名其他角色使用。你弃置其区域里的一张牌。',
|
||
jiedao_info:'出牌阶段，对装备区里有武器牌且有使用【杀】的目标的一名其他角色使用。令其对你指定的一名角色使用一张【杀】，否则将其装备区里的武器牌交给你。',
|
||
jiedao_append:'<span class="text" style="font-family: yuanli">这是一种十分含蓄的计谋。</span>',
|
||
wuxie_info:'一张锦囊牌生效前，对此牌使用。抵消此牌对一名角色产生的效果，或抵消另一张【无懈可击】产生的效果。',
|
||
lebu_info:'出牌阶段，对一名其他角色使用。若判定结果不为红桃，跳过其出牌阶段。',
|
||
shandian_info:'出牌阶段，对自己使用。若判定结果为黑桃2~9，则目标角色受到3点雷电伤害。若判定不为黑桃2~9，将之移动到下家的判定区里。',
|
||
icesha_skill:'冰冻',
|
||
icesha_skill_info:'防止即将造成的伤害，改为依次弃置其两张牌。',
|
||
sha_notshan:'invisible',
|
||
qinggang2:'破防',
|
||
},
|
||
list:[
|
||
["spade",7,"sha"],
|
||
["spade",8,"sha"],
|
||
["spade",8,"sha"],
|
||
["spade",9,"sha"],
|
||
["spade",9,"sha"],
|
||
["spade",10,"sha"],
|
||
["spade",10,"sha"],
|
||
["club",2,"sha"],
|
||
["club",3,"sha"],
|
||
["club",4,"sha"],
|
||
["club",5,"sha"],
|
||
["club",6,"sha"],
|
||
["club",7,"sha"],
|
||
["club",8,"sha"],
|
||
["club",8,"sha"],
|
||
["club",9,"sha"],
|
||
["club",9,"sha"],
|
||
["club",10,"sha"],
|
||
["club",10,"sha"],
|
||
["club",11,"sha"],
|
||
["club",11,"sha"],
|
||
["heart",10,"sha"],
|
||
["heart",10,"sha"],
|
||
["heart",11,"sha"],
|
||
["diamond",6,"sha"],
|
||
["diamond",7,"sha"],
|
||
["diamond",8,"sha"],
|
||
["diamond",9,"sha"],
|
||
["diamond",10,"sha"],
|
||
["diamond",13,"sha"],
|
||
["heart",2,"shan"],
|
||
["heart",2,"shan"],
|
||
["heart",13,"shan"],
|
||
["diamond",2,"shan"],
|
||
["diamond",2,"shan"],
|
||
["diamond",3,"shan"],
|
||
["diamond",4,"shan"],
|
||
["diamond",5,"shan"],
|
||
["diamond",6,"shan"],
|
||
["diamond",7,"shan"],
|
||
["diamond",8,"shan"],
|
||
["diamond",9,"shan"],
|
||
["diamond",10,"shan"],
|
||
["diamond",11,"shan"],
|
||
["diamond",11,"shan"],
|
||
["heart",3,"tao"],
|
||
["heart",4,"tao"],
|
||
["heart",6,"tao"],
|
||
["heart",7,"tao"],
|
||
["heart",8,"tao"],
|
||
["heart",9,"tao"],
|
||
["heart",12,"tao"],
|
||
["diamond",12,"tao"],
|
||
|
||
["spade",2,"bagua"],
|
||
["club",2,"bagua"],
|
||
["spade",5,"jueying"],
|
||
["club",5,"dilu"],
|
||
["heart",13,"zhuahuang"],
|
||
["heart",5,"chitu"],
|
||
["spade",13,"dawan"],
|
||
["diamond",13,"zixin"],
|
||
["club",1,"zhuge"],
|
||
["diamond",1,"zhuge"],
|
||
["spade",2,"cixiong"],
|
||
["spade",6,"qinggang"],
|
||
["spade",5,"qinglong"],
|
||
["spade",12,"zhangba"],
|
||
["diamond",5,"guanshi"],
|
||
["diamond",12,"fangtian"],
|
||
["heart",5,"qilin"],
|
||
|
||
["heart",3,"wugu"],
|
||
["heart",4,"wugu"],
|
||
["heart",1,"taoyuan"],
|
||
["spade",7,"nanman"],
|
||
["spade",13,"nanman"],
|
||
["club",7,"nanman"],
|
||
["heart",1,"wanjian"],
|
||
["spade",1,"juedou"],
|
||
["club",1,"juedou"],
|
||
["diamond",1,"juedou"],
|
||
["heart",7,"wuzhong"],
|
||
["heart",8,"wuzhong"],
|
||
["heart",9,"wuzhong"],
|
||
["heart",11,"wuzhong"],
|
||
["spade",3,'shunshou'],
|
||
["spade",4,'shunshou'],
|
||
["spade",11,'shunshou'],
|
||
["diamond",3,'shunshou'],
|
||
["diamond",4,'shunshou'],
|
||
["spade",3,'guohe'],
|
||
["spade",4,'guohe'],
|
||
["spade",12,'guohe'],
|
||
["club",3,'guohe'],
|
||
["club",4,'guohe'],
|
||
["heart",12,'guohe'],
|
||
["club",12,'jiedao'],
|
||
["club",13,'jiedao'],
|
||
["spade",11,'wuxie'],
|
||
["club",12,'wuxie'],
|
||
["club",13,'wuxie'],
|
||
["spade",6,'lebu'],
|
||
["club",6,'lebu'],
|
||
["heart",6,'lebu'],
|
||
["spade",1,'shandian'],
|
||
["spade",2,'hanbing'],
|
||
["club",2,'renwang'],
|
||
["heart",12,'shandian'],
|
||
["diamond",12,'wuxie'],
|
||
],
|
||
};
|
||
});
|