AceForce2:AI Tactical Grenade Usage System

Platform:

Mobile

Tools Used:

Unreal Engine, Lua

Overview

During early development of the AI positioning system, several limitations were identified in the existing behavior tree and data support. The current AI logic lacked sufficient utility nodes, reusable behavior tasks, and reliable heatmap data to guide tactical positioning. As a result, the AI often relied on overly simplified logic and struggled to select meaningful combat positions.

To address these issues, the system was redesigned to incorporate improved behavior tree structures, heatmap-driven positioning logic, and fallback location mechanisms. These changes aim to provide the AI with more reliable tactical decision-making while ensuring stable behavior even when ideal positioning data is unavailable.

Design Approach

To better understand how throwable mechanics function in actual gameplay, I first deconstructed the player’s throwable behavior within the current game system.

Through analysis, the entire throwing behavior can be broken down into three core modules:

Input
Jump Height
Character State

These three modules together cover all possible throwable scenarios in gameplay. By combining different inputs and character states, the system naturally supports various throwing behaviors such as running throws, crouch throws, and jump throws.

By structuring the system in this modular way, it becomes easier to analyze player behavior patterns and reconstruct them within AI logic. This approach also provides a clearer framework for designing AI behaviors that mimic real player throwable usage under different combat conditions.

System Refactoring

The next step was to refactor the existing nodes in order to better support the AI behavior tree.

Based on the earlier decomposition of player throwable behavior, the system was reorganized into a set of configurable variables. These variables represent key factors such as input conditions, jump height, and character state.

By converting the original behavior logic into parameterized variables, the system could be directly integrated into the behavior tree structure. This allows different throwable behaviors—such as running throws, crouch throws, or jump throws—to be configured through behavior tree parameters rather than requiring separate hard-coded implementations.

This refactoring significantly improves the flexibility of the system and makes it easier to extend or adjust AI throwable behaviors during later development.

Next Design Step

After enabling the AI to use throwables, the next problem was determining where the AI should throw them.

In the NF project, there was already a heatmap system intended to generate throwable target locations and landing points based on player match data. In theory, this system could serve as the foundation for AI throwable decision-making. However, during implementation, two major problems became clear:

The project was still in an early stage, so there was not enough throwable-related gameplay data available.
The reported data types were too limited.
The current system could only record:
- the position where the player threw the throwable
- the type of throwable used
But it could not capture how the throwable was used, such as:
- whether it was a standing throw, running throw, crouch throw, or jump throw
- the contextual purpose of the throw
- the relationship between throw origin, target area, and combat situation

Because of this, the existing heatmap data was not sufficient to directly support believable AI throwable behavior.

Design Response

To solve this problem, the first step was to improve the heatmap reporting structure so that it could collect more meaningful throwable behavior data.

At the same time, I also considered the case where the heatmap system would not yet be usable.
In that situation, the AI still needed a fallback solution to ensure stable behavior.

So, in parallel with heatmap optimization, I planned a set of basic manually configured throwable behaviors, such as:

throwing toward bomb sites
throwing toward common choke points or intersections
using simple predefined target areas as default tactical throw locations

This ensured that even before enough player data had been accumulated, the AI could still perform functional and tactically understandable throwable actions.

System Completion

At the time, the AI system in the project only supported the basic ability to throw a throwable item, but lacked the surrounding data and behavioral context required for more realistic usage.

To address this, the heatmap reporting system needed to be expanded. Additional data related to AI throwable behavior was introduced, such as the character state when a throwable is used.

In FPS games, AI character animation and behavior are often handled with separate upper-body and lower-body logic. Because of this, throwable-related actions also needed to be decomposed into multiple states. These states were then mapped to behavior tree variables, ensuring that the AI could correctly perform throwable actions under different movement and posture conditions.

After establishing where to throw and how to throw, the final step was determining when the AI should use throwables.

To solve this, I analyzed typical player behavior in regular matches and decomposed common throwable usage scenarios. Based on this analysis, a set of behavior rules was configured to guide AI decision-making for throwable timing.

This approach allowed the AI throwable system to be structured around three core questions:

Where to throw
How to throw
When to throw

Together, these elements formed a more complete and believable AI throwable behavior framework.

Result