/*
* //TODO Recursion is required for this (to have X nested loops), so for now, we brute code GetStraight<T>
* //Unfortunately, in the occurence of a straight or
* public static IList<IList<T>> GetXConsecutive<T>(this IList<T> self, int x) where T : IGambleCard
* {
* List<List<T>>
* allStraights = new List<List<T>>();
* if (!self.HasXConsecutive(x))
* {
* return new List<IList<T>>();
* }
*
* Dictionary<GambleCardValue, IList<T>>
* occurences = self.GetValueOccurenceList();
*
* bool found = true;
* for (int i = 13 - (x-1); i >= 0; i--)
* {
* for (int j = i + (x-1); j >= i ; j--)
* {
* if (j < 0)
* {
* found = false;
* break;
* }
* GambleCardValue current = GambleCardExtended.CalculateGambleCardValue(j);
* if (occurences[current].Count <= 0)
* {
* found = false;
* break;
* }
* else
* {
* found = true;
* }
* }
* if (found)
* {
* }
* }
* //We dont need to sort since we start at ACE, go to King, and then loop back down to ACE
* //(We skip the last ace since we cant start with an Low-Ace, (we can with a High-Ace), because Low-Ace is the lowest card
*
* //Cant do an implicit conversion, and explicit didn't work last time i checked, but this does :D
* IList<IList<T>> ret = new List<IList<T>>(allStraights);
* return ret;
* }
*/
//Generic Gets
public static T GetHighCard <T>(this IGambleCardHand <T> self) where T : IGambleCard
{
if (self.Count <= 0)
{
return(default(T));
}
Dictionary <GambleCardFace, IList <T> > occurences = self.GetValueOccurenceList();
for (int i = 13; i > 0; i--)
{
GambleCardFace val = GambleCardExtended.CalculateGambleCardValue(i);
if (occurences[val].Count > 0)
{
return(occurences[val][0]);
}
}
return(default(T));
}
public static bool HasXConsecutive <T>(this IGambleCardHand <T> self, int x) where T : IGambleCard
{
if (x < 2)
{
//if x <= 1, then this is useless to call, still we return false
return(false);
}
Dictionary <GambleCardFace, int> occurences = self.GetValueOccurenceCount();
bool found = true;
for (int i = 0; i <= 13 - (x - 1); i++)
{
for (int j = i; j < i + x; j++)
{
if (j > 13)
{
found = false;
break;
}
GambleCardFace current = GambleCardExtended.CalculateGambleCardValue(j);
if (occurences[current] <= 0)
{
found = false;
break;
}
else
{
found = true;
}
}
if (found)
{
return(true);
}
}
return(found);
}
//We dont return a list of a list?
//Unlike other Gets, we only care about the best case scenario
public static IList <IList <T> > GetXOfAKind <T>(this IGambleCardHand <T> self, int x) where T : IGambleCard
{
Dictionary <GambleCardFace, IList <T> >
myOccurences = self.GetValueOccurenceList();
List <IList <T> >
myListOfKinds = new List <IList <T> >();
if (!self.HasXOfAKind(x))
{
return(new List <IList <T> >());
}
for (int i = 13; i > 0; i--)
{
GambleCardFace val = GambleCardExtended.CalculateGambleCardValue(i);
IList <T>
tempOccurenceList = myOccurences[val];
int occurences = tempOccurenceList.Count;
if (occurences >= x)
{
for (int j = 0; j < occurences; j++)
{
List <T>
myList = new List <T>();
for (int k = j; k < x + j && k < occurences; k++)
{
myList.Add(tempOccurenceList[k]);
}
if (myList.Count >= x)
{
myList.Sort(
delegate(T a, T b)
{
return(a.CompareTo(b));
}
);
myListOfKinds.Add(myList);
}
}
}
}
if (myListOfKinds.Count <= 0)
{
return(new List <IList <T> >());
}
myListOfKinds.Sort(
delegate(IList <T> a, IList <T> b)
{
int ret = 0;
for (int i = 0; i < a.Count && i < b.Count; i++)
{
ret = -a[i].CompareTo(b[i]);
if (ret != 0)
{
return(ret);
}
}
return(-a.Count.CompareTo(b.Count));
}
);
IList <IList <T> > returnList = (IList <IList <T> >)(myListOfKinds);
return(returnList);
}
public static IList <IList <T> > GetXConsecutive <T>(this IGambleCardHand <T> self) where T : IGambleCard
{
int x = 5;
List <IList <T> >
allStraights = new List <IList <T> >();
if (!self.HasXConsecutive(x))
{
return(new List <IList <T> >());
}
Dictionary <GambleCardFace, IList <T> >
occurences = self.GetValueOccurenceList();
bool found = true;
for (int i = 13 - (x - 1); i >= 0; i--)
{
for (int j = i + (x - 1); j >= i; j--)
{
if (j < 0)
{
found = false;
break;
}
GambleCardFace current = GambleCardExtended.CalculateGambleCardValue(j);
if (occurences[current].Count <= 0)
{
found = false;
break;
}
else
{
found = true;
}
}
if (found)
{
GambleCardFace
aVal = GambleCardExtended.CalculateGambleCardValue(i + (x - 1) - 0),
bVal = GambleCardExtended.CalculateGambleCardValue(i + (x - 1) - 1),
cVal = GambleCardExtended.CalculateGambleCardValue(i + (x - 1) - 2),
dVal = GambleCardExtended.CalculateGambleCardValue(i + (x - 1) - 3),
eVal = GambleCardExtended.CalculateGambleCardValue(i + (x - 1) - 4);
for (int a = 0; a < occurences[aVal].Count; a++)
{
for (int b = 0; b < occurences[bVal].Count; b++)
{
for (int c = 0; c < occurences[cVal].Count; c++)
{
for (int d = 0; d < occurences[dVal].Count; d++)
{
for (int e = 0; e < occurences[eVal].Count; e++)
{
List <T> temp = new List <T>();
temp.Add(occurences[aVal][a]);
temp.Add(occurences[bVal][b]);
temp.Add(occurences[cVal][c]);
temp.Add(occurences[dVal][d]);
temp.Add(occurences[eVal][e]);
allStraights.Add(temp);
}
}
}
}
}
}
}
//We dont need to sort since we start at ACE, go to King, and then loop back down to ACE
//(We skip the last ace since we cant start with an Low-Ace, (we can with a High-Ace), because Low-Ace is the lowest card
//Cant do an implicit conversion, and explicit didn't work last time i checked, but this does :D
IList <IList <T> > ret = (IList <IList <T> >)(allStraights);
return(ret);
}