public bool EvaluateHex(BattleHex evaluatedHex)
{
return(evaluatedHex.battleHexState
== HexState.active && // Excluye maleficios inactivos
!evaluatedHex.isStartingHex && // Excluye la posición inicial
evaluatedHex.AvailableToGround()); // excluye agua y montañas
}
public bool EvaluateHex(BattleHex evaluatedHex)
{
return(evaluatedHex.battleHexState
== HexState.active && //exclude inactive hexes
!evaluatedHex.isStartingHex && //exclude starting hex
!evaluatedHex.lookingForTarget); //exclude previously checked hex
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Constructors/Initialisation
/// <summary>
/// Creates a new movement action for the specified unit.
/// </summary>
/// <param name="unit">The unit this action is attached to.</param>
/// <param name="startPosition">The initial position to start this action from.</param>
/// <param name="distance">The total distance of the movement.</param>
/// <param name="startRotation">The initial rotation to start this action from.</param>
/// <param name="endRotation">The end rotation for this movement action.</param>
/// <param name="speedModifier">The movement speed modifier.</param>
internal UnitMovement(BattleUnit unit, Vector3 startPosition, Vector3 endPosition, BattleHex currentTile, HexDirection startDirection, HexDirection endDirection, float startRotation, float endRotation, float speedModifier)
: base(unit)
{
this._startPosition = startPosition;
this._endPosition = endPosition;
this._endTile = currentTile;
this._endFacingDirection = endDirection;
if (startDirection != endDirection)
{
HexDirection between = HexHelpers.DirectionBetween(startDirection, endDirection);
this._rotateAround = currentTile.GetNeighbourPosition(between);
this._startRotation = startRotation;
this._endRotation = endRotation;
float rotation = endRotation - startRotation;
while (rotation <= 0f)
{
rotation += 360f;
}
this._rotationAngle = rotation;
}
this._speedModifier = speedModifier;
this._lerpValue = 0f;
}
private void RemoveHero(Hero hero) //removes the selected hero
{
BattleHex parentHex = hero.GetComponentInParent <BattleHex>(); // para acceder al método MakeMeDeploymentPosition
parentHex.MakeMeDeploymentPosition(); // devuelve el hex a la posición inicial
Destroy(hero.gameObject); // elimina al héroe
}
public bool EvaluateHex(BattleHex evaluatedHex)
{
return(evaluatedHex.battleHexState
== HexState.active &&
!evaluatedHex.isStartingHex &&
!evaluatedHex.isNeighbourgHex);
}
private void RemoveHero(Hero hero) //removes the selected hero
{
BattleHex parentHex = hero.GetComponentInParent <BattleHex>(); //to access the MakeMeDeploymentPosition method
parentHex.MakeMeDeploymentPosition(); //returns the hex to the starting position
Destroy(hero.gameObject); //removes the hero
}
public bool EvaluateHex(BattleHex evaluatedHex)
{
return(evaluatedHex.battleHexState
== HexState.active && //Excludes inactive hexes
!evaluatedHex.isStartingHex && //Excludes the starting position
evaluatedHex.AvailableToGround()); //excludes water and mountains
}
public bool EvaluateHex(BattleHex evaluatedHex)
{
return(evaluatedHex.battleHexState
== HexState.active && // excluir hexágonos inactivos
!evaluatedHex.isStartingHex && // excluir hexadecimal inicial
!evaluatedHex.lookingForTarget); // excluir hexadecimal previamente comprobado
}
public void SetDistanceForFlyingUnit(BattleHex initialHex)
{
stepsToGo = 1;
// agrega un paso al paso anterior para obtener la diastancia desde el punto de partida
distanceFromStartingPoint = initialHex.distanceText.distanceFromStartingPoint + stepsToGo;
//display new value of the distanceFromStartingPoint
//DisplayDistanceText();
}
public bool EvaluateHex(BattleHex evaluatedHex)
{
return(evaluatedHex.battleHexState
== HexState.active &&
!evaluatedHex.isStartingHex &&
!evaluatedHex.isIncluded &&
evaluatedHex.AvailableToGround());
}
public bool EvaluateHex(BattleHex evaluatedHex)
{
return(evaluatedHex.battleHexState
== HexState.active &&
!evaluatedHex.isStartingHex &&
!evaluatedHex.isNeighboringHex &&
evaluatedHex.GetComponentInChildren <Enemy>() == null);
}
public void SetDistanceForFlyingUnit(BattleHex initialHex)
{
stepsToGo = 1;
//add a step to the previous step to get diastance from starting point
distanceFromStartingPoint = initialHex.distanceText.distanceFromStartingPoint + stepsToGo;
//display new value of the distanceFromStartingPoint
//DisplayDistanceText();
}
public bool EvaluateHex(BattleHex evaluatedHex)
{
return(evaluatedHex.battleHexState
== HexState.active && // Excluye maleficios inactivos
!evaluatedHex.isStartingHex && // Excluye la posición inicial
!evaluatedHex.isIncluded && // excluye los hexágonos que ya están marcados como válidos
evaluatedHex.AvailableToGround() && // excluye agua y montañas
ifThereIsAI(evaluatedHex)); // excluye los hacks ocupados por el regimiento del jugador
}
public bool EvaluateHex(BattleHex evaluatedHex)
{
return(evaluatedHex.battleHexState
== HexState.active &&
!evaluatedHex.isStartingHex &&
!evaluatedHex.isIncluded &&
evaluatedHex.AvailableToGround() &&
evaluatedHex.GetComponentInChildren <Enemy>() == null);
}
public bool EvaluateHex(BattleHex evaluatedHex)
{
return(evaluatedHex.battleHexState
== HexState.active && //Excludes inactive hexes
!evaluatedHex.isStartingHex && //Excludes the starting position
!evaluatedHex.isIncluded && //excludes hexes that are already marked as valid
evaluatedHex.AvailableToGround() && //excludes water and mountains
ifThereIsAI(evaluatedHex)); //excludes hacks occupied by player's regiment
}
public bool EvaluateDistanceForGround(BattleHex initialHex)
{
int currentDistance = initialHex.distanceText.distanceFromStartingPosition
+ initialHex.distanceText.stepsToGo;
int stepsLimit = BattleController.currentAtacker.velocity;
return(distanceFromStartingPosition > currentDistance &&
stepsLimit >= currentDistance);
}
/* --------------------------------------------------------------------- */
#region Public Methods
public override void StartTurn()
{
BattleHex endTile = null;
for (int i = 0; i < hexesWithinDistance.Count; i++)
{
BattleHex tile = hexesWithinDistance[i];
if (tile.DoesNeighbourHaveUnit)
{
for (int j = 0; j < tile.Neighbours.Count; j++)
{
BattleHex neighbour = tile.Neighbours[j];
if (neighbour.HasUnit && neighbour.Unit.IsAIControlled == false)
{
endTile = tile;
break;
}
}
if (endTile != null)
{
break;
}
}
}
if (endTile == null)
{
int tileIndex = ((int)(Random.value * 1000)) % hexesWithinDistance.Count;
endTile = hexesWithinDistance[tileIndex];
}
Path <BattleHex> path = PathFinder.FindPath(CurrentHexTile, endTile);
BattleUnit attackTarget = null;
for (int i = 0; i < endTile.Neighbours.Count; i++)
{
BattleHex neighbour = endTile.Neighbours[i];
if (neighbour.HasUnit && neighbour.Unit.IsAIControlled == false)
{
attackTarget = neighbour.Unit;
}
}
if (attackTarget != null)
{
TravelPathAndAttack(path.GetPath(), attackTarget);
}
else
{
TravelPath(path.GetPath());
}
}
public bool EvaluateDistanceForGroundAI(BattleHex initialHex, int stepsLimit)
{
//distance to reach initial hex and get out of it
int currentDistance = initialHex.distanceText.distanceFromStartingPoint
+ initialHex.distanceText.stepsToGo;
//default value of distanceFromStartingPoint is 20 to set the shortest path
return(distanceFromStartingPoint > currentDistance &&
stepsLimit >= currentDistance);//to evaluate if the velocity is enough to reach this hex
}
public bool EvaluateDistanceForGroundAI(BattleHex initialHex, int stepsLimit)
{
// distancia para alcanzar el hex inicial y salir de él
int currentDistance = initialHex.distanceText.distanceFromStartingPoint
+ initialHex.distanceText.stepsToGo;
// el valor predeterminado de distanceFromStartingPoint es 20 para establecer la ruta más corta
return(distanceFromStartingPoint > currentDistance &&
stepsLimit >= currentDistance);// para evaluar si la velocidad es suficiente para alcanzar este
}
private void DestroyMe(CharAttributes SOHero) // destruye este objeto
{
if (SOHero == heroData) // compara la elección del jugador con el héroe
{
BattleHex parentHex = GetComponentInParent <BattleHex>();
parentHex.MakeMeDeploymentPosition();
startBTN.ControlStartBTN();/// comprueba si es hora de ocultar el botón Inicio
Destroy(gameObject);
}
}
public void Aisturnbegins(IInitialHexes getInitialHexes)
{
int stepsLimit = battleController.stepsToCheckWholeField;//gets current velocity of the atacker
BattleHex startintHex = GetComponentInParent <BattleHex>();
//starts looking for all player's units
tocheckTheField.GetAvailablePositions(stepsLimit, getInitialHexes, startintHex);
CollectAllPosToOccupy();
AIMakesDecision();
}
// si no hay enemigos cerca, continúa buscando
void TargetsAtAttackDistance(Hero currentAtacker)
{
int stepsLimit = currentAtacker.heroData.Atackdistanse; // número de niveles de búsqueda
BattleHex inititalHex = currentAtacker.GetComponentInParent <BattleHex>(); // hexadecimal inicial
IAdjacentFinder adjFinder = new MarkTargets(); // regla para verificar el hexadecimal
// verifica toda el área de ataque
currentAtacker.GetComponent <AvailablePos>().GetAvailablePositions(stepsLimit, adjFinder, getInitialHexes);
CheckIfItIsNewTurn();
}
internal void ManageSortingLayer(BattleHex targetHex)
{
heroSprite = GetComponent <SpriteRenderer>();
Canvas canvasOfStack = GetComponentInChildren <Canvas>();
int currentLayer = 16 - targetHex.verticalCoordinate;
canvasOfStack.sortingOrder = currentLayer + 1;
heroSprite.sortingOrder = currentLayer;
//hero.stack.GetComponent<Canvas>().sortingOrder = currentLayer;
}
public void Aisturnbegins(IInitialHexes getInitialHexes)
{
int stepsLimit = battleController.stepsToCheckWholeField;// obtiene la velocidad actual del atacante
BattleHex startintHex = GetComponentInParent <BattleHex>();
// comienza a buscar todas las unidades del jugador
tocheckTheField.GetAvailablePositions(stepsLimit, getInitialHexes, startintHex);
CollectAllPosToOccupy();
AIMakesDecision();
}
private void DestroyMe(CharAttributes SOHero) //destroys this object
{
if (SOHero == heroData) // compares the player’s choice with the hero
{
BattleHex parentHex = GetComponentInParent <BattleHex>();
parentHex.MakeMeDeploymentPosition();
startBTN.ControlStartBTN();//checks if it's time to hide the Start button
Destroy(gameObject);
}
}
public void GetAdjacentHexesExtended(BattleHex initialHex)
{
List <BattleHex> neighboursToCkeck = NeighboursFinder.GetAdjacentHexes(initialHex, checkHex);
foreach (BattleHex hex in neighboursToCkeck)
{
hex.isNeighbourgHex = true;
hex.distanceText.SetDistanceFofFlyingUnit(initialHex);
hex.MakeAvailable();
}
}
IEvaluateHex checkHex = new IfItIsNewFlying();//refer to interface to access the behavior we need
//individualizes the search for positions for a flying regiments
public void GetAdjacentHexesExtended(BattleHex initialHex)
{
List <BattleHex> neighboursToCheck = NeighboursFinder.GetAdjacentHexes(initialHex, checkHex);
foreach (BattleHex hex in neighboursToCheck)
{
hex.isNeighboringHex = true;//defines the hex as adjacent to evaluted initial hex
hex.distanceText.SetDistanceForFlyingUnit(initialHex);
hex.MakeMeAvailable();
}
}
public bool EvaluateDistanceForGround(BattleHex initialHex)
{
//distance to reach initial hex and get out of it
int currentDistance = initialHex.distanceText.distanceFromStartingPoint
+ initialHex.distanceText.stepsToGo;
int stepsLimit = BattleController.currentAtacker.heroData.CurrentVelocity;//velocity of a hero
//default value of distanceFromStartingPoint is 20 to set the shortest path
return(distanceFromStartingPoint > currentDistance &&
stepsLimit >= currentDistance);//to evaluate if the velocity is enough to reach this hex
}
private void Start()
{
IdentifyHexes();
AvailablePosition hero = FindObjectOfType <AvailablePosition>();
IAdjacentFinder adjFinder = new PositionsForFlying();
BattleHex startigHex = hero.GetComponentInParent <BattleHex>();
int stepsLimit = BattleController.currentAtacker.velocity;
startigHex.DefineAsStartingHex();
hero.GetAvailablePositions(hero.GetComponentInParent <BattleHex>(), stepsLimit, adjFinder);
}
IEvaluateHex checkHex = new IfItIsNewFlying();// consulte la interfaz para acceder al comportamiento que necesitamos
// individualiza la búsqueda de puestos para un regimiento de vuelo
public void GetAdjacentHexesExtended(BattleHex initialHex)
{
List <BattleHex> neighboursToCheck = NeighboursFinder.GetAdjacentHexes(initialHex, checkHex);
foreach (BattleHex hex in neighboursToCheck)
{
hex.isNeighboringHex = true;// define el hexadecimal como adyacente al hexadecimal inicial evaluado
hex.distanceText.SetDistanceForFlyingUnit(initialHex);
hex.MakeMeAvailable();
}
}
