/// <summary>
/// Configures the specified IoC container with the type resolutions from this library.
/// </summary>
public void Configure(IServiceLocator container)
{
var cardComparer = new CardComparer();
container.RegisterInstance<IComparer<Card>>(cardComparer);
var highCardComparer = new HighCardComparer(cardComparer);
var handComparer = new HandComparer(
highCardComparer,
new PairComparer(highCardComparer),
new TwoPairComparer(),
new ThreeOfAKindComparer(highCardComparer),
new StraightComparer(),
new FlushComparer(highCardComparer),
new FullHouseComparer(highCardComparer),
new FourOfAKindComparer(highCardComparer),
new StraightFlushComparer());
container.RegisterInstance<IHandComparer>(handComparer);
container.RegisterInstance<Func<List<Card>, IHand>>(
cards => new Hand(
cards,
cardComparer,
handComparer));
container.RegisterInstance<Func<ICollection<IPlayer>, IGame>>(
players => new Game(
container.ResolveType<IDeckFactory>().CreateStandardDeck(),
players,
container.ResolveType<IComparer<IPlayer>>(),
container.ResolveType<Func<List<Card>, IHand>>()));
}
static void MainXXX()
{
//TESTING ZONE
Console.WriteLine("=== TEST ZONE ===");
string path = Environment.CurrentDirectory + @"..\..\..\..\Resorces\waste.csv";
Console.WriteLine(path);
Deck Talia = new Deck(new CardDAO(path));
Talia.Shuffle();
IComparer <Card> comparer = new CardComparer();
int result = comparer.Compare(Talia.CardDeck[0], Talia.CardDeck[1]);
Console.WriteLine($"{Talia.CardDeck[0].Degradability} : {Talia.CardDeck[1].Degradability} --> {result}");
Talia.CardDeck.Sort(comparer);
foreach (var card in Talia.CardDeck)
{
Console.WriteLine($"{card.CardName}, {card.Degradability}");
}
Talia.CardDeck.Sort();
foreach (var card in Talia.CardDeck)
{
Console.WriteLine($"{card.CardName}, {card.TotalStatSum}");
}
Deck allCadrds = new Deck(new CardDAO(Environment.CurrentDirectory + @"..\..\..\..\Resorces\waste.csv"));
SerializeToXml(allCadrds.CardDeck, Environment.CurrentDirectory + @"..\..\..\..\Resorces\waste.xml");
List <Card> deserializedCards = DeserializeFromXml(Environment.CurrentDirectory + @"..\..\..\..\Resorces\waste.xml");
Console.WriteLine(deserializedCards[0]);
//TESTING ZONE END
}
private bool IsCurrentMaxCardInPlayingColor(Card targetCard)
{
CardComparer comparer = new CardComparer(_playingManager.CurrentAnnouncement.Type);
bool foundBigger = false;
foreach (Card remCard in _playingManager.RemainingCards)
{
if (targetCard.CardColor == remCard.CardColor)
{
if (comparer.Compare(targetCard, remCard) < 0)
{
foundBigger = true;
break;
}
}
}
if (!foundBigger)
{
foreach (Card remCard in _playingManager.CurrentHand)
{
if (targetCard.CardColor == remCard.CardColor)
{
if (comparer.Compare(targetCard, remCard) < 0)
{
foundBigger = true;
break;
}
}
}
}
return(!foundBigger);
}
void Start()
{
comparer = new CardComparer(CardComparerCallback);
InitCards();
remainingPairs.Value = cards.Length / 2;
pairCounter = new PairCounter(remainingPairs, OnGameOver);
}
public List <Card> CompareListTest(List <Card> CardsToFind, Dictionary <string, int> Collection)
{
List <Card> result = CardComparer.CompareList(CardsToFind, Collection);
return(result);
// TODO: add assertions to method CardComparerTest.CompareListTest(List`1<Card>, Dictionary`2<String,Int32>)
}
public void DistinctOnTwoCardsReturnsLenghtOf1()
{
var cards = new List<Card>() { new Card(CardSuit.Diamond, CardType.King), new Card(CardSuit.Diamond, CardType.King) };
var comparer = new CardComparer();
cards = cards.Distinct(comparer).ToList();
Assert.AreEqual(1, cards.Count);
}
public void Setup()
{
gamePhaseMock = new Mock <IGamePhase>();
gamePhaseMock.Setup(e => e.GetRequiredColor()).Returns('D');
cardComparer = new CardComparer("C")
{
requiredColor = 'D'
};
}
public void SortCards(IPlayer myself, Func <Card, int> sortingFunc)
{
IComparer <Card> comparer = new CardComparer(this, myself.HandCards, sortingFunc);
List <Card> sortedCards = new List <Card>(myself.HandCards.OrderByDescending(x => x, comparer));
FieldInfo field = myself.GetType().GetField("_handCards", BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.Instance);
List <Card> playerHand = (List <Card>)field.GetValue(myself);
playerHand.Clear();
playerHand.AddRange(sortedCards);
}
private CardComparer GetCardComparer()
{
if (!StickSuit.HasValue)
{
var msg = "Can't compare cards without a StickSuit!";
Log.Error(msg);
throw new InvalidOperationException(msg);
}
var cardComparer = new CardComparer(PlayType, StickSuit.Value);
return(cardComparer);
}
public GameController()
{
GameDeck = new Deck(new CardDAO(Environment.CurrentDirectory + @"..\..\..\..\Resorces\waste.csv"));
GameDeck.Shuffle();
TemporaryHand = new Hand();
Player1 = new Player("Player1", true);
Player1.Hand.GetHand(GameDeck);
Player2 = new Player("Player2");
Player2.Hand.GetHand(GameDeck);
Comparer = new CardComparer();
View = new ViewGarbage();
}
public void Should_Find_Hit()
{
var cardsToFind = new List <Card> {
new Card {
Name = "a", Quantity = 1
}
};
var collection = new Dictionary <string, int> {
{ "a", 1 }
};
var hits = CardComparer.CompareList(cardsToFind, collection);
hits.ShouldNotBeEmpty();
}
private void btnNewCard_Click(object sender, EventArgs e)
{
List<Card> cards = new List<Card>();
for (int i = 0; i < 5; i++)
{
cards.Add(new Card((Card.Suits)_random.Next(0, 3), (Card.Values)_random.Next(1, 13)));
}
txtCardsUnsorted.Text = WriteResult(cards);
CardComparer cardComparer = new CardComparer();
cards.Sort(cardComparer);
txtCardsSorted.Text = WriteResult(cards);
}
public void ExpectedDeckToReturnNDifferentCards(int count)
{
var deck = new Deck();
var cards = new List<Card>();
for (int card = 0; card < count; card++)
{
cards.Add(deck.GetNextCard());
}
var comparer = new CardComparer();
cards = cards.Distinct(comparer).ToList();
Assert.AreEqual(count, cards.Count);
}
public void WhenTwoCardsThenHigherIsBetter()
{
var cardComparer = new CardComparer();
int result = cardComparer.Compare("2C", "1C");
Assert.AreEqual(1, result);
result = cardComparer.Compare("TC", "1C");
Assert.AreEqual(1, result);
result = cardComparer.Compare("JC", "QC");
Assert.AreEqual(-1, result);
result = cardComparer.Compare("KC", "AH");
Assert.AreEqual(-1, result);
}
public static ISheet AddReports(this ISheet builder, List<Card> cards, List<List> lists, List<string> users)
{
var comparer = new CardComparer();
var groupped = cards.GroupBy(c => c.Labels, comparer);
//var rowNumber = 1;
foreach (var group in groupped)
{
// write project name
var name = "Egyéb";
var key = group.Key.FirstOrDefault();
if (key != null)
{
name = key.Name;
}
var tempCards = group.ToList();
foreach (var grouppedCard in tempCards)
{
var actual = grouppedCard.RemoveUnusedMembers(users);
if (actual.Members.Count > 1)
{
foreach (var member in actual.Members)
{
builder.AddCard(name, actual, member);
builder.AddSubtasks(actual);
//rowNumber = rowNumber + 1;
}
}
else
{
builder.AddCard(name, actual, actual.Members.FirstOrDefault());
builder.AddSubtasks(actual);
//rowNumber = rowNumber + 1;
}
}
}
return builder;
}
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);
}
public static IDocument AddReports(this IDocument builder, List<Card> cards, List<List> lists)
{
var comparer = new CardComparer();
var groupped = cards.GroupBy(c => c.Labels, comparer);
foreach (var group in groupped)
{
// write project name
var name = "Egyéb";
var key = group.Key.FirstOrDefault();
if (key != null)
{
name = key.Name;
}
builder.AddEle(new BreakLine(1));
builder.AddEle(Heading2.With(string.Format("{0}:", name)).WithStyle().Bold().Create());
builder.AddLists(group.ToList(), lists);
}
return builder;
}
public static IDocumentTagContextBuilder AddReports(this IDocumentTagContextBuilder builder, List<Card> cards, List<List> lists)
{
var comparer = new CardComparer();
var groupped = cards.GroupBy(c => c.Labels, comparer);
foreach (var group in groupped)
{
// write project name
var name = "Egyéb";
var key = group.Key.FirstOrDefault();
if (key != null)
{
name = key.Name;
}
builder.Paragraph(z => z.Bold.Text(String.Format("{0}:", name)))
.AddLists(group.ToList(), lists)
.EmptyLine();
}
return builder;
}
public void TestCleanup()
{
_target = null;
}
public Board()
{
this._byName = new Dictionary <string, Card>();
this._cardComparer = new CardComparer();
}
/// <summary>
/// Order cards by labels->list->position
/// </summary>
/// <param name="cards">Unordered cards</param>
/// <returns>Ordered cards</returns>
public static IEnumerable<Card> OrderCards(IEnumerable<Card> cards)
{
var comparer = new CardComparer();
var ordered = cards.OrderBy(c => c.Labels, comparer)
.ThenBy(c => c.IdList)
.ThenBy(c => c.Pos)
.ToList();
return ordered;
}
public void Sort()
{
CardComparer cardComparer = new CardComparer();
_cards.Sort(cardComparer);
}
private void OrderCardsAndCalculateLowForPlayers(List <Player> players, List <Card>[] lowCardListForEachPlayer, List <Card> lowCardListForBoard)
{
SortedSet <Card> bestLowHandSoFar = new SortedSet <Card> (new CardComparer());
BitArray winningPlayers = new BitArray(players.Count(), false);
bool doesPlayerTieOtherPlayers = false;
for (int i = 0; i < lowCardListForEachPlayer.Count(); i++)
{
SortedSet <Card> lowCardsForCurrentPlayer = new SortedSet <Card>(new CardComparer());
foreach (Card lowCard in lowCardListForEachPlayer[i])
{
if (!lowCardsForCurrentPlayer.Contains(lowCard))
{
lowCardsForCurrentPlayer.Add(lowCard);
}
}
foreach (Card lowCard in lowCardListForBoard)
{
if (!lowCardsForCurrentPlayer.Contains(lowCard))
{
lowCardsForCurrentPlayer.Add(lowCard);
}
}
if (lowCardsForCurrentPlayer.Count() >= 5)
{
if (bestLowHandSoFar.Count() > 0)
{
Card[] otherPlayersLowCards = new Card[bestLowHandSoFar.Count];
bestLowHandSoFar.CopyTo(otherPlayersLowCards);
Card[] currentPlayersLowCards = new Card[lowCardsForCurrentPlayer.Count];
lowCardsForCurrentPlayer.CopyTo(currentPlayersLowCards);
CardComparer crdCompare = new CardComparer();
bool isCurrentPlayerBest = false;
//start comparing the fifth card in both the arrays, thats what we care about.
for (int j = 4; j >= 0; j--)
{
int compareValue = crdCompare.Compare(otherPlayersLowCards[j], currentPlayersLowCards[j]);
if (compareValue > 0)
{
//Current players low cards are better(lesser rank). So it becomes the best hand.
isCurrentPlayerBest = true;
break;
}
else if (compareValue < 0)
{
break;
}
//continue if 0
if (j == 0)
{
doesPlayerTieOtherPlayers = true;
}
}
if (doesPlayerTieOtherPlayers)
{
winningPlayers.Set(i, true);
}
else if (isCurrentPlayerBest)
{
winningPlayers.SetAll(false);
winningPlayers.Set(i, true);
doesPlayerTieOtherPlayers = false;
}
}
else
{
bestLowHandSoFar = lowCardsForCurrentPlayer;
winningPlayers.Set(i, true);
doesPlayerTieOtherPlayers = false;
}
}
}
int k = 0;
if (doesPlayerTieOtherPlayers)
{
foreach (bool winning in winningPlayers)
{
if (winning)
{
players[k].NumberOfLowTieingHands++;
}
k++;
}
}
else
{
foreach (bool winning in winningPlayers)
{
if (winning)
{
players[k].NumberOfLowWinningHands++;
}
k++;
}
}
}
/// <summary>
/// Inits this instance.
/// </summary>
private void Init()
{
this.cards = new List <Card>();
this.comparer = new CardComparer();
}
