Documentation Warfactory

🏭 Vue d'Ensemble du Projet

Warfactory est un jeu de simulation industrielle militaire inspiré de Factorio, utilisant une architecture modulaire révolutionnaire optimisée pour le développement avec Claude Code.

📚 Documentation Principale

Architecture & Design

• Vue Ensemble - Vision, philosophie et design du jeu
• Architecture Technique - Multi-serveur, engines, spécifications
• Architecture Modulaire - 🔥 NOUVEAU : Architecture triple interface
• Claude Code Integration - 🔥 NOUVEAU : Guide développement IA
• Player Integration - 🔥 NOUVEAU : Client/Server modulaire

Systèmes de Jeu

• Gameplay Industriel - Production, ressources, optimisation
• Système Militaire - Design véhicules, combat
• Économie & Logistique - Marchés, chaînes d'approvisionnement
• Mécaniques de Jeu - Recherche, progression, administration

Systèmes Techniques

• Systèmes Techniques - Tiles, mémoire, chunks
• Map System - Génération procédurale, 218+ éléments
• Arbre Technologique - 3000+ technologies
• Métriques Joueur - Analytics (3.1GB par partie)

Résolution de Problèmes

• Coherence Problem - Contradictions résolues
• Questions Ouvertes - 11 items à résoudre

Planification

• Contexte Narratif - Background et univers
• DLC Prévus - Contenus futurs
• Updates Long Terme - Roadmap

🚀 Architecture Révolutionnaire

Triple Interface Pattern

IEngine        → Coordination (Debug → Production → DataOriented)
IModuleSystem  → Exécution (Sequential → Threaded → Cluster)
IModule        → Logique Pure (Tank.so, Economy.so, Factory.so)
IIO            → Communication (Intra → Local → Network)

Avantages Claude Code

• Contextes micro : 200 lignes vs 50K+ lignes
• Build autonome : cd modules/tank/ && cmake .
• Hot-reload : Modifications instantanées
• Développement parallèle : Multiple instances Claude Code

🎯 Focus Development

Phase Actuelle : Architecture Modulaire

• ✅ Interfaces C++ : IEngine, IModuleSystem, IModule, IIO
• ✅ Modules de base : Factory, Economy, Logistic
• ✅ Build autonome : Chaque module = contexte indépendant
• 🔄 Prochaine étape : Implémentations concrètes

Workflow de Développement

# Développement module spécifique
cd modules/factory/
cmake . && make factory-module     # → factory.so

# Test isolé
./build/factory-module

# Hot-reload dans le jeu principal
# Aucun restart nécessaire !

🎮 Vision du Jeu

Concept Core

• Factory + Military : Production industrielle + doctrine militaire
• Échelles multiples : Local (usines) → Régional (logistique) → Global (diplomatie)
• Progression : PMC → Entreprise → Corporation → Super-pouvoir

Mécaniques Principales

1. Production Factorio-like : Chaînes d'assemblage, optimisation
2. Design véhicules : Grille irrégulière, placement composants
3. Combat auto-battler : Frontlines persistantes, supervision joueur
4. Économie dynamique : Marchés, inflation, cycles économiques

📖 Comment Utiliser Cette Documentation

Pour les Développeurs

1. Commencer par : Architecture Modulaire
2. Puis : Claude Code Integration
3. Ensuite : Vue Ensemble pour le contexte

Pour les Game Designers

1. Commencer par : Vue Ensemble
2. Puis : Gameplay Industriel
3. Ensuite : Système Militaire

Pour Claude Code Sessions

1. Toujours lire : /modules/{module}/CLAUDE.md
2. Context limité : Module spécifique uniquement
3. Build autonome : cmake . depuis le module
4. Max 300 lignes : Logique pure, zéro infrastructure

🔄 Statut du Projet

✅ Complété

• Design complet : 15+ documents de spécification
• Architecture modulaire : Triple interface implémentée
• Build system : CMake + defensive programming
• Structure modules : Factory, Economy, Logistic

🔄 En Cours

• Player Integration : Architecture Client/Server modulaire
• InputModule : Clavier/souris → JSON commands
• NetworkModule : WebSocket client/server communication
• V1 Thin Client : Server-authoritative avec latence acceptable

📋 Prochaines Étapes

• V1 Implementation : Client Input + Server Authority
• Multi-player testing : 2+ joueurs synchronisés
• Hot-reload validation : Server modules sans disconnect client
• V2 Planning : Client prediction + shared logic

---

💡 Philosophy

"Complexity through Simplicity" : Créer un jeu AAA complexe via une architecture de modules simples, chacun compréhensible et modifiable par Claude Code en isolation totale.

Résultat : Développement 10x plus rapide avec qualité maintenue.

---

📋 Build Commands Quick Reference

# Module development (autonomous)
cd modules/factory/
cmake . && make factory-module    # Build factory.so
./build/factory-module           # Test standalone

# Core system
cmake . && make warfactory-core   # Build core engine
./build/bin/warfactory-engine    # Run main engine

# Full system
make warfactory-modules          # Build all modules
make test-all-modules           # Test all modules

🔧 Legacy Documentation

Ancienne Architecture (référence)

• Engines Documentation - Anciens engines (supplanté par modules)
• Client Documentation - Interface system
• Server Documentation - Coordination (supplanté par IEngine)

Ces documents restent utiles pour comprendre le design original, mais l'implémentation actuelle utilise l'architecture modulaire.