public Card(Suit suit, Value value)
{
this.value = value;
this.suit = suit;
this.name = GetName();
this.owner = null;
}
private void button1_Click(object sender, EventArgs e)
{
mySuit = (Suit)random.Next(4);
myValue = (Value)random.Next(1,14);
myCard = new Card(mySuit, myValue);
MessageBox.Show(myCard.Name);
}
public void Suits_Should_Have_13_Cards(Suit suit)
{
var aDeck = new Deck();
var i = aDeck.Cards.Count(x => x.GetCardSuit() == suit);
Assert.AreEqual(i,13);
}
public override Bid? RequestBid()
{
//BUG BUG BUG..... where do you clean this (FGS) for the second round?!?!?! will always have the value of last bid!!! BUG BUG BUG
//if (m_highestBid == -1)
//{
m_highestBid = Math.Round(GetHighestBid(this.Cards));
m_highestBidSuit = GetHighestBidSuit();
//}
// bid is ICompareable !! this means you can sort by simply the bid rather than implement comparing
Bid? currHighestBidObj = (from b in this.CurrentRoundStatus.Biddings
where b != null
orderby b.Value descending
select b.Value).FirstOrDefault();
Bid myHighestBid = new Bid { Amount = (int)m_highestBid, Suit = m_highestBidSuit };
// each bidding round the minimum grows by one : 5 , 6 , 7
if (myHighestBid.Amount >= (5 + this.CurrentRoundStatus.TurnNumber))
{
// if there is no heighest bid or my bid is heigher than the highest one
if( !currHighestBidObj.HasValue || myHighestBid > currHighestBidObj.Value)
{
return myHighestBid;
}
}
return null;
}
static void Main(string[] args)
{
Person xc = new Person("Small bird");
Console.WriteLine("\nThe first decorated type: ");
Finery dtx = new TShirts();
Finery kk = new BigTrouser();
Finery pqx = new Sneakers();
dtx.Show();
kk.Show();
pqx.Show();
xc.Show();
Console.WriteLine("\nThe second decorated type: ");
Finery xz = new Suit();
Finery ld = new Tie();
Finery px = new LeatherShoes();
xz.Show();
ld.Show();
px.Show();
xc.Show();
}
protected Hand CreateHandFromFirstNineCardsOfGivenSuit(Suit suit)
{
return new Hand
{
FaceDownCards = new List<Card>
{
new Card(suit, Rank.Ace),
new Card(suit, Rank.Two),
new Card(suit, Rank.Three)
},
FaceUpCards = new List<Card>
{
new Card(suit, Rank.Four),
new Card(suit, Rank.Five),
new Card(suit, Rank.Six)
},
InHandCards = new List<Card>
{
new Card(suit, Rank.Seven),
new Card(suit, Rank.Eight),
new Card(suit, Rank.Nine)
}
};
}
protected Hand CreateHandWithSpecificInHandCards(Suit suit, Card cardOne, Card cardTwo, Card cardThree)
{
return new Hand
{
FaceDownCards = new List<Card>
{
cardOne,
cardTwo,
cardThree
},
FaceUpCards = new List<Card>
{
new Card(suit, Rank.Four),
new Card(suit, Rank.Five),
new Card(suit, Rank.Six)
},
InHandCards = new List<Card>
{
new Card(suit, Rank.Seven),
new Card(suit, Rank.Eight),
new Card(suit, Rank.Nine)
}
};
}
private static List<Trick> TestTricks(Suit trump, Seat declarer)
{
//D = declarer's team, d = defender's team
var tricks = new List<Trick>(13);
Seat lead = declarer.GetNextSeat(); //Lead:d, Win: D
tricks.Add(Trick.FromCards(trump, lead, new[] {Deck.TwoOfClubs, Deck.FiveOfClubs, Deck.FourOfClubs, Deck.ThreeOfClubs}));
lead = lead.GetNextSeat(); // Lead:D, Win:d
tricks.Add(Trick.FromCards(trump, lead, new[] {Deck.EightOfClubs, Deck.NineOfClubs, Deck.SevenOfClubs, Deck.SixOfClubs}));
lead = lead.GetNextSeat(); // Lead:d, Win:d
tricks.Add(Trick.FromCards(trump, lead, new[] {Deck.AceOfClubs, Deck.KingOfClubs, Deck.QueenOfClubs, Deck.JackOfClubs}));
//lead = lead.GetNextSeat(); // Lead:d, Win:d
tricks.Add(Trick.FromCards(trump, lead, new[] {Deck.TenOfClubs, Deck.TwoOfDiamonds, Deck.ThreeOfDiamonds, Deck.FourOfDiamonds}));
//lead = lead.GetNextSeat(); // Lead:d, Win:D
tricks.Add(Trick.FromCards(trump, lead, new[] {Deck.FiveOfDiamonds, Deck.EightOfDiamonds, Deck.SixOfDiamonds, Deck.SevenOfDiamonds}));
lead = lead.GetNextSeat(); // Lead:D, Win:D
tricks.Add(Trick.FromCards(trump, lead, new[] {Deck.KingOfDiamonds, Deck.QueenOfDiamonds, Deck.JackOfDiamonds, Deck.TenOfDiamonds}));
//lead = lead.GetNextSeat(); // Lead:D, Win:d
tricks.Add(Trick.FromCards(trump, lead, new[] {Deck.TwoOfHearts, Deck.FourOfHearts, Deck.AceOfDiamonds, Deck.ThreeOfHearts}));
lead = lead.GetNextSeat(); // Lead:d, Win:D
tricks.Add(Trick.FromCards(trump, lead, new[] {Deck.FiveOfHearts, Deck.EightOfHearts, Deck.SixOfHearts, Deck.SevenOfHearts}));
lead = lead.GetNextSeat(); // Lead:D, Win:d
tricks.Add(Trick.FromCards(trump, lead, new[] {Deck.NineOfHearts, Deck.QueenOfHearts, Deck.TenOfHearts, Deck.JackOfHearts}));
lead = lead.GetNextSeat(); // Lead:d, Win:D
tricks.Add(Trick.FromCards(trump, lead, new[] {Deck.KingOfHearts, Deck.AceOfHearts, Deck.AceOfSpades, Deck.KingOfSpades}));
lead = lead.GetNextSeat(); // Lead:D, Win:D
tricks.Add(Trick.FromCards(trump, lead, new[] {Deck.NineOfDiamonds, Deck.QueenOfSpades, Deck.JackOfSpades, Deck.TenOfSpades}));
//lead = lead.GetNextSeat(); // Lead:D, Win:d
tricks.Add(Trick.FromCards(trump, lead, new[] {Deck.EightOfSpades, Deck.NineOfSpades, Deck.SevenOfSpades, Deck.SixOfSpades}));
lead = lead.GetNextSeat(); // Lead:d, Win:D
tricks.Add(Trick.FromCards(trump, lead, new[] {Deck.FourOfSpades, Deck.FiveOfSpades, Deck.ThreeOfSpades, Deck.TwoOfSpades}));
//Score D: 7, d: 6
return tricks;
}
private bool IsCardAlreadyDealt(Suit suit, Value value)
{
List<PlayingCard> cardsInSuit = this.cardPack[suit];
// oh god it's like programming in Scala all over again ;_;
return (!cardsInSuit.Exists(c => c.CardSuit == suit && c.CardValue == value));
}
public Card(int i)
{
int shfl = i / 13;
suit += shfl;
shfl = i % 13;
rank += shfl;
}
/// <summary>
/// Nondefault constructor. Allows aces to be set high and a trump suit
/// to be used.
/// </summary>
public Deck(bool isAceHigh, bool useTrumps, Suit trump)
: this()
{
Card.isAceHigh = isAceHigh;
Card.useTrumps = useTrumps;
Card.trump = trump;
}
public Trick(Suit trump)
{
Trump = trump;
_cards = new List<Card>(4);
_players = new List<Seat>(4);
Suit = Suit.None;
}
public Game SwapSuitWith(Suit suit)
{
var cards = this.hand.Cards.Select(c =>
Fun.SwapSuit(c, suit)).ToArray();
return new Game(cards[0], cards[1], cards[2], cards[3], cards[4]);
}
public static King Of(Suit suit)
{
return new King
{
_Suit = suit
};
}
public Card(Value value, Suit suit)
{
if (value < (Value)6) value = (Value)6;
if (value > Value.A) value = Value.A;
this.value = value;
this.suit = suit;
}
public Deck(bool isAceHigh, bool useTrumps, Suit trump)
: this()
{
Card.s_isAceHigh = isAceHigh;
Card.s_useTrumps = useTrumps;
Card.s_trumpSuit = trump;
}
/// <summary>
/// Determines whether [has] [the specified rank].
/// </summary>
/// <param name="rank">The rank.</param>
/// <param name="suit">The suit.</param>
/// <returns>
/// <c>true</c> if [has] [the specified rank]; otherwise, <c>false</c>.
/// </returns>
public bool Has(Rank rank, Suit suit)
{
if (GetCard(rank, suit) != null)
return true;
else
return false;
}
public Card(Suit naipe, int value, bool startClosed)
{
_naipe = naipe;
_value = value;
_isClosed = startClosed;
}
public Card ComputerDoMove(Card fieldCard, Suit troef)
{
List<Card> lstAllowedCards = GetAllowedCards(fieldCard, troef);
Random random = new Random();
return lstAllowedCards[random.Next(0, lstAllowedCards.Count - 1)];
}
private IEnumerable<Card> GetCardsForSuit(Suit suit)
{
var listOfCardTypes = new List<CardType>();
listOfCardTypes.AddRange(new CardType[]
{
CardType.Ace,
CardType.Two,
CardType.Three,
CardType.Four,
CardType.Five,
CardType.Six,
CardType.Seven,
CardType.Eight,
CardType.Nine,
CardType.Ten,
CardType.Jack,
CardType.Queen,
CardType.King,
});
return listOfCardTypes.Select(cardType => new Card()
{
Name = string.Format("{0} of {1}s", cardType, suit.ToString()),
Value = GetPointsForCardType(cardType) + GetExtraPointsForSuit(suit),
CardType = cardType
});
}
public Card(int input)
{
integerValue = input;
int tempValue = input % 13;
int tempSuit = input / 13;
switch (tempValue)
{
case 0: value = Value.ACE; break;
case 1: value = Value.TWO; break;
case 2: value = Value.THREE; break;
case 3: value = Value.FOUR; break;
case 4: value = Value.FIVE; break;
case 5: value = Value.SIX; break;
case 6: value = Value.SEVEN; break;
case 7: value = Value.EIGHT; break;
case 8: value = Value.NINE; break;
case 9: value = Value.TEN; break;
case 10: value = Value.JACK; break;
case 11: value = Value.QUEEN; break;
case 12: value = Value.KING; break;
}
switch (tempSuit)
{
case 0: suit = Suit.SPADES; break;
case 1: suit = Suit.HEARTS; break;
case 2: suit = Suit.DIAMONDS; break;
case 3: suit = Suit.CLUBS; break;
}
}
public Card(Image front, PictureBox pictureBox, int power, Suit suit)
{
this.Front = front;
this.PictureBox = pictureBox;
this.Power = power;
this.Suit = suit;
}
public void WhenCardIsConstructedWithShortNotation(string shortNotation, Value expectedValue, Suit expectedSuit)
{
var card = new Card(shortNotation);
Assert.That(card.Value, Is.EqualTo(expectedValue));
Assert.That(card.Suit, Is.EqualTo(expectedSuit));
}
public IEnumerable<Card> Play(IEnumerable<Card> hand, IEnumerable<Card> table, int rank, Suit suit, Mode mode, bool revolution, History history)
{
if (revolution && rank != Card.RankOfJoker)
{
rank = 14 - rank;
}
if (hand == null || hand.Count() == 0)
return null;
int count = table.Count();
// 初手はとりあえず一番弱いのを出しとく。
if (mode.Match(Mode.First))
{
var min = hand.Min(x => Game.Rank(x, revolution));
return hand.Where(x => Game.Rank(x, revolution) == min);
}
if (mode.Match(Mode.Normal))
{
if(mode.Match(Mode.SuitBound))
{
return hand.MinCard(x => Game.Rank(x, revolution) > rank && x.Suit == suit, revolution);
}
else
{
return hand.MinCard(x => Game.Rank(x, revolution) > rank, revolution);
}
}
if(mode.Match(Mode.Multiple))
{
for (int i = rank + 1; i <= 13; i++)
{
// 出せる
var c = hand.Where(x => Game.Rank(x, revolution) == i);
if (c.Count() >= count)
return c.Take(count);
// Joker含めれば出せる
if (c.Count() + 1 == count && hand.FirstOrDefault(x => x.Suit == Suit.Joker) != null)
return c.Concat(hand.Where(x => x.Suit == Suit.Joker).Take(count));
}
}
if (mode.Match(Mode.SequenceBound))
return null; //todo また未対応
if (mode.Match(Mode.Sequence))
{
if (mode.Match(Mode.SuitBound))
return hand.Sequence(rank, revolution, count, suit);
else
return hand.Sequence(rank, revolution, count);
}
return null;
}
public Card playCardSmart(Suit leadSuit, GameState state)
{
List<Card> legal = getLegalMoves(leadSuit);
Card played = AI.getBestMove(legal, state, index);
Console.WriteLine(hand.Remove(played));
return played;
}
private static IEnumerable<Card> ReadPbnCard(Suit suit, string cardString)
{
return cardString.Aggregate(new List<Card>(), (cards, card) =>
{
cards.Add(new Card(new Rank(card), suit));
return cards;
});
}
public Card( Suit suit, int rank, bool bFaceUp, Deck d )
{
this.Suit = suit;
this.FaceUp = bFaceUp;
m_deck = d;
this.Location = Point.Empty;
this.Rank = rank;
}
public Card(Suit suit, int value)
: this()
{
Suit = suit;
if (value <= 1 || value > 14)
throw new Exception("Card created with wrong arguments");
Value = value;
}
public Card(Suit suit, int value)
{
if(value < 2 || value > 14)
throw new ArgumentOutOfRangeException("value should be between 0 and 13");
Suit = suit;
Value = value;
}
public Card(Rank rank, Suit suit)
: this()
{
if (suit == Suit.None)
throw new ArgumentException("Suit cannot be none", "suit");
this.Rank = rank;
this.Suit = suit;
}
public Player GetDeclarerOrNorth(Suit suit)
{
var declarer = GetDeclarer(suit);
return(declarer == Player.UnKnown ? Player.North : declarer);
}
public Card(Suit Suit, Name Name, int Value)
{
this.Suit = Suit;
this.Name = Name;
this.Value = Value;
}
public Card(Suit suit, int number, IVersionSource versionSource)
{
this.suit = suit;
this.number = number;
this.VersionSource = versionSource;
}
/// <summary>
///// CONSTRUCTS A CARD BY PASSING THE FACEVALUE AND SUIT
/// </summary>
/// <param name="newSuit"></param>
/// <param name="newValue"></param>
public Card(Suit newSuit, FaceValue newValue)
{
this.Suit = newSuit;
this.FaceValue = newValue;
}
public Card(Suit theSuit_, FaceValue theFaceValue_)
{
_suit = theSuit_;
_faceValue = theFaceValue_;
}
public static string ToAbbreviation(this Suit suit)
{
return(Abbreviation.Get(suit));
}
public Card(int rank, Suit suit)
{
this.cardname = rank + " " + suit.ToString();
}
public Card(int r, Suit s)
{
_rank = r;
_suit = s;
}
public Card(string name, Suit suit)
{
Initialize(name, suit, new Display(500));
}
public Card(int c, Suit s)
{
FaceValue = c;
suit = s;
}
public Panic(Rank rank, Suit suit) : base(CardType.Panic, rank, suit)
{
}
private Bitmap Compute(Bitmap inputImage)
{
// Define output array
int[,] output;
// Get the grayscale image from src
int[,] grayscale = Grayscale.FromBitmap(inputImage);
int width = grayscale.GetLength(0);
int height = grayscale.GetLength(1);
// Detect edges using sobel
int[,] edges = Sobel.Compute(grayscale);
bool[,] strucElem =
{
{ false, true, false },
{ true, true, true },
{ false, true, false }
};
// Calculate white top-hat (WTH) with plus-shaped structuring element
int[,] wth = Defaults.Combine(edges, Morphologicals.Opening(edges, strucElem), (a, b) => a - b);
// Create thresholds from the WTH
int[,] wth60 = Threshold.Compute(wth, 60);
int[,] wth30 = Threshold.Compute(wth, 30);
// Calculate Hough transform
const double STEP_SIZE = 0.25;
int[,] hough = Hough.Compute(wth60, STEP_SIZE);
int[,] houghWindow = Window.Compute(hough, 20000, int.MaxValue);
// Find and filter lines from hough transform
SortedSet <Line> lines = Lines.FindLines(houghWindow, STEP_SIZE);
lines = Lines.FilterLines(lines);
strucElem = new bool[, ]
{
{ false, false, true, false, false },
{ false, true, true, true, false },
{ true, true, true, true, true },
{ false, true, true, true, false },
{ false, false, true, false, false }
};
// Find all rectangles that somewhat resemble a card shape
IList <Card> cards = Lines.FindCardShapedRectangles(lines, width, height);
// Filter all card shaped rectangles with enough line support
int[,] dilation = Morphologicals.Dilation(wth60, strucElem);
IList <Card> filteredCards = Lines.FilterCardShapedRectangles(dilation, cards);
// Set the output image, convert it to a bitmap and create a graphics object so we can draw on it
switch (outputSelector.SelectedIndex)
{
default:
case 0:
output = grayscale;
break;
case 1:
output = edges;
break;
case 2:
output = wth;
break;
case 3:
output = wth60;
break;
case 4:
output = wth30;
break;
case 5:
output = dilation;
break;
case 6:
output = hough;
break;
}
Bitmap outputImage = Grayscale.ToBitmap(Defaults.Normalize(output));
if (output == hough)
{
return(outputImage);
}
Graphics g = Graphics.FromImage(outputImage);
// Draw the filtered lines
if (drawFilteredLinesCheckbox.Checked)
{
DrawLines(lines, g, outputImage.Width, outputImage.Height);
}
// Draw the potential cards (card-shaped rectangles)
if (drawFoundRectanglesCheckbox.Checked)
{
foreach (Card card in cards)
{
card.Draw(g, Pens.Yellow);
}
}
if (drawFilteredRectanglesCheckbox.Checked)
{
foreach (Card card in filteredCards)
{
card.Draw(g, Pens.Red);
}
}
// Classify and draw all filtered cards
foreach (Card card in filteredCards)
{
List <ShapeInfo> shapes = Shapes.Find(wth30, card);
if (shapes.Count > 10)
{
continue;
}
Suit suit = Shapes.ClassifyShapes(shapes);
if (suit != Suit.Unknown)
{
// Draw the bboxes of the shapes
if (drawBBCheckbox.Checked)
{
DrawShapes(shapes, g);
}
// Draw the card outline
if (drawFoundCardsCheckbox.Checked)
{
card.Draw(g);
}
// Format the card name and print it on the card
string cardName = String.Format("{0} of {1}", shapes.Count == 1 ? "Ace" : shapes.Count.ToString(), suit);
g.DrawString(cardName, new Font("Arial", 14), Brushes.Orange, new PointF(card.bottomLeft.X, card.bottomLeft.Y + 4));
Console.WriteLine(cardName);
}
}
return(outputImage);
}
public Card(Suit s, int v)
{
CardSuit = s;
CardRank = v;
}
// Parameterized constructor
public Card(Suit newSuit, Rank newRank)
{
suit = newSuit;
rank = newRank;
}
public Card(Suit s, CardRank r)
{
suit = s;
cardRank = r;
cardLocation = CardLocation.Community;
}
public Card(Rank rank, Suit suit)
{
Rank = rank;
Suit = suit;
}
public Card(Suit s, CardRank r, CardLocation location)
{
suit = s;
cardRank = r;
cardLocation = location;
}
/// <summary>
/// Display function. Shows card in format "2 - Hearts" or "X - Clubs"
/// </summary>
public void DisplayCard()
{
show.Card(Name, Suit.ToString(), SuitSymbol.ToString());
}
public Card(Value value, Suit suit)
{
this.Value = value;
this.Suit = suit;
}
public Card(Rank rank, Suit suit)
{
this.Rank = rank;
this.Suit = suit;
this.Power = (int)this.Suit + (int)this.Rank;
}
public Card(Suit suit, Value value)
{
this.Suit = suit;
this.Value = value;
}
public Card(string name, Suit suit, IDisplay display)
{
Initialize(name, suit, display);
}
public PlayingCard(Suit s, Rank r)
{
CardSuit = s;
CardRank = r;
}
/// <summary>
/// Nondefault constructor. Allows a trump suit to be used.
/// </summary>
public Deck(bool useTrumps, Suit trump)
: this()
{
Card.useTrumps = useTrumps;
Card.trump = trump;
}
public Card(Suit suit, int value)
{
this.suit = suit;
this.value = value;
}
public void InstantiateCard(Suit cardSuit, Value cardValue)
{
GameObject newCard = Instantiate(cardPrefab, container.transform);
newCard.GetComponent <Card>().value = cardValue;
newCard.GetComponent <Card>().suit = cardSuit;
if (cardSuit == Suit.CLUBS)
{
switch (cardValue)
{
case Value.ACE:
newCard.GetComponent <Image>().sprite = AceC;
break;
case Value.TWO:
newCard.GetComponent <Image>().sprite = TwoC;
break;
case Value.THREE:
newCard.GetComponent <Image>().sprite = ThreeC;
break;
case Value.FOUR:
newCard.GetComponent <Image>().sprite = FourC;
break;
case Value.FIVE:
newCard.GetComponent <Image>().sprite = FiveC;
break;
case Value.SIX:
newCard.GetComponent <Image>().sprite = SixC;
break;
case Value.SEVEN:
newCard.GetComponent <Image>().sprite = SevenC;
break;
case Value.EIGHT:
newCard.GetComponent <Image>().sprite = EightC;
break;
case Value.NINE:
newCard.GetComponent <Image>().sprite = NineC;
break;
case Value.TEN:
newCard.GetComponent <Image>().sprite = TenC;
break;
case Value.JACK:
newCard.GetComponent <Image>().sprite = JackC;
break;
case Value.QUEEN:
newCard.GetComponent <Image>().sprite = QueenC;
break;
case Value.KING:
newCard.GetComponent <Image>().sprite = KingC;
break;
default:
newCard.GetComponent <Image>().sprite = backside;
break;
}
}
else if (cardSuit == Suit.SPADES)
{
switch (cardValue)
{
case Value.ACE:
newCard.GetComponent <Image>().sprite = AceS;
break;
case Value.TWO:
newCard.GetComponent <Image>().sprite = TwoS;
break;
case Value.THREE:
newCard.GetComponent <Image>().sprite = ThreeS;
break;
case Value.FOUR:
newCard.GetComponent <Image>().sprite = FourS;
break;
case Value.FIVE:
newCard.GetComponent <Image>().sprite = FiveS;
break;
case Value.SIX:
newCard.GetComponent <Image>().sprite = SixS;
break;
case Value.SEVEN:
newCard.GetComponent <Image>().sprite = SevenS;
break;
case Value.EIGHT:
newCard.GetComponent <Image>().sprite = EightS;
break;
case Value.NINE:
newCard.GetComponent <Image>().sprite = NineS;
break;
case Value.TEN:
newCard.GetComponent <Image>().sprite = TenS;
break;
case Value.JACK:
newCard.GetComponent <Image>().sprite = JackS;
break;
case Value.QUEEN:
newCard.GetComponent <Image>().sprite = QueenS;
break;
case Value.KING:
newCard.GetComponent <Image>().sprite = KingS;
break;
default:
newCard.GetComponent <Image>().sprite = backside;
break;
}
}
else if (cardSuit == Suit.DIAMONDS)
{
switch (cardValue)
{
case Value.ACE:
newCard.GetComponent <Image>().sprite = AceD;
break;
case Value.TWO:
newCard.GetComponent <Image>().sprite = TwoD;
break;
case Value.THREE:
newCard.GetComponent <Image>().sprite = ThreeD;
break;
case Value.FOUR:
newCard.GetComponent <Image>().sprite = FourD;
break;
case Value.FIVE:
newCard.GetComponent <Image>().sprite = FiveD;
break;
case Value.SIX:
newCard.GetComponent <Image>().sprite = SixD;
break;
case Value.SEVEN:
newCard.GetComponent <Image>().sprite = SevenD;
break;
case Value.EIGHT:
newCard.GetComponent <Image>().sprite = EightD;
break;
case Value.NINE:
newCard.GetComponent <Image>().sprite = NineD;
break;
case Value.TEN:
newCard.GetComponent <Image>().sprite = TenD;
break;
case Value.JACK:
newCard.GetComponent <Image>().sprite = JackD;
break;
case Value.QUEEN:
newCard.GetComponent <Image>().sprite = QueenD;
break;
case Value.KING:
newCard.GetComponent <Image>().sprite = KingD;
break;
default:
newCard.GetComponent <Image>().sprite = backside;
break;
}
}
else if (cardSuit == Suit.HEARTS)
{
switch (cardValue)
{
case Value.ACE:
newCard.GetComponent <Image>().sprite = AceH;
break;
case Value.TWO:
newCard.GetComponent <Image>().sprite = TwoH;
break;
case Value.THREE:
newCard.GetComponent <Image>().sprite = ThreeH;
break;
case Value.FOUR:
newCard.GetComponent <Image>().sprite = FourH;
break;
case Value.FIVE:
newCard.GetComponent <Image>().sprite = FiveH;
break;
case Value.SIX:
newCard.GetComponent <Image>().sprite = SixH;
break;
case Value.SEVEN:
newCard.GetComponent <Image>().sprite = SevenH;
break;
case Value.EIGHT:
newCard.GetComponent <Image>().sprite = EightH;
break;
case Value.NINE:
newCard.GetComponent <Image>().sprite = NineH;
break;
case Value.TEN:
newCard.GetComponent <Image>().sprite = TenH;
break;
case Value.JACK:
newCard.GetComponent <Image>().sprite = JackH;
break;
case Value.QUEEN:
newCard.GetComponent <Image>().sprite = QueenH;
break;
case Value.KING:
newCard.GetComponent <Image>().sprite = KingH;
break;
default:
newCard.GetComponent <Image>().sprite = backside;
break;
}
}
else if (cardSuit == Suit.JOKER)
{
switch (cardValue)
{
case Value.JOKER1:
newCard.GetComponent <Image>().sprite = Joker1;
break;
case Value.JOKER2:
newCard.GetComponent <Image>().sprite = Joker2;
break;
default:
newCard.GetComponent <Image>().sprite = backside;
break;
}
}
}
public Card(Rank r, Suit s)
{
this.Rank = r;
this.Suit = s;
}
/// <summary>
/// Constructs a card by passing the facevalue and suit
/// </summary>
/// <param name="newSuit"></param>
/// <param name="newValue"></param>
public Card(Suit newSuit, FaceValue newValue)
{
Suit = newSuit;
FaceValue = newValue;
}
public Card(Suit suit, Value value)
{
Name = $"{value} of {suit}";
}
public Card()
{
_suit = Suit.Spades;
_faceValue = FaceValue.Ace;
}
