public void UndoAction()
{
playerSelectedWhileClickingUndo = LM.selectedCharacter;
if (playerSelectedWhileClickingUndo != null && !playerSelectedWhileClickingUndo.isMovingorRotating || playerSelectedWhileClickingUndo == null)
{
if (counter > 0)
{
Debug.Log("Command History count: " + commandHistory.Count);
//Reduzco el counter
counter--;
//Guardo el player del siguiente comando
lastUndoPlayer = commandHistory[counter].Player();
//Deshago el comando
commandHistory[counter].Undo();
Debug.Log("Primer undo: " + commandHistory[counter]);
////Compruebo si la siguiente acción está realizada por el mismo personaje
while (counter > 0)
{
NextCommandPlayer = commandHistory[counter - 1].Player();
//El ninja es excepción porque solo puede atacar de 1 en 1 pero sus saltos cuentan como varios ataques
if ((NextCommandPlayer == lastUndoPlayer || (NextCommandPlayer.GetComponent <Mage>() && lastUndoPlayer.GetComponent <MageDecoy>() || NextCommandPlayer.GetComponent <MageDecoy>() && lastUndoPlayer.GetComponent <Mage>())) &&
!commandHistory[counter - 1].CheckIfMoveCommand() && !NextCommandPlayer.GetComponent <Rogue>())
{
Debug.Log("Siguiente Undo: " + commandHistory[counter]);
//Repito las tres primeras lineas deshaciendo esta acción
counter--;
lastUndoPlayer = commandHistory[counter].Player();
commandHistory[counter].Undo();
}
//Si siguen quedando acciones pero ya no se cumple que coincida el personaje sago del loop.
else
{
break;
}
}
LM.DeSelectUnit();
}
}
playerSelectedWhileClickingUndo = null;
LM.UIM.CheckActionsAvaliable();
}
private IEnumerator attackTarget(UnitBase from, UnitBase target, bool canFightBack)
{
from.CanOperate = false;
yield return(from.Anim_OnAttack());
//发射子弹
ResManager.Get().LoadAsync <GameObject>("Prefabs/Units/Projectile/Projectile", (obj) =>
{
//设置起始位置
Vector3 po = from.transform.position;
po.y = from.GetComponent <UnitBase>().Height;
obj.transform.position = po;
//朝向攻击目标
obj.transform.LookAt(target.transform);
Quaternion rotation = obj.transform.rotation;
//将上下旋转重置为0
rotation.x = 0;
obj.transform.rotation = rotation;
//初始化子弹逻辑
obj.GetComponent <Projectile>().Init(target.gameObject, () => {
//子弹到达攻击目标
target.CostHP(from.Damage);
ResManager.Get().LoadAsync <GameObject>("Prefabs/VFX/ParticleExplosion/ParticleExplosion", (vfx) => {
vfx.transform.position = obj.transform.position;
});
target.Anim_OnDamage();
//若对方未死亡，则回击
if (canFightBack && target.GetHP() > 0)
{
target.Attack(from, true, true);
}
}, 1f);
});
}
public override void HideAttackEffect(UnitBase _unitToAttack)
{
base.HideAttackEffect(_unitToAttack);
if ((_unitToAttack.GetComponent <PlayerUnit>()) && !currentUnitsAvailableToAttack.Contains((_unitToAttack)))
{
ChangePositionIconFeedback(false, _unitToAttack);
Cursor.SetCursor(null, Vector2.zero, CursorMode.Auto);
}
else
{
if (armorMode)
{
if (_unitToAttack.GetComponent <PlayerUnit>())
{
if (armorMode2)
{
canvasHover.SetActive(false);
armorShield2.SetActive(false);
}
_unitToAttack.canvasHover.SetActive(false);
armorShield.SetActive(false);
}
}
}
sombraHoverUnit.SetActive(false);
_unitToAttack.sombraHoverUnit.SetActive(false);
ChangePositionIconFeedback(false, _unitToAttack);
if (tilesInEnemyHover.Count > 0)
{
for (int i = 0; i < tilesInEnemyHover.Count; i++)
{
tilesInEnemyHover[i].ColorBorderRed();
if (tilesInEnemyHover[i].unitOnTile != null)
{
tilesInEnemyHover[i].unitOnTile.ResetColor();
tilesInEnemyHover[i].unitOnTile.DisableCanvasHover();
}
}
}
}
public void WarnBalista(UnitBase _playerMovedToThisTile)
{
if (lookingForKnightToWarnBalista)
{
if (_playerMovedToThisTile.GetComponent <Knight>())
{
//Avisar a las balistas
for (int i = 0; i < allBalistasToWarn.Count; i++)
{
allBalistasToWarn[i].BeWarnedByTile();
}
}
}
}
//Override especial del mago para anlar ventajas por altura y daño por la espalda
public override void CalculateDamage(UnitBase unitToDealDamage)
{
//Esta bien que no haga base.CalculateDamage
//Reseteo la variable de daño a realizar
damageWithMultipliersApplied = baseDamage;
//Estas líneas las añado para comprobar si el samurai tiene la mejora de la pasiva 1
Samurai samuraiUpgraded = FindObjectOfType <Samurai>();
if (samuraiUpgraded != null && samuraiUpgraded.itsForHonorTime2)
{
damageWithMultipliersApplied += LM.honorCount;
}
damageWithMultipliersApplied += buffbonusStateDamage;
damageWithMultipliersApplied += currentTickLightning;
if (lightningChain2 && unitToDealDamage.GetComponent <PlayerUnit>())
{
damageWithMultipliersApplied = 0;
}
}
public void PutQuitMark(UnitBase _unitToMark, UnitBase _unitAttacking, bool haveToPut, bool showFutureMark)
{
//Si pongo la marca actualizo los numeros y el estado del bool
if (haveToPut)
{
_unitToMark.isMarked = true;
_unitToMark.numberOfMarks += 1;
if (suplex2)
{
if (_unitToMark.numberOfMarks > 2)
{
_unitToMark.isMarked = false;
_unitToMark.numberOfMarks = 0;
_unitAttacking.currentHealth += healWithUpgradedMark;
}
}
//NO ES >= 1, ESTÁ BIEN >
else if (_unitToMark.numberOfMarks > 1)
{
_unitToMark.isMarked = false;
_unitToMark.numberOfMarks = 0;
_unitAttacking.currentHealth += healerBonus;
}
_unitAttacking.RefreshHealth(false);
UIM.RefreshHealth();
}
//Independientemente de que actualice la maca o no tengo que enseñarla
//Esto sirve para el showAction que tiene que mostrar el estado en el que acaba la marca (como si ya se hubiese aplicado el ataque)
if (showFutureMark)
{
if (_unitToMark.isMarked)
{
if (_unitToMark.numberOfMarks == 1)
{
if (suplex2)
{
_unitToMark.monkMark.SetActive(false);
if (_unitAttacking.GetComponent <Monk>())
{
_unitToMark.monkMarkUpgrade.SetActive(true);
}
}
else
{
_unitToMark.monkMark.SetActive(false);
_unitAttacking.canvasHover.SetActive(true);
_unitAttacking.canvasHover.GetComponent <CanvasHover>().damageNumber.SetText("+" + healerBonus);
_unitAttacking.canvasHover.GetComponent <CanvasHover>().damageNumber.color = new Color32(0, 255, 50, 255);
_unitAttacking.ColorAvailableToBeHealed();
_unitAttacking.myCurrentTile.ColorHeal();
}
}
else if (_unitToMark.numberOfMarks == 2)
{
_unitToMark.monkMark.SetActive(false);
_unitToMark.monkMarkUpgrade.SetActive(false);
_unitAttacking.canvasHover.SetActive(true);
_unitAttacking.canvasHover.GetComponent <CanvasHover>().damageNumber.SetText("+" + healWithUpgradedMark);
_unitAttacking.canvasHover.GetComponent <CanvasHover>().damageNumber.color = new Color32(0, 255, 50, 255);
_unitAttacking.ColorAvailableToBeHealed();
_unitAttacking.myCurrentTile.ColorHeal();
}
}
else if (_unitToMark.numberOfMarks == 0)
{
if (_unitAttacking.GetComponent <Monk>())
{
_unitToMark.monkMark.SetActive(true);
}
_unitToMark.monkMarkUpgrade.SetActive(false);
}
}
//El estado actual (sirve para el ataque)
else
{
if (_unitToMark.isMarked)
{
if (_unitToMark.numberOfMarks == 1)
{
_unitToMark.monkMark.SetActive(true);
_unitToMark.monkMarkUpgrade.SetActive(false);
}
else if (_unitToMark.numberOfMarks == 2)
{
_unitToMark.monkMark.SetActive(false);
_unitToMark.monkMarkUpgrade.SetActive(true);
}
}
else if (_unitToMark.numberOfMarks == 0)
{
_unitToMark.monkMark.SetActive(false);
_unitToMark.monkMarkUpgrade.SetActive(false);
}
}
}
public void AttackTarget(UnitBase target)
{
// draw a line to the unit we would be attacking
if(target == null || (target.GetComponent<PlayerManager>() && target.GetComponent<PlayerManager>().respawning)){
return;
}
lines.AddLine(u.pos3.Variation(2), target.u.pos3.Variation(2), ourColor);
attackCooldownCounter = u.attackCooldown;
GetComponent<PhotonView>().RPC("SetCooldown", PhotonTargets.AllBuffered, u.attackCooldown);
target.GetComponent<PhotonView>().RPC("SetHealth", PhotonTargets.AllBuffered, target.u.health - u.attackPower);
target.GetComponent<PhotonView>().RPC("GotHit", PhotonTargets.All);
if(target.u.health <= 0){
target.u.alive = false;
}
}
public override void ShowAttackEffect(UnitBase _unitToAttack)
{
currentTickLightning = 0;
base.ShowAttackEffect(_unitToAttack);
tilesInEnemyHover.Clear();
tilesInEnemyHover.Add(_unitToAttack.myCurrentTile);
if (areaAttack)
{
if (areaAttack2)
{
TM.GetSurroundingTiles(_unitToAttack.myCurrentTile, areaRange, true, false);
for (int i = 0; i < TM.surroundingTiles.Count; ++i)
{
tilesInEnemyHover.Add(TM.surroundingTiles[i]);
}
}
else
{
//Animación de ataque
//HAY QUE HACER UNA PARA EL ATAQUE EN CRUZ O PARTÍCULAS
//myAnimator.SetTrigger("Attack");
//Hago daño a las unidades adyacentes
for (int i = 0; i < _unitToAttack.myCurrentTile.neighbours.Count; ++i)
{
if (_unitToAttack.myCurrentTile.neighbours[i] != null)
{
tilesInEnemyHover.Add(_unitToAttack.myCurrentTile.neighbours[i]);
}
}
}
for (int i = 0; i < tilesInEnemyHover.Count; i++)
{
if (tilesInEnemyHover[i].unitOnTile != null)
{
tilesInEnemyHover[i].ColorAttack();
if (tilesInEnemyHover[i].unitOnTile != null)
{
CalculateDamage(tilesInEnemyHover[i].unitOnTile);
tilesInEnemyHover[i].unitOnTile.ColorAvailableToBeAttackedAndNumberDamage(damageWithMultipliersApplied);
}
}
}
}
else if (lightningChain)
{
attackingUnits.Clear();
nextUnits.Clear();
unitsFinished.Clear();
if (lightningChain2 && _unitToAttack.GetComponent <PlayerUnit>())
{
}
else
{
CalculateDamage(_unitToAttack);
}
currentTickLightning = 1;
attackingUnits.Add(_unitToAttack);
for (int i = 0; i < attackingUnits.Count; i++)
{
for (int j = 0; j < attackingUnits[i].myCurrentTile.neighbours.Count; j++)
{
if (attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile != null &&
!unitsFinished.Contains(attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile))
{
if (!nextUnits.Contains(attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile))
{
nextUnits.Add(attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile);
CalculateDamage(attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile);
tilesInEnemyHover.Add(attackingUnits[i].myCurrentTile.neighbours[j]);
attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile.ColorAvailableToBeAttackedAndNumberDamage(damageWithMultipliersApplied);
}
}
}
unitsFinished.Add(attackingUnits[i]);
attackingUnits.Remove(attackingUnits[i]);
i--;
if (attackingUnits.Count == 0)
{
timeElectricityAttackExpands--;
if (timeElectricityAttackExpands > 0)
{
for (int k = 0; k < nextUnits.Count; k++)
{
attackingUnits.Add(nextUnits[k]);
}
nextUnits.Clear();
if (lightningChain2 && currentTickLightning < limitantMaxAttackBonus - 1)
{
currentTickLightning++;
}
}
else
{
timeElectricityAttackExpands = fTimeElectricityAttackExpands;
break;
}
}
}
}
//Ataque básico
else
{
for (int i = 0; i < tilesInEnemyHover.Count; i++)
{
tilesInEnemyHover[i].ColorAttack();
if (tilesInEnemyHover[i].unitOnTile != null)
{
CalculateDamage(tilesInEnemyHover[i].unitOnTile);
tilesInEnemyHover[i].unitOnTile.ColorAvailableToBeAttackedAndNumberDamage(damageWithMultipliersApplied);
}
}
}
timeElectricityAttackExpands = fTimeElectricityAttackExpands;
attackingUnits.Clear();
//PASIVAS
if (mirrorDecoy)
{
for (int i = 0; i < myDecoys.Count; i++)
{
myDecoys[i].GetComponent <MageDecoy>().CheckUnitsAndTilesToColorAtHover();
}
}
}
//En función de donde este mirando el personaje paso una lista de tiles diferente.
public override void Attack(UnitBase unitToAttack)
{
Debug.Log("Attack");
CheckIfUnitHasMarks(unitToAttack);
currentTickLightning = 0;
for (int i = 0; i < tilesInEnemyHover.Count; i++)
{
tilesInEnemyHover[i].ColorDesAttack();
if (tilesInEnemyHover[i].unitOnTile != null)
{
tilesInEnemyHover[i].unitOnTile.ResetColor();
tilesInEnemyHover[i].unitOnTile.DisableCanvasHover();
}
}
tilesInEnemyHover.Clear();
if (mirrorDecoy)
{
for (int i = 0; i < myDecoys.Count; i++)
{
Debug.Log("decoys");
//En el override de esta función el decoy también comprueba si tiene la segunda mejora y ataca de una forma o de la otra
myDecoys[i].GetComponent <MageDecoy>().CheckUnitsAndTilesInRangeToAttack(true);
myDecoys[i].GetComponent <MageDecoy>().HideAttackEffect(null);
}
}
Instantiate(chargingParticle, gameObject.transform.position, chargingParticle.transform.rotation);
if (areaAttack)
{
Instantiate(particleAreaAttack, unitToAttack.transform.position, particleAreaAttack.transform.rotation);
if (areaAttack2)
{
//Animación de ataque
//HAY QUE HACER UNA PARA EL ATAQUE EN CRUZ O PARTÍCULAS
//myAnimator.SetTrigger("Attack");
//UNDO
CreateAttackCommand(unitToAttack);
//COMPROBAR QUE NO DE ERROR EN OTRAS COSAS
TM.surroundingTiles.Clear();
TM.GetSurroundingTiles(unitToAttack.myCurrentTile, areaRange, true, false);
//Hago daño
DoDamage(unitToAttack);
//Hago daño a las unidades adyacentes
for (int i = 0; i < TM.surroundingTiles.Count; ++i)
{
if (TM.surroundingTiles[i].unitOnTile != null)
{
//UNDO
CreateAttackCommand(TM.surroundingTiles[i].unitOnTile);
DoDamage(TM.surroundingTiles[i].unitOnTile);
}
}
}
else
{
//Animación de ataque
//HAY QUE HACER UNA PARA EL ATAQUE EN CRUZ O PARTÍCULAS
//myAnimator.SetTrigger("Attack");
//Hago daño a las unidades adyacentes
for (int i = 0; i < unitToAttack.myCurrentTile.neighbours.Count; ++i)
{
if (unitToAttack.myCurrentTile.neighbours[i].unitOnTile != null)
{
//UNDO
CreateAttackCommand(unitToAttack.myCurrentTile.neighbours[i].unitOnTile);
DoDamage(unitToAttack.myCurrentTile.neighbours[i].unitOnTile);
}
}
//UNDO
CreateAttackCommand(unitToAttack);
//Hago daño
DoDamage(unitToAttack);
}
//La base tiene que ir al final para que el bool de hasAttacked se active después del efecto.
base.Attack(unitToAttack);
}
else if (lightningChain)
{
attackingUnits.Clear();
nextUnits.Clear();
unitsFinished.Clear();
if (lightningChain2 && unitToAttack.GetComponent <PlayerUnit>())
{
}
else
{
//UNDO
CreateAttackCommand(unitToAttack);
Instantiate(particleLightning, unitToAttack.transform.position, unitToAttack.transform.rotation);
//Hago daño
DoDamage(unitToAttack);
}
//Una vez ya he atacado al primer objetivo lo pongo en 1 para que no le afecte al primero.
currentTickLightning = 1;
attackingUnits.Add(unitToAttack);
for (int i = 0; i < attackingUnits.Count; i++)
{
for (int j = 0; j < attackingUnits[i].myCurrentTile.neighbours.Count; j++)
{
if (attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile != null &&
!unitsFinished.Contains(attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile))
{
//Funciona para ambos lightnings porque el no atacar a enemigos se hace en calculate Damage para que funcione en el ShowAttackEffect
if (!nextUnits.Contains(attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile))
{
//UNDO
CreateAttackCommand(attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile);
nextUnits.Add(attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile);
Instantiate(particleLightning, attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile.transform.position, attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile.transform.rotation);
DoDamage(attackingUnits[i].myCurrentTile.neighbours[j].unitOnTile);
}
}
}
if (!unitsFinished.Contains(attackingUnits[i]))
{
unitsFinished.Add(attackingUnits[i]);
}
attackingUnits.Remove(attackingUnits[i]);
i--;
if (attackingUnits.Count == 0)
{
timeElectricityAttackExpands--;
if (timeElectricityAttackExpands > 0)
{
for (int k = 0; k < nextUnits.Count; k++)
{
if (!attackingUnits.Contains(nextUnits[k]))
{
attackingUnits.Add(nextUnits[k]);
}
}
if (lightningChain2 && currentTickLightning < limitantMaxAttackBonus - 1)
{
currentTickLightning++;
}
nextUnits.Clear();
}
else
{
timeElectricityAttackExpands = fTimeElectricityAttackExpands;
currentTickLightning = 0;
break;
}
}
}
//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);
Instantiate(attackParticle, unitToAttack.transform.position, unitToAttack.transform.rotation);
//Hago daño
DoDamage(unitToAttack);
SoundManager.Instance.PlaySound(AppSounds.MAGE_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 Attack(UnitBase unitToAttack)
{
CheckIfUnitHasMarks(unitToAttack);
if (areaHealer)
{
if (unitToAttack.GetComponent <PlayerUnit>())
{
Instantiate(areaHealParticle, unitToAttack.transform.position, areaHealParticle.transform.rotation);
SoundManager.Instance.PlaySound(AppSounds.HEALING);
//COMPROBAR QUE NO DE ERROR EN OTRAS COSAS
TM.surroundingTiles.Clear();
TM.GetSurroundingTiles(unitToAttack.myCurrentTile, 1, true, false);
//UNDO
CreateAttackCommand(unitToAttack);
//Unidad a la que he clickado
if (areaHealer2)
{
unitToAttack.isStunned = false;
unitToAttack.turnStunned = 0;
ApplyBuffOrDebuffDamage(unitToAttack, 0, 0);
unitToAttack.buffbonusStateDamage = 0;
}
if (tileTransformer)
{
realTilesSpawned.Add(Instantiate(healerTilePref, unitToAttack.transform.position, unitToAttack.transform.rotation));
}
unitToAttack.currentHealth += healedLife;
unitToAttack.RefreshHealth(false);
//Curo a las unidades en el área
for (int i = 0; i < TM.surroundingTiles.Count; ++i)
{
if (TM.surroundingTiles[i].unitOnTile != null)
{
//UNDO
CreateAttackCommand(TM.surroundingTiles[i].unitOnTile);
if (areaHealer2)
{
TM.surroundingTiles[i].unitOnTile.isStunned = false;
TM.surroundingTiles[i].unitOnTile.turnStunned = 0;
ApplyBuffOrDebuffDamage(TM.surroundingTiles[i].unitOnTile, 0, 0);
TM.surroundingTiles[i].unitOnTile.buffbonusStateDamage = 0;
}
if (tileTransformer)
{
realTilesSpawned.Add(Instantiate(healerTilePref, TM.surroundingTiles[i].unitOnTile.transform.position, TM.surroundingTiles[i].unitOnTile.transform.rotation));
}
//Curación
if (TM.surroundingTiles[i].unitOnTile.currentHealth < TM.surroundingTiles[i].unitOnTile.maxHealth && !TM.surroundingTiles[i].unitOnTile.GetComponent <BossMultTile>())
{
TM.surroundingTiles[i].unitOnTile.currentHealth += healedLife;
TM.surroundingTiles[i].unitOnTile.RefreshHealth(false);
}
}
}
if (shadowTilesSpawned.Count > 0)
{
for (int i = 0; i < shadowTilesSpawned.Count; i++)
{
Destroy(shadowTilesSpawned[i].gameObject);
}
shadowTilesSpawned.Clear();
}
//IMPORTANTE PARA EL UNDO QUE LA VIDA SE QUITE AL FINAL
currentHealth -= 1;
if (currentHealth <= 0)
{
Die();
isDead = true;
}
UIM.RefreshTokens();
UIM.RefreshHealth();
unitToAttack.RefreshHealth(false);
RefreshHealth(false);
}
else
{
//UNDO
CreateAttackCommand(unitToAttack);
//Hago daño
DoDamage(unitToAttack);
if (currentHealth < maxHealth)
{
currentHealth += healedLife;
RefreshHealth(false);
UIM.RefreshTokens();
UIM.RefreshHealth();
}
//Hay que cambiar
SoundManager.Instance.PlaySound(AppSounds.MAGE_ATTACK);
}
}
else
{
//UNDO
CreateAttackCommand(unitToAttack);
if (unitToAttack.GetComponent <PlayerUnit>())
{
Instantiate(healParticle, unitToAttack.transform.position, healParticle.transform.rotation);
SoundManager.Instance.PlaySound(AppSounds.HEALING);
if (individualHealer2)
{
ApplyBuffOrDebuffMovement(unitToAttack, fMovementUds + movementUpgrade, 3);
}
else if (tileTransformer)
{
realTilesSpawned.Add(Instantiate(healerTilePref, unitToAttack.transform.position, unitToAttack.transform.rotation));
}
if (shadowTilesSpawned.Count > 0)
{
for (int i = 0; i < shadowTilesSpawned.Count; i++)
{
Destroy(shadowTilesSpawned[i].gameObject);
}
shadowTilesSpawned.Clear();
}
if (unitToAttack.currentHealth < unitToAttack.maxHealth)
{
unitToAttack.currentHealth += healedLife;
unitToAttack.RefreshHealth(false);
}
currentHealth -= 1;
if (currentHealth <= 0)
{
Die();
isDead = true;
}
RefreshHealth(false);
UIM.RefreshTokens();
UIM.RefreshHealth();
}
else
{
//Hay que cambiar
Instantiate(attackParticle, unitToAttack.transform.position, attackParticle.transform.rotation);
//Hago daño
DoDamage(unitToAttack);
if (currentHealth < maxHealth)
{
currentHealth += healedLife;
RefreshHealth(false);
UIM.RefreshTokens();
UIM.RefreshHealth();
}
//Hay que cambiar
SoundManager.Instance.PlaySound(AppSounds.MAGE_ATTACK);
}
}
hasAttacked = true;
HideAttackEffect(unitToAttack);
//La base tiene que ir al final para que el bool de hasAttacked se active después del efecto.
base.Attack(unitToAttack);
}
public override void CalculateDamage(UnitBase unitToDealDamage)
{
//Reseteo la variable de daño a realizar
damageWithMultipliersApplied = baseDamage;
//Si estoy en desventaja de altura hago menos daño
if (unitToDealDamage.myCurrentTile.height > myCurrentTile.height)
{
damageWithMultipliersApplied -= penalizatorDamageLessHeight;
healthBar.SetActive(true);
downToUpDamageIcon.SetActive(true);
}
//Si estoy en ventaja de altura hago más daño
else if (unitToDealDamage.myCurrentTile.height < myCurrentTile.height)
{
damageWithMultipliersApplied += bonusDamageMoreHeight;
healthBar.SetActive(true);
upToDownDamageIcon.SetActive(true);
}
//Si le ataco por la espalda hago más daño
if (unitToDealDamage.currentFacingDirection == currentFacingDirection)
{
if (unitToDealDamage.GetComponent <EnDuelist>() &&
unitToDealDamage.GetComponent <EnDuelist>().hasTier2 &&
hasAttacked)
{
if (currentFacingDirection == FacingDirection.North)
{
unitToDealDamage.unitModel.transform.DORotate(new Vector3(0, 180, 0), timeDurationRotation);
unitToDealDamage.currentFacingDirection = FacingDirection.South;
}
else if (currentFacingDirection == FacingDirection.South)
{
unitToDealDamage.unitModel.transform.DORotate(new Vector3(0, 0, 0), timeDurationRotation);
unitToDealDamage.currentFacingDirection = FacingDirection.North;
}
else if (currentFacingDirection == FacingDirection.East)
{
unitToDealDamage.unitModel.transform.DORotate(new Vector3(0, -90, 0), timeDurationRotation);
unitToDealDamage.currentFacingDirection = FacingDirection.West;
}
else if (currentFacingDirection == FacingDirection.West)
{
unitToDealDamage.unitModel.transform.DORotate(new Vector3(0, 90, 0), timeDurationRotation);
unitToDealDamage.currentFacingDirection = FacingDirection.East;
}
}
else
{
//Añado este if para que, cada vez que ataque un jugador y si le va a realizar daño por la espalda, el count del honor se resetea
if (hasAttacked)
{
LM.honorCount = 0;
}
//Ataque por la espalda
damageWithMultipliersApplied += bonusDamageBackAttack;
healthBar.SetActive(true);
backStabIcon.SetActive(true);
}
}
//Estas líneas las añado para comprobar si el samurai tiene la mejora de la pasiva 1
Samurai samuraiUpgraded = FindObjectOfType <Samurai>();
if (samuraiUpgraded != null && samuraiUpgraded.itsForHonorTime2)
{
damageWithMultipliersApplied += LM.honorCount;
}
if (isInRage)
{
//Añado el daño de rage.
damageWithMultipliersApplied += extraDamageWithRage;
}
if (areaAttack)
{
//Añado el daño de rage.
damageWithMultipliersApplied += bonusDamageAreaAttack;
}
damageWithMultipliersApplied += buffbonusStateDamage;
}
public override void ShowAttackEffect(UnitBase _unitToAttack)
{
base.ShowAttackEffect(_unitToAttack);
if ((_unitToAttack.GetComponent <PlayerUnit>()) && !currentUnitsAvailableToAttack.Contains((_unitToAttack)))
{
if (LM.selectedCharacter == this && !hasMoved && changePositions)
{
if (_unitToAttack.currentHealth <= numberCanChange)
{
ChangePositionIconFeedback(true, _unitToAttack);
Cursor.SetCursor(LM.UIM.movementCursor, Vector2.zero, CursorMode.Auto);
}
}
}
else
{
//Al final dijimos que lo de las sombras liaba más que ayudaba
//shaderHover.SetActive(true);
//Vector3 vector2Spawn = new Vector3(transform.position.x, transform.position.y + 2.5f, transform.position.z);
//shaderHover.transform.position = vector2Spawn;
//_unitToAttack.shaderHover.SetActive(true);
//Vector3 vector2SpawnEnemy = new Vector3(_unitToAttack.transform.position.x, transform.position.y + 2.5f, _unitToAttack.transform.position.z);
//_unitToAttack.shaderHover.transform.position = vector2SpawnEnemy;
ChangePositionIconFeedback(true, _unitToAttack);
if (canChooseEnemy)
{
tilesInEnemyHover.Clear();
for (int i = 0; i < currentUnitsAvailableToAttack.Count; i++)
{
tilesInEnemyHover.Add(currentUnitsAvailableToAttack[i].myCurrentTile);
if (currentUnitsAvailableToAttack[i] == _unitToAttack)
{
break;
}
}
}
else if (armorMode)
{
if (_unitToAttack.GetComponent <PlayerUnit>())
{
if (armorMode2)
{
if (currentArmor >= currentHealth)
{
}
else
{
canvasHover.SetActive(true);
armorShield2.SetActive(true);
if (currentArmor + numberOfArmorAdded >= currentHealth)
{
canvasHover.GetComponent <CanvasHover>().damageNumber.SetText("+" + (currentHealth - currentArmor).ToString());
}
else
{
canvasHover.GetComponent <CanvasHover>().damageNumber.SetText("+" + numberOfArmorAdded.ToString());
}
canvasHover.GetComponent <CanvasHover>().damageNumber.color = new Color32(0, 255, 50, 255);
}
}
if (_unitToAttack.currentArmor >= _unitToAttack.currentHealth)
{
}
else
{
_unitToAttack.canvasHover.SetActive(true);
armorShield.SetActive(true);
Vector3 vector2Spawn = new Vector3(_unitToAttack.transform.position.x, _unitToAttack.transform.position.y + 1.5f, _unitToAttack.transform.position.z);
armorShield.transform.position = vector2Spawn;
if (_unitToAttack.currentArmor + numberOfArmorAdded >= _unitToAttack.currentHealth)
{
_unitToAttack.canvasHover.GetComponent <CanvasHover>().damageNumber.SetText("+" + (_unitToAttack.currentHealth - _unitToAttack.currentArmor).ToString());
}
else
{
_unitToAttack.canvasHover.GetComponent <CanvasHover>().damageNumber.SetText("+" + numberOfArmorAdded.ToString());
}
_unitToAttack.canvasHover.GetComponent <CanvasHover>().damageNumber.color = new Color32(0, 255, 50, 255);
}
}
else if (!_unitToAttack.GetComponent <PlayerUnit>())
{
tilesInEnemyHover.Add(_unitToAttack.myCurrentTile);
}
}
else if (!_unitToAttack.GetComponent <PlayerUnit>())
{
tilesInEnemyHover.Add(_unitToAttack.myCurrentTile);
}
if (tilesInEnemyHover.Count > 0)
{
for (int i = 0; i < tilesInEnemyHover.Count; i++)
{
tilesInEnemyHover[i].ColorAttack();
if (tilesInEnemyHover[i].unitOnTile != null)
{
CalculateDamage(tilesInEnemyHover[i].unitOnTile);
tilesInEnemyHover[i].unitOnTile.ColorAvailableToBeAttackedAndNumberDamage(damageWithMultipliersApplied);
}
}
}
}
}
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 ShowAttackEffect(UnitBase _unitToAttack)
{
base.ShowAttackEffect(_unitToAttack);
if (areaHealer)
{
if (_unitToAttack.GetComponent <PlayerUnit>())
{
TM.surroundingTiles.Clear();
TM.GetSurroundingTiles(_unitToAttack.myCurrentTile, 1, true, false);
tilesInEnemyHover.Add(_unitToAttack.myCurrentTile);
for (int i = 0; i < TM.surroundingTiles.Count; ++i)
{
if (TM.surroundingTiles[i] != null)
{
tilesInEnemyHover.Add(TM.surroundingTiles[i]);
}
}
previsualizeAttackIcon.SetActive(true);
canvasHover.SetActive(true);
canvasHover.GetComponent <CanvasHover>().damageNumber.SetText("-1");
for (int i = 0; i < tilesInEnemyHover.Count; i++)
{
tilesInEnemyHover[i].ColorHeal();
if (tilesInEnemyHover[i].unitOnTile != null)
{
if (tileTransformer)
{
GameObject shadowTile = Instantiate(shadowHealerTilePref, tilesInEnemyHover[i].transform.position, tilesInEnemyHover[i].transform.rotation);
shadowTilesSpawned.Add(shadowTile);
}
tilesInEnemyHover[i].unitOnTile.canvasHover.GetComponent <CanvasHover>().damageNumber.SetText("+" + healedLife);
tilesInEnemyHover[i].unitOnTile.canvasHover.GetComponent <CanvasHover>().damageNumber.color = new Color32(0, 255, 50, 255);
tilesInEnemyHover[i].unitOnTile.ColorAvailableToBeHealed();
tilesInEnemyHover[i].unitOnTile.canvasHover.SetActive(true);
tilesInEnemyHover[i].unitOnTile.myCurrentTile.ColorHeal();
}
}
}
else
{
int healNumeber;
if (_unitToAttack.isMarked)
{
if (_unitToAttack.numberOfMarks == 1)
{
healNumeber = (healedLife + pjMonkUnitReference.healerBonus);
}
else
{
healNumeber = (healedLife + pjMonkUnitReference.healWithUpgradedMark);
}
}
else
{
healNumeber = healedLife;
}
canvasHover.SetActive(true);
canvasHover.GetComponent <CanvasHover>().damageNumber.SetText("+" + healNumeber);
canvasHover.GetComponent <CanvasHover>().damageNumber.color = new Color32(0, 255, 50, 255);
ColorAvailableToBeHealed();
myCurrentTile.ColorHeal();
CalculateDamage(_unitToAttack);
_unitToAttack.ColorAvailableToBeAttackedAndNumberDamage(damageWithMultipliersApplied);
_unitToAttack.myCurrentTile.ColorAttack();
}
}
else
{
if (_unitToAttack != null && _unitToAttack.GetComponent <PlayerUnit>())
{
if (tileTransformer)
{
GameObject shadowTile = Instantiate(shadowHealerTilePref, _unitToAttack.transform.position, _unitToAttack.transform.rotation);
shadowTilesSpawned.Add(shadowTile);
}
if (individualHealer2)
{
SetMovementIcon(movementUpgrade, _unitToAttack, true);
}
previsualizeAttackIcon.SetActive(true);
canvasHover.SetActive(true);
canvasHover.GetComponent <CanvasHover>().damageNumber.SetText("-1");
_unitToAttack.canvasHover.SetActive(true);
_unitToAttack.canvasHover.GetComponent <CanvasHover>().damageNumber.SetText("+" + healedLife);
_unitToAttack.canvasHover.GetComponent <CanvasHover>().damageNumber.color = new Color32(0, 255, 50, 255);
_unitToAttack.ColorAvailableToBeHealed();
_unitToAttack.myCurrentTile.ColorHeal();
tilesInEnemyHover.Add(_unitToAttack.myCurrentTile);
}
else if (_unitToAttack != null)
{
int healNumeber;
if (_unitToAttack.isMarked)
{
if (_unitToAttack.numberOfMarks == 1)
{
healNumeber = (healedLife + pjMonkUnitReference.healerBonus);
}
else
{
healNumeber = (healedLife + pjMonkUnitReference.healWithUpgradedMark);
}
}
else
{
healNumeber = healedLife;
}
healthBar.SetActive(true);
canvasHover.SetActive(true);
canvasHover.GetComponent <CanvasHover>().damageNumber.SetText("+" + healNumeber);
canvasHover.GetComponent <CanvasHover>().damageNumber.color = new Color32(0, 255, 50, 255);
ColorAvailableToBeHealed();
myCurrentTile.ColorHeal();
CalculateDamage(_unitToAttack);
_unitToAttack.ColorAvailableToBeAttackedAndNumberDamage(damageWithMultipliersApplied);
_unitToAttack.myCurrentTile.ColorAttack();
}
}
}
void Update()
{
if (!IsAnimating())
{
switch (state)
{
case STATE.PLAYER_TURN:
if (Input.GetMouseButtonDown(0) && !EventSystem.current.IsPointerOverGameObject())
{
Vector3 touchPosition3d = Camera.main.ScreenToWorldPoint(Input.mousePosition);
Vector2Int touchPosition = new Vector2Int(Mathf.RoundToInt(touchPosition3d.x), Mathf.RoundToInt(touchPosition3d.y));
if (IsOnBoard(touchPosition))
{
UnitBase unit = boardUnits[touchPosition.x, touchPosition.y];
//we touched a new unit
if (unit != null && unit != selectedUnit)
{
if (unit != selectedUnit)
{
if (selectedUnit != null)
{
selectedUnit.SetDown(false);
}
SelectUnit(unit);
}
//if unit is in attack units of selected and on the other team
//attack
//we touched an empty board
}
else
{
if (selectedUnit != null && selectedUnit.friendly && !selectedUnit.moved)
{
if (touchPosition == selectedUnit.toPosition && selectedUnit.toPosition != selectedUnit.truePosition)
{
selectedUnit.SetDown(true);
}
else if (availableMovePositions.Contains(touchPosition))
{
selectedUnit.MoveTo(touchPosition);
}
else
{
selectedUnit.SetDown(false);
DeselectUnit();
}
//if the selected position is in the players move positions
//move to the location
}
else if (selectedUnit != null && (!selectedUnit.friendly || selectedUnit.moved))
{
selectedUnit.SetDown(false);
DeselectUnit();
}
}
}
}
break;
case STATE.ENEMY_TURN:
if (!IsAnimating())
{
List <UnitBase> availableEnemyUnits = new List <UnitBase>();
foreach (UnitBase unit in boardUnits)
{
if (unit != null && !unit.friendly && !unit.moved)
{
availableEnemyUnits.Add(unit);
}
}
if (availableEnemyUnits.Count > 0)
{
UnitBase enemyUnit = availableEnemyUnits[Random.Range(0, availableEnemyUnits.Count - 1)];
SelectUnit(enemyUnit);
enemyUnit.GetComponent <UnitEnemy>().TryMove();
}
else
{
CycleTurn();
}
}
break;
}
}
}
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
}
private void setUnitPosition(UnitBase unit, Vector2 position)
{
unit.transform.SetParent((grid[position]).transform);
unit.GetComponent<RectTransform>().position = unit.GetComponentInParent<Hex>().transform.position;
}
