josh/ThordekkCore

Fork 0

Files

T

luis 5e6911ccb4 Init source part 1

2026-01-20 21:33:16 -03:00

25 KiB

Raw Blame History

Phase 2.8: Final Documentation

Duration: 1 week (2025-03-24 to 2025-03-31) Status: ⏳ PENDING Owner: Development Team

Objectives

Create comprehensive documentation for the refactored PlayerBot system:

Complete ARCHITECTURE.md with new design
Update README.md with current state
API documentation for all managers and strategies
Code comments audit and completion
Developer onboarding guide
Performance tuning guide
Troubleshooting guide

Background

Documentation Requirements

After a major refactoring (Phases 2.1-2.7), documentation must:

Accurately reflect the current implementation
Provide clear guidance for new developers
Document all architectural decisions
Explain performance characteristics
Guide troubleshooting efforts

Documentation Principles

Accuracy: Documentation matches code exactly
Clarity: Non-experts can understand
Completeness: All public APIs documented
Examples: Real code examples for every feature
Maintenance: Easy to update as code evolves

Technical Requirements

Documentation Standards

Format: Markdown for all documentation files
Code Examples: Compilable, tested snippets
Diagrams: Mermaid diagrams for architecture
API Docs: Doxygen-compatible comments in code
Version: Documentation matches code version

Audience Segmentation

New Developers - Need overview and onboarding
API Users - Need method signatures and examples
Maintainers - Need architecture and design rationale
Operators - Need configuration and tuning guides

Deliverables

1. ARCHITECTURE.md (Complete Rewrite)

Location: docs/ARCHITECTURE.md

Table of Contents:

# PlayerBot Architecture

## 1. Overview
- System purpose and goals
- High-level architecture diagram
- Key design principles

## 2. Core Components

### 2.1 BotAI (Central Controller)
- Update loop architecture
- Manager orchestration
- Strategy coordination

### 2.2 BehaviorManager Base Class
- Throttling mechanism
- State query interface
- Performance characteristics

### 2.3 Managers
- QuestManager
- TradeManager
- GatheringManager
- AuctionManager

### 2.4 Strategies
- Strategy pattern implementation
- Priority system
- IdleStrategy (observer pattern)
- LeaderFollowBehavior
- CombatMovementStrategy
- GroupCombatStrategy

### 2.5 ClassAI
- Universal combat activation
- Class-specific implementations
- Resource management

## 3. Update Flow
- World::Update() → BotSession → BotAI
- UpdateManagers() phase
- UpdateStrategies() phase
- UpdateMovement() phase
- OnCombatUpdate() phase

## 4. Design Patterns
- Manager pattern
- Strategy pattern
- Observer pattern
- Factory pattern (ClassAI creation)

## 5. Performance Architecture
- Throttling strategy
- Atomic state queries
- Per-bot instances
- Scalability to 5000+ bots

## 6. Thread Safety
- Single-threaded bot logic
- Atomic state flags
- No shared state between bots

## 7. Integration Points
- TrinityCore hook points
- Database interactions
- Network session handling

## 8. Extension Points
- Adding new managers
- Creating custom strategies
- Extending ClassAI

2. API Reference Documentation

Location: docs/API_REFERENCE.md

Format:

# PlayerBot API Reference

## BehaviorManager

### Constructor
```cpp
BehaviorManager(Player* bot, BotAI* ai, uint32 updateInterval);

Parameters:

bot: The bot's Player object
ai: The bot's AI controller
updateInterval: Milliseconds between updates

Example:

class MyManager : public BehaviorManager
{
public:
    MyManager(Player* bot, BotAI* ai)
        : BehaviorManager(bot, ai, 2000) // Update every 2 seconds
    {}
};

Update()

void Update(uint32 diff);

Description: Called every frame, internally throttled to updateInterval

Performance: <0.001ms when throttled, actual OnUpdate() cost varies

[... document all public methods for all classes ...]


### 3. Developer Onboarding Guide
Location: `docs/DEVELOPER_ONBOARDING.md`

**Content**:
```markdown
# Developer Onboarding Guide

