public Card(CardColor color, Shape shape, Fill fill, int count)
        {
            #region validation
            if (color == CardColor.Other)
            {
                throw new InvalidCardException("color", color);
            }
            if (shape == Shape.Other)
            {
                throw new InvalidCardException("shape", shape);
            }
            if (fill == Fill.Other)
            {
                throw new InvalidCardException("fill", fill);
            }
            if (count > 3 || count < 1)
            {
                throw new InvalidCardException("count", count);
            }
            #endregion validation

            this.Color = color;
            this.Shape = shape;
            this.Fill = fill;
            this.Count = count;
        }

        public GameResultCard(CardColor color, CardPosition position)
        {
            this.color = color;
            this.position = position;

            this.Init();
        }

        //bool selected = false;
        public Card(ContentManager cm, float scale, Point pos, CardColor cardColor, int cardID)
        {
            //Load content
            backOfCard = cm.Load<Texture2D>("backofcard");
            frameSheet = cm.Load<Texture2D>("frameSheet");
            numberSheet = cm.Load<Texture2D>("numbers");

            this.scale = scale;
            hexWidth = (int)(backOfCard.Width);
            hexHeight = (int)(backOfCard.Height);
            radius = hexWidth / 2 * scale;

            //Assign Numbers
            this.cardColor = cardColor;
            Tuple<byte, byte, byte> cardNumbers = CardNumbers(cardID);
            TopNumber = cardNumbers.Item1;
            LeftNumber = cardNumbers.Item2;
            RightNumber = cardNumbers.Item3;

            //Position Card Elements
            drawRectangle = new Rectangle(0, 0, (int)(hexWidth * scale), (int)(hexHeight * scale));
            drawRectangle.Location = pos;
            frameRectangle = new Rectangle((int)cardColor * hexWidth, 0, hexWidth, hexHeight);

            //This just defines the size of the draw rectangle for the numbers
            topNumSource = new Rectangle(TopNumber * 18, 0, 18, 22);
            leftNumSource = new Rectangle(LeftNumber * 18, 0, 18, 22);
            rightNumSource = new Rectangle(RightNumber * 18, 0, 18, 22);
        }

        ///////////////////////////////////////////////////////////////////////////////////////
        // Constructors
        ///////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Construct a new card
        /// </summary>
        /// <param name="theColor"></param>
        /// <param name="theFace"></param>
        public Card(CardColor theColor, CardFace theFace)
        {
            // Check the card is value, otherwise throw a runtime error
            if (!IsValidCard(theColor, theFace))
                throw new Exception(CardColorToString(theColor) + " " + CardFaceToString(theFace) + " is not a valid Uno card");

            // Save parameters in private attributes
            color = theColor;
            face = theFace;
        }

        protected static int GetColorRank(CardColor cardColor, ColorScore[] scores)
        {
            var i = 1;
              foreach (var colorScore in scores.OrderByDescending(x => x.Score))
              {
            if (cardColor == colorScore.Color)
              return i;
              }

              return scores.Length;
        }

        public CardViewModel(Card card)
        {
            Card = card;
              Colors = new CardColor[] {};

              Update();

              _timer = new Timer(delegate { Update(); }, null,
            TimeSpan.FromMilliseconds(20),
            TimeSpan.FromMilliseconds(20));
        }

        public List<Card> GenerateCards()
        {
            List<Card> cards = new List<Card>();
            CardColor[] validColors = new CardColor[] { CardColor.Green, CardColor.Purple, CardColor.Red };
            Fill[] validFills = new Fill[] { Fill.Dashed, Fill.Open, Fill.Solid };
            Shape[] validShapes = new Shape[] { Shape.Diamond, Shape.Oval, Shape.Squiggle };
            int[] validCounts = new int[] { 1, 2, 3 };

            foreach (CardColor color in validColors)
            {
                foreach (Fill fill in validFills)
                {
                    foreach (Shape shape in validShapes)
                    {
                        foreach(int i in validCounts)
                        {
                            cards.Add(new Card(color, shape, fill, i));
                        }
                    }
                }
            }

            return cards;
        }

		}// AddCard



		protected CardView AddCardView(int player, CardColor col, int value){
			CardView cv = null;

			// Try to find a free one.
			for (int i = 0; cv == null && i < _cardViewsPerPlayer [player].Count; i++) {
				if (!_cardViewsPerPlayer [player] [i].gameObject.activeSelf)
					cv = _cardViewsPerPlayer [player] [i];
			}// for

			if (cv != null) {
				cv.SetCardColor (col);
				cv.SetCardNumber (value);
				cv.gameObject.SetActive (true);
			} else {
				cv = SpawnCard (
					col,
					value
				);

				int count = _cardViewsPerPlayer [player].Count;
				int row = Mathf.FloorToInt (((float)count) / ((float)CardsMaxPerRow));
				cv.transform.position =
					//ParentPlayerHands[p].transform.position +
					new Vector3 ((count % CardsMaxPerRow) * CardPlayerHandOffset.x, CardPlayerHandOffset.y, row * CardPlayerHandOffset.z);
				cv.transform.rotation = Quaternion.Euler (CardPlayerHandRotation);// + ParentPlayerHands[p].transform.rotation.eulerAngles);
				cv.transform.SetParent (ParentPlayerHands [player].transform, false);

				cv.gameObject.name = "CardPlayer_" + player + "_" + count;

				_cardViewsPerPlayer [player].Add (cv);
			}// fi

			return cv;
		}// AddCardView

		}// AbortMatch


		#endregion match management




		#region view management

		protected CardView SpawnCard(CardColor color, int value){

			GameObject card = GameObject.Instantiate (PrefabCard);
			CardView view = card.GetComponent<CardView> ();
			view.SetCardColor (color);
			view.SetCardNumber (value);

			return view;
		}// SpawnCard

        private Card GetCurrentMaxCardInColor( CardColor color )
        {
            Card maxCard = null;
            CardComparer comparer = new CardComparer( _playingManager.CurrentAnnouncement.Type );

            foreach ( Card card in _playingManager.RemainingCards )
            {
                if ( card.CardColor == color )
                {
                    if ( maxCard == null )
                    {
                        maxCard = card;
                    }

                    if ( comparer.Compare( maxCard, card ) < 0 )
                    {
                        maxCard = card;
                    }
                }
            }

            foreach ( Card card in _playingManager.CurrentHand )
            {
                if ( card.CardColor == color )
                {
                    if ( maxCard == null )
                    {
                        maxCard = card;
                    }

                    if ( comparer.Compare( maxCard, card ) < 0 )
                    {
                        maxCard = card;
                    }
                }
            }

            return maxCard;
        }

 private DrawFourCard(CardColor cc)
     : base(cc, CardFace.DF)
 {
 }

 public bool HasColor(CardColor color)
 {
     return Effect().HasColor(color);
 }

 private NumberCard(CardColor cc, CardFace cf)
     : base(cc, cf)
 {
 }

 protected override object this[string index]
 {
     get
     {
         #region
         switch (index)
         {
             case "Id": return _id;
             case "Name": return _name;
             case "Color": return _color;
             case "Value": return _value;
             case "HeadIcon": return _headIcon;
             default: throw new ArgumentException(string.Format("PokerInfo index[{0}] isn't exist.", index));
         }
         #endregion
     }
     set
     {
         #region
         switch (index)
         {
             case "Id":
                 _id = value.ToInt();
                 break;
             case "Name":
                 _name = value.ToNotNullString();
                 break;
             case "Color":
                 _color = value.ToEnum<CardColor>();
                 break;
             case "Value":
                 _value = value.ToShort();
                 break;
             case "HeadIcon":
                 _headIcon = value.ToNotNullString();
                 break;
             default: throw new ArgumentException(string.Format("PokerInfo index[{0}] isn't exist.", index));
         }
         #endregion
     }
 }

 private DrawTwoCard(CardColor cc)
     : base(cc, CardFace.DT)
 {
 }

            private static void OnObjAiBaseProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
            {
                try
                {
                    if (!sender.IsMe)
                    {
                        return;
                    }

                    if (args.SData.Name == "PickACard")
                    {
                        Status = SelectStatus.Selecting;
                    }
                    if (args.SData.Name == "goldcardlock")
                    {
                        LastCard = CardColor.Gold;
                        Status = SelectStatus.Selected;
                    }
                    else if (args.SData.Name == "bluecardlock")
                    {
                        LastCard = CardColor.Blue;
                        Status = SelectStatus.Selected;
                    }
                    else if (args.SData.Name == "redcardlock")
                    {
                        LastCard = CardColor.Red;
                        Status = SelectStatus.Selected;
                    }
                }
                catch (Exception ex)
                {
                    Global.Logger.AddItem(new LogItem(ex));
                }
            }

 protected Card GetBestCardOfSingleColorOrColorless(IEnumerable<Card> cards, CardColor? primaryColor = null)
 {
     return cards
     .Where(x => x.Colors.Length == 1 || (primaryColor.HasValue && IsUsableNonbasicLand(x, primaryColor.Value)))
     .OrderByDescending(GetRating)
     .FirstOrDefault();
 }

 public static bool Has(CardColor color)
 {
     return color == CardColor.Gold && ObjectManager.Player.HasBuff("goldcardpreattack") ||
            color == CardColor.Red && ObjectManager.Player.HasBuff("redcardpreattack") ||
            color == CardColor.Blue && ObjectManager.Player.HasBuff("bluecardpreattack");
 }

		}// property



		public Card(CardColor color, int value, int position) {
			_color = color;
			_value = value;
			_position = position;
		}// Card

        private bool IsUsableNonbasicLand(Card card, CardColor color1, CardColor? color2 = null)
        {
            if (!card.Is().Land)
            return false;

              var landColors = card.ProducableManaColors;

              if (landColors.Count == 0)
            return true;

              if (landColors.Count == 1)
              {
            if (landColors[0] == (int) CardColor.Colorless)
              return true;

            if (landColors[0] == (int) color1)
              return true;

            if (color2.HasValue && landColors[0] == (int) color2.Value)
              return true;

            return false;
              }

              if (!color2.HasValue)
            return false;

              return landColors.Contains((int) color1) &&
            landColors.Contains((int) color2.Value);
        }