Esempio n. 1
0
 public void CheckReset(int eventCode)
 {
     if (ComVal.isBind(ComVal.resetEvent_Phase, eventCode))
     {
         if (resetCode <= eventCode)
         {
             int val = startRoundCount + resetRoundCount;
             if (val == duel.roundCount)
             {
                 isDisable = true;
             }
             //else if (duel.roundCount > val)
             //{
             //    Debug.Log(ownerCard.cardID);
             //    Debug.Log("error");
             //}
         }
     }
     else
     {
         if (resetCode == eventCode)
         {
             int val = startRoundCount + resetRoundCount;
             if (val == duel.roundCount)
             {
                 isDisable = true;
             }
             //else if (val > duel.roundCount)
             //{
             //    Debug.Log("error");
             //}
         }
     }
 }
Esempio n. 2
0
    public bool isFit(Card card)
    {
        bool result = false;

        switch (attribute)
        {
        case ComVal.fiter_containName:
            result = card.ContainName((string)val);
            break;

        case ComVal.fiter_isAttribute:
            result = ComVal.isBind((int)val, card.GetCurAttribute());
            break;

        case ComVal.fiter_isLevel:
            result = card.level == (int)val;
            break;

        case ComVal.fiter_isCardType:
            result = ComVal.isBind((int)val, card.cardType);
            break;

        case ComVal.fiter_isArea:
            result = ComVal.isBind((int)val, card.curArea);
            break;
        }
        return(result);
    }
Esempio n. 3
0
    /// <summary>
    /// 移除不确定卡片时,需要填写area参数
    /// </summary>
    /// <param name="card"></param>
    /// <param name="player"></param>
    /// <param name="area"></param>
    /// <param name="duel"></param>
    /// <returns></returns>
    public static Card RemoveCardFromArea(Card card, Player player, int area)
    {
        int curArea = card.curArea;

        if (curArea.IsBind(ComVal.Area_Field))//场地
        {
            RemoveCardFromField(card, player);
            return(card);
        }
        else if (ComVal.isBind(curArea, ComVal.Area_Hand))//手牌
        {
            RemoveCardFromHand(card, player);
            return(card);
        }
        else
        {
            if (area != 0)
            {
                return(RemoveCardFromDeck(area, card, player));
            }
            else
            {
                return(RemoveCardFromDeck(curArea, card, player));
            }
        }
    }
Esempio n. 4
0
    public void OnFindButtonClick()
    {
        string keyWord  = keyWordInputField.text;
        int    cardType = StaticMethod.ChangeCardType(cardTypeDropdown.captionText.text);
        int    cardRace = StaticMethod.ChangeCardRace(cardRaceDropdown.captionText.text);
        int    cardAttr = StaticMethod.ChangeCardAttr(cardAttrDropdown.captionText.text);

        string str       = cardLevelDropdown.captionText.text;
        int    cardLevel = 0;

        if (str != "N/A")
        {
            str = str.Replace("星", "");

            cardLevel = int.Parse(str);
        }
        if (!ComVal.isMonster(cardType))
        {
            if (cardRace != 0 || cardAttr != 0 || cardLevel != 0)
            {
                return;
            }
        }
        editUI.FindCard(cardType, cardAttr, cardRace, cardLevel, keyWord);
    }
Esempio n. 5
0
 /// <summary>
 /// 是否可以发动效果
 /// </summary>
 /// <param name="_code"></param>
 /// <returns></returns>
 public bool CanBeLaunch(Code _code)
 {
     if (!ownerCard.CanLauchEffect(this) || !ownerCard.controller.CanLauchEffect(this))
     {
         return(false);
     }
     if (ownerCard.IsMonster() && ownerCard.IsInField())
     {
         if (!ownerCard.IsFaceUp())
         {
             return(false);
         }
     }
     if (lauchArea != 0)
     {
         if (!ComVal.isBind(ownerCard.curArea, lauchArea))
         {
             return(false);
         }
     }
     if (!ComVal.isBind(_code.code, code))
     {
         return(false);
     }
     if (lauchPhase != 0)
     {
         if (!ComVal.isBind(duel.currentPhase, lauchPhase))
         {
             return(false);
         }
     }
     return(checkLauch(duel, ownerCard, this, _code));
 }
