예제 #1
0
    public void Operation(IDuel duel, Card card, LauchEffect effect, Group group = null)
    {
        Group g1 = duel.GetIncludeNameCardFromArea(ComStr.KeyWord_ElementalHERO, false, card.ownerPlayer, ComVal.CardType_Monster_Fusion, ComVal.Area_Extra);
        Group g2 = duel.GetIncludeNameCardFromArea("", false, card.ownerPlayer, ComVal.cardType_Monster, ComVal.Area_Monster | ComVal.Area_Graveyard);

        g1 = g1.GetCanFusionGroup(g2);
        g1 = card.controller.GetCanSpSummonGroup(g1);
        GroupCardSelectBack callBack = delegate(Group theGroup)
        {
            Card  c  = theGroup.GetCard(0);
            Group g3 = c.cardMaterialFitler.GetGroup(g2);

            GroupCardSelectBack callBack1 = delegate(Group theGroup1)
            {
                normalDele finish = delegate
                {
                    duel.FinishHandle();
                };
                normalDele d = delegate
                {
                    duel.SpeicalSummon(ComVal.Area_Extra, c, card.ownerPlayer, card, ComVal.reason_FusionSummon, effect, 0, finish);
                };
                duel.AddDelegate(d);
                duel.SendToRemove(ComVal.Area_Graveyard | ComVal.Area_Monster, theGroup1, card, ComVal.reason_FusionMaterial, effect);
            };
            duel.SelectFusionMaterialFromGroup(g3, callBack1, c);
        };

        duel.SelectCardFromGroup(g1, callBack, 1, card.controller);
    }
예제 #2
0
    public void Operation(IDuel duel, Card card, LauchEffect effect, Group group = null)
    {
        Group g = duel.GetIncludeNameCardFromArea("", false, duel.GetOpsitePlayer(card.controller), ComVal.cardType_Monster, ComVal.Area_Monster);

        duel.AddFinishHandle();
        duel.SendToGraveyard(ComVal.Area_Monster, g, card, ComVal.reason_EffectDestroy, effect);
    }
예제 #3
0
    public void Operation(IDuel duel, Card card, LauchEffect effect, Group group = null)
    {
        Group g = duel.GetIncludeNameCardFromArea("", false, card.controller, 0, ComVal.Area_MainDeck, Fiter);

        duel.AddFinishHandle();
        duel.AddCardToHandFromMainDeck(g.GetCard(0), card.controller, card, effect);
    }
예제 #4
0
    public void InitialEffect(Card card, Player player, IDuel duel)
    {
        LauchEffect e1 = new LauchEffect();

        e1.SetEffectID("50720316");
        e1.SetCategory(ComVal.category_search | ComVal.category_toHand);
        e1.SetCode(ComVal.code_ToGraveyard);
        e1.SetCardEffectType(ComVal.cardEffectType_mustToChooseLauch);
        e1.SetCheckLauch(CheckLauch);
        e1.SetOperation(Operation);
        e1.SetLauchArea(ComVal.Area_Graveyard);
        duel.ResignEffect(e1, card, player);

        LauchEffect e2 = new LauchEffect();

        e2.SetEffectID("50720316");
        e2.SetCategory(ComVal.category_search | ComVal.category_toHand);
        e2.SetCode(ComVal.code_SpecialSummon);
        e2.SetCardEffectType(ComVal.cardEffectType_mustToChooseLauch);
        e2.SetCheckLauch(CheckLauch1);
        e2.SetOperation(Operation1);
        e2.SetLauchArea(ComVal.Area_Monster);
        duel.ResignEffect(e2, card, player);

        duel.ResignEffectLauchLimitCounter(player, "50720316", 1);
    }
