private void AppendRayMoves(
BoardSquare originSquare,
Position.Position position,
MoveDelta rayDelta,
List <Move> moves)
{
var board = position.Board;
var moveBuilder = new MoveBuilder(piece, originSquare);
var currentSquare = originSquare;
while (rayDelta.IsCanApplyTo(currentSquare))
{
currentSquare = rayDelta.GetDestSquare(currentSquare);
if (board.IsEmpty(currentSquare))
{
moves.Add(moveBuilder.SetDestSquare(currentSquare).Build());
}
else
{
var obstacle = board.GetPieceAt(currentSquare);
if (obstacle.player != position.PlayerToMove)
{
moves.Add(moveBuilder
.SetDestSquare(currentSquare)
.SetCapture(obstacle.piece)
.Build());
}
break;
}
}
}
public void AppendMoves(BoardSquare originSquare, Position.Position position, List <Move> moves)
{
var board = position.Board;
var playerToMove = position.PlayerToMove;
var moveDeltas = GetMoveDeltas();
var moveBuilder = new MoveBuilder(GetPiece(), originSquare);
for (int i = 0; i < moveDeltas.Length; ++i)
{
if (!moveDeltas[i].IsCanApplyTo(originSquare))
{
continue;
}
var destSquare = moveDeltas[i].GetDestSquare(originSquare);
if (board.IsEmpty(destSquare))
{
moves.Add(moveBuilder.SetDestSquare(destSquare).Build());
}
else
{
var pieceAtDestSquare = board.GetPieceAt(destSquare);
if (pieceAtDestSquare.player != playerToMove)
{
moves.Add(moveBuilder
.SetDestSquare(destSquare)
.SetCapture(pieceAtDestSquare.piece)
.Build());
}
}
}
}
public void AppendMoves(BoardSquare originSquare, Position.Position position, List <Move> moves)
{
for (int i = 0; i < rayDeltas.Length; ++i)
{
AppendRayMoves(originSquare, position, rayDeltas[i], moves);
}
}
public PositionLongHash CalculateHash(Position.Position position)
{
var result = new PositionLongHash();
result = result.CalculateXor(
CalculatePiecesHash(
position.Board.GetPieces(Player.Black),
Player.Black));
result = result.CalculateXor(
CalculatePiecesHash(
position.Board.GetPieces(Player.White),
Player.White));
result = result.CalculateXor(playerToMoveHashesTable[(int)position.PlayerToMove]);
result = result.CalculateXor(
GetEnPassantCaptureColumnHash(position.EnPassantCaptureColumn));
result = result.CalculateXor(
GetCastlingAvailabilityHash(
position.GetCastlingAvailability(Player.Black),
Player.Black));
result = result.CalculateXor(
GetCastlingAvailabilityHash(
position.GetCastlingAvailability(Player.White),
Player.White));
return(result);
}
public Broccoli(Position.Position position, char objectSymbol, IPlayer player)
: base(position, objectSymbol, player)
{
player.Power += 10;
this.ObjectSymbol = this.broccoliSymbol;
this.broccoliMovesToRegrow = 3;
}
public CherryBerry(Position.Position position, char objectSymbol, IPlayer player)
: base(position, objectSymbol, player)
{
player.Stamina += 10;
this.ObjectSymbol = this.cherryBerrySymbol;
this.cherryBerryMovesToRegrow = 5;
}
private Position.Location GetNewLocation(Position.Position position)
{
var result = _locationCalculator.GetLocation(position, Robot.LateralSpeed);
var location = result.location;
return(location);
}
public Option <Move.Move> FindBestMove(Position.Position currentPosition)
{
evaluator.OnNewSearch(currentPosition);
Option <Move.Move> bestMove = Option.None <Move.Move>();
int bestMoveEvaluation = MinEvaluationValue;
foreach (var move in MoveGenerator.GenerateLegalMoves(currentPosition))
{
currentPosition.PlayMove(move);
var evaluation = -CalculateEvaluationRecursively(
currentPosition,
currentDepth: 1)
.ValueOr(-MinEvaluationValue);
if (!bestMove.HasValue || evaluation >= bestMoveEvaluation)
{
bestMove = Option.Some(move);
bestMoveEvaluation = evaluation;
}
currentPosition.UndoMove();
}
return(bestMove);
}
private void AppendCastleMoves(Position.Position position, List <Move> moves)
{
var availabilityFlags = position.GetCastlingAvailability(player);
if (!availabilityFlags.CanCastleShort && !availabilityFlags.CanCastleLong)
{
return;
}
var board = position.Board;
if (IsBoardSquareAttacked(initialKingSquare, board, otherPlayer))
{
return;
}
if (availabilityFlags.CanCastleShort && IsLegalToCastleShort(board))
{
moves.Add(shortCastleMove);
}
if (availabilityFlags.CanCastleLong && IsLegalToCaslteLong(board))
{
moves.Add(longCastleMove);
}
}
public Asparagus(Position.Position position, char objectSymbol, IPlayer player)
: base(position, objectSymbol, player)
{
player.Power += 5;
player.Stamina -= 5;
this.ObjectSymbol = this.asparagusSymbol;
this.asparagusMovesToRegrow = 2;
}
public Royal(Position.Position position, char objectSymbol, IPlayer player)
: base(position, objectSymbol, player)
{
player.Power += 20;
player.Stamina += 10;
this.ObjectSymbol = this.royalSymbol;
this.royalMovesToRegrow = 10;
}
protected Player(Position.Position position, char objectSymbol, int stamina, int power, string name)
: base(position, objectSymbol)
{
this.Stamina = stamina;
this.Power = power;
this.Name = name;
this.vegetableList = new List <Vegetables.Vegetable>();
}
public Mushroom(Position.Position position, char objectSymbol, IPlayer player)
: base(position, objectSymbol, player)
{
player.Power -= 10;
player.Stamina -= 10;
this.ObjectSymbol = this.mushroomSymbol;
this.mushroomMovesToRegrow = 5;
}
private Option <int> CalculateEvaluationRecursively(
Position.Position position,
int currentDepth)
{
var bestMove = Move.Move.NullMove;
var bestMoveEvaluation = MinEvaluationValue;
bool hasLegalMove = false;
var playerEvaluationMultiplier = GetPlayerEvaluationMultiplier(position.PlayerToMove);
var playerToMove = position.PlayerToMove;
var pseudoLegalMoves = MoveGenerator.GeneratePseudoLegalMoves(position);
foreach (var move in pseudoLegalMoves)
{
position.PlayMove(move);
if (!IsPlayedMoveLegal(position))
{
position.UndoMove();
continue;
}
hasLegalMove = true;
int movePriority = CalculateMovePriority(move, currentDepth);
if (movePriority < MinPriorityToConsiderMove)
{
position.UndoMove();
continue;
}
evaluator.OnMovePlayed(move, playerToMove);
var evaluation = -CalculateEvaluationRecursively(
position,
currentDepth + 1)
.ValueOr(() => - playerEvaluationMultiplier * evaluator.GetCurrentEvaluation());
if (evaluation >= bestMoveEvaluation)
{
bestMove = move;
bestMoveEvaluation = evaluation;
}
position.UndoMove();
evaluator.OnUndoMove();
}
if (!hasLegalMove)
{
return(Option.Some(
GetEvaluationForPositionWithoutLegalMoves(
position,
playerEvaluationMultiplier)));
}
return(bestMove.IsNullMove ? Option.None <int>() : Option.Some(bestMoveEvaluation));
}
private static int GetEvaluationForPositionWithoutLegalMoves(
Position.Position position,
int playerEvaluationMultiplier)
{
return(playerEvaluationMultiplier *
(IsKingUnderAttack(position, position.PlayerToMove) ?
Evaluator.GetCheckmatedEvaluation() :
Evaluator.StalemateEvaluation));
}
public void AppendMoves(BoardSquare originSquare, Position.Position position, List <Move> moves)
{
var board = position.Board;
var moveBuilder = new MoveBuilder(Piece.Pawn, originSquare);
var moveAppender = GetMoveAppender(originSquare);
var moveForwardSquare = new BoardSquare(originSquare.Row + deltaRow, originSquare.Column);
if (board.IsEmpty(moveForwardSquare))
{
moveAppender(moveBuilder.SetDestSquare(moveForwardSquare), moves);
if (originSquare.Row == initialRow)
{
var moveDoubleForwardSquare = GetDoubleForwardMoveSquare(originSquare);
if (board.IsEmpty(moveDoubleForwardSquare))
{
moves.Add(moveBuilder
.SetDestSquare(moveDoubleForwardSquare)
.SetPawnDoubleMove()
.Build());
}
}
}
if (originSquare.Column > 0)
{
AppendIfCanCapture(
new BoardSquare(originSquare.Row + deltaRow, originSquare.Column - 1),
moveBuilder,
board,
moves,
moveAppender);
}
if (originSquare.Column + 1 < Board.Board.ColumnCount)
{
AppendIfCanCapture(
new BoardSquare(originSquare.Row + deltaRow, originSquare.Column + 1),
moveBuilder,
board,
moves,
moveAppender);
}
if (originSquare.Row == enPassantCaptureRow &&
position.EnPassantCaptureColumn.Exists(x => Abs(originSquare.Column - x) == 1))
{
var enPassantDstSquare = new BoardSquare(
originSquare.Row + deltaRow,
position.EnPassantCaptureColumn.ValueOr(0));
moves.Add(moveBuilder
.SetDestSquare(enPassantDstSquare)
.SetEnPassantCapture()
.Build());
}
}
internal static List <Move> GeneratePseudoLegalMoves(Position.Position position)
{
var moves = new List <Move>(capacity: 32);
foreach (var pieceOnBoard in position.Board.GetPieces(position.PlayerToMove))
{
PieceMoveGeneratorFactory.GetPieceMoveGenerator(position.PlayerToMove, pieceOnBoard.piece)
.AppendMoves(pieceOnBoard.square, position, moves);
}
return(moves);
}
private static bool IsKingUnderAttack(
Position.Position position,
Player playerToCheck)
{
var board = position.Board;
var kingSquare = board.GetKingSquare(playerToCheck);
return(IsBoardSquareAttacked(
kingSquare,
board,
GetOtherPlayer(playerToCheck)));
}
private void SetPosition(Match match)
{
if (!match.Success)
{
return;
}
var x = int.Parse(match.Groups[1].Value);
var y = int.Parse(match.Groups[2].Value);
var f = (Direction)Enum.Parse(typeof(Direction), match.Groups[3].Value, true);
Position = new Position.Position(new Location(x, y), f);
}
public static Position.Position GetPosition(CreatePositionData desc)
{
// TODO
var result = new Position.Position();
result.Reset(
new PlayerPieceSet(desc.m_pieces, Players.White),
new PlayerPieceSet(desc.m_pieces, Players.Black),
desc.m_player_to_move,
desc.m_white_castling_options,
desc.m_black_castling_options,
desc.m_capture_en_passant_column,
desc.m_fullmove_number,
desc.m_halfmove_clock);
return result;
}
private static bool IsLegalMove(Position.Position position, Move move)
{
var myPlayer = position.PlayerToMove;
var board = position.Board;
board.PlayMove(move, myPlayer);
var myKingSquare = board.GetKingSquare(myPlayer);
var myKingBecameAttacked = IsBoardSquareAttacked(
myKingSquare,
board,
GetOtherPlayer(position.PlayerToMove));
board.UndoMove(move, position.PlayerToMove);
return(!myKingBecameAttacked);
}
public void EditEmployee(string name)
{
Employee employeExist = FindByName(name);
if (employeExist == null)
{
return;
}
Employee empl = new Employee();
Console.WriteLine("Ведите имя сотрудника");
empl.Name = Console.ReadLine();
Console.WriteLine("Ведите заработную плату сотрудника");
double salary = 0;
while (!Double.TryParse(Console.ReadLine(), out salary))
{
Console.WriteLine("Вы ввели не число");
}
int p = 0;
Console.WriteLine("Выберете должность:");
Console.WriteLine("1. manager\n2. accountant\n3.economist\n4system_administrator\n5. boss");
while (true)
{
while (!Int32.TryParse(Console.ReadLine(), out p))
{
Console.WriteLine("Вы ввели не число");
}
if (p == 1 || p == 2 || p == 3 || p == 4 || p == 5)
{
break;
}
else
{
Console.WriteLine("Нет такой должности");
}
}
Position.position posEnum = (Position.position)p;
Position.Position position = new Position.Position(posEnum);
empl.Position = position;
DeleteEmployee(name);
logData(empl.Name + "was edited");
CreateEmployee(empl);
}
public Task <Option <Move.Move> > FindBestMove(Position.Position position)
{
var legalMoves = MoveGenerator.GenerateLegalMoves(position);
if (legalMoves.Count == 0)
{
return(Task.FromResult(Option.None <Move.Move>()));
}
else if (legalMoves.Count == 1)
{
return(Task.FromResult(Option.Some(legalMoves[0])));
}
var searchManager = new SearchManager(new Evaluator(), 2);
return(Task.Run(() => searchManager.FindBestMove(position)));
}
public IActionResult Index(Models.RobotWars model)
{
if (ModelState.IsValid)
{
Position.Position position = new Position.Position();
model.PenaltyCount = 0;
try
{
//set initial position
position.X = (int)Char.GetNumericValue(model.InitialPosition[0]);
position.Y = (int)Char.GetNumericValue(model.InitialPosition[2]);
position.Direction = (Directions)Enum.Parse(typeof(Directions), model.InitialPosition[4].ToString().ToUpper());
//set variables for the max x and y values for processing the change of location
List <int> maxXYPoints = new List <int>()
{
4, 4
};
//process the new position
position.StartMoving(maxXYPoints, model.MovementInstructions.ToUpper());
model.FinalPosition = position.X + ", " + position.Y + ", " + position.Direction.ToString();
model.PenaltyCount = position.penalty;
return(Location(model));
}
catch (Exception ex)
{
_logger.LogError("There has been an error " + ex);
return(View("Error"));
}
}
return(View("Index", model));
}
public Ninja(Position.Position position, char objectSymbol, int stamina, int power, string name)
: base(position, objectSymbol, stamina, power, name)
{
}
public override (Position.Location location, bool found) GetLocation(Position.Position position, int lateralSpeed)
{
return(position.Direction == Direction.West
? (new Position.Location(position.Location.X - lateralSpeed, position.Location.Y), true)
: (position.Location, false));
}
public override (Position.Location location, bool found) GetLocation(Position.Position position, int lateralSpeed)
{
return(LocationCalculator.GetLocation(position, lateralSpeed));
}
public BlankSpace(Position.Position position, char objectSymbol)
: base(position, objectSymbol)
{
this.ObjectSymbol = this.blankSpaceSymbol;
}
public void SetPosition(Position.Position position)
{
Position = position;
}
public override (Position.Location location, bool found) GetLocation(Position.Position position, int lateralSpeed)
{
return(position.Direction == Direction.South
? (new Position.Location(position.Location.X, position.Location.Y - lateralSpeed), true)
: LocationCalculator.GetLocation(position, lateralSpeed));
}
public Rover()
{
Position = new Position.Position();
Id = Guid.NewGuid();
}
