void DrawAttackState(ProjectedGameState projectedState)
{
Sprite tileTargetedSprite = ScenarioImageManager.GetTileTargetedSprite();
for (int i = 0; i < projectedState.attackedPositions.Count; i++)
{
EntityData activeEntity = projectedState.activeEntity;
Vector2Int attackedPosition = projectedState.attackedPositions[i];
GenerateAndPositionCellImage(attackedPosition, 0f, tileTargetedSprite, activeEntity.IdentifyingColor);
AttackCardData cardData = projectedState.action.card as AttackCardData;
Sprite pointerSprite = cardData.cardImage;
float rotation = GetImageRotation(projectedState.action.direction);
GameObject abilityPointer = ScenarioImageManager.GetAbilityPointer(pointerSprite, rotation, transform);
abilityPointer.transform.position = GetPointerImagePosition(activeEntity.Position, projectedState.action.direction);
if (!drawingSelectedEntity)
{
Color pointerColor = Color.white;
pointerColor.a = deselectedEntityActionOpacity;
abilityPointer.GetComponent <Image>().color = pointerColor;
}
}
}
// TODO: Very rudimentary AI rn, assumes all enemies rushing at player, need some
// switch logic for different AI types.
public void CalculateAndQueueEnemyTurns(ScenarioState gameState)
{
GameBoard currentBoard = BoardController.CurrentBoard;
List <EntityData> enemies = gameState.enemies;
upcomingEntityTargets.Clear();
currentlyOccupiedTiles = enemies.Select(enemy => currentBoard.GetTileAtPosition(enemy.Position)).ToList <Tile>();
foreach (EntityData enemy in enemies)
{
Tile enemyTile = currentBoard.GetTileAtPosition(enemy.Position);
MovementCardData enemyMovementCard = enemy.movementCard;
int enemyMoveRange = enemyMovementCard.range + enemy.GetMovementModifierValue();
AttackCardData enemyAttackCard = enemy.attackCard;
int enemyAttackRange = enemyAttackCard.range;
List <EntityTurnTargets> possibleEntityTurns = enemyTile.GetAllPossibleEntityTurns(enemyMoveRange, enemyAttackRange);
List <EntityTurnTargets> sortedPotentialTurns = SortTurnTargetsByValue(enemyTile, possibleEntityTurns, gameState);
int turnIndex = 0;
EntityTurnTargets selectedTurnTargets = sortedPotentialTurns[turnIndex];
List <Direction> movesToTargetMovementTile = BoardHelperFunctions.FindPathBetweenTiles(enemyTile, selectedTurnTargets.targetMovementTile);
List <Tile> tilesToTargetMovementTile = BoardHelperFunctions.GetTilesOnPath(enemyTile, movesToTargetMovementTile);
// Enemies will not move through traps if they have any other moves available.
while (turnIndex < sortedPotentialTurns.Count &&
tilesToTargetMovementTile.Any(tile => gameState.DoesPositionContainItemWhere(tile.Position, item => item.itemCategory == ItemCategory.Trap) ||
gameState.IsTileOccupied(tile)))
{
turnIndex++;
selectedTurnTargets = sortedPotentialTurns[turnIndex];
movesToTargetMovementTile = BoardHelperFunctions.FindPathBetweenTiles(enemyTile, selectedTurnTargets.targetMovementTile);
tilesToTargetMovementTile = BoardHelperFunctions.GetTilesOnPath(enemyTile, movesToTargetMovementTile);
}
if (turnIndex == sortedPotentialTurns.Count)
{
selectedTurnTargets = sortedPotentialTurns[0];
}
upcomingEntityTargets.Add(selectedTurnTargets);
int rangeOfProjectedAttack = BoardHelperFunctions.GetLinearDistanceBetweenTiles(selectedTurnTargets.targetMovementTile, selectedTurnTargets.targetAttackTile);
Direction attackDirection = BoardHelperFunctions.GetDirectionFromPosition(selectedTurnTargets.targetMovementTile.Position, selectedTurnTargets.targetAttackTile.Position);
Action enemyAction = new Action(enemyAttackCard, enemy, attackDirection, rangeOfProjectedAttack);
Turn enemyTurn = new Turn(enemy, movesToTargetMovementTile, enemyAction);
turnStackController.AddNewTurn(enemyTurn);
}
}
public void LoadCardData(AttackCardData card)
{
cardData = card;
LoadRegularCardData(card);
AttackCard attackCard = (AttackCard)GetComponent <AttackCard>();
attackCard.costText = costText;
attackCard.baseDamageText = baseDamageText;
attackCard.playableEffect = playableEffect;
attackCard.originalCost = card.cost;
attackCard.baseDamage = card.baseDamage;
attackCard.type = card.attackType;
attackCard.statTestStrength = card.statTestStrength;
attackCard.statTestAgility = card.statTestAgility;
attackCard.statTestWisdom = card.statTestWisdom;
attackCard.statTestSpirit = card.statTestSpirit;
attackCard.outStatStrength = card.outStatStrength;
attackCard.outStatAgility = card.outStatAgility;
attackCard.outStatWisdom = card.outStatWisdom;
attackCard.outStatSpirit = card.outStatSpirit;
attackCard.statFailStrength = card.statFailStrength;
attackCard.statFailAgility = card.statFailAgility;
attackCard.statFailWisdom = card.statFailWisdom;
attackCard.statFailSpirit = card.statFailSpirit;
attackCard.modifyUserStrength = card.modifyUserStrength;
attackCard.modifyUserAgility = card.modifyUserAgility;
attackCard.modifyUserWisdom = card.modifyUserWisdom;
attackCard.modifyUserSpirit = card.modifyUserSpirit;
attackCard.modifyEnemyStrength = card.modifyEnemyStrength;
attackCard.modifyEnemyAgility = card.modifyEnemyAgility;
attackCard.modifyEnemyWisdom = card.modifyEnemyWisdom;
attackCard.modifyEnemySpirit = card.modifyEnemySpirit;
}
static ProjectedGameState GetNextStateFromAction_Attack(ScenarioState newState, EntityData entity, Action action)
{
GameBoard testBoard = BoardController.CurrentBoard;
AttackCardData card = action.card as AttackCardData;
TargetType attackTargetType = card.targetType;
Tile attackOriginTile = BoardController.CurrentBoard.GetTileAtPosition(entity.Position);
List <Tile> targetTiles = new List <Tile>();
switch (attackTargetType)
{
case TargetType.Single:
targetTiles.Add(newState.FindFirstOccupiedTileInDirection(attackOriginTile, action.direction, action.distance));
break;
case TargetType.AreaOfEffect:
Tile impactTile = newState.FindFirstOccupiedTileInDirection(attackOriginTile, action.direction, action.distance);
targetTiles.Add(impactTile);
targetTiles.AddRange(impactTile.Neighbors);
break;
case TargetType.Line:
targetTiles.AddRange(attackOriginTile.GetAllTilesInDirection(action.direction, action.card.range));
break;
default:
break;
}
ProjectedGameState newProjectedState = new ProjectedGameState(entity, newState, action);
newProjectedState.AddAttackedPositions(targetTiles.Select(t => t.Position));
List <EntityData> affectedEntities = targetTiles
.Select(t => newState.GetTileOccupant(t))
.Where(o => o != null)
.ToList();
if (affectedEntities.Count == 0)
{
List <ModifierData> modifiersToResolve = action.card.modifiers
.Where(m =>
m.modifierCategory == ModifierCategory.Blowback ||
m.modifierCategory == ModifierCategory.FollowUp)
.ToList();
for (int i = 0; i < modifiersToResolve.Count; i++)
{
ModifierData modifier = modifiersToResolve[i];
ApplyModifierToAttack_BlowbackFollowUp(modifier, entity, newState, action.direction, modifier.modifierCategory);
}
return(newProjectedState);
}
for (int i = 0; i < affectedEntities.Count; i++)
{
EntityData affectedEntity = affectedEntities[i];
int cardDamage = card.damage + entity.GetAttackModifierValue();
affectedEntity.DealDamage(cardDamage, newState);
List <ModifierData> attackModifiers = action.card.modifiers;
if (attackModifiers != null && attackModifiers.Count > 0)
{
for (int j = 0; i < attackModifiers.Count; i++)
{
ApplyModifierToAttack(affectedEntity, attackModifiers[j], entity, newState, action.direction);
}
}
}
return(newProjectedState);
}