예제 #5
0
    public void Operation(IDuel duel, Card card, LauchEffect effect, Group group = null)
    {
        Group      g = duel.GetIncludeNameCardFromArea("", true, card.controller, 0, ComVal.Area_Field);
        normalDele d = delegate
        {
            duel.AddFinishHandle();
            duel.DiscardFromDeck(3, card, effect, card.controller);
        };

        GetMes d1 = delegate(bool val)
        {
            if (val)
            {
                GroupCardSelectBack d2 = delegate(Group target)
                {
                    duel.AddDelegate(d, true);
                    duel.SendToGraveyard(ComVal.Area_Field, target, card, ComVal.reason_EffectDestroy, effect);
                };
                duel.SelectCardFromGroup(g, d2, 1, card.controller);
            }
            else
            {
                d();
            }
        };

        if (g.GroupNum > 0)
        {
            duel.ShowDialogBox(card, d1, card.controller.isMy);
        }
        else
        {
            d();
        }
    }
예제 #6
0
    public void Operation(IDuel duel, Card card, LauchEffect effect, Group group = null)
    {
        AttackEvent e  = duel.GetCurAttackEvent();
        StateEffect e1 = new StateEffect();

        e1.SetRangeArea(ComVal.Area_Monster);
        e1.SetCategory(ComVal.category_stateEffect | ComVal.category_limitTime);
        e1.SetCardEffectType(ComVal.cardEffectType_Single | ComVal.cardEffectType_normalStateEffect);
        e1.SetStateEffectType(ComVal.stateEffectType_addAfkVal);

        if (e.Attacker.controller == card.controller)
        {
            e1.SetTarget(e.Attacker);
            e1.SetStateEffectVal(e.Attackeder.GetCurAfk());
        }
        else
        {
            e1.SetTarget(e.Attackeder);
            e1.SetStateEffectVal(e.Attacker.GetCurAfk());
        }

        e1.SetResetCode(ComVal.resetEvent_LeaveEndPhase, 0);
        duel.ResignEffect(e1, card, card.controller);
        duel.FinishHandle();
    }
예제 #7
0
    public void Operation(IDuel duel, Card card, LauchEffect effect, Group group = null)
    {
        Group g1 = duel.GetIncludeNameCardFromArea("", false, card.ownerPlayer, ComVal.CardType_Monster_Fusion, ComVal.Area_Extra);
        Group g2 = duel.GetIncludeNameCardFromArea("", false, card.ownerPlayer, ComVal.cardType_Monster, ComVal.Area_Hand | ComVal.Area_Monster);

        g1 = g1.GetCanFusionGroup(g2);
        g1 = card.controller.GetCanSpSummonGroup(g1);
        if (g1.GroupNum == 0)
        {
            duel.FinishHandle();
            return;
        }
        GroupCardSelectBack callBack = delegate(Group theGroup)
        {
            Card  c  = theGroup.GetCard(0);
            Group g3 = c.cardMaterialFitler.GetGroup(g2);

            GroupCardSelectBack callBack1 = delegate(Group theGroup1)
            {
                normalDele dele = delegate
                {
                    duel.FinishHandle();
                };
                normalDele d = delegate
                {
                    duel.SpeicalSummon(ComVal.Area_Extra, c, card.ownerPlayer, card, ComVal.reason_Effect, effect, 0, dele);
                };
                duel.AddDelegate(d);
                duel.SendToGraveyard(ComVal.Area_Monster | ComVal.Area_Hand, theGroup1, card, ComVal.reason_FusionMaterial);
            };
            duel.SelectFusionMaterialFromGroup(g3, callBack1, c);
        };

        duel.SelectCardFromGroup(g1, callBack, 1, card.controller);
    }
예제 #8
0
    public void Operation(IDuel duel, Card card, LauchEffect effect, Group group = null)
    {
        Card c = group.GetFirstCard();

        if (!card.curArea.IsBind(ComVal.Area_Monster) || !c.curArea.IsBind(ComVal.Area_Graveyard))
        {
            duel.FinishHandle();
            return;
        }

        normalDele d1 = delegate
        {
            StateEffect e1 = new StateEffect();
            e1.SetCardEffectType(ComVal.cardEffectType_equip | ComVal.cardEffectType_Single);
            e1.SetCategory(ComVal.category_equipCard);
            e1.SetEquipCard(card, c);
            e1.SetRangeArea(ComVal.Area_Trap);
            duel.ResignEffect(e1, c, card.controller);

            duel.FinishHandle();
        };

        duel.AddDelegate(d1, true);
        duel.EquipCardFromArea(ComVal.Area_Graveyard, c, card.controller, card, effect);
    }
