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; }));
});
}
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 Init()
{
attack1Moves = new NextMove[0];
attack2Moves = new NextMove[0];
startTime = 0;
damage = 0;
}
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);
}
