private void PlayCardResultSound(Card.CardValue match) { AudioSource audio = GetComponent <AudioSource>(); if (match == Card.CardValue.Ammo) { audio.PlayOneShot(Reload); } else if (match == Card.CardValue.Health) { audio.PlayOneShot(HealthPickup); } else if (match == Card.CardValue.Poison) { audio.PlayOneShot(Poison); } else if (match == Card.CardValue.Health100) { audio.PlayOneShot(HealthPickup); } else if (match == Card.CardValue.Unknown) { // No match audio.PlayOneShot(NoMatch); } }
private Texture2D GetTextureForCardValue(Card.CardValue cardValue) { switch (cardValue) { case Card.CardValue.Unknown: return(Question); case Card.CardValue.Ammo: return(Ammo); case Card.CardValue.Health: return(Health); case Card.CardValue.Poison: return(Poison); case Card.CardValue.Poison2: return(Poison2); case Card.CardValue.Block: return(Block); case Card.CardValue.Health100: return(Health100); default: return(Question); } }
/** * Check if player is allowed to make meld of given CardValue, * in terms of natural to wild card ratio. * @param cv CardValue of meld * @return True -> is allowed, False -> is not allowed */ private bool CanMeld(Card.CardValue cv) { int natural = CardAmount(cv, myCards); int wild = WildCardAmount(); return(natural > 1 && (wild > 0 || natural > 2)); }
/** * Run given meld -> remove cards from player hand and add cards to player melds. * @param meld Meld to run * @param meldValue CardValue of meld */ private void RunMeld(List <Card> meld, Card.CardValue meldValue) { foreach (Card card in meld) { myCards.Remove(card); } myMelds[CardValueToValue(meldValue) - 3] = meld; }
public void ReturnHighestCardInHand(Card.CardValue[] sourceCardValues, Card.CardValue expectedValue) { Hand instance = new Hand(sourceCardValues); var highestCardValue = instance.GetHighestCardValue(); Assert.AreEqual(highestCardValue, expectedValue); }
/** * Count amount of given cards of given or lower CardValue * @param cv CardValue (or lower) to consider * @param cards Cards to count * @return Amount of cards of CardValue or lower */ private static int CountLowerOrSame(List <Card.CardValue> values, Card.CardValue cv) { int count = 0; foreach (Card.CardValue value in values) { count += CardValueToValue(value) <= CardValueToValue(cv) ? 1 : 0; } return(count); }
/** * Count amount of given cards of given CardValue * @param cv CardValue to consider * @param cards Cards to count * @return Amount of cards of CardValue */ private static int CardAmount(Card.CardValue cv, List <Card> cards) { int amount = 0; foreach (Card card in cards) { amount += card.value == cv ? 1 : 0; } return(amount); }
public Sprite FindCardSprite(Card.CardValue v, Card.CardSuit s) { foreach (var item in commonFronts) { if (item.suit == s && item.value == v) { return(item.faceArt); } } return(null); }
/** * Search for first card of player of given CardValue * @param cv CardValue to consider * @return First Card of given CardValue, Null if not found */ private Card FindFirstCard(Card.CardValue cv) { foreach (Card card in myCards) { if (card.value == cv) { return(card); } } return(null); }
public Card CreateCard(Card.CardSuit suit, Card.CardValue value) { //make sure we can find our prefab in resorces var _cardObj = Resources.Load("Prefabs/Card") as GameObject; if (_cardObj == null) { Debug.LogError("Unable to find card prefab"); return(null); } //now instatiate (creates an instance of that prefab and adds it to the scene) _cardObj = Instantiate(_cardObj); if (_cardObj == null) { Debug.LogError("Failed to create card prefab"); return(null); } //we will be using the "Card" component of the newly created card a few times, // GetComponent is expensive so we do it once and store it. Because _card was created in this function //it will get freed up after the funtion and destroyed. var _card = _cardObj.GetComponent <Card> (); if (_card == null) //if for some reason the card doesnt have a card class/component on it we will just add it. { _card = _cardObj.AddComponent <Card> (); } _card.CSuit = suit; _card.CValue = value; //now we want to set the name of the card so it makes sense as we look at it in the hierarchy //and set the parent to the deck, so all the cards get hidden underneath _cardObj.name = _card.CValue.ToString() + "_" + _card.CSuit.ToString(); _cardObj.transform.SetParent(transform, false); //we will now loop though all the children (possible card types) and //remove the ones we are not set to for this specific card. //this makes creating them a little heavier but ends up the cleanest so far for me. Transform _child = null; //loop though and destroy the kids we are not, that we dont need. for (int m = 0; m < _cardObj.transform.childCount; m++) { _child = _cardObj.transform.GetChild(m); if (_child.name != Card.CardBack && _child.name != _cardObj.name) { Destroy(_child.gameObject); } } return(_card); }
private static int CardValueToValue(Card.CardValue cv) { return(cv switch { Card.CardValue.JOKER => 0, Card.CardValue.TWO => 1, Card.CardValue.THREE => 2, Card.CardValue.FOUR => 3, Card.CardValue.FIVE => 4, Card.CardValue.SIX => 5, Card.CardValue.SEVEN => 6, Card.CardValue.EIGHT => 7, Card.CardValue.NINE => 8, Card.CardValue.TEN => 9, Card.CardValue.JACK => 10, Card.CardValue.QUEEN => 11, Card.CardValue.KING => 12, Card.CardValue.ACE => 13, _ => - 1, });
/* Constructor loops through different suits and kinds in double for loop to * create a deck of 52 cards */ public Deck() { _Deck = new List <Card>(); string[] suits = new string[] { "Clubs", "Hearts", "Diamonds", "Spades" }; //string[] kinds = new string[] { "2", "3", "4", "5", "6", "7", "8", "9", "10", // "Jack", "Queen", "King", "Ace" }; Card.CardValue[] kinds = new Card.CardValue[] { Card.CardValue.TWO, Card.CardValue.THREE, Card.CardValue.FOUR, Card.CardValue.FIVE, Card.CardValue.SIX, Card.CardValue.SEVEN, Card.CardValue.EIGHT, Card.CardValue.NINE, Card.CardValue.TEN, Card.CardValue.JACK, Card.CardValue.QUEEN, Card.CardValue.KING, Card.CardValue.ACE }; foreach (var suit in suits) { foreach (var kind in kinds) { _Deck.Add(new Card() { Kind = kind, Suit = suit }); } } }
private void OnCardMatch(Card.CardValue match) { if (match == Card.CardValue.Ammo) { AmmoCount += 10; gameUI.ShowAmmoBonus(10); } else if (match == Card.CardValue.Health) { Health += 25; gameUI.ShowHealthBonus(25); } else if (match == Card.CardValue.Poison) { Health -= 12; gameUI.ShowHealthBonus(-12); Health = Mathf.Max(Health, 0); } else if (match == Card.CardValue.Health100) { int diff = 100 - Health; if (diff > 0) { gameUI.ShowHealthBonus(diff); } Health = Mathf.Max(Health, 100); } UpdateUI(false); PlayCardResultSound(match); }
/** * Use drop net to predict card to drop. When the player does not hold the card, * the second highest prediction value gets chosen and so on. * @return Card to drop, identified by SUIT and VALUE */ public Card Drop() { Card toDrop; //get raw predictions and copy it. when cutting of later the orginal one is not touched NDarray pred = dropModel.Predict(input)[0]; NDarray predCleaned = np.array(pred); //CardValues that the AI predicted but are not in the playershand List <Card.CardValue> tried = new List <Card.CardValue>(); do { //convert prediction vector to CardValue NDarray argMax = np.argmax(predCleaned); int value = argMax.item <int>(); Card.CardValue tryDrop = value > 0 ? ValueToCardValue(value + 1) : Card.CardValue.JOKER; tryDrop = ValueToCardValue(CardValueToValue(tryDrop) + CountLowerOrSame(tried, tryDrop)); //check if player actually holds predicted CardValue toDrop = FindFirstCard(tryDrop); //JOKER stands for wild card in general -> also consider TWO if (tryDrop == Card.CardValue.JOKER) { toDrop = toDrop ?? FindFirstCard(Card.CardValue.TWO); } //cuts out tried CardValue var sliceIdx = Numpy.Models.Slice.Index( tryDrop != Card.CardValue.JOKER ? CardValueToValue(tryDrop) - CountLowerOrSame(tried, tryDrop) - 1 : 0); predCleaned = np.delete(predCleaned, sliceIdx); tried.Add(tryDrop); }while (toDrop == null); return(toDrop); }
public CardInfo(Card.CardColor color, Card.CardValue value) { this.color = color; this.value = value; }
/// <summary> /// Check if cards have same card value /// </summary> public bool EqualValue(Card.CardValue cardValue) { return(this.value == cardValue); }
/** * Use meldIf net to predict wether to meld cards or not. If yes, meld value and (wild)card amount * get predicted by (meld)value/wild net. Runs as long AI wants(= prediction) to and also can(=cards) meld. * @param minMeldPoints Minimal points needed to be a valid meld * @return All melds to be made. Every array element is representing one meld with a list of cards. * The element at index == 0 represents the meld with CardValue == Four, index == 1 -> CardValuue == Five, ... * When an array element == null, there are no cards of this CardValue to be meld. */ public List <Card>[] Meld(int minMeldPoints = 0) { List <Card>[] toMeld = new List <Card> [11]; int meldPoints = 0; //get raw "if" prediction and convert vector to boolean NDarray predIf = meldIfModel.Predict(input)[0]; float valueIf = predIf.item <float>(); bool doMeld = Math.Round(valueIf) == 1; if (doMeld) { Card toMeldElem; do { //get raw "value" predictions and copy it. when cutting of later the orginal one is not touched NDarray predValue = meldValueModel.Predict(input)[0]; NDarray predValueCleaned = np.array(predValue); //CardValues that the AI predicted but are not in the playershand List <Card.CardValue> tried = new List <Card.CardValue>(); do { //convert prediction vector to CardValue NDarray argMaxValue = np.argmax(predValueCleaned); int valueValue = argMaxValue.item <int>(); Card.CardValue tryMeld = ValueToCardValue(valueValue + 3); tryMeld = ValueToCardValue(CardValueToValue(tryMeld) + CountLowerOrSame(tried, tryMeld)); //check if player actually holds predicted CardValue toMeldElem = FindFirstCard(tryMeld); //cuts out tried CardValue var sliceIdx = Numpy.Models.Slice.Index(CardValueToValue(tryMeld) - 3 - CountLowerOrSame(tried, tryMeld)); predValueCleaned = np.delete(predValueCleaned, sliceIdx); tried.Add(tryMeld); }while (predValueCleaned.size > 0 && (toMeldElem == null || !CanMeld(toMeldElem.value))); if (toMeldElem != null) { //get raw "wild" prediction and convert vector to wild card amount. also considering max wild cards NDarray predWild = meldWildModel.Predict(input)[0]; NDarray argMaxWild = np.argmax(predWild); int wildCardAmount = WildCardAmount(); int cardAmount = CardAmount(toMeldElem.value, myCards); int valueWild = argMaxWild.item <int>() <= wildCardAmount?argMaxWild.item <int>() : wildCardAmount; //correct if not enough cards or too many wild cards if (valueWild + cardAmount < 3) { valueWild = 3 - cardAmount; } if (valueWild > cardAmount) { valueWild = cardAmount; } //build meld List <Card> meld = AllCardsOfCVs(new List <Card.CardValue>() { toMeldElem.value }); meld.AddRange(AllCardsOfCVs(new List <Card.CardValue>() { Card.CardValue.TWO, Card.CardValue.JOKER }, valueWild)); //update meld array and meld points toMeld[CardValueToValue(toMeldElem.value) - 3] = meld; meldPoints += MeldToPoints(meld); //update myCards and myMelds RunMeld(meld, toMeldElem.value); //get raw "if" prediction (after updating input vector) and convert vector to boolean FillInput(); predIf = meldIfModel.Predict(input)[0]; valueIf = predIf.item <float>(); doMeld = Math.Round(valueIf) == 1; } else { doMeld = false; } } while (doMeld); } return(meldPoints >= minMeldPoints ? toMeld : new List <Card> [11]); }