예제 #9
0
    private void GetTarget(IDuel duel, Card card, LauchEffect effect, GroupCardSelectBack dele)
    {
        Group g = duel.GetIncludeNameCardFromArea(ComStr.KeyWord_ElementalHERO, false, card.controller, ComVal.CardType_Monster_Double | ComVal.CardType_Monster_Normal,
                                                  ComVal.Area_Graveyard);

        duel.SelectCardFromGroup(g, dele, 1, card.controller);
    }
예제 #10
0
    public void InitialEffect(Card card, Player player, IDuel duel)
    {
        LauchEffect e1 = new LauchEffect();

        e1.SetCardEffectType(ComVal.cardEffectType_mustNotInChain);
        e1.SetCategory(ComVal.category_pointer);
        e1.SetCheckLauch(CheckLauch);
        e1.SetCode(ComVal.code_NormalSummon | ComVal.code_SpecialSummon);
        e1.SetLauchArea(ComVal.Area_NormalTrap);
        e1.SetOperation(Operation);
        duel.ResignEffect(e1, card, player);

        LauchEffect e2 = new LauchEffect();

        e2.SetCardEffectType(ComVal.cardEffectType_normalLauch);
        e2.SetCode(ComVal.code_NoCode);
        e2.SetCategory(ComVal.category_drawCard);
        e2.SetCheckLauch(CheckLauch1);
        e2.SetCost(Cost);
        e2.SetLauchArea(ComVal.Area_NormalTrap);
        e2.SetOperation(Operation1);
        duel.ResignEffect(e2, card, player);

        LauchEffect e3 = new LauchEffect();

        e3.SetCardEffectType(ComVal.cardEffectType_normalLauch);
        e3.SetCode(ComVal.code_NoCode);
        e3.SetLauchArea(ComVal.Area_Hand);
        e3.SetOperation(Operation2);
        e3.SetCheckLauch(CheckLauch2);
        duel.ResignEffect(e3, card, player);
    }
예제 #11
0
    public void Operation(IDuel duel, Card card, LauchEffect effect, Group group = null)
    {
        Group g = duel.GetIncludeNameCardFromArea("", true, null, ComVal.cardType_Monster, ComVal.Area_Monster);

        duel.AddFinishHandle();
        duel.SendToGraveyard(ComVal.Area_Field, g, card, ComVal.reason_EffectDestroy, effect);
    }
예제 #12
0
    public void InitialEffect(Card card, Player player, IDuel duel)
    {
        //检索
        LauchEffect e1 = new LauchEffect();

        e1.SetCategory(ComVal.category_search | ComVal.category_toHand);
        e1.SetCheckLauch(CheckLauch);
        e1.SetOperation(Operation);
        e1.SetCode(ComVal.code_NotSpSummon | ComVal.code_SpecialSummon);
        e1.SetCardEffectType(ComVal.cardEffectType_mustToChooseLauch);
        e1.SetLauchArea(ComVal.Area_Monster);
        duel.ResignEffect(e1, card, player);

        //送去墓地
        LauchEffect e2 = new LauchEffect();

        e2.SetCategory(ComVal.category_toGrave);
        e2.SetCode(ComVal.code_NoCode);
        e2.SetCardEffectType(ComVal.cardEffectType_normalLauch);
        e2.SetLauchArea(ComVal.Area_Monster);
        e2.SetCheckLauch(CheckLauch1);
        e2.SetOperation(Operation1);
        e2.SetLauchPhase(ComVal.Phase_Mainphase);
        duel.ResignEffect(e2, card, player);

        card.SetCardCountLimit(e1, e2, 1);
    }