## Getting Started (Day 1)

### Prerequisites
- C++20 compiler (MSVC 2022, GCC 11+, or Clang 14+)
- CMake 3.24+
- MySQL 9.4+
- Git

### Setup Steps
1. Clone repository
2. Build TrinityCore with PlayerBot module
3. Configure database
4. Run sample bots
5. Verify logs

## Understanding the Codebase (Day 2-3)

### Key Files to Read
1. `src/modules/Playerbot/AI/BotAI.h` - Start here
2. `src/modules/Playerbot/AI/BehaviorManager.h` - Manager base class
3. `src/modules/Playerbot/AI/Strategy/Strategy.h` - Strategy base class
4. `docs/ARCHITECTURE.md` - System architecture

### Code Navigation Tips
- Managers in `Game/`, `Social/`, `Professions/`, `Economy/`
- Strategies in `AI/Strategy/`
- ClassAI in `AI/ClassAI/`
- Lifecycle in `Lifecycle/`

## First Tasks (Week 1)

### Task 1: Add Debug Logging
**Goal:** Understand update flow
**File:** `src/modules/Playerbot/AI/BotAI.cpp`
**Steps:**
1. Add log to UpdateManagers()
2. Add log to UpdateStrategies()
3. Rebuild and observe logs

### Task 2: Create Simple Manager
**Goal:** Learn manager pattern
**Steps:**
1. Create `EmoteManager.h` (copy from GatheringManager.h)
2. Implement OnUpdate() to play random emote
3. Add to BotAI
4. Test with bots

### Task 3: Modify Existing Strategy
**Goal:** Understand observer pattern
**File:** `src/modules/Playerbot/AI/Strategy/IdleStrategy.cpp`
**Steps:**
1. Add new priority check
2. Observe manager state
3. Implement new behavior
4. Test

## Advanced Topics (Week 2+)

### Performance Profiling
- Using Visual Studio Profiler
- Identifying hotspots
- Optimizing critical paths

### Memory Management
- Smart pointer usage
- Avoiding leaks
- Profiling memory

### Debugging Techniques
- Using breakpoints in BotAI
- Logging best practices
- Crash dump analysis

## Getting Help

### Resources
- `docs/ARCHITECTURE.md` - System design
- `docs/API_REFERENCE.md` - Method documentation
- `docs/TROUBLESHOOTING.md` - Common issues
- `docs/FAQ.md` - Frequently asked questions

### Contact
- Discord: #playerbot-dev channel
- GitHub Issues: Technical problems
- Forums: General discussion

4. Performance Tuning Guide

Location: docs/PERFORMANCE_TUNING.md

Content:

# Performance Tuning Guide

## Understanding Performance Metrics

### Key Metrics
- **Frame Time**: Time per bot per update (<2ms target)
- **CPU Usage**: Total server CPU (<10% for 5000 bots)
- **Memory**: Per-bot memory (<10MB target)
- **Update Rate**: Updates per second per bot

### Measuring Performance

