public decimal getTopBonus(LineValue value)
{
switch (value)
{
case LineValue.Royal:
return(25);
case LineValue.StraightFlash:
return(15);
case LineValue.Care:
return(10);
case LineValue.FullHouse:
return(6);
case LineValue.Flash:
return(4);
case LineValue.Straight:
return(2);
default:
return(0);
}
}
public decimal ScoreCompare(bool isHeroHandDead, bool isVillainHandDead, byte[] heroShortLine, byte[] heroMiddleLine, byte[] heroTopLine,
LineValue shortHeroValue, LineValue middleHeroValue, LineValue topHeroValue,
byte[] villainShortLine, byte[] villainMiddleLine, byte[] villainTopLine,
LineValue shortVillainValue, LineValue middleVillainValue, LineValue topVillainValue)
{
if (isHeroHandDead && isVillainHandDead)
{
return(0);
}
else if (isHeroHandDead && !isVillainHandDead)
{
return(-6);
}
else if (!isHeroHandDead && isVillainHandDead)
{
return(6);
}
var compareShort = CompareOneOther(heroShortLine, villainShortLine, shortHeroValue, shortVillainValue);
var compareMiddle = CompareOneOther(heroMiddleLine, villainMiddleLine, middleHeroValue, middleVillainValue);
var compareTop = CompareOneOther(heroTopLine, villainTopLine, topHeroValue, topVillainValue);
if (compareShort > 0 && compareMiddle > 0 && compareTop > 0)
{
return(6);
}
if (compareShort < 0 && compareMiddle < 0 && compareTop < 0)
{
return(-6);
}
return((compareShort > 0 ? 1 : -1) + (compareMiddle > 0 ? 1 : -1) + (compareTop > 0 ? 1 : -1));
}
public decimal CalculateBonusTop(byte[] sortedLine, LineValue value)
{
if (value == LineValue.Straight)
{
return(2);
}
if (value == LineValue.Flash)
{
return(4);
}
if (value == LineValue.FullHouse)
{
return(6);
}
if (value == LineValue.Care)
{
return(10);
}
if (value == LineValue.StraightFlash)
{
return(15);
}
if (value == LineValue.Royal)
{
return(25);
}
return(0);
}
public decimal CalculateBonusMiddle(byte[] sortedLine, LineValue value)
{
if (value == LineValue.Set)
{
return(2);
}
if (value == LineValue.Straight)
{
return(4);
}
if (value == LineValue.Flash)
{
return(8);
}
if (value == LineValue.FullHouse)
{
return(12);
}
if (value == LineValue.Care)
{
return(20);
}
if (value == LineValue.StraightFlash)
{
return(30);
}
if (value == LineValue.Royal)
{
return(50);
}
return(0);
}
bool valueIn(LineValue value, params LineValue[] ins)
{
foreach (LineValue i in ins)
{
if (value == i)
{
return(true);
}
}
return(false);
}
public void TestCalculateBonusShortHighCard()
{
// assign
var data = InputReader.ReadInput("2d 7h Ac");
var result = new byte[3];
// act
var objectUnderTest = new LastTurnInPosition();
LineValue power = objectUnderTest.SortLine(data, result, 0, 3);
decimal score = objectUnderTest.CalculateBonusShort(result, power);
// assert
Assert.AreEqual(0, score);
}
public void lookAtHand(byte[] heroHand, out LineValue shortValue, out LineValue middleValue, out LineValue topValue, out bool isFantasyGained,
out byte[] shortCount, out byte[] middleCount, out byte[] topCount)
{
byte[] countValue;
byte[] colorValue;
countRange(heroHand, 0, 3, out countValue, out colorValue);
shortCount = countValue;
shortValue = getShortValue(countValue, colorValue, out isFantasyGained);
countRange(heroHand, 3, 8, out countValue, out colorValue);
middleCount = countValue;
middleValue = getMiddleValue(countValue, colorValue);
countRange(heroHand, 8, 13, out countValue, out colorValue);
topCount = countValue;
topValue = getMiddleValue(countValue, colorValue);
}
private LineValue ReadLine(int lineNumber, string name, string line, IList <Configuration.Parameters.BaseParameter> parameters)
{
LineValue res = new LineValue();
res.LineNumber = lineNumber;
res.Line = line;
res.Name = name;
for (int c = 0; c < parameters.Count; c++)
{
res.Parameters.Add(ReadParameter(line, parameters[c]));
}
return(res);
}
public void TestSortLineShortHighCard()
{
// assign
var data = InputReader.ReadInput("Jd Qh Ac");
var result = new byte[3];
// act
var objectUnderTest = new LastTurnInPosition();
LineValue power = objectUnderTest.SortLine(data, result, 0, 3);
// assert
Assert.AreEqual(LineValue.HighCard, power);
Assert.AreEqual(13, result[0]);
Assert.AreEqual(11, result[1]);
Assert.AreEqual(10, result[2]);
}
public void Run(params string[] args)
{
if (Main == null)
{
throw new InvalidProgramException();
}
var lvs = new LineValue[args.Length];
for (int i = 0; i < args.Length; i++)
{
lvs[i] = new LineValueString()
{
Value = args[i]
};
}
Main.Invoke(lvs);
}
public void TestSortLineHighCard()
{
// assign
var data = InputReader.ReadInput("5h 6d Ks Ac 3d");
var result = new byte[5];
// act
var objectUnderTest = new LastTurnInPosition();
LineValue power = objectUnderTest.SortLine(data, result, 0, 5);
// assert
Assert.AreEqual(LineValue.HighCard, power);
Assert.AreEqual(13, result[0]);
Assert.AreEqual(12, result[1]);
Assert.AreEqual(5, result[2]);
Assert.AreEqual(4, result[3]);
Assert.AreEqual(2, result[4]);
}
public void TestSortLineStraight()
{
// assign
var data = InputReader.ReadInput("5h 6d 4s 3d 2c As 3s");
var result = new byte[5];
// act
var objectUnderTest = new LastTurnInPosition();
LineValue power = objectUnderTest.SortLine(data, result, 0, 5);
// assert
Assert.AreEqual(LineValue.Straight, power);
Assert.AreEqual(5, result[0]);
Assert.AreEqual(4, result[1]);
Assert.AreEqual(3, result[2]);
Assert.AreEqual(2, result[3]);
Assert.AreEqual(1, result[4]);
}
public void TestSortLineFlash()
{
// assign
var data = InputReader.ReadInput("2s 3h Qd 2d Jd Kd Ad 3s");
var result = new byte[5];
// act
var objectUnderTest = new LastTurnInPosition();
LineValue power = objectUnderTest.SortLine(data, result, 2, 5);
// assert
Assert.AreEqual(LineValue.Flash, power);
Assert.AreEqual(13, result[0]);
Assert.AreEqual(12, result[1]);
Assert.AreEqual(11, result[2]);
Assert.AreEqual(10, result[3]);
Assert.AreEqual(1, result[4]);
}
public void TestSortLineStraightFlush()
{
// assign
var data = InputReader.ReadInput("2s 2d 3d 4d 5d Ad 3s");
var result = new byte[5];
// act
var objectUnderTest = new LastTurnInPosition();
LineValue power = objectUnderTest.SortLine(data, result, 1, 5);
// assert
Assert.AreEqual(LineValue.StraightFlash, power);
Assert.AreEqual(4, result[0]);
Assert.AreEqual(3, result[1]);
Assert.AreEqual(2, result[2]);
Assert.AreEqual(1, result[3]);
Assert.AreEqual(13, result[4]);
}
public void TestCompareOneAnotherEqualLen()
{
// assign
var oneHand = InputReader.ReadInput("Ah Qh Jh 5d 4d");
var otherHand = InputReader.ReadInput("Ac Jc Qc 5s 4c");
var oneSorted = new byte[5];
var otherSorted = new byte[5];
var objectUnderTest = new LastTurnInPosition();
LineValue onePower = objectUnderTest.SortLine(oneHand, oneSorted, 0, 5);
LineValue otherPower = objectUnderTest.SortLine(otherHand, otherSorted, 0, 5);
// act
int result = objectUnderTest.CompareOneOther(oneSorted, otherSorted, onePower, otherPower);
// assert
Assert.IsTrue(result == 0);
}
public void TestCompareOneAnotherOnPower()
{
// assign
var oneHand = InputReader.ReadInput("Ah Ad Ac 3h 4d");
var otherHand = InputReader.ReadInput("7s 5c 5s 5d 5h");
var oneSorted = new byte[5];
var otherSorted = new byte[5];
var objectUnderTest = new LastTurnInPosition();
LineValue onePower = objectUnderTest.SortLine(oneHand, oneSorted, 0, 5);
LineValue otherPower = objectUnderTest.SortLine(otherHand, otherSorted, 0, 5);
// act
int result = objectUnderTest.CompareOneOther(oneSorted, otherSorted, onePower, otherPower);
// assert
Assert.IsTrue(result < 0);
}
public void TestCompareOneAnotherVariousPower()
{
// assign
var oneHand = InputReader.ReadInput("Qh Qd Jd 2c Js");
var otherHand = InputReader.ReadInput("4c 8h 5s 6c 7d");
var oneSorted = new byte[5];
var otherSorted = new byte[5];
var objectUnderTest = new LastTurnInPosition();
LineValue onePower = objectUnderTest.SortLine(oneHand, oneSorted, 0, 5);
LineValue otherPower = objectUnderTest.SortLine(otherHand, otherSorted, 0, 5);
// act
int result = objectUnderTest.CompareOneOther(oneSorted, otherSorted, onePower, otherPower);
// assert
Assert.IsTrue(result < 0);
}
public void TestSortLineSet()
{
// assign
var data = InputReader.ReadInput("5h 6d 2s 2d Ac 2c 3s");
var result = new byte[5];
// act
var objectUnderTest = new LastTurnInPosition();
LineValue power = objectUnderTest.SortLine(data, result, 2, 5);
// assert
Assert.AreEqual(LineValue.Set, power);
Assert.AreEqual(1, result[0]);
Assert.AreEqual(1, result[1]);
Assert.AreEqual(1, result[2]);
Assert.AreEqual(13, result[3]);
Assert.AreEqual(2, result[4]);
}
public cLineValue GetLineValue(string Key)
{
if (vSection.Count < 1)
{
return(null);
}
cLineValue pLineValue = null;
foreach (cLineValue LineValue in vSection)
{
if (LineValue.IsKey(Key))
{
pLineValue = LineValue;
}
}
return(pLineValue);
}
private void button1_Click(object sender, EventArgs e)
{
int c = 0;
LineValue dummyline = new LineValue();
foreach (FunctionTemplate ft in template.Templates)
{
ft.baseValue = this.Controls["Ed" + c].Text;
if (ft.DataType == dummyline.GetType())
{
int num1;
int num2;
num2 = Int32.Parse(this.Controls["pfholder" + c].Text);
num1 = Int32.Parse(ft.baseValue);
ft.baseValue = ((num1 << 16) + num2).ToString();
}
c++;
}
}
public decimal CalculateBonusShort(byte[] sortedLine, LineValue value)
{
if (value == LineValue.Set)
{
// за 222 - 10 оч, 333 - 111 оч итп ААА - 22 оч
return(10 + (sortedLine[0] - 1) % 13 + FantazyEV);
}
if (value == LineValue.Pair)
{
var bas = sortedLine[0] % 13 - 4;
decimal result = 0;
if (bas >= 7)
{
result += FantazyEV;
}
return(result + (bas > 0 ? bas : 0));
}
return(0);
}
public void TestIsHandDeadWhenAliveVariousCombo()
{
// assign
var shortHand = InputReader.ReadInput("Qh Qd Jd");
var shortSorted = new byte[3];
var middleHand = InputReader.ReadInput("Ah Kd Qs Jd Tc");
var middleSorted = new byte[5];
var topHand = InputReader.ReadInput("6d 6c 6s 2s 2c");
var topSorted = new byte[5];
var objectUnderTest = new LastTurnInPosition();
LineValue shortPower = objectUnderTest.SortLine(shortHand, shortSorted, 0, 3);
LineValue middlePower = objectUnderTest.SortLine(middleHand, middleSorted, 0, 5);
LineValue topPower = objectUnderTest.SortLine(topHand, topSorted, 0, 5);
// act
var isDead = objectUnderTest.IsHandDead(shortSorted, middleSorted, topSorted, shortPower, middlePower, topPower);
// assert
Assert.IsFalse(isDead);
}
public void TestIsHandDeadWhenLiveByEqual()
{
// assign
var shortHand = InputReader.ReadInput("Qh Jd Ts");
var shortSorted = new byte[3];
var middleHand = InputReader.ReadInput("Qs Jc Td 4c 3s");
var middleSorted = new byte[5];
var topHand = InputReader.ReadInput("Qd Js Th 4s 3c");
var topSorted = new byte[5];
var objectUnderTest = new LastTurnInPosition();
LineValue shortPower = objectUnderTest.SortLine(shortHand, shortSorted, 0, 3);
LineValue middlePower = objectUnderTest.SortLine(middleHand, middleSorted, 0, 5);
LineValue topPower = objectUnderTest.SortLine(topHand, topSorted, 0, 5);
// act
var isDead = objectUnderTest.IsHandDead(shortSorted, middleSorted, topSorted, shortPower, middlePower, topPower);
// assert
Assert.IsFalse(isDead);
}
public void TestIsHandDeadWhenDeadByHighCardKicker()
{
// assign
var shortHand = InputReader.ReadInput("Qh Ad Jd");
var shortSorted = new byte[3];
var middleHand = InputReader.ReadInput("Qs 7c Jd Tc 9s");
var middleSorted = new byte[5];
var topHand = InputReader.ReadInput("Kd Kc 6s 2s 3c");
var topSorted = new byte[5];
var objectUnderTest = new LastTurnInPosition();
LineValue shortPower = objectUnderTest.SortLine(shortHand, shortSorted, 0, 3);
LineValue middlePower = objectUnderTest.SortLine(middleHand, middleSorted, 0, 5);
LineValue topPower = objectUnderTest.SortLine(topHand, topSorted, 0, 5);
// act
var isDead = objectUnderTest.IsHandDead(shortSorted, middleSorted, topSorted, shortPower, middlePower, topPower);
// assert
Assert.IsTrue(isDead);
}
private void ArgumentBox_MouseDoubleClick(object sender, MouseEventArgs e)
{
int funcnum = Int32.Parse(strBefore(strAfter(FunctionBox.SelectedItem.ToString(), "("), ")"));
if (NamesandNumbers.Functiontemplates.ContainsKey(funcnum))
{
DynamicEdit de = new DynamicEdit();
FunctionTemplates ft = NamesandNumbers.Functiontemplates[funcnum];
PlayfieldValue dummypf = new PlayfieldValue();
LineValue dummyline = new LineValue();
int argnum = 0;
foreach (FunctionTemplate tmpl in ft.Templates)
{
if (ArgumentBox.Items.Count > argnum)
{
tmpl.baseValue = ArgumentBox.Items[argnum++].ToString();
}
}
de.createDynels(ft);
de.Controls["button_cancel"].Enabled = sender != null;
de.ShowDialog();
if (de.DialogResult == DialogResult.OK)
{
ArgumentBox.Items.Clear();
argnum = 0;
common.execSQL("DELETE FROM statel_function_arguments WHERE statel_id=" + selectedstatel + " AND event_id=" + selectedevent + " AND function_id=" + selectedfunction);
foreach (FunctionTemplate tmpl in de.template.Templates)
{
ArgumentBox.Items.Add(tmpl.baseValue);
common.execSQL("INSERT INTO statel_function_arguments VALUES (" + argnum + "," + selectedfunction + "," + selectedevent + "," + selectedstatel + ",'" + tmpl.baseValue + "')");
argnum++;
}
}
}
else
{
MessageBox.Show("Function not implemented yet");
}
}
public void TestScoreCompareAliveVsDead()
{
// assign
var heroShortHand = InputReader.ReadInput("Qh Jd Ts");
var heroShortSorted = new byte[3];
var heroMiddleHand = InputReader.ReadInput("Ac 2s As 2d 3h");
var heroMiddleSorted = new byte[5];
var heroTopHand = InputReader.ReadInput("Th 9d 9c Tc Ts");
var heroTopSorted = new byte[5];
var villainShortHand = InputReader.ReadInput("8d 8s 2c");
var villainShortSorted = new byte[3];
var villainMiddleHand = InputReader.ReadInput("7d 6c 7s 5c 3h");
var villainMiddleSorted = new byte[5];
var villainTopHand = InputReader.ReadInput("Ad Kd Qd Jd Td");
var villainTopSorted = new byte[5];
var objectUnderTest = new LastTurnInPosition();
LineValue heroShortPower = objectUnderTest.SortLine(heroShortHand, heroShortSorted, 0, 3);
LineValue heroMiddlePower = objectUnderTest.SortLine(heroMiddleHand, heroMiddleSorted, 0, 5);
LineValue heroTopPower = objectUnderTest.SortLine(heroTopHand, heroTopSorted, 0, 5);
LineValue villainShortPower = objectUnderTest.SortLine(villainShortHand, villainShortSorted, 0, 3);
LineValue villainMiddlePower = objectUnderTest.SortLine(villainMiddleHand, villainMiddleSorted, 0, 5);
LineValue villainTopPower = objectUnderTest.SortLine(villainTopHand, villainTopSorted, 0, 5);
var isHeroHandDead = objectUnderTest.IsHandDead(heroShortSorted, heroMiddleSorted, heroTopSorted,
heroShortPower, heroMiddlePower, heroTopPower);
var isVillainHandDead = objectUnderTest.IsHandDead(villainShortSorted, villainMiddleSorted, villainTopSorted,
villainShortPower, villainMiddlePower, villainTopPower);
//act
var score = objectUnderTest.ScoreCompare(isHeroHandDead, isVillainHandDead, heroShortSorted, heroMiddleSorted,
heroTopSorted, heroShortPower, heroMiddlePower, heroTopPower, villainShortSorted, villainMiddleSorted,
villainTopSorted, villainShortPower, villainMiddlePower, villainTopPower);
// assert
Assert.AreEqual(6, score);
}
public LineValue SortLine(byte[] hand, byte[] line, int startIndexInc, int length)
{
LineValue value = LineValue.Undefined;
byte[] valueCountArray = new byte[13];
var color = (int)((hand[startIndexInc] - 1) / 13);
var isFlash = true;
for (int i = startIndexInc; i < startIndexInc + length; i++)
{
if (hand[i] == 0)
{
return(LineValue.Undefined);
}
var nextColor = ((int)((hand[i] - 1) / 13));
if (nextColor != color)
{
isFlash = false;
}
valueCountArray[(hand[i] - 1) % 13]++;
}
int minIndex = 100;
int maxIndex = -1;
for (byte i = 0; i < valueCountArray.Length; i++)
{
if (valueCountArray[i] > 0)
{
if (i < minIndex)
{
minIndex = i;
}
if (i > maxIndex)
{
maxIndex = i;
}
}
if (!isFlash)
{
#region каре
if (valueCountArray[i] == 4)
{
line[0] = (byte)(i + 1);
line[1] = (byte)(i + 1);
line[2] = (byte)(i + 1);
line[3] = (byte)(i + 1);
for (int k = 0; k < valueCountArray.Length; k++)
{
if (valueCountArray[k] == 1)
{
line[4] = (byte)(k + 1);
}
}
return(LineValue.Care);
}
#endregion
#region сет и фулхауз
else if (valueCountArray[i] == 3)
{
int lineCounter = 0;
line[0] = (byte)(i + 1);
line[1] = (byte)(i + 1);
line[2] = (byte)(i + 1);
for (int k = 0; k < valueCountArray.Length; k++)
{
if (valueCountArray[k] == 2)
{
line[3] = (byte)(k + 1);
line[4] = (byte)(k + 1);
return(LineValue.FullHouse);
}
else if (valueCountArray[k] == 1)
{
if (line[4] == 0)
{
line[4] = (byte)(k + 1);
}
else
{
line[3] = (byte)(k + 1);
}
}
}
return(LineValue.Set);
}
#endregion
#region пара фуллхауз или две пары
else if (valueCountArray[i] == 2)
{
for (int k = i + 1; k < valueCountArray.Length; k++)
{
if (valueCountArray[k] == 3)
{
line[0] = (byte)(k + 1);
line[1] = (byte)(k + 1);
line[2] = (byte)(k + 1);
line[3] = (byte)(i + 1);
line[4] = (byte)(i + 1);
return(LineValue.FullHouse);
}
else if (valueCountArray[k] == 2)
{
line[0] = (byte)(k + 1);
line[1] = (byte)(k + 1);
line[2] = (byte)(i + 1);
line[3] = (byte)(i + 1);
for (int j = 0; j < valueCountArray.Length; j++)
{
if (valueCountArray[j] == 1)
{
line[4] = (byte)(j + 1);
}
}
return(LineValue.TwoPair);
}
}
line[0] = (byte)(i + 1);
line[1] = (byte)(i + 1);
for (int k = 0; k < valueCountArray.Length; k++)
{
if (valueCountArray[k] == 1)
{
if (line.Length == 5)
{
if (line[4] == 0)
{
line[4] = (byte)(k + 1);
}
else if (line[3] == 0)
{
line[3] = (byte)(k + 1);
}
else
{
line[2] = (byte)(k + 1);
}
}
else
{
line[2] = (byte)(k + 1);
}
}
}
return(LineValue.Pair);
}
#endregion
}
}
#region флеш стритфлеш
if (line.Length == 5 && isFlash)
{
if (maxIndex - minIndex == 4)
{
line[0] = (byte)(minIndex + 5);
line[1] = (byte)(minIndex + 4);
line[2] = (byte)(minIndex + 3);
line[3] = (byte)(minIndex + 2);
line[4] = (byte)(minIndex + 1);
// if Ace - royal
if ((byte)(minIndex + 5) == 13)
{
return(LineValue.Royal);
}
return(LineValue.StraightFlash);
}
if (valueCountArray[0] == 1 && valueCountArray[1] == 1 &&
valueCountArray[2] == 1 && valueCountArray[3] == 1 && valueCountArray[12] == 1)
{
line[0] = 4;
line[1] = 3;
line[2] = 2;
line[3] = 1;
line[4] = 13;
return(LineValue.StraightFlash);
}
int LineCounter = 4;
for (int i = 0; i < valueCountArray.Length; i++)
{
if (valueCountArray[i] == 1)
{
line[LineCounter] = (byte)(i + 1);
LineCounter--;
}
}
return(LineValue.Flash);
}
#endregion
# region нет пар сетов фуллов и каре и расстояние = 5 === стрит
if (line.Length == 5 && maxIndex - minIndex == 4)
public string ParseValue(int startIndex, int length)
{
return(LineValue.Substring(startIndex, length));
}
/// <summary>
/// Append part.
/// </summary>
/// <param name="appender"></param>
/// <param name="previous"></param>
/// <param name="args"></param>
/// <param name="line"></param>
/// <returns></returns>
public virtual bool TryCreate(ILineFactory appender, ILine previous, object[] args, out ILineValue line)
{
line = new LineValue(appender, previous, args);
return(true);
}
public decimal TryPlace(int firstIndex, int secondIndex, byte card1, byte card2, byte[] heroHand,
byte[] heroShortLine, byte[] heroMiddleLine, byte[] heroTopLine,
LineValue shortHeroValue, LineValue middleHeroValue, LineValue topHeroValue,
byte[] villainShortLine, byte[] villainMiddleLine, byte[] villainTopLine,
LineValue shortVillainValue, LineValue middleVillainValue, LineValue topVillainValue, bool isVillainHandDead)
{
heroHand[firstIndex] = card1;
heroHand[secondIndex] = card2;
if (firstIndex < 3)
{
byte[] firstLine = new byte[3];
var firstValue = SortLine(heroHand, firstLine, 0, 3);
var bonusShort = CalculateBonusShort(firstLine, firstValue);
if (secondIndex > 2 && secondIndex < 8)
{
byte[] secondLine = new byte[5];
var secondValue = SortLine(heroHand, secondLine, 3, 5);
var isHeroHandDead = IsHandDead(firstLine, secondLine, heroTopLine, firstValue, secondValue, topHeroValue);
var score = ScoreCompare(isHeroHandDead, isVillainHandDead,
firstLine, secondLine, heroTopLine, firstValue, secondValue, topHeroValue,
villainShortLine, villainMiddleLine, villainTopLine, shortVillainValue, middleVillainValue, topVillainValue);
if (!isHeroHandDead)
{
return(bonusShort + CalculateBonusMiddle(secondLine, secondValue) + score);
}
else
{
return(score);
}
}
else if (secondIndex >= 8)
{
byte[] secondLine = new byte[5];
var secondValue = SortLine(heroHand, secondLine, 3, 5);
var isHeroHandDead = IsHandDead(firstLine, heroMiddleLine, secondLine, firstValue, middleHeroValue, secondValue);
var score = ScoreCompare(isHeroHandDead, isVillainHandDead,
firstLine, heroMiddleLine, secondLine, firstValue, middleHeroValue, secondValue,
villainShortLine, villainMiddleLine, villainTopLine, shortVillainValue, middleVillainValue, topVillainValue);
if (!isHeroHandDead)
{
return(bonusShort + CalculateBonusTop(secondLine, secondValue) + score);
}
else
{
return(score);
}
}
else // both slots in first line
{
var isHeroHandDead = IsHandDead(firstLine, heroMiddleLine, heroTopLine, firstValue, middleHeroValue, topHeroValue);
var score = ScoreCompare(isHeroHandDead, isVillainHandDead,
firstLine, heroMiddleLine, heroTopLine, firstValue, middleHeroValue, topHeroValue,
villainShortLine, villainMiddleLine, villainTopLine, shortVillainValue, middleVillainValue, topVillainValue);
if (!isHeroHandDead)
{
return(bonusShort + score);
}
else
{
return(score);
}
}
}
else if (firstIndex < 8)
{
byte[] firstLine = new byte[5];
var firstValue = SortLine(heroHand, firstLine, 3, 5);
var bonusMiddle = CalculateBonusMiddle(firstLine, firstValue);
if (secondIndex >= 8)
{
byte[] secondLine = new byte[5];
var secondValue = SortLine(heroHand, secondLine, 8, 5);
var isHeroHandDead = IsHandDead(heroShortLine, firstLine, secondLine, shortHeroValue, firstValue, secondValue);
var score = ScoreCompare(isHeroHandDead, isVillainHandDead,
heroShortLine, firstLine, secondLine, shortHeroValue, firstValue, secondValue,
villainShortLine, villainMiddleLine, villainTopLine, shortVillainValue, middleVillainValue, topVillainValue);
if (!isHeroHandDead)
{
return(bonusMiddle + CalculateBonusTop(secondLine, secondValue) + score);
}
else
{
return(score);
}
}
else // both slots in second line
{
var isHeroHandDead = IsHandDead(heroShortLine, firstLine, heroTopLine, shortHeroValue, firstValue, topHeroValue);
var score = ScoreCompare(isHeroHandDead, isVillainHandDead,
heroShortLine, firstLine, heroTopLine, shortHeroValue, firstValue, topHeroValue,
villainShortLine, villainMiddleLine, villainTopLine, shortVillainValue, middleVillainValue, topVillainValue);
if (!isHeroHandDead)
{
return(bonusMiddle + score);
}
else
{
return(score);
}
}
}
else // both slots in third line
{
byte[] firstLine = new byte[5];
var firstValue = SortLine(heroHand, firstLine, 8, 5);
var isHeroHandDead = IsHandDead(heroShortLine, heroMiddleLine, firstLine, shortHeroValue, middleHeroValue, firstValue);
var score = ScoreCompare(isHeroHandDead, isVillainHandDead,
heroShortLine, heroMiddleLine, firstLine, shortHeroValue, middleHeroValue, firstValue,
villainShortLine, villainMiddleLine, villainTopLine, shortVillainValue, middleVillainValue, topVillainValue);
if (!isHeroHandDead)
{
return(CalculateBonusTop(firstLine, firstValue) + score);
}
else
{
return(score);
}
}
}