예제 #13
0
    public void InitialEffect(Card card, Player player, IDuel duel)
    {
        card.SetMaterialFilter2(F1, F2);

        LauchEffect e1 = new LauchEffect();

        e1.SetCategory(ComVal.category_destroy | ComVal.category_disAbleEffect);
        e1.SetCardEffectType(ComVal.cardEffectType_chooseLauch);
        e1.SetCode(ComVal.code_EffectLanch);
        e1.SetLauchArea(ComVal.Area_Monster);
        e1.SetCheckLauch(CheckLauch);
        e1.SetCost(Cost);
        e1.SetOperation(Operation);
        duel.ResignEffect(e1, card, player);

        LauchEffect e2 = new LauchEffect();

        e2.SetCategory(ComVal.category_revived);
        e2.SetCardEffectType(ComVal.cardEffectType_chooseLauch);
        e2.SetCode(ComVal.code_EnterEndPhase);
        e2.SetLauchArea(ComVal.Area_Graveyard);
        e2.SetCheckLauch(CheckLauch1);
        e2.SetOperation(Operation1);
        duel.ResignEffect(e2, card, player);
    }
예제 #14
0
    public bool CheckLauch(IDuel duel, Card card, LauchEffect effect, Code code)
    {
        Group g = duel.GetIncludeNameCardFromArea(ComStr.KeyWord_Lightsworn, false, card.controller, ComVal.cardType_Monster, ComVal.Area_Graveyard);

        Debug.Log(g.GetTypeNum());
        return(g.GetTypeNum() >= 4);
    }
예제 #15
0
 public void AddCardEffectLauchTime(LauchEffect effect)
 {
     foreach (var item in effectLauchCountLimitList)
     {
         item.AddLauchCount(effect);
     }
 }
예제 #16
0
    public bool CheckLauch(IDuel duel, Card card, LauchEffect effect, Code code)
    {
        Group g = duel.GetIncludeNameCardFromArea(ComStr.KeyWord_ElementalHERO, false, card.controller, ComVal.CardType_Monster_Double | ComVal.CardType_Monster_Normal,
                                                  ComVal.Area_Graveyard);

        return(g.GroupNum > 0);
    }
예제 #17
0
    public void Operation(IDuel duel, Card card, LauchEffect effect, Group group = null)
    {
        Card c = group.GetCard(0);

        if (c.curArea != ComVal.Area_Monster)
        {
            duel.FinishHandle();
            return;
        }
        Group g = duel.GetIncludeNameCardFromArea(ComStr.KeyWord_MaskHERO, false, card.ownerPlayer, ComVal.CardType_Monster_Fusion, ComVal.Area_Extra);

        g = g.SiftingGroupInAttr(c.GetCurAttribute());
        g = card.controller.GetCanSpSummonGroup(g);
        GroupCardSelectBack d = delegate(Group g1)
        {
            Card c1 = g1.GetCard(0);

            normalDele dele = delegate
            {
                duel.FinishHandle();
            };
            duel.SpeicalSummon(ComVal.Area_Extra, c1, card.ownerPlayer, card, ComVal.reason_Effect, effect, 0, dele);
        };
        normalDele d1 = delegate
        {
            duel.SelectCardFromGroup(g, d, 1, card.controller);
        };

        duel.AddDelegate(d1);
        duel.SendToGraveyard(ComVal.Area_Monster, group, card, ComVal.reason_Effect, effect);
    }
