mirror of
https://github.com/webxoss/webxoss-core.git
synced 2024-11-20 06:49:53 +01:00
2426 lines
No EOL
71 KiB
JavaScript
2426 lines
No EOL
71 KiB
JavaScript
'use strict';
|
||
|
||
function Player (game,io,mainDeck,lrigDeck) {
|
||
// 引用
|
||
this.game = game;
|
||
// this.client = open('../WEBXOSS_Client/test.html');
|
||
// this.client = new Client(this.input.bind(this));
|
||
this.io = io;
|
||
io.listener = function () {
|
||
if (!this.input.apply(this,arguments)) {
|
||
console.warn('Invalid input!');
|
||
console.warn(arguments);
|
||
var effectSource = this.game.getEffectSource();
|
||
if (effectSource) {
|
||
console.warn('EffectSource cid: %s',effectSource.cid);
|
||
}
|
||
// console.warn('IP Address: %s',this.io.socket.request.connection.remoteAddress);
|
||
}
|
||
}.bind(this);
|
||
|
||
// 注册
|
||
game.register(this);
|
||
|
||
// 储存的数据
|
||
this.listener = {}; // 监听器(监听玩家输入).
|
||
this.msgQueue = []; // 要向客户端发送的消息队列.
|
||
// 消息不是直接发送给客户端,而是先入队,
|
||
// 然后在调用堆栈的最后将整个队列发送.
|
||
this.messagePacks = []; // 用于保存录像.
|
||
this.rebuildCount = 0;
|
||
this.coin = 0;
|
||
|
||
// 快捷方式
|
||
this.hands = []; // 手牌
|
||
this.signis = [];
|
||
this.lrig = null;
|
||
this.opponent = null; // 对手(Player对象)
|
||
this.crossed = [];
|
||
|
||
// 区域
|
||
this.mainDeck = new Zone(game,this,'MainDeck','up',mainDeck);
|
||
this.lrigDeck = new Zone(game,this,'LrigDeck','checkable up',lrigDeck);
|
||
this.handZone = new Zone(game,this,'HandZone','checkable up inhand');
|
||
this.lrigZone = new Zone(game,this,'LrigZone','checkable up faceup');
|
||
this.signiZones = [new Zone(game,this,'SigniZone','up faceup bottom'),
|
||
new Zone(game,this,'SigniZone','up faceup bottom'),
|
||
new Zone(game,this,'SigniZone','up faceup bottom')];
|
||
this.enerZone = new Zone(game,this,'EnerZone','checkable faceup');
|
||
this.checkZone = new Zone(game,this,'CheckZone','checkable up faceup');
|
||
this.trashZone = new Zone(game,this,'TrashZone','checkable up faceup');
|
||
this.lrigTrashZone = new Zone(game,this,'LrigTrashZone','checkable up faceup');
|
||
this.lifeClothZone = new Zone(game,this,'LifeClothZone','');
|
||
this.excludedZone = new Zone(game,this,'ExcludedZone','checkable up faceup');
|
||
|
||
// 时点
|
||
// this.onLrigChange = new Timming(game);
|
||
// this.onSignisChange = new Timming(game);
|
||
this.onUseSpell = new Timming(game);
|
||
this.onUseArts = new Timming(game);
|
||
this.onCrash = new Timming(game);
|
||
this.onSigniBanished = new Timming(game);
|
||
this.onTurnStart = new Timming(game);
|
||
this.onTurnEnd = new Timming(game);
|
||
this.onSummonSigni = new Timming(game);
|
||
this.onCardMove = new Timming(game);
|
||
this.onBurstTriggered = new Timming(game);
|
||
this.onAttack = new Timming(game);
|
||
this.onAttackPrevented = new Timming(game);
|
||
this.onRebuild = new Timming(game);
|
||
this.onAttackPhaseStart = new Timming(game);
|
||
this.onGrowPhaseStart = new Timming(game);
|
||
this.onMainPhaseStart = new Timming(game);
|
||
this.onTurnEnd2 = new Timming(game); // 注: 详见 Phase.js 的 endPhase 函数.
|
||
this.onHeaven = new Timming(game);
|
||
this.onSigniFreezed = new Timming(game);
|
||
this.onSigniLeaveField = new Timming(game);
|
||
this.onDiscard = new Timming(game);
|
||
this.onDoubleCrashed = new Timming(game);
|
||
this.onDraw = new Timming(game);
|
||
this.onRemoveVirus = new Timming(game);
|
||
this.onTrapTriggered = new Timming(game);
|
||
|
||
// 附加属性
|
||
this.skipGrowPhase = false;
|
||
this.guardLimit = 0;
|
||
this.banishTrash = false;
|
||
this.ignoreGrowCost = false;
|
||
this.lrigAttackBanned = false; // 与 lrig.canNotAttack 不同,不会被无效.
|
||
this.wontBeCrashed = false;
|
||
this.wontBeCrashedExceptDamage = false;
|
||
this._trashLifeClothCount = 0;
|
||
this.forceSigniAttack = false;
|
||
this.drawCount = 2;
|
||
this._ionaUltimaMaiden = false; // <究极/少女 伊绪奈>
|
||
this.twoSignisLimit = false; // <白罗星 土星> <开辟者 塔维尔=TRE>
|
||
this.spellCancelable = true;
|
||
this.artsBanned = false;
|
||
this.trashSigniBanned = false;
|
||
this._ViolenceSplashCount = 0; // <暴力飞溅>
|
||
this._DreiDioDaughter = 0; // <DREI=恶英娘>
|
||
this.powerChangeBanned = false;
|
||
this.skipSigniAttackStep = false;
|
||
this.skipLrigAttackStep = false;
|
||
this.addCardToHandBanned = false;
|
||
this.spellBanned = false;
|
||
this.skipEnerPhase = false;
|
||
this.ignoreLimitingOfArtsAndSpell = false;
|
||
this.ignoreLimitingOfLevel5Signi = false; // <紡ぐ者>
|
||
this.summonPowerLimit = 0;
|
||
this.additionalRevealCount = 0; // <反复的独立性 网格>
|
||
this.useBikouAsWhiteCost = false; // <不思議な童話 メルへ>
|
||
this.burstTwice = false; // <Burst Rush>
|
||
this.wontBeDamaged = false; // <音阶的右律 G>
|
||
this.wontBeDamagedByOpponentLrig = false; // <紡ぐ者>
|
||
this.actionEffectBanned = false;
|
||
this.charmedActionEffectBanned = false; // <黒幻蟲 アラクネ・パイダ>
|
||
this.canNotGrow = false; // <ドント・グロウ>
|
||
this._HammerChance = false; // <ハンマー・チャンス>
|
||
this._VierVX = false; // <VIER=维克斯>
|
||
this._RanergeOriginalSpear = []; // <原槍 ラナジェ>
|
||
this.reducedGrowCostWhite = 0;
|
||
this.reducedGrowCostBlack = 0;
|
||
this.reducedGrowCostRed = 0;
|
||
this.reducedGrowCostBlue = 0;
|
||
this.reducedGrowCostGreen = 0;
|
||
this.reducedGrowCostColorless = 0;
|
||
this.attackCount = 0; // <暴风警报>
|
||
this._stormWarning = false; // <暴风警报>
|
||
this.guardBannedLevels = []; // <缚魔炎 花代·叁>
|
||
this.discardOnAttackPhase = false; // <雪月風火 花代・肆>
|
||
this.signiStartUpBanned = false; // <呪われし数字 ６６６>
|
||
this.lrigStartUpBanned = false; // <花咲乱 游月·叁>
|
||
this.signiAttackCountLimit = Infinity;
|
||
this.signiTotalAttackCountLimit = Infinity;
|
||
this.lrigAttackCountLimit = Infinity;
|
||
this.canNotGuard = false;
|
||
this.wontLoseGame = false; // <紅蓮乙女 遊月・肆>
|
||
this.canNotBeBanished = false;
|
||
this.canNotBeBounced = false;
|
||
this.signiCanNotGainAbility = false;
|
||
this.canNotBeDownedByOpponentEffect = false;
|
||
this.canNotUseColorlessSigni = false; // <绿罗植 世界树>
|
||
this.canNotUseColorlessSpell = false; // <绿罗植 世界树>
|
||
this.skipNextTurn = false;
|
||
|
||
this.usedActionEffects = [];
|
||
this.chain = null;
|
||
this.inResonaAction = null; // 是否正在执行共鸣单位的出现条件. (同时也是正在执行出现条件的那只共鸣单位)
|
||
this.inActionEffectCost = false; // 是否正在支付起动能力的COST
|
||
this.bannedCards = []; // <漆黑之棺>
|
||
this.oneArtEachTurn = false; // <博愛の使者 サシェ・リュンヌ>
|
||
}
|
||
|
||
// Player.prototype.rockPaperScissorsAsyn = function () {
|
||
// var player = this;
|
||
// player.output({
|
||
// type: 'ROCK_PAPER_SCISSORS',
|
||
// content: {}
|
||
// });
|
||
// return new Callback(function (callback) {
|
||
// player.listen('ROCK_PAPER_SCISSORS',function (input) {
|
||
// input = +input;
|
||
// if (!(input>=0 && input<=2)) return false;
|
||
// return function () {
|
||
// callback(input);
|
||
// };
|
||
// });
|
||
// });
|
||
// };
|
||
|
||
// 玩家设置lrig
|
||
// (从LRIG卡组里选择等级0的卡片,背面表示放置到LRIG区)
|
||
Player.prototype.setupLrigAsyn = function () {
|
||
var cards = this.lrigDeck.cards.filter(function (card) {
|
||
return (card.type === 'LRIG') && (card.level === 0);
|
||
});
|
||
return Callback.immediately().callback(this,function () {
|
||
if (cards.length === 1) return cards[0];
|
||
return this.selectAsyn('LEVEL0_LRIG',cards);;
|
||
}).callback(this,function (card) {
|
||
card.moveTo(this.lrigZone,{faceup: false});
|
||
});
|
||
};
|
||
|
||
// 玩家抽起始手牌(5张)
|
||
Player.prototype.setupHands = function () {
|
||
this.draw(5);
|
||
};
|
||
|
||
// 玩家重抽手牌
|
||
// (将不需要的卡片返回主卡组并洗牌,再从主卡组顶端抽和返回的卡片数量相同的卡片.)
|
||
Player.prototype.redrawAsyn = function () {
|
||
return this.selectSomeAsyn('DISCARD_AND_REDRAW',this.hands).callback(this,function (cards) {
|
||
this.game.moveCards(cards,this.mainDeck);
|
||
this.shuffle();
|
||
this.draw(cards.length);
|
||
});
|
||
};
|
||
|
||
// 玩家洗切牌组
|
||
Player.prototype.shuffle = function (cards) {
|
||
if (!cards) {
|
||
cards = this.mainDeck.cards;
|
||
}
|
||
var len = cards.length;
|
||
|
||
if (!len) return;
|
||
|
||
var oldSids = cards.map(function (card) {
|
||
return {
|
||
a: this.game.getSid(this,card),
|
||
b: this.game.getSid(this.opponent,card)
|
||
};
|
||
},this);
|
||
|
||
for (var i = 0; i < len-1; i++) {
|
||
var r = this.game.rand(i,len-1);
|
||
var tmp = cards[i];
|
||
cards[i] = cards[r];
|
||
cards[r] = tmp;
|
||
}
|
||
|
||
cards.forEach(function (card,idx) {
|
||
this.game.setSid(this,card,oldSids[idx].a);
|
||
this.game.setSid(this.opponent,card,oldSids[idx].b);
|
||
},this);
|
||
|
||
this.game.output({
|
||
type: 'SHUFFLE',
|
||
content: {
|
||
cards: cards
|
||
}
|
||
});
|
||
};
|
||
|
||
// 玩家设置生命护甲
|
||
// (从主卡组顶将7张卡依次重叠放置到生命护甲区)
|
||
Player.prototype.setupLifeCloth = function () {
|
||
var cards = this.mainDeck.getTopCards(7);
|
||
this.game.moveCards(cards,this.lifeClothZone);
|
||
};
|
||
|
||
// OPEN!!
|
||
Player.prototype.open = function () {
|
||
this.lrig.faceup();
|
||
this.setCoin(this.coin); // output
|
||
};
|
||
|
||
// 玩家把lrig和所有signi竖置 (竖置阶段)
|
||
Player.prototype.up = function () {
|
||
var cards = concat(this.lrig,this.signis);
|
||
if (!cards.length) return;
|
||
this.game.packOutputs(function () {
|
||
this.game.frame(this,function () {
|
||
cards.forEach(function (card) {
|
||
if (card.frozen) {
|
||
card.frozen = false;
|
||
} else {
|
||
card.up();
|
||
}
|
||
},this);
|
||
});
|
||
},this);
|
||
};
|
||
|
||
// 玩家从卡组抽取n张卡
|
||
// 返回:
|
||
// cards: Array,抽到的卡,长度可能少于n(卡组没有足够的卡可以抽),也可能为空数组.
|
||
Player.prototype.draw = function (n) {
|
||
if (this.addCardToHandBanned) return [];
|
||
var cards = this.mainDeck.getTopCards(n);
|
||
if (!cards.length) return [];
|
||
if (this.game.phase.isAttackPhase()) {
|
||
var count = this.game.getData(this,'attackPhaseDrawCount') || 0;
|
||
count += cards.length;
|
||
this.game.setData(this,'attackPhaseDrawCount',count);
|
||
}
|
||
this.onDraw.trigger();
|
||
this.game.moveCards(cards,this.handZone);
|
||
return cards;
|
||
};
|
||
|
||
// 被动充能
|
||
// 从卡组最上面拿n张卡放到能量区.
|
||
// 跟主动充能 player.chargeAsyn() 不一样.
|
||
Player.prototype.enerCharge = function (n) {
|
||
var cards = this.mainDeck.getTopCards(n);
|
||
this.game.moveCards(cards,this.enerZone);
|
||
return cards;
|
||
};
|
||
|
||
// 舍弃n张卡
|
||
Player.prototype.discardAsyn = function (n) {
|
||
if (!this.hands.length || !n) return Callback.immediately([]);
|
||
if (this.hands.length < n) {
|
||
n = this.hands.length;
|
||
}
|
||
return this.selectSomeAsyn('DISCARD',this.hands,n,n).callback(this,function (cards) {
|
||
return this.discardCards(cards);
|
||
});
|
||
};
|
||
|
||
// 随机舍弃n张卡
|
||
Player.prototype.discardRandomly = function (n) {
|
||
if (!isNum(n)) n = 1;
|
||
var cards = [];
|
||
var hands = this.hands.slice();
|
||
for (var i = 0; i < n; i++) {
|
||
if (!hands.length) break;
|
||
var idx = this.game.rand(0,hands.length - 1);
|
||
cards.push(hands[idx]);
|
||
removeFromArr(hands[idx],hands);
|
||
}
|
||
return this.discardCards(cards);
|
||
};
|
||
|
||
// 舍弃指定的卡
|
||
Player.prototype.discardCards = function (cards) {
|
||
return this.game.trashCards(cards);
|
||
};
|
||
|
||
// 玩家进行充能操作 (主动充能)
|
||
// 玩家从手牌或自己场上的SIGNI选一张卡放到能力区.
|
||
Player.prototype.chargeAsyn = function () {
|
||
var cards = concat(this.hands,this.signis);
|
||
if (!cards.length) return Callback.never();
|
||
return this.selectAsyn('CHARGE',cards).callback(this,function (card) {
|
||
return this.game.blockAsyn(this,function () {
|
||
card.moveTo(this.enerZone);
|
||
});
|
||
});
|
||
};
|
||
|
||
// 玩家结束充能阶段
|
||
Player.prototype.endEnerPhaseAsyn = function () {
|
||
return this.selectAsyn('END_ENER_PHASE');
|
||
};
|
||
|
||
// 玩家进行成长操作 (主动成长)
|
||
Player.prototype.growAsyn = function () {
|
||
var cards = this.lrigDeck.cards.filter(function (card) {
|
||
return card.canGrow(this.ignoreGrowCost);
|
||
},this);
|
||
if (!cards.length) return Callback.never();
|
||
return this.selectAsyn('GROW',cards).callback(this,function (card) {
|
||
return this.game.blockAsyn(this,function () {
|
||
// return Callback.immediately().callback(this,function () {
|
||
// if (!card.growActionAsyn) return;
|
||
// return card.growActionAsyn();
|
||
// }).callback(this,function () {
|
||
// if (this.ignoreGrowCost) return;
|
||
// return this.payCostAsyn(card);
|
||
// }).callback(this,function () {
|
||
// var colorChanged = (card.color !== this.lrig.color);
|
||
// card.moveTo(this.lrigZone,{
|
||
// up: this.lrig.isUp
|
||
// });
|
||
// if (colorChanged) this.game.outputColor();
|
||
// });
|
||
return card.growAsyn();
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.resetSignisAsyn = function () {
|
||
var signis = [];
|
||
var totalLevel = this.signis.reduce(function (total,signi) {
|
||
return total + signi.level;
|
||
},0);
|
||
// 超出 SIGNI 数量限制
|
||
if (this.signis.length > this.getSigniAmountLimit()) {
|
||
signis = this.signis;
|
||
} else if (totalLevel > this.lrig.limit) {
|
||
// 超出界限
|
||
signis = this.signis;
|
||
} else {
|
||
// 限制及等级
|
||
signis = this.signis.filter(function (signi) {
|
||
return (!signi.checkLimiting()) || (signi.level > this.lrig.level);
|
||
},this);
|
||
}
|
||
if (!signis.length) return Callback.immediately();
|
||
return this.selectAsyn('TRASH_SIGNI',signis).callback(this,function (card) {
|
||
return this.game.blockAsyn(this,function () {
|
||
card.trash();
|
||
});
|
||
}).callback(this,this.resetSignisAsyn);
|
||
};
|
||
|
||
Player.prototype.resetAccesAsyn = function() {
|
||
var signis = this.signis.filter(function (signi) {
|
||
return (signi.getAccedCards().length > signi.maxAcceCount);
|
||
},this);
|
||
return Callback.forEach(signis,function (signi) {
|
||
signi.beSelectedAsTarget();
|
||
var cards = signi.getAccedCards();
|
||
var count = cards.length - signi.maxAcceCount;
|
||
return this.selectSomeAsyn('TRASH',cards,count,count).callback(this,function (cards) {
|
||
this.game.trashCards(cards);
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.getSigniAmountLimit = function () {
|
||
if (this._ionaUltimaMaiden) return 1;
|
||
if (this.twoSignisLimit) return 2;
|
||
return 3;
|
||
};
|
||
|
||
// 玩家结束成长阶段
|
||
Player.prototype.endGrowPhaseAsyn = function () {
|
||
return this.selectAsyn('END_GROW_PHASE');
|
||
};
|
||
|
||
// 玩家召唤SIGNI
|
||
Player.prototype.summonSigniAsyn = function () {
|
||
var cards = this.hands.filter(function (card) {
|
||
return card.canSummon() && (!this.summonPowerLimit || (card.power < this.summonPowerLimit));
|
||
},this);
|
||
if (!cards.length) {
|
||
return Callback.never();
|
||
}
|
||
return this.selectAsyn('SUMMON_SIGNI',cards).callback(this,function (card) {
|
||
return this.selectSummonZoneAsyn(true,card.rise).callback(this,function (zone) {
|
||
if (!zone) return;
|
||
return this.game.blockAsyn(this,function () {
|
||
return card.handleSummonAsyn(zone);
|
||
});
|
||
});
|
||
});
|
||
};
|
||
|
||
// 玩家召唤共鸣SIGNI
|
||
Player.prototype.summonResonaSigniAsyn = function (arg) {
|
||
if (!arg) arg = {};
|
||
var cards = this.getResonas(arg);
|
||
if (!cards.length) {
|
||
return Callback.never();
|
||
}
|
||
return this.selectAsyn('RESONA',cards).callback(this,function (card) {
|
||
return this.summonResonaAsyn(card);
|
||
});
|
||
};
|
||
|
||
Player.prototype.getResonas = function (arg) {
|
||
return this.lrigDeck.cards.filter(function (card) {
|
||
if (!card.resona) return false;
|
||
var phase = '';
|
||
if (arg.spellCutIn) {
|
||
phase = 'spellCutIn';
|
||
} else if (this.game.phase.status === 'mainPhase') {
|
||
phase = 'mainPhase';
|
||
} else if (this.game.phase.isAttackPhase()) {
|
||
phase = 'attackPhase';
|
||
}
|
||
if (!inArr(phase,card.resonaPhases)) return false;
|
||
var resonaAsyn = card.resonaCondition();
|
||
if (!resonaAsyn) return false;
|
||
card.resonaAsyn = resonaAsyn;
|
||
return true;
|
||
},this);
|
||
};
|
||
|
||
Player.prototype.summonResonaAsyn = function (card) {
|
||
this.inResonaAction = card;
|
||
return card.resonaAsyn().callback(this,function (resonaArg) {
|
||
this.inResonaAction = null;
|
||
return this.selectSummonZoneAsyn(false).callback(this,function (zone) {
|
||
if (!zone) return;
|
||
return this.game.blockAsyn(this,function () {
|
||
return card.handleSummonAsyn(zone)
|
||
});
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.selectSummonZoneAsyn = function (optional,rise) {
|
||
var zones = this.getSummonZones(null,rise);
|
||
if (!zones.length) {
|
||
return Callback.immediately(null);
|
||
}
|
||
if (optional) return this.selectOptionalAsyn('SUMMON_SIGNI_ZONE',zones);
|
||
return this.selectAsyn('SUMMON_SIGNI_ZONE',zones);
|
||
};
|
||
|
||
Player.prototype.getSummonZones = function (signis,rise) {
|
||
if (!signis) signis = this.signis;
|
||
var forcedZones = [];
|
||
var zones = this.signiZones.filter(function (zone,idx) {
|
||
if (zone.disabled) return false;
|
||
var signi = zone.getSigni();
|
||
if (rise) {
|
||
if (!signi || !rise(signi)) return false;
|
||
} else {
|
||
if (signi && inArr(signi,signis)) return false;
|
||
}
|
||
var opposingSigni = this.opponent.signiZones[2-idx].getSigni();
|
||
if (opposingSigni && opposingSigni.forceSummonZone) {
|
||
forcedZones.push(zone);
|
||
}
|
||
return true;
|
||
},this);
|
||
if (forcedZones.length) {
|
||
zones = forcedZones;
|
||
}
|
||
return zones.slice();
|
||
};
|
||
|
||
// 玩家废弃SIGNI
|
||
Player.prototype.trashSigniAsyn = function () {
|
||
if (this.trashSigniBanned) return Callback.never();
|
||
var signis = this.signis.filter(function (signi) {
|
||
return !signi.resona && !signi.canNotBeTrashedBySelf;
|
||
},this);
|
||
if (!signis.length) return Callback.never();
|
||
return this.selectAsyn('TRASH_SIGNI',signis).callback(this,function (card) {
|
||
return this.game.blockAsyn(this,function () {
|
||
card.trash();
|
||
});
|
||
});
|
||
};
|
||
|
||
// 玩家使用魔法
|
||
Player.prototype.useSpellAsyn = function () {
|
||
var cards = this.hands.filter(function (card) {
|
||
return card.canUse();
|
||
});
|
||
if (!cards.length) return Callback.never();
|
||
|
||
return this.selectAsyn('USE_SPELL',cards).callback(this,this.handleSpellAsyn);
|
||
};
|
||
|
||
Player.prototype.handleSpellAsyn = function (card,ignoreCost,costObj,arg) {
|
||
if (!costObj) costObj = card;
|
||
if (!arg) arg = {};
|
||
var effect,target,costArg;
|
||
this.game.setData(this,'flagSpellUsed',true);
|
||
var count = this.game.getData(this,'CodeHeartAMS') || 0;
|
||
this.game.setData(this,'CodeHeartAMS',count + 1);
|
||
|
||
this.game.spellToCutIn = card;
|
||
return Callback.immediately().callback(this,function () {
|
||
// ------ 块开始 ------
|
||
this.game.blockStart();
|
||
// 1. 放到检查区.
|
||
card.moveTo(this.checkZone);
|
||
|
||
// 被 米璐璐恩 抢夺,转移控制权
|
||
// 要在 moveTo 之后改变 player .
|
||
card.player = this;
|
||
|
||
// 2. 支付费用.
|
||
// 无视支付费用
|
||
if (ignoreCost) return { // 返回 costArg 对象
|
||
enerCards: [],
|
||
enerColors: []
|
||
};
|
||
return this.payCostAsyn(costObj);
|
||
}).callback(this,function (_costArg) {
|
||
costArg = _costArg;
|
||
// 如果魔法卡的效果不止一个,选择其中一个发动
|
||
if (card.spellEffects.length === 1) {
|
||
effect = card.spellEffects[0];
|
||
} else {
|
||
return this.selectAsyn('SPELL_EFFECT',card.spellEffects).callback(this,function (eff) {
|
||
effect = eff;
|
||
return this.opponent.showEffectsAsyn([eff]);
|
||
});
|
||
}
|
||
}).callback(this,function () {
|
||
// 3. 娶(划掉)取对象.
|
||
card.activate();
|
||
if (effect.getTargets) {
|
||
// 简单的取对象,即从目标卡片中选一张. (也可以不选,空发)
|
||
if (effect.targetCovered) {
|
||
// 从废弃区等[卡片可能被覆盖的区域]取对象
|
||
return this.selectAsyn('TARGET',effect.getTargets.call(card)).callback(this,function (card) {
|
||
if (!card) return card;
|
||
return this.opponent.showCardsAsyn([card]).callback(this,function () {
|
||
return card;
|
||
});
|
||
});
|
||
}
|
||
return this.selectTargetAsyn(effect.getTargets.call(card));
|
||
}
|
||
if (effect.getTargetAdvancedAsyn) {
|
||
// 复杂(高级)的取对象.
|
||
return effect.getTargetAdvancedAsyn.call(card,costArg);
|
||
}
|
||
}).callback(this,function (t) {
|
||
target = t;
|
||
return this.game.blockEndAsyn();
|
||
// ------ 块结束 ------
|
||
}).callback(this,function () {
|
||
// 4. 魔法切入.
|
||
return this.opponent.useSpellCutInArtsAsyn();
|
||
}).callback(this,function (canceled) {
|
||
// 5. 处理.
|
||
// "处理+放置到废弃区"放在1个block里.
|
||
return this.game.blockAsyn(effect.source,this,function () {
|
||
return Callback.immediately().callback(this,function () {
|
||
// "结束这个回合",处理直接结束.
|
||
if (this.game.phase.checkForcedEndTurn()) return;
|
||
// "不会被取消"
|
||
if (!this.spellCancelable) {
|
||
canceled = false;
|
||
}
|
||
// 触发"使用魔法"时点,不管是否被取消
|
||
var event = {
|
||
card: effect.source
|
||
};
|
||
effect.source.player.onUseSpell.trigger(event);
|
||
// 如果被取消,处理直接结束.
|
||
if (canceled) return;
|
||
// 如果目标丢失,处理直接结束. (除非设置了dontCheckTarget)
|
||
if (effect.getTargets && !effect.dontCheckTarget) {
|
||
if (!inArr(target,effect.getTargets.call(card))) {
|
||
return;
|
||
}
|
||
}
|
||
return effect.actionAsyn.call(card,target,costArg);
|
||
}).callback(this,function () {
|
||
// 6. 放到废弃区
|
||
// 恢复控制权
|
||
card.player = card.owner;
|
||
this.game.spellToCutIn = null;
|
||
if (card.zone !== this.checkZone) return;
|
||
return this.game.blockAsyn(this,function () {
|
||
// <皮露露可 APEX>
|
||
if (arg.excludeAfterUse) {
|
||
card.exclude()
|
||
} else {
|
||
card.trash();
|
||
}
|
||
});
|
||
}).callback(this,function () {
|
||
// <混乱交织> 的特殊处理
|
||
if (this.game.phase.checkForcedEndTurn()) return;
|
||
if (canceled !== '_crossScramble') return;
|
||
return this.opponent.handleSpellAsyn(card,true);
|
||
});
|
||
});
|
||
});
|
||
};
|
||
|
||
// 技艺的处理
|
||
Player.prototype.handleArtsAsyn = function (card,ignoreCost) {
|
||
var effects,costArg,control;
|
||
var encored = false;
|
||
var costObj = card.getChainedCostObj();
|
||
if (ignoreCost) costObj = {};
|
||
var count = this.game.getData(this,'artsCount') || 0;
|
||
this.game.setData(this,'artsCount',count+1);
|
||
this.game.setData(this,'flagArtsUsed',true);
|
||
// 五色电影卡
|
||
if (card.cid !== 1167) {
|
||
this.game.setData(this,'flagArcDestruct',true);
|
||
}
|
||
if (card.cid !== 1526) {
|
||
this.game.setData(this,'flagDestructOut',true);
|
||
}
|
||
return Callback.immediately().callback(this,function () {
|
||
// ------ 块开始 ------
|
||
this.game.blockStart();
|
||
// 1. 放到检查区
|
||
card.moveTo(this.checkZone);
|
||
if (card.beforeUseAsyn) return card.beforeUseAsyn();
|
||
}).callback(this,function () {
|
||
// bet
|
||
if (card.betAdvancedAsyn) {
|
||
return card.betAdvancedAsyn(costObj).callback(this,function (c) {
|
||
costObj = c;
|
||
});
|
||
}
|
||
if (!card.bet) return;
|
||
if (this.coin < card.bet) return;
|
||
var bettedCost = Object.create(costObj);
|
||
if (card.bettedCost && !ignoreCost) {
|
||
bettedCost = card.getChainedCostObj(card.bettedCost);
|
||
}
|
||
bettedCost.costCoin = card.bet;
|
||
if (!this.enoughCost(costObj)) {
|
||
// 必须 bet
|
||
return costObj = bettedCost;
|
||
}
|
||
return this.confirmAsyn('CONFIRM_BET').callback(this,function (answer) {
|
||
if (!answer) return;
|
||
costObj = bettedCost;
|
||
})
|
||
}).callback(this,function () {
|
||
// 如果效果不止一个,选择其中n个发动
|
||
if (card.artsEffects.length === 1) {
|
||
effects = card.artsEffects.slice();
|
||
} else {
|
||
var min,max;
|
||
if (!card.getMinEffectCount || !card.getMaxEffectCount) {
|
||
min = max = 1;
|
||
} else {
|
||
min = card.getMinEffectCount(costObj);
|
||
max = card.getMaxEffectCount(costObj);
|
||
}
|
||
return this.selectSomeAsyn('ARTS_EFFECT',card.artsEffects,min,max,false).callback(this,function (effs) {
|
||
effects = effs;
|
||
if (card.costChangeAfterChoose) {
|
||
card.costChangeAfterChoose.call(card,costObj,effs);
|
||
}
|
||
return this.opponent.showEffectsAsyn(effs);
|
||
});
|
||
}
|
||
}).callback(this,function () {
|
||
// encore 费用,约定: 除了颜色费用，其它属性直接覆盖
|
||
if (!card.encore) return;
|
||
var encoredCost = Object.create(costObj);
|
||
encoredCost.source = card;
|
||
var enerCostProps = [
|
||
'costColorless',
|
||
'costWhite',
|
||
'costBlack',
|
||
'costRed',
|
||
'costBlue',
|
||
'costGreen',
|
||
];
|
||
for (var prop in card.encore) {
|
||
if (inArr(prop,enerCostProps)) {
|
||
encoredCost[prop] += card.encore[prop];
|
||
} else {
|
||
encoredCost[prop] = card.encore[prop];
|
||
}
|
||
}
|
||
if (!this.enoughCost(encoredCost)) return;
|
||
return this.confirmAsyn('CONFIRM_ENCORE').callback(this,function (answer) {
|
||
if (!answer) return;
|
||
costObj = encoredCost;
|
||
encored = true;
|
||
});
|
||
}).callback(this,function () {
|
||
// 2. 支付费用
|
||
return this.payCostAsyn(costObj);
|
||
}).callback(this,function (_costArg) {
|
||
costArg = _costArg;
|
||
card.activate();
|
||
control = {
|
||
backToDeck: false,
|
||
rtn: null // 当有多个效果时,这个作为返回值. <ブルー・パニッシュ>
|
||
};
|
||
// 3. 处理
|
||
this.onUseArts.trigger({
|
||
card: card
|
||
});
|
||
return this.game.blockAsyn(card,this,function () {
|
||
return Callback.forEach(effects,function (effect) {
|
||
return effect.actionAsyn.call(card,costArg,control);
|
||
},this);
|
||
});
|
||
}).callback(this,function (rtn) {
|
||
// 4. 放到LRIG废弃区
|
||
this.chain = card.chain; // 连锁
|
||
if (encored || control.backToDeck) {
|
||
card.moveTo(card.player.lrigDeck);
|
||
} else {
|
||
card.moveTo(card.player.lrigTrashZone);
|
||
}
|
||
// ------ 块结束 ------
|
||
return this.game.blockEndAsyn().callback(this,function () {
|
||
return control.rtn || rtn;
|
||
});
|
||
});
|
||
};
|
||
|
||
|
||
// 玩家使用【魔法切入】的技艺(和起动效果和召唤魔法切入共鸣单位)
|
||
Player.prototype.useSpellCutInArtsAsyn = function () {
|
||
var canceled = false;
|
||
function loopAsyn () {
|
||
if (this.game.phase.checkForcedEndTurn()) {
|
||
return Callback.immediately(true);
|
||
}
|
||
var cards = this.lrigDeck.cards.filter(function (card) {
|
||
return card.canUse('spellCutIn');
|
||
});
|
||
cards = cards.concat(this.getResonas({spellCutIn: true}));
|
||
concat(this.signis,this.lrig).forEach(function (card) {
|
||
var hasSpellCutInEffect = card.actionEffects.some(function (effect) {
|
||
return this.canUseActionEffect(effect,{spellCutIn: true});
|
||
},this);
|
||
if (hasSpellCutInEffect) cards.push(card);
|
||
},this);
|
||
// 选择一张魔法切入的技艺(或持有魔法切入的起动效果的卡)
|
||
return this.selectOptionalAsyn('SPELL_CUT_IN',cards,true).callback(this,function (card) {
|
||
if (!card) return true;
|
||
if (card.type === 'ARTS') {
|
||
// 如果选择的是ARTS
|
||
return this.handleArtsAsyn(card).callback(this,function (c) {
|
||
if (c) canceled = c;
|
||
return false;
|
||
});
|
||
} else if (card.resona && inArr('spellCutIn',card.resonaPhases)) {
|
||
// 如果选择的是魔法切入的共鸣单位
|
||
return this.summonResonaAsyn(card);
|
||
} else {
|
||
// 如果选择的是持有起动效果的卡
|
||
var effects = card.actionEffects.filter(function (effect) {
|
||
return this.canUseActionEffect(effect,{spellCutIn: true});
|
||
},this);
|
||
if (!effects.length) return false;
|
||
return Callback.immediately().callback(this,function () {
|
||
if (effects.length === 1) return effects[0];
|
||
return this.selectAsyn('USE_ACTION_EFFECT',effects);
|
||
}).callback(this,function (effect) {
|
||
return this.handleActionEffectAsyn(effect);
|
||
}).callback(this,function (c) {
|
||
if (c) canceled = c;
|
||
return false;
|
||
});
|
||
}
|
||
}).callback(this,function (done) {
|
||
if (canceled || done) return canceled;
|
||
// 重复上述步骤 (直至魔法被取消或没有魔法切入或玩家放弃使用)
|
||
return loopAsyn.call(this);
|
||
});
|
||
}
|
||
return loopAsyn.call(this);
|
||
};
|
||
|
||
// 玩家使用【主要阶段】的技艺
|
||
Player.prototype.useMainPhaseArtsAsyn = function () {
|
||
var cards = this.lrigDeck.cards.filter(function (card) {
|
||
return card.canUse('mainPhase');
|
||
});
|
||
if (!cards.length) return Callback.never();
|
||
return this.selectAsyn('USE_ARTS',cards).callback(this,function (card) {
|
||
return this.handleArtsAsyn(card);
|
||
});
|
||
};
|
||
|
||
Player.prototype.canUseActionEffect = function (effect,arg) {
|
||
if (!arg) arg = {};
|
||
if (this.actionEffectBanned) return false;
|
||
if (this.charmedActionEffectBanned && effect.source.charm) return false;
|
||
if (effect.source.abilityLost) return false;
|
||
// inHand
|
||
if (effect.source.zone === this.handZone && !effect.activatedInHand) return false;
|
||
if (effect.source.zone !== this.handZone && effect.activatedInHand) return false;
|
||
// inTrashZone
|
||
if (effect.source.zone === this.trashZone && !effect.activatedInTrashZone) return false;
|
||
if (effect.source.zone !== this.trashZone && effect.activatedInTrashZone) return false;
|
||
// inEnerZone
|
||
if (effect.source.zone === this.enerZone && !effect.activatedInEnerZone) return false;
|
||
if (effect.source.zone !== this.enerZone && effect.activatedInEnerZone) return false;
|
||
// attackPhase && spellCutIn
|
||
if (!arg.ignoreTimming) {
|
||
if (arg.spellCutIn) {
|
||
if (!effect.spellCutIn) return false;
|
||
} else {
|
||
if (this.game.phase.isAttackPhase()) {
|
||
if (!effect.attackPhase) return false;
|
||
} else {
|
||
if (effect.attackPhase && !effect.mainPhase) return false;
|
||
}
|
||
}
|
||
}
|
||
// onAttack
|
||
if (arg.onAttack && !effect.onAttack) return false;
|
||
if (!arg.onAttack && effect.onAttack) return false;
|
||
// cross
|
||
if (effect.cross && !effect.source.crossed) return false;
|
||
// wisdom
|
||
if (effect.wisdom && (effect.source.player.getWisdom() !== effect.wisdom)) return false;
|
||
// once
|
||
if (effect.once && inArr(effect,this.usedActionEffects)) return false;
|
||
// condition
|
||
if (effect.useCondition && !effect.useCondition.call(effect.source,arg)) return false;
|
||
// <混沌之键主 乌姆尔=FYRA>
|
||
if (effect.activatedInTrashZone) {
|
||
if (this.game.getData(effect.source,'zeroActionCostInTrash')) {
|
||
return true;
|
||
}
|
||
}
|
||
var obj = Object.create(effect);
|
||
if (obj.costColorless) {
|
||
obj.costColorless += effect.source.attachedCostColorless;
|
||
} else {
|
||
obj.costColorless = effect.source.attachedCostColorless;
|
||
}
|
||
if (arg.ignoreExceedCost) {
|
||
obj.costExceed = 0;
|
||
}
|
||
return this.enoughCost(obj);
|
||
};
|
||
|
||
// 玩家使用起动效果
|
||
Player.prototype.useActionEffectAsyn = function () {
|
||
var effects = [];
|
||
var cards = concat(this.lrig,this.signis,this.trashZone.cards,this.hands,this.enerZone.cards);
|
||
cards.forEach(function (card) {
|
||
card.actionEffects.forEach(function (effect) {
|
||
if (effect.spellCutIn) return;
|
||
if (this.canUseActionEffect(effect)) {
|
||
effects.push(effect);
|
||
}
|
||
},this);
|
||
},this);
|
||
if (!effects.length) return Callback.never();
|
||
return this.selectAsyn('USE_ACTION_EFFECT',effects).callback(this,function (effect) {
|
||
return this.handleActionEffectAsyn(effect,{
|
||
cancelable: true,
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.useOnAttackActionEffectAsyn = function (event) {
|
||
var effects = this.lrig.actionEffects.filter(function (effect) {
|
||
return this.canUseActionEffect(effect,{
|
||
onAttack: true,
|
||
event: event,
|
||
});
|
||
},this);
|
||
if (!effects.length) return Callback.immediately();
|
||
return this.selectOptionalAsyn('LAUNCH',effects).callback(this,function (effect) {
|
||
if (!effect) return;
|
||
return this.handleActionEffectAsyn(effect,{event: event});
|
||
});
|
||
};
|
||
|
||
Player.prototype.handleActionEffectAsyn = function (effect,arg) {
|
||
if (!arg) arg = {};
|
||
return this.game.blockAsyn(this,function () {
|
||
var obj = Object.create(effect);
|
||
if (obj.costColorless) {
|
||
obj.costColorless += effect.source.attachedCostColorless;
|
||
} else {
|
||
obj.costColorless = effect.source.attachedCostColorless;
|
||
}
|
||
if (arg.ignoreExceedCost) {
|
||
obj.costExceed = 0;
|
||
}
|
||
// <混沌之键主 乌姆尔=FYRA>
|
||
if (effect.activatedInTrashZone) {
|
||
if (this.game.getData(effect.source,'zeroActionCostInTrash')) {
|
||
obj = {};
|
||
this.game.setData(effect.source,'zeroActionCostInTrash',false);
|
||
}
|
||
}
|
||
this.inActionEffectCost = true;
|
||
return this.payCostAsyn(obj,arg.cancelable).callback(this,function (costArg) {
|
||
this.inActionEffectCost = false;
|
||
if (!costArg) return; // canceled
|
||
effect.source.activate();
|
||
this.usedActionEffects.push(effect);
|
||
return this.game.blockAsyn(effect.source,this,function () {
|
||
return effect.actionAsyn.call(effect.source,costArg,arg);
|
||
});
|
||
});
|
||
});
|
||
};
|
||
|
||
// 玩家结束主要阶段
|
||
Player.prototype.endMainPhaseAsyn = function () {
|
||
return this.selectAsyn('END_MAIN_PHASE');
|
||
};
|
||
|
||
// // 玩家使用【攻击阶段】的技艺(和起动效果)
|
||
// Player.prototype.useAttackPhaseArtsAsyn = function () {
|
||
// var cards = this.lrigDeck.cards.filter(function (card) {
|
||
// return card.canUse('attackPhase');
|
||
// });
|
||
// concat(this.signis,this.lrig).forEach(function (card) {
|
||
// var hasAttackPhaseEffect = card.actionEffects.some(function (effect) {
|
||
// return effect.attackPhase && this.canUseActionEffect(effect);
|
||
// },this);
|
||
// if (hasAttackPhaseEffect) cards.push(card);
|
||
// },this);
|
||
// if (!cards.length) return Callback.never();
|
||
// // 选择一张【攻击阶段】的技艺(或持有【攻击阶段】的起动效果的卡)
|
||
// return this.selectAsyn('USE_ARTS',cards).callback(this,function (card) {
|
||
// if (card.type === 'ARTS') {
|
||
// // 如果选择的是ARTS
|
||
// return this.handleArtsAsyn(card);
|
||
// } else {
|
||
// // 如果选择的是持有起动效果的卡
|
||
// var effects = card.actionEffects.filter(function (effect) {
|
||
// return effect.attackPhase && this.canUseActionEffect(effect);
|
||
// },this);
|
||
// if (!effects.length) return;
|
||
// return Callback.immediately().callback(this,function () {
|
||
// if (effects.length === 1) return effects[0];
|
||
// return this.selectAsyn('USE_ACTION_EFFECT',effects);
|
||
// }).callback(this,function (effect) {
|
||
// return this.handleActionEffectAsyn(effect);
|
||
// });
|
||
// }
|
||
// });
|
||
// };
|
||
|
||
Player.prototype.useAttackPhaseArtsAsyn = function () {
|
||
var cards = this.lrigDeck.cards.filter(function (card) {
|
||
return card.canUse('attackPhase');
|
||
});
|
||
if (!cards.length) return Callback.never();
|
||
return this.selectAsyn('USE_ARTS',cards).callback(this,function (card) {
|
||
return this.handleArtsAsyn(card);
|
||
});
|
||
};
|
||
|
||
Player.prototype.useAttackPhaseActionEffect = function () {
|
||
var cards = concat(this.signis,this.lrig,this.trashZone.cards,this.hands).filter(function (card) {
|
||
return card.actionEffects.some(function (effect) {
|
||
return this.canUseActionEffect(effect);
|
||
},this);
|
||
},this);
|
||
if (!cards.length) return Callback.never();
|
||
return this.selectAsyn('USE_ACTION_EFFECT',cards).callback(this,function (card) {
|
||
var effects = card.actionEffects.filter(function (effect) {
|
||
return this.canUseActionEffect(effect);
|
||
},this);
|
||
if (!effects.length) return;
|
||
return Callback.immediately().callback(this,function () {
|
||
if (effects.length === 1) return effects[0];
|
||
return this.selectAsyn('USE_ACTION_EFFECT',effects);
|
||
}).callback(this,function (effect) {
|
||
return this.handleActionEffectAsyn(effect);
|
||
});
|
||
});
|
||
};
|
||
|
||
// 玩家结束技艺使用步骤
|
||
Player.prototype.endArtsStepAsyn = function () {
|
||
return this.selectAsyn('END_ARTS_STEP');
|
||
};
|
||
|
||
// 玩家进行SIGNI攻击
|
||
Player.prototype.signiAttackAsyn = function () {
|
||
var cards = this.signis.filter(function (card) {
|
||
return card.canAttack();
|
||
});
|
||
if (!cards.length) return Callback.never();
|
||
return this.selectAsyn('SIGNI_ATTACK',cards).callback(this,function (card) {
|
||
return card.attackAsyn();
|
||
});
|
||
};
|
||
|
||
// 玩家结束SIGNI攻击步骤
|
||
Player.prototype.endSigniAttackStepAsyn = function () {
|
||
// 必须进行攻击的卡
|
||
var cards = this.signis.filter(function (card) {
|
||
return (this.forceSigniAttack || card.mustAttack) && card.canAttack() && !card.attackCostColorless;
|
||
},this);
|
||
if (cards.length) return Callback.never();
|
||
return this.selectAsyn('END_SIGNI_ATTACK_STEP');
|
||
};
|
||
|
||
// 玩家进行LRIG攻击
|
||
Player.prototype.lrigAttackAsyn = function () {
|
||
if (this.lrigAttackBanned) return Callback.never();
|
||
var cards = [this.lrig].filter(function (card) {
|
||
return card.canAttack();
|
||
});
|
||
if (!cards.length) return Callback.never();
|
||
return this.selectAsyn('LRIG_ATTACK',cards).callback(this,function (card) {
|
||
return card.attackAsyn();
|
||
});
|
||
};
|
||
|
||
// 防御
|
||
// callback(succ)
|
||
// succ: 表示是否成功防御
|
||
Player.prototype.guardAsyn = function () {
|
||
if (this.canNotGuard) return Callback.immediately(false);
|
||
var cards = this.hands.filter(function (card) {
|
||
return card.guardFlag && (card.level > this.guardLimit) && !inArr(card.level,this.guardBannedLevels);
|
||
},this);
|
||
return this.selectOptionalAsyn('GUARD',cards,true).callback(this,function (card) {
|
||
if (!card) return false;
|
||
card.moveTo(this.trashZone);
|
||
return true;
|
||
});
|
||
};
|
||
|
||
// 玩家结束LRIG攻击步骤
|
||
Player.prototype.endLrigAttackStepAsyn = function () {
|
||
return this.selectAsyn('END_LRIG_ATTACK_STEP');
|
||
};
|
||
|
||
// 玩家被击溃(噗
|
||
Player.prototype.crashAsyn = function (n,arg) {
|
||
if (n === undefined) n = 1;
|
||
if (arg === undefined) arg = {};
|
||
var source = arg.source || this.game.getEffectSource();
|
||
var attack = !!arg.attack;
|
||
var lancer = !!arg.lancer;
|
||
var doubleCrash = !!arg.doubleCrash;
|
||
var damage = !!arg.damage;
|
||
var tag = arg.tag || '';
|
||
|
||
if (this.wontBeCrashed) return Callback.immediately(false);
|
||
if (this.wontBeCrashedExceptDamage && !damage) return Callback.immediately(false);
|
||
|
||
var cards = this.lifeClothZone.getTopCards(n);
|
||
if (!cards.length) return Callback.immediately(false);
|
||
var crossLifeCloth = (tag === 'crossLifeCloth'); // <幻水 希拉>
|
||
var effectSource = this.game.getEffectSource();
|
||
return this.game.blockAsyn(this,function () {
|
||
// 放到检查区并触发 onBurst 和 onCrash .
|
||
// 根据<幻竜姫 スヴァローグ>的FAQ,
|
||
// 无迸发的卡立即进入能量区;
|
||
// 有迸发的卡在迸发解决后进入能量区.
|
||
this.game.frame(this,function () {
|
||
cards.forEach(function (card) {
|
||
// <多元描写>
|
||
if (effectSource && (effectSource.player === this.opponent)) {
|
||
this.game.setData(this,'_PluralismDepiction',true);
|
||
}
|
||
|
||
card.moveTo(this.checkZone);
|
||
var event = {
|
||
source: source,
|
||
lancer: lancer
|
||
};
|
||
this.onCrash.trigger(event);
|
||
var shouldBurst = card.onBurst.effects.length &&
|
||
(tag !== 'dontTriggerBurst') &&
|
||
(!source || !source.disableBurst)
|
||
if (shouldBurst) {
|
||
// 迸发
|
||
card.onBurst.trigger({crossLifeCloth: crossLifeCloth}); // 注意<DYNAMITE>
|
||
} else {
|
||
card.handleBurstEnd(crossLifeCloth);
|
||
}
|
||
},this);
|
||
if (doubleCrash && (cards.length === 2)) {
|
||
this.onDoubleCrashed.trigger();
|
||
}
|
||
});
|
||
}).callback(this,function () {
|
||
return true;
|
||
});
|
||
};
|
||
|
||
Player.prototype.damageAsyn = function () {
|
||
if (this.wontBeDamaged) return Callback.immediately(false);
|
||
if (this.wontBeDamagedByOpponentLrig) {
|
||
var source = this.game.getEffectSource();
|
||
if (source === this.opponent.lrig) {
|
||
return Callback.immediately(false);
|
||
}
|
||
}
|
||
if (!this.lifeClothZone.cards.length) {
|
||
if (this.game.win(this.opponent)) return Callback.never();
|
||
return Callback.immediately(false);
|
||
}
|
||
return this.crashAsyn(1,{damage: true});
|
||
};
|
||
|
||
// 向玩家展示一些卡,通常用于公开探寻的卡.
|
||
Player.prototype.showCardsAsyn = function (cards,label) {
|
||
var player = this;
|
||
// player.opponent.output({
|
||
// type: 'WAIT_FOR_OPPONENT',
|
||
// content: {
|
||
// operation: 'CONFIRM'
|
||
// }
|
||
// });
|
||
player.output({
|
||
type: 'SHOW_CARDS',
|
||
content: {
|
||
label: label || 'CONFIRM',
|
||
cards: cards,
|
||
pids: cards.map(function (card) {
|
||
return card.pid;
|
||
})
|
||
}
|
||
});
|
||
return new Callback(function (callback) {
|
||
player.listen('OK',function (input) {
|
||
return function () {
|
||
callback(cards);
|
||
};
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.showCardsByIdAsyn = function (ids,label) {
|
||
var player = this;
|
||
// player.opponent.output({
|
||
// type: 'WAIT_FOR_OPPONENT',
|
||
// content: {
|
||
// operation: 'CONFIRM'
|
||
// }
|
||
// });
|
||
player.output({
|
||
type: 'SHOW_CARDS_BY_ID',
|
||
content: {
|
||
label: label || 'CONFIRM',
|
||
ids: ids
|
||
}
|
||
});
|
||
return new Callback(function (callback) {
|
||
player.listen('OK',function (input) {
|
||
return function () {
|
||
callback();
|
||
};
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.revealAsyn = function (n) {
|
||
return Callback.immediately().callback(this,function () {
|
||
var source = this.game.getEffectSource();
|
||
if (!source) return 0;
|
||
if (source.player !== this) return 0;
|
||
if (!this.additionalRevealCount) return 0;
|
||
return this.selectNumberAsyn('REVEAL_MORE',0,this.additionalRevealCount,this.additionalRevealCount);
|
||
}).callback(this,function (num) {
|
||
n += num;
|
||
var cards = this.mainDeck.getTopCards(n);
|
||
return this.showCardsAsyn(cards).callback(this,function () {
|
||
return this.opponent.showCardsAsyn(cards).callback(this,function () {
|
||
return cards;
|
||
});
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.showColorsAsyn = function (colors) {
|
||
var player = this;
|
||
// player.opponent.output({
|
||
// type: 'WAIT_FOR_OPPONENT',
|
||
// content: {
|
||
// operation: 'CONFIRM'
|
||
// }
|
||
// });
|
||
player.output({
|
||
type: 'SHOW_COLORS',
|
||
content: {
|
||
colors: colors
|
||
}
|
||
});
|
||
return new Callback(function (callback) {
|
||
player.listen('OK',function (input) {
|
||
return function () {
|
||
callback();
|
||
};
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.showCardTypesAsyn = function (types) {
|
||
var player = this;
|
||
// player.opponent.output({
|
||
// type: 'WAIT_FOR_OPPONENT',
|
||
// content: {
|
||
// operation: 'CONFIRM'
|
||
// }
|
||
// });
|
||
player.output({
|
||
type: 'SHOW_TYPES',
|
||
content: {
|
||
types: types
|
||
}
|
||
});
|
||
return new Callback(function (callback) {
|
||
player.listen('OK',function (input) {
|
||
return function () {
|
||
callback();
|
||
};
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.showEffectsAsyn = function (effects) {
|
||
var player = this;
|
||
// player.opponent.output({
|
||
// type: 'WAIT_FOR_OPPONENT',
|
||
// content: {
|
||
// operation: 'CONFIRM'
|
||
// }
|
||
// });
|
||
player.output({
|
||
type: 'SHOW_EFFECTS',
|
||
content: {
|
||
effects: effects.map(function (eff) {
|
||
return eff.description;
|
||
})
|
||
}
|
||
});
|
||
return new Callback(function (callback) {
|
||
player.listen('OK',function (input) {
|
||
return function () {
|
||
callback();
|
||
};
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.showTextAsyn = function (title,type,content) {
|
||
var player = this;
|
||
// player.opponent.output({
|
||
// type: 'WAIT_FOR_OPPONENT',
|
||
// content: {
|
||
// operation: 'CONFIRM'
|
||
// }
|
||
// });
|
||
player.output({
|
||
type: 'SHOW_TEXT',
|
||
content: {
|
||
type: type,
|
||
title: title,
|
||
content: content
|
||
}
|
||
});
|
||
return new Callback(function (callback) {
|
||
player.listen('OK',function (input) {
|
||
return function () {
|
||
callback();
|
||
};
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.selectNumberAsyn = function (label,min,max,defaultValue) {
|
||
if (defaultValue === undefined) {
|
||
defaultValue = min;
|
||
}
|
||
var player = this;
|
||
player.output({
|
||
type: 'SELECT_NUMBER',
|
||
content: {
|
||
label: label,
|
||
min: min,
|
||
max: max,
|
||
defaultValue: defaultValue
|
||
}
|
||
});
|
||
return new Callback(function (callback) {
|
||
player.listen(label,function (num) {
|
||
num = num >>> 0;
|
||
if (!((num >= min) && (num <= max))) return false;
|
||
return function () {
|
||
callback(num);
|
||
};
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.declareAsyn = function (min,max) {
|
||
return this.selectNumberAsyn('DECLARE',min,max).callback(this,function (num) {
|
||
return this.opponent.showTextAsyn('DECLARE','number',num).callback(this,function () {
|
||
return num;
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.declareCardIdAsyn = function () {
|
||
return this.selectCardIdAsyn('DECLARE').callback(this,function (pid) {
|
||
return this.opponent.showCardsByIdAsyn([pid],'DECLARE').callback(this,function () {
|
||
return pid;
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.selectTextAsyn = function (label,texts,type) {
|
||
var player = this;
|
||
if (!texts.length) return Callback.immediately(null);
|
||
player.output({
|
||
type: 'SELECT_TEXT',
|
||
content: {
|
||
label: label,
|
||
texts: texts,
|
||
type: type || ''
|
||
}
|
||
});
|
||
return new Callback(function (callback) {
|
||
player.listen(label,function (idx) {
|
||
idx = idx >>> 0;
|
||
var text = texts[idx];
|
||
if (!text) return false;
|
||
return function () {
|
||
callback(text);
|
||
};
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.selectCardIdAsyn = function (label) {
|
||
var player = this;
|
||
player.output({
|
||
type: 'SELECT_CARD_ID',
|
||
content: {
|
||
label: label
|
||
}
|
||
});
|
||
return new Callback(function (callback) {
|
||
player.listen(label,function (pid) {
|
||
pid = pid >>> 0;
|
||
if (!CardInfo[pid]) return false;
|
||
return function () {
|
||
callback(pid);
|
||
};
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.confirmAsyn = function (text) {
|
||
var player = this;
|
||
player.output({
|
||
type: 'CONFIRM',
|
||
content: {
|
||
text: text
|
||
}
|
||
});
|
||
return new Callback(function (callback) {
|
||
player.listen('OK',function (answer) {
|
||
return function () {
|
||
callback(!!answer);
|
||
};
|
||
});
|
||
});
|
||
};
|
||
|
||
// 令玩家获得cards的pid.
|
||
Player.prototype.informCards = function (cards) {
|
||
this.output({
|
||
type: 'INFORM_CARDS',
|
||
content: {
|
||
cards: cards,
|
||
pids: cards.map(function (card) {
|
||
return card.pid;
|
||
},this)
|
||
}
|
||
});
|
||
};
|
||
|
||
// needEner(obj)
|
||
// obj是一个包含 costWhite 等属性的对象 (cost对象),
|
||
// 如果obj的所有cost为零,返回false,否则true
|
||
Player.prototype.needEner = function (obj) {
|
||
if (obj.costChange) {
|
||
obj = obj.costChange();
|
||
}
|
||
var costs = [obj.costColorless,obj.costWhite,obj.costBlack,obj.costRed,obj.costBlue,obj.costGreen];
|
||
return costs.some(function (cost) {
|
||
return cost > 0;
|
||
});
|
||
};
|
||
|
||
Player.prototype.getTotalEnerCost = function (obj,original) {
|
||
if (!original && obj.costChange) {
|
||
obj = obj.costChange();
|
||
}
|
||
var props = [
|
||
'costColorless',
|
||
'costWhite',
|
||
'costBlack',
|
||
'costRed',
|
||
'costBlue',
|
||
'costGreen',
|
||
];
|
||
var total = 0;
|
||
props.forEach(function (prop) {
|
||
total += (original? this.game.getOriginalValue(obj,prop) : obj[prop]) || 0;
|
||
},this);
|
||
return total;
|
||
};
|
||
|
||
Player.prototype.needCost = function (obj) {
|
||
if (obj.costChange) {
|
||
obj = obj.costChange();
|
||
}
|
||
if (obj.costCoin) return true;
|
||
if (obj.costDown && obj.source) return true;
|
||
if (obj.costAsyn && obj.source) return true;
|
||
if (obj.costExceed && obj.source) return true;
|
||
if (this.needEner(obj)) return true;
|
||
return false;
|
||
};
|
||
|
||
Player.prototype.checkRequirements = function (items, requirements) {
|
||
var n = requirements.length
|
||
var len = 1 << n
|
||
var arr = (typeof Uint8Array === 'undefined') ? new Array(len) : new Uint8Array(len)
|
||
// 第 i 条不等式。
|
||
// 假设 n == 4，即有 4 种元需求：
|
||
// i 为从 0000 到 1111，从右到左分别称为第 1,2,3,4 位
|
||
// 当 i == 0110 时，代表不等式左边为第 2、3 个集合的并集
|
||
for (var i = 0; i < len; i++) {
|
||
var filters = []
|
||
for (var j = 0; j < n; j++) {
|
||
if (i & (1 << j)) {
|
||
filters.push(requirements[j].filter)
|
||
// 不等式的右边（先把需求数加上去，满足的时候减 1，减至 0 则满足该不等式）
|
||
arr[i] += requirements[j].count
|
||
}
|
||
}
|
||
// 遍历能量区，满足条件的减 1
|
||
for (var j = 0; j < items.length; j++) {
|
||
var item = items[j]
|
||
if (filters.some(function (filter) {
|
||
return filter(item)
|
||
})) {
|
||
// 减至 0，该不等式成立
|
||
if (!--arr[i]) break
|
||
}
|
||
}
|
||
if (arr[i]) return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
Player.prototype.cardToInteger = function (card) {
|
||
var int = 0
|
||
if (card.hasColor('white')) int |= 1 // 0b00001
|
||
if (card.hasColor('black')) int |= 2 // 0b00010
|
||
if (card.hasColor('green')) int |= 4 // 0b00100
|
||
if (card.hasColor('blue')) int |= 8 // 0b01000
|
||
if (card.hasColor('red')) int |= 16 // 0b10000
|
||
return int
|
||
}
|
||
Player.prototype.canUseBikou = function (obj) {
|
||
return obj.useBikouAsWhiteCost || this.useBikouAsWhiteCost
|
||
}
|
||
Player.prototype.encodeCard = function (card, costObj) {
|
||
// card => 01011 (红蓝绿黑白)
|
||
var int = 0
|
||
if (card.multiEner) {
|
||
int = 31 // 0b11111
|
||
} else {
|
||
int = this.cardToInteger(card)
|
||
}
|
||
// 美巧
|
||
if (this.canUseBikou(costObj) && card.hasClass('美巧')) {
|
||
int |= 1
|
||
}
|
||
if (card.trashAsWhiteCost) {
|
||
int |= 1
|
||
}
|
||
// <小剑 三日月>
|
||
if (card._MikamuneSmallSword) {
|
||
int |= this.cardToInteger(this.lrig)
|
||
}
|
||
return int
|
||
}
|
||
Player.prototype.encodeCost = function (cost, withoutFilter) {
|
||
// cost => [{ count: 3, mask: 0b00001, filter: () => ... }, ...]
|
||
var requirements = []
|
||
if (cost.costColorless) {
|
||
if (cost._2286) {
|
||
requirements.push({ count: cost.costColorless, mask: this.cardToInteger(this.lrig) })
|
||
} else {
|
||
requirements.push({ count: cost.costColorless, mask: 0 })
|
||
}
|
||
}
|
||
if (cost.costWhite) requirements.push({ count: cost.costWhite, mask: 1 })
|
||
if (cost.costBlack) requirements.push({ count: cost.costBlack, mask: 2 })
|
||
if (cost.costGreen) requirements.push({ count: cost.costGreen, mask: 4 })
|
||
if (cost.costBlue) requirements.push({ count: cost.costBlue, mask: 8 })
|
||
if (cost.costRed) requirements.push({ count: cost.costRed, mask: 16 })
|
||
if (!withoutFilter) {
|
||
requirements.forEach(function (item) {
|
||
item.filter = function (int) {
|
||
return !item.mask || (int & item.mask)
|
||
}
|
||
})
|
||
}
|
||
return requirements
|
||
}
|
||
Player.prototype._checkEner = function (cards,cost) {
|
||
var items = cards.map(this.encodeCard.bind(this))
|
||
var requirements = this.encodeCost(cost)
|
||
var enough = this.checkRequirements(items,requirements)
|
||
var total = requirements.reduce(function (total,requirement) {
|
||
return total + requirement.count
|
||
}, 0)
|
||
return {
|
||
left: enough? items.length - total : -1,
|
||
}
|
||
}
|
||
|
||
// 御先狐...
|
||
Player.prototype.checkEner = function (cards,obj,ignoreReplacement) {
|
||
if (obj.costChange) {
|
||
obj = obj.costChange();
|
||
}
|
||
obj = Object.create(obj);
|
||
obj.costGreen = obj.costGreen || 0;
|
||
cards = cards.slice();
|
||
var osakiCards = cards.filter(function (card) {
|
||
return card._KosakiPhantomBeast;
|
||
},this);
|
||
var minOsaki = 0;
|
||
var maxOsaki = Math.min(osakiCards.length,Math.floor(obj.costGreen/2));
|
||
for (var i = 0; i <= maxOsaki; i++) {
|
||
var result = this._checkEner(cards,obj);
|
||
if (ignoreReplacement || (result.left >= 0)) break;
|
||
minOsaki++;
|
||
removeFromArr(osakiCards[i],cards);
|
||
obj.costGreen = Math.max(0,obj.costGreen - 3);
|
||
}
|
||
result.osakiCards = osakiCards;
|
||
result.minOsaki = minOsaki;
|
||
result.maxOsaki = maxOsaki;
|
||
return result;
|
||
};
|
||
// _checkEner(cards,obj)
|
||
// obj是个cost对象,cards是用来支付能量的卡.
|
||
// 返回一个带 left,minBikou,maxBikou,bikouCards 属性的对象.
|
||
// left: 支付后剩余的卡片数. (若为负数,表示无法完成支付)
|
||
// minBikou: 表示至少要支付的美巧数量.
|
||
// maxBikou: 表示至多可以支付的美巧数量.
|
||
// bikouCards: 可以用于代替白色费用的美巧卡.
|
||
// 注: 由于后来出现了<美しき弦奏 コントラ>,这里的美巧也指这张卡.
|
||
// Player.prototype._checkEner = function (cards,obj,ignoreReplacement) {
|
||
// var minBikou = 0;
|
||
// var maxBikou = 0;
|
||
// var bikouCards = [];
|
||
// // 以下变量表示对应颜色的卡的盈余量. (盈余=存在-需求,负数则表示不足)
|
||
// // 减掉需求
|
||
// var colorless = -obj.costColorless || 0;
|
||
// var white = -obj.costWhite || 0;
|
||
// var black = -obj.costBlack || 0;
|
||
// var red = -obj.costRed || 0;
|
||
// var blue = -obj.costBlue || 0;
|
||
// var green = -obj.costGreen || 0;
|
||
// var multi = 0;
|
||
// // 美巧
|
||
// var useBikou = !ignoreReplacement && this.canUseBikou(obj);
|
||
// var bikou = 0;
|
||
// var costWhite = obj.costWhite || 0;
|
||
// // <小剑 三日月>
|
||
// var mikamune = 0;
|
||
// var lrig = this.lrig;
|
||
|
||
// // 加上存在
|
||
// cards.forEach(function (card) {
|
||
// if (card.multiEner) multi++;
|
||
// else if (card.color === 'colorless') colorless++;
|
||
// else if (card.color === 'white' ) white++;
|
||
// else if (card.color === 'black' ) black++;
|
||
// else if (card.color === 'red' ) red++;
|
||
// else if (card.color === 'blue' ) blue++;
|
||
// else if (card.color === 'green' ) green++;
|
||
// // <小剑 三日月>
|
||
// if (card._MikamuneSmallSword && !card.multiEner && (card.color !== lrig.color)) {
|
||
// mikamune++;
|
||
// }
|
||
// },this);
|
||
// // <小剑 三日月>
|
||
// // 借与LRIG颜色相同的卡
|
||
// if (lrig.color === 'white') white += mikamune;
|
||
// else if (lrig.color === 'black') black += mikamune;
|
||
// else if (lrig.color === 'red') red += mikamune;
|
||
// else if (lrig.color === 'blue') blue += mikamune;
|
||
// else if (lrig.color === 'green') green += mikamune;
|
||
// else mikamune = 0;
|
||
// // 美巧
|
||
// if (useBikou) {
|
||
// bikouCards = cards.filter(function (card) {
|
||
// return card.hasClass('美巧');
|
||
// },this);
|
||
// } else {
|
||
// bikouCards = cards.filter(function (card) {
|
||
// return card.trashAsWhiteCost; // <美しき弦奏 コントラ>
|
||
// },this);
|
||
// }
|
||
// bikou = bikouCards.length;
|
||
|
||
// // 于是此时变量的值即为盈余值. (负数表示不足)
|
||
|
||
// // 先考虑白色
|
||
// if (white >= 0) {
|
||
// maxBikou = Math.min(bikou,costWhite);
|
||
// colorless += white; // 盈余的数量加到无色上.
|
||
// } else {
|
||
// minBikou = Math.min(-white,bikou);
|
||
// bikou += white; // 不足的数量用美巧代替.
|
||
// green += white; // 注意绿色也同时减少了.
|
||
// if (bikou < 0) {
|
||
// // 若用美巧代替之后还是不足,则用万花色代替.
|
||
// multi += bikou; // 不足的数量用万花色代替.
|
||
// green -= bikou; // 注意因为用万花色代替了,所以绿色的盈余增加.
|
||
// if (multi < 0) {
|
||
// // 万花色不足,无法完成支付.
|
||
// return {left: -1,minBikou: 0,maxBikou: 0,bikouCards: []};
|
||
// }
|
||
// } else {
|
||
// maxBikou = Math.min(bikou,costWhite - minBikou);
|
||
// }
|
||
// }
|
||
|
||
// // 然后考虑剩下的颜色,除了无色
|
||
// if (![black,red,blue,green].every(function (count) {
|
||
// if (count >= 0) {
|
||
// colorless += count; // 盈余的数量加到无色上.
|
||
// return true;
|
||
// }
|
||
// multi += count; // 不足的数量用万花色代替.
|
||
// return multi >= 0; // 万花色不足,无法完成支付.
|
||
// })) return {left: -1,minBikou: 0,maxBikou: 0,bikouCards: []};
|
||
|
||
// maxBikou = minBikou + Math.min(maxBikou,Math.max(0,green) + multi);
|
||
// minBikou = Math.max(0,minBikou - multi);
|
||
|
||
// // 最后考虑无色.
|
||
// colorless += multi; // 盈余的数量加到无色上.
|
||
// colorless -= mikamune; // 还回从<小剑 三日月>借来的卡.
|
||
|
||
// return {
|
||
// left: colorless, // 此时无色的盈余量即为支付能力后剩下的卡片数.
|
||
// bikouCards: bikouCards,
|
||
// minBikou: minBikou,
|
||
// maxBikou: maxBikou
|
||
// };
|
||
// };
|
||
|
||
// 注意 costSigniColorless 是指任意颜色的signi作为cost
|
||
// Player.prototype.enoughSigniCost = function (obj) {
|
||
// var white = obj.costSigniWhite || 0;
|
||
// var black = obj.costSigniBlack || 0;
|
||
// var red = obj.costSigniRed || 0;
|
||
// var blue = obj.costSigniBlue || 0;
|
||
// var green = obj.costSigniGreen || 0;
|
||
// var colorless = obj.costSigniColorless || 0;
|
||
// for (var i = 0; i < this.hands.length; i++) {
|
||
// var card = this.hands[i];
|
||
// if (card.type !== 'SIGNI') continue;
|
||
|
||
// if (card.color === 'white') {
|
||
// white? white-- : colorless--;
|
||
// } else if (card.color === 'black') {
|
||
// black? black-- : colorless--;
|
||
// } else if (card.color === 'red') {
|
||
// red? red-- : colorless--;
|
||
// } else if (card.color === 'blue') {
|
||
// blue? blue-- : colorless--;
|
||
// } else if (card.color === 'green') {
|
||
// green? green-- : colorless--;
|
||
// } else {
|
||
// colorless--;
|
||
// }
|
||
// }
|
||
// return [white,black,red,blue,green,colorless].some(function (need) {
|
||
// return need > 0;
|
||
// });
|
||
// };
|
||
|
||
// 玩家是否有足够的能量来支付obj指定的费用
|
||
Player.prototype.enoughEner = function (obj) {
|
||
if (obj.costChange) {
|
||
obj = obj.costChange();
|
||
}
|
||
return this.checkEner(this.enerZone.cards,obj).left >= 0;
|
||
};
|
||
Player.prototype.enoughExceed = function (obj) {
|
||
var lrig = obj.source;
|
||
return lrig.zone.cards.length > obj.costExceed;
|
||
};
|
||
Player.prototype.enoughCost = function (obj) {
|
||
if (obj.costChange) {
|
||
obj = obj.costChange();
|
||
}
|
||
if (obj.costCoin && obj.costCoin > this.coin) return false;
|
||
if (obj.costDown && obj.source && !obj.source.isUp) return false;
|
||
if (obj.costCondition && obj.source) {
|
||
if (!obj.costCondition.call(obj.source)) return false;
|
||
}
|
||
if (obj.costExceed && obj.source) {
|
||
if (!this.enoughExceed(obj)) return false;
|
||
}
|
||
if (!this.enoughEner(obj)) return false;
|
||
return true;
|
||
};
|
||
|
||
// Player.prototype.selectSigniCost = function (obj) {
|
||
// if ((!this.needSigniCost(obj))) return Callback.immediately([]);
|
||
// };
|
||
// 要求玩家选择能量
|
||
Player.prototype.selectEnerAsyn = function (obj,cancelable) {
|
||
if (obj.costChange) {
|
||
obj = obj.costChange();
|
||
}
|
||
if (!this.needEner(obj)) return Callback.immediately([]);
|
||
|
||
var player = this;
|
||
player.output({
|
||
type: 'PAY_ENER',
|
||
content: {
|
||
source: obj.source || 0,
|
||
cancelable: !!cancelable,
|
||
cards: this.enerZone.cards,
|
||
integers: this.enerZone.cards.map(this.encodeCard.bind(this)),
|
||
requirements: this.encodeCost(obj, true),
|
||
},
|
||
});
|
||
// player.opponent.output({
|
||
// type: 'WAIT_FOR_OPPONENT',
|
||
// content: {
|
||
// operation: 'PAY_ENER'
|
||
// }
|
||
// });
|
||
|
||
return new Callback(function (callback) {
|
||
player.listen('PAY_ENER',function (idxs) {
|
||
if (idxs === null) {
|
||
// cancel
|
||
if (!cancelable) return false;
|
||
return function () {
|
||
callback(null);
|
||
}
|
||
}
|
||
if (!isArr(idxs)) return false;
|
||
var cards = idxs.map(function (idx) {
|
||
return player.enerZone.cards[idx];
|
||
});
|
||
var legal = cards.every(function (card,idx) {
|
||
return inArr(card,player.enerZone.cards) && cards.indexOf(card) >= idx;
|
||
});
|
||
if (!legal || player.checkEner(cards,obj,true).left !== 0) return false;
|
||
return function () {
|
||
callback(cards);
|
||
}
|
||
})
|
||
});
|
||
};
|
||
|
||
Player.prototype.selectExceedAsyn = function (obj) {
|
||
var cards = obj.source.zone.cards.slice(1);
|
||
var n = obj.costExceed;
|
||
return this.selectSomeAsyn('PAY_EXCEED',cards,n,n);
|
||
};
|
||
|
||
// 支付Cost
|
||
Player.prototype.payCostAsyn = function (obj,cancelable) {
|
||
this.game.frameStart();
|
||
return Callback.immediately().callback(this,function () {
|
||
if (obj.costChangeAsyn) {
|
||
cancelable = false;
|
||
// 需要异步操作的费用改变,如<虹彩・横置>等.
|
||
return obj.costChangeAsyn().callback(this,function (o) {
|
||
obj = o;
|
||
});
|
||
} else if (obj.costChange) {
|
||
// 费用改变
|
||
obj = obj.costChange();
|
||
}
|
||
}).callback(this,function () {
|
||
// 御先狐
|
||
var o = this.checkEner(this.enerZone.cards,obj);
|
||
if (o.left < 0) {
|
||
throw new Error('No enough ener to pay! obj.cid:' + obj.cid);
|
||
}
|
||
if (o.maxOsaki) {
|
||
var min = o.minOsaki;
|
||
var max = o.maxOsaki;
|
||
return this.selectSomeAsyn('TRASH_OSAKI',o.osakiCards,min,max).callback(this,function (cards) {
|
||
if (!cards.length) return;
|
||
cancelable = false;
|
||
this.game.trashCards(cards);
|
||
obj = Object.create(obj);
|
||
obj.costGreen -= cards.length * 3;
|
||
if (obj.costGreen < 0) obj.costGreen = 0;
|
||
});
|
||
}
|
||
}).callback(this,function () {
|
||
// 选择能量
|
||
var costArg = {};
|
||
return this.selectEnerAsyn(obj,cancelable).callback(this,function (cards) {
|
||
if (!cards) {
|
||
// 取消
|
||
this.game.frameEnd();
|
||
return null;
|
||
}
|
||
return Callback.immediately().callback(this,function () {
|
||
costArg.enerCards = cards;
|
||
costArg.enerColors = cards.map(function (card) {
|
||
if (card.multiEner) return 'multi';
|
||
return card.color;
|
||
},this);
|
||
this.game.trashCards(cards);
|
||
// 超越
|
||
if (obj.costExceed && obj.source) {
|
||
return this.selectExceedAsyn(obj).callback(this,function (cards) {
|
||
costArg.exceedCards = cards;
|
||
this.game.trashCards(cards,{isExceedCost: true});
|
||
});
|
||
}
|
||
}).callback(this,function () {
|
||
// 横置
|
||
if (obj.costDown && obj.source) {
|
||
obj.source.down();
|
||
}
|
||
// Coin
|
||
if (obj.costCoin) {
|
||
this.loseCoins(obj.costCoin);
|
||
costArg.bet = obj.costCoin;
|
||
}
|
||
// 其它
|
||
if (obj.costAsyn) {
|
||
if (obj.source) return obj.costAsyn.call(obj.source);
|
||
return obj.costAsyn();
|
||
}
|
||
}).callback(this,function (others) {
|
||
costArg.others = others;
|
||
this.game.frameEnd();
|
||
return costArg;
|
||
});
|
||
});
|
||
});
|
||
};
|
||
|
||
// player.selectAsyn(label,cards,optional,needConfirm)
|
||
// 玩家从cards中选一张卡,
|
||
// 若cards为null或空数组:
|
||
// 若!needConfirm,那么立即callback(null).
|
||
// 否则等玩家确认,然后callback(null).
|
||
// 若cards非空:
|
||
// 若optional,玩家可以不选(返回null).
|
||
// 否则,玩家必须从cards中选一张卡,callback返回这张卡.
|
||
// callback(null|card)
|
||
Player.prototype.selectAsyn = function (label,cards,optional,needConfirm) {
|
||
if (cards && !cards.length && !needConfirm) {
|
||
return Callback.immediately(null);
|
||
}
|
||
|
||
if (!cards) {
|
||
return this.selectSomeAsyn(label,[]).callback(this,function () {
|
||
return null;
|
||
});
|
||
}
|
||
|
||
var min = optional? 0 : 1;
|
||
return this.selectSomeAsyn(label,cards,min,1).callback(this,function (selectedCards) {
|
||
return selectedCards[0] || null;
|
||
});
|
||
};
|
||
|
||
Player.prototype.selectOptionalAsyn = function (label,cards,needConfirm) {
|
||
return this.selectAsyn(label,cards,true,needConfirm);
|
||
};
|
||
|
||
Player.prototype.selectTargetAsyn = function (cards,optional,needConfirm) {
|
||
return this.selectAsyn('TARGET',cards,optional,needConfirm).callback(this,function (card) {
|
||
if (card) {
|
||
card.beSelectedAsTarget();
|
||
}
|
||
return card;
|
||
});
|
||
};
|
||
|
||
Player.prototype.selectTargetOptionalAsyn = function (cards,needConfirm) {
|
||
return this.selectTargetAsyn(cards,true,needConfirm);
|
||
};
|
||
|
||
Player.prototype.selectSomeTargetsAsyn = function (cards,min,max,careOrder) {
|
||
return this.selectSomeAsyn('TARGET',cards,min,max,careOrder).callback(this,function (selectedCards) {
|
||
selectedCards.forEach(function (card) {
|
||
card.beSelectedAsTarget();
|
||
},this);
|
||
return selectedCards;
|
||
})
|
||
};
|
||
|
||
Player.prototype.selectSomeAsyn = function (label,items,min,max,careOrder,extraCards) {
|
||
// 过滤 shadow 目标
|
||
items = items.filter(item => {
|
||
var source = this.game.getEffectSource();
|
||
if (item.shadow && source && source.player !== item.player) {
|
||
return false;
|
||
}
|
||
return true;
|
||
});
|
||
if (!(min >= 0)) min = 0;
|
||
if (max === undefined || max < 0) {
|
||
max = items.length;
|
||
}
|
||
min = Math.min(min,items.length);
|
||
max = Math.min(max,items.length);
|
||
careOrder = !!careOrder;
|
||
extraCards = extraCards || [];
|
||
|
||
var cards = items;
|
||
var descriptions = [];
|
||
var sample = items[0];
|
||
if (sample && sample.source) {
|
||
// 选项是效果
|
||
cards = items.map(function (effect) {
|
||
return effect.source || null;
|
||
});
|
||
descriptions = items.map(function (effect) {
|
||
return effect.description || '';
|
||
});
|
||
}
|
||
|
||
var player = this;
|
||
player.output({
|
||
type: 'SELECT',
|
||
content: {
|
||
label: label,
|
||
options: cards,
|
||
descriptions: descriptions,
|
||
extraCards: extraCards,
|
||
extraPids: extraCards.map(function (card) {
|
||
return card.pid;
|
||
}),
|
||
min: min,
|
||
max: max,
|
||
careOrder: careOrder
|
||
}
|
||
});
|
||
// player.opponent.output({
|
||
// type: 'WAIT_FOR_OPPONENT',
|
||
// content: {
|
||
// operation: '' // 注意!
|
||
// }
|
||
// });
|
||
return new Callback(function (callback) {
|
||
player.listen(label,function (idxs) {
|
||
if (!isArr(idxs)) return false;
|
||
if (idxs.length > max) return false;
|
||
if (idxs.length < min) return false;
|
||
if (!careOrder) {
|
||
idxs.sort(function (a,b) {
|
||
return a - b;
|
||
});
|
||
}
|
||
var selectedItems = idxs.map(function (idx) {
|
||
if ((idx >= 0) && (idx < items.length)) {
|
||
return items[idx];
|
||
}
|
||
return null;
|
||
},this);
|
||
var legal = selectedItems.every(function (item,i) {
|
||
return item && (selectedItems.indexOf(item) === i);
|
||
},this);
|
||
if (!legal) return false;
|
||
return function () {
|
||
callback(selectedItems);
|
||
}
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.selectByFilterAsyn = function (filter,optional,cards) {
|
||
var cards = filter? cards.filter(filter) : cards;
|
||
return optional? this.selectTargetOptionalAsyn(cards) : this.selectTargetAsyn(cards);
|
||
};
|
||
|
||
Player.prototype.selectOpponentSigniAsyn = function (filter,optional) {
|
||
return this.selectByFilterAsyn(filter,optional,this.opponent.signis);
|
||
};
|
||
|
||
Player.prototype.selectSelfSigniAsyn = function (filter,optional) {
|
||
return this.selectByFilterAsyn(filter,optional,this.signis);
|
||
};
|
||
|
||
Player.prototype.searchAsyn = function (filter,max,min,dontShow) {
|
||
var cards = this.mainDeck.cards.filter(filter,this);
|
||
max = Math.min(max,cards.length);
|
||
min = min || 0;
|
||
min = Math.min(min,cards.length);
|
||
return this.selectSomeAsyn('SEEK',cards,min,max,false,this.mainDeck.cards).callback(this,function (cards) {
|
||
if (dontShow) {
|
||
this.shuffle();
|
||
return cards;
|
||
}
|
||
return this.opponent.showCardsAsyn(cards).callback(this,function () {
|
||
this.shuffle();
|
||
return cards;
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.seekAsyn = function (filter,max,min,dontShow) {
|
||
return this.searchAsyn(filter,max,min,dontShow).callback(this,function (cards) {
|
||
this.game.moveCards(cards,this.handZone);
|
||
return cards;
|
||
});
|
||
};
|
||
|
||
Player.prototype.seekAndSummonAsyn = function (filter,n,dontTriggerStartUp) {
|
||
var done = false;
|
||
var rtnCards = [];
|
||
this.game.frameStart();
|
||
return Callback.loop(this,n,function () {
|
||
if (done) return;
|
||
var cards = this.mainDeck.cards.filter(function (card) {
|
||
return card.canSummon() && filter(card);
|
||
},this);
|
||
return this.selectSomeAsyn('SEEK',cards,0,1,false,this.mainDeck.cards).callback(this,function (cards) {
|
||
var card = cards[0];
|
||
if (!card) {
|
||
done = true;
|
||
return;
|
||
};
|
||
rtnCards.push(card);
|
||
return card.summonAsyn(false,dontTriggerStartUp);
|
||
});
|
||
}).callback(this,function () {
|
||
this.shuffle();
|
||
this.game.frameEnd();
|
||
return rtnCards;
|
||
});
|
||
};
|
||
|
||
Player.prototype.pickCardAsyn = function (filter,min,max,zone) {
|
||
if (!isNum(min)) min = 1;
|
||
if (!isNum(max)) max = 1;
|
||
if (!zone) zone = this.trashZone;
|
||
var cards = filter? zone.cards.filter(filter) : zone.cards;
|
||
return this.selectSomeAsyn('ADD_TO_HAND',cards,min,max).callback(this,function (cards) {
|
||
if (!cards.length) return;
|
||
return this.opponent.showCardsAsyn(cards).callback(this,function () {
|
||
this.game.moveCards(cards,this.handZone);
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.rebornAsyn = function (filter,count,arg) {
|
||
if (!isNum(count)) count = 1;
|
||
if (!arg) arg = {};
|
||
var done = false;
|
||
return Callback.loop(this,count,function () {
|
||
if (done) return;
|
||
var cards = this.trashZone.cards.filter(function (card) {
|
||
if (filter && !filter(card)) return false;
|
||
return card.canSummon();
|
||
},this);
|
||
return this.selectAsyn('SUMMON_SIGNI',cards).callback(this,function (card) {
|
||
if (!card) return done = true;
|
||
return card.summonAsyn(false,arg.dontTriggerStartUp,arg.down);
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.rearrangeOpponentSignisAsyn = function () {
|
||
return this.rearrangeSignisAsyn(this.opponent);
|
||
};
|
||
|
||
Player.prototype.rearrangeSignisAsyn = function (whos) {
|
||
if (!whos) whos = this;
|
||
var done = false;
|
||
var signis = whos.signis.filter(function (signi) {
|
||
return !signi.isEffectFiltered();
|
||
},this);
|
||
var zones = whos.signiZones.filter(function (zone) {
|
||
if (zone.disabled) return false;
|
||
return (!zone.cards.length) || (!zone.cards[0].isEffectFiltered());
|
||
},this);
|
||
|
||
var changedSignis = [];
|
||
return Callback.loop(this,2,function () {
|
||
if (done) return;
|
||
if (!signis.length || (zones.length <= 1)) return;
|
||
return this.selectTargetOptionalAsyn(signis).callback(this,function (signi) {
|
||
if (!signi) {
|
||
done = true;
|
||
return;
|
||
}
|
||
removeFromArr(signi,signis);
|
||
var _zones = zones.filter(function (zone) {
|
||
return (zone !== signi.zone);
|
||
},this);
|
||
return this.selectOptionalAsyn('RESET_SIGNI_ZONE',_zones).callback(this,function (zone) {
|
||
if (!zone) return;
|
||
removeFromArr(zone,zones);
|
||
var card = zone.cards[0];
|
||
if (signi.changeSigniZone(zone)) {
|
||
if (!inArr(signi,changedSignis)) changedSignis.push(signi);
|
||
if (card && !inArr(card,changedSignis)) changedSignis.push(card);
|
||
}
|
||
});
|
||
});
|
||
}).callback(this,function () {
|
||
return changedSignis;
|
||
});
|
||
};
|
||
|
||
Player.prototype.listen = function (label,handle) {
|
||
this.listener[label] = handle;
|
||
};
|
||
|
||
Player.prototype.input = function (data) {
|
||
// if (!isArr(data)) return false;
|
||
// if (data.length !== 2) return false;
|
||
// var label = data[0];
|
||
// var input = data[1];
|
||
if (!isObj(data)) return false;
|
||
var label = data.label;
|
||
var input = data.input;
|
||
if (!isStr(label)) return false;
|
||
var handle = this.listener[label];
|
||
if (!isFunc(handle)) return false;
|
||
var callback = handle(input);
|
||
if (!isFunc(callback)) return false;
|
||
this.listener = {};
|
||
// var p = (this === this.game.hostPlayer)? 'hostPlayer' : 'guestPlayer';
|
||
// if (!window.inputs) window.inputs = '';
|
||
// window.inputs += ('game.'+p+'.input("'+label+'",['+input.toString()+']);');
|
||
// console.time(label);
|
||
callback();
|
||
// console.timeEnd(label);
|
||
this.game.sendMsgQueue();
|
||
if (this.game.winner) {
|
||
this.game.gameover();
|
||
}
|
||
return true;
|
||
};
|
||
|
||
Player.prototype.output = function (msgObj) {
|
||
// var start = Date.now();
|
||
msgObj = this.handleMsgObj(msgObj);
|
||
// var end = Date.now();
|
||
// console.log('player.handleMsgObj() '+(end-start)+'ms');
|
||
this.msgQueue.push(msgObj);
|
||
};
|
||
|
||
Player.prototype.sendMsgQueue = function () {
|
||
var queue = this.msgQueue.slice();
|
||
this.messagePacks.push(queue);
|
||
this.io.send(queue);
|
||
this.msgQueue.length = 0;
|
||
};
|
||
|
||
Player.prototype.handleMsgObj = function (v) {
|
||
if (isArr(v)) {
|
||
var arr = v;
|
||
var newArr = []
|
||
arr.forEach(function (item) {
|
||
newArr.push(this.handleMsgObj(item));
|
||
},this);
|
||
return newArr;
|
||
}
|
||
if (isObj(v)) {
|
||
var obj = v;
|
||
var sid = this.game.getSid(this,obj);
|
||
if (isNum(sid)) return sid;
|
||
var newObj = {};
|
||
for (var x in obj) {
|
||
newObj[x] = this.handleMsgObj(obj[x]);
|
||
}
|
||
return newObj;
|
||
}
|
||
return v;
|
||
};
|
||
|
||
Player.prototype.ignoreGrowCostInNextTurn = function () {
|
||
this.ignoreGrowCost = true;
|
||
};
|
||
|
||
Player.prototype.trashLifeClothWhenTurnEnd = function (n) {
|
||
this._trashLifeClothCount += n;
|
||
};
|
||
|
||
Player.prototype.getCharms = function () {
|
||
var charms = [];
|
||
this.signis.forEach(function (signi) {
|
||
if (signi.charm) {
|
||
charms.push(signi.charm);
|
||
}
|
||
},this);
|
||
return charms;
|
||
};
|
||
|
||
Player.prototype.setCrossPair = function () {
|
||
// 清除已有CP
|
||
this.crossed.forEach(function (pair) {
|
||
pair.crossed = null;
|
||
},this);
|
||
this.crossed = [];
|
||
|
||
var card = this.signiZones[1].cards[0];
|
||
if (!card) return;
|
||
if (!card.crossLeft && !card.crossRight) return;
|
||
function checkMatch (zone,cross) {
|
||
if (!zone) return null;
|
||
var card = zone.getSigni();
|
||
if (!card) return null;
|
||
var cids = concat(cross);
|
||
var matched = cids.some(function (cid) {
|
||
return (card.cid === cid);
|
||
},this);
|
||
return matched? card : null;
|
||
}
|
||
// 3 CROSS
|
||
if (card.crossLeft && card.crossRight) {
|
||
if (!checkMatch(this.signiZones[0],card.crossRight)) return;
|
||
if (!checkMatch(this.signiZones[2],card.crossLeft)) return;
|
||
this.crossed = this.signis.slice();
|
||
this.signis.forEach(function (signi) {
|
||
signi.crossed = this.signis.slice();
|
||
},this);
|
||
return;
|
||
}
|
||
// 2 CROSS
|
||
var zone = card.crossRight? this.signiZones[0] : this.signiZones[2];
|
||
var pair = checkMatch(zone,card.crossLeft || card.crossRight);
|
||
if (!pair) return;
|
||
this.crossed = [card,pair];
|
||
card.crossed = [card,pair];
|
||
pair.crossed = [card,pair];
|
||
};
|
||
|
||
Player.prototype.gainCoins = function(count) {
|
||
this.setCoin(this.coin + count);
|
||
};
|
||
|
||
Player.prototype.loseCoins = function(count) {
|
||
this.setCoin(this.coin - count);
|
||
};
|
||
|
||
Player.prototype.setCoin = function(count) {
|
||
var coin = this.coin;
|
||
this.coin = Math.max(0, Math.min(5, count));
|
||
if (this.lrig.isFaceup) {
|
||
this.game.output({
|
||
type: 'COIN_CHANGE',
|
||
content: {
|
||
player: this,
|
||
coin: this.coin,
|
||
},
|
||
});
|
||
}
|
||
};
|
||
|
||
Player.prototype.getInfectedZones = function() {
|
||
return this.signiZones.filter(function (zone) {
|
||
return zone.virus;
|
||
},this);
|
||
};
|
||
|
||
Player.prototype.getInfectedCards = function() {
|
||
return this.signis.filter(function (signi) {
|
||
return signi.isInfected();
|
||
},this);
|
||
};
|
||
|
||
Player.prototype.infectZoneAsyn = function() {
|
||
var zones = this.opponent.signiZones;
|
||
return this.selectAsyn('TARGET',zones).callback(this,function (zone) {
|
||
if (!zone) return null;
|
||
zone.putVirus();
|
||
return zone;
|
||
});
|
||
};
|
||
|
||
Player.prototype.setTrapFromDeckTopAsyn = function(count,max,forced) {
|
||
if (!isNum(max)) max = 1;
|
||
var cards = this.mainDeck.getTopCards(count);
|
||
this.informCards(cards);
|
||
var done = false;
|
||
return Callback.loop(this,max,function () {
|
||
if (done) return;
|
||
return this.selectAsyn('TARGET',cards,!forced).callback(this,function (card) {
|
||
if (!card) return done = true;
|
||
removeFromArr(card,cards);
|
||
return this.selectAsyn('TARGET',this.signiZones).callback(this,function (zone) {
|
||
card.trapTo(zone);
|
||
});
|
||
});
|
||
}).callback(this,function () {
|
||
var len = cards.length;
|
||
if (!len) return;
|
||
return this.selectSomeAsyn('SET_ORDER',cards,len,len,true).callback(this,function (cards) {
|
||
this.mainDeck.moveCardsToBottom(cards);
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.getTraps = function() {
|
||
return this.signiZones.filter(function (zone) {
|
||
return zone.trap;
|
||
}).map(function (zone) {
|
||
return zone.trap;
|
||
});
|
||
};
|
||
|
||
Player.prototype.handleEffectAsyn = function(effect) {
|
||
if (!effect.checkCondition()) return Callback.immediately();
|
||
var card = effect.source;
|
||
card.beSelectedAsTarget();
|
||
return card.player.opponent.showEffectsAsyn([effect]).callback(this,function () {
|
||
return this.game.blockAsyn(card,function () {
|
||
return effect.handleAsyn(false);
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.addLifeCloth = function(count) {
|
||
if (!isNum(count)) count = 1;
|
||
var cards = this.mainDeck.getTopCards(count);
|
||
return this.game.moveCards(cards,this.lifeClothZone);
|
||
};
|
||
|
||
Player.prototype.pickCardsFromDeckTopAsyn = function(count,filter,max) {
|
||
if (!isNum(max)) max = 1;
|
||
var cards = this.mainDeck.getTopCards(count);
|
||
if (!cards.length) return;
|
||
this.informCards(cards);
|
||
var targets = cards.filter(filter);
|
||
return Callback.immediately().callback(this,function () {
|
||
if (!targets.length) return;
|
||
return this.selectSomeAsyn('ADD_TO_HAND',targets,0,max,false,cards).callback(this,function (targets) {
|
||
return this.opponent.showCardsAsyn(targets).callback(this,function () {
|
||
this.game.moveCards(targets,this.handZone);
|
||
cards = cards.filter(function (card) {
|
||
return !inArr(card,targets);
|
||
},this);
|
||
});
|
||
});
|
||
}).callback(this,function () {
|
||
var len = cards.length;
|
||
if (!len) return;
|
||
return this.selectSomeAsyn('SET_ORDER',cards,len,len,true).callback(this,function (cards) {
|
||
this.mainDeck.moveCardsToBottom(cards);
|
||
});
|
||
});
|
||
};
|
||
|
||
Player.prototype.getWisdom = function() {
|
||
var wisdom = 0;
|
||
this.signis.forEach(function (signi) {
|
||
if (!signi.hasClass('英知')) return;
|
||
wisdom += signi.level;
|
||
},this);
|
||
return wisdom;
|
||
};
|
||
|
||
global.Player = Player; |