public override void OnUse(Room room, CardUseStruct use)
{
Player player = use.From;
if (use.To.Count == 0)
{
use.To.Add(player);
}
object data = use;
RoomThread thread = room.RoomThread;
thread.Trigger(TriggerEvent.PreCardUsed, room, player, ref data);
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_USE, player.Name)
{
CardString = RoomLogic.CardToString(room, use.Card)
};
room.MoveCardTo(use.Card, player, Place.PlaceTable, reason, true);
Thread.Sleep(300);
room.RoomThread.Trigger(TriggerEvent.CardUsedAnnounced, room, use.From, ref data);
room.RoomThread.Trigger(TriggerEvent.CardTargetAnnounced, room, use.From, ref data);
thread.Trigger(TriggerEvent.CardUsed, room, player, ref data);
thread.Trigger(TriggerEvent.CardFinished, room, player, ref data);
}
public override void OnUse(Room room, CardUseStruct use)
{
string str = RoomLogic.CardToString(room, use.Card);
object data = use;
RoomThread thread = room.RoomThread;
thread.Trigger(TriggerEvent.PreCardUsed, room, use.From, ref data);
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_USE, use.From.Name, use.To[0].Name, use.Card.Skill, null)
{
CardString = str,
General = RoomLogic.GetGeneralSkin(room, use.From, use.Card.Skill, use.Card.SkillPosition)
};
room.MoveCardTo(use.Card, use.From, Place.PlaceTable, reason, true);
LogMessage log = new LogMessage
{
From = use.From.Name,
To = new List <string>(),
Type = "#DelayedTrick",
Card_str = str
};
foreach (Player to in use.To)
{
log.To.Add(to.Name);
}
room.SendLog(log);
Thread.Sleep(300);
room.RoomThread.Trigger(TriggerEvent.CardUsedAnnounced, room, use.From, ref data);
room.RoomThread.Trigger(TriggerEvent.CardTargetAnnounced, room, use.From, ref data);
thread.Trigger(TriggerEvent.CardUsed, room, use.From, ref data);
thread.Trigger(TriggerEvent.CardFinished, room, use.From, ref data);
}
protected virtual void OnCardUsed(Room room, Player player, ref object data)
{
if (data is CardUseStruct card_use)
{
RoomThread thread = room.RoomThread;
FunctionCard fcard = Engine.GetFunctionCard(card_use.Card.Name);
WrappedCard card = card_use.Card;
if (fcard.HasPreact)
{
fcard.DoPreAction(room, player, card);
data = card_use;
}
room.AddUseList(card_use);
card_use.EffectCount = new List <CardBasicEffect>();
foreach (Player p in card_use.To)
{
card_use.EffectCount.Add(fcard.FillCardBasicEffct(room, p));
}
data = card_use;
if (card_use.From != null)
{
thread.Trigger(TriggerEvent.TargetChoosing, room, card_use.From, ref data);
CardUseStruct new_use = (CardUseStruct)data;
}
card_use = (CardUseStruct)data;
if (card_use.From != null && card_use.To.Count > 0)
{
foreach (CardBasicEffect effect in card_use.EffectCount)
{
effect.Triggered = false;
}
while (card_use.EffectCount.Count > 0)
{
bool check = true;
int count = card_use.EffectCount.Count;
for (int i = 0; i < count; i++)
{
CardBasicEffect effect = card_use.EffectCount[i];
if (!effect.Triggered)
{
check = false;
thread.Trigger(TriggerEvent.TargetConfirming, room, effect.To, ref data);
effect.Triggered = true;
break;
}
}
if (check)
{
break;
}
card_use = (CardUseStruct)data;
}
}
card_use = (CardUseStruct)data;
if (card_use.From != null && card_use.To.Count > 0)
{
thread.Trigger(TriggerEvent.TargetChosen, room, card_use.From, ref data);
for (int i = 0; i < card_use.EffectCount.Count; i++)
{
CardBasicEffect effect = card_use.EffectCount[i];
effect.Triggered = false;
thread.Trigger(TriggerEvent.TargetConfirmed, room, effect.To, ref data);
effect.Triggered = true;
}
}
card_use = (CardUseStruct)data;
fcard.Use(room, card_use);
}
}
protected virtual void OnCardUsed(Room room, Player player, ref object data)
{
if (data is CardUseStruct card_use)
{
RoomThread thread = room.RoomThread;
FunctionCard fcard = Engine.GetFunctionCard(card_use.Card.Name);
WrappedCard card = card_use.Card;
if (fcard.HasPreact)
{
fcard.DoPreAction(room, player, card);
data = card_use;
}
List <Player> targets = card_use.To;
List <CardUseStruct> use_list = room.ContainsTag("card_proceeing") ?
(List <CardUseStruct>)room.GetTag("card_proceeing") : new List <CardUseStruct>(); //for serval purpose, such as AI
use_list.Add(card_use);
room.SetTag("card_proceeing", use_list);
if (card_use.From != null)
{
thread.Trigger(TriggerEvent.TargetChoosing, room, card_use.From, ref data);
CardUseStruct new_use = (CardUseStruct)data;
targets = new_use.To;
}
if (card_use.From != null && targets.Count > 0)
{
List <Player> targets_copy = new List <Player>(targets);
foreach (Player to in targets_copy)
{
if (targets.Contains(to))
{
thread.Trigger(TriggerEvent.TargetConfirming, room, to, ref data);
CardUseStruct new_use = (CardUseStruct)data;
targets = new_use.To;
if (targets.Count == 0)
{
break;
}
}
}
}
card_use = (CardUseStruct)data;
if (card_use.From != null && card_use.To.Count > 0)
{
thread.Trigger(TriggerEvent.TargetChosen, room, card_use.From, ref data);
foreach (Player p in card_use.To)
{
thread.Trigger(TriggerEvent.TargetConfirmed, room, p, ref data);
}
}
card_use = (CardUseStruct)data;
if (card_use.NullifiedList != null)
{
room.SetTag("CardUseNullifiedList", card_use.NullifiedList);
}
fcard.Use(room, card_use);
}
}
public override void OnNullified(Room room, Player target, WrappedCard card)
{
RoomThread thread = room.RoomThread;
string card_str = RoomLogic.CardToString(room, card);
bool move = false;
Player p = null;
if (movable)
{
List <Player> players = new List <Player>();
List <Player> count_players = new List <Player>(room.Players);
Player starter = target;
int index = count_players.IndexOf(starter);
for (int i = index + 1; i < count_players.Count; i++)
{
if (count_players[i].Alive)
{
players.Add(count_players[i]);
}
}
for (int i = 0; i <= index; i++)
{
if (count_players[i].Alive)
{
players.Add(count_players[i]);
}
}
foreach (Player player in players)
{
if (RoomLogic.PlayerContainsTrick(room, player, Name))
{
continue;
}
Skill skill = RoomLogic.IsProhibited(room, null, player, card);
if (skill != null)
{
skill = Engine.GetMainSkill(skill.Name);
LogMessage log = new LogMessage
{
Type = "#SkillAvoid",
From = player.Name,
Arg = skill.Name,
Arg2 = Name
};
room.SendLog(log);
room.BroadcastSkillInvoke(skill.Name, player);
continue;
}
if (player.HasFlag(card_str + "_delay_trick_cancel"))
{
continue;
}
CardUseStruct use = new CardUseStruct(room.GetCard(card.GetEffectiveId()), null, player);
object data = use;
thread.Trigger(TriggerEvent.TargetConfirming, room, player, ref data);
CardUseStruct new_use = (CardUseStruct)data;
if (new_use.To.Count == 0)
{
p = player;
player.SetFlags(card_str + "_delay_trick_cancel");
break;
}
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_TRANSFER, string.Empty)
{
CardString = RoomLogic.CardToString(room, card)
};
room.MoveCardTo(card, null, player, Place.PlaceDelayedTrick, reason, true);
move = true;
foreach (Player p2 in room.GetAllPlayers())
{
thread.Trigger(TriggerEvent.TargetChosen, room, p2, ref data);
}
foreach (Player p2 in room.GetAllPlayers())
{
thread.Trigger(TriggerEvent.TargetConfirmed, room, p2, ref data);
}
break;
}
}
if (p != null)
{
OnNullified(room, p, card);
}
else if (!move)
{
foreach (Player player in room.GetAllPlayers())
{
if (player.HasFlag(RoomLogic.CardToString(room, card) + "_delay_trick_cancel"))
{
player.SetFlags(string.Format("-{0}{1}", card_str, "_delay_trick_cancel"));
}
}
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_NATURAL_ENTER, string.Empty);
room.MoveCardTo(card, null, Place.DiscardPile, reason, 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);
}
public override void OnNullified(Room room, Player target, WrappedCard card)
{
RoomThread thread = room.RoomThread;
string card_str = RoomLogic.CardToString(room, card);
bool move = false;
Player p = null;
if (movable)
{
List <Player> players = new List <Player>();
List <Player> count_players = new List <Player>(room.Players);
Player starter = target;
int index = count_players.IndexOf(starter);
for (int i = index + 1; i < count_players.Count; i++)
{
if (count_players[i].Alive)
{
players.Add(count_players[i]);
}
}
for (int i = 0; i <= index; i++)
{
if (count_players[i].Alive)
{
players.Add(count_players[i]);
}
}
foreach (Player player in players)
{
if (RoomLogic.PlayerContainsTrick(room, player, Name) || !player.JudgingAreaAvailable)
{
continue;
}
Skill skill = RoomLogic.IsProhibited(room, null, player, card);
if (skill != null)
{
skill = Engine.GetMainSkill(skill.Name);
LogMessage log = new LogMessage
{
Type = "#SkillAvoid",
From = player.Name,
Arg = skill.Name,
Arg2 = Name
};
room.SendLog(log);
if (RoomLogic.PlayerHasShownSkill(room, player, skill))
{
room.NotifySkillInvoked(player, skill.Name);
GeneralSkin gsk = RoomLogic.GetGeneralSkin(room, player, skill.Name);
string genral = gsk.General;
int skin_id = gsk.SkinId;
string skill_name = skill.Name;
int audio = -1;
skill.GetEffectIndex(room, player, card, ref audio, ref skill_name, ref genral, ref skin_id);
if (audio >= -1)
{
room.BroadcastSkillInvoke(skill_name, "male", audio, genral, skin_id);
}
}
continue;
}
//if (player.HasFlag(card_str + "_delay_trick_cancel")) continue;
/*
* CardUseStruct use = new CardUseStruct(room.GetCard(card.GetEffectiveId()), null, player)
* {
* EffectCount = new List<CardBasicEffect> { FillCardBasicEffct(room, player) }
* };
* object data = use;
* thread.Trigger(TriggerEvent.TargetConfirming, room, player, ref data);
* CardUseStruct new_use = (CardUseStruct)data;
* if (new_use.To.Count == 0)
* {
* p = player;
* player.SetFlags(card_str + "_delay_trick_cancel");
* break;
* }
*
* thread.Trigger(TriggerEvent.TargetChosen, room, null, ref data);
* thread.Trigger(TriggerEvent.TargetConfirmed, room, player, ref data);
*/
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_TRANSFER, string.Empty)
{
Card = card
};
room.MoveCardTo(card, null, player, Place.PlaceDelayedTrick, reason, true);
move = true;
break;
}
}
if (p != null)
{
OnNullified(room, p, card);
}
else if (!move)
{
//foreach (Player player in room.GetAllPlayers())
//if (player.HasFlag(RoomLogic.CardToString(room, card) + "_delay_trick_cancel"))
//player.SetFlags(string.Format("-{0}{1}", card_str, "_delay_trick_cancel"));
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_NATURAL_ENTER, string.Empty);
room.MoveCardTo(card, null, Place.DiscardPile, reason, true);
}
}