예제 #18
0
    public void Operation(IDuel duel, Card card, LauchEffect effect, Group group = null)
    {
        Card target = card.EffectDataCard;

        mCard = target;
        Group g = duel.GetIncludeNameCardFromArea(ComStr.KeyWord_SixSamurai, false, card.controller, ComVal.cardType_Monster, ComVal.Area_MainDeck, Fiter);

        if (!target.curArea.IsBind(ComVal.Area_Monster) || g.GroupNum == 0)
        {
            duel.FinishHandle();
            return;
        }

        GroupCardSelectBack callBack = delegate(Group val)
        {
            normalDele d = delegate
            {
                normalDele DestoryCard = delegate
                {
                    Card c = val.GetFirstCard();
                    duel.SendToGraveyard(ComVal.Area_Monster, c.ToGroup(), card, ComVal.reason_Effect, effect);
                };
                duel.AddDelayAction(DestoryCard, ComVal.resetEvent_LeaveEndPhase, 0);
                duel.FinishHandle();
            };
            duel.SpeicalSummon(ComVal.Area_MainDeck, val.GetFirstCard(), card.controller, card, ComVal.reason_Effect, effect, 0, d);
        };

        duel.SelectCardFromGroup(g, callBack, 1, card.controller);
    }
예제 #19
0
    public void InitialEffect(Card card, Player player, IDuel duel)
    {
        LauchEffect e1 = new LauchEffect();

        e1.SetCategory(ComVal.category_addAttackVal);
        e1.SetCode(ComVal.code_BeforeReckonAttack);
        e1.SetLauchPhase(ComVal.Phase_Battlephase);
        e1.SetLauchArea(ComVal.Area_Hand);
        e1.SetCardEffectType(ComVal.cardEffectType_chooseLauch);
        e1.SetCost(Cost);
        e1.SetCheckLauch(CheckLauch);
        e1.SetOperation(Operation);
        duel.ResignEffect(e1, card, player);

        LauchEffect e2 = new LauchEffect();

        e2.SetCategory(ComVal.category_toHand);
        e2.SetCardEffectType(ComVal.cardEffectType_normalLauch);
        e2.SetCode(ComVal.code_NoCode);
        e2.SetLauchPhase(ComVal.Phase_Mainphase);
        e2.SetLauchArea(ComVal.Area_Monster);
        e2.SetCheckLauch(CheckLauch1);
        e2.SetOperation(Operation1);
        duel.ResignEffect(e2, card, player);
    }
예제 #20
0
    public void Operation(IDuel duel, Card card, LauchEffect effect, Group group = null)
    {
        GroupCardSelectBack d = delegate(Group val)
        {
            card.EffectDataGroup = val;

            normalDele d1 = delegate
            {
                Group      result = new Group();
                normalDele d2     = delegate
                {
                    List <Card> list     = result.ToList();
                    int         reduceLP = 0;
                    foreach (var item in list)
                    {
                        reduceLP += item.GetCurAfk();
                    }
                    duel.ReduceLP(reduceLP, card.controller, ComVal.reason_Effect, card, effect);
                    duel.FinishHandle();
                };
                duel.AddDelegate(d2, true);
                Group target = card.EffectDataGroup.GetFitlerGroup(Fiter1);
                result = duel.SendToGraveyard(ComVal.Area_Monster, target, card, ComVal.reason_EffectDestroy, effect);
            };
            duel.AddDelayAction(d1, ComVal.resetEvent_LeaveEndPhase, 0);
            duel.FinishHandle();
        };

        duel.SpeicalSummon(ComVal.Area_Graveyard, group, card.controller, card, ComVal.reason_Effect, effect, ComVal.CardPutType_UpRightFront, d);
    }
예제 #21
0
    public void Operation(IDuel duel, Card card, LauchEffect effect, Group group = null)
    {
        Card target = group.GetCard(0);

        duel.AddFinishHandle();
        duel.AddCardToHandFromArea(ComVal.Area_Monster, target, target.ownerPlayer, card, effect);
    }
