AI Algorithm Practice Behind Unity Stealth Chase Game: A* Pathfinding and Minimax Decision-Making

Relic Hunter, a turn-based grid stealth game developed by a student team from the Polytechnic University of the Philippines, is an assignment for the COSC304 Artificial Intelligence course. The project combines the A* pathfinding algorithm and Minimax/Alpha-Beta pruning algorithm to implement intelligent enemy movement and decision-making. The code is open-sourced on GitHub (https://github.com/DLJocson/relic-hunter) and serves as an excellent example for game AI learning.

The project was developed by the PUP CS3-2 student team (Cabbadu, Jocson, Lambohon, Salgado) with the course background of COSC304 Introduction to Artificial Intelligence. The project adopts a modular architecture with a clear code structure: Under Assets/_Project, there are subfolders such as Scenes (levels), Scripts (logic, including AI/Core/Player/Enemy/UI subfolders), and Prefabs (prefabs). The AI module is decoupled from other systems for easy debugging and optimization.

The A* algorithm is responsible for calculating the optimal path for enemies, with core values: g-value (actual cost from the start node to the current node), h-value (estimated cost to the target), and f-value (g + h). In the project, AStar.cs under the AI folder implements the core logic, PathNode.cs defines the node structure, and Heuristics.cs provides heuristic functions (supporting flexible switching between Manhattan/Euclidean distance).

Minimax solves the problem of enemy strategic decision-making (the Max layer selects the most threatening action, and the Min layer simulates the player's evasion). Alpha-Beta pruning optimizes to reduce computational overhead by maintaining alpha (lower bound of maximum gain) and beta (upper bound of minimum gain) to prune irrelevant branches. In the project, Minimax.cs and AlphaBeta.cs implement the basic and optimized versions respectively, facilitating performance comparison.

The team has a clear division of labor: Jocson is responsible for AI algorithms and code review (AStar.cs, Minimax.cs, etc.); Cabbadu optimizes enemy AI behavior (Heuristics.cs, GuardController.cs); Lambohon handles visual resources and UI; Salgado develops core systems and testing (GridManager.cs, PlayerController.cs). The division of labor ensures that each subsystem is managed by a dedicated person, and code review guarantees quality.

The project brings three insights: 1. Algorithm combination is more practical (A* for tactical pathfinding + Minimax for strategic decision-making); 2. Turn-based systems reduce AI complexity (sufficient time for computation); 3. Standardized grid maps facilitate algorithm implementation (clear neighbor relationships and simple cost calculation).

The AI architecture can be applied to scenarios such as strategy games (unit movement), puzzle games (NPC chase), and RPGs (enemy pursuit). Expansion directions include: introducing machine learning to replace heuristic functions, dynamic obstacle handling, Monte Carlo Tree Search to replace Minimax, and behavior trees to handle complex enemy state machines.

Relic Hunter combines academic theory with game practice, completing the course assignment while creating a runnable system. With a clear code structure, clear division of labor, and complete documentation, it provides game AI learners with a reference example of transforming classic algorithms into game experiences and is a valuable open-source resource to learn from.