public void SolveGame_Legal_9X9_ReturnTrue()
{
// Arrange
// create valid 9 on 9 sudoku Board string
string testBoard = "500080049" +
"000500030" +
"067300001" +
"150000000" +
"000208000" +
"000000018" +
"700004150" +
"030002000" +
"490050000";
// build a Board and gameSolver
Board board = new Board(testBoard, 9);
GameSolver solver = new GameSolver(board);
// Act
// try to solve the sudoku board
bool solved = solver.SolveGame();
// Assert - we expect the solver to Solve the sudoku and return true
Assert.AreEqual(solved, true);
}
public void SolveGame_Unsolvable_9X9_ReturnFalse()
{
// Arrange
// Create valid 9 on 9 sudoku Board
// this board in unslovable because we have to set '9' in
// indexes [0,8] and this wiil casue '9' dupliacte in the last col
string testBoard = "123456780" +
"000000000" +
"000000000" +
"009000000" +
"000000000" +
"000005000" +
"000000000" +
"030002009" +
"000000000";
Board board = new Board(testBoard, 9);
GameSolver solver = new GameSolver(board);
// Act
bool solved = solver.SolveGame();
// Assert - The solver needs to try to solve the board
// without success and return false
Assert.AreEqual(solved, false);
}
public void FindNeighbors(string seed, int expectedNeighbors)
{
var board = seed.FromString();
int actualNeighbors = GameSolver.FindNeighborCount(board.First(), board);
Assert.AreEqual(expectedNeighbors, actualNeighbors);
}
public void SolveGame_Legal_16X16_ReturnTrue()
{
// Arrange
// create valid 16 on 16 sudoku Board
string testBoard = "0080040000000003" +
"0000000000000000" +
"@00000=000000000" +
"<0000>000?000000" +
"07@000000;030000" +
"000000>005000;00" +
"00000000=0400000" +
"0000000000009000" +
"0000060800>00007" +
":0;00000@<000000" +
"0000000000?00200" +
"000000@>00000000" +
"00700=0;00000060" +
"0000000000000@00" +
"0>002@000=000000" +
"000100000000=500";
Board board = new Board(testBoard, 16);
GameSolver solver = new GameSolver(board);
// Act
bool solved = solver.SolveGame();
// Assert
Assert.AreEqual(solved, true);
}
static void Main()
{
Console.WriteLine("Initial State:");
GameSolver gs = new GameSolver();
Console.WriteLine(gs.InitialState.DrawState());
var result = gs.SearchForSolution();
Console.WriteLine($"Overall moves made: {gs.OverallMoves:N0}");
Console.WriteLine(result);
Console.WriteLine();
Console.WriteLine("Detailed movements:");
var state = gs.InitialState;
foreach (var movement in result.MovementsMade)
{
Console.WriteLine(movement);
state = state.Go(movement);
//TODO: consider refactoring logic of removal matched ids from CheckBoardState
state.CheckBoardState();
Console.WriteLine(state.DrawState());
}
Console.ReadLine();
}
////
//// GET: /Game/
public JsonResult Index(int bucket1, int bucket2, int target)
{
IEnumerable <StateTransition> steps = GameSolver.Solve(bucket1, bucket2, target);
string result = serializer.Serialize(new { Steps = steps.ToArray(), Message = string.Empty });
return(Json(result, JsonRequestBehavior.AllowGet));
}
public void SolveBoard(string seed, string result, int numGenerations, string reason)
{
var seedBoard = seed.FromString();
var expectedResult = result.FromString();
var actualResult = GameSolver.Solve(seedBoard, numGenerations);
expectedResult.Should().BeEquivalentTo(actualResult, because: reason);
}
public void SolveCapaCity2and18WithTarget4Returns4Steps()
{
int bucket1capacity = 2;
int bucket2capacity = 18;
int target = 4;
IEnumerable <StateTransition> result = GameSolver.Solve(bucket1capacity, bucket2capacity, target);
Assert.AreEqual(result.ToList().Count, 4);
}
public void SolveGame_EmptyBoard16X16_ReturnTrue()
{
// Arrange
// create empty 16 on 16 sudoku Board
string testBoard = new string('0', 16 * 16);
Board board = new Board(testBoard, 16);
GameSolver solver = new GameSolver(board);
// Act
bool solved = solver.SolveGame();
// Assert
// empty board is solvable board with a lot of solvign options
// the function should return true
Assert.AreEqual(solved, true);
}
private void OnSolvePuzzle_Click(object sender, EventArgs e)
{
bool couldSolve;
UIGameBoard.SuspendLayout();
PuzzleSolution = GameSolver.Solve(UIGameBoard.Board, out couldSolve);
if (!couldSolve)
{
new TooHardBox().ShowDialog();
}
CurrentStep = PuzzleSolution.Count;
ButtonUndoAll_Click(null, null);
ButtonSolve.Visible = false;
UpdateRuleButtons();
UIGameBoard.ResumeLayout(true /*performLayout*/);
}
// [TestCase(SampleGames.GosperGliderGunInitial, gosperGliderGun43rdGen, 43, "Gun is shooting down and to the right")]
public void SolveJsonBoard(string seed, string result, int numGenerations, string reason)
{
var seedBoard = JsonSerializer.Deserialize <IEnumerable <Coordinate> >(seed);
var expectedResult = JsonSerializer.Deserialize <IEnumerable <Coordinate> >(result);
var actualResult = GameSolver.Solve(seedBoard, numGenerations);
Console.WriteLine();
Console.WriteLine(JsonSerializer.Serialize(expectedResult));
Console.WriteLine(JsonSerializer.Serialize(actualResult));
Console.WriteLine(expectedResult.SequenceEqual(actualResult));
expectedResult.All(actualResult.Contains).Should().BeTrue(reason);
}
public Game Optimal(OptimalMoveRequest optimalMoveRequest)
{
if (optimalMoveRequest.Game.isLastMove())
{
return(optimalMoveRequest.Game);
}
optimalMoveRequest.Game.InvertBoard();
Move m = GameSolver.BestMove(
optimalMoveRequest.BetaCards,
optimalMoveRequest.AlphaCards,
optimalMoveRequest.Game);
optimalMoveRequest.Game.InvertBoard();
optimalMoveRequest.Game.addCard(m.Card, m.X, m.Y, false);
return(optimalMoveRequest.Game);
}
public void SolveGame_Legal_4X4_ReturnTrue()
{
// Arrange
// create valid 4 on 4 sudoku Board
string testBoard = "1234" +
"3400" +
"2040" +
"4002";
Board Sudokuboard = new Board(testBoard, 4);
GameSolver solver = new GameSolver(Sudokuboard);
// Act
bool solved = solver.SolveGame();
// Assert
Assert.AreEqual(solved, true);
}
public void SolveGame_SolvedBoard_ReturnTrue()
{
// Arrange
// Create 4 on 4 solved board
string slovedBoard = "1234" +
"3412" +
"2143" +
"4321";
Board board = new Board(slovedBoard, 4);
GameSolver solver = new GameSolver(board);
// Act
bool solved = solver.SolveGame();
// Assert
Assert.AreEqual(solved, true);
}
public void SimpleGameCanBeSolved()
{
char[] gameField = new char[]
{
'w', 'o', 'r',
'i', 'f', 'k',
'e', 'l', 'd'
};
GameInformation gameInfo = new GameInformation(gameField, 3, 3);
ConcurrentWordStateMachine concurrentWordStateMachine = new ConcurrentWordStateMachine();
concurrentWordStateMachine.AddWords("./Words/English.txt");
GameSolver gameSolver = new GameSolver(concurrentWordStateMachine);
GameSolution solution = gameSolver.SolveGameAsync(gameInfo).Result;
Assert.True(solution.IsSolved);
GameWord[] gameWords = new GameWord[]
{
//work
new GameWord(gameInfo, new GamePoint[]
{
new GamePoint(gameInfo, 0, 0),
new GamePoint(gameInfo, 1, 0),
new GamePoint(gameInfo, 2, 0),
new GamePoint(gameInfo, 2, 1)
}),
//field
new GameWord(gameInfo, new GamePoint[]
{
new GamePoint(gameInfo, 1, 1),
new GamePoint(gameInfo, 0, 1),
new GamePoint(gameInfo, 0, 2),
new GamePoint(gameInfo, 1, 2),
new GamePoint(gameInfo, 2, 2)
})
};
GameState expectedGameState = new GameState(gameInfo, gameWords);
Assert.Contains(expectedGameState, solution.GameStates);
Assert.Single(solution.GameStates);
}
public void SolveGame_Unsolvable_4X4_ReturnFalse()
{
// Arrange
// Create Legal 4 on 4 sudoku Board
// this board in unslovable because we have to set '4' in
// indexes [2,1] and this wiil casue '4' dupliacte in the third row
string testBoard = "4000" +
"0000" +
"1042" +
"2300";
Board Sudokuboard = new Board(testBoard, 4);
GameSolver solver = new GameSolver(Sudokuboard);
// Act
bool solved = solver.SolveGame();
// Assert - The solver needs to try to solve the board
// without success and return false
Assert.AreEqual(solved, false);
}
static async Task Main(string[] args)
{
if (args.Length < 1)
{
Console.WriteLine("Pass the server address as the 1st parameter.");
return;
}
var server = args[0];
var clientName = Environment.UserName;
if (args.Length > 1)
{
clientName = args[1];
}
HttpWebResponse response;
var timer = Stopwatch.StartNew();
do
{
Console.WriteLine($"Connecting to server @ {server}");
var request = WebRequest.CreateHttp(server);
response = (HttpWebResponse)request.GetResponse();
} while (response.StatusCode != HttpStatusCode.OK && timer.Elapsed.TotalSeconds < 30);
if (response.StatusCode != HttpStatusCode.OK)
{
Console.WriteLine("Server didn't come up. What's going on?");
return;
}
client = RestService.For <IContestServer>(server);
var registerRequest = new RegisterRequest {
Name = clientName
};
RegisterResponse registerResponse;
while (true)
{
try
{
registerResponse = await client.Register(registerRequest);
break;
}
catch
{
registerRequest.Name += "_1";
}
}
token = registerResponse.Token;
status = ClientStatus.Waiting;
UpdateResponse updateResponse = null;
do
{
if (updateResponse != null)
{
Console.WriteLine("Waiting for game to start... {0}", DateTime.Now);
Thread.Sleep(TimeSpan.FromSeconds(1));
}
updateResponse = await client.Update(new UpdateRequest
{
Token = token
});
} while (updateResponse.GameState == GameState.NotStarted);
var seedBoard = updateResponse.SeedBoard;
generationsToCompute = updateResponse.GenerationsToCompute ?? 0;
Console.WriteLine($"Got seed board w/{seedBoard.Count()} live cells counting {generationsToCompute} generations.");
heartbeatTimer = new Timer(new TimerCallback(heartbeat), state: null, dueTime: 500, period: 500);
status = ClientStatus.Processing;
GameSolver.GenerationBatchCompleted += (s, e) => Interlocked.Exchange(ref generationsComputed, e.GenerationsComputed);
solvedBoard = GameSolver.Solve(seedBoard, generationsToCompute, batchSize: 5);
status = ClientStatus.Complete;
Console.WriteLine("You finished!");
Console.ReadLine();
}
static void Main(string[] args)
{
var gameBordOpt = new GameBoards.GameBoard(9)
{
{ new GameBoardTag(new Coordinate(9, 8), 6) },
{ new GameBoardTag(new Coordinate(9, 5), 3) },
{ new GameBoardTag(new Coordinate(8, 4), 2) },
{ new GameBoardTag(new Coordinate(8, 5), 7) },
{ new GameBoardTag(new Coordinate(8, 7), 3) },
{ new GameBoardTag(new Coordinate(7, 2), 7) },
{ new GameBoardTag(new Coordinate(7, 4), 9) },
{ new GameBoardTag(new Coordinate(3, 5), 4) },
{ new GameBoardTag(new Coordinate(5, 5), 1) },
{ new GameBoardTag(new Coordinate(5, 7), 6) },
{ new GameBoardTag(new Coordinate(5, 8), 7) },
{ new GameBoardTag(new Coordinate(5, 9), 4) },
{ new GameBoardTag(new Coordinate(9, 1), 4) }
};
for (int j = 0; j < 80; j++)
{
var gameBoard2 = new GameBoards.GameBoard(9);
var boardRules = new NormalSodukoRules();
var gameCreator = new GameHolder(gameBoard2, 3, boardRules);
Console.WriteLine("///////////////////////////////");
gameCreator.LoadGame();
var gameKey2 = gameCreator.GameBoardGameKeysPair.Keys.ElementAt(0);
var game2 = gameCreator.GameBoardGameKeysPair.Values.ElementAt(0);
//Console.Clear();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(game2);
Console.WriteLine(gameKey2);
Console.ResetColor();
var solve = game2.Clone();
var gameSolver = new GameSolver(game2, boardRules);
for (int i = 0; i < 1; i++)
{
gameSolver.SolveBoard();
var target = gameSolver.TargetSolutionGameBoards.Keys.ElementAt(i);
var solutuion = gameSolver.TargetSolutionGameBoards.Values.ElementAt(i).FirstOrDefault();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("---------------------------------------");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(target);
Console.WriteLine(solutuion);
Console.ResetColor();
}
}
Console.WriteLine("Done!!");
Console.ReadKey();
}
