public void Init() { attack1Moves = new NextMove[0]; attack2Moves = new NextMove[0]; startTime = 0; damage = 0; }
private void MakeAIMove(NextMove nextMove) { ThreadPool.QueueUserWorkItem(_ => { while (_CurrentPlayer.IsRed) { Thread.Sleep(750); var move = Board.moveOfTheComputer(_State, nextMove); var moveResult = Board.applyMove(move.Item1, move.Item2, _State); _State = moveResult.Item1; _CurrentPlayer = GetNextPlayer(moveResult.Item2); visualState1.CurrentPlayer = _CurrentPlayer; var validMoves = Board.allValidMoves(moveResult.Item2, moveResult.Item1); visualState1.Draw(moveResult.Item1, validMoves); if (CheckAndDisplayWinner()) { this.Invoke(new MethodInvoker(() => { this.Enabled = true; visualState1.Enabled = false; })); return; } } this.Invoke(new MethodInvoker(() => { this.Enabled = true; })); }); }
public void AssertThatSolverReturnsNoMove(int[] heaps) { // Arrange // Act var actual = NextMove.Solve(heaps); // Assert actual.Should().BeNull(); }
private Player GetNextPlayer(NextMove nextMove) { if (nextMove.IsColor) { return ((NextMove.Color)nextMove).Item; } var coords = ((NextMove.Piece)nextMove).Item; var field = _State[coords]; return ((FieldState.Color)field).Item; }
public void AssertThatSolverReturnsWinningMove(int[] heaps, int heap, int number) { // Arrange var expected = new Move(heap: heap, number: number); // Act var actual = NextMove.Solve(heaps); // Assert actual.Should().BeEquivalentTo(expected); }
private Player GetNextPlayer(NextMove nextMove) { if (nextMove.IsColor) { return(((NextMove.Color)nextMove).Item); } var coords = ((NextMove.Piece)nextMove).Item; var field = _State[coords]; return(((FieldState.Color)field).Item); }
public NextMove DiscoverNextMove(Grid grid, IReadOnlyList <Cube> cubes, int depth = 0) { if (cubes.Count == depth) { return(null); } var allPossibilities = GenerateAllPossibilities(cubes[depth], grid.Width); var agrValues = new NextMove[allPossibilities.Count]; Parallel.For(0, allPossibilities.Count, i => { var pos = allPossibilities[i]; var cube = cubes[depth].Rotations[pos.Item2]; var gridLocal = grid.Clone(); int lowest; var success = gridLocal.AddToColumn(cube, pos.Item1, out lowest); if (!success) { return; } var next = DiscoverNextMove(gridLocal, cubes, depth + 1); // double rating; // int estMoves; if (next != null) { agrValues[i] = new NextMove() { Column = pos.Item1, Rotation = pos.Item2, EstimatedMoves = next.EstimatedMoves, Rating = next.Rating, Row = lowest }; // rating = next.Rating; // estMoves = next.EstimatedMoves; } else { gridLocal.DeleteRows(); var rating = gridLocal.RateGrid().Zip(_fact, (d, f) => d * f).Sum(); agrValues[i] = new NextMove() { Column = pos.Item1, Rotation = pos.Item2, EstimatedMoves = depth, Rating = rating, Row = lowest }; } }); return(agrValues.Max()); }
public override string ToString() { var stringBuilder = new StringBuilder(); stringBuilder.AppendLine("SearchResult:"); stringBuilder.AppendLine(nameof(Evaluation) + " == " + Evaluation); stringBuilder.AppendLine(nameof(SearchTime) + " == " + SearchTime); stringBuilder.AppendLine(nameof(Leaves) + " == " + Leaves); stringBuilder.AppendLine(nameof(InternalNodes) + " == " + InternalNodes); stringBuilder.AppendLine(nameof(SearchDepth) + " == " + SearchDepth); stringBuilder.AppendLine(nameof(FullTreeSearchedOrPruned) + " == " + FullTreeSearchedOrPruned); stringBuilder.AppendLine(nameof(AllChildrenAreDeadEnds) + " == " + AllChildrenAreDeadEnds); stringBuilder.AppendLine(nameof(NextMove) + ":"); stringBuilder.AppendLine(NextMove.ToString()); return(stringBuilder.ToString()); }
public ActionResult Post(GetNextMove getNextMove) { int version = getNextMove.Version; IAutomatedPlayerService service; switch (version) { case 1: service = new AutomatedPlayerServiceV1(); break; case 2: service = new AutomatedPlayerServiceV2(); break; case 3: service = new AutomatedPlayerServiceV3(); break; default: service = null; break; } if (service == null) { return(BadRequest( new Response { Successful = false } )); } NextMove nextmove = service.GetNextMoveForAutomatedPlayer(getNextMove); return(Ok( new Response { Successful = true, NextMove = nextmove } )); }
/// <summary> /// Save Human player's most recent move ('X') and the Cpu player's next move ('O') /// </summary> /// <param name="move"></param> /// <returns></returns> public async Task <NextMove> PlayNextMove(PlayerMove move) { var newMove = new NextMove(); try { // Save human player's move await _gameRepo.SaveMove(move); // Get saved board including player's latest move var currentGame = await _gameRepo.GetGame(move.GameId); var isPlayerWinner = IsPlayerWinner(currentGame, GamePlayer.Human); newMove.GameCompleted = (currentGame.Status != GameStatus.Incomplete.ToString()); newMove.Winner = currentGame.Winner; if (!isPlayerWinner) { if (currentGame.Status == GameStatus.Incomplete.ToString()) { var nextCpuMove = GetCpuMove(currentGame); newMove.Cell = nextCpuMove.Cell; newMove.Value = nextCpuMove.Value; // Save cpu player's move await _gameRepo.SaveMove(nextCpuMove); var isCpuWinner = IsPlayerWinner(currentGame, GamePlayer.Cpu); newMove.GameCompleted = (currentGame.Status != GameStatus.Incomplete.ToString()); newMove.Winner = currentGame.Winner; } } } catch (Exception ex) { throw ex; } return(newMove); }
public async void StartBattle(Trainer player, Trainer enemy) { Player = player; Enemy = enemy; Turn = 1; InitializeBattle(player, enemy); do { GetNextTurn(); Monster target = null; do { BattleInput.Instance.CurrentInputMode = BattleInput.InputMode.Action; NextMove = await CurrentMonsterTurn.Item1.SelectMove(CurrentMonsterTurn.Item2); BattleInput.Instance.CurrentInputMode = BattleInput.InputMode.Target; if (NextMove.ValidTargets.Count == 0) { break; } target = await CurrentMonsterTurn.Item1.SelectTarget(CurrentMonsterTurn.Item2); } while (target == null); BattleInput.Instance.CurrentInputMode = BattleInput.InputMode.NoInput; await NextMove.Execute(CurrentMonsterTurn.Item2, target); NextMove = null; Turn++; } while (!Player.Team.IsDefeated && !Enemy.Team.IsDefeated); CleanupBattle(); }
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req, ILogger log) { try { String requestBody = await new StreamReader(req.Body).ReadToEndAsync(); GetNextMove getNextMove = JObject.Parse(requestBody).ToObject <GetNextMove>(); Int64 version = getNextMove.Version; IAutomatedPlayerService service = version switch { 1 => new AutomatedPlayerServiceV1(), 2 => new AutomatedPlayerServiceV2(), 3 => new AutomatedPlayerServiceV3(), _ => throw new ArgumentException("No version in body of request") }; NextMove nextmove = service.GetNextMoveForAutomatedPlayer(getNextMove); return(new OkObjectResult( new AutomatedPlayerResponse { Successful = true, NextMove = nextmove } )); } catch (Exception ex) { return(new BadRequestObjectResult( new AutomatedPlayerResponse { Successful = false, ErrorMessage = ex.Message } )); } }
public void AssertThatNullHeapsThrowAnException() { NextMove.Solve(null); }
public Int32 GetMiniMaxAiHard(PlayerType[,] newBoard, PlayerType state, IMatrixAlgorithm ticTacToeMatrix) { if (ticTacToeMatrix is null) { throw new ArgumentNullException(nameof(ticTacToeMatrix)); } this.FunctionCalls++; if (this.EvaluateAiHardMode(newBoard) && ticTacToeMatrix.CurrentTurn == PlayerType.X) { return(-10); } else if (this.EvaluateAiHardMode(newBoard) && ticTacToeMatrix.CurrentTurn == PlayerType.O) { return(10); } else if (this.GetMovesLeftAiHard(ticTacToeMatrix, newBoard)) { return(0); } this.ScoreList = new List <NextMove>(); for (Int32 x = 0; x < ticTacToeMatrix.BoardSize; x++) { for (Int32 y = 0; y < ticTacToeMatrix.BoardSize; y++) { NextMove nextMove = new NextMove(); if (newBoard[x, y] == PlayerType.Unassigned) { nextMove.PointIndex = new PointIndex { X = x, Y = y }; newBoard[x, y] = state; if (state == PlayerType.X) { Int32 result = this.GetMiniMaxAiHard(newBoard, PlayerType.O, ticTacToeMatrix); nextMove.Score = result; } else { Int32 result = this.GetMiniMaxAiHard(newBoard, PlayerType.X, ticTacToeMatrix); nextMove.Score = result; } newBoard[x, y] = PlayerType.Unassigned; this.ScoreList.Add(nextMove); } } } switch (state) { case PlayerType.X: this.CalcMinValueAiHard(); break; case PlayerType.O: this.CalcMaxValueAiHard(); break; default: throw new ArgumentOutOfRangeException(nameof(state)); } return(this.BestPointIndex); }