public void DoAction(VacuumWorldState state, VacuumWorldAction action)
{
if (action != VacuumWorldAction.Suck)
{
throw new InvalidOperationException();
}
var squareWasClean = !state.SquareIsDirty(state.VacuumPos);
_decoratedHandler.DoAction(state, action);
if (squareWasClean)
{
if (_random.TrueWithProbability(_makeDirtyProbability))
{
state.MakeSquareDirty(state.VacuumPos);
}
}
else
{
if (_random.TrueWithProbability(_cleanExtraProbability))
{
CleanRandomDirtyNeighbour(state);
}
}
}
public void SolveErratic2X2VacuumWorldWithDfs()
{
var initialState = new VacuumWorldState(2);
initialState.MakeSquareDirty(1, 1);
var problem = new ErraticVacuumWorldSearchProblem();
var solver = new NonDeterministicDfsSearch <VacuumWorldState, VacuumWorldAction>(problem, initialState);
var solution = solver.GetSolution();
var actionCounter = 0;
const int actionLimit = 1000;
var erraticWorld = VacuumWorld.CreateErraticVacuumWorld(initialState);
while (!problem.IsGoal(erraticWorld.State))
{
var action = solution.NextAction(erraticWorld.State);
erraticWorld.DoAction(action);
if (++actionCounter > actionLimit)
{
Assert.Fail($"failed to reach goal after {actionCounter} actions");
}
}
}
public void GivenSomeSquaresAreDirty_ShouldNotBeGoalState()
{
var stateWithDirtySquares = new VacuumWorldState(3);
stateWithDirtySquares.MakeSquareDirty(1, 1);
Assert.IsFalse(_searchProblem.IsGoal(stateWithDirtySquares));
}
public void New_empty_states_should_be_equal()
{
var a = new VacuumWorldState(3);
var b = new VacuumWorldState(3);
Assert.AreEqual(a, b);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
public void Setup()
{
_initialState = new VacuumWorldState(2);
_initialState.MakeSquareDirty(0, 0);
_initialState.MakeSquareDirty(0, 1);
_problem = new VacuumWorldSearchProblem(_initialState,
VacuumWorldActionHandler.CreateDeterministicActionHandler());
}
public void DoAction_ShouldNotModifyGivenState()
{
var state = new VacuumWorldState(3);
var newState = _problem.DoAction(state, VacuumWorldAction.Down);
Assert.IsFalse(ReferenceEquals(newState, state));
Assert.IsFalse(newState.Equals(state));
}
public void DoAction(VacuumWorldState state, VacuumWorldAction action)
{
if (action != VacuumWorldAction.Suck)
{
throw new InvalidOperationException();
}
state.CleanSquare(state.VacuumPos);
}
public void States_with_different_vacuum_pos_should_not_be_equal()
{
var a = new VacuumWorldState(3);
var b = new VacuumWorldState(3);
a.VacuumPos = new Point2D(1, 2);
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void States_with_different_dirty_squares_should_not_be_equal()
{
var a = new VacuumWorldState(3);
var b = new VacuumWorldState(3);
a.MakeSquareDirty(1, 1);
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void DoAction(VacuumWorldState state, VacuumWorldAction action)
{
if (action != VacuumWorldAction.Right)
{
throw new InvalidOperationException();
}
if (state.VacuumPos.X < state.WorldSize - 1)
{
state.VacuumPos = new Point2D(state.VacuumPos.X + 1, state.VacuumPos.Y);
}
}
public void DoAction(VacuumWorldState state, VacuumWorldAction action)
{
if (action != VacuumWorldAction.Up)
{
throw new InvalidOperationException();
}
if (state.VacuumPos.Y > 0)
{
state.VacuumPos = new Point2D(state.VacuumPos.X, state.VacuumPos.Y - 1);
}
}
private void CleanRandomDirtyNeighbour(VacuumWorldState state)
{
var adj = state.AdjacentSquares(state.VacuumPos).Where(state.SquareIsDirty).ToList();
if (adj.Count == 0)
{
return;
}
var squareToClean = _random.Choice(adj);
state.CleanSquare(squareToClean);
}
public void States_with_same_data_should_be_equal()
{
var a = new VacuumWorldState(3);
var b = new VacuumWorldState(3);
a.VacuumPos = new Point2D(1, 2);
a.MakeSquareDirty(1, 1);
b.VacuumPos = new Point2D(1, 2);
b.MakeSquareDirty(1, 1);
Assert.AreEqual(a, b);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
public void GivenSquareIsClean_Suck_ShouldReturnTwoPossibleStates()
{
var currentState = new VacuumWorldState(3);
var possibleStateAllClean = currentState.Clone();
var possibleStateOneSquareDirty = currentState.Clone();
possibleStateOneSquareDirty.MakeSquareDirty(currentState.VacuumPos);
// act
var potentialStates = _searchProblem.DoAction(currentState, VacuumWorldAction.Suck).ToList();
// assert
Assert.AreEqual(2, potentialStates.Count);
Assert.AreEqual(1, potentialStates.Count(s => s.Equals(possibleStateAllClean)));
Assert.AreEqual(1, potentialStates.Count(s => s.Equals(possibleStateOneSquareDirty)));
}
public void GivenOnlyVacuumSquareIsDirty_Suck_ShouldReturnOnePossibleState()
{
var currentState = new VacuumWorldState(3);
currentState.MakeSquareDirty(currentState.VacuumPos);
var onlyPossibleState = currentState.Clone();
onlyPossibleState.CleanSquare(currentState.VacuumPos);
// act
var potentialStates = _searchProblem.DoAction(currentState, VacuumWorldAction.Suck).ToList();
// assert
Assert.AreEqual(1, potentialStates.Count);
Assert.AreEqual(1, potentialStates.Count(s => s.Equals(onlyPossibleState)));
}
private static void InteractivelyDisplaySolution(
VacuumWorldState initialState,
IEnumerable <VacuumWorldAction> solution)
{
var renderer = new Renderer();
var machine = new VacuumWorld(initialState,
VacuumWorldActionHandler.CreateDeterministicActionHandler());
foreach (var action in solution)
{
renderer.Render(machine.State);
var key = Console.ReadKey();
if (key.Key == ConsoleKey.Escape)
{
break;
}
machine.DoAction(action);
}
renderer.Render(machine.State);
}
public void GivenAllSquaresAreDirty_Suck_ShouldReturnCleanedStatePlusCleanedNeighbourStates()
{
var currentState = new VacuumWorldState(3);
currentState.SetAllSquaresDirty();
currentState.VacuumPos = new Point2D(1, 1);
var onlyOneSquareCleanedState = currentState.Clone();
onlyOneSquareCleanedState.CleanSquare(currentState.VacuumPos);
var neighbourCleanedStates = CreateAllStatesWithOneCleanedNeighbour(onlyOneSquareCleanedState);
var expectedPotentialStates = neighbourCleanedStates
.Concat(new[] { onlyOneSquareCleanedState }).ToList();
// act
var potentialStates = _searchProblem.DoAction(currentState, VacuumWorldAction.Suck).ToList();
// assert
CollectionAssert.AreEquivalent(expectedPotentialStates, potentialStates);
}
public void Setup()
{
_handler = new SuckActionHandler();
_state = new VacuumWorldState(3);
}
public void Setup()
{
_decoratedHandler = A.Fake <IVacuumWorldActionHandler>();
_handler = new ErraticSuckActionHandler(_decoratedHandler);
_state = new VacuumWorldState(3);
}
public void Render(VacuumWorldState state)
{
Console.WriteLine(state);
}
private static IEnumerable <VacuumWorldState> CreateAllStatesWithOneCleanedNeighbour(VacuumWorldState state)
{
return(state
.AdjacentSquares(state.VacuumPos)
.Select(square =>
{
var neighbourState = state.Clone();
neighbourState.CleanSquare(square);
return neighbourState;
}));
}
public void DoAction(VacuumWorldState state, VacuumWorldAction action)
{
var handler = _actionHandlers[action];
handler.DoAction(state, action);
}
public void Setup()
{
_initialState = new VacuumWorldState(3);
_searchProblem = new ErraticVacuumWorldSearchProblem();
}
public void NoDirtySquares_ShouldBeGoal()
{
var stateWithNoDirtySquares = new VacuumWorldState(3);
Assert.IsTrue(_searchProblem.IsGoal(stateWithNoDirtySquares));
}
