public override TriggerStruct Triggerable(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who)
{
if (player != null && data is InfoStruct info && info.Info == skill_name)
{
TriggerStruct trigger = new TriggerStruct(Name, player)
{
SkillPosition = info.Head ? "head" : "deputy"
};
return(trigger);
}
return(new TriggerStruct());
}
public override TriggerStruct Triggerable(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who)
{
if (player != null && player.Alive && player.HasFlag("tunchu"))
{
if (player.IsKongcheng())
{
player.SetFlags("-tunchu");
return(new TriggerStruct());
}
TriggerStruct trigger = new TriggerStruct(Name, player)
{
SkillPosition = (string)player.GetTag("tunchu")
};
return(trigger);
}
return(new TriggerStruct());
}
public override List <TriggerStruct> Triggerable(TriggerEvent triggerEvent, Room room, Player player, ref object data)
{
List <TriggerStruct> skill_list = new List <TriggerStruct>();
if (player.Alive && player.Phase == PlayerPhase.Finish && player.HandcardNum < player.Hp)
{
List <Player> lifengs = RoomLogic.FindPlayersBySkillName(room, Name);
foreach (Player p in lifengs)
{
if (p.GetPile("commissariat").Count > 0)
{
TriggerStruct trigger = new TriggerStruct(Name, p);
skill_list.Add(trigger);
}
}
}
return(skill_list);
}
public override List <TriggerStruct> Triggerable(TriggerEvent triggerEvent, Room room, Player player, ref object data)
{
List <TriggerStruct> result = new List <TriggerStruct>();
if (player.Phase == PlayerPhase.Start && room.AliveCount() >= 4)
{
foreach (string skill in player.GetHeadSkillList(true, false))
{
Skill real_skill = Engine.GetSkill(skill);
if (real_skill != null && real_skill is BattleArraySkill baskill)
{
if (baskill.ViewAsSkill.IsEnabledAtPlay(room, player))
{
TriggerStruct trigger = new TriggerStruct(Name, player)
{
SkillPosition = "head"
};
result.Add(trigger);
}
}
}
foreach (string skill in player.GetDeputySkillList(true, false))
{
Skill real_skill = Engine.GetSkill(skill);
if (real_skill != null && real_skill is BattleArraySkill baskill)
{
if (baskill.ViewAsSkill.IsEnabledAtPlay(room, player))
{
TriggerStruct trigger = new TriggerStruct(Name, player)
{
SkillPosition = "deputy"
};
result.Add(trigger);
}
}
}
}
return(result);
}
public virtual List <TriggerStruct> Triggerable(TriggerEvent triggerEvent, Room room, Player player, ref object data)
{
List <TriggerStruct> skill_lists = new List <TriggerStruct>();
if (Name == "gamerule")
{
return(skill_lists);
}
TriggerStruct skill_list = Triggerable(triggerEvent, room, player, ref data, null);
if (!string.IsNullOrEmpty(skill_list.SkillName))
{
for (int i = 0; i < skill_list.Times; i++)
{
TriggerStruct skill = skill_list;
skill.Times = 1;
skill_lists.Add(skill);
}
}
return(skill_lists);
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
Player lord = null;
foreach (Player p in room.GetAlivePlayers())
{
if (p.GetRoleEnum() == PlayerRole.Lord)
{
lord = p;
break;
}
}
room.DoAnimate(AnimateType.S_ANIMATE_INDICATE, player.Name, lord.Name);
room.SendCompulsoryTriggerLog(player, Name, true);
room.BroadcastSkillInvoke(Name, player, info.SkillPosition);
room.LoseHp(player);
if (lord.Alive)
{
RecoverStruct recover = new RecoverStruct
{
Who = player,
Recover = 1
};
room.Recover(lord, recover, true);
if (lord.Alive)
{
room.DrawCards(lord, new DrawCardStruct(1, player, Name));
}
}
return(false);
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
room.SendCompulsoryTriggerLog(ask_who, name, true);
room.BroadcastSkillInvoke(Name, ask_who, info.SkillPosition);
JudgeStruct judge = new JudgeStruct
{
Pattern = ".|black",
Good = true,
Reason = Name,
PlayAnimation = true,
Who = player,
};
room.Judge(ref judge);
if (judge.IsEffected())
{
List <Player> players = new List <Player>();
foreach (Player p in room.GetAlivePlayers())
{
if (p.Camp == ask_who.Camp)
{
room.DoAnimate(AnimateType.S_ANIMATE_INDICATE, player.Name, p.Name);
players.Add(p);
}
}
room.SortByActionOrder(ref players);
foreach (Player p in players)
{
room.DrawCards(p, new DrawCardStruct(1, ask_who, Name));
}
}
return(false);
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
room.SendCompulsoryTriggerLog(ask_who, Name);
room.BroadcastSkillInvoke(Name, ask_who, info.SkillPosition);
List <string> choices = new List <string> {
"draw"
};
if (player.IsWounded())
{
choices.Add("recover");
}
string choice = room.AskForChoice(player, Name, string.Join("+", choices));
if (choice == "draw")
{
room.DrawCards(player, 1, Name);
}
else
{
room.Recover(player, 1);
}
return(false);
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
room.SendCompulsoryTriggerLog(player, Name, true);
room.BroadcastSkillInvoke(Name, player, info.SkillPosition);
List <Player> targets = room.GetOtherPlayers(player);
room.SortByActionOrder(ref targets);
foreach (Player p in targets)
{
if (p.Alive && player.Alive && !p.IsAllNude() && RoomLogic.CanGetCard(room, player, p, "hej"))
{
room.DoAnimate(AnimateType.S_ANIMATE_INDICATE, player.Name, p.Name);
int id = room.AskForCardChosen(player, p, "hej", Name, false, HandlingMethod.MethodGet);
List <int> ids = new List <int> {
id
};
room.ObtainCard(player, ref ids, new CardMoveReason(MoveReason.S_REASON_EXTRACTION, player.Name, p.Name, Name, string.Empty), false);
}
}
if (player.Alive)
{
room.LoseHp(player);
}
return(false);
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
if (data is DamageStruct damage)
{
room.DoAnimate(AnimateType.S_ANIMATE_INDICATE, player.Name, damage.To.Name);
room.SendCompulsoryTriggerLog(player, name, true);
room.BroadcastSkillInvoke(Name, player, info.SkillPosition);
Player target = damage.To;
List <string> handle = new List <string>();
if (!target.IsKongcheng() && RoomLogic.CanGetCard(room, player, target, "h"))
{
handle.Add("h^false^get");
}
if (target.HasEquip() && RoomLogic.CanGetCard(room, player, target, "e"))
{
handle.Add("e^false^get");
}
if (target.JudgingArea.Count > 0 && RoomLogic.CanGetCard(room, player, target, "j"))
{
handle.Add("j^false^get");
}
List <int> ids = room.AskForCardsChosen(player, damage.To, handle, Name);
if (ids.Count > 0)
{
room.ObtainCard(player, ref ids, new CardMoveReason(MoveReason.S_REASON_EXTRACTION, player.Name, damage.To.Name, Name, string.Empty), false);
}
if (player.Alive)
{
room.LoseHp(player);
}
}
return(false);
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
Player lord = null;
foreach (Player p in room.GetAlivePlayers())
{
if (p.GetRoleEnum() == PlayerRole.Lord)
{
lord = p;
break;
}
}
List <int> give = room.AskForExchange(player, Name, 1, 0, "@huying:" + lord.Name, string.Empty, Slash.ClassName, info.SkillPosition);
room.SendCompulsoryTriggerLog(player, Name, true);
room.BroadcastSkillInvoke(Name, player, info.SkillPosition);
room.DoAnimate(AnimateType.S_ANIMATE_INDICATE, player.Name, lord.Name);
if (give.Count > 0)
{
room.ObtainCard(lord, ref give, new CardMoveReason(MoveReason.S_REASON_GIVE, player.Name, lord.Name, Name, string.Empty), true);
}
else
{
room.LoseHp(player);
if (lord.Alive)
{
foreach (int id in room.DrawPile)
{
WrappedCard card = room.GetCard(id);
if (card.Name.Contains(Slash.ClassName))
{
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_GOTBACK, lord.Name, Name, string.Empty);
List <int> ids = new List <int> {
id
};
room.ObtainCard(lord, ref ids, reason, true);
break;
}
}
}
}
return(false);
}
public abstract bool OnPhaseChange(Room room, Player player, TriggerStruct info);
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
int n = (int)data;
data = GetDrawNum(room, player, n);
return(false);
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
return(OnPhaseChange(room, player, info));
}
virtual public bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
return(false);
}
virtual public TriggerStruct Cost(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
return(info);
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
room.SendCompulsoryTriggerLog(ask_who, Name, true);
room.BroadcastSkillInvoke(Name, ask_who, info.SkillPosition);
room.LoseMaxHp(ask_who);
if (ask_who.Alive)
{
room.DrawCards(ask_who, ask_who.MaxHp, Name);
}
return(false);
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
int count = 1 - player.Hp;
if (count > 0)
{
RecoverStruct recover = new RecoverStruct
{
Who = ask_who,
Recover = count
};
room.Recover(player, recover, true);
}
return(false);
}
public override TriggerStruct Cost(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
if (player.Alive && ask_who.Alive)
{
ask_who.SetFlags("slashTargetFix");
player.SetFlags("SlashAssignee");
WrappedCard used = room.AskForUseCard(ask_who, "Slash:fangong", "@fangong-slash:" + player.Name, null, -1, HandlingMethod.MethodUse, false);
if (used == null)
{
ask_who.SetFlags("-slashTargetFix");
player.SetFlags("-SlashAssignee");
}
}
return(new TriggerStruct());
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player target, TriggerStruct trigger_info)
{
if (room.SkipGameRule)
{
room.SkipGameRule = false;
return(false);
}
// Handle global events
if (player == null)
{
if (triggerEvent == TriggerEvent.GameStart)
{
OnGameStart(room, ref data);
}
if (triggerEvent != TriggerEvent.BeforeCardsMove && triggerEvent != TriggerEvent.CardsMoveOneTime)
{
return(false);
}
}
switch (triggerEvent)
{
case TriggerEvent.TurnStart:
OnTurnStart(room, player, ref data);
break;
case TriggerEvent.EventPhaseProceeding:
OnPhaseProceed(room, player, ref data);
break;
case TriggerEvent.EventPhaseEnd:
OnPhaseEnd(room, player, ref data);
break;
case TriggerEvent.EventPhaseChanging:
OnPhaseChanging(room, player, ref data);
break;
case TriggerEvent.PreCardUsed:
OnPreCardUsed(room, player, ref data);
break;
case TriggerEvent.CardUsed:
OnCardUsed(room, player, ref data);
break;
case TriggerEvent.CardFinished:
CardUseStruct use = (CardUseStruct)data;
//room.ClearCardFlag(use.Card);
use.Card.ClearFlags(); //RoomCard会在其移动后自动清除flag
room.RemoveSubCards(use.Card);
//以askforcard形式使用的卡牌没有onUse的trigger，但有finish
if (use.Reason != CardUseStruct.CardUseReason.CARD_USE_REASON_RESPONSE)
{
room.RemoveUseOnFinish();
}
if (Engine.GetFunctionCard(use.Card.Name).IsNDTrick())
{
room.RemoveHegNullification(use.Card);
}
foreach (Client p in room.Clients)
{
room.DoNotify(p, CommandType.S_COMMAND_NULLIFICATION_ASKED, new List <string> {
"."
});
}
break;
case TriggerEvent.EventAcquireSkill:
case TriggerEvent.EventLoseSkill:
InfoStruct info = (InfoStruct)data;
string skill_name = info.Info;
Skill skill = Engine.GetSkill(skill_name);
bool refilter = skill is FilterSkill;
if (!refilter && skill is TriggerSkill)
{
TriggerSkill trigger = (TriggerSkill)skill;
ViewAsSkill vsskill = trigger.ViewAsSkill;
if (vsskill != null && (vsskill is FilterSkill))
{
refilter = true;
}
}
if (refilter)
{
room.FilterCards(player, player.GetCards("he"), triggerEvent == TriggerEvent.EventLoseSkill);
}
CheckBigKingdoms(room);
break;
case TriggerEvent.PostHpReduced:
if (player.Hp > 0 || player.HasFlag("Global_Dying")) // newest GameRule -- a player cannot enter dying when it is dying.
{
break;
}
if (data is DamageStruct damage)
{
room.EnterDying(player, damage);
}
else
{
room.EnterDying(player, new DamageStruct());
}
break;
case TriggerEvent.AskForPeaches:
OnAskforPeach(room, player, ref data);
break;
case TriggerEvent.AskForPeachesDone:
{
if (player.Hp <= 0 && player.Alive)
{
DyingStruct dying = (DyingStruct)data;
room.KillPlayer(player, dying.Damage);
}
break;
}
case TriggerEvent.ConfirmDamage:
{
break;
}
case TriggerEvent.DamageDone:
{
damage = (DamageStruct)data;
if (damage.From != null && !damage.From.Alive)
{
damage.From = null;
}
room.SendDamageLog(damage);
if (damage.Nature != DamageNature.Normal && player.Chained && !damage.Chain && !damage.ChainStarter)
{
damage.ChainStarter = true;
}
data = damage;
bool reduce = !room.ApplyDamage(player, damage);
if (reduce)
{
room.RoomThread.Trigger(TriggerEvent.PostHpReduced, room, player, ref data);
}
break;
}
case TriggerEvent.DamageComplete:
{
damage = (DamageStruct)data;
if (damage.Prevented)
{
return(false);
}
/*
* if (damage.Nature != DamageNature.Normal && player.Chained)
* {
* room.ChainedRemoveOnDamageDone(player, damage);
* }
*/
if (damage.Nature != DamageNature.Normal && !damage.Chain && damage.ChainStarter) // iron chain effect
{
List <Player> chained_players = new List <Player>();
if (!room.Current.Alive)
{
chained_players = room.GetOtherPlayers(room.Current);
}
else
{
chained_players = room.GetAllPlayers();
}
chained_players.Remove(damage.To);
foreach (Player chained_player in chained_players)
{
if (chained_player.Chained)
{
Thread.Sleep(500);
LogMessage log = new LogMessage
{
Type = "#IronChainDamage",
From = chained_player.Name
};
room.SendLog(log);
DamageStruct chain_damage = damage;
chain_damage.To = chained_player;
chain_damage.Chain = true;
chain_damage.Transfer = false;
chain_damage.TransferReason = null;
room.Damage(chain_damage);
}
}
}
foreach (Player p in room.GetAllPlayers())
{
if (p.HasFlag("Global_DFDebut"))
{
p.SetFlags("-Global_DFDebut");
room.RoomThread.Trigger(TriggerEvent.DFDebut, room, p);
}
}
break;
}
case TriggerEvent.CardEffect:
{
if (data is CardEffectStruct effect)
{
if (Engine.GetFunctionCard(effect.Card.Name) is DelayedTrick)
{
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_DELAYTRICK_EFFECT,
effect.To.Name, effect.Card.Skill, effect.Card.Name)
{
Card = effect.Card
};
room.MoveCardTo(effect.Card, effect.To, Place.PlaceTable, reason, true);
Thread.Sleep(500);
}
}
break;
}
case TriggerEvent.CardEffected:
{
if (data is CardEffectStruct effect)
{
FunctionCard fcard = Engine.GetFunctionCard(effect.Card.Name);
if (!(fcard is Slash) && effect.BasicEffect.Nullified)
{
LogMessage log = new LogMessage
{
Type = "#Cardnullified",
From = effect.To.Name,
Arg = effect.Card.Name
};
room.SendLog(log);
return(true);
}
else if (fcard.TypeID == CardType.TypeTrick && room.IsCanceled(effect))
{
effect.To.SetFlags("Global_NonSkillnullify");
return(true);
}
object _effect = effect;
room.RoomThread.Trigger(TriggerEvent.CardEffectConfirmed, room, effect.To, ref _effect);
if (effect.To.Alive || fcard is Slash)
{
fcard.OnEffect(room, effect);
}
}
break;
}
case TriggerEvent.SlashEffected:
{
SlashEffectStruct effect = (SlashEffectStruct)data;
if (effect.Nullified)
{
LogMessage log = new LogMessage
{
Type = "#Cardnullified",
From = effect.To.Name,
Arg = effect.Slash.Name
};
room.SendLog(log);
return(true);
}
if (effect.Jink_num > 0)
{
room.RoomThread.Trigger(TriggerEvent.SlashProceed, room, effect.From, ref data);
}
else
{
room.SlashResult(effect, null);
}
break;
}
case TriggerEvent.SlashProceed:
{
SlashEffectStruct effect = (SlashEffectStruct)data;
string slasher = effect.From.Name;
if (!effect.To.Alive)
{
break;
}
if (effect.Jink_num == 1)
{
CardResponseStruct resp = room.AskForCard(effect.To, Slash.ClassName, Jink.ClassName, string.Format("slash-jink:{0}::{1}", slasher, effect.Slash.Name),
data, HandlingMethod.MethodUse, null, effect.From, false, false);
room.SlashResult(effect, room.IsJinkEffected(effect.To, resp) ? resp.Card : null);
}
else
{
WrappedCard jink = new WrappedCard(DummyCard.ClassName);
for (int i = effect.Jink_num; i > 0; i--)
{
string prompt = string.Format("@multi-jink{0}:{1}::{2}:{3}", i == effect.Jink_num ? "-start" : string.Empty, slasher, i, effect.Slash.Name);
CardResponseStruct resp = room.AskForCard(effect.To, Slash.ClassName, Jink.ClassName, prompt, data, HandlingMethod.MethodUse, null, effect.From, false, false);
if (!room.IsJinkEffected(effect.To, resp))
{
//delete jink;
room.SlashResult(effect, null);
return(false);
}
else
{
jink.AddSubCard(resp.Card);
}
}
room.SlashResult(effect, jink);
}
break;
}
case TriggerEvent.SlashHit:
{
SlashEffectStruct effect = (SlashEffectStruct)data;
if (effect.Drank > 0)
{
LogMessage log = new LogMessage
{
Type = "#AnalepticBuff",
From = effect.From.Name,
To = new List <string> {
effect.To.Name
},
Arg = (1 + effect.ExDamage).ToString(),
Arg2 = (1 + effect.ExDamage + effect.Drank).ToString()
};
room.SendLog(log);
}
DamageStruct slash_damage = new DamageStruct(effect.Slash, effect.From, effect.To, 1 + effect.ExDamage + effect.Drank, effect.Nature)
{
Drank = effect.Drank > 0
};
room.Damage(slash_damage);
break;
}
case TriggerEvent.BeforeGameOverJudge:
{
if (!player.General1Showed)
{
room.ShowGeneral(player, true, false, false);
}
if (!player.General2Showed)
{
room.ShowGeneral(player, false, false, false);
}
break;
}
case TriggerEvent.GameOverJudge:
{
string winner = GetWinner(room);
if (!string.IsNullOrEmpty(winner))
{
room.GameOver(winner);
return(true);
}
break;
}
case TriggerEvent.BuryVictim:
{
OnBuryVictim(room, player, ref data);
break;
}
case TriggerEvent.StartJudge:
{
int card_id = room.GetNCards(1)[0];
JudgeStruct judge_struct = (JudgeStruct)data;
judge_struct.Card = room.GetCard(card_id);
LogMessage log = new LogMessage
{
Type = "$InitialJudge",
From = judge_struct.Who.Name,
Card_str = card_id.ToString()
};
room.SendLog(log);
room.MoveCardTo(judge_struct.Card, null, judge_struct.Who, Place.PlaceJudge,
new CardMoveReason(MoveReason.S_REASON_JUDGE, judge_struct.Who.Name, null, null, judge_struct.Reason), true);
Thread.Sleep(500);
bool effected = judge_struct.Good == Engine.MatchExpPattern(room, judge_struct.Pattern, judge_struct.Who, judge_struct.Card);
judge_struct.UpdateResult(effected);
data = judge_struct;
break;
}
case TriggerEvent.JudgeResult:
{
JudgeStruct judge = (JudgeStruct)data;
LogMessage log = new LogMessage
{
Type = "$JudgeResult",
From = player.Name,
Card_str = RoomLogic.CardToString(room, judge.Card)
};
room.SendLog(log);
//Thread.Sleep(500);
if (judge.PlayAnimation)
{
room.SendJudgeResult(judge);
Thread.Sleep(800);
}
break;
}
case TriggerEvent.FinishJudge:
{
JudgeStruct judge = (JudgeStruct)data;
if (room.GetCardPlace(judge.Card.Id) == Place.PlaceJudge)
{
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_JUDGEDONE, judge.Who.Name, null, judge.Reason);
room.MoveCardTo(judge.Card, judge.Who, null, Place.DiscardPile, reason, true);
}
break;
}
case TriggerEvent.ChoiceMade:
{
foreach (Player p in room.GetAlivePlayers())
{
List <string> flags = new List <string>(p.Flags);
foreach (string flag in flags)
{
if (flag.StartsWith("Global_") && flag.EndsWith("Failed"))
{
p.SetFlags("-" + flag);
}
}
}
break;
}
case TriggerEvent.GeneralShown:
{
string winner = GetWinner(room);
if (!string.IsNullOrEmpty(winner))
{
room.GameOver(winner); // if all hasShownGenreal, and they are all friend, game over.
return(true);
}
if (!room.ContainsTag("TheFirstToShowRewarded"))
{
room.SetTag("TheFirstToShowRewarded", true);
room.SetPlayerMark(player, "@pioneer", 1);
room.AttachSkillToPlayer(player, "pioneer");
}
if (player.Alive && player.HasShownAllGenerals())
{
if (player.GetMark("CompanionEffect") > 0)
{
room.RemovePlayerMark(player, "CompanionEffect");
room.DoSuperLightbox(player, string.Empty, "companion");
room.SetPlayerMark(player, "@companion", 1);
room.AttachSkillToPlayer(player, "companion");
}
if (player.GetMark("HalfMaxHpLeft") > 0)
{
room.RemovePlayerMark(player, "HalfMaxHpLeft");
room.SetPlayerMark(player, "@megatama", 1);
room.AttachSkillToPlayer(player, "megatama");
}
}
CheckBigKingdoms(room);
break;
}
case TriggerEvent.BeforeCardsMove:
{
if (data is CardsMoveOneTimeStruct move)
{
bool should_find_io = false;
if (move.To_place == Place.DiscardPile)
{
if (move.Reason.Reason != MoveReason.S_REASON_USE)
{
should_find_io = true; // not use
}
else if (move.Card_ids.Count > 1)
{
should_find_io = true; // use card isn't IO
}
else
{
WrappedCard card = room.GetCard(move.Card_ids[0]);
if (card.Name == Edict.ClassName && !card.HasFlag("edict_normal_use"))
{
should_find_io = true; // use card isn't IO
}
}
}
if (should_find_io)
{
foreach (int id in move.Card_ids)
{
WrappedCard card = room.GetCard(id);
if (card.Name == Edict.ClassName)
{
room.MoveCardTo(card, null, Place.PlaceTable, true);
room.AddToPile(room.Players[0], "#edict", card, false);
LogMessage log = new LogMessage
{
Type = "#RemoveEdict",
Arg = Edict.ClassName
};
room.SendLog(log);
room.SetTag("EdictInvoke", true);
room.SetTag("EdictCard", card);
int i = move.Card_ids.IndexOf(id);
move.From_places.RemoveAt(i);
move.Open.RemoveAt(i);
move.From_pile_names.RemoveAt(i);
move.Card_ids.Remove(id);
data = move;
break;
}
}
}
}
break;
}
case TriggerEvent.Death:
{
OnDeath(room, player, ref data);
break;
}
case TriggerEvent.CardsMoveOneTime:
{
if (data is CardsMoveOneTimeStruct move)
{
if (move.From != null && move.From_places.Contains(Place.PlaceEquip))
{
foreach (int id in move.Card_ids)
{
WrappedCard card = room.GetCard(id);
if (card.Name == JadeSeal.ClassName)
{
CheckBigKingdoms(room);
break;
}
}
}
if (move.To != null && move.To_place == Place.PlaceEquip)
{
foreach (int id in move.Card_ids)
{
WrappedCard card = room.GetCard(id);
if (card.Name == JadeSeal.ClassName)
{
CheckBigKingdoms(room);
break;
}
}
}
}
break;
}
default:
break;
}
return(false);
}
public override TriggerStruct Cost(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
if (room.AskForSkillInvoke(ask_who, Name, player, info.SkillPosition))
{
room.BroadcastSkillInvoke(Name, ask_who, info.SkillPosition);
room.DoSuperLightbox(ask_who, info.SkillPosition, Name);
room.DoAnimate(AnimateType.S_ANIMATE_INDICATE, ask_who.Name, player.Name);
room.SetPlayerMark(ask_who, limit_mark, 0);
return(info);
}
return(new TriggerStruct());
}
/*
* public override TriggerStruct Cost(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct inf)
* {
* if (RoomLogic.PlayerHasSkill(room, player, skill_name) && player.Alive && data is InfoStruct info)
* {
* if (!player.HasShownSkill(skill_name, info.Head) && room.AskForSkillInvoke(player, name, null, inf.SkillPosition))
* {
* room.ShowSkill(player, skill_name, inf.SkillPosition);
* return new TriggerStruct();
* }
* else if (player.HasShownSkill(skill_name, info.Head))
* return new TriggerStruct();
* }
* return inf;
* }
*/
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
if (!string.IsNullOrEmpty(pile_name))
{
room.ClearOnePrivatePile(player, pile_name);
}
OnSkillDetached(room, player, data);
return(false);
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
room.SendCompulsoryTriggerLog(player, Name, true);
room.BroadcastSkillInvoke(Name, player, info.SkillPosition);
List <Player> targets = room.GetOtherPlayers(player);
room.SortByActionOrder(ref targets);
foreach (Player p in targets)
{
if (p.Alive && player.Alive)
{
room.DoAnimate(AnimateType.S_ANIMATE_INDICATE, player.Name, p.Name);
room.Damage(new DamageStruct(Name, player, p));
}
}
if (player.Alive)
{
room.LoseHp(player);
}
return(false);
}
public override TriggerStruct Cost(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
return(base.Cost(triggerEvent, room, player, ref data, ask_who, info));
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
if (ask_who != player)
{
ResultStruct result = ask_who.Result;
result.Assist++;
ask_who.Result = result;
}
room.SendCompulsoryTriggerLog(ask_who, Name);
room.BroadcastSkillInvoke(Name, ask_who, info.SkillPosition);
room.DoAnimate(AnimateType.S_ANIMATE_INDICATE, ask_who.Name, player.Name);
int count = (int)data;
count++;
data = count;
return(false);
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
DamageStruct damage = (DamageStruct)data;
OnDamaged(room, player, damage, info);
return(false);
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
if (triggerEvent == TriggerEvent.EventPhaseStart)
{
GeneralSkin gsk = RoomLogic.GetGeneralSkin(room, player, Name, info.SkillPosition);
room.SendCompulsoryTriggerLog(ask_who, Name, true);
room.BroadcastSkillInvoke(Name, "male", 1, gsk.General, gsk.SkinId);
room.DrawCards(ask_who, 2, Name);
}
else
{
room.AskForDiscard(ask_who, Name, 1, 1, false, true, "@moqu", false, info.SkillPosition);
GeneralSkin gsk = RoomLogic.GetGeneralSkin(room, player, Name, info.SkillPosition);
room.BroadcastSkillInvoke(Name, "male", 2, gsk.General, gsk.SkinId);
room.SendCompulsoryTriggerLog(ask_who, Name, true);
}
return(false);
}
public abstract void OnDamaged(Room room, Player target, DamageStruct damage, TriggerStruct info);
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
room.SendCompulsoryTriggerLog(ask_who, Name, true);
room.BroadcastSkillInvoke(Name, ask_who, info.SkillPosition);
int count = ask_who.GetMark(Name);
count++;
List <Player> targets = new List <Player>();
foreach (Player p in room.GetAlivePlayers())
{
if (p.Camp == ask_who.Camp)
{
targets.Add(p);
}
}
room.SortByActionOrder(ref targets);
foreach (Player p in targets)
{
if (p.Alive)
{
room.DoAnimate(AnimateType.S_ANIMATE_INDICATE, ask_who.Name, p.Name);
room.DrawCards(p, new DrawCardStruct(count, ask_who, Name));
}
}
if (ask_who.Alive)
{
ask_who.SetMark(Name, count);
room.SetPlayerStringMark(ask_who, Name, count.ToString());
}
return(false);
}
public virtual TriggerStruct Cost(Room room, ref object data, TriggerStruct info)
{
Player target = room.FindPlayer(info.Invoker, true);
if (RoomLogic.HasArmorEffect(room, target, Name, false) &&
(frequency == Frequency.Compulsory || room.AskForSkillInvoke(target, Name, data)))
{
return(info);
}
List <string> all = new List <string>();
bool show = false;
bool protect = true;
foreach (ViewHasSkill vhskill in Engine.ViewHas(room, target, Name, "armor"))
{
Skill mskill = Engine.GetMainSkill(vhskill.Name);
if (RoomLogic.PlayerHasShownSkill(room, target, mskill))
{
protect = false;
if (frequency == Frequency.Compulsory)
{
show = true;
}
}
all.Add(mskill.Name);
}
if (protect)
{
target.SetFlags("Global_askForSkillCost");
}
if (all.Count > 0)
{
List <TriggerStruct> skills = new List <TriggerStruct>();
foreach (string sk in all)
{
TriggerStruct skill = new TriggerStruct(sk, target)
{
ResultTarget = info.ResultTarget
};
skills.Add(skill);
}
TriggerStruct result = room.AskForSkillTrigger(target, "armorskill", skills, !show, data);
if (string.IsNullOrEmpty(result.SkillName))
{
return(result);
}
else
{
TriggerSkill result_skill = Engine.GetTriggerSkill(result.SkillName);
if (result_skill != null)
{
if (show || all.Count > 1 || room.AskForSkillInvoke(target, result_skill.Name, data, result.SkillPosition))
{
return(result);
}
}
else if (show || all.Count > 1 || room.AskForSkillInvoke(target, result_skill.Name, data, result.SkillPosition))
{
return(info);
}
}
}
return(new TriggerStruct());
}
