AI

Some in-built support for writing game AIs is given in the engine. The AITaskComponent (code) can be given a list of priority tasks. Every frame, it calculates the priority of each task, and runs the highest priority one. A task should be able to be started and stopped at any time, and can succeed, fail, or run forever. The power of this task-based system is that a task can be made up of smaller sub-tasks.

For example, the ghost enemy AI has the following tasks:

• WanderTask with constant priority 1.
• ChaseTask with a low priority if the player is not visible, but a high priority if the player is visible.
• AvoidTask with a low priority if an entity is not visible, but a high priority if the player is visible.
• PauseTask with a low priority if the player is not visible, but a high priority if the player is visible.

This allows an entity to chase the player only while they are in line of sight, avoid an entity if they are in the line of sight or pause when a player is in the line of sight. The wander task is made up of two smaller tasks:

• MoveTask to move to a random location.
• WaitTask to wait for a bit before moving again.

Note that these tasks do not need priorities, since they are run repeatedly in a sequence inside the wander task. MoveTask is also used inside of ChaseTask to let the ghost move towards the player. By splitting the AI's actions into smaller tasks, we can reuse the same code in multiple places!

Overview of Added Tasks (PauseTask and AvoidTask)

Package: com.csse3200.game.components.tasks

This package contains task components that define specific behaviours for entities in the game. Tasks in this package extend from the base ChaseTask class, adding specialised functionality such as pausing near a target or avoiding a target entity.

PauseTask

The PauseTask class allows an entity to pause near a target entity until the target moves too far away or out of sight. This class extends the ChaseTask to include pausing behaviour.

Methods

• start(): Initialises the pause behaviour and triggers the pause event.
• update(): Continuously checks the distance to the target entity, determining whether to approach, pause, or end the pause state.
• getPriority(): Returns the priority level of the pause behaviour, depending on whether the task is active or inactive.
• getActivePriority(): Returns the priority when the behaviour is active. If the distance to the target is greater than the view distance or the target is not visible, the task stops.
• getInactivePriority(): Returns the priority when the behaviour is inactive. If the distance to the target is less than the view distance and the target is visible, the task activates.

AvoidTask

The AvoidTask class enables an entity to move away from a target entity until a safe distance is reached or the line of sight is lost. This class extends the ChaseTask but reverses the behaviour to avoid rather than chase.

Methods

• start(): Begins the avoidance behaviour by initialising the movement task and triggering the "avoidStart" event.
• update(): Updates the avoidance behaviour by adjusting the movement target and restarting the task if necessary.
• getPriority(): Determines the priority level of the avoidance behaviour, based on whether the task is active or inactive.
• getActivePriority(): Returns the priority when avoidance is active. The task stops if the safe distance is reached or the target is no longer visible.
• getInactivePriority(): Returns the priority when avoidance is inactive. The task activates if the target is within the safe distance and is visible.
• getAvoidanceTarget(): Calculates the target position for avoidance based on the entity's current position, the target's position, and the minimum avoidance distance.

Usage

Using the AI task component is as simple as attaching it to an entity and giving it the priority tasks you want it to run. It will always run the highest priority one available. For example:

public Entity createEnemy() {
  AITaskComponent aiComponent = new AITaskComponent()
    .addTask(new WanderTask(new Vector2(2f, 2f), 2f))); // Vector area to wander in 
    .addTask(new ChaseTask(player)); // Entity in which to chase
    .addTask(new PauseTask(target, 10, 2f, 1f)); // entity to Target, Priority, viewDistance, maxPauseDistance
    .addTask(new AvoidTask(target, 10, 2f, 1f)); // entity to Target, Priority, viewDistance, minAvoidDistance
  return new Entity()
    .addComponent(aiComponent);
}

Pathfinding and Movement

The provided AI code is deliberately basic in terms of movement. Enemies run straight towards the player, ignoring obstacles in their way. If your game requires more complicated movement, refer to the relevant parts of Further Reading. Implementing a full pathfinding algorithm like A* is a challenging undertaking since the game uses physics and is not grid-based.

Behind the Scenes

Why not just use a Finite State Machine (FSM)?

FSMs can be great for modelling basic game AI, and are a common application of the state pattern in game development. Depending on how complex your AI becomes, you can quickly reach the limits of what FSMs can do. Key limitations here are:

• States are very highly coupled to each other since each state contains exit logic to other states. This makes it very hard to reuse parts of the AI across different entities.
• It's difficult to nest states without creating multiple FSMs inside each other. This also makes it difficult to break one state down into multiple smaller states, reducing reusability.

What about behaviour trees?

Behaviour trees are a very powerful and commonly used system for programming game AI. Feel free to implement these in your game if desired, but they have been left out of the base implementation due to their complexity.

Further Reading

• For collision avoidance and other steering behaviours: http://www.red3d.com/cwr/steer/
• For pathfinding, look into algorithms for generating a navigation mesh or navigation grid.
• The entire Programming Game AI By Example book is recommended if you're interested in game AI.