use game state context to reduce actions space

bot/src/strategy/dqn_common.rs

@@ -16,6 +16,105 @@ pub enum TrictracAction {
     },
 }
 
+/// Actions compactes basées sur le contexte du jeu
+/// Réduit drastiquement l'espace d'actions en utilisant l'état du jeu
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum CompactAction {
+    /// Lancer les dés
+    Roll,
+    /// Marquer des points (0-12)
+    Mark { points: u8 },
+    /// Continuer après avoir gagné un trou
+    Go,
+    /// Choix de mouvement simplifié
+    MoveChoice {
+        dice_order: bool,  // true = utiliser dice[0] en premier, false = dice[1] en premier
+        from1: usize,      // position de départ du premier pion (0-24)
+        from2: usize,      // position de départ du deuxième pion (0-24)
+    },
+}
+
+impl CompactAction {
+    /// Convertit CompactAction vers TrictracAction en utilisant l'état du jeu
+    pub fn to_trictrac_action(&self, game_state: &crate::GameState) -> Option<TrictracAction> {
+        match self {
+            CompactAction::Roll => Some(TrictracAction::Roll),
+            CompactAction::Mark { points } => Some(TrictracAction::Mark { points: *points }),
+            CompactAction::Go => Some(TrictracAction::Go),
+            CompactAction::MoveChoice { dice_order, from1, from2 } => {
+                // Calculer les positions de destination basées sur les dés
+                if let Some(player_color) = game_state.player_color_by_id(&game_state.active_player_id) {
+                    let dice = game_state.dice;
+                    let (die1, die2) = if *dice_order { (dice.values.0, dice.values.1) } else { (dice.values.1, dice.values.0) };
+                    
+                    // Calculer les destinations (simplifiée - à adapter selon les règles de mouvement)
+                    let to1 = if player_color == store::Color::White {
+                        from1 + die1 as usize
+                    } else {
+                        from1.saturating_sub(die1 as usize)
+                    };
+                    
+                    let to2 = if player_color == store::Color::White {
+                        from2 + die2 as usize
+                    } else {
+                        from2.saturating_sub(die2 as usize)
+                    };
+                    
+                    Some(TrictracAction::Move {
+                        move1: (*from1, to1),
+                        move2: (*from2, to2),
+                    })
+                } else {
+                    None
+                }
+            }
+        }
+    }
+    
+    /// Taille de l'espace d'actions compactes selon le contexte
+    pub fn context_action_space_size(game_state: &crate::GameState) -> usize {
+        use store::TurnStage;
+        
+        match game_state.turn_stage {
+            TurnStage::RollDice | TurnStage::RollWaiting => 1, // Seulement Roll
+            TurnStage::MarkPoints | TurnStage::MarkAdvPoints => 13, // Mark 0-12 points
+            TurnStage::HoldOrGoChoice => {
+                // Go + mouvements possibles
+                if let Some(player_color) = game_state.player_color_by_id(&game_state.active_player_id) {
+                    let rules = store::MoveRules::new(&player_color, &game_state.board, game_state.dice);
+                    let possible_moves = rules.get_possible_moves_sequences(true, vec![]);
+                    1 + Self::estimate_compact_moves(game_state, &possible_moves)
+                } else {
+                    1
+                }
+            }
+            TurnStage::Move => {
+                // Seulement les mouvements
+                if let Some(player_color) = game_state.player_color_by_id(&game_state.active_player_id) {
+                    let rules = store::MoveRules::new(&player_color, &game_state.board, game_state.dice);
+                    let possible_moves = rules.get_possible_moves_sequences(true, vec![]);
+                    Self::estimate_compact_moves(game_state, &possible_moves)
+                } else {
+                    0
+                }
+            }
+        }
+    }
+    
+    /// Estime le nombre d'actions compactes pour les mouvements
+    fn estimate_compact_moves(game_state: &crate::GameState, _possible_moves: &[(store::CheckerMove, store::CheckerMove)]) -> usize {
+        // Au lieu d'encoder tous les mouvements possibles,
+        // on utilise : 2 (ordre des dés) * 25 (from1) * 25 (from2) = 1250 maximum
+        // En pratique, beaucoup moins car on ne peut partir que des positions avec des pions
+        
+        let max_dice_orders = if game_state.dice.values.0 != game_state.dice.values.1 { 2 } else { 1 };
+        let _max_positions = 25; // positions 0-24
+        
+        // Estimation conservatrice : environ 10 positions de départ possibles en moyenne
+        max_dice_orders * 10 * 10 // ≈ 200 au lieu de 331,791
+    }
+}
+
 impl TrictracAction {
     /// Encode une action en index pour le réseau de neurones
     pub fn to_action_index(&self) -> usize {
@@ -238,7 +337,7 @@ impl SimpleNeuralNetwork {
 /// Obtient les actions valides pour l'état de jeu actuel
 pub fn get_valid_actions(game_state: &crate::GameState) -> Vec<TrictracAction> {
     use crate::PointsRules;
-    use store::{MoveRules, TurnStage};
+    use store::TurnStage;
 
     let mut valid_actions = Vec::new();
 
@@ -267,7 +366,7 @@ pub fn get_valid_actions(game_state: &crate::GameState) -> Vec<TrictracAction> {
                 valid_actions.push(TrictracAction::Go);
 
                 // Ajouter aussi les mouvements possibles
-                let rules = MoveRules::new(&color, &game_state.board, game_state.dice);
+                let rules = store::MoveRules::new(&color, &game_state.board, game_state.dice);
                 let possible_moves = rules.get_possible_moves_sequences(true, vec![]);
 
                 for (move1, move2) in possible_moves {
@@ -278,7 +377,7 @@ pub fn get_valid_actions(game_state: &crate::GameState) -> Vec<TrictracAction> {
                 }
             }
             TurnStage::Move => {
-                let rules = MoveRules::new(&color, &game_state.board, game_state.dice);
+                let rules = store::MoveRules::new(&color, &game_state.board, game_state.dice);
                 let possible_moves = rules.get_possible_moves_sequences(true, vec![]);
 
                 for (move1, move2) in possible_moves {
@@ -294,6 +393,92 @@ pub fn get_valid_actions(game_state: &crate::GameState) -> Vec<TrictracAction> {
     valid_actions
 }
 
+/// Génère les actions compactes valides selon l'état du jeu
+pub fn get_valid_compact_actions(game_state: &crate::GameState) -> Vec<CompactAction> {
+    use crate::PointsRules;
+    use store::TurnStage;
+
+    let mut valid_actions = Vec::new();
+
+    let active_player_id = game_state.active_player_id;
+    let player_color = game_state.player_color_by_id(&active_player_id);
+
+    if let Some(color) = player_color {
+        match game_state.turn_stage {
+            TurnStage::RollDice | TurnStage::RollWaiting => {
+                valid_actions.push(CompactAction::Roll);
+            }
+            TurnStage::MarkPoints | TurnStage::MarkAdvPoints => {
+                // Calculer les points possibles
+                if let Some(player) = game_state.players.get(&active_player_id) {
+                    let dice_roll_count = player.dice_roll_count;
+                    let points_rules = PointsRules::new(&color, &game_state.board, game_state.dice);
+                    let (max_points, _) = points_rules.get_points(dice_roll_count);
+
+                    // Permettre de marquer entre 0 et max_points
+                    for points in 0..=max_points {
+                        valid_actions.push(CompactAction::Mark { points });
+                    }
+                }
+            }
+            TurnStage::HoldOrGoChoice => {
+                valid_actions.push(CompactAction::Go);
+                
+                // Ajouter les choix de mouvements compacts
+                add_compact_move_actions(game_state, &color, &mut valid_actions);
+            }
+            TurnStage::Move => {
+                // Seulement les mouvements compacts
+                add_compact_move_actions(game_state, &color, &mut valid_actions);
+            }
+        }
+    }
+
+    valid_actions
+}
+
+/// Ajoute les actions de mouvement compactes basées sur le contexte
+fn add_compact_move_actions(game_state: &crate::GameState, color: &store::Color, valid_actions: &mut Vec<CompactAction>) {
+    let rules = store::MoveRules::new(color, &game_state.board, game_state.dice);
+    let possible_moves = rules.get_possible_moves_sequences(true, vec![]);
+    
+    // Extraire les positions de départ uniques des mouvements possibles
+    let mut valid_from_positions = std::collections::HashSet::new();
+    for (move1, move2) in &possible_moves {
+        valid_from_positions.insert(move1.get_from());
+        valid_from_positions.insert(move2.get_from());
+    }
+    
+    let dice = game_state.dice;
+    let dice_orders = if dice.values.0 != dice.values.1 { vec![true, false] } else { vec![true] };
+    
+    // Générer les combinaisons compactes valides
+    for dice_order in dice_orders {
+        for &from1 in &valid_from_positions {
+            for &from2 in &valid_from_positions {
+                // Vérifier si cette combinaison produit un mouvement valide
+                let compact_action = CompactAction::MoveChoice { 
+                    dice_order, 
+                    from1, 
+                    from2 
+                };
+                
+                if let Some(trictrac_action) = compact_action.to_trictrac_action(game_state) {
+                    // Vérifier si ce mouvement est dans la liste des mouvements possibles
+                    if let TrictracAction::Move { move1, move2 } = trictrac_action {
+                        if let (Ok(checker_move1), Ok(checker_move2)) = 
+                            (store::CheckerMove::new(move1.0, move1.1), store::CheckerMove::new(move2.0, move2.1)) {
+                            if possible_moves.contains(&(checker_move1, checker_move2)) {
+                                valid_actions.push(compact_action);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
 /// Retourne les indices des actions valides
 pub fn get_valid_action_indices(game_state: &crate::GameState) -> Vec<usize> {
     get_valid_actions(game_state)