2026-02-23 04:47:38 +00:00

10 KiB

Raw Blame History

AeThex Engine - AI Assistant Module Architecture

Vision

An AI-powered coding assistant built directly into the AeThex Engine editor, providing realtime code completion, bug detection, documentation generation, and intelligent suggestions.

Core Features

1. Smart Code Completion

Context-aware GDScript suggestions
Function parameter hints with AI explanations
Auto-completion that understands your project
Natural language to code generation

2. Intelligent Error Detection

Real-time bug detection
AI-powered fix suggestions
Performance optimization hints
Security vulnerability scanning

3. Documentation AI

Auto-generate function documentation
Explain complex code blocks
Generate tutorials from your code
API reference creator

4. Asset Intelligence

Texture optimization suggestions
Mesh LOD recommendations
Shader performance analysis
Asset naming conventions

5. Natural Language Commands

"Create a player controller"
"Add jump physics to this character"
"Generate a main menu UI"
"Debug why my player isn't moving"

Technical Architecture

Module Structure

engine/modules/aethex_ai/
├── SCsub                          # Build configuration
├── config.py                      # Module setup
├── register_types.h/cpp           # Godot module registration
├── ai_assistant.h/cpp             # Main AI assistant class
├── ai_code_completion.h/cpp       # Code completion engine
├── ai_error_analyzer.h/cpp        # Error detection & fixes
├── ai_doc_generator.h/cpp         # Documentation generation
├── ai_asset_optimizer.h/cpp       # Asset optimization
├── api/
│   ├── ai_api_client.h/cpp        # API communication
│   ├── claude_client.h/cpp        # Claude API integration
│   ├── rate_limiter.h/cpp         # API rate limiting
│   └── cache_manager.h/cpp        # Response caching
├── ui/
│   ├── ai_panel.h/cpp             # Main AI panel UI
│   ├── ai_chat_widget.h/cpp       # Chat interface
│   └── ai_suggestions_panel.h/cpp # Suggestions display
└── tests/
    └── test_ai_assistant.h        # Unit tests

Core Classes

1. AIAssistant (Singleton)

class AIAssistant : public Object {
    GDCLASS(AIAssistant, Object);
    
private:
    static AIAssistant *singleton;
    AIAPIClient *api_client;
    CacheManager *cache;
    RateLimiter *rate_limiter;
    
public:
    // Code assistance
    String get_code_completion(const String &context, const Vector<String> &recent_code);
    String explain_code(const String &code_block);
    String fix_error(const String &error_message, const String &code_context);
    
    // Documentation
    String generate_function_docs(const String &function_signature);
    String generate_class_docs(const String &class_code);
    
    // Natural language
    String natural_language_to_code(const String &description, const String &context);
    
    // Asset optimization
    Dictionary analyze_asset(const String &asset_path);
    String suggest_optimization(const String &asset_path);
    
    static AIAssistant *get_singleton();
};

2. AIAPIClient

class AIAPIClient : public RefCounted {
    GDCLASS(AIAPIClient, RefCounted);
    
private:
    String api_key;
    String api_endpoint;
    HTTPClient *http_client;
    
    struct PendingRequest {
        Callable callback;
        String request_id;
        uint64_t timestamp;
    };
    
    HashMap<String, PendingRequest> pending_requests;
    
public:
    // Async API calls
    String send_completion_request(const String &prompt, const Callable &callback);
    String send_chat_request(const Vector<String> &messages, const Callable &callback);
    
    // Sync API calls (with timeout)
    String send_completion_sync(const String &prompt, float timeout = 10.0);
    
    // Configuration
    void set_api_key(const String &p_key);
    void set_endpoint(const String &p_endpoint);
    
    Error initialize();
};

3. AICodeCompletion (Editor Plugin)

class AICodeCompletion : public EditorPlugin {
    GDCLASS(AICodeCompletion, EditorPlugin);
    
private:
    CodeEdit *current_editor;
    PopupMenu *suggestion_popup;
    Timer *completion_timer;
    String current_context;
    
    void _on_text_changed();
    void _on_completion_timer_timeout();
    void _show_ai_suggestions(const Vector<String> &suggestions);
    
public:
    virtual String get_name() const override { return "AICodeCompletion"; }
    virtual void edit(Object *p_object) override;
    virtual bool handles(Object *p_object) const override;
};

4. AIPanel (Editor Dock)

class AIPanel : public VBoxContainer {
    GDCLASS(AIPanel, VBoxContainer);
    
private:
    TabContainer *tab_container;
    
    // Tabs
    Control *chat_tab;
    Control *suggestions_tab;
    Control *docs_tab;
    
    // Chat interface
    RichTextLabel *chat_history;
    LineEdit *chat_input;
    Button *send_button;
    
    // Suggestions
    Tree *suggestions_tree;
    Button *apply_suggestion_button;
    
