Summary of "(French) Efficiently Running Large Numbers of NPC AI by Florianne10 | Inspire 2024"

Summary of “Efficiently Running Large Numbers of NPC AI” by Floran10 at Inspire 2024

Overview

The presentation by Floran10 focuses on efficiently managing large numbers of NPC (Non-Player Character) AIs in multiplayer games, specifically within Roblox. Floran10 shares insights from his experience developing My Prison, a Roblox game featuring over 1000 NPCs per server. The workshop covers AI behavior modeling, pathfinding techniques, server and client optimizations, and rendering strategies for large-scale NPC management.

Key Technological Concepts & Product Features

1. NPC Behavior Modeling

Basic Behavior Logic: NPCs perform sequences of actions based on game states (e.g., prisoners getting food, eating, disposing of trays).
Challenges: Complex behaviors lead to many conditional checks, becoming hard to maintain.
Behavior Trees: Introduced as a scalable solution to organize NPC actions logically. Behavior trees use nodes and selectors to manage sequences and choices in NPC behavior.
Tools: Use of the BAV Editor plugin in Roblox Studio to visually create behavior trees that generate code modules for easier integration.

2. Pathfinding

Pathfinding Approaches:
- Shortest Path: Finds the minimal distance but is computationally expensive.
- Fastest Path: Quicker to compute but may not be shortest.
Roblox Pathfinding Service: Uses navigation meshes (geometric representations of walkable areas). Supports modifiers to prioritize or block certain paths (e.g., avoiding safe zones or enabling teleport portals).
Custom Pathfinding: Implementation of algorithms like A* (A-star) with heuristics (Euclidean distance) for efficient pathfinding. Demonstrated with a prototype showing pathfinding from start to goal.
Modifiers: Used to customize NPC movement, such as avoiding safe zones or preferring certain terrain.

3. Server-Side Optimizations

Multithreading with Actors: Distributes NPC calculations across multiple threads (actors) to improve performance. Caution advised not to overuse actors due to processor core limits.
Coroutines for Pathfinding: Pathfinding calculations are split into steps using coroutines to spread workload over time. Infinite loops with coroutine yields allow incremental path search without blocking server resources.
Calculation Time Management: Limits maximum CPU time allocated per frame for pathfinding (e.g., 1/4 of frame time at 60 FPS).
Pre-calculation of Paths: NPCs start calculating their next path while performing current actions, making transitions seamless and unnoticeable to players.

4. Client-Side Rendering & Replication

Model Replication: NPC 3D models exist only on clients; the server replicates NPC states, actions, and waypoints. This reduces bandwidth and processing by not loading NPCs outside a player’s zone or view.
Waypoints: Paths are represented as waypoints that NPCs follow. Waypoints often reversed in order to optimize memory operations when removing passed points.
Movement Interpolation: Uses frame-based events (RunService.Heartbeat) and linear interpolation (lerp) between waypoints based on timestamps. Synchronization with server time or adjusted for latency ensures smooth and consistent NPC movement.
No Physics for NPCs: NPCs are anchored to avoid expensive physics calculations. Validated paths ensure NPCs do not collide or fall through geometry, so physics simulation is unnecessary.
Animation Without Humanoids: Humanoids are not used to save resources and because NPCs are anchored. Animations are handled via AnimationController and Animator instances. Enabling Roblox’s built-in Animator Streaming reduces animation update frequency for distant NPCs, improving performance.
Clothing Without Humanoids: Clothing textures are manually mapped using decals or parts with hair instances. This approach allows export/import of NPC models with textures intact but results in simple cubic collision shapes.

5. Handling Complex Cases & Multiplayer Considerations

Safe Zones: Managed by combining behavior tree selectors and pathfinding modifiers to prevent NPCs from entering or interacting within safe zones.
Breaking Down Behavior Trees: Large behavior trees can be split into multiple smaller trees by NPC type or time of day (e.g., day vs. night behaviors) for maintainability.
NPC Interactions: NPC states are managed using object-oriented programming with meta-tables. Interactions like combat check NPC states to determine availability.
Dynamic Environments: For changing maps (e.g., walls opening), caching paths with waypoints on a grid and invalidating them on changes can optimize recalculations.
NPCs Initiating Interaction: Strategies include calculating paths to players and recalculating paths dynamically. Trade-offs exist between recalculating paths continuously versus following precomputed waypoints.
Resource Usage: Pathfinding is computationally expensive, especially in complex or player-built environments (e.g., mazes). Optimization and workload distribution are essential for scalability.

Reviews, Guides, and Tutorials Provided

Step-by-step explanation of:
- Behavior tree design and implementation.
- Using Roblox’s Pathfinding Service vs. custom pathfinding algorithms.
- Server-side optimizations including multithreading and coroutine usage.
- Client-side rendering optimizations and animation handling without humanoids.
Practical coding examples and demos (e.g., A-star algorithm prototype).
Best practices for managing large NPC populations in multiplayer Roblox games.
Q&A session addressing common challenges such as AI complexity, animation without humanoids, physics in dynamic environments, and NPC-player interactions.

Main Speaker / Source

Floran10 Roblox developer, programmer since 2017, creator of My Prison with over 1000 NPCs per server.

This workshop is a comprehensive technical guide for game developers aiming to implement and optimize large-scale NPC AI systems, particularly in Roblox environments, balancing realism, performance, and scalability.