public void TestCompatibilityStartEnd()
{
var startEndShipFields =
new BimaruValue[]
{
BimaruValue.SHIP_CONT_DOWN,
BimaruValue.SHIP_CONT_LEFT,
BimaruValue.SHIP_CONT_RIGHT,
BimaruValue.SHIP_CONT_UP
};
foreach (Direction direction in Directions.GetNonDiagonalDirections())
{
foreach (BimaruValue value in startEndShipFields)
{
foreach (BimaruValue neighbourValue in BimaruValues.AllBimaruValues())
{
bool isValidShipContinuation =
neighbourValue == BimaruValue.SHIP_MIDDLE ||
neighbourValue == BimaruValue.SHIP_UNDETERMINED ||
neighbourValue == BimaruValue.UNDETERMINED ||
neighbourValue == direction.GetLastShipValue();
bool shouldBeCompatible =
(value != direction.GetFirstShipValue() && !neighbourValue.IsShip()) ||
(value == direction.GetFirstShipValue() && isValidShipContinuation);
Assert.AreEqual(shouldBeCompatible, value.IsCompatibleWith(direction, neighbourValue));
Assert.AreEqual(shouldBeCompatible, neighbourValue.IsCompatibleWith(direction.GetOpposite(), value));
}
}
}
}
public void TestClipboard()
{
var backup = new Backup <BimaruGrid>();
var grid = new BimaruGrid(1, 2);
var p0 = new GridPoint(0, 0);
var p1 = new GridPoint(0, 1);
grid[p0] = BimaruValue.SHIP_CONT_UP;
grid[p1] = BimaruValue.SHIP_CONT_DOWN;
backup.CloneToClipboard(grid);
grid[p0] = BimaruValue.SHIP_SINGLE;
grid[p1] = BimaruValue.WATER;
backup.RestoreFromClipboardTo(grid);
BimaruValue[,] expectedFieldValues;
expectedFieldValues = new BimaruValue[1, 2]
{
{ BimaruValue.SHIP_CONT_UP, BimaruValue.SHIP_CONT_DOWN }
};
grid.AssertEqual(expectedFieldValues);
}
public void TestStackOperations()
{
var backup = new Backup <BimaruGrid>();
var grid = new BimaruGrid(1, 2);
var p0 = new GridPoint(0, 0);
var p1 = new GridPoint(0, 1);
grid[p0] = BimaruValue.SHIP_SINGLE;
grid[p1] = BimaruValue.WATER;
backup.SetSavePoint(grid);
grid[p0] = BimaruValue.SHIP_CONT_DOWN;
grid[p1] = BimaruValue.UNDETERMINED;
backup.RestoreAndDeleteLastSavepoint(grid);
BimaruValue[,] expectedFieldValues = new BimaruValue[1, 2]
{
{ BimaruValue.SHIP_SINGLE, BimaruValue.WATER }
};
grid.AssertEqual(expectedFieldValues);
AssertEmptyStack(backup);
}
/// <summary>
/// True, if the given value and its neighbour value in the given direction are compatible.
/// </summary>
public static bool IsCompatibleWith(this BimaruValue value, Direction direction, BimaruValue neighbourValue)
{
BimaruValueConstraint constraintToNeighbour = value.GetConstraint(direction);
BimaruValueConstraint constraintToThis = neighbourValue.GetConstraint(direction.GetOpposite());
return(constraintToNeighbour.DoesAllow(neighbourValue) && constraintToThis.DoesAllow(value));
}
private static void CheckIsChangeValid(IGame game, FieldValueChangedEventArgs <BimaruValue> e)
{
BimaruValue newValue = game.Grid[e.Point];
if (!game.IsValid || !e.OriginalValue.IsCompatibleChangeTo(newValue))
{
throw new InvalidFieldValueChange();
}
}
public void TestFillUndeterminedFieldsColumnToNo()
{
var grid = new BimaruGrid(2, 3);
grid.FillUndeterminedFieldsColumn(1, BimaruValueConstraint.NO);
BimaruValue[,] expectedFieldValues = new BimaruValue[2, 3]
{
{ BimaruValue.UNDETERMINED, BimaruValue.UNDETERMINED, BimaruValue.UNDETERMINED },
{ BimaruValue.UNDETERMINED, BimaruValue.UNDETERMINED, BimaruValue.UNDETERMINED }
};
grid.AssertEqual(expectedFieldValues);
}
public void TestFillUndeterminedFieldsRowToShip()
{
var grid = new BimaruGrid(2, 3);
grid.FillUndeterminedFieldsRow(1, BimaruValueConstraint.SHIP);
BimaruValue[,] expectedFieldValues = new BimaruValue[2, 3]
{
{ BimaruValue.UNDETERMINED, BimaruValue.UNDETERMINED, BimaruValue.UNDETERMINED },
{ BimaruValue.SHIP_UNDETERMINED, BimaruValue.SHIP_UNDETERMINED, BimaruValue.SHIP_UNDETERMINED }
};
grid.AssertEqual(expectedFieldValues);
}
public void TestFillUndeterminedFieldsColumnPreset()
{
var grid = new BimaruGrid(2, 3);
grid[new GridPoint(0, 1)] = BimaruValue.WATER;
grid.FillUndeterminedFieldsColumn(1, BimaruValueConstraint.SHIP);
BimaruValue[,] expectedFieldValues = new BimaruValue[2, 3]
{
{ BimaruValue.UNDETERMINED, BimaruValue.WATER, BimaruValue.UNDETERMINED },
{ BimaruValue.UNDETERMINED, BimaruValue.SHIP_UNDETERMINED, BimaruValue.UNDETERMINED }
};
grid.AssertEqual(expectedFieldValues);
}
private void SetShipMiddleNeighbours(IGame game, GridPoint pointShipMiddle, DirectionType directionShipMiddle)
{
foreach (var direction in Directions.GetAllDirections())
{
var constraint = direction.GetDirectionType() == directionShipMiddle ?
BimaruValueConstraint.SHIP :
BimaruValueConstraint.WATER;
// Skip set if constraint already satisfied
var pointInDirection = pointShipMiddle.GetNextPoint(direction);
if (!constraint.IsSatisfiedBy(game.Grid[pointInDirection]))
{
BimaruValue valueToSet = constraint.GetRepresentativeValue();
game.Grid[pointInDirection] = valueToSet;
}
}
}
public bool IsCompatibleButNotEqualIn(IGame game)
{
bool isEqual = true;
foreach (var c in Changes)
{
BimaruValue currentValue = game.Grid[c.Point];
if (!currentValue.IsCompatibleChangeTo(c.NewValue))
{
return(false);
}
isEqual = isEqual && (currentValue == c.NewValue);
}
return(!isEqual);
}
public void FieldValueChanged(IGame game, FieldValueChangedEventArgs <BimaruValue> e)
{
BimaruValue newValue = game.Grid[e.Point];
foreach (Direction direction in Directions.GetAllDirections())
{
BimaruValueConstraint constraintInDirection = newValue.GetConstraint(direction);
GridPoint pointInDirection = e.Point.GetNextPoint(direction);
BimaruValue valueInDirection = game.Grid[pointInDirection];
// Skip set if constraint already satisfied
if (!constraintInDirection.IsSatisfiedBy(valueInDirection))
{
BimaruValue valueToSet = constraintInDirection.GetRepresentativeValue();
game.Grid[pointInDirection] = valueToSet;
}
}
}
public void TestCompatibilityRemaining()
{
var remainingShipFields =
new BimaruValue[]
{
BimaruValue.UNDETERMINED,
BimaruValue.WATER,
BimaruValue.SHIP_UNDETERMINED,
BimaruValue.SHIP_MIDDLE
};
foreach (Direction direction in Directions.GetNonDiagonalDirections())
{
foreach (BimaruValue value in remainingShipFields)
{
foreach (BimaruValue neighbourValue in remainingShipFields)
{
Assert.IsTrue(value.IsCompatibleWith(direction, neighbourValue));
Assert.IsTrue(neighbourValue.IsCompatibleWith(direction, value));
}
}
}
}
/// <summary>
/// Constraint that a field value gives to the neighbour field in the given direction.
/// </summary>
public static BimaruValueConstraint GetConstraint(this BimaruValue value, Direction direction)
{
BimaruValueConstraint constraint = BimaruValueConstraint.NO;
if (value.IsShip())
{
if (direction.GetDirectionType() == DirectionType.DIAGONAL)
{
constraint = BimaruValueConstraint.WATER;
}
else if (value == direction.GetFirstShipValue())
{
constraint = BimaruValueConstraint.SHIP;
}
else if (value != BimaruValue.SHIP_MIDDLE &&
value != BimaruValue.SHIP_UNDETERMINED)
{
constraint = BimaruValueConstraint.WATER;
}
}
return(constraint);
}
/// <summary>
/// True, if a new field value does not contradict the old value.
/// For example, the new value WATER would be incompatible with
/// SHIP_UNDETERMINED. However, the new value SHIP_SINGLE would
/// be compatible with SHIP_UNDETERMINED, as it further specifies it.
/// </summary>
public static bool IsCompatibleChangeTo(this BimaruValue oldValue, BimaruValue newValue)
{
return(oldValue == newValue ||
oldValue == BimaruValue.UNDETERMINED ||
(oldValue == BimaruValue.SHIP_UNDETERMINED && newValue.IsShip()));
}
/// <summary>
/// Whether the constraint allows the Bimaru value. Note that all
/// constraints allow the value UNDETERMINED as the constraint
/// can still be fullfilled in the future.
/// </summary>
public static bool DoesAllow(this BimaruValueConstraint constraint, BimaruValue value)
{
return(constraint.IsSatisfiedBy(value) || value == BimaruValue.UNDETERMINED);
}
/// <summary>
/// True, if the constraint is satisfied by the Bimaru value.
/// </summary>
public static bool IsSatisfiedBy(this BimaruValueConstraint constraint, BimaruValue value)
{
return(constraint == BimaruValueConstraint.NO || constraint == value.GetConstraint());
}
/// <summary>
/// Most specific constraint that the field value satisfies.
/// </summary>
public static BimaruValueConstraint GetConstraint(this BimaruValue value)
{
return(constraintOfValue[value]);
}
/// <summary>
/// All Bimaru values except UNDETERMINED and SHIP_UNDETERMINED
/// are fully determined.
/// </summary>
public static bool IsFullyDetermined(this BimaruValue value)
{
return(!isNotFullyDetermined.Contains(value));
}
/// <summary>
/// True, if the field is any kind of ship.
/// </summary>
public static bool IsShip(this BimaruValue value)
{
return(value.GetConstraint() == BimaruValueConstraint.SHIP);
}
