public KuangFeng()
 {
     kuangfengTarget = null;
     var trigger = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) => { kuangfengTarget = null; },
         TriggerCondition.OwnerIsSource
     ) { AskForConfirmation = false, IsAutoNotify = false };
     var trigger2 = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) => { return Game.CurrentGame.Decks[Owner, QiXing.QiXingDeck].Count > 0; },
         Run,
         TriggerCondition.OwnerIsSource
     ) { IsAutoNotify = false };
     var trigger3 = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) =>
         {
             var args = a as DamageEventArgs;
             return (DamageElement)args.Element == DamageElement.Fire && kuangfengTarget == args.Targets[0];
         },
         (p, e, a) =>
         {
             var args = a as DamageEventArgs;
             args.Magnitude++;
         },
         TriggerCondition.Global
     ) { AskForConfirmation = false };
     Triggers.Add(GameEvent.PhaseBeginEvents[TurnPhase.Start], trigger);
     Triggers.Add(GameEvent.PhaseBeginEvents[TurnPhase.End], trigger2);
     Triggers.Add(GameEvent.DamageInflicted, trigger3);
     IsAutoInvoked = false;
 }

 public DaWu()
 {
     dawuTargets = new List<Player>();
     var trigger = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) => { foreach (var mark in dawuTargets) { mark[DaWuMark] = 0; } dawuTargets.Clear(); },
         TriggerCondition.OwnerIsSource
     ) { AskForConfirmation = false, IsAutoNotify = false };
     var trigger2 = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) => { return Game.CurrentGame.Decks[Owner, QiXing.QiXingDeck].Count > 0; },
         Run,
         TriggerCondition.OwnerIsSource
     ) { IsAutoNotify = false };
     var trigger3 = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) =>
         {
             var args = a as DamageEventArgs;
             return (DamageElement)args.Element != DamageElement.Lightning && dawuTargets.Contains(args.Targets[0]);
         },
         (p, e, a) =>
         {
             throw new TriggerResultException(TriggerResult.End);
         },
         TriggerCondition.Global
     ) { AskForConfirmation = false };
     Triggers.Add(GameEvent.PhaseBeginEvents[TurnPhase.Start], trigger);
     Triggers.Add(GameEvent.PhaseBeginEvents[TurnPhase.End], trigger2);
     Triggers.Add(GameEvent.DamageInflicted, trigger3);
     IsAutoInvoked = false;
 }

 public ZuiXiang()
 {
     var trigger = new AutoNotifyPassiveSkillTrigger(
         this,
         Run,
         TriggerCondition.OwnerIsSource
     ) { AskForConfirmation = false, IsAutoNotify = false };
     var trigger2 = new AutoNotifyPassiveSkillTrigger(
         this,
         CardUseStopper,
         TriggerCondition.OwnerIsSource
     ) { AskForConfirmation = false, IsAutoNotify = false };
     var trigger3 = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) => { return a.ReadonlyCard != null; },
         CardEffectStopper,
         TriggerCondition.OwnerIsTarget
     ) { AskForConfirmation = false, IsAutoNotify = false };
     Triggers.Add(GameEvent.PhaseBeginEvents[TurnPhase.Start], trigger);
     Triggers.Add(GameEvent.PlayerCanUseCard, trigger2);
     Triggers.Add(GameEvent.PlayerCanPlayCard, trigger2);
     Triggers.Add(GameEvent.CardUsageTargetValidating, trigger3);
     IsSingleUse = true;
     DeckCleanup.Add(zxDeck);
 }

 public TengJiaSkill()
 {
     var trigger = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) => { return a.ReadonlyCard != null && ((a.ReadonlyCard.Type is Aoe) || (a.ReadonlyCard.Type is RegularSha)) && a.ReadonlyCard[Armor.IgnoreAllArmor] == 0 && a.ReadonlyCard[Armor.IgnorePlayerArmor] != Owner.Id + 1; },
         (p, e, a) => { throw new TriggerResultException(TriggerResult.End); },
         TriggerCondition.OwnerIsTarget
     );
     var trigger2 = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) =>
         {
             var args = a as DamageEventArgs;
             return (DamageElement)args.Element == DamageElement.Fire && a.ReadonlyCard[Armor.IgnoreAllArmor] == 0 && a.ReadonlyCard[Armor.IgnorePlayerArmor] != Owner.Id + 1;
         },
         (p, e, a) =>
         {
             var args = a as DamageEventArgs;
             args.Magnitude++;
         },
         TriggerCondition.OwnerIsTarget
     );
     Triggers.Add(GameEvent.CardUsageTargetValidating, trigger);
     Triggers.Add(GameEvent.DamageInflicted, trigger2);
 }

 public RulerGivenSkillContainerSkill(IRulerGivenSkill InnerSkill, Allegiance al)
 {
     innerSkillType = InnerSkill.GetType();
     Allegiance = al;
     masterList = new Dictionary<Player, IRulerGivenSkill>();
     var trigger = new AutoNotifyPassiveSkillTrigger(
         this,
         DistributeSkills,
         TriggerCondition.OwnerIsSource
     ) { IsAutoNotify = false, AskForConfirmation = false };
     var trigger2 = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) =>
         {
             if (a.Source.Allegiance == Allegiance && !masterList.ContainsKey(a.Source))
             {
                 DistributeSkills(Owner, null, null);
             }
             if (a.Source.Allegiance != Allegiance && masterList.ContainsKey(a.Source))
             {
                 ISkill skill = masterList[a.Source];
                 masterList.Remove(a.Source);
                 Game.CurrentGame.PlayerLoseAdditionalSkill(a.Source, skill, true);
             }
         },
         TriggerCondition.Global
     ) { IsAutoNotify = false, AskForConfirmation = false };
     Triggers.Add(GameEvent.PlayerGameStartAction, trigger);
     Triggers.Add(GameEvent.PlayerChangedAllegiance, trigger2);
     IsAutoInvoked = null;
     IsRulerOnly = true;
 }

 public ZiLi()
 {
     var trigger = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) => { return p[ZiLiAwakened] == 0 && Game.CurrentGame.Decks[p, QuanJi.QuanDeck].Count >= 3; },
         (p, e, a) =>
         {
             p[ZiLiAwakened] = 1;
             Game.CurrentGame.LoseMaxHealth(p, 1);
             int answer = 0;
             Owner.AskForMultipleChoice(
                     new MultipleChoicePrompt("ZiLi"),
                     new List<OptionPrompt>() { new OptionPrompt("ZiLiRecover"), new OptionPrompt("ZiLiDraw") },
                     out answer);
             if (answer == 0)
             {
                 Game.CurrentGame.RecoverHealth(Owner, Owner, 1);
             }
             else
             {
                 Game.CurrentGame.DrawCards(Owner, 2);
             }
             Game.CurrentGame.PlayerAcquireAdditionalSkill(Owner, new PaiYi(), HeroTag);
         },
         TriggerCondition.OwnerIsSource
     );
     Triggers.Add(GameEvent.PhaseBeginEvents[TurnPhase.Start], trigger);
     IsAwakening = true;
 }

 public BengHuai()
 {
     var trigger = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) =>
         {
             int minHp = int.MaxValue;
             foreach (Player pl in Game.CurrentGame.AlivePlayers)
             {
                 if (pl.Health < minHp) minHp = pl.Health;
             }
             return p.Health > minHp;
         },
         (p, e, a) =>
         {
             int answer = 0;
             Game.CurrentGame.UiProxies[p].AskForMultipleChoice(new MultipleChoicePrompt("BengHuai"), new List<string>() { "TiLiZhi", "TiLiShangXian" }, out answer);
             if (answer == 0)
             {
                 Game.CurrentGame.LoseHealth(p, 1);
             }
             else
             {
                 Game.CurrentGame.LoseMaxHealth(p, 1);
             }
         },
         TriggerCondition.OwnerIsSource
     );
     Triggers.Add(GameEvent.PhaseBeginEvents[TurnPhase.End], trigger);
     IsEnforced = true;
 }

 public ZhuGeLianNuSkill()
 {
     var trigger = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) =>
         {
             return a.Source[Sha.NumberOfShaUsed] > 0 &&  a.Card.Type is Sha;
         },
         (p, e, a) => { },
         TriggerCondition.OwnerIsSource
     );
     var trigger2 = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) => { throw new TriggerResultException(TriggerResult.Success); },
         TriggerCondition.OwnerIsSource
     ) { IsAutoNotify = false };
     var trigger3 = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) =>
         {
             ShaEventArgs args = (ShaEventArgs)a;
             args.TargetApproval[0] = true;
         },
         TriggerCondition.OwnerIsSource
     ) { IsAutoNotify = false, Priority = int.MaxValue, Type = TriggerType.Skill };
     Triggers.Add(GameEvent.PlayerUsedCard, trigger);
     Triggers.Add(Sha.PlayerNumberOfShaCheck, trigger2);
     Triggers.Add(Sha.PlayerShaTargetValidation, trigger3);
     IsEnforced = true;
 }

        public WeiMu()
        {
            Triggers.Add(GameEvent.PlayerCanBeTargeted, new RelayTrigger(
                (p, e, a) =>
                {
                    return CardCategoryManager.IsCardCategory(a.Card.Type.Category, CardCategory.Tool) && a.Card.SuitColor == SuitColorType.Black;
                },
                (p, e, a) =>
                {
                    if (a.Card.Place.DeckType == DeckType.DelayedTools)
                    {
                        NotifySkillUse();
                    }
                    throw new TriggerResultException(TriggerResult.Fail);
                },
                TriggerCondition.OwnerIsTarget
                ));

            var notify = new AutoNotifyPassiveSkillTrigger(
                 this,
                 (p, e, a) => { return a.Source != p && a.ReadonlyCard.Type is Aoe && a.ReadonlyCard.SuitColor == SuitColorType.Black; },
                 (p, e, a) => { },
                 TriggerCondition.Global
             );
            Triggers.Add(GameEvent.PlayerUsedCard, notify);
            IsEnforced = true;
        }

        public LieGong()
        {
            var trigger = new AutoNotifyPassiveSkillTrigger(
                this,
                (p, e, a) => { return (a.ReadonlyCard.Type is Sha) && Game.CurrentGame.CurrentPhase == TurnPhase.Play; },
                (p, e, a) =>
                {
                    Dictionary<Player, int> map = new Dictionary<Player, int>();
                    foreach (var target in a.Targets)
                    {
                        if (!map.Keys.Contains(target)) map.Add(target, 0);
                        if ((Game.CurrentGame.Decks[target, DeckType.Hand].Count >= a.Source.Health || Game.CurrentGame.Decks[target, DeckType.Hand].Count <= a.Source[Player.AttackRange] + 1)
                         && AskForSkillUse())
                        {
                            a.ReadonlyCard[ShaCancelling.CannotProvideShan[target]] |= (1 << map[target]);
                            NotifySkillUse(new List<Player>() { target });
                        }
                        map[target]++;
                    }
                },
                TriggerCondition.OwnerIsSource
            ) { IsAutoNotify = false, AskForConfirmation = false };

            Triggers.Add(GameEvent.CardUsageTargetConfirmed, trigger);
            IsAutoInvoked = true;
        }

 public FangQuan()
 {
     var trigger = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) =>
         {
             return !Game.CurrentGame.PhasesSkipped.Contains(TurnPhase.Play);
         },
         (p, e, a) =>
         {
             p[FangQuanUsed] = 1;
             Game.CurrentGame.PhasesSkipped.Add(TurnPhase.Play);
         },
         TriggerCondition.OwnerIsSource
     );
     var trigger2 = new AutoNotifyUsagePassiveSkillTrigger(
         this,
         (p, e, a) => { return p[FangQuanUsed] == 1; },
         (p, e, a, cards, players) =>
         {
             Game.CurrentGame.HandleCardDiscard(a.Source, cards);
             Game.CurrentGame.RegisterTrigger(GameEvent.PhasePostEnd, new FangQuanTrigger(Owner, players[0]));
         },
         TriggerCondition.OwnerIsSource,
         new FangQuanVerifier()
     ) { AskForConfirmation = false };
     Triggers.Add(GameEvent.PhaseOutEvents[TurnPhase.Draw], trigger);
     Triggers.Add(GameEvent.PhaseProceedEvents[TurnPhase.End], trigger2);
 }

 public GuZheng()
 {
     GuZhengCards = new List<Card>();
     var trigger = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) => { return Game.CurrentGame.CurrentPlayer != p && Game.CurrentGame.CurrentPhase == TurnPhase.Discard; },
         (p, e, a) => { GuZhengCards.AddRange(a.Cards); },
         TriggerCondition.Global
     ) { IsAutoNotify = false, AskForConfirmation = false };
     var trigger2 = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) => { return GuZhengCards.Count > 0 && Game.CurrentGame.CurrentPlayer != p; },
         Run,
         TriggerCondition.Global
     ) { Priority = 1 };
     var trigger3 = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) => { GuZhengCards = new List<Card>(); },
         TriggerCondition.Global
     ) { Priority = 0, AskForConfirmation = false, IsAutoNotify = false };
     Triggers.Add(GameEvent.CardsEnteredDiscardDeck, trigger);
     Triggers.Add(GameEvent.PhaseEndEvents[TurnPhase.Discard], trigger2);
     Triggers.Add(GameEvent.PhasePostEnd, trigger3);
     IsAutoInvoked = null;
 }

        public WeiDi()
        {
            var trigger = new AutoNotifyPassiveSkillTrigger(
                this,
                (p, e, a) => { return a.Source == ruler; },
                (p, e, a) =>
                {
                    bool canInvoke = true;
                    if (e == GameEvent.PlayerSkillSetChanged)
                    {
                        SkillSetChangedEventArgs arg = a as SkillSetChangedEventArgs;
                        canInvoke = arg.Skills.Any(sk => sk.IsRulerOnly);
                    }
                    if (canInvoke)
                    {
                        UninstallSkills();
                        InstallSkills(p, ruler);
                    }
                },
                TriggerCondition.Global
            ) { AskForConfirmation = false, IsAutoNotify = false };
            Triggers.Add(GameEvent.PlayerSkillSetChanged, trigger);
            Triggers.Add(GameEvent.PlayerChangedHero, trigger);

            IsEnforced = true;
            ruler = null;
            theSkills = new Dictionary<ISkill, ISkill>();
        }

        public WuJi()
        {
            var trigger1 = new AutoNotifyPassiveSkillTrigger(
                this,
                (p, e, a) => { return p[WuJiAwaken] == 0; },
                (p, e, a) => { p[WuJiCount] += (a as DamageEventArgs).Magnitude; },
                TriggerCondition.OwnerIsSource
            ) { IsAutoNotify = false };
            Triggers.Add(GameEvent.AfterDamageCaused, trigger1);

            var trigger2 = new AutoNotifyPassiveSkillTrigger(
                this,
                (p, e, a) => { return p[WuJiCount] >= 3 && p[WuJiAwaken] == 0; },
                (p, e, a) =>
                {
                    p[WuJiAwaken]++;
                    p.MaxHealth++;
                    Game.CurrentGame.RecoverHealth(p, p, 1);
                    ISkill huxiao = p.LoseHeroSkill("HuXiao", HeroTag);
                    Trace.Assert(huxiao != null);
                    Game.CurrentGame.NotificationProxy.NotifyLogEvent(new LogEvent("WuJi", Owner, huxiao), new List<Player>() { Owner });
                },
                TriggerCondition.OwnerIsSource
            );
            Triggers.Add(GameEvent.PhaseBeginEvents[TurnPhase.End], trigger2);
            IsAwakening = true;
        }

        public DuanChang()
        {
            var trigger = new AutoNotifyPassiveSkillTrigger(
                this,
                (p, e, a) => { return a.Source != null; },
                (p, e, a) =>
                {
                    var h = a.Source.Hero;
                    foreach (ISkill sk in new List<ISkill>(a.Source.AdditionalSkills))
                    {
                        Game.CurrentGame.PlayerLoseSkill(a.Source, sk);
                    }

                    SkillSetChangedEventArgs args = new SkillSetChangedEventArgs();
                    args.Source = a.Source;
                    args.IsLosingSkill = true;
                    foreach (var sk in a.Source.Hero.Skills)
                    {
                        sk.Owner = null;
                        args.Skills.Clear();
                        args.Skills.Add(sk);
                        Game.CurrentGame.Emit(GameEvent.PlayerSkillSetChanged, args);
                    }
                    a.Source.Hero = new Hero(h.Name, h.IsMale, h.Allegiance, h.MaxHealth, new List<ISkill>());
                    a.Source[DuanChangStatus] = 1;
                },
                TriggerCondition.OwnerIsTarget
            );

            Triggers.Add(GameEvent.PlayerIsDead, trigger);
            IsEnforced = true;
        }

        public EnforcedCardTransformSkill()
        {
            Decks = new List<DeckType>();
            var trigger = new AutoNotifyPassiveSkillTrigger(
                this,
                (p, e, a) => { return a.Card != null && Decks.Contains(a.Card.Place.DeckType) && CardVerifier(a.Card); },
                (p, e, a) => { TransfromAction(p, a.Card); },
                TriggerCondition.OwnerIsSource
            ) { IsAutoNotify = false };
            Triggers.Add(GameEvent.EnforcedCardTransform, trigger);

            var notify = new AutoNotifyPassiveSkillTrigger(
                this,
                (p, e, a) =>
                {
                    Card card = a.Card as Card;
                    return card != null && Decks.Contains(card.HistoryPlace1.DeckType) && CardVerifier(Game.CurrentGame.OriginalCardSet[card.Id]);
                },
                (p, e, a) =>
                {
                    Game.CurrentGame.NotificationProxy.NotifyLogEvent(
                        new LogEvent("EnforcedCardTransform", Owner, Game.CurrentGame.OriginalCardSet[(a.Card as Card).Id], a.Card),
                        new List<Player> { Owner },
                        true,
                        false
                    );
                },
                TriggerCondition.OwnerIsSource
            );
            Triggers.Add(GameEvent.PlayerUsedCard, notify);
            IsEnforced = true;
        }

        public MouKui()
        {
            var trigger = new AutoNotifyPassiveSkillTrigger(
                this,
                (p, e, a) => { return a.ReadonlyCard.Type is Sha; },
                Run1,
                TriggerCondition.OwnerIsSource
            ) { AskForConfirmation = false, IsAutoNotify = false };
            Triggers.Add(GameEvent.CardUsageTargetConfirmed, trigger);

            var trigger2 = new AutoNotifyPassiveSkillTrigger(
                this,
                Run2,
                TriggerCondition.OwnerIsSource
            ) { AskForConfirmation = false, IsAutoNotify = false };
            Triggers.Add(ShaCancelling.PlayerShaTargetDodged, trigger2);

            var trigger3 = new AutoNotifyPassiveSkillTrigger(
                this,
                (p, e, a) =>
                {
                    if (a.ReadonlyCard[MouKuiCheck] == 0)
                    {
                        a.ReadonlyCard[MouKuiCheck] = 1;
                        return;
                    }
                    a.ReadonlyCard[MouKuiCheck[a.Targets[0]]] >>= 1;
                }
                ,
                TriggerCondition.OwnerIsSource
            ) { AskForConfirmation = false, IsAutoNotify = false };
            Triggers.Add(ShaCancelling.PlayerShaTargetShanModifier, trigger3);
            IsAutoInvoked = null;
        }

 public JueCe()
 {
     var trigger = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) =>
         {
             var ret = a.Cards.Any(c => c[Card.IsLastHandCard] == 1) && Game.CurrentGame.CurrentPlayer == p;
             if (ret)
             {
                 var card = a.Cards.FirstOrDefault(c => c[Card.IsLastHandCard] == 1);
                 if (card != null && card.HistoryPlace1.Player != null && !card.HistoryPlace1.Player.IsDead)
                     return true;
             }
             return false;
         },
         (p, e, a) =>
         {
             var card = a.Cards.FirstOrDefault(c => c[Card.IsLastHandCard] == 1);
             if (card != null && card.HistoryPlace1.Player != null)
                 Game.CurrentGame.DoDamage(p, card.HistoryPlace1.Player, 1, DamageElement.None, null, null);
         },
         TriggerCondition.Global
     ) {  };
     Triggers.Add(GameEvent.CardsLost, trigger);
     IsAutoInvoked = null;
 }

 public ShenJi()
 {
     var trigger = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) => { return p.Weapon() == null; },
         (p, e, a) =>
         {
             ShaEventArgs args = (ShaEventArgs)a;
             if (args.TargetApproval[0] == false)
             {
                 return;
             }
             int moreTargetsToApprove = 2;
             int i = 1;
             while (moreTargetsToApprove > 0 && i < args.TargetApproval.Count)
             {
                 if (args.TargetApproval[i] == true)
                 {
                     i++;
                     continue;
                 }
                 args.TargetApproval[i] = true;
                 i++;
                 moreTargetsToApprove--;
             }
         },
         TriggerCondition.OwnerIsSource
     ) { IsAutoNotify = false, AskForConfirmation = false, Priority = SkillPriority.ShenJi };
     Triggers.Add(Sha.PlayerShaTargetValidation, trigger);
     IsAutoInvoked = null;
 }

 public QingGangJianSkill()
 {
     var trigger = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) =>
         {
             return a.ReadonlyCard != null && (a.ReadonlyCard.Type is Sha);
         },
         Run,
         TriggerCondition.OwnerIsSource
     );
     Triggers.Add(GameEvent.CardUsageTargetConfirmed, trigger);
     var trigger2 = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) =>
         {
             return a.ReadonlyCard != null && (a.ReadonlyCard.Type is Sha);
         },
         (p, e, a) => { var args = a as DamageEventArgs; args.ReadonlyCard[Armor.IgnorePlayerArmor[args.Targets[0]]]--;},
         TriggerCondition.OwnerIsSource
     ) { AskForConfirmation = false, IsAutoNotify = false, Priority = int.MinValue };
     Triggers.Add(GameEvent.DamageInflicted, trigger2);
     var trigger3 = new AutoNotifyPassiveSkillTrigger(
         this,
         (p, e, a) =>
         {
             return a.ReadonlyCard != null && (a.ReadonlyCard.Type is Sha);
         },
         (p, e, a) => { a.ReadonlyCard[Armor.IgnorePlayerArmor[a.Targets[0]]]--; },
         TriggerCondition.OwnerIsSource
     ) { AskForConfirmation = false, IsAutoNotify = false, Priority = int.MinValue };
     Triggers.Add(ShaCancelling.PlayerShaTargetDodged, trigger3);
     IsEnforced = true;
 }