#### Using Visual Studio Profiler (Windows)
```bash
# Start profiling
devenv /profile worldserver.exe

# Or use command-line profiler
VSPerfCmd /start:sample /output:profile.vsp
VSPerfCmd /launch:worldserver.exe
# ... run test ...
VSPerfCmd /shutdown

Using perf (Linux)

# Profile for 60 seconds
perf record -g -o perf.data -p $(pidof worldserver) -- sleep 60

# Analyze results
perf report -i perf.data

Optimization Techniques

1. Manager Throttling

What: Control how often managers update When: Manager update taking too much time How:

// Increase interval for expensive operations
class MyManager : public BehaviorManager
{
    MyManager(Player* bot, BotAI* ai)
        : BehaviorManager(bot, ai, 5000) // Was 2000, now 5000
    {}
};

2. Strategy Optimization

What: Make strategies faster When: UpdateStrategies() is slow How:

// Cache expensive calculations
void MyStrategy::UpdateBehavior(BotAI* ai, uint32 diff)
{
    // BAD: Recalculate every frame
    if (CalculateComplexCondition(ai))
        DoSomething();

    // GOOD: Cache and update periodically
    if (_lastCheck + 1000 < getMSTime())
    {
        _cachedCondition = CalculateComplexCondition(ai);
        _lastCheck = getMSTime();
    }

    if (_cachedCondition)
        DoSomething();
}

3. Database Query Optimization

What: Reduce database load When: Queries are slow How:

Use prepared statements
Batch queries when possible
Cache frequently accessed data
Use connection pooling

4. Memory Optimization

What: Reduce per-bot memory When: Memory usage too high How:

Use object pooling for temporary objects
Avoid unnecessary allocations
Reuse vectors/strings
Profile with Valgrind/Dr. Memory

Configuration Tuning

playerbots.conf Settings

# Reduce update frequency for better performance
Playerbot.AI.UpdateDelay = 200  # Default: 100

# Increase intervals for managers
Playerbot.QuestUpdateInterval = 5000  # Default: 2000
Playerbot.GatheringUpdateInterval = 2000  # Default: 1000

# Reduce bot count if needed
Playerbot.MaxBots = 500  # Default: 1000

Profiling Results Interpretation

Sample Profiling Session

Function                              Time      %
--------------------------------------------------
BotAI::UpdateAI                       45.2ms    22%
  UpdateManagers                      18.5ms    9%
    QuestManager::OnUpdate            8.2ms     4%
    GatheringManager::OnUpdate        6.1ms     3%
  UpdateStrategies                    12.3ms    6%
    IdleStrategy::UpdateBehavior      5.8ms     3%
    CombatMovementStrategy            4.2ms     2%
  OnCombatUpdate                      8.7ms     4%
    WarriorClassAI::Update            3.5ms     1.7%

Analysis:

QuestManager is hotspot (8.2ms = 4% of total time)
Consider increasing QuestManager throttling
IdleStrategy is efficient (5.8ms for all bots)

Scaling Guidelines

Bot Count Recommendations

Hardware	Max Bots	Expected CPU
4-core CPU	1000	8-12%
8-core CPU	2500	10-15%
16-core CPU	5000	12-18%
32-core CPU	10000+	15-25%

RAM Requirements

Minimum: 16GB for 1000 bots
Recommended: 32GB for 2500 bots
High-load: 64GB for 5000+ bots

Troubleshooting Performance Issues

Issue: High CPU Usage

Symptoms: >20% CPU for expected bot count Diagnosis:

Profile with perf/VSPerfCmd
Identify hottest functions
Check for infinite loops or missing throttling

Solutions:

Increase manager intervals
Optimize hot functions
Reduce bot count

Issue: High Memory Usage

Symptoms: >15MB per bot Diagnosis:

Profile with Valgrind/Dr. Memory
Check for memory leaks
Check for excessive allocations

Solutions:

Fix memory leaks
Use object pooling
Optimize data structures

Issue: Slow Update Times

Symptoms: >5ms per bot update Diagnosis:

Profile update loop
Check database queries
Check for synchronous I/O

Solutions:

Optimize slow queries
Use async operations
Cache frequently accessed data


### 5. Troubleshooting Guide
Location: `docs/TROUBLESHOOTING.md`

**Content**:
```markdown
# Troubleshooting Guide

## Common Issues

### Bots Not Spawning

**Symptoms:**
- `.bot spawn` command does nothing
- No bots in world
- No errors in logs

**Diagnosis:**
1. Check playerbots.conf: `Playerbot.Enable = 1`
2. Check account has bot characters created
3. Check database connection
4. Enable debug logging: `Playerbot.Debug = 1`

