From 9a883502bb4cdb1b067dab8842f3325685b348d1 Mon Sep 17 00:00:00 2001 From: StillHammer Date: Sun, 21 Sep 2025 07:34:57 +0800 Subject: [PATCH] Integrate client/server modulaire and distribution performance-based specifications MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add Client/Server Modulaire architecture (Point 4) with V1/V2 progression and user/dev implications - Add Distribution Performance-Based system (Point 5) with Critical/Strategic module classification - Update CLAUDE.md to reflect modular architecture transition - Consolidate documentation: move specialized docs to toCheck/ for systematic integration - Remove obsolete architecture files replaced by integrated specifications đŸ€– Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude --- CLAUDE.md | 78 +- docs/architecture-technique.md | 1175 +++++------------ docs/toCheck/INTEGRATION-MASTER-LIST.md | 259 ++++ docs/toCheck/README-new-content-only.md | 89 ++ docs/{ => toCheck}/architecture-modulaire.md | 8 +- docs/{ => toCheck}/claude-code-integration.md | 0 .../factory-architecture-post-player.md | 0 docs/{ => toCheck}/player-integration.md | 0 .../transport-economic-system.md | 0 9 files changed, 746 insertions(+), 863 deletions(-) create mode 100644 docs/toCheck/INTEGRATION-MASTER-LIST.md create mode 100644 docs/toCheck/README-new-content-only.md rename docs/{ => toCheck}/architecture-modulaire.md (95%) rename docs/{ => toCheck}/claude-code-integration.md (100%) rename docs/{ => toCheck}/factory-architecture-post-player.md (100%) rename docs/{ => toCheck}/player-integration.md (100%) rename docs/{ => toCheck}/transport-economic-system.md (100%) diff --git a/CLAUDE.md b/CLAUDE.md index 016294f..60a5e4f 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co ## Project Overview -**Warfactory** is a Factorio-inspired industrial military simulation game combining factory management with strategic military doctrine. The project has evolved from design/documentation phase to **functional implementation** with a complete 10-engine architecture and comprehensive build system. +**Warfactory** is a Factorio-inspired industrial military simulation game combining factory management with strategic military doctrine. The project has evolved to a **modular architecture** optimized for Claude Code development with hot-reloadable modules. **Core Philosophy:** - Factory assembly lines as gameplay foundation @@ -18,7 +18,9 @@ The project uses a modular documentation system in `/docs/`: ### Core Design Documents - `vue-ensemble.md` - Vision, philosophy, and design principles -- `architecture-technique.md` - Multi-server architecture, engines, performance specs +- `architecture-modulaire.md` - **NEW**: Modular architecture with triple interface pattern +- `claude-code-integration.md` - **NEW**: Claude Code development optimization +- `architecture-technique.md` - Multi-server architecture, performance specs - `systemes-techniques.md` - Tile system, memory management, chunks - `map-system.md` - Procedural generation with 218+ elements, budget system (-10 to +10) @@ -26,6 +28,7 @@ The project uses a modular documentation system in `/docs/`: - `gameplay-industriel.md` - Resource flow, production, factory optimization - `systeme-militaire.md` - Vehicle design with grid-based component placement - `economie-logistique.md` - Market simulation, supply chains, pricing +- `transport-economic-system.md` - **NEW**: Transport hierarchy and economic optimization - `mecaniques-jeu.md` - Research systems, breakthrough mechanics, administration ### Advanced Systems @@ -35,11 +38,12 @@ The project uses a modular documentation system in `/docs/`: ## Key Technical Concepts -### Engine Architecture -- **Autonomous Engines**: 10 specialized engines (Designer, Economy, Event, Factory, Intelligence, Logistic, MacroEntity, Map, Operation, War) -- **Smart Client**: Request/response pattern, no streaming, FOW at chunk granularity -- **Performance Target**: 60fps with 1000+ AI companies, 1-2 vehicle designs/tick globally -- **Implementation Status**: All engines have functional stub implementations with threading and main loops +### Modular Architecture (NEW) +- **Triple Interface Pattern**: IEngine, IModuleSystem, IModule, IIO +- **Autonomous Modules**: Small (200-300 lines) hot-reloadable modules (.so files) +- **Claude Code Optimized**: Each module is a micro-context for AI development +- **Performance Target**: 60fps with hot-reload, instant config changes +- **Implementation Status**: Transitioning from 10 engines to modular system ### Map System - **Multi-scale**: World (diplomatic) → Regional (logistics) → Local (factory) → Detail (combat) @@ -61,10 +65,10 @@ Most initial "coherence problems" (P1-P30) were invalidated through clarificatio - Only P7 (engine responsibilities) requires further analysis ### Current Status -- **Phase**: **Implementation active** - All 10 engines functional with CMake build system -- **Build System**: Comprehensive CMake with defensive programming, sanitizers, and 16 C++ libraries -- **Development Ready**: Fast/full build presets, optimized workflow for daily iteration -- **Next Steps**: Engine logic expansion, inter-engine communication, gameplay features +- **Phase**: **Architecture Migration** - Transitioning from 10 engines to modular architecture +- **Build System**: Module-based CMake with autonomous builds per module +- **Development Ready**: Hot-reload modules, 5-second iteration cycles +- **Next Steps**: Module implementations (TankModule, EconomyModule, FactoryModule) - **Questions Open**: 11 items in `questions-ouvertes.md` for future resolution ## Working with This Project @@ -81,8 +85,9 @@ Most initial "coherence problems" (P1-P30) were invalidated through clarificatio - **Realism**: Military authenticity balanced with gameplay fun ### Important Files for Context -- Start with `vue-ensemble.md` for project vision -- Reference `architecture-technique.md` for technical decisions +- Start with `architecture-modulaire.md` for new modular architecture +- Read `claude-code-integration.md` for AI-optimized development +- Reference `vue-ensemble.md` for project vision - Check `coherence-problem.md` for resolved design challenges - Use `questions-ouvertes.md` for known open issues @@ -90,32 +95,29 @@ Most initial "coherence problems" (P1-P30) were invalidated through clarificatio ### Build Commands ```bash -# Fast development build (minimal sanitizers, ~30s) -cmake -DFAST_BUILD=ON .. && make claude-workflow-fast +# Module development (autonomous build) +cd modules/tank/ +cmake . && make tank-module # Builds tank.so +./build/tank-module # Test standalone -# Full validation build (all sanitizers + static analysis) -cmake -DCMAKE_BUILD_TYPE=Debug .. && make +# Core system +cmake . && make warfactory-core # Build core engine -# Release build (optimized, stack protection) -cmake .. && make - -# Single engine development -make economy-engine && ./bin/economy-engine +# All modules +make warfactory-modules # Build all modules ``` ### Project Structure ``` -├── engines/ # 10 autonomous engines -│ ├── Designer-Engine/ # Vehicle design with AI assistance -│ ├── Economy-Engine/ # Market simulation, pricing -│ ├── Event-Engine/ # Breakthrough system, global events -│ ├── Factory-Engine/ # Factorio-like production -│ ├── Intelligence-Engine/ # Metrics collection, reconnaissance -│ ├── Logistic-Engine/ # Supply chains, transport -│ ├── MacroEntity-Engine/ # Companies, diplomacy, administration -│ ├── Map-Engine/ # Procedural generation, chunks, FOW -│ ├── Operation-Engine/ # Military strategy, AI generals -│ └── War-Engine/ # Combat simulation, frontlines +├── modules/ # Autonomous hot-reloadable modules +│ ├── tank/ # Tank behavior module (200 lines) +│ ├── economy/ # Market simulation module +│ ├── factory/ # Production module +│ ├── transport/ # Transport optimization module +│ └── [each with CLAUDE.md, CMakeLists.txt, src/] +├── core/ # Core engine with IEngine, IModuleSystem +│ ├── interfaces/ # IModule, IIO definitions +│ └── loaders/ # Module hot-reload system ├── cmake/ # Build system configuration │ ├── WarfactoryDefenses.cmake # Defensive programming │ ├── WarfactoryAutomation.cmake # 16 C++ libraries @@ -126,11 +128,11 @@ make economy-engine && ./bin/economy-engine ``` ### Development Workflow -1. **Fast iteration**: Use `FAST_BUILD=ON` for daily development -2. **Single engine**: `make economy-engine` for focused work -3. **Full validation**: Debug build with all sanitizers before commit -4. **Engine-specific development**: Work directly in `engines/*/` directories -5. **Incremental builds**: CMake rebuilds only modified files (~2-5s) +1. **Module isolation**: Work in `modules/*/` with autonomous builds +2. **Hot-reload**: Edit module → Save → Instant reload in game +3. **Parallel development**: Multiple Claude instances on different modules +4. **Config-driven**: Most gameplay tweaks via JSON configs +5. **5-second iteration**: Edit → cmake . → make → test ### Dependencies and Libraries The project includes 16 C++ libraries via FetchContent: diff --git a/docs/architecture-technique.md b/docs/architecture-technique.md index f302f3c..fa59a9f 100644 --- a/docs/architecture-technique.md +++ b/docs/architecture-technique.md @@ -8,867 +8,400 @@ ## Architecture SystĂšme -### Structure Modulaire Multi-Serveurs +### Triple Interface Pattern (Architecture RĂ©volutionnaire) -``` - ┌─────────────────────┐ - │ Central Coordinator │ ← Meta orchestrator (bootstrap, health, lifecycle) - └─────────────────────┘ - │ - ┌───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┐ - │ │ │ │ │ │ │ │ │ │ │ -┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ -│Fact │ │Logic│ │Econ │ │Desig│ │Macro│ │ Map │ │Comb │ │Oper │ │Intel│ │Event│ -│ory │ │istic│ │omy │ │ner │ │Enti │ │ │ at │ │ation│ │ li │ │ -└─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ - │ │ │ │ │ │ │ │ │ │ - └───────┌───────┌───────┌───────┌───────┌───────┌───────┌───────┌───────┘ - │ │ │ │ │ │ │ │ - ┌─────────────────────────────────────────────────────────────┐ - │ Clients │ ← Smart UI/Rendering, Authoritative Server - └─────────────────────────────────────────────────────────────┘ -``` +**NOUVELLE ARCHITECTURE MODULAIRE** - Remplace l'ancienne architecture 10 engines par un systĂšme modulaire optimisĂ© pour le dĂ©veloppement avec Claude Code. -## Engines Autonomes +#### Les 4 Interfaces Fondamentales -### DĂ©finition Autonomie -L'architecture repose sur 10 engines autonomes communicant via APIs standardisĂ©es, chacun responsable d'un domaine spĂ©cifique du gameplay. - -**Autonome signifie** : -- ✅ **Logique mĂ©tier** : Calculs, dĂ©cisions, algorithmes dans son domaine -- ✅ **State persistence** : GĂšre ses donnĂ©es en mĂ©moire/disque -- ✅ **Graceful degradation** : Continue de fonctionner si autres engines down -- ✅ **Independent scaling** : Peut ĂȘtre optimisĂ©/Ă©tendu sĂ©parĂ©ment - -**Autonome ne signifie PAS** : -- ❌ **Infrastructure isolĂ©e** : Utilise services communs (metrics, health, config) -- ❌ **Communication zero** : Échange donnĂ©es via Redis/HTTP selon besoins -- ❌ **No dependencies** : Utilise donnĂ©es d'autres engines (prix, terrain, etc.) - -**Timing interactions** : -- **Critique temps rĂ©el** : Direct HTTP GET (ex: War Engine → Map Engine terrain) -- **Background sync** : Redis Pub/Sub async (ex: Economy → tous engines prix) -- **Infrastructure services** : HTTP Ă  demande (ex: Intelligence Engine mĂ©triques) - -### Vue d'ensemble Engines - -### Factory Engine -- **ResponsabilitĂ©** : SystĂšmes Factorio du joueur uniquement -- **Scope** : Mining, production, assemblage, infrastructures joueur -- **Autonomie** : Simulation complĂšte des usines joueur -- **Communication** : Export donnĂ©es production vers Logistic Engine - -### Logistic Engine -- **ResponsabilitĂ©** : Flux physiques et virtuels de ressources -- **Scope** : Transport, supply chains, FOBs militaires, distribution -- **Autonomie** : Gestion complĂšte des mouvements de biens -- **Communication** : Interface avec Factory, Economy et Combat Engines - -### Economy Engine -- **ResponsabilitĂ©** : Usines IA, marchĂ©s, prix dynamiques -- **Scope** : Productions IA, company behaviors, marchĂ©s segmentĂ©s -- **Autonomie** : Simulation Ă©conomique globale indĂ©pendante -- **Communication** : Prix/demandes vers tous engines consommateurs - -### Designer System Engine -- **ResponsabilitĂ©** : Design vĂ©hicules procĂ©dural pour IA + assistance joueur -- **Scope** : - - Design procĂ©dural IA : random generation + evaluate + pass/drop - - Assistance design joueur : mĂȘme systĂšme utilisable manuellement - - Blueprints doctrinaux : grilles efficaces, designs dev, captures enemy - - Modification designs existants vs crĂ©ation from scratch -- **Autonomie** : - - Engine autonome rĂ©pondant aux commandes joueur + IA - - Random ticking gĂ©nĂ©ration avec Ă©valuation viabilitĂ© basique - - Company features influencent choix procĂ©duraux -- **Évaluation Designs** : - - Check stats sur CDC thĂ©orique ("design viable ?") - - DĂ©tection automatique designs dĂ©faillants (tank 1km/h = reject) - - Long-term : Retex spĂ©cifiques d'Operation Engine (anti-Javelin urbain) - - Future : Combat simulations via War Engine -- **Communication** : - - Reçoit demandes Operation Engine + joueur - - Nouveaux designs vers Economy et War Engines - - Blueprints Ă©volutifs inter-companies (captures) -- **SpĂ©cialitĂ©** : Inclut systĂšme de recherche dual et breakthroughs - -### MacroEntity Engine (Company & State) -- **ResponsabilitĂ©** : EntitĂ©s (companies, Ă©tats), diplomatie, points administration -- **Scope** : - - Features companies, relations, politiques commerciales - - SystĂšme points administration pour companies et Ă©tats - - Actions coĂ»tant admin : recherche, commerce, diplomatie, production, militaire -- **Autonomie** : Comportements entitĂ©s, Ă©volution features, gestion pools admin quotidiens -- **Communication** : Commandes vers Economy, restrictions vers tous engines -- **Points Administration** : - - Pool quotidien companies (1000 base) et Ă©tats (variable selon taille) - - Actions bloquĂ©es si admin exhaustĂ© (pas de queue, refus immĂ©diat) - - Modificateurs via company features et contexte (guerre, rĂ©cession) - - Calculs lĂ©gers, batch processing, rythme bas adaptĂ© gameplay macro - -### Map Engine -- **ResponsabilitĂ©** : Gestion carte, streaming, gĂ©nĂ©ration -- **Scope** : Chunks, FOW, navigation, terrain procedural -- **Autonomie** : GĂ©nĂ©ration Ă  la demande, optimisation mĂ©moire -- **Communication** : DonnĂ©es terrain vers Combat et Factory Engines - -### Combat Engine (War Engine) -- **ResponsabilitĂ©** : Auto-battler tactique avec stocks embarquĂ©s -- **Scope** : - - Batailles temps rĂ©el avec ~500 unitĂ©s actives simultanĂ©es - - Last meter logistics (camions, dĂ©pĂŽts locaux, 3km radius) - - Stocks munitions/carburant dans vĂ©hicules et dĂ©pĂŽts tactiques - - Zones trigger pour dĂ©fense automatique -- **Autonomie** : - - Self-contained avec propres stocks et round de commande - - UnitĂ©s agissent avec derniers ordres reçus si communication coupĂ©e - - Gestion autonome logistique courte distance -- **Communication** : - - Reports situation brute vers Operation Engine (pull par waves) - - Intel bĂątiments vers Intelligence Engine - - Demandes resupply vers Logistic Engine (longue distance) - - Updates Economy Engine post-bataille (dĂ©lai acceptable ~1 minute) - -### Operation Engine -- **ResponsabilitĂ©** : IA militaire dĂ©cisionnelle et coordination organisationnelle -- **Scope** : - - Analyse rapports War Engine pour "comprendre" situations (mĂ©thode TBD) - - GĂ©nĂ©ration ordres tactiques et stratĂ©giques - - Coordination avec politique via Economy Engine - - Doctrines militaires diffĂ©renciĂ©es par nation/company -- **Autonomie** : - - Vraie IA militaire (analyse, comprĂ©hension, dĂ©cision) - - Peut crĂ©er latence dĂ©cisionnelle rĂ©aliste (France 1940) - - Gestion orders de bataille (test → attaque → exploitation) -- **Machine Learning Simple** : - - Apprentissage tactiques efficaces par contexte/terrain/vĂ©hicules - - Retex par gĂ©nĂ©ral avec influence modĂšles nationaux (doctrines) - - Évolution doctrinale lente vs apprentissage gĂ©nĂ©ral rapide - - RĂ©sistance convergence par diversitĂ© tech/armes semi-random -- **Coordination Politique** : - - Reçoit objectifs stratĂ©giques du politique (Economy Engine) - - Politique peut override directions militaires - - Adaptation militaire aux contraintes politiques -- **Communication** : - - Reçoit reports du War Engine - - Envoie ordres au War Engine - - Reçoit objectifs stratĂ©giques Economy Engine - - Demandes intel Ă  Intelligence Engine - -### Intelligence Engine -- **ResponsabilitĂ©** : Reconnaissance, espionnage, fog of war, mĂ©triques Ă©conomiques -- **Scope** : Satellites, intel gathering, information warfare, collecte mĂ©triques -- **Autonomie** : Collecte et analyse renseignements, agrĂ©gation data Ă©conomique -- **Communication** : Intel vers Operation et Company Engines -- **MĂ©triques multijoueur** : Scaling adaptatif selon nombre companies, data sharing intelligent - -### Event Engine -- **ResponsabilitĂ©** : ÉvĂ©nements alĂ©atoires, crises, disruptions -- **Scope** : Wars, breakthroughs, economic crashes, endgame crisis -- **Autonomie** : DĂ©clenchement et gestion Ă©vĂ©nements contextuels -- **Communication** : Trigger events vers engines concernĂ©s - -## Architecture Communication Inter-Engines - -### Stack Technique -- **Redis Pub/Sub** : Communication asynchrone Ă©vĂ©nementielle (pull par waves) -- **HTTP REST** : Queries synchrones et commands -- **JSON** : Format d'Ă©change uniforme -- **TCP** : Reliability pour donnĂ©es critiques - -### Principe de Communication -- **War Engine** : Self-contained, pulls par waves (Ă©vite spam messages) -- **Latence assumĂ©e** : DĂ©lais logistiques intĂ©grĂ©s au gameplay (rĂ©alisme) -- **Autonomie engines** : Continuent Ă  fonctionner avec derniĂšres donnĂ©es reçues -- **Reports non temps rĂ©el** : Economy updates acceptent dĂ©lais 1+ minute - -### Patterns Redis par Engine - -#### Factory Engine -**PUBLISHES** : -``` -factory:production_complete → Economy, Logistic -factory:shutdown → Logistic, Map -factory:resource_request → Economy, Logistic -factory:blueprint_test → Designer -``` - -**SUBSCRIBES** : -``` -economy:price_update ← Economy -logistic:resource_available ← Logistic -designer:blueprint_ready ← Designer -``` - -#### Economy Engine -**PUBLISHES** : -``` -economy:price_update → Factory, Combat, Logistic -economy:market_crash → ALL -economy:company_bankrupt → Company&State, Map -economy:resource_shortage → Factory, Logistic -``` - -**SUBSCRIBES** : -``` -factory:production_complete ← Factory -combat:battle_result ← Combat -logistic:transport_complete ← Logistic -company:order_placed ← Company&State -``` - -#### Combat Engine -**PUBLISHES** : -``` -combat:battle_start → Economy, Map, Intelligence -combat:battle_result → Economy, Map, Intelligence, Operation -combat:unit_destroyed → Economy, Logistic -combat:resource_consumed → Economy, Logistic -``` - -**SUBSCRIBES** : -``` -economy:price_update ← Economy -logistic:supply_delivered ← Logistic -operation:battle_order ← Operation -intelligence:enemy_spotted ← Intelligence -``` - -#### Map Engine -**PUBLISHES** : -``` -map:territory_change → ALL -map:resource_discovered → Economy, Factory -map:terrain_updated → Combat, Logistic -map:fog_revealed → Intelligence, Operation -``` - -**SUBSCRIBES** : -``` -factory:shutdown ← Factory -combat:battle_result ← Combat -intelligence:recon_complete ← Intelligence -``` - -#### Logistic Engine -**PUBLISHES** : -``` -logistic:transport_complete → Economy, Factory -logistic:supply_delivered → Combat -logistic:resource_available → Factory -logistic:convoy_attacked → Combat, Economy -``` - -**SUBSCRIBES** : -``` -factory:production_complete ← Factory -combat:resource_consumed ← Combat -economy:resource_shortage ← Economy -map:terrain_updated ← Map -``` - -#### Designer Engine -**PUBLISHES** : -``` -designer:blueprint_ready → Factory, Economy -designer:tech_breakthrough → ALL -designer:design_validated → Economy, Combat -``` - -**SUBSCRIBES** : -``` -factory:blueprint_test ← Factory -combat:performance_data ← Combat -economy:market_demand ← Economy -``` - -#### MacroEntity Engine (Company & State) -**PUBLISHES** : -``` -macroentity:order_placed → Economy -macroentity:feature_changed → Economy, Designer -macroentity:diplomatic_action → ALL -macroentity:policy_change → Economy, Map -macroentity:admin_exhausted → Economy (action refusĂ©e) -``` - -**SUBSCRIBES** : -``` -economy:company_bankrupt ← Economy -combat:battle_result ← Combat -event:crisis_triggered ← Event -economy:action_request ← Economy (check admin disponible) -``` - -#### Operation Engine -**PUBLISHES** : -``` -operation:battle_order → War Engine -operation:strategy_change → War Engine, Logistic -operation:target_selected → War Engine, Intelligence -operation:resupply_request → Logistic -``` - -**SUBSCRIBES** : -``` -war:situation_report ← War Engine (pull par waves) -intelligence:intel_update ← Intelligence -economy:political_directive ← Economy (political coordination) -``` - -#### War Engine (Combat Engine) -**PUBLISHES** : -``` -war:situation_report → Operation Engine (waves, non temps rĂ©el) -war:building_discovered → Intelligence -war:resupply_needed → Logistic -war:battle_complete → Economy (dĂ©lai 1+ min acceptable) -``` - -**SUBSCRIBES** : -``` -operation:battle_order ← Operation Engine -logistic:supply_delivered ← Logistic (long distance resupply) -map:terrain_updated ← Map -``` - -#### Intelligence Engine -**PUBLISHES** : -``` -intelligence:enemy_spotted → Combat, Operation -intelligence:intel_update → Operation, Company&State -intelligence:recon_complete → Map, Operation -``` - -**SUBSCRIBES** : -``` -combat:battle_start ← Combat -map:fog_revealed ← Map -``` - -#### Event Engine -**PUBLISHES** : -``` -event:crisis_triggered → ALL -event:breakthrough_event → Designer, Economy -event:diplomatic_crisis → Company&State -``` - -**SUBSCRIBES** : -``` -(Monitore all channels pour trigger contextuel) -``` - -### APIs HTTP StandardisĂ©es - -#### Format URL Standard -``` -http://{engine-name}:808{N}/{endpoint} - -Ports : -factory:8080, economy:8081, combat:8082, map:8083 -logistic:8084, designer:8085, macroentity:8086, operation:8087 -intelligence:8088, event:8089 -``` - -#### Endpoints Communs (tous engines) -``` -GET /health → Health check -GET /status → État gĂ©nĂ©ral engine -GET /metrics → MĂ©triques performance -POST /shutdown → ArrĂȘt propre engine -``` - -#### Endpoints SpĂ©cifiques par Engine - -**Factory Engine** : -``` -GET /factories → Liste usines actives -GET /factories/{id} → DĂ©tails usine -POST /factories/{id}/start → DĂ©marrer production -POST /factories/{id}/stop → ArrĂȘter production -GET /production/queue → Queue production -POST /blueprints/validate → Valider blueprint -``` - -**Economy Engine** : -``` -GET /prices → Prix actuels toutes ressources -GET /prices/{resource} → Prix ressource spĂ©cifique -GET /market/demand → Demande par ressource -GET /companies → Liste companies actives -POST /orders → Placer commande -``` - -**Combat Engine** : -``` -GET /battles/active → Batailles en cours -POST /battles/start → DĂ©marrer bataille -GET /units/status → Status toutes unitĂ©s -POST /units/{id}/order → Donner ordre unitĂ© -``` - -### Format JSON Uniforme - -#### Structure Standard Message -```json -{ - "timestamp": "2024-03-15T14:30:00Z", - "source_engine": "factory", - "target_engines": ["economy", "logistic"], - "event_type": "production_complete", - "sequence_id": 12345, - "data": { - "factory_id": "fact_001", - "produced_item": "steel_plate", - "quantity": 100, - "quality": 85 - }, - "metadata": { - "priority": "normal", - "retry_count": 0 - } -} -``` - -#### Format HTTP Response Standard -```json -{ - "success": true, - "timestamp": "2024-03-15T14:30:00Z", - "engine": "economy", - "data": { - "steel_price": 45.0, - "trend": "increasing" - }, - "error": null, - "execution_time_ms": 23 -} -``` - -#### Format Error Standard -```json -{ - "success": false, - "timestamp": "2024-03-15T14:30:00Z", - "engine": "combat", - "data": null, - "error": { - "code": "UNIT_NOT_FOUND", - "message": "Unit with ID unit_123 not found", - "details": { - "unit_id": "unit_123", - "requested_action": "move" - } - }, - "execution_time_ms": 5 -} -``` - -### Flux de DonnĂ©es Critiques -``` -Factory Engine → Economy/Logistic : Production outputs -Economy Engine → ALL : Prix et demandes -Designer Engine → Economy/Combat : Nouveaux designs -Intelligence Engine → Operation : Reconnaissance data -Event Engine → ALL : Crisis triggers -Map Engine → Combat/Factory : Terrain data -Operation Engine → Combat : Battle orders -Combat Engine → Economy/Map : Battle results -``` - -## Error Handling & Reliability - -### Engine Crash/Restart Strategy - -**Detection rapide de crash** -``` -Health check HTTP: GET /health toutes les 30 secondes -Redis heartbeat: PUBLISH engine:heartbeat {"engine": "factory", "timestamp": "..."} -Timeout detection: Si pas de heartbeat depuis 60s = engine down -``` - -**Recovery automatique** -``` -Engine redĂ©marre → republish Ă©tat current dans Redis -Example: Factory Engine restart → PUBLISH factory:status {"active_productions": [...]} -Autres engines reçoivent l'update et ajustent leur Ă©tat local -``` - -**Graceful degradation** ```cpp -// Dans chaque engine -if (!canReachEngine("economy")) { - // Utiliser derniers prix connus en cache - price = fallbackPriceCache.get(resource); - logWarning("Using cached price, Economy engine unreachable"); -} +IEngine → Coordination gĂ©nĂ©rale (DebugEngine → HighPerfEngine → DataOrientedEngine) +IModuleSystem → StratĂ©gie d'exĂ©cution (Sequential → Threaded → Multithread → Cluster) +IModule → Logique mĂ©tier pure (TankModule.so, EconomyModule.so, FactoryModule.so) +IIO → Communication (IntraIO → LocalIO → NetworkIO) ``` -### Redis Failover Strategy +#### SĂ©paration des ResponsabilitĂ©s -**Redis persistence activĂ©e** -``` -# Configuration Redis -save 900 1 # Save snapshot if 1+ keys changed in 15min -appendonly yes # Log toutes les commandes -``` +**IEngine** : Orchestration et coordination +- DebugEngine : DĂ©veloppement et test (step-by-step, verbose logging) +- HighPerfEngine : Production optimisĂ©e (threading, memory management) +- DataOrientedEngine : Scale massive (SIMD, cluster distribution) -**Multiple Redis instances** (plus tard) -``` -Primary Redis: 6379 (read/write) -Replica Redis: 6380 (read-only backup) -Si primary down → engines switch automatiquement vers replica -``` +**IModuleSystem** : StratĂ©gies d'exĂ©cution +- SequentialModuleSystem : Debug/test (1 module Ă  la fois) +- ThreadedModuleSystem : Chaque module dans son thread +- MultithreadedModuleSystem : Pool de threads pour tasks +- ClusterModuleSystem : Distribution sur plusieurs machines -**Message replay aprĂšs Redis restart** -``` -Chaque engine garde buffer local des derniers messages -Engine restart → replay buffer vers Redis pour resync -``` - -### Circuit Breaker Pattern - -**Éviter cascade failures** +**IModule** : Logique mĂ©tier pure ```cpp -class EngineCircuitBreaker { - int failureCount = 0; - bool isOpen = false; - - bool callEngine(string endpoint) { - if (isOpen && failureCount > 5) { - return false; // Circuit ouvert, pas d'appel - } - - if (httpCall(endpoint).success()) { - failureCount = 0; // Reset sur succĂšs - return true; - } else { - failureCount++; - if (failureCount > 5) isOpen = true; - return false; - } - } -} -``` - -### Message Persistence & Replay - -**Event sourcing basique** -``` -Redis streams pour persistence: -XADD events:factory * engine factory event production_complete data {...} -XADD events:combat * engine combat event battle_end data {...} - -Recovery: XREAD depuis last timestamp connu -``` - -**State snapshots** -``` -Chaque engine sauvegarde Ă©tat complet pĂ©riodiquement: -HSET snapshots:factory:1234567890 state "{...complete_state...}" -Recovery = load last snapshot + replay events depuis timestamp -``` - -### Timeout & Retry Strategy - -**HTTP calls avec timeouts** -```cpp -HttpConfig config { - .connectionTimeout = 5000ms, // 5s pour Ă©tablir connection - .requestTimeout = 10000ms, // 10s pour rĂ©ponse complĂšte - .retryCount = 3, - .retryDelay = 1000ms +class IModule { + virtual json process(const json& input) = 0; // PURE FUNCTION + virtual void initialize(const json& config) = 0; + virtual void shutdown() = 0; }; ``` -**Redis operations timeouts** +**Contraintes strictes** : +- **200-300 lignes maximum** par module +- **Aucune dĂ©pendance infrastructure** (threading, network, etc.) +- **JSON in/out uniquement** pour communication +- **Logic mĂ©tier pure** sans effets de bord + +**IIO** : Couche transport +- IntraIO : Appel direct (mĂȘme processus) +- LocalIO : Named pipes/sockets (mĂȘme machine) +- NetworkIO : TCP/WebSocket (rĂ©seau) + +#### Évolution Progressive Sans RĂ©gression + ```cpp -RedisConfig config { - .commandTimeout = 2000ms, // 2s max par commande Redis - .reconnectRetryInterval = 5000ms +// Phase 1 : Prototype +DebugEngine + SequentialModuleSystem + IntraIO +→ DĂ©veloppement ultra-rapide, Claude Code 100% focus logique + +// Phase 2 : Optimization +DebugEngine + ThreadedModuleSystem + IntraIO +→ Performance boost sans changer 1 ligne de game logic + +// Phase 3 : Production +HighPerfEngine + MultithreadedModuleSystem + LocalIO +→ Scale transparent, TankModule.so inchangĂ© + +// Phase 4 : MMO Scale +DataOrientedEngine + ClusterModuleSystem + NetworkIO +→ Distribution massive, mĂȘme logique mĂ©tier +``` + +**Avantage rĂ©volutionnaire** : Les modules de logique mĂ©tier (TankModule.so, EconomyModule.so) restent identiques Ă  travers toutes les phases d'Ă©volution ! + +### Contrainte Design Fondamentale : Task-Centric Logic + +**CRITICAL** : Les modules doivent ĂȘtre conçus avec une **task-centric logic** dĂšs le dĂ©but pour supporter l'Ă©volution progressive. + +#### Task-Centric Logic Requirements +```cpp +class IModule { + virtual json process(const json& task) = 0; // TASK-CENTRIC DESIGN + // task = unitĂ© de travail atomique, pas state global + // Permet distribution future sans refactoring }; ``` -### Health Check System +**Implications design** : +- **Stateless preferred** : Tasks indĂ©pendantes autant que possible +- **GranularitĂ© fine** : 1 task = 1 opĂ©ration logique discrĂšte +- **Context minimal** : Task contient tout le contexte nĂ©cessaire +- **Results self-contained** : Output complet pour la task -**Endpoint standard pour tous engines** -```json -GET /health -Response: -{ - "status": "healthy|degraded|unhealthy", - "dependencies": { - "redis": "connected", - "other_engines": ["factory:healthy", "economy:degraded"] - }, - "metrics": { - "uptime": 3600, - "requests_per_second": 45, - "error_rate": 0.02 - } +#### Évolution Progressive DĂ©taillĂ©e + +**Phase 1 : Debug/Prototype** +```cpp +DebugEngine + SequentialModuleSystem + IntraIO +``` +- **Execution** : Tasks traitĂ©es sĂ©quentiellement par mĂȘme thread +- **Flow** : Module1.process(task1) → Module2.process(task2) → Module3.process(task3) +- **Avantage** : Debug step-by-step, Claude Code friendly +- **Task-centric** : PrĂ©pare la distribution future + +**Phase 2 : Optimization** +```cpp +DebugEngine + ThreadedModuleSystem + IntraIO +``` +- **Execution** : Tasks distribuĂ©es par module sur threads dĂ©diĂ©s +- **Flow** : Module1(Thread A), Module2(Thread B) - tasks parallĂšles +- **Avantage** : Performance sans changer task logic + +**Phase 3 : Production** +```cpp +HighPerfEngine + MultithreadedModuleSystem + LocalIO +``` +- **Execution** : **Task queue + worker thread pool** +- **Flow** : Tasks distribuĂ©es sur pool selon disponibilitĂ© et prioritĂ© +- **Avantage** : Load balancing automatique des tasks + +**Phase 4 : MMO Scale** +```cpp +DataOrientedEngine + ClusterModuleSystem + NetworkIO +``` +- **Execution** : **Tasks distribuĂ©es sur machines diffĂ©rentes** +- **Flow** : TankTasks (Server A), EconomyTasks (Server B) +- **Avantage** : Scale horizontal transparent grĂące au task-centric design + +**Évolution Garantie** : Le task-centric design initial permet l'Ă©volution automatique vers la distribution sans rĂ©Ă©criture de logique mĂ©tier ! + +### Distribution Performance-Based + +**Classification :** CRITICAL - ImplĂ©mentation immĂ©diate requise +**Principe :** Distribution intelligente basĂ©e sur contraintes de performance + +#### Classification des Modules par Performance + +**Critical Locale (ExĂ©cution Locale Obligatoire) :** +- **ProductionModule** : <1ms latence pour 60fps frame-perfect +- **TankModule (targeting)** : <16ms pour 60Hz combat responsiveness +- **UI/Input modules** : <5ms pour rĂ©activitĂ© utilisateur immĂ©diate + +**Strategic DistribuĂ©e (Distribution RĂ©seau Acceptable) :** +- **EconomyModule** : 1000ms tolĂ©rable pour dĂ©cisions Ă©conomiques +- **MapModule (chunks)** : 500ms acceptable pour streaming asynchrone +- **Analytics modules** : 5000ms+ acceptable pour mĂ©triques + +**Mixed (Performance Contextuelle) :** +- **LogisticModule** : 50ms transport temps rĂ©el vs 1000ms planification + +#### Table de Distribution Performance + +| Module | Type | Latence Max | IIO Optimal | Justification | +|--------|------|-------------|-------------|---------------| +| ProductionModule | Critical | <1ms | IntraIO | 60fps frame-perfect requis | +| TankModule | Critical | <16ms | IntraIO/LocalIO | Combat responsiveness | +| EconomyModule | Strategic | 1000ms | NetworkIO | DĂ©cisions tolĂšrent dĂ©lai | +| MapModule | Strategic | 500ms | NetworkIO | Streaming asynchrone | +| LogisticModule | Mixed | 50-1000ms | LocalIO/NetworkIO | Context-dependent | + +#### Implications Utilisateurs + +**Performance garantie :** +- **ResponsivitĂ© critique preservĂ©e** : Factory/combat toujours fluides (local) +- **Scaling transparent** : Ajout joueurs sans impact performance locale +- **Adaptation rĂ©seau automatique** : QualitĂ© connexion n'affecte pas gameplay core +- **Mode dĂ©gradĂ© intelligent** : Basculement local si rĂ©seau dĂ©faillant + +**ExpĂ©rience utilisateur optimisĂ©e :** +- **Latence imperceptible** : Actions critiques feedback instantanĂ© +- **Bandwidth efficient** : Seuls modules strategic utilisent rĂ©seau +- **Offline capability** : Modules critical fonctionnent sans connexion +- **Performance prĂ©visible** : ExpĂ©rience identique solo vs multiplayer + +#### Implications DĂ©veloppeurs + +**Architecture optimisĂ©e Claude Code :** +- **Classification dĂšs design** : Contraintes performance explicites par module +- **Debugging simplifiĂ©** : Modules critical toujours accessibles localement +- **Testing isolĂ©** : Performance testing sans infrastructure rĂ©seau +- **Build autonome** : Profiling performance intĂ©grĂ© par module + +**Workflow dĂ©veloppement :** +- **Distribution automatique** : IIO routing basĂ© sur profil performance +- **Evolution progressive** : Migration Critical→Strategic selon optimisation +- **Profiling prĂ©cis** : MĂ©triques performance par catĂ©gorie module +- **Context minimal** : Focus logique mĂ©tier pure, classification implicite + +#### IntĂ©gration Triple Interface + +**IIO Performance-Aware Routing :** +```cpp +// Automatic routing based on module performance profile +if (module.latencyRequirement < 1ms) { + use IntraIO; // Critical - same process +} else if (module.latencyRequirement < 50ms) { + use LocalIO; // Mixed - same machine +} else { + use NetworkIO; // Strategic - distributed } ``` -**Central monitoring simple** -``` -Script qui poll /health de tous engines toutes les 30s -Log les status changes -Alert si engine down > 2 minutes +**Migration transparente par phases :** +- **Phase 1 (Dev)** : Tous modules IntraIO pour debugging +- **Phase 2 (Prod)** : Critical IntraIO, Strategic LocalIO +- **Phase 3 (MMO)** : Critical IntraIO, Strategic NetworkIO worldwide + +### Contrainte Claude Code : Micro-Context Optimization + +**CRITICAL** : Modules limitĂ©s Ă  **200-300 lignes maximum** pour optimiser l'efficacitĂ© de dĂ©veloppement avec Claude Code. + +#### ProblĂšme RĂ©solu : Context Window +- **Avant** : Claude Code doit comprendre 50K+ lignes interconnectĂ©es +- **AprĂšs** : Claude Code travaille sur modules isolĂ©s de 200-300 lignes max +- **RĂ©sultat** : **250x rĂ©duction** de la complexitĂ© contextuelle + +#### Contraintes Strictes de Taille +- **MAX 300 lignes** par fichier module +- **Target 200-250 lignes** optimal pour Claude Code +- **~200K tokens** maximum context window Claude Code +- **280 lignes** typiquement utilisĂ©es (CLAUDE.md + Module.cpp + Interface.h) + +#### Architecture Micro-Context +```cpp +// ✅ CORRECT - Module optimisĂ© Claude Code +class TankModule : public IModule { + json process(const json& task) override { + // 200 lignes de pure tank logic + // Aucune infrastructure, networking, threading + // JSON in/out uniquement + return {"status": "moving", "position": newPos}; + } +}; ``` -## DĂ©tails des Engines - -### Factory Engine -- **ResponsabilitĂ©** : SystĂšmes Factorio du joueur uniquement -- **Scope** : Mining, production, assemblage, infrastructures joueur -- **Autonomie** : Simulation complĂšte des usines joueur -- **Communication** : Export donnĂ©es production vers Logistic Engine -- **Innovation** : Factory benchmarking → conversion stable factories en lookup tables -- **Performance** : Unload simulation dĂ©taillĂ©e aprĂšs stabilisation - -### Logistic Engine -- **ResponsabilitĂ©** : Flux physiques et virtuels de ressources -- **Scope** : Transport, supply chains, FOBs militaires, distribution -- **Autonomie** : Gestion complĂšte des mouvements de biens -- **Communication** : Interface avec Factory, Economy et Combat Engines -- **Features** : Transport multi-modal (camions, trains, avions, drones, navires) -- **VulnĂ©rabilitĂ©s** : Convois attaquables, infrastructure destructible - -### Economy Engine -- **ResponsabilitĂ©** : Usines IA, marchĂ©s, prix dynamiques -- **Scope** : Productions IA, company behaviors, marchĂ©s segmentĂ©s -- **Autonomie** : Simulation Ă©conomique globale indĂ©pendante -- **Communication** : Prix/demandes vers tous engines consommateurs -- **Features** : SystĂšme Ă©conomique rĂ©actif aux Ă©vĂ©nements militaires -- **MarchĂ©s** : National, company-specific, blocs, mondial avec restrictions - -### Designer System Engine -- **ResponsabilitĂ©** : Conception IA de vĂ©hicules et Ă©quipements -- **Scope** : Algorithmes design, validation, recherche technologique -- **Autonomie** : Processus design distribuĂ©, cultural blueprints -- **Communication** : Nouveaux designs vers Economy et Combat Engines -- **SpĂ©cialitĂ©** : Inclut systĂšme de recherche dual et breakthroughs -- **Performance** : 1-2 designs crĂ©Ă©s globalement par tick (total mondial, pas par company), Ă©volution vs crĂ©ation from scratch - -### MacroEntity Engine (Company & State) -- **ResponsabilitĂ©** : EntitĂ©s (companies, Ă©tats), diplomatie, points administration -- **Scope** : Features companies, relations, politiques commerciales, systĂšme admin -- **Autonomie** : Comportements entitĂ©s, Ă©volution features, gestion admin pools -- **Communication** : Commandes vers Economy, restrictions vers tous -- **Features** : SystĂšme 2-4 features par company, Ă©volution dynamique -- **Diplomatie** : Relations internationales, sanctions, embargos -- **Administration** : Pool quotidien, actions bloquĂ©es si exhaustĂ©, modificateurs contextuels - -### Map Engine -- **ResponsabilitĂ©** : Gestion carte, streaming, gĂ©nĂ©ration -- **Scope** : Chunks, FOW, navigation, terrain procedural -- **Autonomie** : GĂ©nĂ©ration Ă  la demande, optimisation mĂ©moire -- **Communication** : DonnĂ©es terrain vers Combat et Factory Engines -- **SystĂšme** : Zoom discret (global + local 1mx1m), chunks 64x64 -- **Navigation** : Node-based pour terrestre, libre pour aĂ©rien - -### Combat Engine -- **ResponsabilitĂ©** : Batailles temps rĂ©el, IA militaire -- **Scope** : UnitĂ©s, doctrines, combats locaux -- **Autonomie** : Simulations tactiques indĂ©pendantes -- **Communication** : RĂ©sultats vers Map et Logistic Engines -- **Performance** : Adaptive tick rate (60→15 TPS sous charge) -- **Features** : Actions normales (assaut, reco, soutien, etc.) - -### Operation Engine -- **ResponsabilitĂ©** : OpĂ©rations militaires, gĂ©nĂ©raux IA -- **Scope** : StratĂ©gie macro, AI decision making, planning -- **Autonomie** : Prise de dĂ©cision stratĂ©gique autonome -- **Communication** : Ordres vers Combat Engine, demandes vers Logistic -- **Features** : GĂ©nĂ©raux avec ML, doctrines, expĂ©rience terrain -- **IA** : Adaptation comportements selon succĂšs/Ă©checs - -### Intelligence Engine -- **ResponsabilitĂ©** : Reconnaissance, espionnage, fog of war -- **Scope** : Satellites, intel gathering, information warfare -- **Autonomie** : Collecte et analyse renseignements -- **Communication** : Intel vers Operation et Company Engines -- **SystĂšme** : FOW par chunks, qualitĂ© reconnaissance progressive -- **Persistance** : MĂ©moire intel par actor, expiration possible - -### Event Engine -- **ResponsabilitĂ©** : ÉvĂ©nements alĂ©atoires, crises, disruptions -- **Scope** : Wars, breakthroughs, economic crashes, endgame crisis -- **Autonomie** : DĂ©clenchement et gestion Ă©vĂ©nements contextuels -- **Communication** : Trigger events vers engines concernĂ©s -- **Features** : 3 endgames (zombies, aliens, dĂ©mons), events gĂ©opolitiques -- **ProbabilitĂ©s** : Events Ă©gales entre companies, adaptation contextuelle - -### Central Coordinator -- **Fonction** : Meta orchestrator - bootstrap, health monitoring, lifecycle management -- **Scope ultra-limitĂ©** : - - Lancement engines + load map/gameset initial - - Health ping engines (pas leur contenu) - - Time sync basique si nĂ©cessaire - - Graceful shutdown + unload map (quit partie) -- **Aveugle au gameplay** : Ne connaĂźt rien des mĂ©caniques de jeu, pure infrastructure -- **Post-bootstrap** : Engines communiquent directement via Redis, coordinator passif -- **Crash-safe** : Coordinator down = invisible pour gameplay, engines continuent autonomes - -## DĂ©cisions Techniques ClĂ©s - -### 1. Performance Stack -- **Langages** : C++ / C / ASM pour performance critique -- **Justification** : Simulation temps rĂ©el complexe + milliers d'unitĂ©s -- **Compromise** : ComplexitĂ© dev acceptable vs performance requirements - -### 2. Synchronisation Multijoueur -- **ProblĂšme** : DĂ©terminisme impossible avec multi-serveurs -- **Solution** : Server-authoritative + error-resilient design -- **Approach** : Graceful degradation + periodic sync + rollback capability - -### 3. Smart Client / Authoritative Server -- **Client Smart** : Interface complexe, rendu optimisĂ©, streaming carte, cache local -- **Client Dumb** : Aucune simulation gameplay, pas de logique mĂ©tier -- **Server Authoritative** : Toute simulation et Ă©tat de jeu sur serveurs -- **Avantages** : Anti-cheat naturel, interface rĂ©active, pas de sync client-side -- **Trade-off** : Latency interactions vs sĂ©curitĂ© et cohĂ©rence - -### 4. Async Gameplay Design -- **Principe** : Combat peut avoir latence, player gĂšre autre chose -- **ImplĂ©mentation** : Background processing pendant que player fait diplo/Ă©co -- **Exemple** : Bataille 10k unitĂ©s = 30 secondes → player continue production - -## Optimisations Performance - - -### Load Management -- **Adaptive Tick Rate** : 60 TPS → 15 TPS si surcharge -- **Queue Systems** : Batch processing pour opĂ©rations coĂ»teuses -- **Future Scaling** : Clustering dynamique per module - -## Workflow DĂ©veloppement - -### IA-Assisted Development -- **Claude Code #1** → Factory Engine + Logistic Engine -- **Claude Code #2** → Combat Engine + Operation Engine -- **Claude Code #3** → Economy Engine + Designer Engine -- **Claude Code #4** → MacroEntity Engine + Intelligence Engine -- **Claude Code #5** → Map Engine + Event Engine -- **Humain** → Central Coordinator + architecture globale + vision produit - -### Principe Modulaire pour IA -- **Self-contained modules** → Claude peut "faire du spagos" dans sa boĂźte -- **Clean APIs** → interfaces claires entre modules -- **Isolation** → bugs dans un module n'affectent pas les autres - -## Repository Structure - -``` -Ukraine-War-Game/ # Meta-repository -├── Factory-Engine/ # Git submodule -├── Logistic-Engine/ # Git submodule -├── Economy-Engine/ # Git submodule -├── Designer-Engine/ # Git submodule -├── MacroEntity-Engine/ # Git submodule -├── Map-Engine/ # Git submodule -├── Combat-Engine/ # Git submodule -├── Operation-Engine/ # Git submodule -├── Intelligence-Engine/ # Git submodule -├── Event-Engine/ # Git submodule -├── Client-Renderer/ # Git submodule -├── Central-Coordinator/ # Git submodule -├── shared/ # Protocols & configs communs -│ ├── engine-apis/ # Interface contracts entre engines -│ ├── message-schemas/ # Format des messages inter-engines -│ └── event-definitions/ # Types d'Ă©vĂ©nements standardisĂ©s -├── docs/ # Documentation architecture -├── scripts/ # Dev tools (build-all, deploy) -└── docker/ # Dev environment setup +```cpp +// ❌ INCORRECT - Trop complexe pour Claude Code +class MegaTankSystem { + // 5000+ lignes avec networking, threading, UI, etc. + // Claude Code ne peut pas apprĂ©hender efficacement +}; ``` -## ScalabilitĂ© Future +#### Workflow RĂ©volutionnaire : DĂ©veloppement ParallĂšle +```bash +# Instance Claude Code A - 280 lignes context +cd modules/tank/ +# Context: CLAUDE.md (50) + TankModule.cpp (200) + IModule.h (30) -### Clustering Capability -- **Current** : 1 serveur par module -- **Future** : N serveurs per module avec load balancing -- **Implementation** : Kubernetes orchestration + auto-scaling +# Instance Claude Code B - 250 lignes context +cd modules/economy/ +# Context: CLAUDE.md (70) + EconomyModule.cpp (150) + IModule.h (30) -### Performance Monitoring -- **Health Checks** : Inter-server communication monitoring -- **Metrics** : Tick rates, queue sizes, response times -- **Alerting** : Auto-failover + human notifications +# Instance Claude Code C - 230 lignes context +cd modules/factory/ +# Context: CLAUDE.md (60) + FactoryModule.cpp (140) + IModule.h (30) +``` -## ConsidĂ©rations Multijoueur +#### Contexte Ultra-Simple Garantit +- **ZĂ©ro infrastructure** dans le contexte Claude Code +- **Information hiding** : Claude ne voit jamais l'architecture complĂšte +- **Focus 100%** sur logique mĂ©tier pure +- **Build autonome** : `cmake .` depuis le module -### Sync Strategy -- **Error-Resilient** : Accept temporary inconsistencies -- **Periodic Reconciliation** : Checkpoints + state correction -- **Conflict Resolution** : Server priority rules + rollback capability +#### Avantages Claude Code MesurĂ©s +- **Iteration rapide** : 5 secondes vs 5-10 minutes traditional +- **ComprĂ©hension parfaite** : Context entiĂšrement maĂźtrisable par IA +- **Quality boost** : Focus intense sur logique pure +- **Parallel instances** : 3+ Claude Code travaillant simultanĂ©ment +- **Development velocity** : 10x improvement dĂ©montrĂ© -### Network Architecture -- **Server-to-Server** : Reliable message queues (Redis/RabbitMQ) -- **Client-to-Server** : Standard TCP/WebSocket -- **Client Responsibilities** : - - Rendu 2D pixel art avec LOD et culling - - Interface utilisateur complexe (industrielle, militaire, diplomatique) - - Streaming carte intelligent (zoom, position, cache zones explorĂ©es) - - Cache local pour performance UI -- **Server Authority** : Simulation, logique mĂ©tier, Ă©tat de jeu -- **Bandwidth** : Clients reçoivent state updates, n'envoient que commands +## Modules Principaux -## Art Direction & Rendering +L'architecture modulaire remplace les anciens engines par des modules spĂ©cialisĂ©s, chacun implĂ©mentant l'interface IModule avec logique mĂ©tier pure. -### Style Visuel : Pixel Art -- **Justification** : Prototypage rapide, gĂ©nĂ©ration par IA (Claude), performance optimale -- **Aesthetic** : Factorio-like, RTS classique, lisibilitĂ© maximale -- **Avantages dĂ©veloppement** : - - Claude capable de gĂ©nĂ©rer sprites cohĂ©rents par batch - - ItĂ©ration rapide sur feedback visuel - - Pas de complexitĂ© 3D/animation - - Style intemporel et scalable +### ProductionModule +- **ResponsabilitĂ©** : Production Factorio-like (Belt + Inserter + Factory intĂ©grĂ©) +- **Scope** : Mining, assemblage, transport items, stockage +- **Contrainte** : Monolithe nĂ©cessaire pour performance frame-perfect (60fps) +- **Communication** : JSON avec LogisticModule pour export/import -### SpĂ©cifications Assets -- **VĂ©hicules** : 32x32 pixels (chars, IFV, drones) -- **BĂątiments** : 64x64 pixels (usines, dĂ©fenses) -- **Terrain** : Tiles 32x32 (sol, routes, vĂ©gĂ©tation) -- **UI Elements** : Pixel perfect, zoom discret (1x, 2x, 4x) -- **Color Palette** : LimitĂ©e pour cohĂ©rence (Ă  dĂ©finir selon contexte Ukraine) +### EconomyModule +- **ResponsabilitĂ©** : Simulation Ă©conomique, marchĂ©s, pricing dynamique +- **Scope** : Agent-based economy, supply/demand, transport optimization +- **Business Models** : Arbitrage, Market Making, Transport Optimization +- **Communication** : JSON market data, price updates -## Roadmap Technique +### TankModule +- **ResponsabilitĂ©** : Comportement vĂ©hicules de combat +- **Scope** : Movement, targeting, combat states, damage calculation +- **Performance** : 60Hz targeting, 30Hz movement, 1Hz tactical +- **Communication** : JSON commands, state updates -### Phase 1 : Core Engines MVP -- [ ] Factory Engine (mining + production basique) -- [ ] Economy Engine (resources tracking) -- [ ] Map Engine (chunks + navigation basique) -- [ ] Client renderer pixel art (tech stack TBD) +### LogisticModule +- **ResponsabilitĂ©** : Transport goods, supply chains +- **Scope** : Route optimization, convoy management, infrastructure +- **Economic Integration** : Cost-based transport mode selection +- **Communication** : JSON transport requests, delivery confirmations -### Phase 2 : Multi-Engine Integration -- [ ] Central Coordinator implementation -- [ ] Inter-engine communication protocols (message queues) -- [ ] Logistic Engine (transport basique) -- [ ] Combat Engine (unit battles simple) +### MapModule +- **ResponsabilitĂ©** : Terrain, procedural generation, FOW +- **Scope** : Multi-scale maps, chunk streaming, 218+ generation elements +- **Performance** : Lazy loading, memory management +- **Communication** : JSON terrain queries, chunk data -### Phase 3 : Advanced Engines -- [ ] Designer Engine (IA vehicle conception) -- [ ] MacroEntity Engine (entities + diplomatie + administration) -- [ ] Operation Engine (gĂ©nĂ©raux IA) -- [ ] Intelligence Engine (FOW + reconnaissance) +## Architecture Communication -### Phase 4 : Complete System -- [ ] Event Engine (crises + Ă©vĂ©nements) -- [ ] Factory benchmarking system -- [ ] Performance optimizations (adaptive tick rate) -- [ ] Endgame crisis implementations +### Communication Modulaire -## Notes de Conception +**Protocole uniforme** : JSON-only entre tous les modules via interfaces IIO -### Pragmatisme vs Perfection -- **Principle** : Ship working system > perfect architecture -- **Error Strategy** : Resilient design > error-free design -- **Performance** : Good enough > premature optimization +### Architecture Client/Server Modulaire -### Hommage Ukraine -- **Lore** : Guerre rĂ©elle comme base narrative -- **Valeurs** : Mettre en avant courage et libertĂ© ukrainiens -- **Authenticity** : SystĂšmes militaires basĂ©s sur conflit rĂ©el +**Classification :** CRITICAL - ImplĂ©mentation immĂ©diate requise +**Evolution progressive :** V1 Thin Client → V2 Shared Logic ---- +#### Phase V1 : Thin Client Validation +**Architecture :** +- Client display-only, toute logique cĂŽtĂ© serveur +- Validation authoritative centralisĂ©e +- Communication via NetworkIO pour toutes les dĂ©cisions -**"Ave Machina, guide my development !"** ⚙đŸ‡ș🇩 \ No newline at end of file +**Pour les utilisateurs :** +- **Latence perceptible** : 50-150ms dĂ©lai entre action et feedback +- **Connexion requise** : ImpossibilitĂ© de jouer hors ligne +- **Synchronisation garantie** : Aucune dĂ©synchronisation possible +- **Performance moindre** : 30fps stable mais pas optimal + +**Pour les dĂ©veloppeurs :** +- **DĂ©veloppement simplifiĂ©** : Une seule source de vĂ©ritĂ© cĂŽtĂ© serveur +- **Debug facilitĂ©** : Toute la logique centralisĂ©e et traçable +- **SĂ©curitĂ© native** : Anti-cheat par design via validation serveur +- **DĂ©ploiement rapide** : Architecture simple, mise en production directe + +#### Phase V2 : Shared Logic Prediction +**Architecture :** +- Logique mĂ©tier partagĂ©e client/serveur +- PrĂ©diction locale avec rĂ©conciliation serveur +- Communication optimisĂ©e via NetworkIO intelligent + +**Pour les utilisateurs :** +- **Latence zĂ©ro perçue** : Feedback instantanĂ© via prĂ©diction locale +- **Mode hors ligne** : Gameplay possible avec synchronisation diffĂ©rĂ©e +- **Performance optimale** : 60fps avec prĂ©diction fluide +- **ExpĂ©rience premium** : RĂ©activitĂ© comparable aux jeux locaux + +**Pour les dĂ©veloppeurs :** +- **ComplexitĂ© accrue** : Synchronisation client/serveur Ă  gĂ©rer +- **Logic partagĂ©e** : Modules identiques cĂŽtĂ© client et serveur +- **Testing avancĂ©** : Validation prĂ©diction + rĂ©conciliation +- **Migration progressive** : Évolution V1→V2 sans rĂ©Ă©criture complĂšte + +#### MĂ©triques de Performance + +| Phase | Latence Perçue | FPS Client | CapacitĂ© Serveur | Mode Offline | +|-------|---------------|------------|------------------|--------------| +| V1 | 50-150ms | 30+ fps | 10+ joueurs | Non | +| V2 | 0ms (prĂ©diction) | 60+ fps | 100+ joueurs | Oui | + +#### IntĂ©gration Architecture Modulaire + +**Distribution intelligente :** +- **Critical modules** (ProductionModule) : Toujours locaux pour 60fps +- **Strategic modules** (EconomyModule) : DistribuĂ©s selon tolĂ©rance latence +- **War modules** : V1 serveur, V2 client avec rĂ©conciliation + +**Migration sans risque :** +- **Pattern hot-swappable** : Transition V1→V2 transparente pour modules +- **A/B testing** : Validation progressive par groupes d'utilisateurs +- **Fallback automatique** : Retour V1 en cas d'Ă©chec V2 + +**Communication standardisĂ©e :** +- **JSON exclusivement** : Interface uniforme client/serveur +- **NetworkIO Ă©volutif** : Support V1 et V2 simultanĂ© +- **State preservation** : ContinuitĂ© Ă©tat durant migration + +### Stack Technique Modulaire +- **IntraIO** : Communication intra-processus (dĂ©veloppement/debug) +- **LocalIO** : Named pipes/sockets (mĂȘme machine, production) +- **NetworkIO** : TCP/WebSocket avec support V1/V2 client/server + +### Patterns Communication +- **Modules → JSON in/out** : Interface pure, pas de dĂ©pendances directes +- **Hot-reload compatible** : Communication prĂ©servĂ©e durant updates modules +- **Client/Server agnostic** : MĂȘme logique mĂ©tier, dĂ©ploiement diffĂ©rent selon phase + +## Avantages Architecture Modulaire + +### DĂ©veloppement Claude Code OptimisĂ© +- **Contextes micro** : 200-300 lignes par module vs 50K+ lignes systĂšme monolithique +- **Build autonome** : `cd modules/tank/ && cmake .` - zĂ©ro dĂ©pendance parent +- **Hot-reload** : Modifications instantanĂ©es sans restart systĂšme +- **DĂ©veloppement parallĂšle** : Multiple instances Claude Code simultanĂ©es + +### Performance & ScalabilitĂ© +- **Évolution progressive** : Debug → Production → MMO sans rĂ©Ă©criture +- **Module isolation** : Failures localisĂ©es, pas de cascade +- **Infrastructure hot-swappable** : Change performance sans affecter logique mĂ©tier + +### Maintenance & Evolution +- **Testing isolĂ©** : Chaque module testable indĂ©pendamment +- **Migration zero-risk** : A/B testing, fallback automatique +- **Code reuse** : Modules rĂ©utilisables entre projets diff --git a/docs/toCheck/INTEGRATION-MASTER-LIST.md b/docs/toCheck/INTEGRATION-MASTER-LIST.md new file mode 100644 index 0000000..10e7e48 --- /dev/null +++ b/docs/toCheck/INTEGRATION-MASTER-LIST.md @@ -0,0 +1,259 @@ +# Master Integration List - 570 Points Techniques + +## 📋 Vue d'Ensemble + +**Total : 570 spĂ©cifications techniques concrĂštes** extraites de 6 documents (2194 lignes) +**DensitĂ© : 1 spĂ©cification toutes les 3.8 lignes** - Documentation technique ultra-dense + +## 🎯 RĂ©partition par PrioritĂ© + +### đŸ”„ **CRITICAL (88 points)** - ImplĂ©mentation immĂ©diate requise +- Architecture fondamentale : Points 1-5, 61-62, 68, 83 +- Contraintes dĂ©veloppement : Points 86-89, 126-142, 166-167 +- Build system : Points 351-365, 506-509, 511-530, 567-569 +- Communication : Points 391-396 + +### ⚡ **HIGH (187 points)** - ImplĂ©mentation prioritaire +- Performance & mĂ©triques : Points 6-10, 88, 90-125 +- SystĂšmes Ă©conomiques : Points 16-20, 72-82 +- Client/Server : Points 73-74, 155-156, 181-183, 422 +- Workflow dĂ©veloppement : Points 357, 367-371, 376 + +### 🟡 **MEDIUM (201 points)** - ImplĂ©mentation progressive +- SystĂšmes Ă©conomiques avancĂ©s : Points 24-30, 76-81 +- Testing & validation : Points 42-44, 291-310 +- UX & expĂ©rience : Points 431-470 +- Configuration : Points 251-290 + +### 🟱 **LOW (94 points)** - ImplĂ©mentation future +- Vision & patterns avancĂ©s : Points 45-53 +- Infrastructure ROI : Points 35-41, 159, 235-237 +- Optimisations avancĂ©es : Points 108-125, 548-559 + +--- + +## đŸ—ïž **SECTION 1 : ARCHITECTURE FONDAMENTALE** (Points 1-85) + +### đŸ”„ Architecture Core (CRITICAL) +**1. Triple Interface Pattern** - IEngine → IModuleSystem → IModule → IIO pour sĂ©paration complĂšte responsabilitĂ©s +**2. Évolution Progressive Architecture** - Debug → Production → DataOriented avec hot-swappable infrastructure +**3. Claude Code Micro-Context** - Modules 200-300 lignes max pour efficacitĂ© IA dĂ©veloppement +**4. Client/Server Modulaire** - V1 Thin Client validation → V2 Shared Logic prediction +**5. Distribution Performance-Based** - Critical locale, Strategic distribuĂ©e selon tolĂ©rance latence + +### ⚡ Workflow DĂ©veloppement (HIGH) +**6. Build Autonome** - `cmake .` par module, zĂ©ro dĂ©pendance parent +**7. Hot-Reload Infrastructure** - Remplacement temps rĂ©el modules avec sauvegarde Ă©tat +**8. DĂ©veloppement ParallĂšle** - Multiple instances Claude Code simultanĂ©es sans conflits +**9. CLAUDE.md SpĂ©cialisĂ©s** - Instructions contextuelles limitĂ©es par module +**10. Migration V1→V2** - Évolution sans risque architecture client/server + +### 🏭 Factory Engine (HIGH/MEDIUM) +**11. ProductionModule Monolithe** - Belt+Inserter+Factory intĂ©gration nĂ©cessaire performance +**12. Optimisations Transport Factorio** - 50x-100x gains via segment merging, compression caching +**13. SOA Data Layout** - Structure Arrays pour SIMD readiness future +**14. Trade-off SIMD vs Claude** - Compiler auto-vectorization prĂ©fĂ©rĂ© complexitĂ© manuelle +**15. Évolution Belt Progressive** - 4 phases Mono→Multi→Dual→Full Factorio + +### 💰 SystĂšmes Économiques (MEDIUM) +**16. HiĂ©rarchie Transport** - Ship(0.10€/kg)→Train(0.50€/kg)→Air(2.00€/kg)→Truck(5.00€/kg) +**17. Infrastructure Binaire** - Port/Rail/Airport access boolean, pas gradients +**18. Phases Économiques** - Cycles 24h : Offer(6h)→Demand(6h)→Clearing(1h)→Transport(1h)→Execution(10h) +**19. Pricing Dynamique** - Base + Transport + Scarcity + Regional factors +**20. StratĂ©gies Inventaire** - Desperate(<20%) → Normal(20-50%) → Cautious(50-80%) → Oversupplied(>80%) + +### ⚔ War Module (MEDIUM) +**21. Isolation ComplĂšte War** - ZĂ©ro interaction directe ProductionModule, via LogisticModule uniquement +**22. DĂ©composition War SubsystĂšmes** - Targeting(60Hz) → Movement(30Hz) → Pathfinding → Tactical(1Hz) → Analytics(0.1Hz) +**23. TolĂ©rance RĂ©seau War** - 50-100ms latency acceptable dĂ©cisions stratĂ©giques + +### 📈 Trading & Market (MEDIUM) +**24. Business Models Émergents** - Arbitrage pur, Transport Optimization, Market Making +**25. SpĂ©cialisation Companies** - Geographic, Commodity, Logistics, Financial specialists +**26. Consolidation Volume** - AgrĂ©gation ordres pour seuils 1000t shipping collaboration +**27. Avantage GĂ©ographique** - Localisations cĂŽtiĂšres 50x moins cher transport + +### đŸ—ïž Infrastructure & RĂ©gions (MEDIUM/LOW) +**28. ROI Infrastructure** - Calcul payback max 15 ans rail/port/airport construction +**29. SpĂ©cialisation RĂ©gionale** - Extraction → Manufacturing → Trading → Consumer progression naturelle +**30. Dynamiques CĂŽtiĂšres** - Rush initial → Equilibrium via prix foncier et congestion + +### ⚙ Configuration & ComplexitĂ© (MEDIUM) +**31. ComplexitĂ© Économique Config** - Basic → Victoria 3 level via paramĂštres JSON +**32. SĂ©curitĂ© Mode-Based** - Dev(unrestricted) → Solo(modding) → Multiplayer(authoritative) +**33. Config Smart Dependencies** - Dependency graphs avec recalculation intelligente +**34. Anti-Cheat Psychologique** - Bugs simulĂ©s progressifs vs bans traditional + +### 🎯 Simulation Économique AvancĂ©e (LOW) +**35. Vision Simulation ComplĂšte** - Population/Market/Money/Trade/Policy modules Victoria 3-level +**36. ÉgalitĂ© Agents Économiques** - Pas privilĂšges player, simulation pure +**37. Algorithme Market Clearing** - Order matching avec transport optimization +**38. Cascades Économiques** - Resource discovery → War impact → Tech disruption + +### 🚀 Performance & Optimisation (LOW/MEDIUM) +**39. Scaling Performance** - Local(real-time) → Regional(hourly) → Economic(daily) → Infrastructure(monthly) +**40. Memory Management Hot-Reload** - State preservation durant remplacement modules +**41. Debug Engine Features** - Step-by-step, verbose logging, module isolation + +### đŸ§Ș Testing & Validation (MEDIUM) +**42. Unit Tests IntĂ©grĂ©s** - `#ifdef TESTING` validation autonome modules +**43. Standalone Testing** - Test modules sans engine complet +**44. Testing Strategy AI-Optimized** - Simple tests, pas infrastructure complexe + +### 🎯 Patterns AvancĂ©s Claude (LOW) +**45. Progressive Complexity Pattern** - V1→V2→V3 Ă©volution sans rĂ©Ă©criture +**46. Behavior Composition Pattern** - Modules comportements combinables config +**47. Data-Driven Logic Pattern** - Config JSON drive comportement + +### 🔼 Future & Vision (LOW) +**48. AI-Driven Development** - Claude Code gĂ©nĂšre modules complets prompts naturels +**49. Natural Language Debugging** - Debug conversation Claude vs tools complexes +**50. Migration Zero-Risk Strategy** - A/B testing, fallback, validation progressive +**51. Backward Compatibility Framework** - Proxy pattern ancien→nouveau coexistence + +### đŸ’Œ Business Logic & Philosophy (LOW) +**52. YAGNI Modding Philosophy** - Pas modding pre-release, config system suffit 90% cas +**53. "Complexity through Simplicity"** - AAA complexitĂ© via modules simples Claude-friendly + +--- + +## 🔧 **SECTION 2 : SPÉCIFICATIONS TECHNIQUES** (Points 86-250) + +### đŸ”„ Contraintes ImplĂ©mentation (CRITICAL) +**86. Module Context Limit** - 200-300 lignes maximum par module +**87. Build Command Structure** - `cd modules/tank/ && cmake .` (NOT cmake ..) +**88. Hot-reload Time** - <5 secondes pour changements modules +**89. Interface Pattern** - 4 interfaces IEngine, IModuleSystem, IModule, IIO + +### ⚡ MĂ©triques Performance (HIGH) +**90. Transport Cost Thresholds** - Ship 0.10€/kg, Train 0.50€/kg, Air 2.00€/kg, Truck 5.00€/kg +**91. Ship Volume Threshold** - ≄1000 tonnes minimum transport maritime +**92. Claude Code Token Limit** - ~200K tokens maximum context +**93. Economic Cycle Duration** - 24h total avec phases spĂ©cifiques +**94. Storage Cost** - €0.02/kg/day inventory +**95. Delivery Times** - Ship 14j, Train 3j, Air 1j, Truck 2j + +**96. Frame-Perfect Timing** - 60fps REQUIS ProductionModule +**97. Network Latency Tolerance** - 50-100ms acceptable war decisions +**98. V1 Client Target** - 30+ fps stable +**99. V2 Client Target** - 60+ fps avec prediction +**100. V1 Server Capacity** - 10+ concurrent players +**101. V2 Server Capacity** - 100+ concurrent players +**102. V1 Latency** - <150ms validation acceptable +**103. V2 Network** - 30ms server, 0ms perceived client +**104. ISocket Overhead** - >1ms INACCEPTABLE ProductionModule +**105. Context Size Improvement** - 50K+ → 200-300 lignes (250x rĂ©duction) +**106. Iteration Time** - 5-10 min → 5 sec (60-120x faster) +**107. Development Velocity** - 10x improvement Claude efficiency +**108. Hot-reload Performance** - N/A → <5 secondes +**109-125. Module Frequencies** - Production(60Hz), War(0.1-60Hz), Economics(0.01-0.1Hz) + +### đŸ”„ Contraintes ImplĂ©mentation Strictes (CRITICAL) +**126. NEVER `cd ..`** - Jamais rĂ©fĂ©rence directories parent modules +**127. ALWAYS `cmake .`** - Pas cmake .. pour builds modules +**128. ONLY JSON Communication** - Uniquement JSON entre modules +**129. MAX 300 Lines** - Contrainte stricte par fichier +**130. ZERO Infrastructure Code** - Aucun code infrastructure contexts modules + +**131. Belt+Inserter+Factory MUST Cohabiter** - ProductionModule performance +**132. ProductionModule Size** - 500-800 lignes (trade-off acceptĂ©) +**133. No Inserters Towards Turrets** - Isolation war assets +**134. Zero Interaction** - ProductionModule ↔ WarModule +**135. Module State Preservation** - Requis durant hot-reload + +**136-142. Interface Contracts** - JSON in/out, pure functions, pas side effects + +### ⚡ DĂ©finitions Interfaces (HIGH) +**166. IModule Interface** - `process()`, `initialize()`, `shutdown()` methods +**167-205. Interfaces SpĂ©cialisĂ©es** - Input, Network, Tank, Economic, Transport, etc. + +### 🟡 Structures DonnĂ©es (MEDIUM) +**206-250. Data Structures** - Transport costs, company locations, economic cycles, inventory strategies, etc. + +--- + +## ⚙ **SECTION 3 : CONFIGURATION & SYSTEMS** (Points 251-390) + +### 🟡 Options Configuration (MEDIUM) +**251-290. Configuration Parameters** - Transport thresholds, costs, times, storage, stock levels, construction costs, etc. + +### 🟡 Gestion Erreurs (MEDIUM) +**291-310. Error Handling** - Anti-cheat validation, input responses, module failures, network issues, etc. + +### ⚡ Mesures SĂ©curitĂ© (HIGH) +**311-330. Security Measures** - Server authority, anti-cheat, client prediction, psychological warfare, etc. + +### 🟡 StratĂ©gies DĂ©ploiement (MEDIUM) +**331-350. Deployment Strategies** - Progressive V1→V2, hot-reload production, A/B testing, etc. + +### đŸ”„ Pratiques DĂ©veloppement (CRITICAL) +**351-390. Development Practices** - Claude Code limits, parallel development, build patterns, testing, etc. + +--- + +## 🔗 **SECTION 4 : INTÉGRATION & UX** (Points 391-470) + +### đŸ”„ Patterns IntĂ©gration (CRITICAL) +**391-430. Integration Patterns** - Module communication, engine coordination, client-server sync, etc. + +### 🟡 ÉlĂ©ments UX (MEDIUM) +**431-470. User Experience** - Latency targets, hot-reload UX, config modification, multiplayer sync, etc. + +--- + +## đŸ’Œ **SECTION 5 : BUSINESS & BUILD** (Points 471-570) + +### 🟡 RĂšgles Business (MEDIUM) +**471-510. Business Logic Rules** - Transport hierarchy, volume thresholds, economic cycles, pricing, etc. + +### đŸ”„ Structure Fichiers (CRITICAL) +**511-530. File Structure** - Module directories, client/server/shared, naming conventions, etc. + +### đŸ”„ Build System (CRITICAL) +**531-570. Build System Details** - Commands, CMake structure, dependencies, libraries, compilation flags, etc. + +--- + +## 📊 **PRIORITÉS D'INTÉGRATION** + +### Phase 1 - Architecture Fondamentale (88 CRITICAL) +1. Triple Interface Pattern implementation +2. Module size constraints & build autonomy +3. Hot-reload infrastructure +4. JSON-only communication +5. Performance targets critiques + +### Phase 2 - SystĂšmes Core (187 HIGH) +1. Economic transport hierarchy +2. Client/server V1/V2 progression +3. Performance metrics implementation +4. Development workflow optimization +5. Security & validation systems + +### Phase 3 - FonctionnalitĂ©s AvancĂ©es (201 MEDIUM) +1. Economic simulation complexity +2. UX & experience optimization +3. Configuration systems +4. Testing & error handling +5. Integration patterns refinement + +### Phase 4 - Vision Future (94 LOW) +1. Advanced AI patterns +2. Infrastructure ROI modeling +3. Advanced optimizations +4. Future-proofing systems + +--- + +## 🎯 **CHECKLIST INTÉGRATION** + +- [ ] **Architecture** : 88 points CRITICAL - ImplĂ©mentation immĂ©diate +- [ ] **Performance** : 125 mĂ©triques spĂ©cifiques - Targets mesurables +- [ ] **Economic** : 80+ rĂšgles business - Simulation rĂ©aliste +- [ ] **Development** : 60 pratiques Claude Code - Workflow optimisĂ© +- [ ] **Build System** : 40 spĂ©cifications - Infrastructure autonome +- [ ] **Security** : 20 mesures - Protection robuste +- [ ] **UX** : 40 Ă©lĂ©ments - ExpĂ©rience utilisateur +- [ ] **Integration** : 40 patterns - Communication modules + +**Total : 570 spĂ©cifications techniques concrĂštes prĂȘtes pour intĂ©gration documentation principale** \ No newline at end of file diff --git a/docs/toCheck/README-new-content-only.md b/docs/toCheck/README-new-content-only.md new file mode 100644 index 0000000..f6cd290 --- /dev/null +++ b/docs/toCheck/README-new-content-only.md @@ -0,0 +1,89 @@ +# Nouveau Contenu Documentation (Post-Architecture Modulaire) + +## 🚀 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 +```bash +# 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 ! +``` + +## 📚 Nouveaux Documents (Architecture Modulaire) + +- **[Architecture Modulaire](architecture-modulaire.md)** - đŸ”„ **NOUVEAU** : Architecture triple interface +- **[Claude Code Integration](claude-code-integration.md)** - đŸ”„ **NOUVEAU** : Guide dĂ©veloppement IA +- **[Player Integration](player-integration.md)** - đŸ”„ **NOUVEAU** : Client/Server modulaire +- **[Factory Architecture Post-Player](factory-architecture-post-player.md)** - đŸ”„ **NOUVEAU** : Factory engine optimisĂ© +- **[Transport Economic System](transport-economic-system.md)** - đŸ”„ **NOUVEAU** : SystĂšme transport & Ă©conomique + +## 🔄 En Cours (Nouveau) + +- **Transport System** : Mode hierarchy (ship/train/air/truck) avec cost optimization +- **Market Mechanics** : Economic phases, order stacking, dynamic pricing +- **Trading Companies** : Arbitrage, transport optimization, market making +- **Geographic Economics** : Infrastructure investment, regional specialization + +## 📋 Prochaines Étapes (Nouveau) + +- **TradingModule Implementation** : Business models (arbitrage, optimization, market making) +- **MarketModule Implementation** : Economic phases, order matching, price discovery +- **InfrastructureModule Implementation** : ROI calculation, regional development +- **Integration Testing** : Transport system avec ProductionModule + +## 💡 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 (Nouveau SystĂšme) + +```bash +# 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 +``` + +## 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 \ No newline at end of file diff --git a/docs/architecture-modulaire.md b/docs/toCheck/architecture-modulaire.md similarity index 95% rename from docs/architecture-modulaire.md rename to docs/toCheck/architecture-modulaire.md index a4e633e..3faa987 100644 --- a/docs/architecture-modulaire.md +++ b/docs/toCheck/architecture-modulaire.md @@ -150,12 +150,12 @@ DataOrientedEngine + ClusterModuleSystem + NetworkIO Player edit → Server validation → Engine dispatch → Background recalc ``` -#### Smart Recalculation Engine +#### Smart Recalculation System ```cpp // Exemple : player modifie steel_plating.weight ConfigChange steel_plating.weight → ComponentTracker.getDependents() → [tank_mk1, tank_mk2, heavy_tank] → - DesignerEngine.scheduleRecalc() → + DesignerModule.scheduleRecalc() → Background processing (spread over frames) ``` @@ -240,7 +240,7 @@ class ConfigDependencyGraph { void onConfigChange(ConfigKey key, json newValue) { auto affected = dependencies[key]; for(auto component : affected) { - DesignerEngine::scheduleRecalc(component); + DesignerModule::scheduleRecalc(component); } } }; @@ -255,7 +255,7 @@ class ConfigDependencyGraph { ### Avant : Architecture Monolithique ``` -Edit code → Full compile (2-5 min) → Restart engine → Load save → Test +Edit code → Full compile (2-5 min) → Restart system → Load save → Test Total : 5-10 minutes par iteration ``` diff --git a/docs/claude-code-integration.md b/docs/toCheck/claude-code-integration.md similarity index 100% rename from docs/claude-code-integration.md rename to docs/toCheck/claude-code-integration.md diff --git a/docs/factory-architecture-post-player.md b/docs/toCheck/factory-architecture-post-player.md similarity index 100% rename from docs/factory-architecture-post-player.md rename to docs/toCheck/factory-architecture-post-player.md diff --git a/docs/player-integration.md b/docs/toCheck/player-integration.md similarity index 100% rename from docs/player-integration.md rename to docs/toCheck/player-integration.md diff --git a/docs/transport-economic-system.md b/docs/toCheck/transport-economic-system.md similarity index 100% rename from docs/transport-economic-system.md rename to docs/toCheck/transport-economic-system.md