private void CalculateRFlushPower(double current, out double power)
{
current = 5.5;
power = 13 + current * 100;
Win.Add(new Type() { Power = power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
private void rStraight(ref double current, ref double Power, int[] Straight)
{
if (current >= -1)
{
var op = Straight.Select(o => o / 4).Distinct().ToArray();
for (int j = 0; j < op.Length - 4; j++)
{
if (op[j] + 4 == op[j + 4])
{
if (op.Max() - 4 == op[j])
{
current = 4;
Power = op.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 4 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
else
{
current = 4;
Power = op[j + 4] + current * 100;
Win.Add(new Type() { Power = Power, Current = 4 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (op[j] == 0 && op[j + 1] == 9 && op[j + 2] == 10 && op[j + 3] == 11 && op[j + 4] == 12)
{
current = 4;
Power = 13 + current * 100;
Win.Add(new Type() { Power = Power, Current = 4 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
}
}
private void RStraight(IPokerPlayer pokerPlayer, int[] Straight, int index)
{
if (pokerPlayer.Type >= -1)
{
var op = Straight.Select(o => o / 4).Distinct().ToArray();
for (int j = 0; j < op.Length - 4; j++)
{
if (op[j] + 4 == op[j + 4])
{
if (op.Max() - 4 == op[j])
{
pokerPlayer.Type = 4;
pokerPlayer.Power = op.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 4 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
else
{
pokerPlayer.Type = 4;
pokerPlayer.Power = op[j + 4] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 4 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (op[j] == 0 && op[j + 1] == 9 && op[j + 2] == 10 && op[j + 3] == 11 && op[j + 4] == 12)
{
pokerPlayer.Type = 4;
pokerPlayer.Power = 13 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 4 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
}
}
private void CalculateRFlushPower(double current, out double power, out bool vf, ref int[] f1)
{
power = f1.Max() + current * 100;
Win.Add(new Type() { Power = power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
private void rStraightFlush(ref double current, ref double Power, int[] st1, int[] st2, int[] st3, int[] st4)
{
if (current >= -1)
{
if (st1.Length >= 5)
{
if (st1[0] + 4 == st1[4])
{
current = 8;
Power = (st1.Max()) / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 8 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (st1[0] == 0 && st1[1] == 9 && st1[2] == 10 && st1[3] == 11 && st1[0] + 12 == st1[4])
{
current = 9;
Power = (st1.Max()) / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 9 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (st2.Length >= 5)
{
if (st2[0] + 4 == st2[4])
{
current = 8;
Power = (st2.Max()) / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 8 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (st2[0] == 0 && st2[1] == 9 && st2[2] == 10 && st2[3] == 11 && st2[0] + 12 == st2[4])
{
current = 9;
Power = (st2.Max()) / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 9 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (st3.Length >= 5)
{
if (st3[0] + 4 == st3[4])
{
current = 8;
Power = (st3.Max()) / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 8 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (st3[0] == 0 && st3[1] == 9 && st3[2] == 10 && st3[3] == 11 && st3[0] + 12 == st3[4])
{
current = 9;
Power = (st3.Max()) / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 9 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (st4.Length >= 5)
{
if (st4[0] + 4 == st4[4])
{
current = 8;
Power = (st4.Max()) / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 8 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (st4[0] == 0 && st4[1] == 9 && st4[2] == 10 && st4[3] == 11 && st4[0] + 12 == st4[4])
{
current = 9;
Power = (st4.Max()) / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 9 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
}
}
private void rFullHouse(ref double current, ref double Power, ref bool done, int[] Straight)
{
if (current >= -1)
{
type = Power;
for (int j = 0; j <= 12; j++)
{
var fh = Straight.Where(o => o / 4 == j).ToArray();
if (fh.Length == 3 || done)
{
if (fh.Length == 2)
{
if (fh.Max() / 4 == 0)
{
current = 6;
Power = 13 * 2 + current * 100;
Win.Add(new Type() { Power = Power, Current = 6 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
break;
}
if (fh.Max() / 4 > 0)
{
current = 6;
Power = fh.Max() / 4 * 2 + current * 100;
Win.Add(new Type() { Power = Power, Current = 6 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
break;
}
}
if (!done)
{
if (fh.Max() / 4 == 0)
{
Power = 13;
done = true;
j = -1;
}
else
{
Power = fh.Max() / 4;
done = true;
j = -1;
}
}
}
}
if (current != 6)
{
Power = type;
}
}
}
private void rFourOfAKind(IPokerPlayer pokerPlayer, int[] Straight)
{
if (pokerPlayer.Type >= -1)
{
for (int j = 0; j <= 3; j++)
{
if (Straight[j] / 4 == Straight[j + 1] / 4 && Straight[j] / 4 == Straight[j + 2] / 4 &&
Straight[j] / 4 == Straight[j + 3] / 4)
{
pokerPlayer.Type = 7;
pokerPlayer.Power = (Straight[j] / 4) * 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 7 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (Straight[j] / 4 == 0 && Straight[j + 1] / 4 == 0 && Straight[j + 2] / 4 == 0 && Straight[j + 3] / 4 == 0)
{
pokerPlayer.Type = 7;
pokerPlayer.Power = 13 * 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 7 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
}
}
private void rPairFromHand(ref double current, ref double Power)
{
if (current >= -1)
{
bool msgbox = false;
if (Reserve[i] / 4 == Reserve[i + 1] / 4)
{
if (!msgbox)
{
if (Reserve[i] / 4 == 0)
{
current = 1;
Power = 13 * 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
else
{
current = 1;
Power = (Reserve[i + 1] / 4) * 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
msgbox = true;
}
for (int tc = 16; tc >= 12; tc--)
{
if (Reserve[i + 1] / 4 == Reserve[tc] / 4)
{
if (!msgbox)
{
if (Reserve[i + 1] / 4 == 0)
{
current = 1;
Power = 13 * 4 + Reserve[i] / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
else
{
current = 1;
Power = (Reserve[i + 1] / 4) * 4 + Reserve[i] / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
msgbox = true;
}
if (Reserve[i] / 4 == Reserve[tc] / 4)
{
if (!msgbox)
{
if (Reserve[i] / 4 == 0)
{
current = 1;
Power = 13 * 4 + Reserve[i + 1] / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
else
{
current = 1;
Power = (Reserve[tc] / 4) * 4 + Reserve[i + 1] / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
msgbox = true;
}
}
}
}
private void rHighCard(IPokerPlayer pokerPlayer, int index)
{
if (pokerPlayer.Type == -1)
{
if (reserve[index] / 4 > reserve[index + 1] / 4)
{
pokerPlayer.Type = -1;
pokerPlayer.Power = reserve[index] / 4;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = -1 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
else
{
pokerPlayer.Type = -1;
pokerPlayer.Power = reserve[index + 1] / 4;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = -1 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (reserve[index] / 4 == 0 || reserve[index + 1] / 4 == 0)
{
pokerPlayer.Type = -1;
pokerPlayer.Power = 13;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = -1 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
}
private void rStraightFlush(IPokerPlayer pokerPlayer, int[] st1, int[] st2, int[] st3, int[] st4)
{
if (pokerPlayer.Type >= -1)
{
if (st1.Length >= 5)
{
if (st1[0] + 4 == st1[4])
{
pokerPlayer.Type = 8;
pokerPlayer.Power = (st1.Max()) / 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 8 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (st1[0] == 0 && st1[1] == 9 && st1[2] == 10 && st1[3] == 11 && st1[0] + 12 == st1[4])
{
pokerPlayer.Type = 9;
pokerPlayer.Power = (st1.Max()) / 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 9 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (st2.Length >= 5)
{
if (st2[0] + 4 == st2[4])
{
pokerPlayer.Type = 8;
pokerPlayer.Power = (st2.Max()) / 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 8 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (st2[0] == 0 && st2[1] == 9 && st2[2] == 10 && st2[3] == 11 && st2[0] + 12 == st2[4])
{
pokerPlayer.Type = 9;
pokerPlayer.Power = (st2.Max()) / 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 9 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (st3.Length >= 5)
{
if (st3[0] + 4 == st3[4])
{
pokerPlayer.Type = 8;
pokerPlayer.Power = (st3.Max()) / 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 8 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (st3[0] == 0 && st3[1] == 9 && st3[2] == 10 && st3[3] == 11 && st3[0] + 12 == st3[4])
{
pokerPlayer.Type = 9;
pokerPlayer.Power = (st3.Max()) / 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 9 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (st4.Length >= 5)
{
if (st4[0] + 4 == st4[4])
{
pokerPlayer.Type = 8;
pokerPlayer.Power = (st4.Max()) / 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 8 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (st4[0] == 0 && st4[1] == 9 && st4[2] == 10 && st4[3] == 11 && st4[0] + 12 == st4[4])
{
pokerPlayer.Type = 9;
pokerPlayer.Power = (st4.Max()) / 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 9 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
}
}
private void rPairFromHand(IPokerPlayer pokerPlayer, int index)
{
if (pokerPlayer.Type >= -1)
{
bool msgbox = false;
if (reserve[index] / 4 == reserve[index + 1] / 4)
{
if (!msgbox)
{
if (reserve[index] / 4 == 0)
{
pokerPlayer.Type = 1;
pokerPlayer.Power = 13 * 4 + 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
else
{
pokerPlayer.Type = 1;
pokerPlayer.Power = (reserve[index + 1] / 4) * 4 + 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
msgbox = true;
}
for (int tc = 16; tc >= 12; tc--)
{
if (reserve[index + 1] / 4 == reserve[tc] / 4)
{
if (!msgbox)
{
if (reserve[index + 1] / 4 == 0)
{
pokerPlayer.Type = 1;
pokerPlayer.Power = 13 * 4 + reserve[index] / 4 + 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
else
{
pokerPlayer.Type = 1;
pokerPlayer.Power = (reserve[index + 1] / 4) * 4 + reserve[index] / 4 + 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
msgbox = true;
}
if (reserve[index] / 4 == reserve[tc] / 4)
{
if (!msgbox)
{
if (reserve[index] / 4 == 0)
{
pokerPlayer.Type = 1;
pokerPlayer.Power = 13 * 4 + reserve[index + 1] / 4 + 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
else
{
pokerPlayer.Type = 1;
pokerPlayer.Power = (reserve[tc] / 4) * 4 + reserve[index + 1] / 4 + 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
msgbox = true;
}
}
}
}
private void rPairTwoPair(IPokerPlayer pokerPlayer, int index)
{
if (pokerPlayer.Type >= -1)
{
bool msgbox = false;
bool msgbox1 = false;
for (int tc = 16; tc >= 12; tc--)
{
int max = tc - 12;
for (int k = 1; k <= max; k++)
{
if (tc - k < 12)
{
max--;
}
if (tc - k >= 12)
{
if (reserve[tc] / 4 == reserve[tc - k] / 4)
{
if (reserve[tc] / 4 != reserve[index] / 4 && reserve[tc] / 4 != reserve[index + 1] / 4 && pokerPlayer.Type == 1)
{
if (!msgbox)
{
if (reserve[index + 1] / 4 == 0)
{
pokerPlayer.Type = 2;
pokerPlayer.Power = (reserve[index] / 4) * 2 + 13 * 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 2 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
if (reserve[index] / 4 == 0)
{
pokerPlayer.Type = 2;
pokerPlayer.Power = (reserve[index + 1] / 4) * 2 + 13 * 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 2 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
if (reserve[index + 1] / 4 != 0)
{
pokerPlayer.Type = 2;
pokerPlayer.Power = (reserve[tc] / 4) * 2 + (reserve[index + 1] / 4) * 2 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 2 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
if (reserve[index] / 4 != 0)
{
pokerPlayer.Type = 2;
pokerPlayer.Power = (reserve[tc] / 4) * 2 + (reserve[index] / 4) * 2 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 2 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
msgbox = true;
}
if (pokerPlayer.Type == -1)
{
if (!msgbox1)
{
if (reserve[index] / 4 > reserve[index + 1] / 4)
{
if (reserve[tc] / 4 == 0)
{
pokerPlayer.Type = 0;
pokerPlayer.Power = 13 + reserve[index] / 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
else
{
pokerPlayer.Type = 0;
pokerPlayer.Power = reserve[tc] / 4 + reserve[index] / 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
else
{
if (reserve[tc] / 4 == 0)
{
pokerPlayer.Type = 0;
pokerPlayer.Power = 13 + reserve[index + 1] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
else
{
pokerPlayer.Type = 0;
pokerPlayer.Power = reserve[tc] / 4 + reserve[index + 1] / 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
}
msgbox1 = true;
}
}
}
}
}
}
}
private void rThreeOfAKind(IPokerPlayer pokerPlayer, int[] Straight, int index)
{
if (pokerPlayer.Type >= -1)
{
for (int j = 0; j <= 12; j++)
{
var fh = Straight.Where(o => o / 4 == j).ToArray();
if (fh.Length == 3)
{
if (fh.Max() / 4 == 0)
{
pokerPlayer.Type = 3;
pokerPlayer.Power = 13 * 3 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 3 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
else
{
pokerPlayer.Type = 3;
pokerPlayer.Power = fh[0] / 4 + fh[1] / 4 + fh[2] / 4 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 3 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
}
}
}
private void rThreeOfAKind(ref double current, ref double Power, int[] Straight)
{
if (current >= -1)
{
for (int j = 0; j <= 12; j++)
{
var fh = Straight.Where(o => o / 4 == j).ToArray();
if (fh.Length == 3)
{
if (fh.Max() / 4 == 0)
{
current = 3;
Power = 13 * 3 + current * 100;
Win.Add(new Type() { Power = Power, Current = 3 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
else
{
current = 3;
Power = fh[0] / 4 + fh[1] / 4 + fh[2] / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 3 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
}
}
}
private void RFlush(IPokerPlayer pokerPlayer, ref bool vf, int[] straight1, int index)
{
if (pokerPlayer.Type >= -1)
{
var f1 = straight1.Where(o => o % 4 == 0).ToArray();
var f2 = straight1.Where(o => o % 4 == 1).ToArray();
var f3 = straight1.Where(o => o % 4 == 2).ToArray();
var f4 = straight1.Where(o => o % 4 == 3).ToArray();
if (f1.Length == 3 || f1.Length == 4)
{
if (reserve[index] % 4 == reserve[index + 1] % 4 && reserve[index] % 4 == f1[0] % 4)
{
if (reserve[index] / 4 > f1.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (reserve[index + 1] / 4 > f1.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index + 1] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (reserve[index] / 4 < f1.Max() / 4 && reserve[index + 1] / 4 < f1.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f1.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f1.Length == 4)//different cards in hand
{
if (reserve[index] % 4 != reserve[index + 1] % 4 && reserve[index] % 4 == f1[0] % 4)
{
if (reserve[index] / 4 > f1.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f1.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (reserve[index + 1] % 4 != reserve[index] % 4 && reserve[index + 1] % 4 == f1[0] % 4)
{
if (reserve[index + 1] / 4 > f1.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index + 1] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f1.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f1.Length == 5)
{
if (reserve[index] % 4 == f1[0] % 4 && reserve[index] / 4 > f1.Min() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (reserve[index + 1] % 4 == f1[0] % 4 && reserve[index + 1] / 4 > f1.Min() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index + 1] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (reserve[index] / 4 < f1.Min() / 4 && reserve[index + 1] / 4 < f1.Min())
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f1.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (f2.Length == 3 || f2.Length == 4)
{
if (reserve[index] % 4 == reserve[index + 1] % 4 && reserve[index] % 4 == f2[0] % 4)
{
if (reserve[index] / 4 > f2.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (reserve[index + 1] / 4 > f2.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index + 1] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (reserve[index] / 4 < f2.Max() / 4 && reserve[index + 1] / 4 < f2.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f2.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f2.Length == 4)//different cards in hand
{
if (reserve[index] % 4 != reserve[index + 1] % 4 && reserve[index] % 4 == f2[0] % 4)
{
if (reserve[index] / 4 > f2.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f2.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (reserve[index + 1] % 4 != reserve[index] % 4 && reserve[index + 1] % 4 == f2[0] % 4)
{
if (reserve[index + 1] / 4 > f2.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index + 1] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f2.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f2.Length == 5)
{
if (reserve[index] % 4 == f2[0] % 4 && reserve[index] / 4 > f2.Min() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (reserve[index + 1] % 4 == f2[0] % 4 && reserve[index + 1] / 4 > f2.Min() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index + 1] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (reserve[index] / 4 < f2.Min() / 4 && reserve[index + 1] / 4 < f2.Min())
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f2.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (f3.Length == 3 || f3.Length == 4)
{
if (reserve[index] % 4 == reserve[index + 1] % 4 && reserve[index] % 4 == f3[0] % 4)
{
if (reserve[index] / 4 > f3.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (reserve[index + 1] / 4 > f3.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index + 1] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (reserve[index] / 4 < f3.Max() / 4 && reserve[index + 1] / 4 < f3.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f3.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f3.Length == 4)//different cards in hand
{
if (reserve[index] % 4 != reserve[index + 1] % 4 && reserve[index] % 4 == f3[0] % 4)
{
if (reserve[index] / 4 > f3.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f3.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (reserve[index + 1] % 4 != reserve[index] % 4 && reserve[index + 1] % 4 == f3[0] % 4)
{
if (reserve[index + 1] / 4 > f3.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index + 1] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f3.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f3.Length == 5)
{
if (reserve[index] % 4 == f3[0] % 4 && reserve[index] / 4 > f3.Min() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (reserve[index + 1] % 4 == f3[0] % 4 && reserve[index + 1] / 4 > f3.Min() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index + 1] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (reserve[index] / 4 < f3.Min() / 4 && reserve[index + 1] / 4 < f3.Min())
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f3.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (f4.Length == 3 || f4.Length == 4)
{
if (reserve[index] % 4 == reserve[index + 1] % 4 && reserve[index] % 4 == f4[0] % 4)
{
if (reserve[index] / 4 > f4.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (reserve[index + 1] / 4 > f4.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index + 1] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (reserve[index] / 4 < f4.Max() / 4 && reserve[index + 1] / 4 < f4.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f4.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f4.Length == 4)//different cards in hand
{
if (reserve[index] % 4 != reserve[index + 1] % 4 && reserve[index] % 4 == f4[0] % 4)
{
if (reserve[index] / 4 > f4.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f4.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (reserve[index + 1] % 4 != reserve[index] % 4 && reserve[index + 1] % 4 == f4[0] % 4)
{
if (reserve[index + 1] / 4 > f4.Max() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index + 1] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f4.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f4.Length == 5)
{
if (reserve[index] % 4 == f4[0] % 4 && reserve[index] / 4 > f4.Min() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (reserve[index + 1] % 4 == f4[0] % 4 && reserve[index + 1] / 4 > f4.Min() / 4)
{
pokerPlayer.Type = 5;
pokerPlayer.Power = reserve[index + 1] + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (reserve[index] / 4 < f4.Min() / 4 && reserve[index + 1] / 4 < f4.Min())
{
pokerPlayer.Type = 5;
pokerPlayer.Power = f4.Max() + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
//ace
if (f1.Length > 0)
{
if (reserve[index] / 4 == 0 && reserve[index] % 4 == f1[0] % 4 && vf && f1.Length > 0)
{
pokerPlayer.Type = 5.5;
pokerPlayer.Power = 13 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (reserve[index + 1] / 4 == 0 && reserve[index + 1] % 4 == f1[0] % 4 && vf && f1.Length > 0)
{
pokerPlayer.Type = 5.5;
pokerPlayer.Power = 13 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (f2.Length > 0)
{
if (reserve[index] / 4 == 0 && reserve[index] % 4 == f2[0] % 4 && vf && f2.Length > 0)
{
pokerPlayer.Type = 5.5;
pokerPlayer.Power = 13 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (reserve[index + 1] / 4 == 0 && reserve[index + 1] % 4 == f2[0] % 4 && vf && f2.Length > 0)
{
pokerPlayer.Type = 5.5;
pokerPlayer.Power = 13 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (f3.Length > 0)
{
if (reserve[index] / 4 == 0 && reserve[index] % 4 == f3[0] % 4 && vf && f3.Length > 0)
{
pokerPlayer.Type = 5.5;
pokerPlayer.Power = 13 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (reserve[index + 1] / 4 == 0 && reserve[index + 1] % 4 == f3[0] % 4 && vf && f3.Length > 0)
{
pokerPlayer.Type = 5.5;
pokerPlayer.Power = 13 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (f4.Length > 0)
{
if (reserve[index] / 4 == 0 && reserve[index] % 4 == f4[0] % 4 && vf && f4.Length > 0)
{
pokerPlayer.Type = 5.5;
pokerPlayer.Power = 13 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (reserve[index + 1] / 4 == 0 && reserve[index + 1] % 4 == f4[0] % 4 && vf)
{
pokerPlayer.Type = 5.5;
pokerPlayer.Power = 13 + pokerPlayer.Type * 100;
Win.Add(new Type() { Power = pokerPlayer.Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
}
}
private void rPairTwoPair(ref double current, ref double Power)
{
if (current >= -1)
{
bool msgbox = false;
bool msgbox1 = false;
for (int tc = 16; tc >= 12; tc--)
{
int max = tc - 12;
for (int k = 1; k <= max; k++)
{
if (tc - k < 12)
{
max--;
}
if (tc - k >= 12)
{
if (Reserve[tc] / 4 == Reserve[tc - k] / 4)
{
if (Reserve[tc] / 4 != Reserve[i] / 4 && Reserve[tc] / 4 != Reserve[i + 1] / 4 && current == 1)
{
if (!msgbox)
{
if (Reserve[i + 1] / 4 == 0)
{
current = 2;
Power = (Reserve[i] / 4) * 2 + 13 * 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 2 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
if (Reserve[i] / 4 == 0)
{
current = 2;
Power = (Reserve[i + 1] / 4) * 2 + 13 * 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 2 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
if (Reserve[i + 1] / 4 != 0)
{
current = 2;
Power = (Reserve[tc] / 4) * 2 + (Reserve[i + 1] / 4) * 2 + current * 100;
Win.Add(new Type() { Power = Power, Current = 2 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
if (Reserve[i] / 4 != 0)
{
current = 2;
Power = (Reserve[tc] / 4) * 2 + (Reserve[i] / 4) * 2 + current * 100;
Win.Add(new Type() { Power = Power, Current = 2 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
msgbox = true;
}
if (current == -1)
{
if (!msgbox1)
{
if (Reserve[i] / 4 > Reserve[i + 1] / 4)
{
if (Reserve[tc] / 4 == 0)
{
current = 0;
Power = 13 + Reserve[i] / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
else
{
current = 0;
Power = Reserve[tc] / 4 + Reserve[i] / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
else
{
if (Reserve[tc] / 4 == 0)
{
current = 0;
Power = 13 + Reserve[i + 1] + current * 100;
Win.Add(new Type() { Power = Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
else
{
current = 0;
Power = Reserve[tc] / 4 + Reserve[i + 1] / 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 1 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
}
msgbox1 = true;
}
}
}
}
}
}
}
// TODO: if someone knows how to extract the method and retain a simpler signature, be my guest :D
public void TexasHoldEmRules(
int card1,
int card2,
string currentText,
IPokerPlayer pokerPlayer,
ref Label playerStatus,
ref PictureBox[] cardPicture,
ref List<Type> Win,
ref Type sorted,
ref int[] reserve)
{
if (card1 == 0 && card2 == 1)
{
}
if (!pokerPlayer.OutOfChips || card1 == 0 && card2 == 1 && playerStatus.Text.Contains("Fold") == false)
{
#region Variables
int[] Straight = new int[7];
Straight[0] = reserve[card1];
Straight[1] = reserve[card2];
Straight[2] = reserve[12];
Straight[3] = reserve[13];
Straight[4] = reserve[14];
Straight[5] = reserve[15];
Straight[6] = reserve[16];
int[] getClubes = Straight.Where(o => o % 4 == 0).ToArray();
int[] getDimonds = Straight.Where(o => o % 4 == 1).ToArray();
int[] getHearts = Straight.Where(o => o % 4 == 2).ToArray();
int[] getSpades = Straight.Where(o => o % 4 == 3).ToArray();
int[] clubes = getClubes.Select(o => o / 4).Distinct().ToArray();
int[] diamonds = getDimonds.Select(o => o / 4).Distinct().ToArray();
int[] hearts = getHearts.Select(o => o / 4).Distinct().ToArray();
int[] spades = getSpades.Select(o => o / 4).Distinct().ToArray();
#endregion Variables
Array.Sort(Straight);
Array.Sort(clubes);
Array.Sort(diamonds);
Array.Sort(hearts);
Array.Sort(spades);
for (int index = 0; index < 16; index++)
{
if (reserve[index] == int.Parse(cardPicture[card1].Tag.ToString()) &&
reserve[index + 1] == int.Parse(cardPicture[card2].Tag.ToString()))
{
this.checkHand.PairFromHand(pokerPlayer, index, ref Win, ref sorted, ref reserve);
this.checkHand.PairTwoPair(pokerPlayer, index, ref Win, ref sorted, ref reserve);
this.checkHand.TwoPair(pokerPlayer, index, ref Win, ref sorted, ref reserve);
this.checkHand.ThreeOfAKind(pokerPlayer, Straight, ref Win, ref sorted);
this.checkHand.Straight(pokerPlayer, Straight, ref Win, ref sorted);
this.checkHand.Flush(pokerPlayer, Straight, ref Win, ref sorted);
this.checkHand.FullHouse(pokerPlayer, Straight, ref Win, ref sorted);
this.checkHand.FourOfAKind(pokerPlayer, Straight, ref Win, ref sorted);
this.checkHand.StraightFlush(pokerPlayer, clubes, diamonds, hearts, spades, ref Win, ref sorted);
this.checkHand.HighCard(pokerPlayer, index, ref Win, ref sorted, ref reserve);
}
}
}
}
private void rHighCard(ref double current, ref double Power)
{
if (current == -1)
{
if (Reserve[i] / 4 > Reserve[i + 1] / 4)
{
current = -1;
Power = Reserve[i] / 4;
Win.Add(new Type() { Power = Power, Current = -1 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
else
{
current = -1;
Power = Reserve[i + 1] / 4;
Win.Add(new Type() { Power = Power, Current = -1 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (Reserve[i] / 4 == 0 || Reserve[i + 1] / 4 == 0)
{
current = -1;
Power = 13;
Win.Add(new Type() { Power = Power, Current = -1 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
}
private void RTwoPair(ref double current, ref double Power)
{
if (current >= -1)
{
bool msgbox = false;
for (int tc = 16; tc >= 12; tc--)
{
int max = tc - 12;
if (reserve[index] / 4 != reserve[index + 1] / 4)
{
for (int k = 1; k <= max; k++)
{
if (tc - k < 12)
{
max--;
}
if (tc - k >= 12)
{
if (reserve[index] / 4 == reserve[tc] / 4 && reserve[index + 1] / 4 == reserve[tc - k] / 4 ||
reserve[index + 1] / 4 == reserve[tc] / 4 && reserve[index] / 4 == reserve[tc - k] / 4)
{
if (!msgbox)
{
if (reserve[index] / 4 == 0)
{
current = 2;
Power = 13 * 4 + (reserve[index + 1] / 4) * 2 + current * 100;
Win.Add(new Type() { Power = Power, Current = 2 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
if (reserve[index + 1] / 4 == 0)
{
current = 2;
Power = 13 * 4 + (reserve[index] / 4) * 2 + current * 100;
Win.Add(new Type() { Power = Power, Current = 2 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
if (reserve[index + 1] / 4 != 0 && reserve[index] / 4 != 0)
{
current = 2;
Power = (reserve[index] / 4) * 2 + (reserve[index + 1] / 4) * 2 + current * 100;
Win.Add(new Type() { Power = Power, Current = 2 });
sorted = Win.OrderByDescending(op => op.Current).ThenByDescending(op => op.Power).First();
}
}
msgbox = true;
}
}
}
}
}
}
}
private void rFourOfAKind(ref double current, ref double Power, int[] Straight)
{
if (current >= -1)
{
for (int j = 0; j <= 3; j++)
{
if (Straight[j] / 4 == Straight[j + 1] / 4 && Straight[j] / 4 == Straight[j + 2] / 4 &&
Straight[j] / 4 == Straight[j + 3] / 4)
{
current = 7;
Power = (Straight[j] / 4) * 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 7 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (Straight[j] / 4 == 0 && Straight[j + 1] / 4 == 0 && Straight[j + 2] / 4 == 0 && Straight[j + 3] / 4 == 0)
{
current = 7;
Power = 13 * 4 + current * 100;
Win.Add(new Type() { Power = Power, Current = 7 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
}
}
private void CalculatePower(out double Power, ref int[] st1, int currentIndex)
{
Power = (st1.Max()) / 4 + currentIndex * 100;
Win.Add(new Type() { Power = Power, Current = currentIndex });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
private void rFlush(ref double current, ref double Power, ref bool vf, int[] Straight1)
{
if (current >= -1)
{
var f1 = Straight1.Where(o => o % 4 == 0).ToArray();
var f2 = Straight1.Where(o => o % 4 == 1).ToArray();
var f3 = Straight1.Where(o => o % 4 == 2).ToArray();
var f4 = Straight1.Where(o => o % 4 == 3).ToArray();
if (f1.Length == 3 || f1.Length == 4)
{
if (Reserve[i] % 4 == Reserve[i + 1] % 4 && Reserve[i] % 4 == f1[0] % 4)
{
if (Reserve[i] / 4 > f1.Max() / 4)
{
current = 5;
Power = Reserve[i] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (Reserve[i + 1] / 4 > f1.Max() / 4)
{
current = 5;
Power = Reserve[i + 1] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (Reserve[i] / 4 < f1.Max() / 4 && Reserve[i + 1] / 4 < f1.Max() / 4)
{
current = 5;
Power = f1.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f1.Length == 4)//different cards in hand
{
if (Reserve[i] % 4 != Reserve[i + 1] % 4 && Reserve[i] % 4 == f1[0] % 4)
{
if (Reserve[i] / 4 > f1.Max() / 4)
{
current = 5;
Power = Reserve[i] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
current = 5;
Power = f1.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (Reserve[i + 1] % 4 != Reserve[i] % 4 && Reserve[i + 1] % 4 == f1[0] % 4)
{
if (Reserve[i + 1] / 4 > f1.Max() / 4)
{
current = 5;
Power = Reserve[i + 1] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
current = 5;
Power = f1.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f1.Length == 5)
{
if (Reserve[i] % 4 == f1[0] % 4 && Reserve[i] / 4 > f1.Min() / 4)
{
current = 5;
Power = Reserve[i] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (Reserve[i + 1] % 4 == f1[0] % 4 && Reserve[i + 1] / 4 > f1.Min() / 4)
{
current = 5;
Power = Reserve[i + 1] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (Reserve[i] / 4 < f1.Min() / 4 && Reserve[i + 1] / 4 < f1.Min())
{
current = 5;
Power = f1.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (f2.Length == 3 || f2.Length == 4)
{
if (Reserve[i] % 4 == Reserve[i + 1] % 4 && Reserve[i] % 4 == f2[0] % 4)
{
if (Reserve[i] / 4 > f2.Max() / 4)
{
current = 5;
Power = Reserve[i] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (Reserve[i + 1] / 4 > f2.Max() / 4)
{
current = 5;
Power = Reserve[i + 1] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (Reserve[i] / 4 < f2.Max() / 4 && Reserve[i + 1] / 4 < f2.Max() / 4)
{
current = 5;
Power = f2.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f2.Length == 4)//different cards in hand
{
if (Reserve[i] % 4 != Reserve[i + 1] % 4 && Reserve[i] % 4 == f2[0] % 4)
{
if (Reserve[i] / 4 > f2.Max() / 4)
{
current = 5;
Power = Reserve[i] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
current = 5;
Power = f2.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (Reserve[i + 1] % 4 != Reserve[i] % 4 && Reserve[i + 1] % 4 == f2[0] % 4)
{
if (Reserve[i + 1] / 4 > f2.Max() / 4)
{
current = 5;
Power = Reserve[i + 1] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
current = 5;
Power = f2.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f2.Length == 5)
{
if (Reserve[i] % 4 == f2[0] % 4 && Reserve[i] / 4 > f2.Min() / 4)
{
current = 5;
Power = Reserve[i] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (Reserve[i + 1] % 4 == f2[0] % 4 && Reserve[i + 1] / 4 > f2.Min() / 4)
{
current = 5;
Power = Reserve[i + 1] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (Reserve[i] / 4 < f2.Min() / 4 && Reserve[i + 1] / 4 < f2.Min())
{
current = 5;
Power = f2.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (f3.Length == 3 || f3.Length == 4)
{
if (Reserve[i] % 4 == Reserve[i + 1] % 4 && Reserve[i] % 4 == f3[0] % 4)
{
if (Reserve[i] / 4 > f3.Max() / 4)
{
current = 5;
Power = Reserve[i] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (Reserve[i + 1] / 4 > f3.Max() / 4)
{
current = 5;
Power = Reserve[i + 1] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (Reserve[i] / 4 < f3.Max() / 4 && Reserve[i + 1] / 4 < f3.Max() / 4)
{
current = 5;
Power = f3.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f3.Length == 4)//different cards in hand
{
if (Reserve[i] % 4 != Reserve[i + 1] % 4 && Reserve[i] % 4 == f3[0] % 4)
{
if (Reserve[i] / 4 > f3.Max() / 4)
{
current = 5;
Power = Reserve[i] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
current = 5;
Power = f3.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (Reserve[i + 1] % 4 != Reserve[i] % 4 && Reserve[i + 1] % 4 == f3[0] % 4)
{
if (Reserve[i + 1] / 4 > f3.Max() / 4)
{
current = 5;
Power = Reserve[i + 1] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
current = 5;
Power = f3.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f3.Length == 5)
{
if (Reserve[i] % 4 == f3[0] % 4 && Reserve[i] / 4 > f3.Min() / 4)
{
current = 5;
Power = Reserve[i] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (Reserve[i + 1] % 4 == f3[0] % 4 && Reserve[i + 1] / 4 > f3.Min() / 4)
{
current = 5;
Power = Reserve[i + 1] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (Reserve[i] / 4 < f3.Min() / 4 && Reserve[i + 1] / 4 < f3.Min())
{
current = 5;
Power = f3.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (f4.Length == 3 || f4.Length == 4)
{
if (Reserve[i] % 4 == Reserve[i + 1] % 4 && Reserve[i] % 4 == f4[0] % 4)
{
if (Reserve[i] / 4 > f4.Max() / 4)
{
current = 5;
Power = Reserve[i] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (Reserve[i + 1] / 4 > f4.Max() / 4)
{
current = 5;
Power = Reserve[i + 1] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (Reserve[i] / 4 < f4.Max() / 4 && Reserve[i + 1] / 4 < f4.Max() / 4)
{
current = 5;
Power = f4.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f4.Length == 4)//different cards in hand
{
if (Reserve[i] % 4 != Reserve[i + 1] % 4 && Reserve[i] % 4 == f4[0] % 4)
{
if (Reserve[i] / 4 > f4.Max() / 4)
{
current = 5;
Power = Reserve[i] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
current = 5;
Power = f4.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
if (Reserve[i + 1] % 4 != Reserve[i] % 4 && Reserve[i + 1] % 4 == f4[0] % 4)
{
if (Reserve[i + 1] / 4 > f4.Max() / 4)
{
current = 5;
Power = Reserve[i + 1] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else
{
current = 5;
Power = f4.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
}
if (f4.Length == 5)
{
if (Reserve[i] % 4 == f4[0] % 4 && Reserve[i] / 4 > f4.Min() / 4)
{
current = 5;
Power = Reserve[i] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
if (Reserve[i + 1] % 4 == f4[0] % 4 && Reserve[i + 1] / 4 > f4.Min() / 4)
{
current = 5;
Power = Reserve[i + 1] + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
else if (Reserve[i] / 4 < f4.Min() / 4 && Reserve[i + 1] / 4 < f4.Min())
{
current = 5;
Power = f4.Max() + current * 100;
Win.Add(new Type() { Power = Power, Current = 5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
vf = true;
}
}
//ace
if (f1.Length > 0)
{
if (Reserve[i] / 4 == 0 && Reserve[i] % 4 == f1[0] % 4 && vf && f1.Length > 0)
{
current = 5.5;
Power = 13 + current * 100;
Win.Add(new Type() { Power = Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (Reserve[i + 1] / 4 == 0 && Reserve[i + 1] % 4 == f1[0] % 4 && vf && f1.Length > 0)
{
current = 5.5;
Power = 13 + current * 100;
Win.Add(new Type() { Power = Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (f2.Length > 0)
{
if (Reserve[i] / 4 == 0 && Reserve[i] % 4 == f2[0] % 4 && vf && f2.Length > 0)
{
current = 5.5;
Power = 13 + current * 100;
Win.Add(new Type() { Power = Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (Reserve[i + 1] / 4 == 0 && Reserve[i + 1] % 4 == f2[0] % 4 && vf && f2.Length > 0)
{
current = 5.5;
Power = 13 + current * 100;
Win.Add(new Type() { Power = Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (f3.Length > 0)
{
if (Reserve[i] / 4 == 0 && Reserve[i] % 4 == f3[0] % 4 && vf && f3.Length > 0)
{
current = 5.5;
Power = 13 + current * 100;
Win.Add(new Type() { Power = Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (Reserve[i + 1] / 4 == 0 && Reserve[i + 1] % 4 == f3[0] % 4 && vf && f3.Length > 0)
{
current = 5.5;
Power = 13 + current * 100;
Win.Add(new Type() { Power = Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
if (f4.Length > 0)
{
if (Reserve[i] / 4 == 0 && Reserve[i] % 4 == f4[0] % 4 && vf && f4.Length > 0)
{
current = 5.5;
Power = 13 + current * 100;
Win.Add(new Type() { Power = Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
if (Reserve[i + 1] / 4 == 0 && Reserve[i + 1] % 4 == f4[0] % 4 && vf)
{
current = 5.5;
Power = 13 + current * 100;
Win.Add(new Type() { Power = Power, Current = 5.5 });
sorted = Win.OrderByDescending(op1 => op1.Current).ThenByDescending(op1 => op1.Power).First();
}
}
}
}
// TODO: if someone knows how to extract the method and retain a simpler signature, be my guest :D
public void TexasHoldEmRules(
int card1,
int card2,
string currentText,
IPokerPlayer pokerPlayer,
ref Label playerStatus,
ref PictureBox[] cardPicture,
ref List <Type> Win,
ref Type sorted,
ref int[] reserve)
{
if (card1 == 0 && card2 == 1)
{
}
if (!pokerPlayer.OutOfChips || card1 == 0 && card2 == 1 && playerStatus.Text.Contains("Fold") == false)
{
#region Variables
int[] Straight = new int[7];
Straight[0] = reserve[card1];
Straight[1] = reserve[card2];
Straight[2] = reserve[12];
Straight[3] = reserve[13];
Straight[4] = reserve[14];
Straight[5] = reserve[15];
Straight[6] = reserve[16];
int[] getClubes = Straight.Where(o => o % 4 == 0).ToArray();
int[] getDimonds = Straight.Where(o => o % 4 == 1).ToArray();
int[] getHearts = Straight.Where(o => o % 4 == 2).ToArray();
int[] getSpades = Straight.Where(o => o % 4 == 3).ToArray();
int[] clubes = getClubes.Select(o => o / 4).Distinct().ToArray();
int[] diamonds = getDimonds.Select(o => o / 4).Distinct().ToArray();
int[] hearts = getHearts.Select(o => o / 4).Distinct().ToArray();
int[] spades = getSpades.Select(o => o / 4).Distinct().ToArray();
#endregion Variables
Array.Sort(Straight);
Array.Sort(clubes);
Array.Sort(diamonds);
Array.Sort(hearts);
Array.Sort(spades);
for (int index = 0; index < 16; index++)
{
if (reserve[index] == int.Parse(cardPicture[card1].Tag.ToString()) &&
reserve[index + 1] == int.Parse(cardPicture[card2].Tag.ToString()))
{
this.checkHand.PairFromHand(pokerPlayer, index, ref Win, ref sorted, ref reserve);
this.checkHand.PairTwoPair(pokerPlayer, index, ref Win, ref sorted, ref reserve);
this.checkHand.TwoPair(pokerPlayer, index, ref Win, ref sorted, ref reserve);
this.checkHand.ThreeOfAKind(pokerPlayer, Straight, ref Win, ref sorted);
this.checkHand.Straight(pokerPlayer, Straight, ref Win, ref sorted);
this.checkHand.Flush(pokerPlayer, Straight, ref Win, ref sorted);
this.checkHand.FullHouse(pokerPlayer, Straight, ref Win, ref sorted);
this.checkHand.FourOfAKind(pokerPlayer, Straight, ref Win, ref sorted);
this.checkHand.StraightFlush(pokerPlayer, clubes, diamonds, hearts, spades, ref Win, ref sorted);
this.checkHand.HighCard(pokerPlayer, index, ref Win, ref sorted, ref reserve);
}
}
}
}
