public static MoveDestinationField GetFieldById(GameTable actualTable, int fieldId)
{
MoveDestinationField moveDestinationField = null;
PlayerFieldArea playerFieldArea = actualTable.PlayerFieldAreas.Find(area => area.Fields.Find(field =>
{
if (field.Identifier != fieldId)
{
return(false);
}
moveDestinationField = field;
return(true);
}) != null);
if (moveDestinationField == null)
{
PlayerFieldArea playerFieldAreaKennel = actualTable.PlayerFieldAreas.Find(area => area.KennelFields.Find(field =>
{
if (field.Identifier != fieldId)
{
return(false);
}
moveDestinationField = field;
return(true);
}) != null);
}
return(moveDestinationField);
}
private static bool IsSimpleInvalidChangeField(MoveDestinationField field)
{
KennelField kennelField = field as KennelField;
EndField endField = field as EndField;
return(kennelField != null || endField != null);
}
public static bool ProveChangePlace(Meeple moveMeeple, MoveDestinationField destinationField)
{
if (moveMeeple == null || destinationField.CurrentMeeple == null)
{
return(false);
}
if (IsSameColorCode(moveMeeple.ColorCode, destinationField.CurrentMeeple.ColorCode))
{
return(false);
}
if (IsSimpleInvalidChangeField(destinationField) || IsSimpleInvalidChangeField(moveMeeple.CurrentPosition))
{
return(false);
}
if (IsStandardField(destinationField) && !IsStandardField(moveMeeple.CurrentPosition))
{
return(IsValidStartField(moveMeeple.CurrentPosition));
}
if (!IsStandardField(destinationField) && IsStandardField(moveMeeple.CurrentPosition))
{
return(IsValidStartField(destinationField));
}
if (!(IsStandardField(moveMeeple.CurrentPosition) && IsStandardField(destinationField)))
{
return(IsValidStartField(destinationField) && IsValidStartField(moveMeeple.CurrentPosition));
}
return(true);
}
private static void SetSecondMeeplePosition(GameTable gameTable, MoveDestinationField saveField, Meeple moveDestinationMeeple)
{
foreach (Meeple actualMeeple in gameTable.PlayerFieldAreas.Select(area =>
area.Meeples.Find(meeple => meeple.CurrentPosition.Identifier == saveField.Identifier && meeple.ColorCode == moveDestinationMeeple.ColorCode)).
Where(actualMeeple => actualMeeple != null))
{
actualMeeple.CurrentPosition = moveDestinationMeeple.CurrentPosition;
actualMeeple.CurrentFieldId = moveDestinationMeeple.CurrentFieldId;
}
}
public static bool IsValidStartField(MoveDestinationField field)
{
StartField startField = field as StartField;
if (startField?.CurrentMeeple != null)
{
return(!startField.CurrentMeeple.IsStartFieldBlocked);
}
return(startField != null && startField.CurrentMeeple == null);
}
public void TestUpdateMeeplePositionNoMeepleMove()
{
GameTable table = MakeInitialGameTable;
PlayerFieldArea redArea = table.PlayerFieldAreas.Find(area => area.ColorCode == ColorCode.Red);
Meeple redMeeple = redArea.Meeples.First();
MoveDestinationField currentField = redArea.Fields.Find(field => field.FieldType.Contains("StartField"));
currentField.CurrentMeeple = redMeeple;
MoveDestinationField moveField = redArea.Fields.Find(field => field.FieldType.Contains("StandardField"));
GameTable notModified = table;
GameTableService.UpdateMeeplePosition(null, table, false);
Assert.AreEqual(table, notModified);
}
public void TestUpdateMeeplePositionCorrectlyInitialized()
{
GameTable table = MakeInitialGameTable;
PlayerFieldArea redArea = table.PlayerFieldAreas.Find(area => area.ColorCode == ColorCode.Red);
Meeple redMeeple = redArea.Meeples.First();
MoveDestinationField currentField = redArea.Fields.Find(field => field.FieldType.Contains("StartField"));
currentField.CurrentMeeple = redMeeple;
MoveDestinationField moveField = redArea.Fields.Find(field => field.FieldType.Contains("StandardField"));
GameTableService.UpdateMeeplePosition(new MeepleMove()
{
Meeple = redMeeple, MoveDestination = moveField
}, table, false);
Assert.AreEqual(moveField, table.PlayerFieldAreas.Find(area => area.ColorCode == ColorCode.Red).Fields.Find(field => field.CurrentMeeple == redMeeple));
}
public static MoveDestinationField GetNextField(MoveDestinationField currentPos, int value)
{
if (currentPos.FieldType.Contains("KennelField"))
{
return(null);
}
int fieldCounter = Math.Abs(value);
while (fieldCounter > 0)
{
currentPos = value > 0 ? currentPos.Next : currentPos.Previous;
if (!IsSimpleInvalidChangeField(currentPos))
{
--fieldCounter;
}
}
return(currentPos);
}
public static bool ProveLeaveKennel(Meeple moveMeeple, MoveDestinationField destinationField)
{
if (!moveMeeple.CurrentPosition.FieldType.Contains("KennelField"))
{
return(false);
}
if (!destinationField.FieldType.Contains("StartField"))
{
return(false);
}
StartField startField = destinationField as StartField;
if (startField != null && !IsSameColorCode(startField.ColorCode, moveMeeple.ColorCode))
{
return(false);
}
return(destinationField.CurrentMeeple == null || IsValidStartField(destinationField));
}
public static bool ProveValueCard(Meeple moveMeeple, MoveDestinationField destinationField, int value)
{
MoveDestinationField currentPos = moveMeeple.CurrentPosition;
if (destinationField == null)
{
return(false);
}
if (HasBlockedField(currentPos, value))
{
return(false);
}
if (destinationField.FieldType.Contains("EndField"))
{
return(CanMoveToEndFields(currentPos, value, moveMeeple.ColorCode));
}
currentPos = GetNextField(currentPos, value);
return(currentPos?.Identifier == destinationField.Identifier);
}
private static int GetDifferenceBetweenTwoFields(MoveDestinationField startField, MoveDestinationField endField)
{
int counter = 0;
MoveDestinationField tempField = startField.Next;
while (tempField != null)
{
if (!tempField.FieldType.Contains("EndField"))
{
counter++;
}
if (tempField.Identifier == endField.Identifier)
{
return(counter);
}
tempField = tempField.Next;
}
return(-1);
}
public static bool ValidateMove(MeepleMove meepleMove, CardMove cardMove)
{
Meeple movedMeeple = meepleMove.Meeple;
MoveDestinationField destinationField = meepleMove.MoveDestination;
int test = 0;
if (movedMeeple == null || cardMove == null)
{
return(false);
}
foreach (CardAttribute attribute in cardMove.Card.Attributes)
{
switch (attribute.Attribute)
{
case CardFeature.ChangePlace:
if (ProveChangePlace(movedMeeple, destinationField))
{
test += 1;
if ((cardMove.Card.Name == "cardJoker" && GetDifferenceBetweenTwoFields(movedMeeple.CurrentPosition, destinationField) > 13) ||
(cardMove.Card.Name == "cardJoker" && IsPartnerColorCode(movedMeeple.ColorCode, destinationField.CurrentMeeple.ColorCode) && GetDifferenceBetweenTwoFields(movedMeeple.CurrentPosition, destinationField) <= 13) ||
(cardMove.Card.Name != "cardJoker"))
{
cardMove.SelectedAttribute = new CardAttribute(CardFeature.ChangePlace);
}
}
break;
case CardFeature.LeaveKennel:
if (ProveLeaveKennel(movedMeeple, destinationField))
{
test += 1;
}
break;
}
if (ProveValueCard(movedMeeple, destinationField, (int)attribute.Attribute))
{
test += 1;
}
}
return(test > 0);
}
public static bool HasBlockedField(MoveDestinationField startCountField, int countFields)
{
if (startCountField == null)
{
return(true);
}
if (startCountField.FieldType.Contains("StartField"))
{
return(false);
}
int fieldCounter = Math.Abs(countFields);
for (int i = 0; i < fieldCounter; i++)
{
if (startCountField == null)
{
return(false);
}
while (startCountField.FieldType.Contains("EndField"))
{
startCountField = countFields > 0 ? startCountField.Next : startCountField.Previous;
fieldCounter--;
if (startCountField == null)
{
return(fieldCounter == i);
}
if (startCountField.FieldType.Contains("EndField"))
{
return(startCountField.CurrentMeeple != null);
}
}
StartField startField = startCountField as StartField;
if (startField != null)
{
return(startField.CurrentMeeple != null && startField.CurrentMeeple.IsStartFieldBlocked);
}
startCountField = countFields > 0 ? startCountField.Next : startCountField.Previous;
}
return(false);
}
private static void PrepareMeeplePos(GameTable gameTable, MeepleMove meepleMove, ref MoveDestinationField saveField, ref Meeple meeple, bool isChangePlace)
{
foreach (PlayerFieldArea area in gameTable.PlayerFieldAreas)
{
MoveDestinationField oldDestinationField = area.Fields.Find(field => field.Identifier == meepleMove.Meeple.CurrentFieldId) ??
area.KennelFields.Find(field => field.Identifier == meepleMove.Meeple.CurrentFieldId);
if (oldDestinationField != null)
{
oldDestinationField.CurrentMeeple = null;
}
MoveDestinationField updateField = area.Fields.Find(field => field.Identifier == meepleMove.MoveDestination.Identifier) ??
area.KennelFields.Find(field => field.Identifier == meepleMove.MoveDestination.Identifier);
if (updateField == null)
{
continue;
}
saveField = updateField;
if (isChangePlace)
{
if (updateField.CurrentMeeple != null)
{
meeple = updateField.CurrentMeeple;
meeple.CurrentFieldId = meepleMove.Meeple.CurrentPosition.Identifier;
meeple.CurrentPosition = meepleMove.Meeple.CurrentPosition;
}
}
else
{
if (updateField.CurrentMeeple != null)
{
meeple = updateField.CurrentMeeple;
}
}
updateField.CurrentMeeple = meepleMove.Meeple;
}
}
public static bool CanMoveToEndFields(MoveDestinationField startCountField, int fieldDistanceCount, ColorCode meepleColorCode)
{
if (startCountField.FieldType.Contains("EndField"))
{
return(HandleEndFieldsFromEndField((EndField)startCountField, fieldDistanceCount));
}
if (HasBlockedField(startCountField, fieldDistanceCount))
{
return(false);
}
if (startCountField.FieldType.Contains("StartField") &&
!startCountField.CurrentMeeple.IsStartFieldBlocked)
{
return(false);
}
int fieldCount = Math.Abs(fieldDistanceCount);
for (int i = 0; i < fieldCount; i++)
{
if (startCountField == null)
{
return(false);
}
startCountField = fieldDistanceCount > 0 ? startCountField.Next : startCountField.Previous;
StartField startField = startCountField as StartField;
if (startField == null)
{
continue;
}
if (HandleEndFieldsFromStartField(startField, fieldCount - i - 1))
{
return(startField.ColorCode == meepleColorCode);
}
return(false);
}
return(false);
}
public static void UpdateMeeplePosition(MeepleMove meepleMove, GameTable gameTable, bool isChangePlace)
{
if (gameTable == null || meepleMove == null)
{
return;
}
MoveDestinationField saveField = null;
Meeple moveDestinationMeeple = null;
PrepareMeeplePos(gameTable, meepleMove, ref saveField, ref moveDestinationMeeple, isChangePlace);
SetFirstMeeplePosition(gameTable, meepleMove, saveField);
if (moveDestinationMeeple == null)
{
return;
}
if (!isChangePlace)
{
moveDestinationMeeple = SetBackToKennelField(gameTable, moveDestinationMeeple);
}
SetSecondMeeplePosition(gameTable, saveField, moveDestinationMeeple);
}
public Meeple(KennelField kennelField)
{
CurrentPosition = kennelField;
}
private static void SetFirstMeeplePosition(GameTable gameTable, MeepleMove meepleMove, MoveDestinationField saveField)
{
foreach (Meeple actualMeeple in gameTable.PlayerFieldAreas.Select(area =>
area.Meeples.Find(meeple => meeple.CurrentPosition.Identifier == meepleMove.Meeple.CurrentFieldId)).
Where(actualMeeple => actualMeeple != null))
{
if (actualMeeple.CurrentPosition.FieldType.Contains("StartField"))
{
actualMeeple.IsStartFieldBlocked = false;
if (saveField != null)
{
saveField.CurrentMeeple.IsStartFieldBlocked = false;
}
}
actualMeeple.CurrentPosition = saveField;
actualMeeple.CurrentFieldId = saveField?.Identifier ?? -1;
}
}
public static bool IsStandardField(MoveDestinationField field)
{
return(field.FieldType.Contains("StandardField"));
}
public static bool IsMovableField(MoveDestinationField field)
{
return(field.FieldType.Contains("StartField") || field.FieldType.Contains("EndField") ||
field.FieldType.Contains("StandardField"));
}
