private int Negamax(IPosition position) { if (position.NbMoves == position.Width * position.Height) // check for draw game { return(0); } for (int x = 0; x < position.Width; x++) // check if current player can win next move { if (position.CanPlay(x) && position.IsWinningMove(x)) { return((position.Width * position.Height + 1 - position.NbMoves) / 2); } } int bestScore = -position.Width * position.Height; // init the best possible score with a lower bound of score. for (int x = 0; x < position.Width; x++) // compute the score of all possible next move and keep the best one { if (position.CanPlay(x)) { IPosition newPosition = position.Clone(); newPosition.Play(x); // It's opponent turn in P2 position after current player plays x column. int score = -Negamax(newPosition); // If current player plays col x, his score will be the opposite of opponent's score after playing col x if (score > bestScore) { bestScore = score; // keep track of best possible score so far. } } } return(bestScore); }
private void CheckCurrentPosition() { if (CurrentPosition.X.IsOutOfRange(_plato.XLength) || CurrentPosition.Y.IsOutOfRange(_plato.YLength)) { CurrentPosition = _startPosition.Clone();//Set rover the start position for another try. throw new ArgumentOutOfRangeException("The rover drives out of range!!"); } }
private int Negamax(IPosition position, int alpha, int beta) { if (position.NbMoves == position.Width * position.Height) // check for draw game { return(0); } for (int x = 0; x < position.Width; x++) // check if current player can win next move { if (position.CanPlay(x) && position.IsWinningMove(x)) { return((position.Width * position.Height + 1 - position.NbMoves) / 2); } } int max = (position.Width * position.Height - 1 - position.NbMoves) / 2; // upper bound of our score as we cannot win immediately if (beta > max) { beta = max; // there is no need to keep beta above our max possible score. if (alpha >= beta) { return(beta); // prune the exploration if the [alpha;beta] window is empty. } } for (int x = 0; x < position.Width; x++) // compute the score of all possible next move and keep the best one { if (position.CanPlay(x)) { IPosition newPosition = position.Clone(); newPosition.Play(x); // It's opponent turn in P2 position after current player plays x column. int score = -Negamax(newPosition, -beta, -alpha); // explore opponent's score within [-beta;-alpha] windows: // no need to have good precision for score better than beta (opponent's score worse than -beta) // no need to check for score worse than alpha (opponent's score worse better than -alpha) if (score >= beta) { return(score); // prune the exploration if we find a possible move better than what we were looking for. } if (score > alpha) { alpha = score; // reduce the [alpha;beta] window for next exploration, as we only } // need to search for a position that is better than the best so far. } } return(alpha); }
public void Position_Clone_Should_CreateNewInstance_And_SetPropertiesCorrect() { IFactory factory = new Factory(); IPosition position = factory.CreateInputObject <IPosition>(); position.X = 1; position.Y = 2; position.Direction = Direction.North; IPosition newPosition = position.Clone(); Assert.AreNotSame(position, newPosition);//Should Create New Object. Assert.AreEqual(position.X, newPosition.X); Assert.AreEqual(position.Y, newPosition.Y); Assert.AreEqual(position.Direction, newPosition.Direction); }
protected override IPosition BoundaryReachPositionRecalculator(IPosition newPosition, IDirection direction, int xMaxValue, int yMaxValue) { var recalculatedPosition = newPosition.Clone(); if (newPosition.Coordinate.X >= xMaxValue && direction.XSpeed == 1) { recalculatedPosition.Coordinate.X = 0; } if (newPosition.Coordinate.X <= 0 && direction.XSpeed == -1) { recalculatedPosition.Coordinate.X = xMaxValue; } if (newPosition.Coordinate.Y <= 0 && direction.YSpeed == -1) { recalculatedPosition.Coordinate.Y = yMaxValue; } if (newPosition.Coordinate.Y >= yMaxValue && direction.YSpeed == 1) { recalculatedPosition.Coordinate.Y = 0; } return(recalculatedPosition); }
public void Populate(IPosition startPosition, IDirectionSequence directionsInstructions, ICellValueSequence valueProvider) { if (startPosition == null) { throw new ArgumentNullException(nameof(startPosition)); } if (directionsInstructions == null) { throw new ArgumentNullException(nameof(directionsInstructions)); } if (valueProvider == null) { throw new ArgumentNullException(nameof(valueProvider)); } var position = startPosition.Clone(); var direction = directionsInstructions.GetNextDirection(); var initialDirection = direction.Clone(); var matrixSize = this.matrix.Count; var matrixIsFilled = false; do { var nextCellValue = valueProvider.GetNextCellValue(); this.matrix[position.Row][position.Col].Value = nextCellValue; this.visitedCellPositions[position.Row][position.Col] = true; var nextPosition = position.Clone(); nextPosition = nextPosition.MoveInDirection(direction); var nextPositionIsFree = this.CheckIfPositionIsValidToMove(nextPosition, matrixSize); if (!nextPositionIsFree) { for (int directionChangeCount = 1; directionChangeCount <= directionsInstructions.DirectionSequenceLength; directionChangeCount++) { var nextDirection = directionsInstructions.GetNextDirection(); var adjustedNextPosition = position.Clone(); adjustedNextPosition = adjustedNextPosition.MoveInDirection(nextDirection); var adjustedNextPositionIsFree = this.CheckIfPositionIsValidToMove(adjustedNextPosition, matrixSize); if (adjustedNextPositionIsFree) { nextPosition = adjustedNextPosition; direction = nextDirection; break; } else if (directionChangeCount == directionsInstructions.DirectionSequenceLength) { var positionToJumpTo = this.FindPositionToJumpTo(adjustedNextPosition, matrixSize); if (positionToJumpTo == null) { matrixIsFilled = true; break; } else { nextPosition = positionToJumpTo; direction = initialDirection.Clone(); } } } } position = nextPosition; }while (!matrixIsFilled); }
public Rectangle(IPosition position, ISize size) { Position = position.Clone(); Size = size.Clone(); }
public Driver(IPlato plato, IPosition startPosition) { _plato = plato; _startPosition = startPosition; CurrentPosition = startPosition.Clone(); }