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; }