**Solution:**
```bash
# Verify configuration
cat playerbots.conf | grep "Playerbot.Enable"

# Check database
mysql -u root -p
USE playerbot_characters;
SELECT COUNT(*) FROM characters WHERE account IN (1,2,3); -- Bot accounts

# Check logs
tail -f logs/worldserver.log | grep "playerbot"

Bots Not Moving

Symptoms:

Bots spawn but stand still
No movement at all
Strategies activated but no behavior

Diagnosis:

Check IdleStrategy is active: Look for "Idle strategy activated" in logs
Check UpdateBehavior() is called: Look for UpdateBehavior logs
Check managers are updating: Enable manager debug logs

Solution: See PHASE_2_5_IDLE_STRATEGY.md for observer pattern implementation

Bots Not Casting Spells

Symptoms:

Bots only auto-attack
No spell casts in combat
ClassAI not working

Diagnosis:

Check OnCombatUpdate() is called for ALL combat (not just groups)
Verify ClassAI initialized: Look for "ClassAI created" in logs
Check bot has mana/rage/energy

Solution: See PHASE_2_3_COMBAT_ACTIVATION.md for universal ClassAI fix

Performance Issues

Symptoms:

High CPU usage
Slow server response
Lag spikes

Diagnosis:

Profile with perf/VSPerfCmd
Check bot count vs hardware capacity
Check for performance regressions

Solution: See PERFORMANCE_TUNING.md for optimization techniques

Error Messages

"Failed to create ClassAI"

Meaning: Bot's class doesn't have ClassAI implementation

Solution: Check that ClassAI exists for bot's class:

ls src/modules/Playerbot/AI/ClassAI/ | grep -i "warrior"
# Should show: WarriorClassAI.h, WarriorClassAI.cpp

"Manager update took >50ms"

Meaning: Manager is too slow

Solution: Increase manager throttling interval:

MyManager(Player* bot, BotAI* ai)
    : BehaviorManager(bot, ai, 5000) // Increase from 2000
{}

"Slow update detected - 144ms"

Meaning: Bot update took too long

Solution:

Profile to find hotspot
Optimize or throttle expensive operations
See PERFORMANCE_TUNING.md

Debug Logging

Enable Debug Logs

# playerbots.conf
Playerbot.Debug = 1
Playerbot.Debug.BotAI = 1
Playerbot.Debug.Managers = 1
Playerbot.Debug.Strategies = 1

Log Levels

ERROR: Critical problems
WARN: Potential issues
INFO: Important events
DEBUG: Detailed execution flow
TRACE: Very verbose (performance impact)

Reading Logs

# Follow worldserver logs
tail -f logs/worldserver.log

# Filter for playerbot
grep "module.playerbot" logs/worldserver.log

# Find errors
grep "ERROR.*playerbot" logs/worldserver.log

# Performance warnings
grep "Slow update" logs/worldserver.log

Getting Help

Before Asking for Help

Check this troubleshooting guide
Read relevant phase documentation
Check logs for errors
Try to reproduce issue

Information to Provide

TrinityCore version/commit
Operating system
Bot count
Reproduction steps
Relevant log excerpts
Hardware specs

Where to Ask

GitHub Issues: Bug reports
Discord #playerbot-dev: Development questions
Forums: General help


### 6. FAQ Document
Location: `docs/FAQ.md`

**Content**:
```markdown
# Frequently Asked Questions

## General

### Q: What is PlayerBot?
**A:** An AI system that creates autonomous player-controlled characters in TrinityCore, enabling single-player and bot-populated gameplay.

### Q: How many bots can I run?
**A:** Depends on hardware. 8-core CPU can handle ~2500 bots, 16-core ~5000 bots. See PERFORMANCE_TUNING.md for details.

### Q: Is this compatible with TrinityCore 3.3.5a?
**A:** Yes, this module is designed for TrinityCore 3.3.5a (Wrath of the Lich King).

