C# Card.GetType方法代码示例

    public bool canPlayCard(Card card)
    {
        Debug.Log(card.manaCost[1]);
        if (!payMana(card.manaCost))
            return false;

        if (card.GetType() == typeof(UnitCard))
            return (cardsOfType(card) < Math.Max(memory / 2, 1));
        else if (card.GetType() == typeof(SpellCard))
            return (cardsOfType(card) < Math.Max(impulse / 3, 1));
        else if (card.GetType() == typeof(CrystalCard))
        {
            if (crystals.Count < impulse)
                return (cardsOfType(card) < Math.Max(memory, 1));
        }
        //Equipments
        else
            return (cardsOfType(card) < Math.Max(memory / 2, 1));
        return false;
    }

 public override Unit PlayCardOnHex(Card card, Hex hex, string id)
 {
     CardHistory.Add(card);
     GuiControl.AddCardToHistory(card);
     // TODO Clean up this method to better handle multiple card types.
     if(typeof(EntityCard).IsAssignableFrom(card.GetType())) {
         EntityCard eCard = (EntityCard) card;
         GameObject go = (GameObject) Instantiate(UnitPrefab, Vector3.zero, Quaternion.identity);
         Unit unit = go.GetComponent<Unit>();
         unit.Id = id;
         unit.FromCard(eCard);
         unit.Hex = hex;
         unit.transform.position = hex.transform.position;
         hex.Unit = unit;
         Units.Add(unit);
         unit.Team = MyTurn() ? Team.ME : Team.ENEMY;
         if(MyTurn() && ThisPlayer.Hand.Count != 0) {
             // TODO Find a better way to sort this
             ThisPlayer.PlayCard();
         }
         card.OnPlay(new StateObject(Units, hex, null, MyTurn() ? ThisPlayer : EnemyPlayer, MyTurn() ? EnemyPlayer : ThisPlayer));
         return unit;
     } else {
         if(MyTurn() && ThisPlayer.Hand.Count != 0) {
             // TODO Find a better way to sort this
             ThisPlayer.PlayCard();
         }
         card.OnPlay(new StateObject(Units, hex, null, MyTurn() ? ThisPlayer : EnemyPlayer, MyTurn() ? EnemyPlayer : ThisPlayer));
         return null;
     }
 }

 int ValuateCard(Card card)
 {
     int v = 0;
     if(typeof(UnitCard).IsAssignableFrom(card.GetType())) {
         v = UnitCardValue((UnitCard) card);
     } else if(typeof(BuildingCard).IsAssignableFrom(card.GetType())) {
         // TODO Find a better way of calculating buildingvalues
         v = UnitCardValue((BuildingCard) card);
     } else if(typeof(SpellCard).IsAssignableFrom(card.GetType())) {
         SpellCard sCard = (SpellCard) card;
         player.SetTargetsForCard(card);
         foreach(Hex hex in player.targets) {
             int k = SpellOnHexValue(sCard, hex);
             v = k > v ? k : v;
         }
         player.targets = new List<Hex>();
     }
     return v;
 }

    bool PlayCard(Card card)
    {
        // TODO When adding different card types, improve this.
        // Choose a card
        if(card == null) { return false; }
        if(typeof(SpellCard).IsAssignableFrom(card.GetType())) { return PlaySpellCard((SpellCard) card); }

        // Choose a tile
        Hex targetHex = null;

        player.SetTargetsForCard(card);
        if(player.targets.Count > 1) {
            targetHex = player.targets[Random.Range(0, player.targets.Count-1)];
        } else if(player.targets.Count == 1) {
            targetHex = player.targets[0];
        } else {
            return false;
        }
        // Play card
        gameControl.EnemyCardPlayed(card);
        Unit unit = gameControl.PlayCardOnHex(card, targetHex, System.Guid.NewGuid().ToString());
        player.SpendMana(card.Cost);
        player.Hand.Remove(card);
        unitMoves[unit] = StandardList();
        unitBlacklist[unit] = new List<Hex>();
        return true;
    }

 private int cardsOfType(Card card)
 {
     int n = 0;
     Debug.Log("Card played is " + card.GetType().ToString());
     foreach (Card x in cardsPlayed)
     {
         Debug.Log("Card already played is " + x.GetType().ToString());
         if (x.GetType() == card.GetType())
             n++;
     }
         
     return n;
 }

 int ValuateCard(Card card)
 {
     int v = int.MinValue;
     if(typeof(EntityCard).IsAssignableFrom(card.GetType())) {
         v = EntityCardValue((EntityCard) card);
     } else if(typeof(SpellCard).IsAssignableFrom(card.GetType())) {
         SpellCard sCard = (SpellCard) card;
         if(!sCard.IsTargetless) {
             player.SetTargetsForCard(card);
             foreach(Hex hex in player.targets) {
                 int k = SpellOnHexValue(sCard, hex);
                 v = Mathf.Max (k, v);
             }
             player.targets = new List<Hex>();
         } else {
             v = sCard.TargetlessMockOnPlay();
         }
     }
     return v;
 }

 bool PlayCard(Card card)
 {
     if(card == null) { return false; }
     if(typeof(SpellCard).IsAssignableFrom(card.GetType())) { return PlaySpellCard((SpellCard) card); }
     if(typeof(EntityCard).IsAssignableFrom(card.GetType())) { return PlayEntityCard((EntityCard) card); }
     return false;
 }