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