void HuangtianCard::use(Room *room, ServerPlayer *source, QList<ServerPlayer *> &targets) const
{
ServerPlayer *zhangjiao = targets.first();
if (zhangjiao->hasLordSkill("huangtian")) {
room->setPlayerFlag(zhangjiao, "HuangtianInvoked");
if (!zhangjiao->isLord() && zhangjiao->hasSkill("weidi"))
room->broadcastSkillInvoke("weidi");
else {
int index = qrand() % 2 + 1;
if (Player::isNostalGeneral(zhangjiao, "zhangjiao"))
index += 2;
room->broadcastSkillInvoke("huangtian", index);
}
room->notifySkillInvoked(zhangjiao, "huangtian");
CardMoveReason reason(CardMoveReason::S_REASON_GIVE, source->objectName(), zhangjiao->objectName(), "huangtian", QString());
room->obtainCard(zhangjiao, this, reason);
QList<ServerPlayer *> zhangjiaos;
QList<ServerPlayer *> players = room->getOtherPlayers(source);
foreach (ServerPlayer *p, players) {
if (p->hasLordSkill("huangtian") && !p->hasFlag("HuangtianInvoked"))
zhangjiaos << p;
}
if (zhangjiaos.isEmpty())
room->setPlayerFlag(source, "ForbidHuangtian");
}
virtual bool onPhaseChange(ServerPlayer *wangyi) const{
if(!wangyi->isWounded())
return false;
if(wangyi->getPhase() == Player::Start || wangyi->getPhase() == Player::Finish){
if(!wangyi->askForSkillInvoke(objectName()))
return false;
Room *room = wangyi->getRoom();
room->broadcastSkillInvoke(objectName(), 1);
JudgeStruct judge;
judge.pattern = QRegExp("(.*):(club|spade):(.*)");
judge.good = true;
judge.reason = objectName();
judge.who = wangyi;
room->judge(judge);
if(judge.isGood()){
int x = wangyi->getLostHp();
wangyi->drawCards(x); //It should be preview, not draw
ServerPlayer *target = room->askForPlayerChosen(wangyi, room->getAllPlayers(), objectName());
if (target == wangyi)
room->broadcastSkillInvoke(objectName(), 2);
else if (target->getGeneralName().contains("machao"))
room->broadcastSkillInvoke(objectName(), 4);
else
room->broadcastSkillInvoke(objectName(), 3);
QList<const Card *> miji_cards = wangyi->getHandcards().mid(wangyi->getHandcardNum() - x);
foreach(const Card *card, miji_cards){
CardMoveReason reason(CardMoveReason::S_REASON_GIVE, wangyi->objectName());
reason.m_playerId == target->objectName();
room->obtainCard(target, card, reason, false);
}
}
void RendeCard::use(Room *room, ServerPlayer *source, QList<ServerPlayer *> &targets) const{
ServerPlayer *target = targets.first();
int old_value = source->getMark("rende");
QList<int> rende_list;
if (old_value > 0)
rende_list = StringList2IntList(source->property("rende").toString().split("+"));
else
rende_list = source->handCards();
foreach (int id, this->subcards)
rende_list.removeOne(id);
room->setPlayerProperty(source, "rende", IntList2StringList(rende_list).join("+"));
CardMoveReason reason(CardMoveReason::S_REASON_GIVE, source->objectName(), target->objectName(), "rende", QString());
room->obtainCard(target, this, reason, false);
int new_value = old_value + subcards.length();
room->setPlayerMark(source, "rende", new_value);
if (old_value < 2 && new_value >= 2) {
RecoverStruct recover;
recover.card = this;
recover.who = source;
room->recover(source, recover);
}
if (room->getMode() == "04_1v3" && source->getMark("rende") >= 2) return;
if (source->isKongcheng() || source->isDead() || rende_list.isEmpty()) return;
room->addPlayerHistory(source, "RendeCard", -1);
if (!room->askForUseCard(source, "@@rende", "@rende-give", -1, Card::MethodNone))
room->addPlayerHistory(source, "RendeCard");
}
void EquipCard::onUse(Room *room, const CardUseStruct &card_use) const
{
CardUseStruct use = card_use;
ServerPlayer *player = use.from;
if (use.to.isEmpty())
use.to << player;
if (!use.to.contains(player)) {
LogMessage log;
log.from = player;
log.to = use.to;
log.type = "#UseCard";
log.card_str = use.card->toString();
room->sendLog(log);
}
QVariant data = QVariant::fromValue(use);
RoomThread *thread = room->getThread();
thread->trigger(PreCardUsed, room, data);
CardMoveReason reason(CardMoveReason::S_REASON_USE, player->objectName(), QString(), card_use.card->getSkillName(), QString());
CardsMoveStruct move(card_use.card->getEffectiveId(), NULL, Player::PlaceTable, reason);
room->moveCardsAtomic(move, true);
thread->trigger(CardUsed, room, data);
thread->trigger(CardFinished, room, data);
}
void EquipCard::use(Room *room, ServerPlayer *source, QList<ServerPlayer *> &targets) const{
const EquipCard *equipped = NULL;
ServerPlayer *target = targets.value(0, source);
if (room->getCardOwner(getId()) != source) return;
switch(location()){
case WeaponLocation: equipped = target->getWeapon(); break;
case ArmorLocation: equipped = target->getArmor(); break;
case DefensiveHorseLocation: equipped = target->getDefensiveHorse(); break;
case OffensiveHorseLocation: equipped = target->getOffensiveHorse(); break;
}
if (room->getCardPlace(getId()) == Player::PlaceHand)
{
QList<CardsMoveStruct> exchangeMove;
CardsMoveStruct move1;
move1.card_ids << getId();
move1.to = target;
move1.to_place = Player::PlaceEquip;
move1.reason = CardMoveReason(CardMoveReason::S_REASON_USE, target->objectName());
exchangeMove.push_back(move1);
if(equipped)
{
CardsMoveStruct move2;
move2.card_ids << equipped->getId();
move2.to = NULL;
move2.to_place = Player::DiscardPile;
move2.reason = CardMoveReason(CardMoveReason::S_REASON_CHANGE_EQUIP, target->objectName());
exchangeMove.push_back(move2);
}
LogMessage log;
log.from = target;
log.type = "$Install";
log.card_str = QString::number(getEffectiveId());
room->sendLog(log);
room->moveCardsAtomic(exchangeMove, true);
}
}
const Card *JijiangCard::validate(CardUseStruct &cardUse) const{
cardUse.m_isOwnerUse = false;
ServerPlayer *liubei = cardUse.from;
QList<ServerPlayer *> targets = cardUse.to;
Room *room = liubei->getRoom();
liubei->broadcastSkillInvoke(this);
room->notifySkillInvoked(liubei, "jijiang");
LogMessage log;
log.from = liubei;
log.to = targets;
log.type = "#UseCard";
log.card_str = toString();
room->sendLog(log);
const Card *slash = NULL;
QList<ServerPlayer *> lieges = room->getLieges("shu", liubei);
foreach (ServerPlayer *target, targets)
target->setFlags("JijiangTarget");
foreach (ServerPlayer *liege, lieges) {
try {
slash = room->askForCard(liege, "slash", "@jijiang-slash:" + liubei->objectName(), QVariant(), Card::MethodResponse, liubei);
}
catch (TriggerEvent triggerEvent) {
if (triggerEvent == TurnBroken || triggerEvent == StageChange) {
foreach (ServerPlayer *target, targets)
target->setFlags("-JijiangTarget");
}
throw triggerEvent;
}
if (slash) {
foreach (ServerPlayer *target, targets)
target->setFlags("-JijiangTarget");
return slash;
}
}
foreach (ServerPlayer *target, targets)
target->setFlags("-JijiangTarget");
room->setPlayerFlag(liubei, "Global_JijiangFailed");
return NULL;
}
void Shit::onUse(Room *room, const CardUseStruct &card_use) const {
ServerPlayer *player = card_use.from;
QList<int> used_cards;
QList<CardsMoveStruct> moves;
if (card_use.card->isVirtualCard())
used_cards.append(card_use.card->getSubcards());
else
used_cards << card_use.card->getEffectiveId();
QVariant data = QVariant::fromValue(card_use);
RoomThread *thread = room->getThread();
Q_ASSERT(thread != NULL);
thread->trigger(PreCardUsed, room, player, data);
CardMoveReason reason(CardMoveReason::S_REASON_THROW, player->objectName(), QString(), card_use.card->getSkillName(), QString());
room->moveCardTo(this, player, NULL, Player::DiscardPile, reason, true);
thread->trigger(CardUsed, room, player, data);
thread->trigger(CardFinished, room, player, data);
}
void LijianCard::onUse(Room *room, const CardUseStruct &card_use) const{
ServerPlayer *diaochan = card_use.from;
LogMessage log;
log.from = diaochan;
log.to << card_use.to;
log.type = "#UseCard";
log.card_str = toString();
room->sendLog(log);
QVariant data = QVariant::fromValue(card_use);
RoomThread *thread = room->getThread();
thread->trigger(PreCardUsed, room, diaochan, data);
room->broadcastSkillInvoke("lijian");
CardMoveReason reason(CardMoveReason::S_REASON_THROW, diaochan->objectName(), QString(), "lijian", QString());
room->moveCardTo(this, diaochan, NULL, Player::DiscardPile, reason, true);
thread->trigger(CardUsed, room, diaochan, data);
thread->trigger(CardFinished, room, diaochan, data);
}
bool trigger(TriggerEvent, Room *room, ServerPlayer *player, QVariant &data) const{
PhaseChangeStruct change = data.value<PhaseChangeStruct>();
if (change.to != Player::NotActive) return false;
int weapon_id = player->tag.value("DrJiedaoWeapon", -1).toInt();
player->tag["DrJiedaoWeapon"] = -1;
if (!player->getWeapon()
|| weapon_id != player->getWeapon()->getEffectiveId())
return false;
ServerPlayer *target = NULL;
foreach (ServerPlayer *p, room->getOtherPlayers(player))
if (p->hasFlag("DrJiedaoTarget")) {
p->setFlags("-DrJiedaoTarget");
target = p;
break;
}
if (target == NULL) {
room->throwCard(player->getWeapon(), NULL);
} else {
QList<CardsMoveStruct> exchangeMove;
CardsMoveStruct move1(player->getWeapon()->getEffectiveId(), target, Player::PlaceEquip,
CardMoveReason(CardMoveReason::S_REASON_GOTCARD, player->objectName()));
exchangeMove.push_back(move1);
if (target->getWeapon() != NULL) {
CardsMoveStruct move2(target->getWeapon()->getEffectiveId(), NULL, Player::DiscardPile,
CardMoveReason(CardMoveReason::S_REASON_CHANGE_EQUIP, target->objectName()));
exchangeMove.push_back(move2);
}
room->moveCardsAtomic(exchangeMove, true);
}
return false;
}
void QuhuCard::use(Room *room, ServerPlayer *xunyu, QList<ServerPlayer *> &targets) const{
ServerPlayer *tiger = targets.first();
room->broadcastSkillInvoke("quhu", 1);
bool success = xunyu->pindian(tiger, "quhu", NULL);
if (success) {
room->broadcastSkillInvoke("quhu", 2);
QList<ServerPlayer *> players = room->getOtherPlayers(tiger), wolves;
foreach (ServerPlayer *player, players) {
if (tiger->inMyAttackRange(player))
wolves << player;
}
if (wolves.isEmpty()) {
LogMessage log;
log.type = "#QuhuNoWolf";
log.from = xunyu;
log.to << tiger;
room->sendLog(log);
return;
}
ServerPlayer *wolf = room->askForPlayerChosen(xunyu, wolves, "quhu", QString("@quhu-damage:%1").arg(tiger->objectName()));
room->damage(DamageStruct("quhu", tiger, wolf));
} else {
void EquipCard::use(Room *room, ServerPlayer *source, const QList<ServerPlayer *> &targets) const{
const EquipCard *equipped = NULL;
ServerPlayer *target = targets.value(0, source);
switch(location()){
case WeaponLocation: equipped = target->getWeapon(); break;
case ArmorLocation: equipped = target->getArmor(); break;
case DefensiveHorseLocation: equipped = target->getDefensiveHorse(); break;
case OffensiveHorseLocation: equipped = target->getOffensiveHorse(); break;
}
if(equipped)
room->throwCard(equipped, source);
int tmpId = -1;
if(getId() > -1)
tmpId = getId();
else if(!getSubcards().empty())
tmpId = this->getSubcards().first();
if(this->objectName() == "gale-shell" || room->getCardOwner(tmpId)->objectName() == target->objectName()){
LogMessage log;
log.from = target;
log.type = "$Install";
log.card_str = QString::number(tmpId);
room->sendLog(log);
room->moveCardTo(this, target, Player::Equip, true);
}
}
void DelayedTrick::use(Room *room, ServerPlayer *source, QList<ServerPlayer *> &targets) const{
ServerPlayer *target = targets.value(0, source);
CardMoveReason reason(CardMoveReason::S_REASON_USE, source->objectName(), target->objectName(), this->getSkillName(), QString());
room->moveCardTo(this, source, target, Player::PlaceDelayedTrick, reason, true);
}
void EquipCard::use(Room *room, ServerPlayer *source, QList<ServerPlayer *> &targets) const
{
if (targets.isEmpty()) {
CardMoveReason reason(CardMoveReason::S_REASON_USE, source->objectName(), QString(), getSkillName(), QString());
room->moveCardTo(this, source, NULL, Player::DiscardPile, reason, true);
return;
}
int equipped_id = Card::S_UNKNOWN_CARD_ID;
ServerPlayer *target = targets.first();
if (target->getEquip(location()))
equipped_id = target->getEquip(location())->getEffectiveId();
QList<CardsMoveStruct> exchangeMove;
CardsMoveStruct move1(getEffectiveId(), target, Player::PlaceEquip, CardMoveReason(CardMoveReason::S_REASON_USE, target->objectName()));
exchangeMove.push_back(move1);
if (equipped_id != Card::S_UNKNOWN_CARD_ID) {
CardsMoveStruct move2(equipped_id, NULL, Player::DiscardPile, CardMoveReason(CardMoveReason::S_REASON_CHANGE_EQUIP, target->objectName()));
exchangeMove.push_back(move2);
}
LogMessage log;
log.from = target;
log.type = "$Install";
log.card_str = QString::number(getEffectiveId());
room->sendLog(log);
room->moveCardsAtomic(exchangeMove, true);
}
virtual bool trigger(TriggerEvent , Room* room, ServerPlayer *, QVariant &data) const{
ServerPlayer *caozhi = room->findPlayerBySkillName(objectName());
CardsMoveOneTimeStar move = data.value<CardsMoveOneTimeStar>();
if(move->from_places.contains(Player::PlaceDelayedTrick) || move->from_places.contains(Player::PlaceSpecial))
return false;
if(move->to_place == Player::DiscardPile && move->from && move->from->objectName() != caozhi->objectName() &&
(move->reason.m_reason & CardMoveReason::S_MASK_BASIC_REASON) == CardMoveReason::S_REASON_DISCARD){
QList<CardsMoveStruct> exchangeMove;
CardsMoveStruct luoyingget;
foreach(int card_id, move->card_ids){
if(Sanguosha->getCard(card_id)->getSuit() == Card::Club
&& Sanguosha->getCard(card_id)->objectName() != "shit"){
luoyingget.card_ids << card_id;
luoyingget.to = caozhi;
luoyingget.to_place = Player::PlaceHand;
}
}
if(luoyingget.card_ids.empty())
return false;
else{
if(move->reason.m_reason == CardMoveReason::S_REASON_THROW
&& caozhi->askForSkillInvoke(objectName(), data)){
if(move->from->getGeneralName() == "zhenji")
room->broadcastSkillInvoke("luoying", 2);
else
room->broadcastSkillInvoke("luoying", 1);
exchangeMove.push_back(luoyingget);
// iwillback
room->moveCards(exchangeMove, true);
}
else{
foreach(int card_id, luoyingget.card_ids){
if(caozhi->askForSkillInvoke(objectName(), data)){
if(move->from->getGeneralName() == "zhenji")
room->broadcastSkillInvoke("luoying", 2);
else
room->broadcastSkillInvoke("luoying", 1);
CardMoveReason reason(CardMoveReason::S_REASON_RECYCLE, caozhi->objectName());
room->obtainCard(caozhi, Sanguosha->getCard(card_id), reason);
}
}
}
}
}