Ballistic Trajectory Prediction for Prison Dodgeball: Unity AI Tutorial

Introduction to Ballistic Trajectory Prediction in Unity

In the world of game AI, predicting the path of a projectile to intercept a moving target is a crucial skill. This tutorial focuses on implementing ballistic trajectory prediction for a Prison Dodgeball game, as part of the Cs7632 homework assignment. Whether you're a student working on this assignment or a developer interested in game physics, understanding these concepts will help you create more intelligent and realistic AI opponents.

Ballistic trajectory prediction is used in many modern games, from first-person shooters to sports simulations. The ability to calculate where a thrown object will land and whether it can hit a moving target is essential for AI decision-making. In this tutorial, we'll cover two main approaches: Millington's static target method with iterative refinement, and the Law of Cosines (LoC) method. We'll also discuss shot selection logic, which determines when it's appropriate to throw a dodgeball.

Understanding the Problem: Intercepting a Moving Target

Imagine you're in a game of Prison Dodgeball, and your AI minion needs to throw a ball at an opponent who is running across the field. The ball follows a parabolic trajectory due to gravity, and you need to predict where the opponent will be when the ball arrives. This is a classic intercept problem.

The key challenge is that the target is moving, so you can't just aim at its current position. You need to solve for the time of flight and the launch direction such that the ball and the target meet at the same point in space and time.

Key Variables

ThrowSpeed: The speed at which the minion can throw the ball (e.g., 20 m/s).
Gravity: Typically -9.81 m/s² in the Y direction, but can be zero.
Target Position and Velocity: The opponent's current position and constant velocity.
Launch Point: The position from which the ball is thrown (e.g., the minion's hand).

Method 1: Millington's Static Target Method with Iterative Refinement

This approach first solves the trajectory for a stationary target, then iteratively adjusts for target movement. It's relatively easy to implement and gives good results for targets moving at constant velocity.

Step 1: Solve for a Static Target

Given a stationary target at position targetPos, we can compute the launch direction using the formula for a ballistic trajectory. The time of flight t is found by solving a quadratic equation derived from the projectile motion equations.

// Pseudocode for static targeting
Vector3 delta = targetPos - launchPos;
float a = gravity.magnitude * gravity.magnitude * 0.25f;
float b = -throwSpeed * throwSpeed - Vector3.Dot(delta, gravity);
float c = delta.magnitude * delta.magnitude;
float discriminant = b * b - 4 * a * c;
if (discriminant < 0) return false; // unreachable
float t = Mathf.Sqrt((-b - Mathf.Sqrt(discriminant)) / (2 * a));
Vector3 aimDir = (delta - 0.5f * gravity * t * t) / (throwSpeed * t);

Step 2: Iterative Refinement for Moving Targets

If the target is moving with constant velocity, we can iteratively adjust the aim point. Start with the static solution, compute the target's position at the predicted time of flight, then recalculate using that new position. Repeat until convergence.

// Iterative refinement
Vector3 aimTarget = targetPos;
for (int i = 0; i < 5; i++) {
    // Compute time of flight to aimTarget
    // ... (same as static targeting)
    // Update aimTarget
    aimTarget = targetPos + targetVel * t;
}

This method works well for targets moving at constant velocity and is recommended for this assignment due to its balance of simplicity and accuracy.

Method 2: Law of Cosines (LoC) with 10% Holdback

The Law of Cosines approach uses the geometry of the triangle formed by the launch point, the target's current position, and the intercept point. It's another viable method, though it can be less accurate for fast-moving targets.

Implementation Steps

Calculate the distance from the launcher to the target.
Use the Law of Cosines to find the angle between the launcher-target line and the required launch direction, considering the target's velocity and the throw speed.
Apply a 10% holdback: reduce the predicted intercept time by 10% to account for errors.

// LoC with holdback
float t = distance / throwSpeed; // rough estimate
Vector3 futurePos = targetPos + targetVel * t * 0.9f;
// Then solve for aim direction to futurePos (static targeting)

This method is simpler but may require additional refinement for better accuracy.

Shot Selection Logic: When to Throw

Not every opportunity is a good one. Your AI must decide when to throw based on the context. The ShotSelection.SelectThrow() method should consider:

Constant velocity assumption: If the opponent is clearly breaking constant velocity (e.g., changing direction or accelerating), defer the throw.
Occlusion: If the predicted intercept position is behind an obstacle, the throw will likely miss.
Reachability: Use the trajectory prediction to determine if the target is reachable.

Example Logic

bool ShouldThrow(OpponentInfo opponent) {
    // Check if opponent velocity is constant
    if (Vector3.Distance(opponent.Vel, opponent.PrevVel) > threshold) return false;
    // Predict intercept position
    if (!PredictThrow(opponent.Pos, opponent.Vel, out Vector3 interceptPos)) return false;
    // Check occlusion
    if (IsOccluded(interceptPos)) return false;
    return true;
}

Testing Your Implementation

The assignment provides test scenes: ShootingRange for isolated trajectory tests, and AdvancedMinionTestThrowScenario for combined trajectory and shot selection tests. Your code will be evaluated on accuracy and shots per minute.

Common Pitfalls

Not accounting for gravity direction (always down in -Y).
Ignoring the minion's throw speed and launch position (use HeldBallPosition).
Failing to handle unreachable targets (return false correctly).

Connecting to Real-World Trends

Ballistic prediction is not just for games. In AI-powered robotics, similar algorithms are used for catching objects or intercepting drones. In sports analytics, predicting the trajectory of a basketball or soccer ball helps coaches and players make better decisions. Even in fintech, trajectory optimization concepts are applied to portfolio management and risk assessment.

As we approach the 2026 FIFA World Cup, imagine a robot goalkeeper that uses ballistic prediction to intercept a penalty kick. The same principles you learn here could be applied to real-world AI systems.

Conclusion

Implementing ballistic trajectory prediction and shot selection in Unity is a rewarding challenge that builds your game AI skills. Start with Millington's method plus iterative refinement for a solid balance of simplicity and performance. Remember to test thoroughly with the provided scenes and pay attention to edge cases like extreme speeds or elevations.

By mastering these techniques, you'll be well-prepared for Homework 6 and beyond. Good luck, and may your dodgeballs always find their mark!