This is what I came up with for the challenge solution (though I missed adding the Cancel() the first time 'round). Really liked this challenge! Let me know if this code would come up with anything odd, or if I’ve messed things up for future lectures.
using RPGTutorial.Movement;
using RPGTutorial.Combat;
namespace RPGTutorial.Control
{
[RequireComponent(typeof(Fighter))]
[RequireComponent(typeof(Mover))]
public class AIController : MonoBehaviour
{
[SerializeField] float chaseDistance = 10f;
GameObject player;
Mover mover;
Fighter fighter;
/// <summary>
/// Here, we are caching references to things we are going to use multiple times in the class. "Player", Mover, and Fighter are referenced more than once,
/// and so it's generally a very good idea to make a reference to them rather than getting their components every time.
///
/// Others' tips: "In this case, it’s ok to cache the Player in Start(), but there are situations where it’s imperative that you cache an external reference in Awake()
/// to avoid a race condition with the Saving System (future lecture). It’s generally safe to cache the reference in Awake() but it’s seldom safe to actually access
/// the reference in Awake()."
/// </summary>
private void Awake()
{
mover = GetComponent<Mover>();
fighter = GetComponent<Fighter>();
player = GameObject.FindWithTag("Player");
}
/// <summary>
/// Checks to see if the player does not exist, and if so, exits Update before doing anything else.
/// Then, if the AI is busy in combat, it exits Update before checking if it is chasing the player.
/// Finally, if the AI is busy chasing the player, it exits Update and checks it all again.
/// This makes sure that the AI does not worry about chasing if it is in combat, or about combat if it is chasing.
/// It's important that it checks if it's in combat first, otherwise it would never check to see if the AI is in
/// combat, since it's exiting Update if it's busy chasing.
/// The same types of bools are in the PlayerController for the same reasons.
/// </summary>
private void Update()
{
if (player == null) { return; }
if (IsBusyInCombat()) { return; }
if (IsBusyChasing()) { return; }
}
/// <summary>
/// Just like in the PlayerController, we want to make sure the AI isn't trying to move while it's in combat and vice versa.
/// First we see if the distance between the AI's position and the player's position in world space is less than or equal to the
/// AI's chasingDistance variable. If it is in chasing distance of the player, we check to see if the AI can attack the player or not.
/// If both are true, we tell the Fighter to allow the AI to attack the player, and return this bool true. The moment either of these two
/// statements (in chasing distance or can attack) are false, we tell the Fighter to cancel the attack and return false.
/// </summary>
bool IsBusyInCombat()
{
if (GetIsInChasingDistance() && fighter.CanAttack(player))
{
fighter.Attack(player);
return true;
}
else
{
fighter.Cancel();
return false;
}
}
/// <summary>
/// Much like in the PlayerController's InteractWithMovement bool, this checks to see if the AI is within chasing distance of the player, and
/// if the player is not null, we tell the Mover to start a move action, setting the AI's destination to the player's position in world space.
/// We then set the bool to true. Otherwise, we tell the mover to cancel the move action and return the bool false.
/// </summary>
bool IsBusyChasing()
{
if (GetIsInChasingDistance() && player != null)
{
mover.StartMoveAction(player.transform.position);
return true;
}
else
{
mover.Cancel();
return false;
}
}
/// <summary>
/// Pretty self-explanatory, but this bool returns true only if the distance between the AI's position and the player's position are less than or equal to
/// the AI's chasing distance.
/// </summary>
private bool GetIsInChasingDistance()
{
float distanceToPlayer = Vector3.Distance(transform.position, player.transform.position);
return distanceToPlayer <= chaseDistance;
}
}
}