CitizenExample

public class CitizenAI : MonoBehaviour {

    public Transform _myTransform;
    public Transform workLocation;
    public Transform target;
    public float idleTime;

    public enum State{
        Hungry,
        LookingForWork,
        Working,
        BringingRessourcesToWork,
        Hunting,
        Idle,
        Waiting,
        //Many more states but you get the idea
    };

    private float speed;
    private float idleTimer;

    void Update()
        {
        //Run any movement code that hasn't ran this frame
                MoveTorwards();

        switch (state){
        //There's a case for every possible State, only listing relevant one here
        //When entering a state, a villager should not have a target

        //Villager just picked up resources from a storage barn and is bringing them
        //to his workplace.
        case State.BringingRessourcesToWork:
                        if(!target) //If there is no destination, acquire one.
                        {
                                target = workLocation;
                //Make a call to StartPath only once
                                seeker.StartPath(_myTransform.position, target.position, OnPathComplete);
                                currentStateString = "Bringing needed ressources to work.";
                        }//villager has a valid target, only check if within range

            //Here I check to see if the unit is within range of his destination
            //I could probably check if the waypoint is path.vectorPath[path.vectorPath.Length - 1]
                        if(SquareDistance (_myTransform.position, target.position) < 4.5f)
                        {
                                dropRessoucesAtWork(); //drop work related resources
                                target = null; //clear the destination reference
                                state = assesNeeds(); //get a new state
                        }//end if distance is short enough
                break;

        //Here is another case where I perdiodically need to refresh the path.
        case State.HuntingAnimal:
                        if(!target){ //Same principle as above, acquire a target and call StartPath
                                target = workLocation.parent.GetComponent<HunterScript>().getNextTarget();
                                if(target){
                                        seeker.StartPath (_myTransform.position, target.position, OnPathComplete);
                                        idleTimer = 8.0f; //Here I set a timer at 8 seconds
                                        currentStateString = "Hunting";
                                }
                else{
                    state = assessNeeds();
                    return;
                }
                        }

                        idleTimer -= Time.deltaTime; //Every frame deduct deltaTime from the timer
                        if(idleTimer <= 0){//Once the timer reaches 0 recall StartPath (the deer might have moved)
                                seeker.StartPath (_myTransform.position, target.position, OnPathComplete);
                                idleTimer = 8.0f;
                        }

            //if we're within a certain distance of the deer, do stuff
                        if(SquareDistance (_myTransform.position, target.position) < 500){
                                path = null;
                                target.GetComponent<DeerAI>().MarkForDeath();
                //The code below simply sets the AI not to do anything for 3 seconds and play an archery animation
                                idleTimer = 3.0f;
                                state = State.Waiting;
                                playArcheryAnim();
                                lastState = State.GoingForKill;
                                idleTimer = idleTime;
                        }
                break;

        }//end switch (state)
    }//end update

    private void MoveTorwards(){
        if (path == null) {
                    return;
            }

            if (currentWaypoint >= path.vectorPath.Count) {
                    //End of path reached
                        path = null;
                    return;
            }
                if(!bentDown){
                    playWalkCycle();
                }

                _myTransform.position = Vector3.Slerp (_myTransform.position, path.vectorPath[currentWaypoint],
                        speed * Time.deltaTime);

            //Check if we are close enough to the next waypoint
            //If we are, proceed to follow the next waypoint
            if (SquareDistance(_myTransform.position,path.vectorPath[currentWaypoint]) < 4) {
                    currentWaypoint++;
                        if (currentWaypoint < path.vectorPath.Count) {
                                Vector3 lookDirection = path.vectorPath[currentWaypoint];
                                lookDirection.y = this._myTransform.position.y;
                                transform.LookAt(lookDirection);
                        }
                    return;
            }
    }

    private float SquareDistance(Vector3 a, Vector3 b){
                Vector3 diff = b - a;
                return diff.sqrMagnitude;
        }
}