public void DoubleSelfTackleAddsTwoBeers()
{
var pos = getStartPositions();
pos[0] = Position.Green5;
pos[1] = Position.Green5;
pos[4] = Position.RedStart;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Green, 2);
sit.ApplyMove(moves[0]);
Assert.AreEqual(2, sit.beers[(int)Piece.Green]);
}
public void MoveToGoalIfPossible()
{
var pos = getStartPositions();
pos[0] = Position.Yellow6;
pos[1] = Position.Green1;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Green, 2);
int selected = p.SelectMove(sit, moves, Piece.Green, 2);
var selectedMove = moves[selected];
Assert.AreEqual(Position.Yellow6, selectedMove.StartPosition);
}
public void GetOutOfHomeIfPossible()
{
var pos = getStartPositions();
pos[0] = Position.Blue2;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Green, 6);
int selected = p.SelectMove(sit, moves, Piece.Green, 6);
var selectedMove = moves[selected];
Assert.AreEqual(Position.GreenStart, selectedMove.EndPosition);
}
public void EatIfYouCan()
{
var pos = getStartPositions();
pos[0] = Position.Blue1;
pos[1] = Position.Green1;
pos[4] = Position.Green3;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Green, 2);
int selected = p.SelectMove(sit, moves, Piece.Green, 2);
var selectedMove = moves[selected];
Assert.AreEqual(Position.Green1, selectedMove.StartPosition);
}
public void DoubleUnfoldsToStartPosition()
{
var pos = getStartPositions();
pos[4] = pos[5] = Position.RedGoal1;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Red, 3);
Assert.AreEqual(1, moves.Length);
sit.ApplyMove(moves[0]);
Assert.AreEqual(Piece.Red, sit.board[(int)Position.RedGoal1]);
Assert.AreEqual(Piece.None, sit.board[(int)Position.RedGoal2]);
Assert.AreEqual(Piece.None, sit.board[(int)Position.RedGoal3]);
Assert.AreEqual(Piece.Red, sit.board[(int)Position.RedGoal4]);
}
public void TestGreenShouldGetToGoal()
{
Position[] pos = getStartPositions();
pos[0] = Position.Yellow6;
Situation start = new Situation(pos);
Move[] moves = start.GetMoves(Piece.Green, 1);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Yellow6, moves[0].StartPosition);
Assert.AreEqual(Position.GreenGoal1, moves[0].EndPosition);
moves = start.GetMoves(Piece.Green, 2);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Yellow6, moves[0].StartPosition);
Assert.AreEqual(Position.GreenGoal2, moves[0].EndPosition);
moves = start.GetMoves(Piece.Green, 3);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Yellow6, moves[0].StartPosition);
Assert.AreEqual(Position.GreenGoal3, moves[0].EndPosition);
moves = start.GetMoves(Piece.Green, 4);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Yellow6, moves[0].StartPosition);
Assert.AreEqual(Position.GreenGoal4, moves[0].EndPosition);
moves = start.GetMoves(Piece.Green, 5);
Assert.AreEqual(0, moves.Length);
}
public void TestDoubleGetsEatenAndGetsOut()
{
var pos = getStartPositions();
pos[0] = pos[1] = Position.RedStart;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Red, 6);
sit.ApplyMove(moves[0]);
moves = sit.GetMoves(Piece.Green, 6);
sit.ApplyMove(moves[0]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenStart]);
Assert.AreEqual(Piece.None, sit.board[(int)Position.GreenHome1]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenHome2]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenHome3]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenHome4]);
Assert.IsTrue(sit.Validate());
}
public void TestAfterEatingHomePiecesShouldBeLastInPieceList()
{
Position[] pos = getStartPositions();
pos[0] = Position.Yellow1;
pos[4] = Position.GreenStart;
pos[5] = Position.Yellow3;
pos[6] = Position.Red2;
Situation start = new Situation(pos);
Move[] moves = start.GetMoves(Piece.Green, 2);
start.ApplyMove(moves[0]);
Assert.AreEqual(Position.GreenStart, start.pieces[4]);
Assert.AreEqual(Position.Red2, start.pieces[5]);
Assert.AreEqual(Position.RedHome3, start.pieces[6]);
Assert.AreEqual(Position.RedHome4, start.pieces[7]);
}
public void Test2DoublePieces()
{
var pos = getStartPositions();
pos[0] = pos[1] = Position.Yellow2;
pos[2] = pos[3] = Position.Red2;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Green, 4);
sit.ApplyMove(moves[1]);
Assert.AreEqual(2, moves.Length);
Assert.AreEqual(0, moves[0].Piece);
Assert.AreEqual(Position.Yellow2, moves[0].StartPosition);
Assert.AreEqual(Position.Yellow6, moves[0].EndPosition);
Assert.AreEqual(2, moves[1].Piece);
Assert.AreEqual(Position.Red2, moves[1].StartPosition);
Assert.AreEqual(Position.Red6, moves[1].EndPosition);
Assert.AreEqual(Position.Red6, sit.pieces[2]);
Assert.AreEqual(Position.Red6, sit.pieces[3]);
Assert.AreEqual(Piece.None, sit.board[(int)Position.Red2]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.Red6]);
}
public void TestYouCannotMoveOntoYourOwnPiece()
{
Position[] pos = getStartPositions();
pos[0] = Position.Green6;
pos[1] = Position.Green4;
pos[2] = Position.Green2;
Situation start = new Situation(pos);
Move[] moves = start.GetMoves(Piece.Green, 2);
Assert.AreEqual(1, moves.Length, "Should only have 1 option, as others move onto your own piece");
Assert.AreEqual(Position.Green6, moves[0].StartPosition);
Assert.AreEqual(Position.Red1, moves[0].EndPosition);
}
public void TestBasicMove()
{
Position[] pos = getStartPositions();
pos[0] = Position.GreenStart;
Situation start = new Situation(pos);
Move[] moves;
for (int i = 1; i < 6; i++)
{
moves = start.GetMoves(Piece.Green, i);
Assert.AreEqual(1, moves.Length, "Should have 1 option for roll " + i);
Assert.AreEqual((Position)((byte)Position.GreenStart + i), moves[0].EndPosition, "Should move correct amount");
}
moves = start.GetMoves(Piece.Green, 6);
Assert.AreEqual(2, moves.Length, "Should have 2 options for 6");
}
public void TestRedShouldGetToGoal()
{
Position[] pos = getStartPositions();
pos[4] = Position.Green5;
Situation start = new Situation(pos);
Move[] moves = start.GetMoves(Piece.Red, 1);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Green5, moves[0].StartPosition);
Assert.AreEqual(Position.Green6, moves[0].EndPosition);
moves = start.GetMoves(Piece.Red, 2);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Green5, moves[0].StartPosition);
Assert.AreEqual(Position.RedGoal1, moves[0].EndPosition);
moves = start.GetMoves(Piece.Red, 3);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Green5, moves[0].StartPosition);
Assert.AreEqual(Position.RedGoal2, moves[0].EndPosition);
moves = start.GetMoves(Piece.Red, 4);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Green5, moves[0].StartPosition);
Assert.AreEqual(Position.RedGoal3, moves[0].EndPosition);
moves = start.GetMoves(Piece.Red, 5);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Green5, moves[0].StartPosition);
Assert.AreEqual(Position.RedGoal4, moves[0].EndPosition);
moves = start.GetMoves(Piece.Red, 6);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.RedHome2, moves[0].StartPosition);
Assert.AreEqual(Position.RedStart, moves[0].EndPosition);
}
public void DoubleUnfoldsWhenPiecesBeforeItAreFilled()
{
var pos = getStartPositions();
pos[0] = Position.GreenGoal4;
pos[1] = pos[2] = Position.GreenGoal2;
pos[3] = Position.GreenGoal1;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Green, 2);
sit.ApplyMove(moves[0]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenGoal1]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenGoal2]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenGoal3]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenGoal4]);
Assert.AreEqual(Piece.Green, sit.GetWinner());
}
public void TestRedCanQuadruple()
{
Position[] pos = getStartPositions();
pos[4] = Position.RedStart;
pos[5] = Position.RedStart;
pos[6] = Position.RedStart;
Situation sit = new Situation(pos);
for (int i = 4; i < 7; i++)
{
Assert.AreEqual(Position.RedStart, sit.pieces[i]);
}
Move[] moves = sit.GetMoves(Piece.Red, 6);
Assert.AreEqual(2, moves.Length);
Assert.AreEqual(Position.RedStart, moves[0].StartPosition);
Assert.AreEqual(Position.Red6, moves[0].EndPosition);
Assert.AreEqual(Position.RedHome4, moves[1].StartPosition);
Assert.AreEqual(Position.RedStart, moves[1].EndPosition);
Assert.AreEqual(MoveType.DoubleUp, moves[1].Type);
sit.ApplyMove(moves[1]);
for (int i = 4; i < 8; i++)
{
Assert.AreEqual(Position.RedStart, sit.pieces[i]);
}
moves = sit.GetMoves(Piece.Red, 3);
Assert.AreEqual(1, moves.Length);
sit.ApplyMove(moves[0]);
for (int i = 4; i < 8; i++)
{
Assert.AreEqual(Position.Red3, sit.pieces[i]);
}
Assert.AreEqual(Piece.None, sit.board[(int)Position.RedStart]);
Assert.AreEqual(Piece.Red, sit.board[(int)Position.Red3]);
}
public void TestDoubleArrivesToGoalWithPieceAlreadyInGoal()
{
var pos = getStartPositions();
pos[0] = Position.GreenGoal1;
pos[1] = pos[2] = Position.Yellow6;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Green, 4);
sit.ApplyMove(moves[0]);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.GreenGoal4, moves[0].EndPosition);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenGoal2]);
Assert.AreEqual(Piece.None, sit.board[(int)Position.GreenGoal3]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenGoal4]);
}
public void TestDoubleArrivesToGoal3()
{
var pos = getStartPositions();
pos[0] = pos[1] = Position.Yellow6;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Green, 3);
sit.ApplyMove(moves[0]);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.GreenGoal3, moves[0].EndPosition);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenGoal1]);
Assert.AreEqual(Piece.None, sit.board[(int)Position.GreenGoal2]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenGoal3]);
Assert.AreEqual(Piece.None, sit.board[(int)Position.GreenGoal4]);
Assert.IsTrue(sit.Validate());
}
public void TestBlueShouldGetToGoal()
{
Position[] pos = getStartPositions();
pos[8] = Position.Red4;
Situation start = new Situation(pos);
Move[] moves = start.GetMoves(Piece.Blue, 1);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Red4, moves[0].StartPosition);
Assert.AreEqual(Position.Red5, moves[0].EndPosition);
moves = start.GetMoves(Piece.Blue, 2);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Red4, moves[0].StartPosition);
Assert.AreEqual(Position.Red6, moves[0].EndPosition);
moves = start.GetMoves(Piece.Blue, 3);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Red4, moves[0].StartPosition);
Assert.AreEqual(Position.BlueGoal1, moves[0].EndPosition);
moves = start.GetMoves(Piece.Blue, 4);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Red4, moves[0].StartPosition);
Assert.AreEqual(Position.BlueGoal2, moves[0].EndPosition);
moves = start.GetMoves(Piece.Blue, 5);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Red4, moves[0].StartPosition);
Assert.AreEqual(Position.BlueGoal3, moves[0].EndPosition);
moves = start.GetMoves(Piece.Blue, 6);
Assert.AreEqual(2, moves.Length);
Assert.AreEqual(Position.Red4, moves[0].StartPosition);
Assert.AreEqual(Position.BlueGoal4, moves[0].EndPosition);
Assert.AreEqual(Position.BlueHome2, moves[1].StartPosition);
Assert.AreEqual(Position.BlueStart, moves[1].EndPosition);
}
public void TestCannotEatAPieceInStartPosition()
{
Position[] pos = getStartPositions();
pos[0] = Position.Green6;
pos[4] = Position.RedStart;
Situation sit = new Situation(pos);
Move[] moves = sit.GetMoves(Piece.Green, 1);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Green6, moves[0].StartPosition);
Assert.AreEqual(Position.GreenHome1, moves[0].EndPosition);
}
public void TestRedCanTriple()
{
Position[] pos = getStartPositions();
pos[4] = Position.RedStart;
pos[5] = Position.RedStart;
Situation sit = new Situation(pos);
Move[] moves = sit.GetMoves(Piece.Red, 6);
Assert.AreEqual(2, moves.Length);
Assert.AreEqual(Position.RedStart, moves[0].StartPosition);
Assert.AreEqual(Position.Red6, moves[0].EndPosition);
Assert.AreEqual(Position.RedHome3, moves[1].StartPosition);
Assert.AreEqual(Position.RedStart, moves[1].EndPosition);
Assert.AreEqual(MoveType.DoubleUp, moves[1].Type);
}
public void TestDoublePieceMovesTogether()
{
Position[] pos = getStartPositions();
pos[0] = Position.GreenStart;
pos[1] = Position.GreenStart;
Situation sit = new Situation(pos);
Move[] moves = sit.GetMoves(Piece.Green, 3);
Assert.AreEqual(1, moves.Length);
sit.ApplyMove(moves[0]);
Assert.AreEqual(Piece.None, sit.board[(int)Position.GreenStart]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.Green3]);
Assert.AreEqual(Position.Green3, sit.pieces[0]);
Assert.AreEqual(Position.Green3, sit.pieces[1]);
}
public void TestTripleGetEaten()
{
var pos = getStartPositions();
pos[0] = Position.GreenGoal1;
pos[1] = pos[2] = pos[3] = Position.Yellow6;
pos[4] = Position.Yellow3;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Red, 3);
sit.ApplyMove(moves[0]);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Yellow6, moves[0].EndPosition);
Assert.AreEqual(Piece.None, sit.board[(int)Position.GreenHome1]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenHome2]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenHome3]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenHome4]);
Assert.AreEqual(Position.GreenGoal1, sit.pieces[0]);
Assert.AreEqual(Position.GreenHome2, sit.pieces[1]);
Assert.AreEqual(Position.GreenHome3, sit.pieces[2]);
Assert.AreEqual(Position.GreenHome4, sit.pieces[3]);
}
public void TestEating()
{
Position[] pos = getStartPositions();
pos[0] = Position.Red1;
pos[4] = Position.Red4;
Situation start = new Situation(pos);
Move[] moves = start.GetMoves(Piece.Green, 3);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Red1, moves[0].StartPosition);
Assert.AreEqual(Position.Red4, moves[0].EndPosition);
start.ApplyMove(moves[0]);
Assert.AreEqual(Piece.None, start.board[(int)Position.Red1]);
Assert.AreEqual(Piece.Green, start.board[(int)Position.Red4]);
Assert.AreEqual(Piece.Red, start.board[(int)Position.RedHome1]);
Assert.AreEqual(Piece.Red, start.board[(int)Position.RedHome2]);
Assert.AreEqual(Piece.Red, start.board[(int)Position.RedHome4]);
Assert.AreEqual(Piece.Red, start.board[(int)Position.RedHome3]);
Assert.AreEqual(Position.RedHome1, start.pieces[4]);
}
public void TestYellowShouldGetToGoal()
{
Position[] pos = getStartPositions();
pos[12] = Position.Blue3;
Situation start = new Situation(pos);
Move[] moves = start.GetMoves(Piece.Yellow, 1);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Blue3, moves[0].StartPosition);
Assert.AreEqual(Position.Blue4, moves[0].EndPosition);
moves = start.GetMoves(Piece.Yellow, 2);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Blue3, moves[0].StartPosition);
Assert.AreEqual(Position.Blue5, moves[0].EndPosition);
moves = start.GetMoves(Piece.Yellow, 3);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Blue3, moves[0].StartPosition);
Assert.AreEqual(Position.Blue6, moves[0].EndPosition);
moves = start.GetMoves(Piece.Yellow, 4);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Blue3, moves[0].StartPosition);
Assert.AreEqual(Position.YellowGoal1, moves[0].EndPosition);
moves = start.GetMoves(Piece.Yellow, 5);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Blue3, moves[0].StartPosition);
Assert.AreEqual(Position.YellowGoal2, moves[0].EndPosition);
moves = start.GetMoves(Piece.Yellow, 6);
Assert.AreEqual(2, moves.Length);
Assert.AreEqual(Position.Blue3, moves[0].StartPosition);
Assert.AreEqual(Position.YellowGoal3, moves[0].EndPosition);
Assert.AreEqual(Position.YellowHome2, moves[1].StartPosition);
Assert.AreEqual(Position.YellowStart, moves[1].EndPosition);
}
public void TestEatingWithMultiplePiecesOnBoard()
{
Position[] pos = getStartPositions();
pos[0] = Position.Red1;
pos[4] = Position.GreenStart;
pos[5] = Position.Yellow3;
pos[6] = Position.Red2;
Situation start = new Situation(pos);
Move[] moves = start.GetMoves(Piece.Green, 1);
Assert.AreEqual(1, moves.Length);
Assert.AreEqual(Position.Red1, moves[0].StartPosition);
Assert.AreEqual(Position.Red2, moves[0].EndPosition);
start.ApplyMove(moves[0]);
Assert.AreEqual(Piece.None, start.board[(int)Position.Red1]);
Assert.AreEqual(Piece.Green, start.board[(int)Position.Red2]);
Assert.AreEqual(Piece.None, start.board[(int)Position.RedHome1]);
Assert.AreEqual(Piece.None, start.board[(int)Position.RedHome2]);
Assert.AreEqual(Piece.Red, start.board[(int)Position.RedHome4]);
Assert.AreEqual(Piece.Red, start.board[(int)Position.RedHome3]);
Assert.AreEqual(Position.RedHome3, start.pieces[6]);
}
public void TripleFinishesOverOwnPiece()
{
var pos = getStartPositions();
pos[0] = Position.GreenGoal2;
pos[1] = pos[2] = pos[3] = Position.GreenGoal1;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Green, 3);
sit.ApplyMove(moves[0]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenGoal1]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenGoal2]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenGoal3]);
Assert.AreEqual(Piece.Green, sit.board[(int)Position.GreenGoal4]);
Assert.AreEqual(Piece.Green, sit.GetWinner());
}
public void TestGeneratingMovesDoesNotBreakGroupings()
{
var pos = getStartPositions();
pos[8] = pos[9] = Position.BlueGoal1;
pos[10] = pos[11] = Position.BlueStart;
var sit = new Situation(pos);
Move[] moves = sit.GetMoves(Piece.Blue, 3);
Assert.AreEqual(4, sit.groupingDict.Count);
foreach (List<int> grouping in sit.groupingDict.Values)
{
Assert.AreEqual(2, grouping.Count);
}
}
public void TestGreenCanDouble()
{
Position[] pos = getStartPositions();
pos[0] = Position.GreenStart;
Situation sit = new Situation(pos);
Move[] moves = sit.GetMoves(Piece.Green, 6);
Assert.AreEqual(2, moves.Length);
Assert.AreEqual(Position.GreenStart, moves[0].StartPosition);
Assert.AreEqual(Position.Green6, moves[0].EndPosition);
Assert.AreEqual(Position.GreenHome2, moves[1].StartPosition);
Assert.AreEqual(Position.GreenStart, moves[1].EndPosition);
Assert.AreEqual(MoveType.DoubleUp, moves[1].Type);
}
public void TestGreenGoesToGoal()
{
var pos = getStartPositions();
pos[0] = Position.GreenGoal3;
pos[1] = Position.Yellow6;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Green, 1);
Assert.AreEqual(2, moves.Length);
sit.ApplyMove(moves[1]);
Assert.AreEqual(Position.GreenGoal1, sit.pieces[1]);
moves = sit.GetMoves(Piece.Green, 2);
Assert.AreEqual(0, moves.Length);
}
static void Main(string[] args)
{
List<Position> positionList = new List<Position>();
positionList.AddRange(new Position[] { Position.GreenGoal4, Position.GreenGoal3, Position.GreenGoal2, Position.GreenGoal1});
for (int p = (int)Position.Yellow6; p >= (int)Position.GreenStart; p--)
{
positionList.Add((Position)p);
}
positionList.AddRange(new Position[] { Position.GreenHome4, Position.GreenHome3, Position.GreenHome2, Position.GreenHome1 });
Position[] positionOrder = positionList.ToArray();
int len = positionOrder.Length;
int homeStart = len-4;
bool first = true;
for (int i = 0; i < len; i++)
{
for (int j = Math.Max(i, 1); j < len; j++)
{
if (i == j && i >= homeStart)
continue;
for (int k = Math.Max(j, 2); k < len; k++)
{
if (j == k && j >= homeStart)
continue;
for (int l = Math.Max(k,3); l < len; l++)
{
if (k == l && k >= homeStart)
continue;
var pos = getStartPositions();
pos[0] = positionOrder[i];
pos[1] = positionOrder[j];
pos[2] = positionOrder[k];
pos[3] = positionOrder[l];
Situation sit = new Situation(pos);
Situation s2 = new Situation(sit);
if (s2.UnfoldMultiples(Piece.Green))
{
continue;
}
int nomoves = 0;
decimal ev = 0;
if (first)
{
SaveValue(sit, 0);
first = false;
continue;
}
for (int roll = 1; roll <= 6; roll++)
{
Move[] moves = sit.GetMoves(Piece.Green, roll);
if (moves.Length == 0)
{
nomoves++;
}
else
{
decimal value = Decimal.MaxValue;
foreach(Move move in moves)
{
Situation s = new Situation(sit);
s.ApplyMove(move);
value = Math.Min(value, GetValue(s));
}
ev += value;
}
}
if (sit.GetNumberOfTries(Piece.Green) == 3)
{
ev = (5 * nomoves * nomoves + (36 + 6 * nomoves + nomoves * nomoves) * ev) / (216 - nomoves * nomoves * nomoves);
}
else
{
ev = (5 + ev) / (6 - nomoves);
}
SaveValue(sit, ev);
Console.WriteLine(positionOrder[i] + " "
+ positionOrder[j] + " "
+ positionOrder[k] + " "
+ positionOrder[l] + ": " + ev);
}
}
}
}
Byte[] bytes = new Byte[6 * dict.Count];
int offset = 0;
foreach (KeyValuePair<int, decimal> kvp in dict)
{
Array.Copy(System.BitConverter.GetBytes(kvp.Key), 0, bytes, offset, 4);
offset += 4;
Array.Copy(System.BitConverter.GetBytes((Int16)(kvp.Value * 256)), 0, bytes, offset, 2);
offset += 2;
}
File.WriteAllBytes("singleplayer.data", bytes);
Console.ReadLine();
}
public void RedShouldGetTwoBeersWhenAPieceIsEatenByADouble()
{
var pos = getStartPositions();
pos[0] = Position.Blue1;
pos[1] = Position.Blue1;
pos[5] = Position.Blue3;
var sit = new Situation(pos);
var moves = sit.GetMoves(Piece.Green, 2);
sit.ApplyMove(moves[0]);
Assert.AreEqual(2, sit.beers[(int)Piece.Red]);
}
