public override int Run(Board board, Player player)
{
Player enemy = BackendHelper.SwapPlayer(player);
Player winner = board.Winner;
if (winner == player)
{
return(inf);
}
else if (winner == enemy)
{
return(-inf);
}
int result = 0;
for (int i = 0; i < board.Dimension; ++i)
{
result += MatchLine(board, player, new Place(i, 0), new Place(0, 1));
result += MatchLine(board, player, new Place(0, i), new Place(1, 0));
}
//if (board.GetPlayer(new Place(3, 3)) == player)
// result++;
//else if (board.GetPlayer(new Place(3, 3)) == enemy)
// result--;
return(result);
}
private int MatchLine(Board board, Player player, Place place, Place vector)
{
Dictionary <Player, int> places = new Dictionary <Player, int>();
places[Player.None] = 0;
places[Player.White] = 0;
places[Player.Black] = 0;
Player enemy = BackendHelper.SwapPlayer(player);
Place place1 = place;
double resultOffensive = 0;
double resultDefensive = 0;
int count = 0;
//while (BackendHelper.IsPlaceValid(place1, board.Dimension))
for (int i = 0; i < board.Dimension; ++i)
{
places[board.GetPlayer(place1)]++;
count++;
if (count > 4)
{
places[board.GetPlayer(place1 + (-4 * vector))]--;
count--;
}
if (count == 4)
{
if (places[enemy] == 0)
{
resultOffensive += lineBonus[places[Player.None]];
}
else if (places[player] == 0)
{
resultDefensive += lineBonus[places[Player.None]];
}
}
place1 += vector;
}
switch (player)
{
case Player.Black:
resultOffensive *= 1.1;
break;
case Player.White:
resultDefensive *= 0.9;
break;
}
return((int)Math.Round(resultOffensive - resultDefensive));
}
private Result Run(Evaluator evaluator, Board board, Player player, int depth, int alpha, int beta)
{
hits++;
if (depth == 0 || board.Winner != Player.None)
{
return(new Result(null, evaluator.Run(board, player)));
}
Result best = new Result(null, -inf);
List <Move> moves = board.GetPossibleMovesSorted(player);
if (depth == start)
{
total = moves.Count;
}
foreach (Move move in moves)
{
Transition transition = board.PerformMove(move);
Result candidate = Run(evaluator, board, BackendHelper.SwapPlayer(player), depth - 1, -beta, -alpha);
board.ReverseTransition(transition);
if (-candidate.Value > best.Value)
{
best = new Result(move, -candidate.Value);
}
if (best.Value >= beta)
{
break;
}
if (best.Value > alpha)
{
alpha = best.Value;
}
if (depth == start)
{
done++;
}
}
return(best);
}
public override int Run(Board board, Player player)
{
int result = 0;
foreach (Place place1 in BackendHelper.GetAllPlaces(board.Dimension))
{
int k;
Player currentPlayer;
if (player == board.GetPlayer(place1))
{
currentPlayer = player;
k = 1;
}
else if (BackendHelper.SwapPlayer(player) == board.GetPlayer(place1))
{
currentPlayer = BackendHelper.SwapPlayer(player);
k = -1;
}
else
{
continue;
}
foreach (Place vector in BackendHelper.Vectors.Values)
{
Place place2 = place1 + vector;
result += k;
while (BackendHelper.IsPlaceValid(place2, board.Dimension) &&
board.GetPlayer(place2) == currentPlayer)
{
result += k;
place2 = place2 + vector;
}
}
}
return(result);
}
private Result RunInternal(Evaluator evaluator, Board board, Player player, int depth)
{
hits++;
if (depth == 0 || board.Winner != Player.None)
{
return(new Result(null, evaluator.Run(board, player)));
}
Result winner = new Result(null, int.MinValue);
List <Move> moves = board.GetPossibleMovesSorted(player);
if (depth == start)
{
total = moves.Count;
}
foreach (Move move in moves)
{
Transition transition = board.PerformMove(move);
Result candidate = RunInternal(evaluator, board, BackendHelper.SwapPlayer(player), depth - 1);
if (-candidate.Value > winner.Value)
{
winner = new Result(move, -candidate.Value);
}
board.ReverseTransition(transition);
if (depth == start)
{
done++;
}
}
return(winner);
}
private Result Run(Evaluator evaluator, Board board, Player player, int depth, int alpha, int beta)
{
hits++;
if (depth == 0 || board.Winner != Player.None)
{
return(new Result(null, evaluator.Run(board, player)));
}
int prevalpha = alpha;
Transposition transposition = transTable.Lookup(board, player);
if (transposition != null && transposition.Depth >= depth)
{
switch (transposition.Bound)
{
case EvaluationBound.Lower:
alpha = Math.Max(alpha, transposition.BestMove.Value);
break;
case EvaluationBound.Upper:
beta = Math.Min(beta, transposition.BestMove.Value);
break;
case EvaluationBound.Accurate:
alpha = beta = transposition.BestMove.Value;
break;
}
if (alpha >= beta)
{
return(transposition.BestMove);
}
}
List <Move> possibleMoves = board.GetPossibleMovesSorted(player);
if (depth == start)
{
total = possibleMoves.Count;
}
if (transposition != null)
{
int index = possibleMoves.IndexOf(transposition.BestMove.Move);
if (index == -1)
{
throw new Exception(String.Format("Move \"{0}\" not found.", transposition.BestMove.Move));
}
possibleMoves[index] = possibleMoves[0];
possibleMoves[0] = transposition.BestMove.Move;
}
Result best = new Result(null, -inf);
foreach (Move move in possibleMoves)
{
Transition transition = board.PerformMove(move);
Result candidate = Run(evaluator, board, BackendHelper.SwapPlayer(player), depth - 1, -beta, -alpha);
board.ReverseTransition(transition);
if (-candidate.Value > best.Value)
{
best = new Result(move, -candidate.Value);
}
if (best.Value >= beta)
{
break;
}
if (best.Value > alpha)
{
alpha = best.Value;
}
if (depth == start)
{
done++;
}
}
transTable.Save(board, best, prevalpha, beta, depth);
return(best);
}
