public void CardCollection_AdditionTest() { CardCollection left = new CardCollection(); ColorettoCard card1 = new ColorettoCard(ColorettoCardColors.Blue); ColorettoCard card2 = new ColorettoCard(ColorettoCardColors.Brown); ColorettoCard card3 = new ColorettoCard(ColorettoCardColors.Gray); left = left.Add(card1); left = left.Add(card2); left = left.Add(card3); CardCollection right = new CardCollection(); card1 = new ColorettoCard(ColorettoCardColors.Blue); card2 = new ColorettoCard(ColorettoCardColors.Brown); card3 = new ColorettoCard(ColorettoCardColors.Gray); right = right.Add(card1); right = right.Add(card2); right = right.Add(card3); CardCollection added = left + right; Assert.AreEqual<int>(6, added.Count); Assert.AreEqual<int>(9, added.Score); }
/// <summary> /// Handles validating the server state. If the round is 6, this handles moving to the next round, giving the defender the win /// </summary> /// <param name="server">The server to execute on</param> public void ValidateState(GameServer server) { // Todo check won battle if (server.GameState.GetValueInt(Names.CURRENT_ROUND) == 6) { // Get the current round and the discard pile from the state int round = server.GameState.GetValueInt(Names.CURRENT_ROUND); CardCollection discard = server.GameState.GetValueCardCollection(Names.DISCARD); // Iterate over over all the previous rounds, as this round has no attacking or defending cards for (int index = 0; index < round; index++) { // Add the cards to the discard pile discard.Add(server.GameState.GetValueCard(Names.ATTACKING_CARD, index)); discard.Add(server.GameState.GetValueCard(Names.DEFENDING_CARD, index)); // Remove the cards from the state server.GameState.Set <PlayingCard>(Names.ATTACKING_CARD, index, null); server.GameState.Set <PlayingCard>(Names.DEFENDING_CARD, index, null); } // Update the discard pile server.GameState.Set(Names.DISCARD, discard); // Move to the next duel Utils.MoveNextDuel(server); } }
public void Test_DetermineWinners_FullHouse_TwoWinners() { Player winner1 = new Player("Winner1", 1000); winner1.Cards.Add(new Card(Rank.Two, Suit.Spades)); winner1.Cards.Add(new Card(Rank.Two, Suit.Hearts)); Player winner2 = new Player("Winner2", 1000); winner2.Cards.Add(new Card(Rank.Two, Suit.Diamonds)); winner2.Cards.Add(new Card(Rank.Two, Suit.Clubs)); CardCollection communityCards = new CardCollection(); communityCards.Add(new Card(Rank.Three, Suit.Hearts)); communityCards.Add(new Card(Rank.Six, Suit.Clubs)); communityCards.Add(new Card(Rank.King, Suit.Hearts)); communityCards.Add(new Card(Rank.King, Suit.Spades)); communityCards.Add(new Card(Rank.King, Suit.Diamonds)); HandEvaluator eval = new HandEvaluator(); Hand hand1 = eval.GetBestHand(winner1.Cards + communityCards); Hand hand2 = eval.GetBestHand(winner2.Cards + communityCards); Assert.AreEqual(0, HandEvaluator.Compare(hand1, hand2)); }
/// <summary> /// Handles validating the server state. If the attacker has lost, this handles moving to the next round /// </summary> /// <param name="server">The server to execute on</param> public void ValidateState(GameServer server) { // Only run this state update if the attacker is forfeiting if (server.GameState.GetValueBool(Names.ATTACKER_FORFEIT)) { // Get the current round and the discard pile from the state int round = server.GameState.GetValueInt(Names.CURRENT_ROUND); CardCollection discard = server.GameState.GetValueCardCollection(Names.DISCARD); // Iterate over over all the previous rounds, as this round has no attacking or defending cards for (int index = 0; index < round; index++) { // Add the cards to the discard pile discard.Add(server.GameState.GetValueCard(Names.ATTACKING_CARD, index)); discard.Add(server.GameState.GetValueCard(Names.DEFENDING_CARD, index)); // Remove the cards from the state server.GameState.Set <PlayingCard>(Names.ATTACKING_CARD, index, null); server.GameState.Set <PlayingCard>(Names.DEFENDING_CARD, index, null); } // Send the message server.SendServerMessage(server.Players[server.GameState.GetValueByte(Names.ATTACKING_PLAYER)].Name + " has forfeited"); // Update the discard pile server.GameState.Set(Names.DISCARD, discard); // Move to next match Utils.MoveNextDuel(server); } }
public void AddTest() { var cc = new CardCollection(); cc.Add(new Card("TEST1", "Test1")); cc.Add("TEST2", new Card("TEST2", "Test2")); // Test add with existing keyword }
public override CardCollection CardStack() { CardCollection cc = new CardCollection(); if (_SetAsideCard != null) { cc.Add(_SetAsideCard); } cc.Add(this); return(cc); }
public static CardCollection operator +(Card c1, Card c2) { CardCollection summCollection = new CardCollection(); if (c1 != null) summCollection.Add(c1); if (c2 != null) summCollection.Add(c2); return summCollection; }
/// <summary> /// 动态条件查询卡号 /// </summary> /// <param name="strFields">条件字段</param> /// <param name="strValues">条件值</param> /// <returns></returns> public static CardCollection GetCard(List <QueryElement> list) { CardCollection coll = new CardCollection(); StringBuilder sb = new StringBuilder(); sb.Append(" select card.*,a.name as ownerName,b.name as userName from card left join user a on card.ownerId=a.id left join user b on card.userId = b.id where 1=1 "); if (list.Count > 0) { MySqlParameter[] pars = new MySqlParameter[list.Count]; for (int i = 0; i < list.Count; i++) { QueryElement query = list[i]; if (query.QueryElementType == MySqlDbType.DateTime) { sb.AppendFormat(" {0} {1} {2} @{3} ", query.QueryLogic, query.Queryname, query.QueryOperation, query.Queryname + i); pars[i] = new MySqlParameter("@" + query.Queryname + i, query.QueryElementType); } else { sb.AppendFormat(" {0} {1} {2} @{3} ", query.QueryLogic, query.Queryname, query.QueryOperation, query.Queryname); pars[i] = new MySqlParameter("@" + query.Queryname, query.QueryElementType); } if (query.QueryOperation.Equals("like")) { pars[i].Value = "%" + query.Queryvalue + "%"; } else { pars[i].Value = query.Queryvalue; } } using (MySqlDataReader reader = MySqlDBHelper.GetReader(sb.ToString(), pars)) { while (reader.Read()) { coll.Add(new CardInfo(reader)); } } } else { using (MySqlDataReader reader = MySqlDBHelper.GetReader(sb.ToString())) { while (reader.Read()) { coll.Add(new CardInfo(reader)); } } } return(coll); }
public Deck(CardValue minValue, CardValue maxValue) { for (var suit = 0; suit < 4; suit++) { for (var value = (int)minValue; value < (int)maxValue + 1; value++) { Cards.Add(new Card((CardValue)value, (CardSuit)suit)); } } Shuffle(); trumpSuit = Cards.Last().Suit; }
public void TestUpdateLocation( ) { CardCollection coll = new CardCollection( ); coll.Add( new Card( Suit.Clubs, 10, true, null ) ); coll.Add( new Card( Suit.Diamonds, 11, true, null ) ); coll.Add( new Card( Suit.Diamonds, 7, true, null ) ); coll.UpdateLocation( 10, 7 ); // This test does in fact rely on the fact that a card // will by default initialize its location to 0,0. Assert.AreEqual( coll[ 0 ].Location.X, 10 ); }
/// <summary> /// Refreshes the logic decks each time there is an action. /// </summary> private void RefreshLogicDeckFromPanels() { AIHand.Clear(); playerHand.Clear(); foreach (CardBox.CardBox card in pnlComputerCards.Controls) { AIHand.Add(card.Card); } foreach (CardBox.CardBox card in pnlPlayerCards.Controls) { playerHand.Add(card.Card); } }
public GotCardsMessage(byte [] b, GameRules rules) : base(b) { Validate(rules); Card c = null; int cards = (int)(msg[1]); _cards = new CardCollection(cards); int msgctr = 2; int id = 0; int col = 0; int num = 0; for (int ctr = 0; ctr < cards; ctr++) { id = (int)msg[msgctr + 3]; id <<= 8; id += (int)msg[msgctr + 4]; num = (int)msg[msgctr + 1]; col = (int)msg[msgctr]; if (1 == ((int)(msg[msgctr + 2]))) { c = new Card(CardNumber.Wild, (CardColor)col, id); c.Number = (CardNumber)num; } else { c = new Card((CardNumber)num, (CardColor)col, id); } _cards.Add(c); msgctr += 5; } }
public override void Load(BinaryReader reader, long length) { Categories.Clear(); var fileStartPos = reader.BaseStream.Position; var numCategories = reader.ReadInt64(); for (var i = 0; i < numCategories; i++) { var cardListOffset = reader.ReadInt64(); var tempOffset = reader.BaseStream.Position; reader.BaseStream.Position = fileStartPos + cardListOffset; var cardCount = reader.ReadInt16(); var cardCollection = new CardCollection(); for (var j = 0; j < cardCount; j++) { cardCollection.Add(reader.ReadInt16()); } Categories.Add(cardCollection); reader.BaseStream.Position = tempOffset; } }
private CardCollection BuildNineThroughAceOfEachSuit() { var nineThroughAces = new List <IRank> { _rankFactory.GetRank(RankEnum.Ace), _rankFactory.GetRank(RankEnum.King), _rankFactory.GetRank(RankEnum.Queen), _rankFactory.GetRank(RankEnum.Jack), _rankFactory.GetRank(RankEnum.Ten), _rankFactory.GetRank(RankEnum.Nine), }; var suits = new List <ISuit> { _suitFactory.GetSuit(SuitEnum.Diamonds), _suitFactory.GetSuit(SuitEnum.Clubs), _suitFactory.GetSuit(SuitEnum.Hearts), _suitFactory.GetSuit(SuitEnum.Spades), }; var cardCollection = new CardCollection(); foreach (var suit in suits) { foreach (var rank in nineThroughAces) { cardCollection.Add(new Card(rank, suit)); } } return(cardCollection); }
private void ViewModelCollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { if (syncDisabled) { return; } syncDisabled = true; switch (e.Action) { case NotifyCollectionChangedAction.Add: foreach (var card in e.NewItems.OfType <CardViewModel>().Select(v => v.Card).OfType <Card>()) { cards.Add(card); } break; case NotifyCollectionChangedAction.Remove: foreach (var card in e.OldItems.OfType <CardViewModel>().Select(v => v.Card).OfType <Card>()) { cards.Remove(card); } break; case NotifyCollectionChangedAction.Reset: cards.Clear(); break; } syncDisabled = false; }
private void handleGetTopDiscardMessage(GetTopDiscardMessage m, ServerPlayer p) { if (!p.MyTurn) { p.Send(new ErrorMessage("ERROR: It is not your turn to get the top discard!")); return; //client sent invalid request! } if (_discard.ReadTopCard() == null) { SendAll(new ErrorMessage("Internal server error")); return; } if ((_discard.ReadTopCard().Number == CardNumber.Skip) && (!_firstDiscard))//skip card { p.Send(new ErrorMessage("ERROR: You asked for a skip card. This is an invalid move, and should have been caught by your client. Upgrade!")); return; //client sent invalid request } //remove card from discard Card c = _discard.RemoveTopCard(); p.PickedUpCard = true; p.GetHand().Add(c); CardCollection cc = new CardCollection(1); cc.Add(c); p.Send(new GotCardsMessage(cc)); SendAll(new UpdateDiscardMessage(_discard.ReadTopCard(), p, false)); SendAll(new GotDiscardMessage(p.PlayerID, c)); updateClientsStatuses(); }
private void handleGetTopDeckCardMessage(GetTopDeckCardMessage m, ServerPlayer p) { if (!p.MyTurn) { return; //client sent invalid request! } //remove card from deck Card c = _deck.RemoveCard(); //check to see if top deck card is null! if (_deck.IsTopCardNull()) { _deck.ShuffleAndAddUnused(_discard.RemoveAllButTopCard()); } //add to hand of client p.PickedUpCard = true; p.GetHand().Add(c); CardCollection cc = new CardCollection(1); cc.Add(c); p.Send(new GotCardsMessage(cc)); //notify the users SendAll(new GotDeckCardMessage(p.PlayerID)); updateClientsStatuses(); }
/// <summary> /// Handles the card changed packet /// </summary> /// <param name="inMsg">The message to decode</param> private void HandleCardChanged(NetIncomingMessage inMsg) { bool added = inMsg.ReadBoolean(); bool hasValue = inMsg.ReadBoolean(); inMsg.ReadPadBits(); if (hasValue) { CardRank rank = (CardRank)inMsg.ReadByte(); CardSuit suit = (CardSuit)inMsg.ReadByte(); PlayingCard card = new PlayingCard(rank, suit) { FaceUp = true }; if (added) { myHand.Add(card); OnHandCardAdded?.Invoke(this, card); } else { myHand.Discard(card); OnHandCardRemoved?.Invoke(this, card); } } }
public void CardCollection_AddTest() { CardCollection target = new CardCollection(); ColorettoCard card1 = new ColorettoCard(ColorettoCardColors.Blue); ColorettoCard card2 = new ColorettoCard(ColorettoCardColors.Brown); ColorettoCard card3 = new ColorettoCard(ColorettoCardColors.Gray); target = target.Add(card1); target = target.Add(card2); target = target.Add(card3); Assert.AreEqual<ColorettoCard>(card1, target[0]); Assert.AreEqual<ColorettoCard>(card2, target[1]); Assert.AreEqual<ColorettoCard>(card3, target[2]); }
public void GetEnumeratorShouldReturnAllElementsInCollection() { var cards = new List <Card> { new Card(CardSuit.Club, CardType.Ace), new Card(CardSuit.Spade, CardType.Ace), new Card(CardSuit.Diamond, CardType.Ten), new Card(CardSuit.Heart, CardType.Jack), new Card(CardSuit.Club, CardType.Nine), new Card(CardSuit.Spade, CardType.Nine) }; var collection = new CardCollection(); foreach (var card in cards) { collection.Add(card); } foreach (var card in collection) { Assert.IsTrue(cards.Contains(card), $"Card {card} not found in collection!"); } // Second enumeration var count = 0; foreach (var card in collection) { Assert.IsTrue(cards.Contains(card), $"Card {card} not found in collection!"); count++; } Assert.AreEqual(cards.Count, count); }
private void btnExcluirFuncionarios_Click(object sender, EventArgs e) { try { InstanciaWatchComm(); this._watchComm.OpenConnection(); CardCollection listCartoes = new CardCollection(); foreach (DataRow dr in dsSDKBioLite.dtFuncionarios) { TemplateCollection templateCollection = new TemplateCollection(); Template template = new Template(); Card card = new Card(); card.Code = dr["Matricula"].ToString(); card.Name = dr["Nome"].ToString(); if (!dr["Senha"].ToString().Equals("")) { card.PassWord = Int32.Parse(dr["Senha"].ToString()); } if (dr["Supervisor"].ToString().Equals("True")) { card.MasterCard = TypeMasterCard.Master; } foreach (DataRow drTemplate in dsSDKBioLite.dtTemplates) { if (drTemplate["Matricula"].ToString().Equals(card.Code)) { template = new Template(); template.DedoDigital = (TypeDedoDigital)Int32.Parse(drTemplate["Dedo"].ToString()); template.Digital = drTemplate["String"].ToString(); templateCollection.Add(template); } } card.Template = templateCollection; listCartoes.Add(card); } this._watchComm.eraseCardListBioLite(listCartoes); this._watchComm.CloseConnection(); ComandoRecepcionadoComSucesso(); } catch (Exception ex) { this._watchComm.CloseConnection(); MessageBox.Show(ex.Message, "Erro"); } }
public override void Undo() { location.Clear(); foreach (Card c in before.AllCards()) { location.Add(c); } }
public override void Execute() { foreach (Card c in location.AllCards()) { before.Add(c); } cg.SetDeck(deck, location, script); }
public void Played(Card card) { if (!_CardsPlayed.Contains(card)) { _CardsPlayed.Add(card); } _CardsResolved.Add(card); }
public void TestAlternatingColors( ) { CardCollection coll = new CardCollection( ); // An empty one is also alternating: Assert.AreEqual( coll.IsAlternatingColors( ), true ); coll.Add( new Card( Suit.Clubs, 10, true, null ) ); // So is a collection of only one element: Assert.AreEqual( coll.IsAlternatingColors( ), true ); // Then, add a few cards of alternating colors: coll.Add( new Card( Suit.Diamonds, 11, true, null ) ); coll.Add( new Card( Suit.Clubs, 7, true, null ) ); coll.Add( new Card( Suit.Diamonds, 11, true, null ) ); coll.Add( new Card( Suit.Spades, 7, true, null ) ); coll.Add( new Card( Suit.Hearts, 11, true, null ) ); coll.Add( new Card( Suit.Clubs, 7, true, null ) ); // This should hold: Assert.AreEqual( coll.IsAlternatingColors( ), true ); // Finally, remove a card in the middle: coll.RemoveAt( 2 ); // ... which should make it no longer alternating: Assert.AreEqual( coll.IsAlternatingColors( ), false ); }
public override void Execute() { foreach (Card c in locations.cardList.AllCards()) { unshuffled.Add(c); } locations.cardList.Shuffle(); script.WriteToFile("O:" + locations.cardList); }
public void AddCards(List <Card> cards) { CardCollection _cards = (CardCollection)this.Resources["cards"]; foreach (var card in cards) { _cards.Add(card); } }
public void CountShouldReturn1WhenOneCardIsAddedAndThenRemoved() { var collection = new CardCollection(); var card = Card.GetCard(CardSuit.Club, CardType.Ace); collection.Add(card); collection.Remove(card); Assert.Empty(collection); }
public void CountShouldReturn1WhenOneCardIsAddedAndThenRemoved() { var collection = new CardCollection(); var card = new Card(CardSuit.Club, CardType.Ace); collection.Add(card); collection.Remove(card); Assert.AreEqual(0, collection.Count); }
/// <summary> /// This method disables all cards in the players cards that are lower /// than the current AIs attacking card. Also it disables cards that have /// not been played yet /// </summary> private void DisableInvalidCardsInHands() { if (!playerAttacking) { // start with all disabled cards foreach (CardBox.CardBox cardBox in pnlPlayerCards.Controls) { cardBox.Enabled = false; } // start with empty collection cardsPlayedThisTurn.Clear(); if (pnlActiveCards.Controls.Count > 0) { attackingCard = ((CardBox.CardBox)pnlActiveCards.Controls[0]).Card; // add the defended cards to collection foreach (CardBox.CardBox cardBox in pnlDefended.Controls) { // add the defended cards cardsPlayedThisTurn.Add(cardBox.Card); } // enable players cards in the cardsPlayedThisTurn collection foreach (CardBox.CardBox cardBox in pnlPlayerCards.Controls) { // if the collection has this card then enable it in the players hand if (cardsPlayedThisTurn.Contains(cardBox.Card) && cardBox.Card > attackingCard) { cardBox.Enabled = true; } } // enable player cards higher than the current attacking card foreach (CardBox.CardBox cardBox in pnlPlayerCards.Controls) { defendingCard = cardBox.Card; // trump card or higher ranked card in same suit if (defendingCard > attackingCard) { //MessageBox.Show(cardBox.Card + " is greater than " + attackingCard); cardBox.Enabled = true; } } } } else { foreach (CardBox.CardBox cardBox in pnlPlayerCards.Controls) { cardBox.Enabled = true; } } }
public static CardCollection CreateEnemyCollection() { // Create enemy deck collection and return CardCollection enemyDeck = new CardCollection(); foreach (string c in EnemyDeck1) { enemyDeck.Add(CardData.CreateCardFromName(c)); } return enemyDeck; }
private CardCollection Clone(CardCollection source) { var recurseList = new CardCollection(CCType.VIRTUAL); foreach (var card in source.AllCards()) { recurseList.Add(card); } return(recurseList); }
public void Passed(Card card) { if (!this.IsTurnFinished) { _CardsPassed.Add(card); } else { _CardsPassedAfter.Add(card); } }
public void Received(Card card) { if (!this.IsTurnFinished) { _CardsReceived.Add(card); } else { _CardsReceivedAfter.Add(card); } }
public void AddListTest() { collection = new CardCollection(); List <Hanafuda> cards = new List <Hanafuda> { new Kwang(Month.April), new Kwang(Month.December) }; collection.Add(cards); Assert.AreEqual(collection[0], cards[0]); Assert.AreEqual(collection[1], cards[1]); }
private List <CardCollection> RightLook(int idx, int remainingLength) { if (idx < array.Count() && array[idx].Count > 0) { List <CardCollection> recurs; if (remainingLength != 1) { recurs = RightLook(idx + 1, remainingLength - 1); var ret = new List <CardCollection>(); foreach (var card in array[idx].AllCards()) { foreach (var downLine in recurs) { var tempList = new CardCollection(CCType.VIRTUAL); tempList.Add(card); foreach (var innerCard in downLine.AllCards()) { tempList.Add(innerCard); } ret.Add(tempList); } } return(ret); } else { var ret = new List <CardCollection>(); foreach (var card in array[idx].AllCards()) { var tempList = new CardCollection(CCType.VIRTUAL); tempList.Add(card); ret.Add(tempList); } return(ret); } } else { return(new List <CardCollection>()); } }
public void DefenderCards_Can_Beat_AttackerCards_Without_Trump() { var attackerCards = new CardCollection <BuraCard>(); var defenderCards = new CardCollection <BuraCard>(); attackerCards.Add(new BuraCard(CardSuit.Clubs, CardName.Seven)); attackerCards.Add(new BuraCard(CardSuit.Clubs, CardName.Queen)); attackerCards.Add(new BuraCard(CardSuit.Clubs, CardName.Eight)); defenderCards.Add(new BuraCard(CardSuit.Clubs, CardName.Ace)); defenderCards.Add(new BuraCard(CardSuit.Clubs, CardName.Ten)); defenderCards.Add(new BuraCard(CardSuit.Clubs, CardName.Nine)); var strategy = new BuraDefenseStrategy(); var tricks = strategy.Execute(attackerCards, defenderCards); foreach (var trick in tricks) { Assert.True(trick.Completed); } }
public void Add(Card c) { switch (locIdentifier) { case "top": cardList.Add(c); break; case "bottom": cardList.AddBottom(c); break; case "-1": // SHOULD THIS THROW EXCEPTION INSTEAD? cardList.Add(c); break; default: cardList.Add(c, Int32.Parse(locIdentifier)); break; } }
internal static CardCollection BitsToCardCollection(int source) { var result = new CardCollection(); for (int i = 0; i < 32; i++) { int card = (1 << i); if ((source & card) != 0) result.Add(BitsToCard(card)); } return result; }
public void ContainsShouldReturnTrueForAllCardsAfterAddingThem() { var collection = new CardCollection(); foreach (CardSuit cardSuitValue in Enum.GetValues(typeof(CardSuit))) { foreach (CardType cardTypeValue in Enum.GetValues(typeof(CardType))) { var card = new Card(cardSuitValue, cardTypeValue); collection.Add(card); } } foreach (CardSuit cardSuitValue in Enum.GetValues(typeof(CardSuit))) { foreach (CardType cardTypeValue in Enum.GetValues(typeof(CardType))) { var card = new Card(cardSuitValue, cardTypeValue); Assert.IsTrue(collection.Contains(card)); } } }
public void CardCollection_TooManyPiles() { CardCollection target = new CardCollection(); ColorettoCard card1 = new ColorettoCard(ColorettoCardColors.Blue); ColorettoCard card2 = new ColorettoCard(ColorettoCardColors.Brown); ColorettoCard card3 = new ColorettoCard(ColorettoCardColors.Gray); ColorettoCard card4 = new ColorettoCard(ColorettoCardColors.Green); ColorettoCard card5 = new ColorettoCard(ColorettoCardColors.Orange); ColorettoCard wild = new ColorettoCard(ColorettoCardTypes.Wild); target = target.Add(card1); target = target.Add((ColorettoCard)card1.Clone()); target = target.Add((ColorettoCard)card1.Clone()); target = target.Add(wild); target = target.Add(card2); target = target.Add((ColorettoCard)card2.Clone()); target = target.Add((ColorettoCard)card2.Clone()); target = target.Add(card3); target = target.Add(card4); Assert.AreEqual<int>(16, target.Score); }
protected override ChoiceResult Decide_SecretChamber(Choice choice) { if (choice.Text == "Choose order of cards to put back on your deck") { // Order all the cards IEnumerable<Card> cardsToReturn = this.FindBestCardsToDiscard(choice.Cards, choice.Cards.Count()); // Try to save 1 Curse if we can if (choice.CardTriggers[0].CardType == Cards.Prosperity.TypeClass.Mountebank) { cardsToReturn = cardsToReturn.Take(3); if (cardsToReturn.ElementAt(0).CardType == Cards.Universal.TypeClass.Curse) return new ChoiceResult(new CardCollection(cardsToReturn.Skip(1))); if (cardsToReturn.ElementAt(1).CardType == Cards.Universal.TypeClass.Curse) return new ChoiceResult(new CardCollection() { cardsToReturn.ElementAt(0), cardsToReturn.ElementAt(2)}); } // Try to not put Treasure cards onto our deck, even if that means putting Action cards there else if (choice.CardTriggers[0].CardType == Cards.Seaside.TypeClass.PirateShip) { CardCollection pirateShipCards = new CardCollection(cardsToReturn.Where(c => (c.Category & Category.Treasure) != Category.Treasure)); if (pirateShipCards.Count < 2) pirateShipCards.AddRange(cardsToReturn.Where(c => (c.Category & Category.Treasure) != Category.Treasure).Take(2 - pirateShipCards.Count)); return new ChoiceResult(pirateShipCards); } return new ChoiceResult(new CardCollection(cardsToReturn.Take(2))); } else { CardCollection scCards = new CardCollection(); foreach (Card card in choice.Cards) { if (card.Category == Category.Curse || ((card.Category & Category.Victory) == Category.Victory && (card.Category & Category.Treasure) != Category.Treasure) || (card.CardType == Cards.Universal.TypeClass.Copper && this.RealThis.InPlay[Cards.Intrigue.TypeClass.Coppersmith].Count == 0) || (this.RealThis.Actions == 0 && (card.Category & Category.Treasure) != Category.Treasure)) scCards.Add(card); } return new ChoiceResult(scCards); } }
public void GetEnumeratorShouldReturnAllElementsInCollection() { var cards = new List<Card> { new Card(CardSuit.Club, CardType.Ace), new Card(CardSuit.Spade, CardType.Ace), new Card(CardSuit.Diamond, CardType.Ten), new Card(CardSuit.Heart, CardType.Jack), new Card(CardSuit.Club, CardType.Nine), new Card(CardSuit.Spade, CardType.Nine) }; var collection = new CardCollection(); foreach (var card in cards) { collection.Add(card); } foreach (var card in collection) { Assert.IsTrue(cards.Contains(card), $"Card {card} not found in collection!"); } // Second enumeration var count = 0; foreach (var card in collection) { Assert.IsTrue(cards.Contains(card), $"Card {card} not found in collection!"); count++; } Assert.AreEqual(cards.Count, count); }
public override CardCollection CardStack() { CardCollection cc = new CardCollection(); if (_SetAsideCard != null) cc.Add(_SetAsideCard); cc.Add(this); return cc; }
public void CardCollection_BasicScoreCheck() { CardCollection target = new CardCollection(); ColorettoCard card1 = new ColorettoCard(ColorettoCardColors.Blue); ColorettoCard card2 = new ColorettoCard(ColorettoCardColors.Brown); ColorettoCard card3 = new ColorettoCard(ColorettoCardColors.Gray); target = target.Add(card1); Assert.AreEqual<int>(1, target.Score); target = target.Add(card2); Assert.AreEqual<int>(2, target.Score); target = target.Add(card3); Assert.AreEqual<int>(3, target.Score); target = target.Add((ColorettoCard)card1.Clone()); Assert.AreEqual<int>(5, target.Score); target = target.Add((ColorettoCard)card1.Clone()); Assert.AreEqual<int>(8, target.Score); target = target.Add((ColorettoCard)card2.Clone()); Assert.AreEqual<int>(10, target.Score); }
public void CardCollection_WildCardScores() { CardCollection target = new CardCollection(); ColorettoCard card1 = new ColorettoCard(ColorettoCardColors.Blue); ColorettoCard card2 = new ColorettoCard(ColorettoCardColors.Brown); ColorettoCard card3 = new ColorettoCard(ColorettoCardColors.Gray); ColorettoCard wild = new ColorettoCard( ColorettoCardTypes.Wild); target = target.Add(card1); target = target.Add((ColorettoCard)card1.Clone()); target = target.Add((ColorettoCard)card1.Clone()); target = target.Add(wild); target = target.Add(card2); target = target.Add(card3); Assert.AreEqual<int>(12, target.Score); }
/// <summary> /// Detects and recognizes cards from source image /// </summary> /// <param name="source">Source image to be scanned</param> /// <returns>Recognized Cards</returns> public CardCollection Recognize(Bitmap source, string filePath, int id, int minSize, Rectangle suitRect, Rectangle rankRect ) { CardCollection collection = new CardCollection(); //Collection that will hold cards Bitmap temp = source.Clone() as Bitmap; //Clone image to keep original image FiltersSequence seq = new FiltersSequence(); seq.Add(Grayscale.CommonAlgorithms.BT709); //First add grayScaling filter seq.Add(new OtsuThreshold()); //Then add binarization(thresholding) filter temp = seq.Apply(source); // Apply filters on source image //if (!string.IsNullOrEmpty(fileName)) //{ // temp.Save(fileName, ImageFormat.Bmp); //} //Extract blobs from image whose size width and height larger than 150 BlobCounter extractor = new BlobCounter(); extractor.FilterBlobs = true; extractor.MinWidth = extractor.MinHeight = minSize;//TODO card size //extractor.MaxWidth = extractor.MaxHeight = 70;//TODO card size extractor.ProcessImage(temp); //Will be used transform(extract) cards on source image //QuadrilateralTransformation quadTransformer = new QuadrilateralTransformation(); foreach (Blob blob in extractor.GetObjectsInformation()) { var cardImg = source.Clone(blob.Rectangle, PixelFormat.DontCare); Card card = new Card(cardImg); //Create Card Object Bitmap suitBmp = card.GetPart(suitRect); char color = ScanColor(suitBmp); //Scan color seq.Clear(); seq.Add(Grayscale.CommonAlgorithms.BT709); seq.Add(new OtsuThreshold()); suitBmp = seq.Apply(suitBmp); card.Suit = ScanSuit(suitBmp, color); //Scan suit of face card Bitmap rankBmp = card.GetPart(rankRect); seq.Clear(); seq.Add(Grayscale.CommonAlgorithms.BT709); seq.Add(new OtsuThreshold()); rankBmp = seq.Apply(rankBmp); //var ext = new BlobsFiltering(0, 0, 40, 40); //ext.ApplyInPlace(rankBmp); card.Rank = ScanRank(rankBmp); //Scan Rank of non-face card //if (card.Rank == Rank.NOT_RECOGNIZED) //{ // if (!string.IsNullOrEmpty(filePath)) // { // while (File.Exists(filePath + id + ".bmp")) // id++; // top.Save(filePath + id + ".bmp", ImageFormat.Bmp); // } //} if(card.Rank != Rank.NOT_RECOGNIZED && card.Suit != Suit.NOT_RECOGNIZED) collection.Add(card); //Add card to collection } collection.SortByRank(); return collection; }
public override void Play(Player player) { base.Play(player); SupplyCollection availableSupplies = new SupplyCollection(player._Game.Table.Supplies.Where(kvp => kvp.Value.Randomizer != null && kvp.Value.Randomizer.GroupMembership != Group.None)); CardCollection cards = new CardCollection(); Choice choice = new Choice("Name a card", this, availableSupplies, player, false); foreach (Supply supply in player._Game.Table.Supplies.Values.Union(player._Game.Table.SpecialPiles.Values)) { foreach (Type type in supply.CardTypes) { if (!choice.Supplies.Any(kvp => kvp.Value.CardType == type)) cards.Add(Card.CreateInstance(type)); } } cards.Sort(); choice.AddCards(cards); ChoiceResult result = player.MakeChoice(choice); ICard namedCard = null; if (result.Supply != null) namedCard = result.Supply; else namedCard = result.Cards[0]; player._Game.SendMessage(player, this, namedCard); if (player.CanDraw) { player.Draw(DeckLocation.Revealed); if (player.Revealed[namedCard.CardType].Count > 0) { player.AddCardsToHand(DeckLocation.Revealed); } else { player.AddCardsToDeck(player.RetrieveCardsFrom(DeckLocation.Revealed), DeckPosition.Top); } } }
public bool IsStraight(out CardCollection winningCards) { checkCardList(); // Get a copy of the card list CardCollection cardList = new CardCollection(_cardList); winningCards = new CardCollection(); // Sort the cards by value cardList.Sort(); // if there is an ace in the deck, it got moved to the end by the sort // so we need to insert a new "ace" in the sorted deck (with a value of 1) in the beginning position foreach (Card card in cardList) { if (card.Value == (int)Rank.Ace) { cardList.Insert(0, new Card(card.Rank, card.Suit)); break; } } int cardsInARow = 1; // Check each card and the next one for (int i = 0; i < cardList.Count; i++) { // Add the current card to the winning cards index, just in case it's part of a straight winningCards.Add(cardList[i]); // If this is the last card, check to see if it is part of a straight if (i == cardList.Count - 1) { if (cardList[i].IsOneGreaterThan(cardList[i - 1])) { cardsInARow++; } else winningCards.Clear(); } else { // If this card is the same as the next one, ignore it if (cardList[i].Value == cardList[i + 1].Value) { // remove the card we just added winningCards.Remove(cardList[i]); continue; } // Check to see if this card is exactly one less than the next card if (cardList[i].IsOneLessThan(cardList[i + 1])) { cardsInARow++; } else { // if we already have a straight (5 cards) stop checking for more straights if (cardsInARow >= 5) break; else { cardsInARow = 1; winningCards.Clear(); } } } } // Trim off any excess cards that are not the highest straight, and return true // Example: if you have A 2 3 4 5 6, the ace will be cut off and 2 3 4 5 6 will be preserved if (winningCards.Count >= 5) { if (winningCards.Count > 5) winningCards.RemoveRange(0, winningCards.Count - 5); return true; } else { winningCards = null; return false; } }
public bool IsFlush(out CardCollection winningCards) { checkCardList(); CardCollection cardList = new CardCollection(_cardList); CardCollection clubs = new CardCollection(); CardCollection diamonds = new CardCollection(); CardCollection hearts = new CardCollection(); CardCollection spades = new CardCollection(); foreach (Card card in cardList) { switch (card.Suit) { case Suit.Clubs: clubs.Add(card); break; case Suit.Diamonds: diamonds.Add(card); break; case Suit.Hearts: hearts.Add(card); break; case Suit.Spades: spades.Add(card); break; default: break; } } if (clubs.Count >= 5) { winningCards = clubs; winningCards.Sort(); return true; } if (diamonds.Count >= 5) { winningCards = diamonds; winningCards.Sort(); return true; } if (hearts.Count >= 5) { winningCards = hearts; winningCards.Sort(); return true; } if (spades.Count >= 5) { winningCards = spades; winningCards.Sort(); return true; } winningCards = null; return false; }
public bool CheckHighestPairConfiguration(out Hand hand) { checkCardList(); // make a copy //List<Card> cardList = new List<Card>(_cardList); CardCollection cardList = new CardCollection(_cardList); cardList.Sort(); // this is a list of cards that match the key value Dictionary<int, CardCollection> matches = new Dictionary<int, CardCollection>(); int numPairs = 0; int numThrees = 0; int numFours = 0; // Construct the dictionary foreach (Card card in cardList) { if (matches.ContainsKey(card.Value)) matches[card.Value].Add(card); else matches.Add(card.Value, new CardCollection(new Card[] { card })); //matches.Add(card.Value, new List<Card>(new Card[] { card })); } // Determine the number of pairs, threes, and fours //foreach (List<Card> cardPairs in matches.Values) foreach (CardCollection cardPairs in matches.Values) { if (cardPairs.Count == 2) numPairs++; if (cardPairs.Count == 3) numThrees++; if (cardPairs.Count == 4) numFours++; } //List<Card> resultCards = new List<Card>(); CardCollection resultCards = new CardCollection(); // Okay, here comes the real logic // One Pair and One Pair Only if (numPairs == 1 && numThrees == 0 && numFours == 0) { // Continue with the assumption that we'll only find one pair foreach (int cardValue in matches.Keys) { if (matches[cardValue].Count == 2) // this is our pair { resultCards.AddRange(matches[cardValue]); break; } } // Also add the next highest card for (int highCard = cardList.Count - 1; highCard >= 0; highCard--) { if (!resultCards.Contains(cardList[highCard])) { // Add the next highest card from the sorted list and break resultCards.Add(cardList[highCard]); break; } } // Construct the Best Hand for one pair and return true //hand = new BestHand(resultCards, HandType.OnePair); hand = new Hand(resultCards, Combination.OnePair); return true; } // Two Pair and two pair only else if (numPairs >= 2 && numThrees == 0 && numFours == 0) { int numPairsFound = 0; // Continue with the assumption that we'll only find two pairs foreach (int cardValue in new Stack<int>(matches.Keys)) { if (matches[cardValue].Count == 2) // this is our pair { resultCards.AddRange(matches[cardValue]); numPairs++; if (numPairsFound >= 2) break; } } // Also add the next highest card for (int highCard = cardList.Count - 1; highCard >= 0; highCard--) { if (!resultCards.Contains(cardList[highCard])) { // Add the next highest card from the sorted list and break resultCards.Add(cardList[highCard]); break; } } // Construct the Best Hand for one pair and return true //hand = new BestHand(resultCards, HandType.TwoPair); hand = new Hand(resultCards, Combination.TwoPair); return true; } // Three of a kind only else if (numPairs == 0 && numThrees >= 1 && numFours == 0) { foreach (int cardValue in new Stack<int>(matches.Keys)) { if (matches[cardValue].Count == 3) // this is our highest 3 { resultCards.AddRange(matches[cardValue]); break; } } // Also add the next highest card for (int highCard = cardList.Count - 1; highCard >= 0; highCard--) { if (!resultCards.Contains(cardList[highCard])) { // Add the next highest card from the sorted list and break resultCards.Add(cardList[highCard]); break; } } // Construct the Best Hand for one pair and return true //hand = new BestHand(resultCards, HandType.ThreeOfAKind); hand = new Hand(resultCards, Combination.ThreeOfAKind); return true; } // four of a kind only else if (numPairs <= 1 && numThrees <= 1 && numFours == 1) { foreach (int cardValue in new Stack<int>(matches.Keys)) { if (matches[cardValue].Count == 4) // this is the 4 { resultCards.AddRange(matches[cardValue]); break; } } // Also add the next highest card for (int highCard = cardList.Count - 1; highCard >= 0; highCard--) { if (!resultCards.Contains(cardList[highCard])) { resultCards.Add(cardList[highCard]); break; } } // Construct the Best Hand for one pair and return true //hand = new BestHand(resultCards, HandType.FourOfAKind); hand = new Hand(resultCards, Combination.FourOfAKind); return true; } // Full house only else if (numPairs >= 1 && numThrees == 1 && numFours == 0) { foreach (int cardValue in new Stack<int>(matches.Keys)) { if (matches[cardValue].Count == 3) // this is the 3 in the full house resultCards.AddRange(matches[cardValue]); if (matches[cardValue].Count == 2) // this is the 2 resultCards.AddRange(matches[cardValue]); if (resultCards.Count >= 5) break; } // Construct the Best Hand for one pair and return true //hand = new BestHand(resultCards, HandType.FullHouse); hand = new Hand(resultCards, Combination.FullHouse); return true; } else { // Just return the high card //List<Card> highCard = new List<Card>(); CardCollection highCard = new CardCollection(); highCard.Add(cardList[cardList.Count - 1]); //hand = new BestHand(highCard, HandType.HighCard); hand = new Hand(highCard, Combination.HighCard); return false; } }
public void CardCollection_UnEqualityTest() { CardCollection left = new CardCollection(); ColorettoCard card1 = new ColorettoCard(ColorettoCardColors.Blue); ColorettoCard card2 = new ColorettoCard(ColorettoCardColors.Brown); ColorettoCard card3 = new ColorettoCard(ColorettoCardColors.Gray); left = left.Add(card1); left = left.Add(card2); left = left.Add(card3); CardCollection right = new CardCollection(); card1 = new ColorettoCard(ColorettoCardColors.Blue); card2 = new ColorettoCard(ColorettoCardColors.Blue); card3 = new ColorettoCard(ColorettoCardColors.Gray); right = right.Add(card1); right = right.Add(card2); right = right.Add(card3); bool areEqual = left == right; Assert.IsFalse(areEqual); }
public void CountShouldReturnCorrectValueAfterAddingAllCards() { var collection = new CardCollection(); foreach (CardSuit cardSuitValue in Enum.GetValues(typeof(CardSuit))) { foreach (CardType cardTypeValue in Enum.GetValues(typeof(CardType))) { var card = new Card(cardSuitValue, cardTypeValue); collection.Add(card); } } Assert.AreEqual(24, collection.Count); }
public override void Setup(Game game, Supply supply) { base.Setup(game, supply); CardCollection cards = new CardCollection(); for (int i = 0; i < 10; i++) { cards.Add(new AbandonedMine()); cards.Add(new RuinedLibrary()); cards.Add(new RuinedMarket()); cards.Add(new RuinedVillage()); cards.Add(new Survivors()); } Utilities.Shuffler.Shuffle<Card>(cards); supply.AddTo(cards.Take(10 * (game.Players.Count - 1))); }
public void CountShouldReturn1WhenOneCardIsAddedAndThenRemoved() { var collection = new CardCollection(); var card = new Card(CardSuit.Club, CardType.Ace); collection.Add(card); collection.Remove(card); Assert.AreEqual(0, collection.Count); }
private void CardEffects(Player player) { // Perform attack on every player IEnumerator<Player> enumerator = player._Game.GetPlayersStartingWithEnumerator(player); enumerator.MoveNext(); CardCollection trashed = new CardCollection(); while (enumerator.MoveNext()) { Player attackee = enumerator.Current; // Skip if the attack is blocked (Moat, Lighthouse, etc.) // The on-buy Attack can't be blocked, so make sure the player is in the dictionary first if (this.IsAttackBlocked.ContainsKey(attackee) && this.IsAttackBlocked[attackee]) continue; attackee.Draw(2, DeckLocation.Revealed); Boolean gainCopper = false; if (attackee.Revealed[Cards.Category.Treasure].Count == 0) gainCopper = true; CardCollection treasuresSilverGold = attackee.Revealed[c => c.CardType == Universal.TypeClass.Silver || c.CardType == Universal.TypeClass.Gold]; Choice choice = new Choice(String.Format("Choose a Treasure card of {0} to trash", attackee), this, treasuresSilverGold, attackee); ChoiceResult result = player.MakeChoice(choice); if (result.Cards.Count > 0) { Card trashCard = attackee.RetrieveCardFrom(DeckLocation.Revealed, result.Cards[0]); attackee.Trash(trashCard); trashed.Add(trashCard); } attackee.DiscardRevealed(); if (gainCopper) attackee.Gain(player._Game.Table.Copper); } // Gain all trashed Silver & Golds foreach (Card card in trashed) player.Gain(player._Game.Table.Trash, card); }
public override void Play(Player player) { base.Play(player); SupplyCollection availableSupplies = new SupplyCollection(player._Game.Table.Supplies.Where(kvp => kvp.Value.Randomizer != null && kvp.Value.Randomizer.GroupMembership != Group.None)); CardCollection cards = new CardCollection(); Choice choice = new Choice("Name a card", this, availableSupplies, player, false); foreach (Supply supply in player._Game.Table.Supplies.Values.Union(player._Game.Table.SpecialPiles.Values)) { foreach (Type type in supply.CardTypes) { if (!choice.Supplies.Any(kvp => kvp.Value.CardType == type)) cards.Add(Card.CreateInstance(type)); } } choice.AddCards(cards); ChoiceResult result = player.MakeChoice(choice); ICard namedCard = null; if (result.Supply != null) namedCard = result.Supply; else namedCard = result.Cards[0]; player._Game.SendMessage(player, this, namedCard); Card foundCard = null; player.BeginDrawing(); while (player.CanDraw) { player.Draw(DeckLocation.Revealed); Card lastRevealed = player.Revealed.Last(); if ((lastRevealed.Category & Cards.Category.Victory) == Cards.Category.Victory && namedCard.Name != lastRevealed.Name) { foundCard = lastRevealed; break; } } player.EndDrawing(); if (foundCard != null) foundCard = player.RetrieveCardFrom(DeckLocation.Revealed, foundCard); player.DiscardRevealed(); if (foundCard != null) { player.Trash(foundCard); Cost trashedCardCost = player._Game.ComputeCost(foundCard); SupplyCollection gainableSupplies = player._Game.Table.Supplies.FindAll(supply => supply.CanGain() && (supply.Category & Cards.Category.Victory) == Cards.Category.Victory && supply.CurrentCost <= (trashedCardCost + new Coin(3))); Choice choiceGain = new Choice("Gain a Victory card", this, gainableSupplies, player, false); ChoiceResult resultGain = player.MakeChoice(choiceGain); if (resultGain.Supply != null) player.Gain(resultGain.Supply); } }
public override void Setup(Game game, Supply supply) { base.Setup(game, supply); supply.Empty(); CardCollection cards = new CardCollection(); cards.Add(new DameAnna()); cards.Add(new DameJosephine()); cards.Add(new DameMolly()); cards.Add(new DameNatalie()); cards.Add(new DameSylvia()); cards.Add(new SirBailey()); cards.Add(new SirDestry()); cards.Add(new SirMartin()); cards.Add(new SirMichael()); cards.Add(new SirVander()); Utilities.Shuffler.Shuffle<Card>(cards); supply.AddTo(cards); }
private CardCollection GetSelectableCards(CleaningUpEventArgs e) { CardCollection allInPlayCards = new CardCollection(); allInPlayCards.AddRange(e.CardsMovements.Where(cm => ((cm.Card.Category & Cards.Category.Action) == Cards.Category.Action) && cm.CurrentLocation == DeckLocation.InPlay && (cm.Destination == DeckLocation.SetAside || cm.Destination == DeckLocation.Discard)).Select(cm => cm.Card)); // This is used to separate the In Play from the Set Aside for the Choice.MakeChoice call allInPlayCards.Add(new Universal.Dummy()); allInPlayCards.AddRange(e.CardsMovements.Where(cm => ((cm.Card.Category & Cards.Category.Action) == Cards.Category.Action) && cm.CurrentLocation == DeckLocation.SetAside && cm.Destination == DeckLocation.Discard).Select(cm => cm.Card)); if (allInPlayCards.FirstOrDefault() is Universal.Dummy) allInPlayCards.RemoveAt(0); if (allInPlayCards.LastOrDefault() is Universal.Dummy) allInPlayCards.RemoveAt(allInPlayCards.Count - 1); return allInPlayCards; }
public override void Play(Player player) { base.Play(player); // Perform attack on every player IEnumerator<Player> enumerator = player._Game.GetPlayersStartingWithEnumerator(player); enumerator.MoveNext(); CardCollection trashed = new CardCollection(); while (enumerator.MoveNext()) { Player attackee = enumerator.Current; // Skip if the attack is blocked (Moat, Lighthouse, etc.) if (this.IsAttackBlocked[attackee]) continue; attackee.Draw(2, DeckLocation.Revealed); CardCollection treasures = attackee.Revealed[Category.Treasure]; Choice choice = new Choice(String.Format("Choose a Treasure card of {0} to trash", attackee), this, treasures, attackee); ChoiceResult result = player.MakeChoice(choice); if (result.Cards.Count > 0) { Card trashCard = attackee.RetrieveCardFrom(DeckLocation.Revealed, result.Cards[0]); attackee.Trash(trashCard); trashed.Add(trashCard); } attackee.DiscardRevealed(); } Choice keepCards = new Choice("Choose which cards you'd like to gain from being trashed.", this, trashed, player, true, 0, trashed.Count); ChoiceResult keptCards = player.MakeChoice(keepCards); foreach (Card card in keptCards.Cards) player.Gain(player._Game.Table.Trash, card); }