// Start is called before the first frame update
private void Awake()
{
enemyLocomotionManager = GetComponent <EnemyLocomotionManager>();
enemyAnimatorManager = GetComponentInChildren <EnemyAnimatorManager>();
enemyFXManager = GetComponentInChildren <EnemyFXManager>();
enemyStats = GetComponent <EnemyStats>();
enemyRigidbody = GetComponent <Rigidbody>();
//backStabCollider = GetComponentInChildren<DeathblowsCollider>();
navMeshAgent = GetComponentInChildren <NavMeshAgent>();
navMeshAgent.enabled = false;
}
public override State Tick(EnemyManager enemyManager, EnemyStats enemyStats, EnemyAnimatorManager enemyAnimatorManager)
{
Vector3 targetDirection = enemyManager.currentTarget.transform.position - enemyManager.transform.position;
float distanceFromTarget = Vector3.Distance(enemyManager.currentTarget.transform.position, enemyManager.transform.position);
float viewableAngle = Vector3.SignedAngle(targetDirection, enemyManager.transform.forward, Vector3.up);
HandleRotateTowardsTarget(enemyManager);
/*if (viewableAngle > 65 || viewableAngle < -65)
* return lookForTargetState;*/
if (enemyManager.isInteracting)
{
return(this);
}
if (enemyManager.isPerformingAction)
{
enemyAnimatorManager.anim.SetFloat("Vertical", 0, 0.1f, Time.deltaTime);
return(this);
}
if (distanceFromTarget > enemyManager.maximumAttackRange)
{
if (gameObject.tag == "Boss")
{
enemyAnimatorManager.anim.SetFloat("Vertical", 0.4f, 0.1f, Time.deltaTime);
}
else if (gameObject.tag == "Slow Mob")
{
enemyAnimatorManager.anim.SetFloat("Vertical", 0.6f, 0.1f, Time.deltaTime);
}
else
{
enemyAnimatorManager.anim.SetFloat("Vertical", 1, 0.1f, Time.deltaTime);
}
//if performing some action , stop all movement on the pursuit state
}
if (distanceFromTarget <= enemyManager.maximumAttackRange)
{
return(combatStanceState);
}
else
{
return(this);
}
}
public override State Tick(EnemyManager enemyManager, EnemyStats enemyStats, EnemyAnimatorManager enemyAnimatorManager)
{
if (isSleeping && enemyManager.isInteracting == false)
{
enemyAnimatorManager.PlayTargetAnimation(sleepAnimation, true);
}
#region Handle Target Detection
Collider[] colliders = Physics.OverlapSphere(enemyManager.transform.position, detectionRadius, detectionLayer);
for (int i = 0; i < colliders.Length; i++)
{
//search all colliders finds for a player manager variable
CharacterStats characterStats = colliders[i].transform.GetComponent <CharacterStats>();
//if its finds it , continue the logic
if (characterStats != null)
{
Vector3 targetDirection = characterStats.transform.position - enemyManager.transform.position;
float viewableAngle = Vector3.Angle(targetDirection, enemyManager.transform.forward);
if (viewableAngle > enemyManager.minimumDetectionAngle && viewableAngle < enemyManager.maximumDetectionAngle)
{
enemyManager.currentTarget = characterStats;
isSleeping = false;
enemyAnimatorManager.PlayTargetAnimation(wakeAnimation, true);
}
}
}
#endregion
#region Handle State Change
if (enemyManager.currentTarget != null)
{
return(pursueTargetState);
}
else
{
return(this);
}
#endregion
}
public override State Tick(EnemyManager enemyManager, EnemyStats enemyStats, EnemyAnimatorManager enemyAnimatorManager)
{
if (enemyManager.isInteracting)
{
return(this);
}
if (playerManager.isUsingRightHand)
{
int ran = Random.Range(0, 100);
if (ran < 90)
{
enemyAnimatorManager.PlayTargetAnimation("Rolling", true);
}
}
// Check for attack range
//walk around target
float distanceFromTarget = Vector3.Distance(enemyManager.currentTarget.transform.position, enemyManager.transform.position);
Debug.Log(distanceFromTarget);
HandleRotateTowardsTarget(enemyManager);
if (enemyManager.isPerformingAction)
{
//after atk return to combat state
enemyAnimatorManager.anim.SetFloat("Vertical", 0, 0.1f, Time.deltaTime);
}
if (enemyManager.currentRecoveryTime <= 0 && distanceFromTarget <= enemyManager.maximumAttackRange)
{
return(attackState);
// if still in the atk range , return atk state
}
else if (distanceFromTarget > enemyManager.maximumAttackRange)
{
return(pursueTargetState);
//in cooldown attacking , return this state and continue focus player
}
else
{
return(this);
//fail safe
}
}
private void Awake()
{
enemyManager = GetComponentInParent <EnemyManager>();
enemyStats = GetComponentInParent <EnemyStats>();
enemyAnimator = GetComponent <EnemyAnimatorManager>();
WeaponHolderSlot[] weaponHolderSlots = GetComponentsInChildren <WeaponHolderSlot>();
foreach (WeaponHolderSlot weaponSlot in weaponHolderSlots)
{
if (weaponSlot.isLeftHandSlot)
{
leftHandSlot = weaponSlot;
}
else if (weaponSlot.isRightHandSlot)
{
rightHandSlot = weaponSlot;
}
}
}
public override State Tick(EnemyManager enemyManager, EnemyStats enemyStats, EnemyAnimatorManager enemyAnimatorManager)
{
enemyAnimatorManager.anim.SetFloat("Vertical", 0);
enemyAnimatorManager.anim.SetFloat("Horizontal", 0);
Vector3 targetDirection = enemyManager.currentTarget.transform.position - enemyManager.transform.position;
float viewableAngle = Vector3.SignedAngle(targetDirection, enemyManager.transform.forward, Vector3.up);
if (enemyManager.isInteracting)
{
return(this); // when we enter the state we will still be interacting from the attack animation so we pause here until it has finished
}
//these if conditions values can tune up
if (viewableAngle >= 100 && viewableAngle <= 180 && !enemyManager.isInteracting)
{
enemyAnimatorManager.PlayTargetAnimationWithRootRotation("Turn Behind", true);
Debug.Log("Turn 180");
return(combatStanceState);
}
else if (viewableAngle <= -101 && viewableAngle >= -180 && !enemyManager.isInteracting)
{
enemyAnimatorManager.PlayTargetAnimationWithRootRotation("Turn Behind", true);
Debug.Log("Turn 180");
return(combatStanceState);
}
else if (viewableAngle <= -45 && viewableAngle >= -100 && !enemyManager.isInteracting)
{
enemyAnimatorManager.PlayTargetAnimationWithRootRotation("Turn Right", true);
Debug.Log("Turn Right");
return(combatStanceState);
}
else if (viewableAngle >= 45 && viewableAngle <= 100 && !enemyManager.isInteracting)
{
enemyAnimatorManager.PlayTargetAnimationWithRootRotation("Turn Left", true);
Debug.Log("Turn Left");
return(combatStanceState);
}
return(combatStanceState);
}
public override State Tick(EnemyManager enemyManager, EnemyStats enemyStats, EnemyAnimatorManager enemyAnimatorManager)
{
// Look for target
#region Target Detection
Collider[] colliders = Physics.OverlapSphere(transform.position, enemyManager.detectionRadius, detectionLayer);
for (int i = 0; i < colliders.Length; i++)
{
CharacterStats characterStats = colliders[i].transform.GetComponent <CharacterStats>();
if (characterStats != null)
{
//check ID
Vector3 targetDirection = characterStats.transform.position - transform.position;
float viewableAngle = Vector3.Angle(targetDirection, transform.forward);
if (viewableAngle > enemyManager.minimumDetectionAngle && viewableAngle < enemyManager.maximumDetectionAngle)
{
enemyManager.currentTarget = characterStats;
}
}
}
#endregion
#region Switch State
if (enemyManager.currentTarget != null)
{
//Switch state when found the target
return(pursueTargetState);
}
else
{
//if not , return to this state
return(this);
}
#endregion
}
private void Awake()
{
enemyStats = GetComponentInParent <EnemyStats>();
enemyManager = GetComponentInParent <EnemyManager>();
weaponSlotManager = GetComponent <WeaponSlotManager>();
}
private void Awake()
{
//bossHealthBar = FindObjectOfType<UIBossHealthBar>();
ui = FindObjectOfType <UIManager>();
enemyStats = GetComponent <EnemyStats>();
}
private void OnTriggerEnter(Collider collision)
{
if (collision.tag == "Player")
{
PlayerStats playerStats = collision.GetComponent <PlayerStats>();
CharacterManager enemyCharacterManager = collision.GetComponent <CharacterManager>();
BlockingCollider shield = collision.transform.GetComponentInChildren <BlockingCollider>();
if (enemyCharacterManager != null)
{
if (enemyCharacterManager.isParrying)
{
// play animation
characterManager.GetComponentInChildren <AnimatorManager>().PlayTargetAnimation("Parried", true);
return;
}
else if (shield != null && enemyCharacterManager.isBlocking)
{
float physicalDamageAfterBlock =
currentWeaponDamage - (currentWeaponDamage * shield.blockingPhysicalDamageAbsorption) / 100;
if (playerStats != null)
{
playerStats.TakeDamage(Mathf.RoundToInt(physicalDamageAfterBlock), "Block Guard");
return;
}
}
}
if (playerStats != null)
{
playerStats.TakeDamage(currentWeaponDamage);
}
}
if (collision.tag == "Enemy")
{
EnemyStats enemyStats = collision.GetComponent <EnemyStats>();
CharacterManager enemyCharacterManager = collision.GetComponent <CharacterManager>();
BlockingCollider shield = collision.transform.GetComponentInChildren <BlockingCollider>();
if (enemyCharacterManager != null)
{
if (enemyCharacterManager.isParrying)
{
// play animation
characterManager.GetComponentInChildren <EnemyAnimatorManager>().PlayTargetAnimation("Parried", true);
return;
}
else if (shield != null && enemyCharacterManager.isBlocking)
{
float physicalDamageAfterBlock =
currentWeaponDamage - (currentWeaponDamage * shield.blockingPhysicalDamageAbsorption) / 100;
if (enemyStats != null)
{
enemyStats.TakeDamage(Mathf.RoundToInt(physicalDamageAfterBlock), "Block Guard");
return;
}
}
}
if (enemyStats != null)
{
enemyStats.TakeDamage(currentWeaponDamage);
}
}
if (collision.tag == "Hidden Wall")
{
HiddenWall hiddenWall = collision.GetComponent <HiddenWall>();
hiddenWall.wallHasBeenHit = true;
}
}
private void Awake()
{
anim = GetComponent <Animator>();
enemyManager = GetComponentInParent <EnemyManager>();
enemyStats = GetComponentInParent <EnemyStats>();
}
public override State Tick(EnemyManager enemyManager, EnemyStats enemyStats, EnemyAnimatorManager enemyAnimatorManager)
{
Vector3 targetDirection = enemyManager.currentTarget.transform.position - enemyManager.transform.position;
float distanceFromTarget = Vector3.Distance(enemyManager.currentTarget.transform.position, enemyManager.transform.position);
float viewableAngle = Vector3.Angle(targetDirection, enemyManager.transform.forward);
phaseLimit = enemyStats.MaxHealth / 2;
HandleRotateTowardsTarget(enemyManager);
if (enemyManager.isInteracting && enemyManager.canDoCombo == false)
{
return(this);
}
else if (enemyManager.isInteracting && enemyManager.canDoCombo)
{
if (comboOnNextAttack)
{
comboOnNextAttack = false;
//CUSTOM
if (enemyManager.currentAttack.usingWeapon)
{
enemyAnimatorManager.anim.SetBool("isUsingWeapon", true);
}
if (!enemyManager.currentAttack.isLeft)
{
enemyAnimatorManager.anim.SetBool("isUsingRightHand", true);
}
else if (enemyManager.currentAttack.isLeft)
{
enemyAnimatorManager.anim.SetBool("isUsingLeftHand", true);
}
//
enemyAnimatorManager.PlayTargetAnimation(enemyManager.currentAttack.actionAnimation, true);
}
}
if (enemyManager.isPerformingAction)
{
return(lookForTargetState);
}
if (gameObject.tag == "Enemy")
{
if (enemyStats.CurrentHealth < phaseLimit && rageCount < 1)
{
enemyAnimatorManager.PlayTargetAnimation("Rage", true);
enemyStats.RestoreHP(phaseLimit / 2);
rageCount++;
}
}
if (enemyManager.currentAttack != null)
{
//CUSTOM
if (enemyManager.currentAttack.usingWeapon)
{
enemyAnimatorManager.anim.SetBool("isUsingWeapon", true);
}
if (!enemyManager.currentAttack.isLeft)
{
enemyAnimatorManager.anim.SetBool("isUsingRightHand", true);
}
else if (enemyManager.currentAttack.isLeft)
{
enemyAnimatorManager.anim.SetBool("isUsingLeftHand", true);
}
//
//if we are too close to the enemy to perform current attack , get a new attack
if (distanceFromTarget < enemyManager.currentAttack.minimumDistanceNeededToAttack)
{
return(this);
}
//if we are close enough to attack , then proceed
else if (distanceFromTarget < enemyManager.currentAttack.maximumDistanceNeededToAttack)
{
//if our enemy is within our attacks viewable angle, we attack
if (viewableAngle <= enemyManager.currentAttack.maximumAttackAngle && viewableAngle >= enemyManager.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(enemyManager.currentAttack.actionAnimation, true);
enemyManager.isPerformingAction = true;
RollForComboChance(enemyManager);
if (enemyManager.currentAttack.canDoCombo && comboOnNextAttack)
{
enemyManager.currentAttack = enemyManager.currentAttack.comboAction;
return(this);
}
else
{
enemyManager.currentRecoveryTime = enemyManager.currentAttack.recoveryTime;
enemyManager.currentAttack = null;
return(lookForTargetState);
}
}
}
}
}
else if (enemyManager.currentMagicAttack != null)
{
if (distanceFromTarget < enemyManager.currentMagicAttack.maximumDistanceNeededToAttack)
{
//if our enemy is within our attacks viewable angle, we attack
if (viewableAngle <= enemyManager.currentMagicAttack.maximumAttackAngle && viewableAngle >= enemyManager.currentMagicAttack.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);
enemyManager.currentMagicAttack.AttemptToCastSpell(enemyAnimatorManager);
enemyManager.isPerformingAction = true;
enemyManager.currentRecoveryTime = enemyManager.currentMagicAttack.recoveryTime;
//enemyManager.currentMagicAttack = null;
return(lookForTargetState);
}
else if (enemyManager.currentRecoveryTime > 0 && distanceFromTarget <= enemyManager.maximumAttackRange)
{
return(lookForTargetState);
}
}
}
}
else
{
GetNewAttack(enemyManager);
}
return(lookForTargetState);
}
public abstract State Tick(EnemyManager enemyManager, EnemyStats enemyStats, EnemyAnimatorManager enemyAnimatorManager);