public virtual void Use(Room room, CardUseStruct card_use)
{
WrappedCard card = card_use.Card;
List <Player> targets = card_use.To;
for (int index = 0; index < targets.Count; index++)
{
Player target = targets[index];
CardEffectStruct effect = new CardEffectStruct
{
Card = card,
From = card_use.From,
To = target,
Multiple = (targets.Count > 1),
Drank = card_use.Drank,
ExDamage = card_use.ExDamage,
BasicEffect = card_use.EffectCount.Count > index ? card_use.EffectCount[index] : new CardBasicEffect(target, 0, 0, 0)
};
List <Player> players = new List <Player>();
for (int i = index; i < targets.Count; i++)
{
if (card_use.EffectCount.Count <= i || !card_use.EffectCount[i].Nullified)
{
players.Add(targets[i]);
}
}
effect.StackPlayers = players;
room.CardEffect(effect);
}
List <int> table_cardids = room.GetCardIdsOnTable(room.GetSubCards(card));
if (table_cardids.Count > 0)
{
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_USE, card_use.From.Name, null, card.Skill, null)
{
Card = card
};
if (targets.Count == 1)
{
reason.TargetId = targets[0].Name;
}
CardsMoveStruct move = new CardsMoveStruct(table_cardids, card_use.From, null, Place.PlaceTable, Place.DiscardPile, reason);
room.MoveCardsAtomic(new List <CardsMoveStruct> {
move
}, true);
}
}
public virtual void DoRecast(Room room, CardUseStruct use)
{
WrappedCard card = use.Card;
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_RECAST, use.From.Name)
{
SkillName = card.Skill
};
room.RecordSubCards(use.Card);
room.MoveCardTo(card, null, Place.PlaceTable, reason, true);
if (!string.IsNullOrEmpty(reason.SkillName))
{
room.BroadcastSkillInvoke(use.From, use.Card);
}
else
{
room.BroadcastSkillInvoke("@recast", use.From.IsMale() ? "male" : "female", -1);
}
if (!string.IsNullOrEmpty(card.Skill) && !card.Skill.StartsWith("-") && use.IsOwnerUse && RoomLogic.PlayerHasSkill(room, use.From, card.Skill))
{
room.NotifySkillInvoked(use.From, card.Skill);
}
LogMessage log = new LogMessage("#Card_Recast")
{
From = use.From.Name,
Card_str = RoomLogic.CardToString(room, card)
};
room.SendLog(log);
List <int> table_cardids = room.GetCardIdsOnTable(room.GetSubCards(card));
if (table_cardids.Count > 0)
{
CardsMoveStruct move = new CardsMoveStruct(table_cardids, use.From, null, Place.PlaceTable, Place.DiscardPile, reason);
room.MoveCardsAtomic(new List <CardsMoveStruct>()
{
move
}, true);
room.RemoveSubCards(use.Card);
}
room.DrawCards(use.From, 1, "recast");
}
public override void Record(TriggerEvent triggerEvent, Room room, Player player, ref object data)
{
if (triggerEvent == TriggerEvent.EventPhaseStart && player.Phase == PlayerPhase.Start && base.Triggerable(player, room) && player.GetPile("qiuan").Count > 0)
{
List <int> ids = player.GetPile("qiuan");
player.SetTag(Name, ids);
CardsMoveStruct move = new CardsMoveStruct(ids, player, Place.PlaceHand, new CardMoveReason(MoveReason.S_REASON_EXCHANGE_FROM_PILE, player.Name));
room.MoveCardsAtomic(new List <CardsMoveStruct> {
move
}, false);
room.LoseHp(player);
}
else if (triggerEvent == TriggerEvent.EventPhaseChanging && data is PhaseChangeStruct change && change.To == PlayerPhase.NotActive && player.ContainsTag(Name))
{
player.RemoveTag(Name);
}
}
public override void Use(Room room, CardUseStruct card_use)
{
WrappedCard card = card_use.Card;
if (card_use.To.Count == 0)
{
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_USE, card_use.From.Name, null, card.Skill, null)
{
CardString = RoomLogic.CardToString(room, card_use.Card)
};
room.MoveCardTo(card, room.GetCardOwner(card.GetEffectiveId()), null, Place.DiscardPile, reason, true);
}
if (room.GetCardIdsOnTable(card).Count == 0)
{
return;
}
int equipped_id = -1;
Player target = card_use.To[0];
if (target.HasEquip((int)EquipLocation()))
{
equipped_id = target.GetEquip((int)EquipLocation());
}
List <CardsMoveStruct> exchangeMove = new List <CardsMoveStruct> {
};
CardsMoveStruct move1 = new CardsMoveStruct(card.GetEffectiveId(), target, Place.PlaceEquip,
new CardMoveReason(CardMoveReason.MoveReason.S_REASON_USE, target.Name));
move1.Reason.CardString = RoomLogic.CardToString(room, card_use.Card);
exchangeMove.Add(move1);
if (equipped_id != -1)
{
CardsMoveStruct move2 = new CardsMoveStruct(equipped_id, target, Place.PlaceTable,
new CardMoveReason(CardMoveReason.MoveReason.S_REASON_CHANGE_EQUIP, target.Name));
exchangeMove.Add(move2);
}
room.MoveCardsAtomic(exchangeMove, true);
LogMessage log = new LogMessage
{
From = target.Name,
Type = "$Install",
Card_str = card.GetEffectiveId().ToString()
};
room.SendLog(log);
if (equipped_id != -1)
{
if (room.GetCardPlace(equipped_id) == Place.PlaceTable)
{
CardsMoveStruct move3 = new CardsMoveStruct(equipped_id, null, Place.DiscardPile,
new CardMoveReason(CardMoveReason.MoveReason.S_REASON_CHANGE_EQUIP, target.Name));
room.MoveCardsAtomic(new List <CardsMoveStruct> {
move3
}, true);
}
}
}
public override void OnEffect(Room room, CardEffectStruct effect)
{
WrappedCard card = effect.Card;
if (room.GetCardIdsOnTable(card).Count == 0)
{
return;
}
LogMessage log = new LogMessage
{
From = effect.To.Name,
Type = "#DelayedTrick",
Arg = card.Name
};
room.SendLog(log);
JudgeStruct judge_struct = new JudgeStruct
{
Pattern = judge.Pattern,
Good = judge.Good,
Negative = judge.Negative,
Reason = judge.Reason,
PlayAnimation = judge.PlayAnimation,
Time_consuming = judge.Time_consuming,
Who = effect.To
};
room.Judge(ref judge_struct);
if (judge_struct.IsEffected())
{
TakeEffect(room, effect.To, card);
List <int> table_cardids = room.GetCardIdsOnTable(card);
if (table_cardids.Count > 0)
{
//DummyCard dummy(table_cardids);
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_NATURAL_ENTER, null);
//room->moveCardTo(&dummy, NULL, Player::DiscardPile, reason, true);
CardsMoveStruct move = new CardsMoveStruct(table_cardids, null, Place.DiscardPile, reason);
room.MoveCardsAtomic(new List <CardsMoveStruct> {
move
}, true);
}
}
else if (movable)
{
OnNullified(room, effect.To, card);
}
else
{
List <int> table_cardids = room.GetCardIdsOnTable(card);
if (table_cardids.Count > 0)
{
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_NATURAL_ENTER, null);
CardsMoveStruct move = new CardsMoveStruct(table_cardids, null, Place.DiscardPile, reason);
room.MoveCardsAtomic(new List <CardsMoveStruct> {
move
}, true);
}
}
}
public virtual void Use(Room room, CardUseStruct card_use)
{
WrappedCard card = card_use.Card;
List <Player> targets = card_use.To;
List <string> nullified_list = room.GetTag("CardUseNullifiedList") != null ? (List <string>)room.GetTag("CardUseNullifiedList") : new List <string>();
bool all_nullified = nullified_list.Contains("_ALL_TARGETS");
foreach (Player target in targets)
{
CardEffectStruct effect = new CardEffectStruct
{
Card = card,
From = card_use.From,
To = target,
Multiple = (targets.Count > 1),
Nullified = (all_nullified || nullified_list.Contains(target.Name)),
Drank = card_use.Drank,
};
if (card_use.EffectCount != null)
{
foreach (EffctCount count in new List <EffctCount>(card_use.EffectCount))
{
if ((count.From == card_use.From && count.To == target && count.Index == targets.IndexOf(target)) ||
(count.To == card_use.From && count.From == target) && count.Index == targets.IndexOf(target))
{
card_use.EffectCount.Remove(count);
if (effect.EffectCount != null)
{
effect.EffectCount.Add(count);
}
else
{
effect.EffectCount = new List <EffctCount> {
count
}
};
break;
}
}
}
List <Player> players = new List <Player>();
for (int i = targets.IndexOf(target); i < targets.Count; i++)
{
if (!nullified_list.Contains(targets[i].Name) && !all_nullified)
{
players.Add(targets[i]);
}
}
room.SetTag("targets" + RoomLogic.CardToString(room, card), players);
effect.StackPlayers = players;
room.CardEffect(effect);
}
List <int> table_cardids = room.GetCardIdsOnTable(card);
if (table_cardids.Count > 0)
{
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_USE, card_use.From.Name, null, card.Skill, null)
{
CardString = RoomLogic.CardToString(room, card)
};
if (targets.Count == 1)
{
reason.TargetId = targets[0].Name;
}
CardsMoveStruct move = new CardsMoveStruct(table_cardids, card_use.From, null, Place.PlaceTable, Place.DiscardPile, reason);
room.MoveCardsAtomic(new List <CardsMoveStruct> {
move
}, true);
}
}
public virtual void OnUse(Room room, CardUseStruct card_use)
{
Player player = card_use.From;
room.SortByActionOrder(ref card_use);
List <Player> targets = card_use.To;
bool hidden = (TypeID == CardType.TypeSkill && !WillThrow);
LogMessage log = new LogMessage("#UseCard")
{
From = player.Name,
To = new List <string>(),
Card_str = RoomLogic.CardToString(room, card_use.Card)
};
if (!TargetFixed(card_use.Card) || card_use.To.Count > 1 || !card_use.To.Contains(card_use.From))
{
log.SetTos(card_use.To);
}
List <int> used_cards = new List <int>();
List <CardsMoveStruct> moves = new List <CardsMoveStruct>();
used_cards.AddRange(card_use.Card.SubCards);
RoomThread thread = room.RoomThread;
object data = card_use;
thread.Trigger(TriggerEvent.PreCardUsed, room, player, ref data);
card_use = (CardUseStruct)data;
if (TypeID != CardType.TypeSkill)
{
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_USE, player.Name, null, card_use.Card.Skill, null)
{
CardString = RoomLogic.CardToString(room, card_use.Card),
General = RoomLogic.GetGeneralSkin(room, player, card_use.Card.Skill, card_use.Card.SkillPosition)
};
if (card_use.To.Count == 1)
{
reason.TargetId = card_use.To[0].Name;
}
foreach (int id in used_cards)
{
CardsMoveStruct move = new CardsMoveStruct(id, null, Place.PlaceTable, reason);
moves.Add(move);
}
room.MoveCardsAtomic(moves, true);
if (used_cards.Count == 0)
{ //show virtual card on table
CardsMoveStruct move = new CardsMoveStruct(-1, player, Place.PlaceTable, reason)
{
From_place = Place.PlaceUnknown,
From = player.Name,
Is_last_handcard = false,
};
room.NotifyUsingVirtualCard(RoomLogic.CardToString(room, card_use.Card), move);
}
room.SendLog(log);
if (this is Collateral)
{ // put it here for I don't wanna repeat these codes in Card::onUse
Player victim = room.FindPlayer((string)card_use.To[0].GetTag("collateralVictim"), true);
if (victim != null)
{
log = new LogMessage("#CollateralSlash")
{
From = card_use.From.Name,
To = new List <string> {
victim.Name
},
};
room.SendLog(log);
room.DoAnimate(AnimateType.S_ANIMATE_INDICATE, card_use.To[0].Name, victim.Name);
}
}
}
else
{
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_THROW, card_use.From.Name, null,
card_use.Card.Skill, null)
{
CardString = RoomLogic.CardToString(room, card_use.Card),
General = RoomLogic.GetGeneralSkin(room, player, card_use.Card.Skill, card_use.Card.SkillPosition)
};
FunctionCard card = Engine.GetFunctionCard(card_use.Card.Name);
if (card is SkillCard && WillThrow)
{
room.MoveCardTo(card_use.Card, card_use.From, null, Place.PlaceTable, reason, true);
}
room.SendLog(log);
if (WillThrow)
{
List <int> table_cardids = room.GetCardIdsOnTable(card_use.Card);
if (table_cardids.Count > 0)
{
CardsMoveStruct move = new CardsMoveStruct(table_cardids, player, null, Place.PlaceTable, Place.DiscardPile, reason);
room.MoveCardsAtomic(new List <CardsMoveStruct> {
move
}, true);
}
}
}
room.RoomThread.Trigger(TriggerEvent.CardUsedAnnounced, room, player, ref data);
room.RoomThread.Trigger(TriggerEvent.CardTargetAnnounced, room, player, ref data);
room.RoomThread.Trigger(TriggerEvent.CardUsed, room, player, ref data);
room.RoomThread.Trigger(TriggerEvent.CardFinished, room, player, ref data);
}
