public override void SetShadowRotation(UnitBase unitToSet, IndividualTiles unitToCheckPos, IndividualTiles otherUnitToCheck)
{
if (unitToCheckPos.tileX == otherUnitToCheck.tileX)
{
//Arriba
if (unitToCheckPos.tileZ > otherUnitToCheck.tileZ)
{
unitToSet.sombraHoverUnit.transform.DORotate(new Vector3(0, 0, 0), timeDurationRotation);
}
//Abajo
else
{
unitToSet.sombraHoverUnit.transform.DORotate(new Vector3(0, 180, 0), timeDurationRotation);
}
}
//Izquierda o derecha
else
{
//Derecha
if (unitToCheckPos.tileX > otherUnitToCheck.tileX)
{
unitToSet.sombraHoverUnit.transform.DORotate(new Vector3(0, 90, 0), timeDurationRotation);
}
//Izquierda
else
{
unitToSet.sombraHoverUnit.transform.DORotate(new Vector3(0, -90, 0), timeDurationRotation);
}
}
}
public void ChangePosition(Mage mage2Move)
{
CreateAttackCommand(mage2Move);
IndividualTiles magePreviousTile = mage2Move.myCurrentTile;
mage2Move.MoveToTilePushed(myCurrentTile);
mage2Move.UpdateInformationAfterMovement(myCurrentTile);
this.MoveToTilePushed(magePreviousTile);
UpdateInformationAfterMovement(magePreviousTile);
mage2Move.hasMoved = true;
LM.UnitHasFinishedMovementAndRotation();
UIM.RefreshTokens();
if (mage2Move.isDecoyBomb2)
{
TM.GetSurroundingTiles(myCurrentTile, 1, true, false);
//Hago daño a las unidades adyacentes
for (int i = 0; i < TM.surroundingTiles.Count; ++i)
{
if (TM.surroundingTiles[i] != null)
{
TM.surroundingTiles[i].ColorAttack();
}
}
StartCoroutine("WaitToDamageSurroundingAfterChangePos");
}
HideAttackEffect(null);
}
//MEJORAR ESTO. PROBABLEMENTE NO NECESITO DOS FUNCIONES PARA ESTO Y ADEMÁS SE REPITE EN EL PLAYER UNIT
//Decidir rotación al moverse por los tiles.
public void CheckTileDirection(IndividualTiles tileToCheck)
{
//Arriba o abajo
if (tileToCheck.tileX == myCurrentTile.tileX)
{
//Arriba
if (tileToCheck.tileZ > myCurrentTile.tileZ)
{
unitModel.transform.DORotate(new Vector3(0, 0, 0), timeDurationRotation);
currentFacingDirection = FacingDirection.North;
}
//Abajo
else
{
unitModel.transform.DORotate(new Vector3(0, 180, 0), timeDurationRotation);
currentFacingDirection = FacingDirection.South;
}
}
//Izquierda o derecha
else
{
//Derecha
if (tileToCheck.tileX > myCurrentTile.tileX)
{
unitModel.transform.DORotate(new Vector3(0, 90, 0), timeDurationRotation);
currentFacingDirection = FacingDirection.East;
}
//Izquierda
else
{
unitModel.transform.DORotate(new Vector3(0, -90, 0), timeDurationRotation);
currentFacingDirection = FacingDirection.West;
}
}
}
//Esta función se encarga de mover a la unidad
public override void MoveUnit()
{
if (!isDead)
{
movementParticle.SetActive(true);
IndividualTiles tileToMove = GetTileToMove();
//Si recibe null es porque ambos tiles laterales están ocupados
if (tileToMove == null)
{
hasMoved = true;
}
else
{
MovementLogic(tileToMove);
}
movementParticle.SetActive(false);
tilesToShoot.Clear();
myCurrentEnemyState = enemyState.Searching;
}
else
{
myCurrentEnemyState = enemyState.Waiting;
}
}
//Override a la información que se actualiza al moverse
public override void UpdateInformationAfterMovement(IndividualTiles newTile)
{
//Aviso a los tiles alrededor
for (int i = 0; i < myCurrentTile.surroundingNeighbours.Count; i++)
{
myCurrentTile.surroundingNeighbours[i].unitOnTile = null;
myCurrentTile.surroundingNeighbours[i].WarnInmediateNeighbours();
}
//Actualizo normal
base.UpdateInformationAfterMovement(newTile);
//Aviso a los tiles de alrededor
for (int i = 0; i < myCurrentTile.surroundingNeighbours.Count; i++)
{
myCurrentTile.surroundingNeighbours[i].unitOnTile = GetComponent <UnitBase>();
myCurrentTile.surroundingNeighbours[i].WarnInmediateNeighbours();
}
exteriorTiles.Clear();
//Añado los tiles exteriores para el stomp.
for (int i = 0; i < LM.TM.GetSurroundingTiles(myCurrentTile, 2, true, true).Count; i++)
{
exteriorTiles.Add(LM.TM.GetSurroundingTiles(myCurrentTile, 2, true, true)[i]);
}
}
//Lógica actual del movimiento. Básicamente es el encargado de mover al modelo y setear las cosas
private void MovementLogic(IndividualTiles tileToMove)
{
//Muevo a la balista
transform.DOMove(currentTileVectorToMove, currentTimeForMovement);
//Actualizo las variables de los tiles
UpdateInformationAfterMovement(tileToMove);
//Aviso de que se ha movido
hasMoved = true;
}
//El LevelManager avisa a la unidad de que debe moverse.
//Esta función tiene que ser override para que el mago pueda instanciar decoys.
public override void MoveToTile(IndividualTiles tileToMove, List <IndividualTiles> pathReceived)
{
oldTile = myCurrentTile;
base.MoveToTile(tileToMove, pathReceived);
if (tileToMove != oldTile)
{
//Compruebo si tengo que instanciar decoy
CheckDecoy(oldTile);
}
}
public override void MoveToTilePushed(IndividualTiles newTile)
{
FeedbackTilesToAttack(false);
base.MoveToTilePushed(newTile);
if (isAttackPrepared)
{
FeedbackTilesToAttack(false);
tilesToShoot.Clear();
CheckCharactersInLine(true, myCurrentTile);
FeedbackTilesToAttack(true);
}
}
public void ChangePosition(PlayerUnit unitToMove)
{
CreateAttackCommand(unitToMove);
IndividualTiles valkyriePreviousTile = unitToMove.myCurrentTile;
unitToMove.MoveToTilePushed(myCurrentTile);
unitToMove.UpdateInformationAfterMovement(myCurrentTile);
this.MoveToTilePushed(valkyriePreviousTile);
UpdateInformationAfterMovement(valkyriePreviousTile);
hasMoved = true;
LM.UnitHasFinishedMovementAndRotation();
UIM.RefreshTokens();
}
public void InstantiateDecoy(IndividualTiles tileForDecoy)
{
GameObject decoyToInstantiate = Instantiate(mageDecoyRefAsset, transform.position, transform.rotation);
//Inicializo mageDecoy. SI VUELVE A SALTAR ERROR POR EL TILE DEL MAGEDECOY NO TOCAR ESTO, HABLAR EL PROBLEMA PARA QUE SOLUCIONARLO ENTRE LOS DOS Y QUE NO VUELVA A SALIR
decoyToInstantiate.GetComponent <MageDecoy>().myMage = this;
decoyToInstantiate.GetComponent <MageDecoy>().InitializeHealth();
decoyToInstantiate.GetComponent <MageDecoy>().myCurrentTile = tileForDecoy;
decoyToInstantiate.GetComponent <MageDecoy>().myCurrentTile.WarnInmediateNeighbours();
decoyToInstantiate.GetComponent <MageDecoy>().UpdateInformationAfterMovement(tileForDecoy);
//Pongo esta referencia para que el mage solo pueda cambiarse con sus decoys y para que pueda comprobar sus booleanos (para las habilidades)
myDecoys.Add(decoyToInstantiate);
}
public override void MoveToTilePushed(IndividualTiles newTile)
{
base.MoveToTilePushed(newTile);
if (isCharging)
{
for (int i = 0; i < beamTiles.Count; i++)
{
beamTiles[i].ColorDesAttack();
}
CheckTilesForBeam();
}
}
//Función que muetra la sombra del objetivo donde va a ser atraida
public void ShowGrabShadow(IndividualTiles _referenceTile, FacingDirection _referenceDirection)
{
if (currentUnitsAvailableToAttack.Count > 0)
{
playerWithShadowActivated = currentUnitsAvailableToAttack[0];
currentUnitsAvailableToAttack[0].sombraHoverUnit.SetActive(true);
List <IndividualTiles> tileUnitGrabbed = new List <IndividualTiles>();
tileUnitGrabbed = _referenceTile.GetTilesInFrontOfTheCharacter(_referenceDirection, 1);
Vector3 pointPosition = new Vector3(tileUnitGrabbed[0].transform.position.x, tileUnitGrabbed[0].transform.position.y + 0.5f, tileUnitGrabbed[0].transform.position.z);
currentUnitsAvailableToAttack[0].sombraHoverUnit.transform.position = pointPosition;
}
}
public MoveCommand(UnitBase.FacingDirection newRotation, UnitBase.FacingDirection previousRotation,
IndividualTiles previousTile, IndividualTiles tileToMove,
List <IndividualTiles> currentPath, UnitBase pj,
int _pjDamageBuffDebuff, int _pjTurnsDamageBuffDebuff, int _pjMovementBuffDebuff, int _pjTurnsMovementBuffDebuff)
{
this.newRotation = newRotation;
this.previousRotation = previousRotation;
this.previousTile = previousTile;
this.tileToMove = tileToMove;
this.currentPath = currentPath;
this.pj = pj;
pj_damageBuffDebuff = _pjDamageBuffDebuff;
pj_turnsDamageBuffDebuff = _pjTurnsDamageBuffDebuff;
pj_movementBuffDebuff = _pjMovementBuffDebuff;
pj_turnsMovementBuffDebuff = _pjTurnsMovementBuffDebuff;
}
public void CheckDecoy(IndividualTiles tileForDecoy)
{
if (myDecoys.Count < maxDecoys)
{
//Instancio el decoy
InstantiateDecoy(tileForDecoy);
}
else
{
//Destruyo al decoy anterior
GameObject decoyToDestroy = myDecoys[0];
Destroy(decoyToDestroy);
LM.charactersOnTheBoard.Remove(decoyToDestroy.GetComponent <PlayerUnit>());
myDecoys.Remove(decoyToDestroy);
//Instancio el decoy
InstantiateDecoy(tileForDecoy);
}
}
//Función genérica que comprueba la nueva dirección a la que debe mirar el pícaro tras saltar.
public void NewRotationAfterJump(IndividualTiles tileWithEnemyAttacked)
{
Debug.Log("1");
if (tileWithEnemyAttacked.tileX == myCurrentTile.tileX)
{
Debug.Log("2");
//Arriba
if (tileWithEnemyAttacked.tileZ < myCurrentTile.tileZ)
{
unitModel.transform.DORotate(new Vector3(0, 180, 0), timeDurationRotation);
currentFacingDirection = FacingDirection.South;
}
//Abajo
else
{
unitModel.transform.DORotate(new Vector3(0, 0, 0), timeDurationRotation);
currentFacingDirection = FacingDirection.North;
}
}
//Izquierda o derecha
else
{
//Derecha
if (tileWithEnemyAttacked.tileX < myCurrentTile.tileX)
{
Debug.Log("izq");
unitModel.transform.DORotate(new Vector3(0, -90, 0), timeDurationRotation);
currentFacingDirection = FacingDirection.West;
}
//Izquierda
else
{
Debug.Log("der");
unitModel.transform.DORotate(new Vector3(0, 90, 0), timeDurationRotation);
currentFacingDirection = FacingDirection.East;
}
}
}
//Función que se encarga de realizar el calculo e daño como tal. Simplemente es para no repetir el mismo código todo el rato
private void CalculteDamageLogic(UnitBase unitToDealDamage, IndividualTiles tileLineToCheck, FacingDirection directionForBackAttack)
{
//Si estoy en desventaja de altura hago menos daño
if (unitToDealDamage.myCurrentTile.height > tileLineToCheck.height)
{
damageWithMultipliersApplied -= penalizatorDamageLessHeight;
unitToDealDamage.downToUpDamageIcon.SetActive(true);
}
//Si estoy en ventaja de altura hago más daño
else if (unitToDealDamage.myCurrentTile.height < tileLineToCheck.height)
{
damageWithMultipliersApplied += bonusDamageMoreHeight;
unitToDealDamage.upToDownDamageIcon.SetActive(true);
}
//Si le ataco por la espalda hago más daño
if (unitToDealDamage.currentFacingDirection == directionForBackAttack)
{
//Ataque por la espalda
damageWithMultipliersApplied += bonusDamageBackAttack;
unitToDealDamage.backStabIcon.SetActive(true);
}
}
public override void UndoMove(MoveCommand _moveCommand, IndividualTiles tileToMoveBack, FacingDirection rotationToTurnBack, bool shouldResetMovement)
{
base.UndoMove(_moveCommand, tileToMoveBack, rotationToTurnBack, shouldResetMovement);
if (shouldResetMovement)
{
if (myDecoys.Count > 0)
{
LM.charactersOnTheBoard.Remove(myDecoys[myDecoys.Count - 1].GetComponent <PlayerUnit>());
Destroy(myDecoys[myDecoys.Count - 1]);
myDecoys.RemoveAt(myDecoys.Count - 1);
}
}
//Estas líneas las añado para comprobar si hay samurai y si hay que actualizar el honor
Samurai samuraiUpgraded = FindObjectOfType <Samurai>();
if (samuraiUpgraded != null)
{
samuraiUpgraded.RefreshHonorOnPortrait();
}
UIM.CheckActionsAvaliable();
}
//El bool y el tile es solo para la balista pero comparte la funcion con el charger y tiene que tenerlo
public override void CheckCharactersInLine(bool _NoUsarEsteBooleano, IndividualTiles _noUsarEsteTile)
{
if (!isDead)
{
if (myCurrentTile == null)
{
InitializeUnitOnTile();
}
tilesBehindObjective.Clear();
currentUnitsAvailableToAttack.Clear();
//Busco objetivos en los tiles de arriba
//Seteo número de tiles a comprobar en función del rango y del número de tiles disponibles
if (rangeOfAction <= myCurrentTile.tilesInLineUp.Count)
{
rangeVSTilesInLineLimitant = rangeOfAction;
}
else
{
rangeVSTilesInLineLimitant = myCurrentTile.tilesInLineUp.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
//Paro de comprobar si hay un obstáculo, un tile vacío o una unidad enemiga.
if (myCurrentTile.tilesInLineUp[i].isObstacle ||
myCurrentTile.tilesInLineUp[i].isEmpty ||
(myCurrentTile.tilesInLineUp[i].unitOnTile != null && myCurrentTile.tilesInLineUp[i].unitOnTile.GetComponent <EnemyUnit>()) ||
(i > 0 && Mathf.Abs(myCurrentTile.tilesInLineUp[i].height - myCurrentTile.tilesInLineUp[i - 1].height) > maxHeightDifferenceToMove))
{
break;
}
//Si por el contrario encuentro una unidad del jugador a mi altura, la añado a la lista de objetivos (en el resto de direcciones antes compruebo si es la unidad más lejana)
else if (myCurrentTile.tilesInLineUp[i].unitOnTile != null && myCurrentTile.tilesInLineUp[i].unitOnTile.GetComponent <PlayerUnit>())
{
//Almaceno la primera unidad en la lista de posibles unidades.
currentUnitsAvailableToAttack.Add(myCurrentTile.tilesInLineUp[i].unitOnTile);
furthestAvailableUnitDistance = i;
if (i + 1 < myCurrentTile.tilesInLineUp.Count)
{
tilesBehindObjective.Add(myCurrentTile.tilesInLineUp[i + 1]);
}
temporalFacingDirectionWhileHover = FacingDirection.North;
//Break ya que sólo me interesa la primera unidad de la linea
break;
}
}
//Tiles derecha
if (rangeOfAction <= myCurrentTile.tilesInLineRight.Count)
{
rangeVSTilesInLineLimitant = rangeOfAction;
}
else
{
rangeVSTilesInLineLimitant = myCurrentTile.tilesInLineRight.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
if (myCurrentTile.tilesInLineRight[i].isObstacle ||
myCurrentTile.tilesInLineRight[i].isEmpty ||
(myCurrentTile.tilesInLineRight[i].unitOnTile != null && myCurrentTile.tilesInLineRight[i].unitOnTile.GetComponent <EnemyUnit>()) ||
(i > 0 && Mathf.Abs(myCurrentTile.tilesInLineRight[i].height - myCurrentTile.tilesInLineRight[i - 1].height) > maxHeightDifferenceToMove))
{
break;
}
else if (myCurrentTile.tilesInLineRight[i].unitOnTile != null && myCurrentTile.tilesInLineRight[i].unitOnTile.GetComponent <PlayerUnit>() && Mathf.Abs(myCurrentTile.tilesInLineRight[i].height - myCurrentTile.height) <= maxHeightDifferenceToAttack)
{
//Compruebo que unidad está más lejos
if (currentUnitsAvailableToAttack.Count == 0 || furthestAvailableUnitDistance < i)
{
currentUnitsAvailableToAttack.Clear();
currentUnitsAvailableToAttack.Add(myCurrentTile.tilesInLineRight[i].unitOnTile);
furthestAvailableUnitDistance = i;
}
//Si tienen la misma distancia almaceno a las dos
else if (furthestAvailableUnitDistance == i)
{
currentUnitsAvailableToAttack.Add(myCurrentTile.tilesInLineRight[i].unitOnTile);
}
if (i + 1 < myCurrentTile.tilesInLineRight.Count)
{
tilesBehindObjective.Add(myCurrentTile.tilesInLineRight[i + 1]);
}
temporalFacingDirectionWhileHover = FacingDirection.East;
//Break ya que sólo me interesa la primera unidad de la linea
break;
}
}
//Tiles abajo
if (rangeOfAction <= myCurrentTile.tilesInLineDown.Count)
{
rangeVSTilesInLineLimitant = rangeOfAction;
}
else
{
rangeVSTilesInLineLimitant = myCurrentTile.tilesInLineDown.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
if (myCurrentTile.tilesInLineDown[i].isObstacle ||
myCurrentTile.tilesInLineDown[i].isEmpty ||
(myCurrentTile.tilesInLineDown[i].unitOnTile != null && myCurrentTile.tilesInLineDown[i].unitOnTile.GetComponent <EnemyUnit>()) ||
(i > 0 && Mathf.Abs(myCurrentTile.tilesInLineDown[i].height - myCurrentTile.tilesInLineDown[i - 1].height) > maxHeightDifferenceToMove))
{
break;
}
else if (myCurrentTile.tilesInLineDown[i].unitOnTile != null && myCurrentTile.tilesInLineDown[i].unitOnTile.GetComponent <PlayerUnit>() && Mathf.Abs(myCurrentTile.tilesInLineDown[i].height - myCurrentTile.height) <= maxHeightDifferenceToAttack)
{
//Compruebo que unidad está más lejos
if (currentUnitsAvailableToAttack.Count == 0 || furthestAvailableUnitDistance < i)
{
currentUnitsAvailableToAttack.Clear();
currentUnitsAvailableToAttack.Add(myCurrentTile.tilesInLineDown[i].unitOnTile);
furthestAvailableUnitDistance = i;
}
//Si tienen la misma distancia almaceno a las dos
else if (furthestAvailableUnitDistance == i)
{
currentUnitsAvailableToAttack.Add(myCurrentTile.tilesInLineDown[i].unitOnTile);
}
if (i + 1 < myCurrentTile.tilesInLineDown.Count)
{
tilesBehindObjective.Add(myCurrentTile.tilesInLineDown[i + 1]);
}
temporalFacingDirectionWhileHover = FacingDirection.South;
//Break ya que sólo me interesa la primera unidad de la linea
break;
}
}
//Tiles abajo
if (rangeOfAction <= myCurrentTile.tilesInLineLeft.Count)
{
rangeVSTilesInLineLimitant = rangeOfAction;
}
else
{
rangeVSTilesInLineLimitant = myCurrentTile.tilesInLineLeft.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
if (myCurrentTile.tilesInLineLeft[i].isObstacle ||
myCurrentTile.tilesInLineLeft[i].isEmpty ||
(myCurrentTile.tilesInLineLeft[i].unitOnTile != null && myCurrentTile.tilesInLineLeft[i].unitOnTile.GetComponent <EnemyUnit>()) ||
(i > 0 && Mathf.Abs(myCurrentTile.tilesInLineLeft[i].height - myCurrentTile.tilesInLineLeft[i - 1].height) > maxHeightDifferenceToMove))
{
break;
}
else if (myCurrentTile.tilesInLineLeft[i].unitOnTile != null && myCurrentTile.tilesInLineLeft[i].unitOnTile.GetComponent <PlayerUnit>() && Mathf.Abs(myCurrentTile.tilesInLineLeft[i].height - myCurrentTile.height) <= maxHeightDifferenceToAttack)
{
//Compruebo que unidad está más lejos
if (currentUnitsAvailableToAttack.Count == 0 || furthestAvailableUnitDistance < i)
{
currentUnitsAvailableToAttack.Clear();
currentUnitsAvailableToAttack.Add(myCurrentTile.tilesInLineLeft[i].unitOnTile);
furthestAvailableUnitDistance = i;
}
//Si tienen la misma distancia almaceno a las dos
else if (furthestAvailableUnitDistance == i)
{
currentUnitsAvailableToAttack.Add(myCurrentTile.tilesInLineLeft[i].unitOnTile);
}
if (i + 1 < myCurrentTile.tilesInLineLeft.Count)
{
tilesBehindObjective.Add(myCurrentTile.tilesInLineLeft[i + 1]);
}
temporalFacingDirectionWhileHover = FacingDirection.West;
//Break ya que sólo me interesa la primera unidad de la linea
break;
}
}
//Si coincide que hay varios personajes a la misma distancia, me quedo con el que tiene menos vida
if (currentUnitsAvailableToAttack.Count > 1)
{
//Ordeno la lista de posibles objetivos de menor a mayor vida actual
currentUnitsAvailableToAttack.Sort(delegate(UnitBase a, UnitBase b)
{
return((a.currentHealth).CompareTo(b.currentHealth));
});
}
}
}
public bool isAlone; //ESTO EN REALIDAD IRIA EN EL MOVIMIENTO, COMPROBAR QUE FUNCIONA (HACER LO MISMO CON EL CABALLERO Y SI SE PONE A PROTEGER A LOS LADOS
#endregion
public AttackCommand(UnitBase.FacingDirection _enemypreviousRotation, UnitBase.FacingDirection _pjpreviousRotation,
IndividualTiles _enemyPreviousTile, IndividualTiles _pjPreviousTile,
int _enemyPreviousHealth, int _pjPreviousHealth,
UnitBase _pj, UnitBase _enemy,
int _pjArmor, int _objArmor,
bool _pjIsStunned, bool _objIsStunned,
bool _pjIsMarked, bool _objIsMarked, int _pjnumberOfMarks, int _objnumberOfMarks,
bool _pjHasMoved, bool _objHasMoved, bool _pjHasAttacked, bool _objHasAttacked,
int _pjDamageBuffDebuff, int _objDamageBuffDebuff, int _pjMovementBuffDebuff, int _objMovementBuffDebuff,
int _pjTurnsDamageBuffDebuff, int _objTurnsDamageBuffDebuff, int _pjTurnsMovementBuffDebuff, int _objTurnsMovementBuffDebuff)
{
objPreviousRotation = _enemypreviousRotation;
pjPreviousRotation = _pjpreviousRotation;
objPreviousTile = _enemyPreviousTile;
pjPreviousTile = _pjPreviousTile;
objPreviousHealth = _enemyPreviousHealth;
pjPreviousHealth = _pjPreviousHealth;
pj = _pj;
obj = _enemy;
pjArmor = _pjArmor;
objArmor = _objArmor;
pjIsStunned = _pjIsStunned;
objIsStunned = _objIsStunned;
pjIsMarked = _pjIsMarked;
objIsMarked = _objIsMarked;
pjnumberOfMarks = _pjnumberOfMarks;
objnumberOfMarks = _objnumberOfMarks;
pjHasMoved = _pjHasMoved;
objHasMoved = _objHasMoved;
pjHasAttacked = _pjHasAttacked;
objHasAttacked = _objHasAttacked;
pj_damageBuffDebuff = _pjDamageBuffDebuff;
pj_turnsDamageBuffDebuff = _pjTurnsDamageBuffDebuff;
obj_damageBuffDebuff = _objDamageBuffDebuff;
obj_turnsDamageBuffDebuff = _objTurnsDamageBuffDebuff;
pj_movementBuffDebuff = _pjMovementBuffDebuff;
pj_turnsMovementBuffDebuff = _pjTurnsMovementBuffDebuff;
obj_movementBuffDebuff = _objMovementBuffDebuff;
obj_turnsMovementBuffDebuff = _objTurnsMovementBuffDebuff;
#region Specific
if (pj.GetComponent <Rogue>())
{
Rogue refPj = pj.GetComponent <Rogue>();
unitsAttacked.Clear();
for (int i = 0; i < refPj.unitsAttacked.Count; i++)
{
unitsAttacked.Add(refPj.unitsAttacked[i]);
}
ninjaExtraTurns = refPj.extraTurnCount;
ninjaExtraJumps = refPj.unitsCanJump;
smokeTiles.Clear();
for (int i = 0; i < refPj.realBombsSpawned.Count; i++)
{
smokeTiles.Add(refPj.realBombsSpawned[i]);
}
ninjaBonusDamage = refPj.baseDamage;
}
else if (pj.GetComponent <Mage>())
{
Mage refPj = pj.GetComponent <Mage>();
if (refPj.myDecoys.Count > 0)
{
oldDecoy = refPj.myDecoys[0];
}
//Esto lo tenia apuntado hace tiempo pero en principio funciona bien
//newDecoy; //Esto da problemas seguro, mirar quizas en el execute que quite el actual en vez de guardarlo antes.
//hasMovedWithDecoy = refPj.hasMoved; //Quizás es poner simplemente si ha movido
}
else if (pj.GetComponent <Samurai>())
{
Samurai refPj = pj.GetComponent <Samurai>();
unitToParry = refPj.unitToParry;
honor = pj.GetComponent <Samurai>().currentHonor;
}
else if (pj.GetComponent <Druid>())
{
Druid refPj = pj.GetComponent <Druid>();
for (int i = 0; i < refPj.realTilesSpawned.Count; i++)
{
_realTilesInstantiated.Add(refPj.realTilesSpawned[i]);
}
for (int i = 0; i < refPj.damageTilesReplaced.Count; i++)
{
_damageTilesReplaced.Add(refPj.damageTilesReplaced[i]);
}
_healedLife = refPj.healedLife;
_buffHeal = refPj.buffHeal;
//damageTileReplaced =;
//El druida parece que afecta a movementUDs ¿Esto esta bien? ¿o debería ser un bufo?
}
//Este no es else if.
if (obj.GetComponent <Berserker>())
{
Berserker refPj = obj.GetComponent <Berserker>();
isInRage = refPj.isInRage;
rageTurnsLeft = refPj.turnsLeftToRageOff;
}
#endregion
}
public void ShowPushResult()
{
if (pathToObjective.Count > 0)
{
pathToObjectiveTileReference = pathToObjective[pathToObjective.Count - 1];
}
else
{
pathToObjectiveTileReference = myCurrentTile;
}
currentUnitsAvailableToAttack[0].sombraHoverUnit.SetActive(true);
//COMPROBAR
SetShadowRotation(currentUnitsAvailableToAttack[0], currentUnitsAvailableToAttack[0].myCurrentTile, myCurrentTile);
if (temporalFacingDirectionWhileHover == FacingDirection.North)
{
if (CalculatePushLogic(1, pathToObjectiveTileReference.tilesInLineUp, damageMadeByPush, damageMadeByFall) == currentUnitsAvailableToAttack[0].myCurrentTile)
{
currentUnitsAvailableToAttack[0].sombraHoverUnit.SetActive(false);
}
else
{
tileWhereObjectiveShadowWillEnd = CalculatePushLogic(1, pathToObjectiveTileReference.tilesInLineUp, damageMadeByPush, damageMadeByFall);
currentUnitsAvailableToAttack[0].sombraHoverUnit.transform.position = tileWhereObjectiveShadowWillEnd.transform.position;
tileWhereObjectiveShadowWillEnd.ColorAttack();
}
}
else if (temporalFacingDirectionWhileHover == FacingDirection.South)
{
if (CalculatePushLogic(1, pathToObjectiveTileReference.tilesInLineDown, damageMadeByPush, damageMadeByFall) == currentUnitsAvailableToAttack[0].myCurrentTile)
{
currentUnitsAvailableToAttack[0].sombraHoverUnit.SetActive(false);
}
else
{
tileWhereObjectiveShadowWillEnd = CalculatePushLogic(1, pathToObjectiveTileReference.tilesInLineDown, damageMadeByPush, damageMadeByFall);
currentUnitsAvailableToAttack[0].sombraHoverUnit.transform.position = tileWhereObjectiveShadowWillEnd.transform.position;
tileWhereObjectiveShadowWillEnd.ColorAttack();
}
}
else if (temporalFacingDirectionWhileHover == FacingDirection.East)
{
if (CalculatePushLogic(1, pathToObjectiveTileReference.tilesInLineRight, damageMadeByPush, damageMadeByFall) == currentUnitsAvailableToAttack[0].myCurrentTile)
{
currentUnitsAvailableToAttack[0].sombraHoverUnit.SetActive(false);
}
else
{
tileWhereObjectiveShadowWillEnd = CalculatePushLogic(1, pathToObjectiveTileReference.tilesInLineRight, damageMadeByPush, damageMadeByFall);
currentUnitsAvailableToAttack[0].sombraHoverUnit.transform.position = tileWhereObjectiveShadowWillEnd.transform.position;
tileWhereObjectiveShadowWillEnd.ColorAttack();
}
}
else if (temporalFacingDirectionWhileHover == FacingDirection.West)
{
if (CalculatePushLogic(1, pathToObjectiveTileReference.tilesInLineLeft, damageMadeByPush, damageMadeByFall) == currentUnitsAvailableToAttack[0].myCurrentTile)
{
currentUnitsAvailableToAttack[0].sombraHoverUnit.SetActive(false);
}
else
{
tileWhereObjectiveShadowWillEnd = CalculatePushLogic(1, pathToObjectiveTileReference.tilesInLineLeft, damageMadeByPush, damageMadeByFall);
currentUnitsAvailableToAttack[0].sombraHoverUnit.transform.position = tileWhereObjectiveShadowWillEnd.transform.position;
tileWhereObjectiveShadowWillEnd.ColorAttack();
}
}
}
public override void Attack(UnitBase unitToAttack)
{
CheckIfUnitHasMarks(unitToAttack);
List <IndividualTiles> tilesInFront = new List <IndividualTiles>();
tilesInFront = myCurrentTile.GetTilesInFrontOfTheCharacter(currentFacingDirection, 3);
//Particulas
for (int i = 0; i < tilesInFront.Count; i++)
{
if (tilesInFront[i].unitOnTile != null && tilesInFront[i].unitOnTile == unitToAttack)
{
if (i == 1)
{
attack1.SetActive(true);
}
else if (i == 2)
{
attack2.SetActive(true);
}
else if (i == 3)
{
attack3.SetActive(true);
}
}
}
if (canChooseEnemy)
{
//Animación de ataque
myAnimator.SetTrigger("Attack");
//UNDO
CreateAttackCommand(unitToAttack);
//Quito el color del tile
myCurrentTile.ColorDeselect();
for (int i = 0; i < currentUnitsAvailableToAttack.Count; i++)
{
if (currentUnitsAvailableToAttack[i] == unitToAttack)
{
break;
}
else if (currentUnitsAvailableToAttack[i] != null)
{
//UNDO
CreateAttackCommand(currentUnitsAvailableToAttack[i]);
DoDamage(currentUnitsAvailableToAttack[i]);
}
}
//Hago daño antes de que se produzca el intercambio
DoDamage(unitToAttack);
HideAttackEffect(unitToAttack);
//Intercambio
previousTile = unitToAttack.myCurrentTile;
currentTileVectorToMove = unitToAttack.myCurrentTile.transform.position;
transform.DOMove(currentTileVectorToMove, 1);
currentTileVectorToMove = myCurrentTile.transform.position;
unitToAttack.transform.DOMove(currentTileVectorToMove, 1);
unitToAttack.UpdateInformationAfterMovement(myCurrentTile);
UpdateInformationAfterMovement(previousTile);
unitToAttack.UpdateInformationAfterMovement(unitToAttack.myCurrentTile);
//Hay que cambiarlo
SoundManager.Instance.PlaySound(AppSounds.ROGUE_ATTACK);
//La base tiene que ir al final para que el bool de hasAttacked se active después del efecto.
base.Attack(unitToAttack);
}
else if (armorMode)
{
//Animación de ataque
myAnimator.SetTrigger("Attack");
//UNDO
CreateAttackCommand(unitToAttack);
//Quito el color del tile
myCurrentTile.ColorDeselect();
if (unitToAttack.GetComponent <PlayerUnit>())
{
if (armorMode2)
{
currentArmor += numberOfArmorAdded;
if (currentArmor > currentHealth)
{
currentArmor = currentHealth;
}
}
unitToAttack.currentArmor += numberOfArmorAdded;
if (unitToAttack.currentArmor > unitToAttack.currentHealth)
{
unitToAttack.currentArmor = unitToAttack.currentHealth;
}
unitToAttack.RefreshHealth(false);
RefreshHealth(false);
}
else
{
//Hago daño
DoDamage(unitToAttack);
}
//Intercambio
previousTile = unitToAttack.myCurrentTile;
currentTileVectorToMove = unitToAttack.myCurrentTile.transform.position;
transform.DOMove(currentTileVectorToMove, 1);
currentTileVectorToMove = myCurrentTile.transform.position;
unitToAttack.transform.DOMove(currentTileVectorToMove, 1);
unitToAttack.UpdateInformationAfterMovement(myCurrentTile);
UpdateInformationAfterMovement(previousTile);
unitToAttack.UpdateInformationAfterMovement(unitToAttack.myCurrentTile);
HideAttackEffect(unitToAttack);
UIM.RefreshHealth();
//Hay que cambiarlo
SoundManager.Instance.PlaySound(AppSounds.ROGUE_ATTACK);
//La base tiene que ir al final para que el bool de hasAttacked se active después del efecto.
base.Attack(unitToAttack);
}
else
{
//UNDO
CreateAttackCommand(unitToAttack);
//Animación de ataque
myAnimator.SetTrigger("Attack");
//Quito el color del tile
myCurrentTile.ColorDeselect();
if (unitToAttack.GetComponent <PlayerUnit>())
{
}
else
{
//Hago daño
DoDamage(unitToAttack);
}
HideAttackEffect(unitToAttack);
//Intercambio
previousTile = unitToAttack.myCurrentTile;
currentTileVectorToMove = unitToAttack.myCurrentTile.transform.position;
transform.DOMove(currentTileVectorToMove, 1);
currentTileVectorToMove = myCurrentTile.transform.position;
unitToAttack.transform.DOMove(currentTileVectorToMove, 1);
unitToAttack.UpdateInformationAfterMovement(myCurrentTile);
UpdateInformationAfterMovement(previousTile);
unitToAttack.UpdateInformationAfterMovement(unitToAttack.myCurrentTile);
//Hay que cambiarlo
SoundManager.Instance.PlaySound(AppSounds.ROGUE_ATTACK);
//La base tiene que ir al final para que el bool de hasAttacked se active después del efecto.
base.Attack(unitToAttack);
}
hasAttacked = true;
}
public override void MoveToTilePushed(IndividualTiles newTile)
{
Debug.Log("Can't be pushed");
}
public override void CheckTilesInRange(IndividualTiles _referenceTile, FacingDirection _referenceDirection)
{
currentTilesInRangeForAttack.Clear();
Debug.Log(_referenceTile);
Debug.Log(_referenceDirection);
if (_referenceDirection == FacingDirection.North)
{
if (attackRange <= _referenceTile.tilesInLineUp.Count)
{
rangeVSTilesInLineLimitant = attackRange;
}
else
{
rangeVSTilesInLineLimitant = _referenceTile.tilesInLineUp.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
if (!_referenceTile.tilesInLineUp[i].isEmpty && !_referenceTile.tilesInLineUp[i].isObstacle && Mathf.Abs(_referenceTile.tilesInLineUp[i].height - _referenceTile.height) <= maxHeightDifferenceToAttack)
{
currentTilesInRangeForAttack.Add(_referenceTile.tilesInLineUp[i]);
for (int j = 0; j < _referenceTile.tilesInLineUp[i].GetLateralTilesBasedOnDirection(_referenceDirection, 1).Count; j++)
{
currentTilesInRangeForAttack.Add(_referenceTile.tilesInLineUp[i].GetLateralTilesBasedOnDirection(_referenceDirection, 1)[j]);
}
}
if (_referenceTile.tilesInLineUp[i].unitOnTile != null && Mathf.Abs(_referenceTile.tilesInLineUp[i].height - _referenceTile.height) <= maxHeightDifferenceToAttack)
{
break;
}
}
}
if (_referenceDirection == FacingDirection.South)
{
if (attackRange <= _referenceTile.tilesInLineDown.Count)
{
rangeVSTilesInLineLimitant = attackRange;
}
else
{
rangeVSTilesInLineLimitant = _referenceTile.tilesInLineDown.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
if (!_referenceTile.tilesInLineDown[i].isEmpty && !_referenceTile.tilesInLineDown[i].isObstacle && Mathf.Abs(_referenceTile.tilesInLineDown[i].height - _referenceTile.height) <= maxHeightDifferenceToAttack)
{
currentTilesInRangeForAttack.Add(_referenceTile.tilesInLineDown[i]);
for (int j = 0; j < _referenceTile.tilesInLineDown[i].GetLateralTilesBasedOnDirection(_referenceDirection, 1).Count; j++)
{
currentTilesInRangeForAttack.Add(_referenceTile.tilesInLineDown[i].GetLateralTilesBasedOnDirection(_referenceDirection, 1)[j]);
}
}
if (_referenceTile.tilesInLineDown[i].unitOnTile != null && Mathf.Abs(_referenceTile.tilesInLineDown[i].height - _referenceTile.height) <= maxHeightDifferenceToAttack)
{
break;
}
}
}
if (_referenceDirection == FacingDirection.East)
{
if (attackRange <= _referenceTile.tilesInLineRight.Count)
{
rangeVSTilesInLineLimitant = attackRange;
}
else
{
rangeVSTilesInLineLimitant = _referenceTile.tilesInLineRight.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
if (!_referenceTile.tilesInLineRight[i].isEmpty && !_referenceTile.tilesInLineRight[i].isObstacle && Mathf.Abs(_referenceTile.tilesInLineRight[i].height - _referenceTile.height) <= maxHeightDifferenceToAttack)
{
currentTilesInRangeForAttack.Add(_referenceTile.tilesInLineRight[i]);
for (int j = 0; j < _referenceTile.tilesInLineRight[i].GetLateralTilesBasedOnDirection(_referenceDirection, 1).Count; j++)
{
currentTilesInRangeForAttack.Add(_referenceTile.tilesInLineRight[i].GetLateralTilesBasedOnDirection(_referenceDirection, 1)[j]);
Debug.Log("Tile lateral " + _referenceTile.tilesInLineRight[i].GetLateralTilesBasedOnDirection(_referenceDirection, 1)[j].name);
}
}
if (_referenceTile.tilesInLineRight[i].unitOnTile != null && Mathf.Abs(_referenceTile.tilesInLineRight[i].height - _referenceTile.height) <= maxHeightDifferenceToAttack)
{
break;
}
}
}
if (_referenceDirection == FacingDirection.West)
{
if (attackRange <= _referenceTile.tilesInLineLeft.Count)
{
rangeVSTilesInLineLimitant = attackRange;
}
else
{
rangeVSTilesInLineLimitant = _referenceTile.tilesInLineLeft.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
if (!_referenceTile.tilesInLineLeft[i].isEmpty && !_referenceTile.tilesInLineLeft[i].isObstacle && Mathf.Abs(_referenceTile.tilesInLineLeft[i].height - _referenceTile.height) <= maxHeightDifferenceToAttack)
{
currentTilesInRangeForAttack.Add(_referenceTile.tilesInLineLeft[i]);
for (int j = 0; j < _referenceTile.tilesInLineLeft[i].GetLateralTilesBasedOnDirection(_referenceDirection, 1).Count; j++)
{
currentTilesInRangeForAttack.Add(_referenceTile.tilesInLineLeft[i].GetLateralTilesBasedOnDirection(_referenceDirection, 1)[j]);
}
}
if (_referenceTile.tilesInLineLeft[i].unitOnTile != null && Mathf.Abs(_referenceTile.tilesInLineLeft[i].height - _referenceTile.height) <= maxHeightDifferenceToAttack)
{
break;
}
}
}
for (int i = 0; i < currentTilesInRangeForAttack.Count; i++)
{
currentTilesInRangeForAttack[i].ColorBorderRed();
}
}
//Pongo público para acceder a la hora de hacer hover
//ESTA FUNCIÓN NO PUEDE CAMBIAR EL CURRENTSTATE DEL ENEMIGO, se llama fuera del turno enemigo.
//El referenceTile sirve porque está función la uso también cuando se va a mover para comprobar si va a atacar después de moverse o no.
public override void CheckCharactersInLine(bool _shouldWarnTilesForBalistaColoring, IndividualTiles _referenceTile)
{
if (!isDead)
{
if (myCurrentTile == null)
{
InitializeUnitOnTile();
if (_referenceTile == null)
{
_referenceTile = myCurrentTile;
}
}
currentUnitsAvailableToAttack.Clear();
tilesToShoot.Clear();
if (currentFacingDirection == FacingDirection.North)
{
if (rangeOfAction <= _referenceTile.tilesInLineUp.Count)
{
rangeVSTilesInLineLimitant = rangeOfAction;
}
else
{
rangeVSTilesInLineLimitant = _referenceTile.tilesInLineUp.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
//Si hay un obstáculo paro de comprobar
if (_referenceTile.tilesInLineUp[i].isObstacle || _referenceTile.tilesInLineUp[i] == null)
{
break;
}
//Si el tile no es un obstáculo lo añado a la lista de tiles a los que disparar y compruebo si tiene una unidad.
else if (!_referenceTile.tilesInLineUp[i].isObstacle)
{
//Si la diferencia de altura supera la que puede tener el personaje paro de buscar
if (i > 0 && Mathf.Abs(_referenceTile.tilesInLineUp[i].height - _referenceTile.tilesInLineUp[i - 1].height) > maxHeightDifferenceToAttack)
{
break;
}
tilesToShoot.Add(_referenceTile.tilesInLineUp[i]);
if (_referenceTile.tilesInLineUp[i].unitOnTile != null && _referenceTile.tilesInLineUp[i].unitOnTile.GetComponent <PlayerUnit>())
{
//Almaceno la primera unidad en la lista de posibles unidades.
currentUnitsAvailableToAttack.Add(_referenceTile.tilesInLineUp[i].unitOnTile);
//Si el personaje es un caballero mi disparo acaba aqui
if (_referenceTile.tilesInLineUp[i].unitOnTile.GetComponent <Knight>())
{
if (_referenceTile.tilesInLineUp[i].unitOnTile.GetComponent <Knight>().currentFacingDirection == FacingDirection.South)
{
break;
}
}
}
}
}
}
if (currentFacingDirection == FacingDirection.East)
{
if (rangeOfAction <= _referenceTile.tilesInLineRight.Count)
{
rangeVSTilesInLineLimitant = rangeOfAction;
}
else
{
rangeVSTilesInLineLimitant = _referenceTile.tilesInLineRight.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
//Tanto la balista cómo el charger detiene su comprobación si hay un obstáculo
if (_referenceTile.tilesInLineRight[i].isObstacle || _referenceTile.tilesInLineRight[i] == null)
{
break;
}
else if (!_referenceTile.tilesInLineRight[i].isObstacle)
{
if (i > 0 && Mathf.Abs(_referenceTile.tilesInLineRight[i].height - _referenceTile.tilesInLineRight[i - 1].height) > maxHeightDifferenceToAttack)
{
break;
}
tilesToShoot.Add(_referenceTile.tilesInLineRight[i]);
if (_referenceTile.tilesInLineRight[i].unitOnTile != null && _referenceTile.tilesInLineRight[i].unitOnTile.GetComponent <PlayerUnit>())
{
//Almaceno la primera unidad en la lista de posibles unidades.
currentUnitsAvailableToAttack.Add(_referenceTile.tilesInLineRight[i].unitOnTile);
//Si el personaje es un caballero mi disparo acaba aqui
if (_referenceTile.tilesInLineRight[i].unitOnTile.GetComponent <Knight>())
{
if (_referenceTile.tilesInLineRight[i].unitOnTile.GetComponent <Knight>().currentFacingDirection == FacingDirection.West)
{
break;
}
}
}
}
}
}
if (currentFacingDirection == FacingDirection.South)
{
if (rangeOfAction <= _referenceTile.tilesInLineDown.Count)
{
rangeVSTilesInLineLimitant = rangeOfAction;
}
else
{
rangeVSTilesInLineLimitant = _referenceTile.tilesInLineDown.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
if (_referenceTile.tilesInLineDown[i].isObstacle || _referenceTile.tilesInLineDown[i] == null)
{
break;
}
else if (!_referenceTile.tilesInLineDown[i].isObstacle)
{
if (i > 0 && Mathf.Abs(_referenceTile.tilesInLineDown[i].height - _referenceTile.tilesInLineDown[i - 1].height) > maxHeightDifferenceToAttack)
{
break;
}
tilesToShoot.Add(_referenceTile.tilesInLineDown[i]);
if (_referenceTile.tilesInLineDown[i].unitOnTile != null && _referenceTile.tilesInLineDown[i].unitOnTile.GetComponent <PlayerUnit>())
{
//Almaceno la primera unidad en la lista de posibles unidades.
currentUnitsAvailableToAttack.Add(_referenceTile.tilesInLineDown[i].unitOnTile);
//Si el personaje es un caballero mi disparo acaba aqui
if (_referenceTile.tilesInLineDown[i].unitOnTile.GetComponent <Knight>())
{
if (_referenceTile.tilesInLineDown[i].unitOnTile.GetComponent <Knight>().currentFacingDirection == FacingDirection.North)
{
break;
}
}
}
}
}
}
if (currentFacingDirection == FacingDirection.West)
{
if (rangeOfAction <= _referenceTile.tilesInLineLeft.Count)
{
rangeVSTilesInLineLimitant = rangeOfAction;
}
else
{
rangeVSTilesInLineLimitant = _referenceTile.tilesInLineLeft.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
//Tanto la balista cómo el charger detiene su comprobación si hay un obstáculo
if (_referenceTile.tilesInLineLeft[i].isObstacle || _referenceTile.tilesInLineLeft[i] == null)
{
break;
}
else if (!_referenceTile.tilesInLineLeft[i].isObstacle)
{
if (i > 0 && Mathf.Abs(_referenceTile.tilesInLineLeft[i].height - _referenceTile.tilesInLineLeft[i - 1].height) > maxHeightDifferenceToAttack)
{
break;
}
tilesToShoot.Add(_referenceTile.tilesInLineLeft[i]);
if (_referenceTile.tilesInLineLeft[i].unitOnTile != null && _referenceTile.tilesInLineLeft[i].unitOnTile.GetComponent <PlayerUnit>())
{
//Almaceno la primera unidad en la lista de posibles unidades.
currentUnitsAvailableToAttack.Add(_referenceTile.tilesInLineLeft[i].unitOnTile);
//Si el personaje es un caballero mi disparo acaba aqui
if (_referenceTile.tilesInLineLeft[i].unitOnTile.GetComponent <Knight>())
{
if (_referenceTile.tilesInLineLeft[i].unitOnTile.GetComponent <Knight>().currentFacingDirection == FacingDirection.East)
{
break;
}
}
}
}
}
}
if (_shouldWarnTilesForBalistaColoring)
{
//Aviso a los tiles de que tienen que buscar al caballero.
WarnOrResetTilesToShoot(true);
}
}
}
public void CheckUnitToAttack(IndividualTiles _referenceTile, FacingDirection _referenceFacingDirection)
{
currentUnitsAvailableToAttack.Clear();
previousTileHeight = 0;
if (_referenceTile != null)
{
if (currentFacingDirection == FacingDirection.North)
{
if (attackRange <= _referenceTile.tilesInLineUp.Count)
{
rangeVSTilesInLineLimitant = attackRange;
}
else
{
rangeVSTilesInLineLimitant = _referenceTile.tilesInLineUp.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
//Guardo la altura mas alta en esta linea de tiles
if (_referenceTile.tilesInLineUp[i].height > previousTileHeight)
{
previousTileHeight = _referenceTile.tilesInLineUp[i].height;
}
//Si hay una unidad
if (_referenceTile.tilesInLineUp[i].unitOnTile != null && _referenceTile.tilesInLineUp[i].unitOnTile.GetComponent <PlayerUnit>())
{
//Compruebo que la diferencia de altura con mi tile y con el tile anterior es correcto.
if (Mathf.Abs(_referenceTile.tilesInLineUp[i].height - _referenceTile.height) <= maxHeightDifferenceToAttack ||
Mathf.Abs(_referenceTile.tilesInLineUp[i].height - previousTileHeight) <= maxHeightDifferenceToAttack)
{
//Almaceno la primera unidad en la lista de posibles unidades
currentUnitsAvailableToAttack.Add(_referenceTile.tilesInLineUp[i].unitOnTile);
break;
}
else
{
continue;
}
}
else if (_referenceTile.tilesInLineUp[i].unitOnTile != null)
{
break;
}
if (_referenceTile.tilesInLineUp[i].isEmpty)
{
break;
}
}
}
if (currentFacingDirection == FacingDirection.South)
{
if (attackRange <= _referenceTile.tilesInLineDown.Count)
{
rangeVSTilesInLineLimitant = attackRange;
}
else
{
rangeVSTilesInLineLimitant = _referenceTile.tilesInLineDown.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
//Guardo la altura mas alta en esta linea de tiles
if (_referenceTile.tilesInLineDown[i].height > previousTileHeight)
{
previousTileHeight = _referenceTile.tilesInLineDown[i].height;
}
//Si hay una unidad
if (_referenceTile.tilesInLineDown[i].unitOnTile != null && _referenceTile.tilesInLineDown[i].unitOnTile.GetComponent <PlayerUnit>())
{
//Compruebo que la diferencia de altura con mi tile y con el tile anterior es correcto.
if (Mathf.Abs(_referenceTile.tilesInLineDown[i].height - _referenceTile.height) <= maxHeightDifferenceToAttack ||
Mathf.Abs(_referenceTile.tilesInLineDown[i].height - previousTileHeight) <= maxHeightDifferenceToAttack)
{
//Almaceno la primera unidad en la lista de posibles unidades
currentUnitsAvailableToAttack.Add(_referenceTile.tilesInLineDown[i].unitOnTile);
break;
}
else
{
continue;
}
}
else if (_referenceTile.tilesInLineDown[i].unitOnTile != null)
{
break;
}
if (_referenceTile.tilesInLineDown[i].isEmpty)
{
break;
}
}
}
if (currentFacingDirection == FacingDirection.East)
{
if (attackRange <= _referenceTile.tilesInLineRight.Count)
{
rangeVSTilesInLineLimitant = attackRange;
}
else
{
rangeVSTilesInLineLimitant = _referenceTile.tilesInLineRight.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
//Guardo la altura mas alta en esta linea de tiles
if (_referenceTile.tilesInLineRight[i].height > previousTileHeight)
{
previousTileHeight = _referenceTile.tilesInLineRight[i].height;
}
//Si hay una unidad
if (_referenceTile.tilesInLineRight[i].unitOnTile != null && _referenceTile.tilesInLineRight[i].unitOnTile.GetComponent <PlayerUnit>())
{
//Compruebo que la diferencia de altura con mi tile y con el tile anterior es correcto.
if (Mathf.Abs(_referenceTile.tilesInLineRight[i].height - _referenceTile.height) <= maxHeightDifferenceToAttack ||
Mathf.Abs(_referenceTile.tilesInLineRight[i].height - previousTileHeight) <= maxHeightDifferenceToAttack)
{
//Almaceno la primera unidad en la lista de posibles unidades
currentUnitsAvailableToAttack.Add(_referenceTile.tilesInLineRight[i].unitOnTile);
break;
}
else
{
continue;
}
}
else if (_referenceTile.tilesInLineRight[i].unitOnTile != null)
{
break;
}
if (_referenceTile.tilesInLineRight[i].isEmpty)
{
break;
}
}
}
if (currentFacingDirection == FacingDirection.West)
{
if (attackRange <= _referenceTile.tilesInLineLeft.Count)
{
rangeVSTilesInLineLimitant = attackRange;
}
else
{
rangeVSTilesInLineLimitant = _referenceTile.tilesInLineLeft.Count;
}
for (int i = 0; i < rangeVSTilesInLineLimitant; i++)
{
//Guardo la altura mas alta en esta linea de tiles
if (_referenceTile.tilesInLineLeft[i].height > previousTileHeight)
{
previousTileHeight = _referenceTile.tilesInLineLeft[i].height;
}
//Si hay una unidad
if (_referenceTile.tilesInLineLeft[i].unitOnTile != null && _referenceTile.tilesInLineLeft[i].unitOnTile.GetComponent <PlayerUnit>())
{
//Compruebo que la diferencia de altura con mi tile y con el tile anterior es correcto.
if (Mathf.Abs(_referenceTile.tilesInLineLeft[i].height - _referenceTile.height) <= maxHeightDifferenceToAttack ||
Mathf.Abs(_referenceTile.tilesInLineLeft[i].height - previousTileHeight) <= maxHeightDifferenceToAttack)
{
//Almaceno la primera unidad en la lista de posibles unidades
currentUnitsAvailableToAttack.Add(_referenceTile.tilesInLineLeft[i].unitOnTile);
break;
}
else
{
continue;
}
}
else if (_referenceTile.tilesInLineLeft[i].unitOnTile != null)
{
break;
}
if (_referenceTile.tilesInLineLeft[i].isEmpty)
{
break;
}
}
}
//Marco las unidades disponibles para atacar de color rojo
for (int i = 0; i < currentUnitsAvailableToAttack.Count; i++)
{
CalculateDamagePreviousAttack(currentUnitsAvailableToAttack[i], GetComponent <UnitBase>(), _referenceTile, _referenceFacingDirection);
currentUnitsAvailableToAttack[i].ColorAvailableToBeAttackedAndNumberDamage(damageWithMultipliersApplied);
}
}
}
//Se llama desde el LevelManager. Al final del showAction se encarga de mostrar el tile al que va a atacar
public override void ColorAttackTile()
{
shadowHoverTile = null;
tileToUseBetweenShadowOrMine = null;
//El +2 es porque pathToObjective tiene en cuenta tanto el tile inicial (ocupado por goblin) como el final (ocupado por player)
if (pathToObjective.Count > 0 && pathToObjective.Count <= movementUds + 2 && myCurrentObjectiveTile != null)
{
//Compruebo si tile al que voy a atacar estaba bajo ataque
base.ColorAttackTile();
//Esto significa que el enemigo está adyacente del player (son el tile del gigante y el del player vamos)
if (pathToObjective.Count > 2)
{
Debug.DrawRay(new Vector3(sombraHoverUnit.transform.position.x, sombraHoverUnit.transform.position.y + 0.5f, sombraHoverUnit.transform.position.z), transform.TransformDirection(Vector3.down), Color.yellow, 20f);
if (Physics.Raycast(new Vector3(sombraHoverUnit.transform.position.x, sombraHoverUnit.transform.position.y + 0.5f, sombraHoverUnit.transform.position.z), transform.TransformDirection(Vector3.down), out hit))
{
shadowHoverTile = hit.collider.gameObject.GetComponent <IndividualTiles>();
}
tileToUseBetweenShadowOrMine = shadowHoverTile;
}
else if (pathToObjective.Count == 2)
{
tileToUseBetweenShadowOrMine = myCurrentTile;
}
//Pinto tile izq y derecha
if ((pathToObjective.Count > 2 && myCurrentObjectiveTile != null && shadowHoverTile != null && myCurrentObjectiveTile.tileX == shadowHoverTile.tileX) ||
pathToObjective.Count == 2 && myCurrentObjectiveTile != null && myCurrentObjectiveTile.tileX == myCurrentTile.tileX)
{
//Hago lo mismo con los tiles laterales, los pinto de rojo y los guardo en la lista de bools
if (myCurrentObjectiveTile.tilesInLineRight.Count > 0 && myCurrentObjectiveTile.tilesInLineRight[0] != null)
{
//Tile lateral der
wereTilesAlreadyUnderAttack.Add(myCurrentObjectiveTile.tilesInLineRight[0].isUnderAttack);
tilesAlreadyUnderAttack.Add(myCurrentObjectiveTile.tilesInLineRight[0]);
myCurrentObjectiveTile.tilesInLineRight[0].ColorAttack();
}
if (myCurrentObjectiveTile.tilesInLineLeft.Count > 0 && myCurrentObjectiveTile.tilesInLineLeft[0] != null)
{
//Tile lateral izq
wereTilesAlreadyUnderAttack.Add(myCurrentObjectiveTile.tilesInLineLeft[0].isUnderAttack);
tilesAlreadyUnderAttack.Add(myCurrentObjectiveTile.tilesInLineLeft[0]);
myCurrentObjectiveTile.tilesInLineLeft[0].ColorAttack();
}
}
//O pinto tile arriba y debajo, depende de dirección
else if ((myCurrentObjectiveTile != null && shadowHoverTile != null) && (pathToObjective.Count > 2 && myCurrentObjectiveTile.tileZ == shadowHoverTile.tileZ || pathToObjective.Count == 2 && myCurrentObjectiveTile.tileZ == myCurrentTile.tileZ))
{
if (myCurrentObjectiveTile.tilesInLineUp.Count > 0 && myCurrentObjectiveTile.tilesInLineUp[0] != null)
{
//Tile lateral arriba
wereTilesAlreadyUnderAttack.Add(myCurrentObjectiveTile.tilesInLineUp[0].isUnderAttack);
tilesAlreadyUnderAttack.Add(myCurrentObjectiveTile.tilesInLineUp[0]);
myCurrentObjectiveTile.tilesInLineUp[0].ColorAttack();
}
if (myCurrentObjectiveTile.tilesInLineDown.Count > 0 && myCurrentObjectiveTile.tilesInLineDown[0] != null)
{
//Tile lateral abajo
wereTilesAlreadyUnderAttack.Add(myCurrentObjectiveTile.tilesInLineDown[0].isUnderAttack);
tilesAlreadyUnderAttack.Add(myCurrentObjectiveTile.tilesInLineDown[0]);
myCurrentObjectiveTile.tilesInLineDown[0].ColorAttack();
}
}
}
}