Esempio n. 6
0
 /// <summary>
 /// 由外部调用
 /// </summary>
 /// <param name="i"></param>
 public void ChangeToPhase(int i)
 {
     currentPhase = buttonList[ComVal.ChangePhaseToVal(i) - 1];
     foreach (var item in buttonList)
     {
         item.ChangeToNormalColor();
     }
     currentPhase.ChangeTextColor();
     SetCanControl();
 }
Esempio n. 7
0
 public bool isSpell()
 {
     if (ComVal.isBind(cardType, ComVal.cardType_Spell))
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
Esempio n. 8
0
 public bool IsTrap()
 {
     if (ComVal.isBind(cardType, ComVal.cardType_Trap))
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
Esempio n. 9
0
 public bool IsMonster()
 {
     if (ComVal.isBind(cardType, ComVal.cardType_Monster))
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
Esempio n. 10
0
 /// <summary>
 /// 是否在手牌或场地上
 /// </summary>
 /// <returns></returns>
 public bool IsHandAndField()
 {
     for (int i = 0; i < cardList.Count; i++)
     {
         if (!ComVal.isBind(cardList[i].curArea, ComVal.Area_Hand | ComVal.Area_Monster | ComVal.Area_Trap))
         {
             return(false);
         }
     }
     return(true);
 }
Esempio n. 11
0
    /// <summary>
    /// 筛选出符合种族的怪兽卡片
    /// </summary>
    /// <param name="ff"></param>
    public Group SiftingGroupInRace(int race)
    {
        Group a = new Group();

        for (int i = 0; i < cardList.Count; i++)
        {
            if (ComVal.isBind(cardList[i].race, race))
            {
                a.AddCard(cardList[i]);
            }
        }
        return(a);
    }
Esempio n. 12
0
    public Group SiftingGroupInArea(int area)
    {
        Group a = new Group();

        foreach (var item in cardList)
        {
            if (ComVal.isBind(item.curArea, area))
            {
                a.AddCard(item);
            }
        }
        return(a);
    }
Esempio n. 13
0
    /// <summary>
    /// 筛选出符合属性的怪兽卡片
    /// </summary>
    /// <param name="attr"></param>
    /// <returns></returns>
    public Group SiftingGroupInAttr(int attr)
    {
        Group a = new Group();

        foreach (var item in cardList)
        {
            if (ComVal.isBind(item.GetCurAttribute(), attr))
            {
                a.AddCard(item);
            }
        }
        return(a);
    }
Esempio n. 14
0
    public Group GetAreaGroup(int area)
    {
        Group g = new Group();

        for (int i = 0; i < cardList.Count; i++)
        {
            Card card = cardList[i];
            if (ComVal.isBind(area, card.curArea))
            {
                g.AddCard(card);
            }
        }
        return(g);
    }
Esempio n. 15
0
    public int GetAreaNum(int area)
    {
        int a = 0;

        for (int i = 0; i < cardList.Count; i++)
        {
            Card card = cardList[i];
            if (ComVal.isBind(area, card.curArea))
            {
                a++;
            }
        }
        return(a);
    }
Esempio n. 16
0
    public bool CanLauchTriggerEffect(Code code, Chain chain, bool isDelayode, bool isNotInChain = false)
    {
        int effectType;

        effectType = ComVal.cardEffectType_triggerEffect;
        if (IsHideInTrapArea())
        {
            if (cardSetRound == 0)
            {
                return(false);
            }
        }
        if (isSpell() && curArea == ComVal.Area_Hand)
        {
            if (duel.curPlayer != ownerPlayer)
            {
                return(false);
            }
        }
        if (IsTrap() && curArea == ComVal.Area_Hand)
        {
            return(false);
        }
        foreach (var item in lauchEffectList)
        {
            if (isDelayode)
            {
                if ((ComVal.isBind(item.code, chain.codeVal) && item.IsBindCardEffectType(ComVal.cardEffectType_chooseLauch)))
                {
                    continue;
                }
            }
            if (ComVal.isBind(code.code, item.code))
            {
                if (item.cardEffectType.IsBind(ComVal.cardEffectType_notInChain))
                {
                    if (!isNotInChain)
                    {
                        return(false);
                    }
                }
                if (item.CanBeLaunch(code) && !chain.ContainEffect(item.code, this, item) && item.IsBindCardEffectType(effectType))
                {
                    return(true);
                }
            }
        }
        return(false);
    }
Esempio n. 17
0
    /// <summary>
    /// 对墓地 除外 主卡组 额外卡组移除卡片
    /// <para>如果card为空,则返回主卡组的第一张卡 用于抽卡</para>
    /// </summary>
    /// <param name="card"></param>
    static Card RemoveCardFromDeck(int area, Card card, Player player)
    {
        Card result = Card.Empty();

        switch (area)
        {
        case ComVal.Area_MainDeck:
            if (!Card.IsEmpty(card))
            {
                player.group_MainDeck.RemoveCard(card);
            }
            else
            {
                result = player.group_MainDeck.RemoveFirstCard();
            }
            break;

        case ComVal.Area_Extra:
            player.group_ExtraDeck.RemoveCard(card);
            break;

        case ComVal.Area_Graveyard:
            player.group_Graveyard.RemoveCard(card.areaRank);
            break;

        case ComVal.Area_Remove:
            player.group_Remove.RemoveCard(card.areaRank);
            break;

        default:
            break;
        }
        if (ComVal.isBind(area, ComVal.Area_MainDeck) || ComVal.isBind(area, ComVal.Area_Extra))
        {
            DuelUIManager.GetInstance().RemoveCardFromDeck(area, Card.Empty(), 1, player.isMy);
        }
        else
        {
            DuelUIManager.GetInstance().RemoveCardFromDeck(area, card, 1, player.isMy);
        }
        //if (area == ComVal.Area_MainDeck)
        //{
        //    Duel.GetInstance().ShuffleDeck(player);
        //}

        return(result);
    }
Esempio n. 18
0
    /// <summary>
    /// 获取可以发动的效果
    /// <para>不存在于连锁之中</para>
    /// </summary>
    /// <returns></returns>
    public List <LauchEffect> GetCanLauchEffectList(Code code, Chain chain)
    {
        List <LauchEffect> list = new List <LauchEffect>();

        foreach (var item in lauchEffectList)
        {
            if (chain.isDelayCode)
            {
                if ((ComVal.isBind(item.code, chain.codeVal) && item.IsBindCardEffectType(ComVal.cardEffectType_chooseLauch)))
                {
                    continue;
                }
            }
            if (item.CanBeLaunch(code) && !chain.ContainEffect(item.code, this, item))
            {
                list.Add(item);
            }
        }
        return(list);
    }
Esempio n. 19
0
    public static List <Card> GetCardListFromPlayer(int area, Player player)
    {
        List <Card> list = new List <Card>();

        if (ComVal.isBind(ComVal.Area_Graveyard, area))
        {
            list.AddRange(player.group_Graveyard.cardList);
        }
        if (ComVal.isBind(ComVal.Area_Extra, area))
        {
            list.AddRange(player.group_ExtraDeck.cardList);
        }
        if (ComVal.isBind(ComVal.Area_Hand, area))
        {
            list.AddRange(player.group_HandCard.cardList);
        }
        if (ComVal.isBind(ComVal.Area_Remove, area))
        {
            list.AddRange(player.group_Remove.cardList);
        }
        if (ComVal.isBind(ComVal.Area_MainDeck, area))
        {
            list.AddRange(player.group_MainDeck.cardList);
        }
        if (ComVal.isBind(ComVal.Area_Monster, area))
        {
            list.AddRange(player.group_MonsterCard.GetCardList());
        }
        if (ComVal.isBind(ComVal.Area_NormalTrap, area))
        {
            list.AddRange(player.group_TrapCard.GetCardList());
        }
        if (area.IsBind(ComVal.Area_FieldSpell))
        {
            if (player.fieldSpell != null)
            {
                list.Add(player.fieldSpell);
            }
        }
        return(list);
    }
Esempio n. 20
0
    /// <summary>
    /// 生成卡片信息
    /// </summary>
    public void Init(bool _isMy)
    {
        if (IsMonster())
        {
            curAfk           = afk;
            curDef           = def;
            curLevel         = level;
            curAttribute     = attribute;
            cardAttackedTime = 0;
        }
        isMy = _isMy;
        duel = Duel.GetInstance();

        if (ComVal.isInExtra(cardType))
        {
            curArea = ComVal.Area_Extra;
        }
        else
        {
            curArea = ComVal.Area_MainDeck;
        }
    }
Esempio n. 21
0
    private Group GettargetGroup(IDuel duel, Card card)
    {
        Group g  = duel.GetIncludeNameCardFromArea(ComStr.KeyWord_Hero, false, card.ownerPlayer, ComVal.cardType_Monster, ComVal.Area_Monster, filter, false, null, null);
        Group g1 = duel.GetIncludeNameCardFromArea(ComStr.KeyWord_MaskHERO, false, card.ownerPlayer, ComVal.CardType_Monster_Fusion, ComVal.Area_Extra);

        g1 = card.ownerPlayer.GetCanSpSummonGroup(g1);
        Group g2  = new Group();
        int   val = 0;

        foreach (var item in g1.cardList)
        {
            val = ComVal.Add(item.GetCurAttribute(), val);
        }
        foreach (var item in g.cardList)
        {
            if (ComVal.isBind(item.GetCurAttribute(), val))
            {
                g2.AddCard(item);
            }
        }
        return(g2);
    }
Esempio n. 22
0
 public void RoundEndReset()
 {
     foreach (var item in effectLauchCountLimitList)
     {
         item.ResetLauchCount();
     }
     stayturn++;
     if (ComVal.isBind(curArea, ComVal.Area_Field))
     {
         cardSetRound++;
     }
     else
     {
         cardSetRound = 0;
     }
     if (IsMonster())
     {
         cardChangeTypeTime   = 1;
         cardChangeTypeedTime = 0;
         cardAttackedTime     = 0;
         cardAttackedTime     = 0;
     }
 }
Esempio n. 23
0
    /// <summary>
    /// 只要有一个效果可以发动 返回真
    /// <para>且不存在于连锁当中</para>
    /// </summary>
    /// <param name="code"></param>
    /// <returns></returns>
    private bool MCanLauchEffect(Code code, Chain chain, int cardEffectType)
    {
        if (IsTrap())
        {
            if (curArea == ComVal.Area_NormalTrap && curPlaseState == ComVal.CardPutType_UpRightBack)
            {
                if (cardSetRound == 0)
                {
                    return(false);
                }
            }
        }
        else if (isSpell())
        {
            if (curArea == ComVal.Area_NormalTrap && curPlaseState == ComVal.CardPutType_UpRightBack && cardType == ComVal.CardType_Spell_Quick)
            {
                if (cardSetRound == 0)
                {
                    return(false);
                }
            }
        }
        int effectType = cardEffectType;

        foreach (var item in lauchEffectList)
        {
            if (ComVal.isBind(code.code, item.code))
            {
                if (item.CanBeLaunch(code) && item.IsBindCardEffectType(effectType))
                {
                    return(true);
                }
            }
        }
        return(false);
    }
Esempio n. 24
0
 bool filter(Card card)
 {
     return(ComVal.isBind(ComVal.CardRace_Warrior, card.race));
 }
Esempio n. 25
0
    /// <summary>
    /// 排序
    /// </summary>
    /// <param name="list"></param>
    /// <returns></returns>
    public static List <Card> SortCardList(List <Card> list)
    {
        List <Card> normalMonsterList  = new List <Card>();
        List <Card> monsterList        = new List <Card>();
        List <Card> spellList          = new List <Card>();
        List <Card> trapList           = new List <Card>();
        List <Card> xyzMonsterList     = new List <Card>();
        List <Card> fusionMonsterList  = new List <Card>();
        List <Card> synchroMonsterList = new List <Card>();

        List <Card> resultList = new List <Card>();

        for (int i = 0; i < list.Count; i++)
        {
            Card card = list[i];
            if (card.IsMonster())
            {
                if (!ComVal.isInExtra(card.cardType) && card.cardType != ComVal.CardType_Monster_Normal)
                {
                    bool isInsert = false;
                    for (int j = 0; j < monsterList.Count; j++)//有同名则插入其后面
                    {
                        if (card.cardID == monsterList[j].cardID)
                        {
                            monsterList.Insert(j, card);
                            isInsert = true;
                            break;
                        }
                    }
                    if (!isInsert)
                    {
                        for (int x = 0; x < monsterList.Count; x++)
                        {
                            if (card.level < monsterList[x].level)
                            {
                                monsterList.Insert(x, card);
                                isInsert = true;
                                break;
                            }
                        }
                    }
                    if (!isInsert)
                    {
                        monsterList.Add(card);
                    }
                }
                else if (card.cardType == ComVal.CardType_Monster_Normal)
                {
                    bool isInsert = false;
                    for (int j = 0; j < normalMonsterList.Count; j++)//有同名则插入其后面
                    {
                        if (card.cardID == normalMonsterList[j].cardID)
                        {
                            normalMonsterList.Insert(j, card);
                            isInsert = true;
                            break;
                        }
                    }
                    if (!isInsert)
                    {
                        for (int x = 0; x < normalMonsterList.Count; x++)
                        {
                            if (card.level < normalMonsterList[x].level)
                            {
                                normalMonsterList.Insert(x, card);
                                isInsert = true;
                                break;
                            }
                        }
                    }
                    if (!isInsert)
                    {
                        normalMonsterList.Add(card);
                    }
                }
                else if (card.cardType == ComVal.CardType_Monster_Fusion)
                {
                    bool isInsert = false;
                    for (int j = 0; j < fusionMonsterList.Count; j++)//有同名则插入其后面
                    {
                        if (card.cardID == fusionMonsterList[j].cardID)
                        {
                            fusionMonsterList.Insert(j, card);
                            isInsert = true;
                            break;
                        }
                    }
                    if (!isInsert)
                    {
                        for (int x = 0; x < fusionMonsterList.Count; x++)
                        {
                            if (card.level < fusionMonsterList[x].level)
                            {
                                fusionMonsterList.Insert(x, card);
                                isInsert = true;
                                break;
                            }
                        }
                    }
                    if (!isInsert)
                    {
                        fusionMonsterList.Add(card);
                    }
                }
                else if (card.cardType == ComVal.CardType_Monster_Synchro)
                {
                    bool isInsert = false;
                    for (int j = 0; j < synchroMonsterList.Count; j++)//有同名则插入其后面
                    {
                        if (card.cardID == synchroMonsterList[j].cardID)
                        {
                            synchroMonsterList.Insert(j, card);
                            isInsert = true;
                            break;
                        }
                    }
                    if (!isInsert)
                    {
                        for (int x = 0; x < synchroMonsterList.Count; x++)
                        {
                            if (card.level < synchroMonsterList[x].level)
                            {
                                synchroMonsterList.Insert(x, card);
                                isInsert = true;
                                break;
                            }
                        }
                    }
                    if (!isInsert)
                    {
                        synchroMonsterList.Add(card);
                    }
                }
                else if (card.cardType == ComVal.CardType_Monster_XYZ)
                {
                    bool isInsert = false;
                    for (int j = 0; j < xyzMonsterList.Count; j++)//有同名则插入其后面
                    {
                        if (card.cardID == xyzMonsterList[j].cardID)
                        {
                            xyzMonsterList.Insert(j, card);
                            isInsert = true;
                            break;
                        }
                    }
                    if (!isInsert)
                    {
                        for (int x = 0; x < xyzMonsterList.Count; x++)
                        {
                            if (card.level < xyzMonsterList[x].level)
                            {
                                xyzMonsterList.Insert(x, card);
                                isInsert = true;
                                break;
                            }
                        }
                    }
                    if (!isInsert)
                    {
                        xyzMonsterList.Add(card);
                    }
                }
            }
            else if (card.isSpell())
            {
                bool isInsert = false;
                for (int j = 0; j < spellList.Count; j++)//有同名则插入其后面
                {
                    if (card.cardID == spellList[j].cardID)
                    {
                        spellList.Insert(j, card);
                        isInsert = true;
                        break;
                    }
                }
                if (!isInsert)
                {
                    spellList.Add(card);
                }
            }
            else if (card.IsTrap())
            {
                bool isInsert = false;
                for (int j = 0; j < trapList.Count; j++)//有同名则插入其后面
                {
                    if (card.cardID == trapList[j].cardID)
                    {
                        trapList.Insert(j, card);
                        isInsert = true;
                        break;
                    }
                }
                if (!isInsert)
                {
                    trapList.Add(card);
                }
            }
        }
        resultList.AddRange(normalMonsterList);
        resultList.AddRange(monsterList);
        resultList.AddRange(fusionMonsterList);
        resultList.AddRange(synchroMonsterList);
        resultList.AddRange(xyzMonsterList);
        resultList.AddRange(spellList);
        resultList.AddRange(trapList);
        return(resultList);
    }
Esempio n. 26
0
    /// <summary>
    /// 增加卡片
    /// </summary>
    /// <param name="isMain">是否为主卡组</param>
    /// <param name="id">卡片id</param>
    public void AddCardToDeck(string id)
    {
        Card card   = LoadXml.GetCard(id);
        bool isMain = !ComVal.isInExtra(card.cardType);

        int cardNum = 0;

        if (isMain)
        {
            foreach (var item in curDeck.mainDeck.cardList)
            {
                if (item.cardID == card.cardID)
                {
                    cardNum++;
                }
            }
        }
        else
        {
            foreach (var item in curDeck.extraDeck.cardList)
            {
                if (item.cardID == card.cardID)
                {
                    cardNum++;
                }
            }
        }
        if (cardNum >= 3)
        {
            return;
        }
        if (isMain)
        {
            if (curCard != null)
            {
                int val = GetObjVal(curCard.gameObject, isMain);
                AddToDeckFromPool(card, mainDeckGroup.transform, true);
                curDeck.mainDeck.InsertCard(card, val);
                for (int i = val; i < curDeck.mainDeck.GroupNum; i++)
                {
                    mainDeckList[i].GetComponent <Card_Edit>().SetTexture(curDeck.mainDeck.GetCard(i).cardID, true);
                }
                UpdateText();
                return;
            }
            if (mainDeckList.Count > curDeck.mainDeck.cardList.Count)
            {
                Card_Edit theCard_edit = mainDeckList[curDeck.mainDeck.cardList.Count].GetComponent <Card_Edit>();
                theCard_edit.SetTexture(card.cardID, true);
                theCard_edit.SetActive(true);
            }
            else if (mainDeckList.Count == curDeck.mainDeck.cardList.Count)
            {
                AddToDeckFromPool(card, mainDeckGroup.transform, true);
            }
            else
            {
                Debug.Log("error");
            }

            curDeck.mainDeck.AddCard(card);
        }
        else
        {
            if (curCard != null)
            {
                int val = GetObjVal(curCard.gameObject, isMain);
                AddToDeckFromPool(card, extraDeckGroup.transform, false);
                curDeck.extraDeck.InsertCard(card, val);
                for (int i = val; i < curDeck.extraDeck.GroupNum; i++)
                {
                    extraDeckList[i].GetComponent <Card_Edit>().SetTexture(curDeck.extraDeck.GetCard(i).cardID, true);
                }
                UpdateText();
                return;
            }
            if (extraDeckList.Count > curDeck.extraDeck.cardList.Count)
            {
                Card_Edit theCard_edit = extraDeckList[curDeck.extraDeck.cardList.Count].GetComponent <Card_Edit>();
                theCard_edit.SetTexture(card.cardID, true);
                theCard_edit.SetActive(true);
            }
            else if (extraDeckList.Count == curDeck.extraDeck.cardList.Count)
            {
                AddToDeckFromPool(card, extraDeckGroup.transform, false);
            }
            else
            {
                Debug.Log("error");
            }
            curDeck.extraDeck.AddCard(card);
        }
        UpdateText();
    }