public override State Tick(EnemyManager enemyManager, EnemyStats stats, EnemyAnimatorHandler animatorHandler)
{
Vector3 targetDirection = enemyManager.currentTarget.transform.position - enemyManager.transform.position;
float viewableAngle = Vector3.Angle(targetDirection, transform.forward);
if (currentAttack != null)
{
if (enemyManager.distanceFromTarget < currentAttack.distanceNeededToAttack.min)
{
return(this);
}
else if (enemyManager.distanceFromTarget < currentAttack.distanceNeededToAttack.max)
{
if (enemyManager.viewableAngle <= currentAttack.attackAngle * 0.5f)
{
if (enemyManager.currentRecoveryTime <= 0f && !enemyManager.isPerformingAction)
{
animatorHandler.anim.SetFloat(AnimatorHandler.hashVertical, 0f, 0.1f, Time.deltaTime);
animatorHandler.anim.SetFloat(AnimatorHandler.hashHorizontal, 0f, 0.1f, Time.deltaTime);
animatorHandler.PlayTargetAnimation(currentAttack.actionAnimation, true);
enemyManager.isPerformingAction = true;
enemyManager.currentRecoveryTime = currentAttack.recoveryTime;
currentAttack = null;
return(combatStanceState);
}
}
}
}
else
{
GetNewAttack(enemyManager);
}
return(combatStanceState);
}
public override State Tick(Enemy_Manager enemyManager, Enemy_Stats enemyStats, EnemyAnimatorManager enemyAnimatorManager)
{
Vector3 targetDirection = enemyManager.currentTarget.transform.position - transform.position;
float viewableAngle = Vector3.Angle(targetDirection, transform.forward);
float distanceFromTarget = Vector3.Distance(enemyManager.currentTarget.transform.position, enemyManager.transform.position);
HandleRotationTowardsTarget(enemyManager);
//select one of our many attacks
//if the selected attack is not able to be used because of bad angle or distance, select a new attack
//if the attack is viable, stop our movement and attack the target
//set our recovery timer to the attacks recovery time
//return to the combat stance state
#region Attacks
if (enemyManager.isPerformingAction)
{
return(combatStanceState);
}
if (currentAttack != null)
{
//if too close, get new attack
if (distanceFromTarget < currentAttack.minimumDistanceNeededToAttack)
{
return(this);
}
//if we are close enough to atack, then let us proceed
else if (distanceFromTarget < currentAttack.maximumDistanceNeededToAttack)
{
//if our enemy is within our attacks viewable angle, we attack
if (viewableAngle <= currentAttack.maximumAttackAngle &&
viewableAngle >= currentAttack.minimumAttackAngle)
{
if (enemyManager.currentRecoveryTime <= 0 && enemyManager.isPerformingAction == false)
{
enemyAnimatorManager.anim.SetFloat("Vertical", 0, 0.1f, Time.deltaTime);
enemyAnimatorManager.anim.SetFloat("Horizontal", 0, 0.1f, Time.deltaTime);
enemyAnimatorManager.PlayTargetAnimation(currentAttack.actionAnimation, true);
enemyManager.isPerformingAction = true;
enemyManager.currentRecoveryTime = currentAttack.recoveryTime;
currentAttack = null;
return(combatStanceState);
}
}
}
}
else
{
GetNewAttack(enemyManager);
}
return(combatStanceState);
}
private void GetNewAttack(Enemy_Manager enemyManager)
{
Vector3 targetsDirection = enemyManager.currentTarget.transform.position - transform.position;
float viewableAngle = Vector3.Angle(targetsDirection, transform.forward);
float distanceFromTarget = Vector3.Distance(enemyManager.currentTarget.transform.position, transform.position);
//Debug.Log("Distance from target currently is: " + distanceFromTarget);
int maxScore = 0;
for (int i = 0; i < enemyAttacks.Length; i++)
{
EnemyAttackAction enemyAttackAction = enemyAttacks[i];
if (distanceFromTarget <= enemyAttackAction.maximumDistanceNeededToAttack &&
distanceFromTarget >= enemyAttackAction.minimumDistanceNeededToAttack)
{
//Debug.Log("Enemy in Distance!");
if (viewableAngle <= enemyAttackAction.maximumAttackAngle &&
viewableAngle >= enemyAttackAction.minimumAttackAngle)
{
//Debug.Log("Grabbed Max Score!");
maxScore += enemyAttackAction.attackScore;
}
}
}
int randomValue = Random.Range(0, maxScore);
int temporaryScore = 0;
for (int i = 0; i < enemyAttacks.Length; i++)
{
EnemyAttackAction enemyAttackAction = enemyAttacks[i];
if (distanceFromTarget <= enemyAttackAction.maximumDistanceNeededToAttack &&
distanceFromTarget >= enemyAttackAction.minimumDistanceNeededToAttack)
{
if (viewableAngle <= enemyAttackAction.maximumAttackAngle &&
viewableAngle >= enemyAttackAction.minimumAttackAngle)
{
if (currentAttack != null)
{
return;
}
temporaryScore += enemyAttackAction.attackScore;
if (temporaryScore > randomValue)
{
currentAttack = enemyAttackAction;
}
}
}
}
}
private void GetNewAttack(EnemyManager enemyManager)
{
Vector3 targetsDirection = enemyManager.currentTarget.transform.position - transform.position;
float viewableAngle = Vector3.Angle(targetsDirection, transform.forward);
enemyManager.distanceFromTarget = targetsDirection.magnitude;
List <EnemyAttackAction> possibleAttacks = new List <EnemyAttackAction>(attacks.Length);
int maxScore = 0;
foreach (var attackAction in attacks)
{
if (attackAction.distanceNeededToAttack.IsInRange(enemyManager.distanceFromTarget))
{
if (viewableAngle <= attackAction.attackAngle * 0.5f)
{
maxScore += attackAction.attackScore;
possibleAttacks.Add(attackAction);
}
}
}
int random = Random.Range(0, maxScore);
int tempScore = 0;
foreach (var attackAction in possibleAttacks)
{
if (currentAttack != null)
{
return;
}
tempScore += attackAction.attackScore;
if (tempScore > random)
{
currentAttack = attackAction;
}
}
}