## Development

### Q: How do I add a new manager?
**A:**
1. Create class inheriting from BehaviorManager
2. Implement OnUpdate() method
3. Add to BotAI as member variable
4. Initialize in BotAI constructor
5. Call Update() in BotAI::UpdateManagers()

See DEVELOPER_ONBOARDING.md Task 2 for tutorial.

### Q: How do I create a custom strategy?
**A:**
1. Create class inheriting from Strategy
2. Implement UpdateBehavior()
3. Add to BotAI strategy list
4. Activate with ActivateStrategy()

### Q: What's the difference between Manager and Strategy?
**A:**
- **Managers**: Do heavyweight work, throttled (2-10 seconds)
- **Strategies**: Observe state, lightweight, every frame (<0.1ms)

See ARCHITECTURE.md section 4 for details.

### Q: How does the observer pattern work?
**A:** Strategies query manager state (fast atomic reads) instead of calling manager methods (slow). Managers update independently via BotAI::UpdateManagers().

## Performance

### Q: Why is my CPU usage high?
**A:**
- Too many bots for your hardware
- Manager throttling too aggressive
- Check PERFORMANCE_TUNING.md

### Q: How do I optimize bot performance?
**A:**
- Increase manager update intervals
- Reduce bot count
- Profile to find hotspots
- See PERFORMANCE_TUNING.md

### Q: What's the target frame time per bot?
**A:** <2ms per bot on average for good performance.

## Troubleshooting

### Q: Bots aren't doing anything
**A:** Check TROUBLESHOOTING.md "Bots Not Moving" section.

### Q: Bots only auto-attack
**A:** Check TROUBLESHOOTING.md "Bots Not Casting Spells" section.

### Q: How do I debug bot behavior?
**A:**
1. Enable debug logging in playerbots.conf
2. Check logs in logs/worldserver.log
3. Use breakpoints in BotAI::UpdateAI()

## Configuration

### Q: Where is the configuration file?
**A:** `playerbots.conf` in your server directory.

### Q: What are the most important settings?
**A:**
```ini
Playerbot.Enable = 1
Playerbot.MaxBots = 1000
Playerbot.AI.UpdateDelay = 100

Q: How do I enable debug logging?

Playerbot.Debug = 1


### 7. Code Comments Audit
Location: All source files in `src/modules/Playerbot/`

**Process**:
1. Audit all public methods for Doxygen comments
2. Audit all classes for class-level comments
3. Add missing comments
4. Verify comment accuracy
5. Generate Doxygen documentation

**Doxygen Comment Standard**:
```cpp
/**
 * @brief Manages bot quest automation
 *
 * QuestManager handles quest acceptance, objective tracking, and turn-in.
 * Updates are throttled to once per 2 seconds for performance.
 *
 * @note Thread-safe for single bot (no cross-bot access)
 * @see BehaviorManager for base class documentation
 */
class QuestManager : public BehaviorManager
{
public:
    /**
     * @brief Constructs a quest manager for a bot
     *
     * @param bot The bot's Player object
     * @param ai The bot's AI controller
     */
    QuestManager(Player* bot, BotAI* ai);

    /**
     * @brief Checks if bot is actively questing
     *
     * Fast atomic query, safe to call every frame.
     *
     * @return true if bot has active quests, false otherwise
     * @performance <0.001ms per call (atomic read)
     */
    bool IsQuestingActive() const;

protected:
    /**
     * @brief Performs quest management logic
     *
     * Called internally by Update() when throttle interval expires.
     * Handles quest pickup, objective checking, and turn-in.
     *
     * @param diff Milliseconds since last update
     * @performance ~5-10ms per call (throttled to 2 seconds)
     */
    void OnUpdate(uint32 diff) override;
};

8. README.md Update

Location: README.md

Content (excerpt):

# TrinityCore PlayerBot Module

AI-controlled player bots for TrinityCore 3.3.5a, enabling single-player and bot-populated gameplay.

