public QuiescenceSearch(ArtemisEngine engine, GameState gameState, PositionEvaluator evaluator, MoveEvaluator moveEvaluator)
{
this.engine = engine;
this.gameState = gameState;
this.evaluator = evaluator;
this.moveEvaluator = moveEvaluator;
}
public void HasHelpText()
{
Assert.DoesNotThrow(() =>
{
var x = new MoveEvaluator("", Substitute.For <IUIMap>()).Help;
});
}
public SearchThread(ArtemisEngine engine, ThreadMaster master, GameState gameState, TranspositionTable transpositionTable, ConcurrentDictionary <ulong, bool> searchedNodes, IEngineConfig config)
{
this.master = master;
this.gameState = gameState;
EvaluationConfig evConfig = new EvaluationConfig();
evaluator = new PositionEvaluator(gameState, evConfig);
moveEvaluator = new MoveEvaluator(evConfig);
quietSearch = new QuiescenceSearch(engine, gameState, evaluator, moveEvaluator);
pvSearch = new PVSearch(engine, gameState, transpositionTable, killerMoves, evaluator, moveEvaluator, quietSearch, searchedNodes, config);
this.config = config;
}
public PVSearch(ArtemisEngine engine, GameState gameState, TranspositionTable transpositionTable, KillerMoves killerMoves, PositionEvaluator evaluator, MoveEvaluator moveEvaluator,
QuiescenceSearch quietSearch, ConcurrentDictionary <ulong, bool> searchedNodes, IEngineConfig config)
{
this.engine = engine;
this.gameState = gameState;
this.transpositionTable = transpositionTable;
this.killerMoves = killerMoves;
this.evaluator = evaluator;
this.moveEvaluator = moveEvaluator;
this.quietSearch = quietSearch;
this.searchedNodes = searchedNodes;
this.config = config;
}
public SimpleAi(IGameController controller, IBoardAnalyzer analyzer, IRandomProvider random, IMillRuleEvaluator millRuleEvaluator) : base(controller, analyzer, millRuleEvaluator)
{
using (Stream resourceStream = GetType().Assembly.GetManifestResourceStream(GetType().Namespace + ".Board.json")) {
using (StreamReader sr = new StreamReader(resourceStream)) {
string content = sr.ReadToEnd();
this._protoBoard = JsonConvert.DeserializeObject <ProtoBoard>(content);
}
}
this._random = random;
this._setMoveEvaluator = new MoveEvaluator(this.BoardAnalyzer, random, this._protoBoard);
this._setMoveEvaluator.Initialize();
}
private Move computeBestMove(Side side, Chessboard chessboard, int presentCumulativeScore)
{
currentDepth++;
// First, get the set of available moves
List <Move> moves = new List <Move>();
Move bestMoveForIteration = new Move(null, null);
bool isPlayingSide = chessboard.CurrentMovingSide() == side;
foreach (AbstractPiece piece in chessboard.getActivePieces())
{
if (piece.side == chessboard.CurrentMovingSide())
{
foreach (Position movePosition in piece.GetSafeMovesForCurrentPosition().GetPositions())
{
Move newMove = MoveEvaluator.EvaluateMove(new Move(piece, movePosition), isPlayingSide);
moves = InsertionSortMove(moves, newMove);
}
}
}
if (moves.Count > 0)
{
bestMoveForIteration = moves.ToArray()[0];
if (currentDepth < maxAllowableDepth)
{
foreach (Move move in moves)
{
Chessboard copyChessboard = Chessboard.MakeCopyOfChessboard(chessboard);
copyChessboard.MoveTo(copyChessboard.GetPieceAtPosition(move.getPiece().GetCurrentPosition()), move.getPosition());
copyChessboard.ChangeMovingSide();
int followUpScore = computeBestMove(side, copyChessboard, presentCumulativeScore + move.getScore()).getScore();
if (move.getScore() + followUpScore > bestMoveForIteration.getScore())
{
bestMoveForIteration = move;
}
}
}
}
currentDepth--;
return(bestMoveForIteration);
}
