private List <Vector2> CalcDestinations(
PieceEV pieceEV,
List <PieceEV> allPieces,
IEntitiesDB entitiesDB,
bool excludeCheckViolations = false,
bool excludeObstructedDestinations = true)
{
bool useGoldMovement = IsOpponentPieceDirectlyBelow(pieceEV, allPieces);
IPieceData pieceData = CreatePieceData(pieceEV, useGoldMovement);
List <Vector2> returnValue = AdjustAndExcludeSingleDestinations(
pieceData,
pieceEV,
allPieces,
excludeObstructedDestinations);
returnValue.AddRange(AdjustJumpDestinations(
pieceData,
pieceEV,
allPieces
));
returnValue.AddRange(AdjustAndExcludeLineDestinations(
pieceData,
pieceEV,
allPieces,
excludeObstructedDestinations));
if (excludeCheckViolations) // Should only happen for turn player
{
ExcludeCheckViolations(pieceEV, returnValue, allPieces, entitiesDB);
}
return(returnValue);
}
private IEnumerable <Vector2> AdjustAndExcludeLineDestinations(
IPieceData pieceData,
PieceEV pieceEV,
List <PieceEV> allPieces,
bool excludeObstructedDestinations)
{
int tier = CalcTierToUse(pieceEV, allPieces);
List <Vector2> vectors = pieceData.Tiers[tier - 1].Line;
List <Vector2> returnValue = new List <Vector2>();
foreach (Vector2 vector in vectors)
{
List <Vector2> line = ExpandLineVector(vector);
AdjustRawDataWithPieceLocationAndDirection(pieceEV, line);
ExcludeOutOfBoard(line);
if (excludeObstructedDestinations) // Do NOT allow destinations other pieces in the way
{
ExcludeDestinationsWithObstructingPieces(pieceEV, line, allPieces);
}
// Always exclude these scenarios
ExcludeDestinationsAtCannotBeStackedPieces(line, allPieces);
ExcludeTowerDestinationsWithSameTypeAndTeam(pieceEV, line, allPieces);
returnValue.AddRange(line);
}
return(returnValue);
}
private List <Vector2> AdjustJumpDestinations(
IPieceData pieceData,
PieceEV pieceEV,
List <PieceEV> allPieces)
{
int tier = CalcTierToUse(pieceEV, allPieces);
List <Vector2> returnValue = pieceData.Tiers[tier - 1].Jump;
AdjustDestinations(returnValue, pieceEV, allPieces);
return(returnValue);
}
public void Step(ref ForcedRecoveryStepState token, int condition)
{
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
IPieceData piece = pieceFactory.CreateIPieceData(token.PieceMoved.Piece.PieceType);
bool forcedRecoveryPossible = token.PieceMoved.Tier.TopOfTower && // Paranoia check
piece.Abilities.PostMove.Contains(PostMoveAbility.FORCED_RECOVERY) &&
!HasDestinationTiles(token.PieceMoved) &&
checkService.ForcedRecoveryResolvesOrDoesNotCreateCheck(token.PieceMoved, currentTurn, entitiesDB);
NextAction(ref token, forcedRecoveryPossible);
}
private static void AddPostMoveAbilities(IPieceData pieceData)
{
foreach (PostMoveAbility postMoveAbility in pieceData.Abilities.PostMove)
{
if (!PostMove.ContainsKey(postMoveAbility))
{
PostMove[postMoveAbility] = new List <PieceType>();
}
PostMove[postMoveAbility].Add(pieceData.TypeOfPiece);
}
}
private static void AddDropAbilities(IPieceData pieceData)
{
foreach (DropAbility dropAbility in pieceData.Abilities.Drop)
{
if (!Drop.ContainsKey(dropAbility))
{
Drop[dropAbility] = new List <PieceType>();
}
Drop[dropAbility].Add(pieceData.TypeOfPiece);
}
}
private static void AddOtherMoveAbilities(IPieceData pieceData)
{
if (pieceData.Abilities.OtherMove.HasValue)
{
if (!OtherMove.ContainsKey(pieceData.Abilities.OtherMove.Value))
{
OtherMove[pieceData.Abilities.OtherMove.Value] = new List <PieceType>();
}
OtherMove[pieceData.Abilities.OtherMove.Value].Add(pieceData.TypeOfPiece);
}
}
static AbilityToPiece()
{
PieceFactory pieceFactory = new PieceFactory();
Array pieceTypes = Enum.GetValues(typeof(PieceType));
foreach (PieceType pieceType in pieceTypes)
{
IPieceData pieceData = pieceFactory.CreateIPieceData(pieceType);
AddOtherMoveAbilities(pieceData);
AddPreMoveAbilities(pieceData);
AddPostMoveAbilities(pieceData);
AddDropAbilities(pieceData);
}
}
private List <Vector2> AdjustAndExcludeSingleDestinations(
IPieceData pieceData,
PieceEV pieceEV,
List <PieceEV> allPieces,
bool excludeObstructedDestinations)
{
int tier = CalcTierToUse(pieceEV, allPieces);
List <Vector2> returnValue = pieceData.Tiers[tier - 1].Single;
AdjustDestinations(returnValue, pieceEV, allPieces);
if (excludeObstructedDestinations) // Do NOT allow destinations other pieces in the way
{
ExcludeDestinationsWithObstructingPieces(pieceEV, returnValue, allPieces, true);
}
return(returnValue);
}
private bool HasForcedRearrangementAbility(PieceType pieceType)
{
IPieceData pieceData = pieceFactory.CreateIPieceData(pieceType);
return(pieceData.Abilities.PostMove.Contains(PostMoveAbility.FORCED_REARRANGEMENT));
}
