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 DelayedTrick::onUse(Room *room, const CardUseStruct &card_use) const
{
CardUseStruct use = card_use;
WrappedCard *wrapped = Sanguosha->getWrappedCard(this->getEffectiveId());
use.card = wrapped;
QVariant data = QVariant::fromValue(use);
RoomThread *thread = room->getThread();
thread->trigger(PreCardUsed, room, use.from, data);
use = data.value<CardUseStruct>();
LogMessage log;
log.from = use.from;
log.to = use.to;
log.type = "#UseCard";
log.card_str = toString();
room->sendLog(log);
CardMoveReason reason(CardMoveReason::S_REASON_USE, use.from->objectName(), use.to.first()->objectName(), this->getSkillName(), QString());
room->moveCardTo(this, use.to.first(), Player::PlaceDelayedTrick, reason, true);
thread->trigger(CardUsed, room, use.from, data);
use = data.value<CardUseStruct>();
thread->trigger(CardFinished, room, use.from, data);
}
void DelayedTrick::onUse(Room *room, const CardUseStruct &card_use) const
{
CardUseStruct use = card_use;
WrappedCard *wrapped = Sanguosha->getWrappedCard(getEffectiveId());
use.card = wrapped;
LogMessage log;
log.from = use.from;
log.to = use.to;
log.type = "#UseCard";
log.card_str = toString();
room->sendLog(log);
QVariant data = QVariant::fromValue(use);
RoomThread *thread = room->getThread();
thread->trigger(PreCardUsed, room, data);
//CardMoveReason reason(CardMoveReason::S_REASON_USE, use.from->objectName(), use.to.first()->objectName(), getSkillName(), QString());
//room->moveCardTo(this, use.from, use.to.first(), Player::PlaceDelayedTrick, reason, true);
CardMoveReason reason(CardMoveReason::S_REASON_USE, use.from->objectName(), QString(), card_use.card->getSkillName(), QString());
CardsMoveStruct move(card_use.card->getEffectiveId(), NULL, Player::PlaceTable, reason);
room->moveCardsAtomic(move, true);
//show hidden after move Event to avoid filter card
use.from->showHiddenSkill(getSkillName());
thread->trigger(CardUsed, room, data);
thread->trigger(CardFinished, room, data);
}
void EquipCard::onUse(Room *room, const CardUseStruct &card_use) const{
ServerPlayer *player = card_use.from;
QVariant data = QVariant::fromValue(card_use);
RoomThread *thread = room->getThread();
thread->trigger(CardUsed, room, player, data);
thread->trigger(CardFinished, room, player, data);
}
void DelayedTrick::onNullified(ServerPlayer *target) const
{
Room *room = target->getRoom();
RoomThread *thread = room->getThread();
if (movable) {
QList<ServerPlayer *> players = room->getOtherPlayers(target);
players << target;
ServerPlayer *next = NULL; //next meaning this next one
bool next2next = false; //it's meaning another next(a second next) is necessary
foreach (ServerPlayer *player, players) {
if (player->containsTrick(objectName()))
continue;
const ProhibitSkill *skill = room->isProhibited(target, player, this);
if (skill) {
LogMessage log;
log.type = "#SkillAvoid";
log.from = player;
log.arg = skill->objectName();
log.arg2 = objectName();
room->sendLog(log);
room->broadcastSkillInvoke(skill->objectName());
continue;
}
next = player;
CardMoveReason reason(CardMoveReason::S_REASON_TRANSFER, target->objectName(), QString(), getSkillName(), QString());
room->moveCardTo(this, target, player, Player::PlaceDelayedTrick, reason, true);
if (target == player)
break;
CardUseStruct use;
use.from = NULL;
use.to << player;
use.card = this;
QVariant data = QVariant::fromValue(use);
thread->trigger(TargetConfirming, room, data);
CardUseStruct new_use = data.value<CardUseStruct>();
if (new_use.to.isEmpty()) {
next2next = true;
break;
}
thread->trigger(TargetConfirmed, room, data);
break;
}
//case:stop.
if (!next) {
CardMoveReason reason(CardMoveReason::S_REASON_TRANSFER, target->objectName(), QString(), getSkillName(), QString());
room->moveCardTo(this, target, target, Player::PlaceDelayedTrick, reason, true);
}
//case: next2next
if (next && next2next)
onNullified(next);
} else {
void DelayedTrick::onNullified(ServerPlayer *target) const
{
Room *room = target->getRoom();
RoomThread *thread = room->getThread();
if (movable) {
QList<ServerPlayer *> players = room->getOtherPlayers(target);
players << target;
ServerPlayer *p = NULL;
foreach (ServerPlayer *player, players) {
if (player->containsTrick(objectName()))
continue;
const ProhibitSkill *skill = room->isProhibited(target, player, this);
if (skill) {
if (skill->isVisible()) {
LogMessage log;
log.type = "#SkillAvoid";
log.from = player;
log.arg = skill->objectName();
log.arg2 = objectName();
room->sendLog(log);
room->broadcastSkillInvoke(skill->objectName());
}
continue;
}
CardMoveReason reason(CardMoveReason::S_REASON_TRANSFER, target->objectName(), QString(), this->getSkillName(), QString());
room->moveCardTo(this, target, player, Player::PlaceDelayedTrick, reason, true);
if (target == player) break;
CardUseStruct use;
use.from = NULL;
use.to << player;
use.card = this;
QVariant data = QVariant::fromValue(use);
thread->trigger(TargetConfirming, room, player, data);
CardUseStruct new_use = data.value<CardUseStruct>();
if (new_use.to.isEmpty()) {
p = player;
break;
}
foreach(ServerPlayer *p, room->getAllPlayers())
thread->trigger(TargetConfirmed, room, p, data);
break;
}
if (p)
onNullified(p);
} else {
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;
QVariant data = QVariant::fromValue(use);
RoomThread *thread = room->getThread();
thread->trigger(PreCardUsed, room, player, data);
thread->trigger(CardUsed, room, player, data);
thread->trigger(CardFinished, room, player, data);
}
void DelayedTrick::onUse(Room *room, const CardUseStruct &card_use) const{
LogMessage log;
log.from = card_use.from;
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(CardUsed, room, card_use.from, data);
thread->trigger(CardFinished, room, card_use.from, data);
}
void DelayedTrick::onUse(Room *room, const CardUseStruct &card_use) const{
LogMessage log;
log.from = card_use.from;
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, card_use.from, data);
CardMoveReason reason(CardMoveReason::S_REASON_USE, card_use.from->objectName(), card_use.to.first()->objectName(), this->getSkillName(), QString());
room->moveCardTo(this, card_use.from, card_use.to.first(), Player::PlaceDelayedTrick, reason, true);
thread->trigger(CardUsed, room, card_use.from, data);
thread->trigger(CardFinished, room, card_use.from, data);
}
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 EquipCard::onUse(Room *room, const CardUseStruct &card_use) const{
CardUseStruct use = card_use;
WrappedCard *wrapped = Sanguosha->getWrappedCard(this->getEffectiveId());
use.card = wrapped;
if (use.from->hasFlag("ThChouceUse")) {
room->setPlayerFlag(use.from, "-ThChouceUse");
int n = use.from->getMark("ThChouce");
if (n > 0)
room->removePlayerCardLimitation(use.from, "use", QString("^SkillCard|.|1~%1$0").arg(n));
LogMessage log;
log.type = "#InvokeSkill";
log.from = use.from;
log.arg = "thchouce";
room->sendLog(log);
use.card->setFlags("thchouce_use");
}
ServerPlayer *player = use.from;
if (use.to.isEmpty())
use.to << player;
LogMessage log;
log.from = card_use.from;
if (!card_use.card->targetFixed() || card_use.to.length() > 1 || !card_use.to.contains(card_use.from))
log.to = card_use.to;
log.type = "#UseCard";
log.card_str = card_use.card->toString();
room->sendLog(log);
QVariant data = QVariant::fromValue(use);
RoomThread *thread = room->getThread();
thread->trigger(PreCardUsed, room, player, data);
use = data.value<CardUseStruct>();
thread->trigger(CardUsed, room, use.from, data);
use = data.value<CardUseStruct>();
thread->trigger(CardFinished, room, use.from, 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);
}