예제 #22
0
    public void InitialEffect(Card card, Player player, IDuel duel)
    {
        LauchEffect e1 = new LauchEffect();

        e1.SetCategory(ComVal.category_spSummon);
        e1.SetCode(ComVal.code_ToGraveyard);
        e1.SetCardEffectType(ComVal.cardEffectType_mustLauch);
        e1.SetCheckLauch(CheckLauch);
        e1.SetOperation(Operation);
        e1.SetLauchArea(ComVal.Area_Graveyard);
        duel.ResignEffect(e1, card, player);

        StateEffect e2 = new StateEffect();

        e2.SetTarget(card);
        e2.SetCardEffectType(ComVal.cardEffectType_Single | ComVal.cardEffectType_normalStateEffect | ComVal.cardEffectType_unableReset);
        e2.SetStateEffectType(ComVal.stateEffectType_unableNormalSummon);
        duel.ResignEffect(e2, card, player);

        LauchEffect e3 = new LauchEffect();

        e3.SetCategory(ComVal.category_destroy | ComVal.category_disCard);
        e3.SetCode(ComVal.code_NoCode);
        e3.SetCardEffectType(ComVal.cardEffectType_normalLauch);
        e3.SetLauchArea(ComVal.Area_Monster);
        e3.SetCost(Cost);
        e3.SetCheckLauch(CheckLauch1);
        e3.SetOperation(Operation1);
        duel.ResignEffect(e3, card, player);
    }
예제 #23
0
    public void Operation(IDuel duel, Card card, LauchEffect effect, Group group = null)
    {
        Group a = duel.GetIncludeNameCardFromArea("", false, card.opponentPlayer, 0, ComVal.Area_Trap, filer, false, null, null);

        duel.AddFinishHandle();
        duel.SendToGraveyard(ComVal.Area_Trap, a, card, ComVal.reason_EffectDestroy, effect);
    }
예제 #24
0
    public bool CheckLauch(IDuel duel, Card card, LauchEffect effect, Code code)
    {
        int   num = duel.GetIncludeNameCardNumFromArea("", false, card.ownerPlayer, ComVal.cardType_Monster, ComVal.Area_Monster, fitler, false, null, null);
        Group g1  = duel.GetIncludeNameCardFromArea(ComStr.KeyWord_ElementalHERO, false, card.ownerPlayer, ComVal.cardType_Monster, ComVal.Area_MainDeck, fitler1, false, null, null);

        return(card.ownerPlayer.CanSpSummon(g1) && num == 0);
    }
예제 #25
0
    public void InitialEffect(Card card, Player player, IDuel duel)
    {
        card.SetXYZMaterialFiter(Filter, 2);

        LauchEffect e1 = new LauchEffect();

        e1.SetCost(Cost);
        e1.SetCategory(ComVal.category_drawCard | ComVal.category_disCard);
        e1.SetCheckLauch(CheckLauch);
        e1.SetCardEffectType(ComVal.cardEffectType_normalLauch);
        e1.SetCode(ComVal.code_NoCode);
        e1.SetLauchArea(ComVal.Area_Monster);
        e1.SetOperation(Operation);

        LauchEffect e2 = new LauchEffect();

        e2.SetCategory(ComVal.category_destroy | ComVal.category_disCard);
        e2.SetCheckLauch(CheckLauch1);
        e2.SetCardEffectType(ComVal.cardEffectType_mustToChooseLauch);
        e2.SetCode(ComVal.code_ToGraveyard);
        e2.SetLauchArea(ComVal.Area_Graveyard);
        e2.SetOperation(Operation1);

        duel.ResignEffect(e1, card, player);
        duel.ResignEffect(e2, card, player);
    }
예제 #26
0
    public void Cost(IDuel duel, Card card, LauchEffect effect)
    {
        Player player = card.ownerPlayer;

        duel.ReduceLP(player.LP / 2, player, ComVal.reason_Cost, card, effect);
        duel.FinishHandle();
    }