    void _on_send_chat();
    void _on_apply_suggestion();
    void _update_suggestions();
    
public:
    void add_chat_message(const String &message, bool is_user);
    void show_suggestion(const String &title, const String &description, const String &code);
};

API Integration

Claude API (Anthropic)

Endpoint: https://api.anthropic.com/v1/messages

Request Format:

{
    "model": "claude-3-5-sonnet-20241022",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": "Generate a GDScript player controller with WASD movement"
        }
    ],
    "system": "You are an expert game developer assistant for the AeThex Engine..."
}

Rate Limiting

Free tier: 10 requests/minute
Pro tier: 100 requests/minute
Cache responses for 1 hour
Queue requests when rate limited

Error Handling

enum APIErrorCode {
    API_ERROR_NONE,
    API_ERROR_NETWORK,
    API_ERROR_AUTH,
    API_ERROR_RATE_LIMIT,
    API_ERROR_TIMEOUT,
    API_ERROR_INVALID_RESPONSE
};

User Interface

1. AI Panel (Dock)

Bottom dock by default
Resizable, collapsible
Three tabs: Chat, Suggestions, Docs

2. Inline Suggestions

Ghost text in code editor
Accept with Tab, reject with Esc
Multiple suggestions with Alt+N

Right-click → "Ask AI about this"
Right-click → "Generate docs"
Right-click → "Fix this error"

4. Command Palette

Ctrl+Shift+A → AI Command Palette
Type natural language commands
See AI-powered results instantly

Configuration & Settings

Editor Settings

// In editor_settings.cpp
EDITOR_SETTING(Variant::STRING, PROPERTY_HINT_NONE, 
    "ai/api_key", "", "")
EDITOR_SETTING(Variant::BOOL, PROPERTY_HINT_NONE, 
    "ai/enable_code_completion", true, "")
EDITOR_SETTING(Variant::BOOL, PROPERTY_HINT_NONE, 
    "ai/enable_error_detection", true, "")
EDITOR_SETTING(Variant::INT, PROPERTY_HINT_RANGE, 
    "ai/suggestion_delay_ms", 500, "100,2000,10")
EDITOR_SETTING(Variant::BOOL, PROPERTY_HINT_NONE, 
    "ai/cache_responses", true, "")

User Preferences

API key (encrypted storage)
Enable/disable features
Suggestion delay
Privacy settings (opt-in telemetry)

Privacy & Security

Data Handling

Never send full project code
Only send relevant context (20 lines max)
Strip sensitive data (passwords, keys)
User explicitly opts-in

API Key Storage

// Encrypted storage using EditorSettings
String encrypted_key = EditorSettings::get_singleton()
    ->get_setting("ai/api_key_encrypted");
String api_key = Crypto::decrypt_aes256(encrypted_key, machine_id);

Usage Tracking (Opt-in Only)

Number of requests
Popular features
Error rates
Anonymous metrics only

Implementation Phases

Phase 1: Foundation (Week 1-2)

Module structure & registration
API client implementation
Basic UI panel
Settings integration
Simple code completion

Phase 2: Core Features (Week 3-4)

Enhanced code completion
Error detection & fixes
Documentation generation
Chat interface

Phase 3: Advanced Features (Week 5-8)

Natural language commands
Asset optimization
Performance analysis
Multi-file context

Phase 4: Polish & Optimization (Week 9-12)

Response caching
Rate limiting
Error handling
User testing & feedback

Testing Strategy

Unit Tests

// test_ai_assistant.h
TEST_CASE("[AIAssistant] Code completion") {
    AIAssistant *ai = AIAssistant::get_singleton();
    String result = ai->get_code_completion(
        "func _ready():\n\t",
        Vector<String>()
    );
    CHECK(result.contains("extends"));
}

Integration Tests

Test with real API (sandboxed)
Mock API for CI/CD
Rate limiting behavior
Error recovery

User Acceptance Testing

Beta testers from community
Collect feedback
Iterate quickly

Metrics & Success Criteria

Technical Metrics

Response time < 2 seconds
Cache hit rate > 60%
Error rate < 1%
API cost < $0.01/user/day

User Metrics

Daily active users
Feature usage rates
User satisfaction (surveys)
Productivity improvement

Future Enhancements

Advanced AI Features

Multi-language support (C#, C++)
Voice commands
Visual scripting AI
Game design suggestions

Model Improvements

Fine-tuned models on game dev code
Local AI models (privacy-first)
Specialized models for different tasks

Ecosystem Integration

AI-generated assets
Procedural content generation
Game balancing suggestions
Playtesting AI

Getting Started (Developer)

1. Get API Key

# Sign up at https://console.anthropic.com
# Create API key
# Add to AeThex settings

2. Enable Module

# Build with AI module
scons modules=aethex_ai

3. Test in Editor

Editor → Settings → AI Assistant
Enter API key
Enable code completion
Test with simple script

Next Steps: Implement Phase 1 foundation (API client + basic UI)

10 KiB Raw Blame History