Build & Development Commands
- Build Automation:
- Provide a unified build script (e.g., using Unreal Build Tool and dedicated batch or shell scripts) that encapsulates all build commands.
- Sample commands might include:
- build:debug – Perform a debugging build with full symbols and logging.
- build:release – Compile an optimized final version.
- build:ci – A script specifically targeted for the continuous integration environment.
- Environment Setup:
- Ensure that environment variables are configured properly for locating UE5.6 binaries and required SDKs.
- Include a pre-build step to verify the installation of all dependencies.
- Command Documentation:
- Maintain a clear README or developer guide outlining each build command, expected input parameters, and outputs to help onboard new developers.

Testing Guidelines
- Unit Testing:
- Write unit tests for individual AI logic components. Focus on core decision-making functions, edge-case inputs, and error handling.
- Integration Testing:
- Develop tests that simulate in-engine behavior. For instance, validate that the AI behaves correctly in various simulated game scenarios through Unreal’s automated testing framework.
- End-to-End (E2E) Testing:
- Include scenarios that mirror real-world use. For example, test AI modules interacting with game physics, rendering, and user input.
- Continuous Testing & CI:
- Automate running all tests in your CI pipeline. Ensure that every commit triggers the test suite so that potential issues are detected early.
- Logging & Metrics Collection:
- Integrate detailed logging and assertions in your test cases. This makes failures easier to diagnose, particularly in complex AI decision trees.
- Code Coverage:
- Aim for a coverage goal (e.g., over 80% in critical areas) and document the methodology used for measuring testing metrics.

Code Style & Guidelines
- General Formatting:
- Indentation: Use 4 spaces for indentation and maintain consistency across all files.
- Brace Style: Choose one brace style (such as Allman or K&R) and enforce it with code formatting tools.
- Naming Conventions:
- Classes: Use PascalCase (e.g., EnemyAIController).
- Functions/Methods: Utilize camelCase (e.g., calculatePath()).
- Variables: Use descriptive names with camelCase; prefix pointers/members with a consistent notation if needed.
- Modular Code:
- Ensure clear separation of concerns. AI logic should be decoupled from UI, input handling, and core game mechanics.
- Code Documentation:
- Utilize inline comments and header comments to describe the purpose of classes, functions, and nontrivial algorithms.
- Maintain a standards file or section in the README that outlines expectations for code quality.
- Static Analysis:
- Integrate static analysis tools (or Unreal’s built-in checkers) into your pipeline to catch style and potential error issues early.
- Commit Standards:
- Use consistent commit message conventions that reference issue numbers, brief descriptions of changes, and potential impacts.

Documentation Guidelines
- Centralized Documentation Repository:
- Create and maintain a dedicated documentation folder (e.g., /docs) within the repository for all project-related documents.
- README and Quick-Start Guides:
- Provide a comprehensive README that covers the overall architecture, setup instructions, and a quick-start guide for new developers.
- API Documentation:
- Include in-line documentation (preferably using Doxygen-style comments) so that API references can be automatically generated.
- Process & Architecture Diagrams:
- Use diagrams (such as UML or flowcharts) to visually describe the AI’s architecture. This is invaluable for onboarding and maintenance.
- Change Logs:
- Maintain version-specific change logs documenting updates to the AI system. This makes it easier to track progress and understand the evolution of the codebase.
- FAQ & Troubleshooting:
- Develop a troubleshooting guide that covers common pitfalls and how to resolve them—this is beneficial in a continuous integration context where bugs can arise from environment differences

Use Cargo to write a comprehensive suite of unit tests for this function