## Features

- ✅ **Autonomous Behavior**: Bots quest, gather, trade, and fight independently
- ✅ **Group Support**: Bots follow players, participate in dungeons and raids
- ✅ **Combat AI**: Class-specific rotations for all 13 classes
- ✅ **High Performance**: Supports 5000+ concurrent bots (<10% CPU)
- ✅ **Enterprise Architecture**: Manager pattern, observer pattern, throttled updates

## Quick Start

### Installation
```bash
# Clone TrinityCore with PlayerBot module
git clone https://github.com/TrinityCore/TrinityCore.git -b playerbot-dev
cd TrinityCore

# Build with PlayerBot enabled
cmake -DBUILD_PLAYERBOT=1 ..
make -j$(nproc)

Configuration

# playerbots.conf
Playerbot.Enable = 1
Playerbot.MaxBots = 1000
Playerbot.AI.UpdateDelay = 100

Basic Commands

.bot spawn <account> <class> <name>  # Spawn a bot
.bot add <name>                       # Add bot to your group
.bot remove <name>                    # Remove bot from group

Documentation

Architecture - System design and patterns
API Reference - Method documentation
Developer Onboarding - Getting started guide
Performance Tuning - Optimization guide
Troubleshooting - Common issues
FAQ - Frequently asked questions

Performance

Bot Count	CPU Usage	Memory	Frame Time
100	<1%	1GB	<0.5ms/bot
500	3-5%	5GB	<1ms/bot
1000	8-10%	10GB	<2ms/bot
5000	15-20%	50GB	<3ms/bot

8-core CPU, 64GB RAM

Development

See DEVELOPER_ONBOARDING.md for contribution guidelines.

License

GPL v2 - See LICENSE file

Credits

TrinityCore Team - Base server framework
PlayerBot Contributors - AI implementation


---

## Implementation Steps

### Day 1: ARCHITECTURE.md
- Rewrite complete architecture document
- Create Mermaid diagrams
- Document all design patterns
- Document update flow
- Review and finalize

### Day 2: API Reference
- Document all BehaviorManager methods
- Document all Manager classes
- Document all Strategy classes
- Document BotAI public interface
- Generate Doxygen docs

### Day 3: Developer Onboarding Guide
- Write getting started section
- Create tutorial tasks
- Document debugging techniques
- Add code navigation tips
- Review with test user

### Day 4: Performance Tuning Guide
- Document profiling techniques
- Provide optimization examples
- Create configuration guidelines
- Add scaling recommendations
- Test with real scenarios

### Day 5: Troubleshooting Guide
- Document all common issues
- Provide diagnostic steps
- Create solution cookbook
- Add debug logging guide
- Test with users

### Day 6: Code Comments Audit
- Audit all header files
- Add missing Doxygen comments
- Verify comment accuracy
- Generate Doxygen HTML
- Review generated docs

### Day 7: Final Review and Publish
- Update README.md
- Create FAQ.md
- Cross-reference all docs
- Spell check and format
- Publish documentation

---

## Success Criteria

### Completeness
- ✅ All public APIs documented
- ✅ All classes have class-level comments
- ✅ All design decisions explained
- ✅ All configuration options documented
- ✅ All troubleshooting scenarios covered

### Quality
- ✅ Documentation matches code exactly
- ✅ No broken links between docs
- ✅ All code examples compile
- ✅ Diagrams are clear and accurate
- ✅ Spelling and grammar correct

### Usability
- ✅ New developer can onboard in 1 day
- ✅ API user can find method docs in <5 minutes
- ✅ Troubleshooting guide solves 80% of issues
- ✅ Performance guide improves bot efficiency
- ✅ Architecture doc explains system in <30 minutes

### Maintainability
- ✅ Documentation structure is logical
- ✅ Easy to update as code changes
- ✅ Version-controlled with code
- ✅ Generated docs (Doxygen) automated
- ✅ Clear ownership of each doc

---

## Documentation Structure

docs/ ├── ARCHITECTURE.md # System design ├── API_REFERENCE.md # Method documentation ├── DEVELOPER_ONBOARDING.md # Getting started ├── PERFORMANCE_TUNING.md # Optimization guide ├── TROUBLESHOOTING.md # Common issues ├── FAQ.md # Questions and answers ├── diagrams/ # Mermaid/PNG diagrams │ ├── update_flow.mmd │ ├── manager_pattern.mmd │ └── strategy_pattern.mmd └── examples/ # Code examples ├── create_manager.cpp ├── create_strategy.cpp └── optimize_performance.cpp

README.md # Project overview

Phase Plans/ ├── PLAYERBOT_REFACTORING_MASTER_PLAN.md ├── PHASE_2_1_BEHAVIOR_MANAGER.md ├── PHASE_2_2_COMBAT_MOVEMENT.md ├── PHASE_2_3_COMBAT_ACTIVATION.md ├── PHASE_2_4_MANAGER_REFACTOR.md ├── PHASE_2_5_IDLE_STRATEGY.md ├── PHASE_2_6_INTEGRATION_TESTING.md ├── PHASE_2_7_CLEANUP.md └── PHASE_2_8_DOCUMENTATION.md # This file


---

## Dependencies

### Requires
- Phase 2.1 complete (BehaviorManager implemented)
- Phase 2.2 complete (CombatMovementStrategy implemented)
- Phase 2.3 complete (Universal ClassAI implemented)
- Phase 2.4 complete (All managers refactored)
- Phase 2.5 complete (Observer pattern IdleStrategy)
- Phase 2.6 complete (Integration testing done)
- Phase 2.7 complete (Cleanup finished)

### Blocks
- Nothing (final phase)

---

## Risk Mitigation

### Risk: Documentation becomes outdated
**Mitigation**: Version-control with code, require doc updates with code changes

### Risk: Documentation too technical
**Mitigation**: Multiple audience levels (onboarding, API, architecture)

### Risk: Examples don't compile
**Mitigation**: Test all code examples during documentation phase

### Risk: Diagrams don't match code
**Mitigation**: Generate diagrams from code where possible (Doxygen), manual review

---

## Next Steps

After completion:
- **Project Complete**: Full refactoring finished
- **Deployment Ready**: Documentation enables production use
- **Maintenance Mode**: Focus shifts to bug fixes and enhancements
- **Community Engagement**: Open for contributions

---

**Last Updated**: 2025-01-13
**Next Review**: After Phase 2.8 completion (2025-03-31)

25 KiB Raw Blame History

Phase 2.8: Final Documentation

Objectives

Background

Documentation Requirements

Documentation Principles

Technical Requirements

Documentation Standards

Audience Segmentation

Deliverables

1. ARCHITECTURE.md (Complete Rewrite)

2. API Reference Documentation

Update()

4. Performance Tuning Guide

Using perf (Linux)

Optimization Techniques

1. Manager Throttling

2. Strategy Optimization

3. Database Query Optimization

4. Memory Optimization

Configuration Tuning

playerbots.conf Settings

Profiling Results Interpretation

Sample Profiling Session

Scaling Guidelines

Bot Count Recommendations

RAM Requirements

Troubleshooting Performance Issues

Issue: High CPU Usage

Issue: High Memory Usage

Issue: Slow Update Times

Bots Not Moving

Bots Not Casting Spells

Performance Issues

Error Messages

"Failed to create ClassAI"

"Manager update took >50ms"

"Slow update detected - 144ms"

Debug Logging

Enable Debug Logs

Log Levels

Reading Logs

Getting Help

Before Asking for Help

Information to Provide

Where to Ask

Q: How do I enable debug logging?

8. README.md Update

Configuration

Basic Commands

Documentation

Performance

Development

License

Credits

25 KiB

Raw Blame History