예제 #27
0
    public void InitialEffect(Card card, Player player, IDuel duel)
    {
        LauchEffect e1 = new LauchEffect();

        e1.SetCategory(ComVal.category_destroy);
        e1.SetCode(ComVal.code_NoCode);
        e1.SetCardEffectType(ComVal.cardEffectType_normalLauch);
        e1.SetLauchArea(ComVal.Area_Hand | ComVal.Area_Trap);
        e1.SetOperation(Operation);
        e1.SetCheckLauch(CheckLauch);
        e1.SetGetTarget(GetTarget);
        duel.ResignEffect(e1, card, player);

        LauchEffect e2 = new LauchEffect();

        e2.SetCategory(ComVal.category_destroy);
        e2.SetCode(ComVal.code_NoCode);
        e2.SetCardEffectType(ComVal.cardEffectType_normalLauch);
        e2.SetLauchArea(ComVal.Area_Graveyard);
        e2.SetOperation(Operation1);
        e2.SetCheckLauch(CheckLauch1);
        e2.SetGetTarget(GetTarget1);
        e2.SetCost(Cost);
        e2.SetEffectID("05133471");
        duel.ResignEffect(e2, card, player);

        duel.ResignEffectLauchLimitCounter(player, "05133471", 1);
    }
예제 #28
0
 public void AddLauchCount(LauchEffect e)
 {
     if (list.Contains(e))
     {
         lauchCount++;
     }
 }
예제 #29
0
    public void InitialEffect(Card card, Player player, IDuel duel)
    {
        LauchEffect e1 = new LauchEffect();

        e1.SetCardEffectType(ComVal.cardEffectType_normalLauch);
        e1.SetCode(ComVal.code_NoCode);
        e1.SetLauchArea(ComVal.Area_Hand);
        e1.SetOperation(Operation);
        e1.SetCheckLauch(CheckLauch);
        duel.ResignEffect(e1, card, player);

        LauchEffect e2 = new LauchEffect();

        e2.SetCardEffectType(ComVal.cardEffectType_normalLauch);
        e2.SetCode(ComVal.code_NoCode);
        e2.SetLauchArea(ComVal.Area_FieldSpell);
        e2.SetOperation(Operation1);
        e2.SetCheckLauch(CheckLauch1);
        e2.SetCost(Cost);
        e2.SetDescribe("从卡组把1只4星以下的名字带有「龙骑兵团」的怪兽加入手卡");
        duel.ResignEffect(e2, card, player);

        LauchEffect e3 = new LauchEffect();

        e3.SetCardEffectType(ComVal.cardEffectType_normalLauch);
        e3.SetCode(ComVal.code_NoCode);
        e3.SetLauchArea(ComVal.Area_FieldSpell);
        e3.SetOperation(Operation2);
        e3.SetCheckLauch(CheckLauch2);
        e3.SetCost(Cost);
        e3.SetDescribe("从卡组把1只龙族怪兽送去墓地");
        duel.ResignEffect(e3, card, player);

        card.SetCardCountLimit(e2, e3, 1);
    }
예제 #30
0
    /// <summary>
    /// 生成效果
    /// </summary>
    public void InitialEffect(Card card, Player player, IDuel duel)
    {
        //检索
        LauchEffect e1 = new LauchEffect();

        e1.SetCategory(ComVal.category_search);
        e1.SetCardEffectType(ComVal.cardEffectType_chooseLauch);
        e1.SetCheckLauch(CheckLauch);
        e1.SetCode(ComVal.code_NormalSummon | ComVal.code_SpecialSummon);
        e1.SetOperation(Operation);
        e1.SetDescribe(ComStr.EffectDescribe_40044918_2);
        e1.SetLauchArea(ComVal.Area_Monster);
        e1.SetGetTarget(GetTarget);
        duel.ResignEffect(e1, card, card.ownerPlayer);

        //破坏后场
        LauchEffect e2 = new LauchEffect();

        e2.SetCategory(ComVal.category_destroy);
        e2.SetCardEffectType(ComVal.cardEffectType_chooseLauch);
        e2.SetCheckLauch(CheckLauch1);
        e2.SetCode(ComVal.code_NormalSummon | ComVal.code_SpecialSummon);
        e2.SetOperation(Operation1);
        e2.SetDescribe(ComStr.EffectDescribe_40044918_1);
        e2.SetLauchArea(ComVal.Area_Monster);
        e2.SetGetTarget(GetTarget1);
        duel.ResignEffect(e2, card, card.ownerPlayer);
    }