.gitignore

@@ -1,7 +1,6 @@
 # Generated by Cargo
 # will have compiled files and executables
 /target/
-/target
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
@@ -12,5 +11,6 @@ devenv.local.nix
 # generated by samply rust profiler
 profile.json
 
-# IA modles used by bots
-/models
+# Added by cargo
+
+/target

.pre-commit-config.yaml

@@ -0,0 +1 @@
+/nix/store/i4sgk0h4rjc84waf065w8xkrwvxlnhpw-pre-commit-config.json

CLAUDE.md

@@ -1,26 +0,0 @@
-# Trictrac Project Guidelines
-
-## Build & Run Commands
-- Build: `cargo build`
-- Test: `cargo test`
-- Test specific: `cargo test -- test_name`
-- Lint: `cargo clippy`
-- Format: `cargo fmt`
-- Run CLI: `RUST_LOG=info cargo run --bin=client_cli`
-- Run CLI with bots: `RUST_LOG=info cargo run --bin=client_cli -- --bot dummy,dummy`
-- Build Python lib: `maturin build -m store/Cargo.toml --release`
-
-## Code Style
-- Use Rust 2021 edition idioms
-- Error handling: Use Result<T, Error> pattern with custom Error types
-- Naming: snake_case for functions/variables, CamelCase for types
-- Imports: Group standard lib, external crates, then internal modules
-- Module structure: Prefer small, focused modules with clear responsibilities
-- Documentation: Document public APIs with doc comments
-- Testing: Write unit tests in same file as implementation
-- Python bindings: Use pyo3 for creating Python modules
-
-## Architecture
-- Core game logic in `store` crate
-- Multiple clients: CLI, TUI, Bevy (graphical)
-- Bot interfaces in `bot` crate

bot/Cargo.toml

@@ -5,20 +5,6 @@ edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-[[bin]]
-name = "train_dqn_burn"
-path = "src/dqn/burnrl/main.rs"
-
-[[bin]]
-name = "train_dqn"
-path = "src/bin/train_dqn.rs"
-
 [dependencies]
 pretty_assertions = "1.4.0"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
 store = { path = "../store" }
-rand = "0.8"
-env_logger = "0.10"
-burn = { version = "0.17", features = ["ndarray", "autodiff"] }
-burn-rl = { git = "https://github.com/yunjhongwu/burn-rl-examples.git", package = "burn-rl" }

bot/src/bin/train_dqn.rs

@@ -1,111 +0,0 @@
-use bot::dqn::dqn_common::{DqnConfig, TrictracAction};
-use bot::dqn::simple::dqn_trainer::DqnTrainer;
-use std::env;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    env_logger::init();
-
-    let args: Vec<String> = env::args().collect();
-
-    // Paramètres par défaut
-    let mut episodes = 1000;
-    let mut model_path = "models/dqn_model".to_string();
-    let mut save_every = 100;
-
-    // Parser les arguments de ligne de commande
-    let mut i = 1;
-    while i < args.len() {
-        match args[i].as_str() {
-            "--episodes" => {
-                if i + 1 < args.len() {
-                    episodes = args[i + 1].parse().unwrap_or(1000);
-                    i += 2;
-                } else {
-                    eprintln!("Erreur : --episodes nécessite une valeur");
-                    std::process::exit(1);
-                }
-            }
-            "--model-path" => {
-                if i + 1 < args.len() {
-                    model_path = args[i + 1].clone();
-                    i += 2;
-                } else {
-                    eprintln!("Erreur : --model-path nécessite une valeur");
-                    std::process::exit(1);
-                }
-            }
-            "--save-every" => {
-                if i + 1 < args.len() {
-                    save_every = args[i + 1].parse().unwrap_or(100);
-                    i += 2;
-                } else {
-                    eprintln!("Erreur : --save-every nécessite une valeur");
-                    std::process::exit(1);
-                }
-            }
-            "--help" | "-h" => {
-                print_help();
-                std::process::exit(0);
-            }
-            _ => {
-                eprintln!("Argument inconnu : {}", args[i]);
-                print_help();
-                std::process::exit(1);
-            }
-        }
-    }
-
-    // Créer le dossier models s'il n'existe pas
-    std::fs::create_dir_all("models")?;
-
-    println!("Configuration d'entraînement DQN :");
-    println!("  Épisodes : {}", episodes);
-    println!("  Chemin du modèle : {}", model_path);
-    println!("  Sauvegarde tous les {} épisodes", save_every);
-    println!();
-
-    // Configuration DQN
-    let config = DqnConfig {
-        state_size: 36, // state.to_vec size
-        hidden_size: 256,
-        num_actions: TrictracAction::action_space_size(),
-        learning_rate: 0.001,
-        gamma: 0.99,
-        epsilon: 0.9, // Commencer avec plus d'exploration
-        epsilon_decay: 0.995,
-        epsilon_min: 0.01,
-        replay_buffer_size: 10000,
-        batch_size: 32,
-    };
-
-    // Créer et lancer l'entraîneur
-    let mut trainer = DqnTrainer::new(config);
-    trainer.train(episodes, save_every, &model_path)?;
-
-    println!("Entraînement terminé avec succès !");
-    println!("Pour utiliser le modèle entraîné :");
-    println!(
-        "  cargo run --bin=client_cli -- --bot dqn:{}_final.json,dummy",
-        model_path
-    );
-
-    Ok(())
-}
-
-fn print_help() {
-    println!("Entraîneur DQN pour Trictrac");
-    println!();
-    println!("USAGE:");
-    println!("  cargo run --bin=train_dqn [OPTIONS]");
-    println!();
-    println!("OPTIONS:");
-    println!("  --episodes <NUM>      Nombre d'épisodes d'entraînement (défaut: 1000)");
-    println!("  --model-path <PATH>   Chemin de base pour sauvegarder les modèles (défaut: models/dqn_model)");
-    println!("  --save-every <NUM>    Sauvegarder le modèle tous les N épisodes (défaut: 100)");
-    println!("  -h, --help            Afficher cette aide");
-    println!();
-    println!("EXEMPLES:");
-    println!("  cargo run --bin=train_dqn");
-    println!("  cargo run --bin=train_dqn -- --episodes 5000 --save-every 500");
-    println!("  cargo run --bin=train_dqn -- --model-path models/my_model --episodes 2000");
-}

bot/src/dqn/burnrl/dqn_model.rs

@@ -1,166 +0,0 @@
-use crate::dqn::burnrl::utils::soft_update_linear;
-use burn::module::Module;
-use burn::nn::{Linear, LinearConfig};
-use burn::optim::AdamWConfig;
-use burn::tensor::activation::relu;
-use burn::tensor::backend::{AutodiffBackend, Backend};
-use burn::tensor::Tensor;
-use burn_rl::agent::DQN;
-use burn_rl::agent::{DQNModel, DQNTrainingConfig};
-use burn_rl::base::{Action, ElemType, Environment, Memory, Model, State};
-use std::time::SystemTime;
-
-#[derive(Module, Debug)]
-pub struct Net<B: Backend> {
-    linear_0: Linear<B>,
-    linear_1: Linear<B>,
-    linear_2: Linear<B>,
-}
-
-impl<B: Backend> Net<B> {
-    #[allow(unused)]
-    pub fn new(input_size: usize, dense_size: usize, output_size: usize) -> Self {
-        Self {
-            linear_0: LinearConfig::new(input_size, dense_size).init(&Default::default()),
-            linear_1: LinearConfig::new(dense_size, dense_size).init(&Default::default()),
-            linear_2: LinearConfig::new(dense_size, output_size).init(&Default::default()),
-        }
-    }
-
-    fn consume(self) -> (Linear<B>, Linear<B>, Linear<B>) {
-        (self.linear_0, self.linear_1, self.linear_2)
-    }
-}
-
-impl<B: Backend> Model<B, Tensor<B, 2>, Tensor<B, 2>> for Net<B> {
-    fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2> {
-        let layer_0_output = relu(self.linear_0.forward(input));
-        let layer_1_output = relu(self.linear_1.forward(layer_0_output));
-
-        relu(self.linear_2.forward(layer_1_output))
-    }
-
-    fn infer(&self, input: Tensor<B, 2>) -> Tensor<B, 2> {
-        self.forward(input)
-    }
-}
-
-impl<B: Backend> DQNModel<B> for Net<B> {
-    fn soft_update(this: Self, that: &Self, tau: ElemType) -> Self {
-        let (linear_0, linear_1, linear_2) = this.consume();
-
-        Self {
-            linear_0: soft_update_linear(linear_0, &that.linear_0, tau),
-            linear_1: soft_update_linear(linear_1, &that.linear_1, tau),
-            linear_2: soft_update_linear(linear_2, &that.linear_2, tau),
-        }
-    }
-}
-
-#[allow(unused)]
-const MEMORY_SIZE: usize = 8192;
-
-pub struct DqnConfig {
-    pub num_episodes: usize,
-    // pub memory_size: usize,
-    pub dense_size: usize,
-    pub eps_start: f64,
-    pub eps_end: f64,
-    pub eps_decay: f64,
-}
-
-impl Default for DqnConfig {
-    fn default() -> Self {
-        Self {
-            num_episodes: 1000,
-            // memory_size: 8192,
-            dense_size: 256,
-            eps_start: 0.9,
-            eps_end: 0.05,
-            eps_decay: 1000.0,
-        }
-    }
-}
-
-type MyAgent<E, B> = DQN<E, B, Net<B>>;
-
-#[allow(unused)]
-pub fn run<E: Environment, B: AutodiffBackend>(
-    conf: &DqnConfig,
-    visualized: bool,
-) -> DQN<E, B, Net<B>> {
-    // ) -> impl Agent<E> {
-    let mut env = E::new(visualized);
-
-    let model = Net::<B>::new(
-        <<E as Environment>::StateType as State>::size(),
-        conf.dense_size,
-        <<E as Environment>::ActionType as Action>::size(),
-    );
-
-    let mut agent = MyAgent::new(model);
-
-    let config = DQNTrainingConfig::default();
-
-    let mut memory = Memory::<E, B, MEMORY_SIZE>::default();
-
-    let mut optimizer = AdamWConfig::new()
-        .with_grad_clipping(config.clip_grad.clone())
-        .init();
-
-    let mut policy_net = agent.model().as_ref().unwrap().clone();
-
-    let mut step = 0_usize;
-
-    for episode in 0..conf.num_episodes {
-        let mut episode_done = false;
-        let mut episode_reward: ElemType = 0.0;
-        let mut episode_duration = 0_usize;
-        let mut state = env.state();
-        let mut now = SystemTime::now();
-
-        while !episode_done {
-            let eps_threshold = conf.eps_end
-                + (conf.eps_start - conf.eps_end) * f64::exp(-(step as f64) / conf.eps_decay);
-            let action =
-                DQN::<E, B, Net<B>>::react_with_exploration(&policy_net, state, eps_threshold);
-            let snapshot = env.step(action);
-
-            episode_reward +=
-                <<E as Environment>::RewardType as Into<ElemType>>::into(snapshot.reward().clone());
-
-            memory.push(
-                state,
-                *snapshot.state(),
-                action,
-                snapshot.reward().clone(),
-                snapshot.done(),
-            );
-
-            if config.batch_size < memory.len() {
-                policy_net =
-                    agent.train::<MEMORY_SIZE>(policy_net, &memory, &mut optimizer, &config);
-            }
-
-            step += 1;
-            episode_duration += 1;
-
-            if snapshot.done() || episode_duration >= E::MAX_STEPS {
-                env.reset();
-                episode_done = true;
-
-                println!(
-                    "{{\"episode\": {}, \"reward\": {:.4}, \"steps count\": {}, \"duration\": {}}}",
-                    episode,
-                    episode_reward,
-                    episode_duration,
-                    now.elapsed().unwrap().as_secs()
-                );
-                now = SystemTime::now();
-            } else {
-                state = *snapshot.state();
-            }
-        }
-    }
-    agent
-}

bot/src/dqn/burnrl/environment.rs

@@ -1,414 +0,0 @@
-use crate::dqn::dqn_common;
-use burn::{prelude::Backend, tensor::Tensor};
-use burn_rl::base::{Action, Environment, Snapshot, State};
-use rand::{thread_rng, Rng};
-use store::{GameEvent, GameState, PlayerId, PointsRules, Stage, TurnStage};
-
-/// État du jeu Trictrac pour burn-rl
-#[derive(Debug, Clone, Copy)]
-pub struct TrictracState {
-    pub data: [f32; 36], // Représentation vectorielle de l'état du jeu
-}
-
-impl State for TrictracState {
-    type Data = [f32; 36];
-
-    fn to_tensor<B: Backend>(&self) -> Tensor<B, 1> {
-        Tensor::from_floats(self.data, &B::Device::default())
-    }
-
-    fn size() -> usize {
-        36
-    }
-}
-
-impl TrictracState {
-    /// Convertit un GameState en TrictracState
-    pub fn from_game_state(game_state: &GameState) -> Self {
-        let state_vec = game_state.to_vec_float();
-        let mut data = [0.0; 36];
-
-        // Copier les données en s'assurant qu'on ne dépasse pas la taille
-        let copy_len = state_vec.len().min(36);
-        data[..copy_len].copy_from_slice(&state_vec[..copy_len]);
-
-        TrictracState { data }
-    }
-}
-
-/// Actions possibles dans Trictrac pour burn-rl
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub struct TrictracAction {
-    pub index: u32,
-}
-
-impl Action for TrictracAction {
-    fn random() -> Self {
-        use rand::{thread_rng, Rng};
-        let mut rng = thread_rng();
-        TrictracAction {
-            index: rng.gen_range(0..Self::size() as u32),
-        }
-    }
-
-    fn enumerate() -> Vec<Self> {
-        (0..Self::size() as u32)
-            .map(|index| TrictracAction { index })
-            .collect()
-    }
-
-    fn size() -> usize {
-        1252
-    }
-}
-
-impl From<u32> for TrictracAction {
-    fn from(index: u32) -> Self {
-        TrictracAction { index }
-    }
-}
-
-impl From<TrictracAction> for u32 {
-    fn from(action: TrictracAction) -> u32 {
-        action.index
-    }
-}
-
-/// Environnement Trictrac pour burn-rl
-#[derive(Debug)]
-pub struct TrictracEnvironment {
-    pub game: GameState,
-    active_player_id: PlayerId,
-    opponent_id: PlayerId,
-    current_state: TrictracState,
-    episode_reward: f32,
-    step_count: usize,
-    pub visualized: bool,
-}
-
-impl Environment for TrictracEnvironment {
-    type StateType = TrictracState;
-    type ActionType = TrictracAction;
-    type RewardType = f32;
-
-    const MAX_STEPS: usize = 700; // Limite max pour éviter les parties infinies
-
-    fn new(visualized: bool) -> Self {
-        let mut game = GameState::new(false);
-
-        // Ajouter deux joueurs
-        game.init_player("DQN Agent");
-        game.init_player("Opponent");
-        let player1_id = 1;
-        let player2_id = 2;
-
-        // Commencer la partie
-        game.consume(&GameEvent::BeginGame { goes_first: 1 });
-
-        let current_state = TrictracState::from_game_state(&game);
-        TrictracEnvironment {
-            game,
-            active_player_id: player1_id,
-            opponent_id: player2_id,
-            current_state,
-            episode_reward: 0.0,
-            step_count: 0,
-            visualized,
-        }
-    }
-
-    fn state(&self) -> Self::StateType {
-        self.current_state
-    }
-
-    fn reset(&mut self) -> Snapshot<Self> {
-        // Réinitialiser le jeu
-        self.game = GameState::new(false);
-        self.game.init_player("DQN Agent");
-        self.game.init_player("Opponent");
-
-        // Commencer la partie
-        self.game.consume(&GameEvent::BeginGame { goes_first: 1 });
-
-        self.current_state = TrictracState::from_game_state(&self.game);
-        self.episode_reward = 0.0;
-        self.step_count = 0;
-
-        Snapshot::new(self.current_state, 0.0, false)
-    }
-
-    fn step(&mut self, action: Self::ActionType) -> Snapshot<Self> {
-        self.step_count += 1;
-
-        // Convertir l'action burn-rl vers une action Trictrac
-        let trictrac_action = self.convert_action(action, &self.game);
-
-        let mut reward = 0.0;
-        let mut terminated = false;
-
-        // Exécuter l'action si c'est le tour de l'agent DQN
-        if self.game.active_player_id == self.active_player_id {
-            if let Some(action) = trictrac_action {
-                match self.execute_action(action) {
-                    Ok(action_reward) => {
-                        reward = action_reward;
-                    }
-                    Err(_) => {
-                        // Action invalide, pénalité
-                        reward = -1.0;
-                    }
-                }
-            } else {
-                // Action non convertible, pénalité
-                reward = -0.5;
-            }
-        }
-
-        // Faire jouer l'adversaire (stratégie simple)
-        while self.game.active_player_id == self.opponent_id && self.game.stage != Stage::Ended {
-            reward += self.play_opponent_if_needed();
-        }
-
-        // Vérifier si la partie est terminée
-        let done = self.game.stage == Stage::Ended
-            || self.game.determine_winner().is_some()
-            || self.step_count >= Self::MAX_STEPS;
-
-        if done {
-            terminated = true;
-            // Récompense finale basée sur le résultat
-            if let Some(winner_id) = self.game.determine_winner() {
-                if winner_id == self.active_player_id {
-                    reward += 50.0; // Victoire
-                } else {
-                    reward -= 25.0; // Défaite
-                }
-            }
-        }
-
-        // Mettre à jour l'état
-        self.current_state = TrictracState::from_game_state(&self.game);
-        self.episode_reward += reward;
-
-        if self.visualized && terminated {
-            println!(
-                "Episode terminé. Récompense totale: {:.2}, Étapes: {}",
-                self.episode_reward, self.step_count
-            );
-        }
-
-        Snapshot::new(self.current_state, reward, terminated)
-    }
-}
-
-impl TrictracEnvironment {
-    /// Convertit une action burn-rl vers une action Trictrac
-    fn convert_action(
-        &self,
-        action: TrictracAction,
-        game_state: &GameState,
-    ) -> Option<dqn_common::TrictracAction> {
-        dqn_common::TrictracAction::from_action_index(action.index.try_into().unwrap())
-    }
-
-    /// Convertit l'index d'une action au sein des actions valides vers une action Trictrac
-    fn convert_valid_action_index(
-        &self,
-        action: TrictracAction,
-        game_state: &GameState,
-    ) -> Option<dqn_common::TrictracAction> {
-        use dqn_common::get_valid_actions;
-
-        // Obtenir les actions valides dans le contexte actuel
-        let valid_actions = get_valid_actions(game_state);
-
-        if valid_actions.is_empty() {
-            return None;
-        }
-
-        // Mapper l'index d'action sur une action valide
-        let action_index = (action.index as usize) % valid_actions.len();
-        Some(valid_actions[action_index].clone())
-    }
-
-    /// Exécute une action Trictrac dans le jeu
-    fn execute_action(
-        &mut self,
-        action: dqn_common::TrictracAction,
-    ) -> Result<f32, Box<dyn std::error::Error>> {
-        use dqn_common::TrictracAction;
-
-        let mut reward = 0.0;
-
-        let event = match action {
-            TrictracAction::Roll => {
-                // Lancer les dés
-                reward += 0.1;
-                Some(GameEvent::Roll {
-                    player_id: self.active_player_id,
-                })
-            }
-            // TrictracAction::Mark => {
-            //     // Marquer des points
-            //     let points = self.game.
-            //     reward += 0.1 * points as f32;
-            //     Some(GameEvent::Mark {
-            //         player_id: self.active_player_id,
-            //         points,
-            //     })
-            // }
-            TrictracAction::Go => {
-                // Continuer après avoir gagné un trou
-                reward += 0.2;
-                Some(GameEvent::Go {
-                    player_id: self.active_player_id,
-                })
-            }
-            TrictracAction::Move {
-                dice_order,
-                from1,
-                from2,
-            } => {
-                // Effectuer un mouvement
-                let (dice1, dice2) = if dice_order {
-                    (self.game.dice.values.0, self.game.dice.values.1)
-                } else {
-                    (self.game.dice.values.1, self.game.dice.values.0)
-                };
-                let mut to1 = from1 + dice1 as usize;
-                let mut to2 = from2 + dice2 as usize;
-
-                // Gestion prise de coin par puissance
-                let opp_rest_field = 13;
-                if to1 == opp_rest_field && to2 == opp_rest_field {
-                    to1 -= 1;
-                    to2 -= 1;
-                }
-
-                let checker_move1 = store::CheckerMove::new(from1, to1).unwrap_or_default();
-                let checker_move2 = store::CheckerMove::new(from2, to2).unwrap_or_default();
-
-                reward += 0.2;
-                Some(GameEvent::Move {
-                    player_id: self.active_player_id,
-                    moves: (checker_move1, checker_move2),
-                })
-            }
-        };
-
-        // Appliquer l'événement si valide
-        if let Some(event) = event {
-            if self.game.validate(&event) {
-                self.game.consume(&event);
-
-                // Simuler le résultat des dés après un Roll
-                if matches!(action, TrictracAction::Roll) {
-                    let mut rng = thread_rng();
-                    let dice_values = (rng.gen_range(1..=6), rng.gen_range(1..=6));
-                    let dice_event = GameEvent::RollResult {
-                        player_id: self.active_player_id,
-                        dice: store::Dice {
-                            values: dice_values,
-                        },
-                    };
-                    if self.game.validate(&dice_event) {
-                        self.game.consume(&dice_event);
-                        let (points, adv_points) = self.game.dice_points;
-                        reward += 0.3 * (points - adv_points) as f32; // Récompense proportionnelle aux points
-                    }
-                }
-            } else {
-                // Pénalité pour action invalide
-                reward -= 2.0;
-            }
-        }
-
-        Ok(reward)
-    }
-
-    /// Fait jouer l'adversaire avec une stratégie simple
-    fn play_opponent_if_needed(&mut self) -> f32 {
-        let mut reward = 0.0;
-
-        // Si c'est le tour de l'adversaire, jouer automatiquement
-        if self.game.active_player_id == self.opponent_id && self.game.stage != Stage::Ended {
-            // Utiliser la stratégie default pour l'adversaire
-            use crate::strategy::default::DefaultStrategy;
-            use crate::BotStrategy;
-
-            let mut default_strategy = DefaultStrategy::default();
-            default_strategy.set_player_id(self.opponent_id);
-            if let Some(color) = self.game.player_color_by_id(&self.opponent_id) {
-                default_strategy.set_color(color);
-            }
-            *default_strategy.get_mut_game() = self.game.clone();
-
-            // Exécuter l'action selon le turn_stage
-            let event = match self.game.turn_stage {
-                TurnStage::RollDice => GameEvent::Roll {
-                    player_id: self.opponent_id,
-                },
-                TurnStage::RollWaiting => {
-                    let mut rng = thread_rng();
-                    let dice_values = (rng.gen_range(1..=6), rng.gen_range(1..=6));
-                    GameEvent::RollResult {
-                        player_id: self.opponent_id,
-                        dice: store::Dice {
-                            values: dice_values,
-                        },
-                    }
-                }
-                TurnStage::MarkPoints => {
-                    let opponent_color = store::Color::Black;
-                    let dice_roll_count = self
-                        .game
-                        .players
-                        .get(&self.opponent_id)
-                        .unwrap()
-                        .dice_roll_count;
-                    let points_rules =
-                        PointsRules::new(&opponent_color, &self.game.board, self.game.dice);
-                    let (points, adv_points) = points_rules.get_points(dice_roll_count);
-                    reward -= 0.3 * (points - adv_points) as f32; // Récompense proportionnelle aux points
-
-                    GameEvent::Mark {
-                        player_id: self.opponent_id,
-                        points,
-                    }
-                }
-                TurnStage::MarkAdvPoints => {
-                    let opponent_color = store::Color::Black;
-                    let dice_roll_count = self
-                        .game
-                        .players
-                        .get(&self.opponent_id)
-                        .unwrap()
-                        .dice_roll_count;
-                    let points_rules =
-                        PointsRules::new(&opponent_color, &self.game.board, self.game.dice);
-                    let points = points_rules.get_points(dice_roll_count).1;
-                    // pas de reward : déjà comptabilisé lors du tour de blanc
-                    GameEvent::Mark {
-                        player_id: self.opponent_id,
-                        points,
-                    }
-                }
-                TurnStage::HoldOrGoChoice => {
-                    // Stratégie simple : toujours continuer
-                    GameEvent::Go {
-                        player_id: self.opponent_id,
-                    }
-                }
-                TurnStage::Move => GameEvent::Move {
-                    player_id: self.opponent_id,
-                    moves: default_strategy.choose_move(),
-                },
-            };
-
-            if self.game.validate(&event) {
-                self.game.consume(&event);
-            }
-        }
-        reward
-    }
-}

bot/src/dqn/burnrl/main.rs

@@ -1,68 +0,0 @@
-use bot::dqn::burnrl::{dqn_model, environment, utils::demo_model};
-use burn::backend::{ndarray::NdArrayDevice, Autodiff, NdArray};
-use burn::module::Module;
-use burn::record::{CompactRecorder, Recorder};
-use burn_rl::agent::DQN;
-use burn_rl::base::{Action, Agent, ElemType, Environment, State};
-
-type Backend = Autodiff<NdArray<ElemType>>;
-type Env = environment::TrictracEnvironment;
-
-fn main() {
-    // println!("> Entraînement");
-    let conf = dqn_model::DqnConfig {
-        num_episodes: 40,
-        // memory_size: 8192, // must be set in  dqn_model.rs with the MEMORY_SIZE constant
-        // max_steps: 700, // must be set in  environment.rs with the MAX_STEPS constant
-        dense_size: 256, // neural network complexity
-        eps_start: 0.9,  // epsilon initial value (0.9 => more exploration)
-        eps_end: 0.05,
-        eps_decay: 3000.0,
-    };
-    let agent = dqn_model::run::<Env, Backend>(&conf, false); //true);
-
-    let valid_agent = agent.valid();
-
-    println!("> Sauvegarde du modèle de validation");
-
-    let path = "models/burn_dqn_50".to_string();
-    save_model(valid_agent.model().as_ref().unwrap(), &path);
-
-    // println!("> Test avec le modèle entraîné");
-    // demo_model::<Env>(valid_agent);
-
-    println!("> Chargement du modèle pour test");
-    let loaded_model = load_model(conf.dense_size, &path);
-    let loaded_agent = DQN::new(loaded_model);
-
-    println!("> Test avec le modèle chargé");
-    demo_model(loaded_agent);
-}
-
-fn save_model(model: &dqn_model::Net<NdArray<ElemType>>, path: &String) {
-    let recorder = CompactRecorder::new();
-    let model_path = format!("{}_model.mpk", path);
-    println!("Modèle de validation sauvegardé : {}", model_path);
-    recorder
-        .record(model.clone().into_record(), model_path.into())
-        .unwrap();
-}
-
-fn load_model(dense_size: usize, path: &String) -> dqn_model::Net<NdArray<ElemType>> {
-    let model_path = format!("{}_model.mpk", path);
-    println!("Chargement du modèle depuis : {}", model_path);
-
-    let device = NdArrayDevice::default();
-    let recorder = CompactRecorder::new();
-
-    let record = recorder
-        .load(model_path.into(), &device)
-        .expect("Impossible de charger le modèle");
-
-    dqn_model::Net::new(
-        <environment::TrictracEnvironment as Environment>::StateType::size(),
-        dense_size,
-        <environment::TrictracEnvironment as Environment>::ActionType::size(),
-    )
-    .load_record(record)
-}

bot/src/dqn/burnrl/mod.rs

@@ -1,3 +0,0 @@
-pub mod dqn_model;
-pub mod environment;
-pub mod utils;

bot/src/dqn/burnrl/utils.rs

@@ -1,83 +0,0 @@
-use crate::dqn::burnrl::environment::{TrictracAction, TrictracEnvironment};
-use crate::dqn::dqn_common::get_valid_action_indices;
-use burn::module::{Param, ParamId};
-use burn::nn::Linear;
-use burn::tensor::backend::Backend;
-use burn::tensor::cast::ToElement;
-use burn::tensor::Tensor;
-use burn_rl::agent::{DQNModel, DQN};
-use burn_rl::base::{ElemType, Environment, State};
-
-pub fn demo_model<B: Backend, M: DQNModel<B>>(agent: DQN<TrictracEnvironment, B, M>) {
-    let mut env = TrictracEnvironment::new(true);
-    let mut done = false;
-    while !done {
-        // let action = match infer_action(&agent, &env, state) {
-        let action = match infer_action(&agent, &env) {
-            Some(value) => value,
-            None => break,
-        };
-        // Execute action
-        let snapshot = env.step(action);
-        done = snapshot.done();
-    }
-}
-
-fn infer_action<B: Backend, M: DQNModel<B>>(
-    agent: &DQN<TrictracEnvironment, B, M>,
-    env: &TrictracEnvironment,
-) -> Option<TrictracAction> {
-    let state = env.state();
-    // Get q-values
-    let q_values = agent
-        .model()
-        .as_ref()
-        .unwrap()
-        .infer(state.to_tensor().unsqueeze());
-    // Get valid actions
-    let valid_actions_indices = get_valid_action_indices(&env.game);
-    if valid_actions_indices.is_empty() {
-        return None; // No valid actions, end of episode
-    }
-    // Set non valid actions q-values to lowest
-    let mut masked_q_values = q_values.clone();
-    let q_values_vec: Vec<f32> = q_values.into_data().into_vec().unwrap();
-    for (index, q_value) in q_values_vec.iter().enumerate() {
-        if !valid_actions_indices.contains(&index) {
-            masked_q_values = masked_q_values.clone().mask_fill(
-                masked_q_values.clone().equal_elem(*q_value),
-                f32::NEG_INFINITY,
-            );
-        }
-    }
-    // Get best action (highest q-value)
-    let action_index = masked_q_values.argmax(1).into_scalar().to_u32();
-    let action = TrictracAction::from(action_index);
-    Some(action)
-}
-
-fn soft_update_tensor<const N: usize, B: Backend>(
-    this: &Param<Tensor<B, N>>,
-    that: &Param<Tensor<B, N>>,
-    tau: ElemType,
-) -> Param<Tensor<B, N>> {
-    let that_weight = that.val();
-    let this_weight = this.val();
-    let new_weight = this_weight * (1.0 - tau) + that_weight * tau;
-
-    Param::initialized(ParamId::new(), new_weight)
-}
-
-pub fn soft_update_linear<B: Backend>(
-    this: Linear<B>,
-    that: &Linear<B>,
-    tau: ElemType,
-) -> Linear<B> {
-    let weight = soft_update_tensor(&this.weight, &that.weight, tau);
-    let bias = match (&this.bias, &that.bias) {
-        (Some(this_bias), Some(that_bias)) => Some(soft_update_tensor(this_bias, that_bias, tau)),
-        _ => None,
-    };
-
-    Linear::<B> { weight, bias }
-}

bot/src/dqn/dqn_common.rs

@@ -1,406 +0,0 @@
-use std::cmp::{max, min};
-
-use serde::{Deserialize, Serialize};
-use store::{CheckerMove, Dice};
-
-/// Types d'actions possibles dans le jeu
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub enum TrictracAction {
-    /// Lancer les dés
-    Roll,
-    /// Continuer après avoir gagné un trou
-    Go,
-    /// Effectuer un mouvement de pions
-    Move {
-        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)
-    },
-    // Marquer les points : à activer si support des écoles
-    // Mark,
-}
-
-impl TrictracAction {
-    /// Encode une action en index pour le réseau de neurones
-    pub fn to_action_index(&self) -> usize {
-        match self {
-            TrictracAction::Roll => 0,
-            TrictracAction::Go => 1,
-            TrictracAction::Move {
-                dice_order,
-                from1,
-                from2,
-            } => {
-                // Encoder les mouvements dans l'espace d'actions
-                // Indices 2+ pour les mouvements
-                // de 2 à 1251 (2 à  626 pour dé 1 en premier, 627 à 1251 pour dé 2 en premier)
-                let mut start = 2;
-                if !dice_order {
-                    // 25 * 25 = 625
-                    start += 625;
-                }
-                start + from1 * 25 + from2
-            } // TrictracAction::Mark => 1252,
-        }
-    }
-
-    /// Décode un index d'action en TrictracAction
-    pub fn from_action_index(index: usize) -> Option<TrictracAction> {
-        match index {
-            0 => Some(TrictracAction::Roll),
-            // 1252 => Some(TrictracAction::Mark),
-            1 => Some(TrictracAction::Go),
-            i if i >= 3 => {
-                let move_code = i - 3;
-                let (dice_order, from1, from2) = Self::decode_move(move_code);
-                Some(TrictracAction::Move {
-                    dice_order,
-                    from1,
-                    from2,
-                })
-            }
-            _ => None,
-        }
-    }
-
-    /// Décode un entier en paire de mouvements
-    fn decode_move(code: usize) -> (bool, usize, usize) {
-        let mut encoded = code;
-        let dice_order = code < 626;
-        if !dice_order {
-            encoded -= 625
-        }
-        let from1 = encoded / 25;
-        let from2 = 1 + encoded % 25;
-        (dice_order, from1, from2)
-    }
-
-    /// Retourne la taille de l'espace d'actions total
-    pub fn action_space_size() -> usize {
-        // 1 (Roll) + 1 (Go) + mouvements possibles
-        // Pour les mouvements : 2*25*25 = 1250 (choix du dé + position 0-24 pour chaque from)
-        // Mais on peut optimiser en limitant aux positions valides (1-24)
-        2 + (2 * 25 * 25) // = 1252
-    }
-
-    // pub fn to_game_event(&self, player_id: PlayerId, dice: Dice) -> GameEvent {
-    //     match action {
-    //         TrictracAction::Roll => Some(GameEvent::Roll { player_id }),
-    //         TrictracAction::Mark => Some(GameEvent::Mark { player_id, points }),
-    //         TrictracAction::Go => Some(GameEvent::Go { player_id }),
-    //         TrictracAction::Move {
-    //             dice_order,
-    //             from1,
-    //             from2,
-    //         } => {
-    //             // Effectuer un mouvement
-    //             let checker_move1 = store::CheckerMove::new(move1.0, move1.1).unwrap_or_default();
-    //             let checker_move2 = store::CheckerMove::new(move2.0, move2.1).unwrap_or_default();
-    //
-    //             Some(GameEvent::Move {
-    //                 player_id: self.agent_player_id,
-    //                 moves: (checker_move1, checker_move2),
-    //             })
-    //         }
-    //     };
-    // }
-}
-
-/// Configuration pour l'agent DQN
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DqnConfig {
-    pub state_size: usize,
-    pub hidden_size: usize,
-    pub num_actions: usize,
-    pub learning_rate: f64,
-    pub gamma: f64,
-    pub epsilon: f64,
-    pub epsilon_decay: f64,
-    pub epsilon_min: f64,
-    pub replay_buffer_size: usize,
-    pub batch_size: usize,
-}
-
-impl Default for DqnConfig {
-    fn default() -> Self {
-        Self {
-            state_size: 36,
-            hidden_size: 512, // Augmenter la taille pour gérer l'espace d'actions élargi
-            num_actions: TrictracAction::action_space_size(),
-            learning_rate: 0.001,
-            gamma: 0.99,
-            epsilon: 0.1,
-            epsilon_decay: 0.995,
-            epsilon_min: 0.01,
-            replay_buffer_size: 10000,
-            batch_size: 32,
-        }
-    }
-}
-
-/// Réseau de neurones DQN simplifié (matrice de poids basique)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SimpleNeuralNetwork {
-    pub weights1: Vec<Vec<f32>>,
-    pub biases1: Vec<f32>,
-    pub weights2: Vec<Vec<f32>>,
-    pub biases2: Vec<f32>,
-    pub weights3: Vec<Vec<f32>>,
-    pub biases3: Vec<f32>,
-}
-
-impl SimpleNeuralNetwork {
-    pub fn new(input_size: usize, hidden_size: usize, output_size: usize) -> Self {
-        use rand::{thread_rng, Rng};
-        let mut rng = thread_rng();
-
-        // Initialisation aléatoire des poids avec Xavier/Glorot
-        let scale1 = (2.0 / input_size as f32).sqrt();
-        let weights1 = (0..hidden_size)
-            .map(|_| {
-                (0..input_size)
-                    .map(|_| rng.gen_range(-scale1..scale1))
-                    .collect()
-            })
-            .collect();
-        let biases1 = vec![0.0; hidden_size];
-
-        let scale2 = (2.0 / hidden_size as f32).sqrt();
-        let weights2 = (0..hidden_size)
-            .map(|_| {
-                (0..hidden_size)
-                    .map(|_| rng.gen_range(-scale2..scale2))
-                    .collect()
-            })
-            .collect();
-        let biases2 = vec![0.0; hidden_size];
-
-        let scale3 = (2.0 / hidden_size as f32).sqrt();
-        let weights3 = (0..output_size)
-            .map(|_| {
-                (0..hidden_size)
-                    .map(|_| rng.gen_range(-scale3..scale3))
-                    .collect()
-            })
-            .collect();
-        let biases3 = vec![0.0; output_size];
-
-        Self {
-            weights1,
-            biases1,
-            weights2,
-            biases2,
-            weights3,
-            biases3,
-        }
-    }
-
-    pub fn forward(&self, input: &[f32]) -> Vec<f32> {
-        // Première couche
-        let mut layer1: Vec<f32> = self.biases1.clone();
-        for (i, neuron_weights) in self.weights1.iter().enumerate() {
-            for (j, &weight) in neuron_weights.iter().enumerate() {
-                if j < input.len() {
-                    layer1[i] += input[j] * weight;
-                }
-            }
-            layer1[i] = layer1[i].max(0.0); // ReLU
-        }
-
-        // Deuxième couche
-        let mut layer2: Vec<f32> = self.biases2.clone();
-        for (i, neuron_weights) in self.weights2.iter().enumerate() {
-            for (j, &weight) in neuron_weights.iter().enumerate() {
-                if j < layer1.len() {
-                    layer2[i] += layer1[j] * weight;
-                }
-            }
-            layer2[i] = layer2[i].max(0.0); // ReLU
-        }
-
-        // Couche de sortie
-        let mut output: Vec<f32> = self.biases3.clone();
-        for (i, neuron_weights) in self.weights3.iter().enumerate() {
-            for (j, &weight) in neuron_weights.iter().enumerate() {
-                if j < layer2.len() {
-                    output[i] += layer2[j] * weight;
-                }
-            }
-        }
-
-        output
-    }
-
-    pub fn get_best_action(&self, input: &[f32]) -> usize {
-        let q_values = self.forward(input);
-        q_values
-            .iter()
-            .enumerate()
-            .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
-            .map(|(index, _)| index)
-            .unwrap_or(0)
-    }
-
-    pub fn save<P: AsRef<std::path::Path>>(
-        &self,
-        path: P,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        let data = serde_json::to_string_pretty(self)?;
-        std::fs::write(path, data)?;
-        Ok(())
-    }
-
-    pub fn load<P: AsRef<std::path::Path>>(path: P) -> Result<Self, Box<dyn std::error::Error>> {
-        let data = std::fs::read_to_string(path)?;
-        let network = serde_json::from_str(&data)?;
-        Ok(network)
-    }
-}
-
-/// Obtient les actions valides pour l'état de jeu actuel
-pub fn get_valid_actions(game_state: &crate::GameState) -> Vec<TrictracAction> {
-    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(TrictracAction::Roll);
-            }
-            TurnStage::MarkPoints | TurnStage::MarkAdvPoints => {
-                // valid_actions.push(TrictracAction::Mark);
-            }
-            TurnStage::HoldOrGoChoice => {
-                valid_actions.push(TrictracAction::Go);
-
-                // Ajoute aussi les mouvements possibles
-                let rules = store::MoveRules::new(&color, &game_state.board, game_state.dice);
-                let possible_moves = rules.get_possible_moves_sequences(true, vec![]);
-
-                // Modififier checker_moves_to_trictrac_action si on doit gérer Black
-                assert_eq!(color, store::Color::White);
-                for (move1, move2) in possible_moves {
-                    valid_actions.push(checker_moves_to_trictrac_action(
-                        &move1,
-                        &move2,
-                        &game_state.dice,
-                    ));
-                }
-            }
-            TurnStage::Move => {
-                let rules = store::MoveRules::new(&color, &game_state.board, game_state.dice);
-                let possible_moves = rules.get_possible_moves_sequences(true, vec![]);
-
-                // Modififier checker_moves_to_trictrac_action si on doit gérer Black
-                assert_eq!(color, store::Color::White);
-                for (move1, move2) in possible_moves {
-                    valid_actions.push(checker_moves_to_trictrac_action(
-                        &move1,
-                        &move2,
-                        &game_state.dice,
-                    ));
-                }
-            }
-        }
-    }
-
-    valid_actions
-}
-
-// Valid only for White player
-fn checker_moves_to_trictrac_action(
-    move1: &CheckerMove,
-    move2: &CheckerMove,
-    dice: &Dice,
-) -> TrictracAction {
-    let to1 = move1.get_to();
-    let to2 = move2.get_to();
-    let from1 = move1.get_from();
-    let from2 = move2.get_from();
-
-    let mut diff_move1 = if to1 > 0 {
-        // Mouvement sans sortie
-        to1 - from1
-    } else {
-        // sortie, on utilise la valeur du dé
-        if to2 > 0 {
-            // sortie pour le mouvement 1 uniquement
-            let dice2 = to2 - from2;
-            if dice2 == dice.values.0 as usize {
-                dice.values.1 as usize
-            } else {
-                dice.values.0 as usize
-            }
-        } else {
-            // double sortie
-            if from1 < from2 {
-                max(dice.values.0, dice.values.1) as usize
-            } else {
-                min(dice.values.0, dice.values.1) as usize
-            }
-        }
-    };
-
-    // modification de diff_move1 si on est dans le cas d'un mouvement par puissance
-    let rest_field = 12;
-    if to1 == rest_field
-        && to2 == rest_field
-        && max(dice.values.0 as usize, dice.values.1 as usize) + min(from1, from2) != rest_field
-    {
-        // prise par puissance
-        diff_move1 += 1;
-    }
-    TrictracAction::Move {
-        dice_order: diff_move1 == dice.values.0 as usize,
-        from1: move1.get_from(),
-        from2: move2.get_from(),
-    }
-}
-
-/// Retourne les indices des actions valides
-pub fn get_valid_action_indices(game_state: &crate::GameState) -> Vec<usize> {
-    get_valid_actions(game_state)
-        .into_iter()
-        .map(|action| action.to_action_index())
-        .collect()
-}
-
-/// Sélectionne une action valide aléatoire
-pub fn sample_valid_action(game_state: &crate::GameState) -> Option<TrictracAction> {
-    use rand::{seq::SliceRandom, thread_rng};
-
-    let valid_actions = get_valid_actions(game_state);
-    let mut rng = thread_rng();
-    valid_actions.choose(&mut rng).cloned()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn to_action_index() {
-        let action = TrictracAction::Move {
-            dice_order: true,
-            from1: 3,
-            from2: 4,
-        };
-        let index = action.to_action_index();
-        assert_eq!(Some(action), TrictracAction::from_action_index(index));
-        assert_eq!(81, index);
-    }
-
-    #[test]
-    fn from_action_index() {
-        let action = TrictracAction::Move {
-            dice_order: true,
-            from1: 3,
-            from2: 4,
-        };
-        assert_eq!(Some(action), TrictracAction::from_action_index(81));
-    }
-}

bot/src/dqn/mod.rs

@@ -1,3 +0,0 @@
-pub mod dqn_common;
-pub mod simple;
-pub mod burnrl;

bot/src/dqn/simple/dqn_trainer.rs

@@ -1,489 +0,0 @@
-use crate::{CheckerMove, Color, GameState, PlayerId};
-use rand::prelude::SliceRandom;
-use rand::{thread_rng, Rng};
-use serde::{Deserialize, Serialize};
-use std::collections::VecDeque;
-use store::{GameEvent, MoveRules, PointsRules, Stage, TurnStage};
-
-use crate::dqn::dqn_common::{get_valid_actions, DqnConfig, SimpleNeuralNetwork, TrictracAction};
-
-/// Expérience pour le buffer de replay
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Experience {
-    pub state: Vec<f32>,
-    pub action: TrictracAction,
-    pub reward: f32,
-    pub next_state: Vec<f32>,
-    pub done: bool,
-}
-
-/// Buffer de replay pour stocker les expériences
-#[derive(Debug)]
-pub struct ReplayBuffer {
-    buffer: VecDeque<Experience>,
-    capacity: usize,
-}
-
-impl ReplayBuffer {
-    pub fn new(capacity: usize) -> Self {
-        Self {
-            buffer: VecDeque::with_capacity(capacity),
-            capacity,
-        }
-    }
-
-    pub fn push(&mut self, experience: Experience) {
-        if self.buffer.len() >= self.capacity {
-            self.buffer.pop_front();
-        }
-        self.buffer.push_back(experience);
-    }
-
-    pub fn sample(&self, batch_size: usize) -> Vec<Experience> {
-        let mut rng = thread_rng();
-        let len = self.buffer.len();
-        if len < batch_size {
-            return self.buffer.iter().cloned().collect();
-        }
-
-        let mut batch = Vec::with_capacity(batch_size);
-        for _ in 0..batch_size {
-            let idx = rng.gen_range(0..len);
-            batch.push(self.buffer[idx].clone());
-        }
-        batch
-    }
-
-    pub fn len(&self) -> usize {
-        self.buffer.len()
-    }
-}
-
-/// Agent DQN pour l'apprentissage par renforcement
-#[derive(Debug)]
-pub struct DqnAgent {
-    config: DqnConfig,
-    model: SimpleNeuralNetwork,
-    target_model: SimpleNeuralNetwork,
-    replay_buffer: ReplayBuffer,
-    epsilon: f64,
-    step_count: usize,
-}
-
-impl DqnAgent {
-    pub fn new(config: DqnConfig) -> Self {
-        let model =
-            SimpleNeuralNetwork::new(config.state_size, config.hidden_size, config.num_actions);
-        let target_model = model.clone();
-        let replay_buffer = ReplayBuffer::new(config.replay_buffer_size);
-        let epsilon = config.epsilon;
-
-        Self {
-            config,
-            model,
-            target_model,
-            replay_buffer,
-            epsilon,
-            step_count: 0,
-        }
-    }
-
-    pub fn select_action(&mut self, game_state: &GameState, state: &[f32]) -> TrictracAction {
-        let valid_actions = get_valid_actions(game_state);
-
-        if valid_actions.is_empty() {
-            // Fallback si aucune action valide
-            return TrictracAction::Roll;
-        }
-
-        let mut rng = thread_rng();
-        if rng.gen::<f64>() < self.epsilon {
-            // Exploration : action valide aléatoire
-            valid_actions
-                .choose(&mut rng)
-                .cloned()
-                .unwrap_or(TrictracAction::Roll)
-        } else {
-            // Exploitation : meilleure action valide selon le modèle
-            let q_values = self.model.forward(state);
-
-            let mut best_action = &valid_actions[0];
-            let mut best_q_value = f32::NEG_INFINITY;
-
-            for action in &valid_actions {
-                let action_index = action.to_action_index();
-                if action_index < q_values.len() {
-                    let q_value = q_values[action_index];
-                    if q_value > best_q_value {
-                        best_q_value = q_value;
-                        best_action = action;
-                    }
-                }
-            }
-
-            best_action.clone()
-        }
-    }
-
-    pub fn store_experience(&mut self, experience: Experience) {
-        self.replay_buffer.push(experience);
-    }
-
-    pub fn train(&mut self) {
-        if self.replay_buffer.len() < self.config.batch_size {
-            return;
-        }
-
-        // Pour l'instant, on simule l'entraînement en mettant à jour epsilon
-        // Dans une implémentation complète, ici on ferait la backpropagation
-        self.epsilon = (self.epsilon * self.config.epsilon_decay).max(self.config.epsilon_min);
-        self.step_count += 1;
-
-        // Mise à jour du target model tous les 100 steps
-        if self.step_count % 100 == 0 {
-            self.target_model = self.model.clone();
-        }
-    }
-
-    pub fn save_model<P: AsRef<std::path::Path>>(
-        &self,
-        path: P,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        self.model.save(path)
-    }
-
-    pub fn get_epsilon(&self) -> f64 {
-        self.epsilon
-    }
-
-    pub fn get_step_count(&self) -> usize {
-        self.step_count
-    }
-}
-
-/// Environnement Trictrac pour l'entraînement
-#[derive(Debug)]
-pub struct TrictracEnv {
-    pub game_state: GameState,
-    pub agent_player_id: PlayerId,
-    pub opponent_player_id: PlayerId,
-    pub agent_color: Color,
-    pub max_steps: usize,
-    pub current_step: usize,
-}
-
-impl Default for TrictracEnv {
-    fn default() -> Self {
-        let mut game_state = GameState::new(false);
-        game_state.init_player("agent");
-        game_state.init_player("opponent");
-
-        Self {
-            game_state,
-            agent_player_id: 1,
-            opponent_player_id: 2,
-            agent_color: Color::White,
-            max_steps: 1000,
-            current_step: 0,
-        }
-    }
-}
-
-impl TrictracEnv {
-    pub fn reset(&mut self) -> Vec<f32> {
-        self.game_state = GameState::new(false);
-        self.game_state.init_player("agent");
-        self.game_state.init_player("opponent");
-
-        // Commencer la partie
-        self.game_state.consume(&GameEvent::BeginGame {
-            goes_first: self.agent_player_id,
-        });
-
-        self.current_step = 0;
-        self.game_state.to_vec_float()
-    }
-
-    pub fn step(&mut self, action: TrictracAction) -> (Vec<f32>, f32, bool) {
-        let mut reward = 0.0;
-
-        // Appliquer l'action de l'agent
-        if self.game_state.active_player_id == self.agent_player_id {
-            reward += self.apply_agent_action(action);
-        }
-
-        // Faire jouer l'adversaire (stratégie simple)
-        while self.game_state.active_player_id == self.opponent_player_id
-            && self.game_state.stage != Stage::Ended
-        {
-            reward += self.play_opponent_turn();
-        }
-
-        // Vérifier si la partie est terminée
-        let done = self.game_state.stage == Stage::Ended
-            || self.game_state.determine_winner().is_some()
-            || self.current_step >= self.max_steps;
-
-        // Récompense finale si la partie est terminée
-        if done {
-            if let Some(winner) = self.game_state.determine_winner() {
-                if winner == self.agent_player_id {
-                    reward += 100.0; // Bonus pour gagner
-                } else {
-                    reward -= 50.0; // Pénalité pour perdre
-                }
-            }
-        }
-
-        self.current_step += 1;
-        let next_state = self.game_state.to_vec_float();
-        (next_state, reward, done)
-    }
-
-    fn apply_agent_action(&mut self, action: TrictracAction) -> f32 {
-        let mut reward = 0.0;
-
-        let event = match action {
-            TrictracAction::Roll => {
-                // Lancer les dés
-                reward += 0.1;
-                Some(GameEvent::Roll {
-                    player_id: self.agent_player_id,
-                })
-            }
-            // TrictracAction::Mark => {
-            //     // Marquer des points
-            //     let points = self.game_state.
-            //     reward += 0.1 * points as f32;
-            //     Some(GameEvent::Mark {
-            //         player_id: self.agent_player_id,
-            //         points,
-            //     })
-            // }
-            TrictracAction::Go => {
-                // Continuer après avoir gagné un trou
-                reward += 0.2;
-                Some(GameEvent::Go {
-                    player_id: self.agent_player_id,
-                })
-            }
-            TrictracAction::Move {
-                dice_order,
-                from1,
-                from2,
-            } => {
-                // Effectuer un mouvement
-                let (dice1, dice2) = if dice_order {
-                    (self.game_state.dice.values.0, self.game_state.dice.values.1)
-                } else {
-                    (self.game_state.dice.values.1, self.game_state.dice.values.0)
-                };
-                let mut to1 = from1 + dice1 as usize;
-                let mut to2 = from2 + dice2 as usize;
-
-                // Gestion prise de coin par puissance
-                let opp_rest_field = 13;
-                if to1 == opp_rest_field && to2 == opp_rest_field {
-                    to1 -= 1;
-                    to2 -= 1;
-                }
-
-                let checker_move1 = store::CheckerMove::new(from1, to1).unwrap_or_default();
-                let checker_move2 = store::CheckerMove::new(from2, to2).unwrap_or_default();
-
-                reward += 0.2;
-                Some(GameEvent::Move {
-                    player_id: self.agent_player_id,
-                    moves: (checker_move1, checker_move2),
-                })
-            }
-        };
-
-        // Appliquer l'événement si valide
-        if let Some(event) = event {
-            if self.game_state.validate(&event) {
-                self.game_state.consume(&event);
-
-                // Simuler le résultat des dés après un Roll
-                if matches!(action, TrictracAction::Roll) {
-                    let mut rng = thread_rng();
-                    let dice_values = (rng.gen_range(1..=6), rng.gen_range(1..=6));
-                    let dice_event = GameEvent::RollResult {
-                        player_id: self.agent_player_id,
-                        dice: store::Dice {
-                            values: dice_values,
-                        },
-                    };
-                    if self.game_state.validate(&dice_event) {
-                        self.game_state.consume(&dice_event);
-                    }
-                }
-            } else {
-                // Pénalité pour action invalide
-                reward -= 2.0;
-            }
-        }
-
-        reward
-    }
-
-    // TODO : use default bot strategy
-    fn play_opponent_turn(&mut self) -> f32 {
-        let mut reward = 0.0;
-        let event = match self.game_state.turn_stage {
-            TurnStage::RollDice => GameEvent::Roll {
-                player_id: self.opponent_player_id,
-            },
-            TurnStage::RollWaiting => {
-                let mut rng = thread_rng();
-                let dice_values = (rng.gen_range(1..=6), rng.gen_range(1..=6));
-                GameEvent::RollResult {
-                    player_id: self.opponent_player_id,
-                    dice: store::Dice {
-                        values: dice_values,
-                    },
-                }
-            }
-            TurnStage::MarkAdvPoints | TurnStage::MarkPoints => {
-                let opponent_color = self.agent_color.opponent_color();
-                let dice_roll_count = self
-                    .game_state
-                    .players
-                    .get(&self.opponent_player_id)
-                    .unwrap()
-                    .dice_roll_count;
-                let points_rules = PointsRules::new(
-                    &opponent_color,
-                    &self.game_state.board,
-                    self.game_state.dice,
-                );
-                let (points, adv_points) = points_rules.get_points(dice_roll_count);
-                reward -= 0.3 * (points - adv_points) as f32; // Récompense proportionnelle aux points
-
-                GameEvent::Mark {
-                    player_id: self.opponent_player_id,
-                    points,
-                }
-            }
-            TurnStage::Move => {
-                let opponent_color = self.agent_color.opponent_color();
-                let rules = MoveRules::new(
-                    &opponent_color,
-                    &self.game_state.board,
-                    self.game_state.dice,
-                );
-                let possible_moves = rules.get_possible_moves_sequences(true, vec![]);
-
-                // Stratégie simple : choix aléatoire
-                let mut rng = thread_rng();
-                let choosen_move = *possible_moves
-                    .choose(&mut rng)
-                    .unwrap_or(&(CheckerMove::default(), CheckerMove::default()));
-
-                GameEvent::Move {
-                    player_id: self.opponent_player_id,
-                    moves: if opponent_color == Color::White {
-                        choosen_move
-                    } else {
-                        (choosen_move.0.mirror(), choosen_move.1.mirror())
-                    },
-                }
-            }
-            TurnStage::HoldOrGoChoice => {
-                // Stratégie simple : toujours continuer
-                GameEvent::Go {
-                    player_id: self.opponent_player_id,
-                }
-            }
-        };
-        if self.game_state.validate(&event) {
-            self.game_state.consume(&event);
-        }
-        reward
-    }
-}
-
-/// Entraîneur pour le modèle DQN
-pub struct DqnTrainer {
-    agent: DqnAgent,
-    env: TrictracEnv,
-}
-
-impl DqnTrainer {
-    pub fn new(config: DqnConfig) -> Self {
-        Self {
-            agent: DqnAgent::new(config),
-            env: TrictracEnv::default(),
-        }
-    }
-
-    pub fn train_episode(&mut self) -> f32 {
-        let mut total_reward = 0.0;
-        let mut state = self.env.reset();
-        // let mut step_count = 0;
-
-        loop {
-            // step_count += 1;
-            let action = self.agent.select_action(&self.env.game_state, &state);
-            let (next_state, reward, done) = self.env.step(action.clone());
-            total_reward += reward;
-
-            let experience = Experience {
-                state: state.clone(),
-                action,
-                reward,
-                next_state: next_state.clone(),
-                done,
-            };
-            self.agent.store_experience(experience);
-            self.agent.train();
-
-            if done {
-                break;
-            }
-            // if step_count % 100 == 0 {
-            //     println!("{:?}", next_state);
-            // }
-            state = next_state;
-        }
-
-        total_reward
-    }
-
-    pub fn train(
-        &mut self,
-        episodes: usize,
-        save_every: usize,
-        model_path: &str,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        println!("Démarrage de l'entraînement DQN pour {} épisodes", episodes);
-
-        for episode in 1..=episodes {
-            let reward = self.train_episode();
-
-            if episode % 100 == 0 {
-                println!(
-                    "Épisode {}/{}: Récompense = {:.2}, Epsilon = {:.3}, Steps = {}",
-                    episode,
-                    episodes,
-                    reward,
-                    self.agent.get_epsilon(),
-                    self.agent.get_step_count()
-                );
-            }
-
-            if episode % save_every == 0 {
-                let save_path = format!("{}_episode_{}.json", model_path, episode);
-                self.agent.save_model(&save_path)?;
-                println!("Modèle sauvegardé : {}", save_path);
-            }
-        }
-
-        // Sauvegarder le modèle final
-        let final_path = format!("{}_final.json", model_path);
-        self.agent.save_model(&final_path)?;
-        println!("Modèle final sauvegardé : {}", final_path);
-
-        Ok(())
-    }
-}

bot/src/dqn/simple/mod.rs

@@ -1 +0,0 @@
-pub mod dqn_trainer;

bot/src/lib.rs

@@ -1,11 +1,7 @@
-pub mod dqn;
-pub mod strategy;
+mod strategy;
 
 use store::{CheckerMove, Color, GameEvent, GameState, PlayerId, PointsRules, Stage, TurnStage};
 pub use strategy::default::DefaultStrategy;
-pub use strategy::dqn::DqnStrategy;
-pub use strategy::erroneous_moves::ErroneousStrategy;
-pub use strategy::stable_baselines3::StableBaselines3Strategy;
 
 pub trait BotStrategy: std::fmt::Debug {
     fn get_game(&self) -> &GameState;

bot/src/strategy.rs

@@ -0,0 +1,2 @@
+pub mod client;
+pub mod default;

bot/src/strategy/client.rs

@@ -46,14 +46,7 @@ impl BotStrategy for ClientStrategy {
     }
 
     fn calculate_adv_points(&self) -> u8 {
-        let dice_roll_count = self
-            .get_game()
-            .players
-            .get(&self.player_id)
-            .unwrap()
-            .dice_roll_count;
-        let points_rules = PointsRules::new(&Color::White, &self.game.board, self.game.dice);
-        points_rules.get_points(dice_roll_count).1
+        self.calculate_points()
     }
 
     fn choose_go(&self) -> bool {

bot/src/strategy/default.rs

@@ -1,4 +1,4 @@
-use crate::{BotStrategy, CheckerMove, Color, GameState, PlayerId};
+use crate::{BotStrategy, CheckerMove, Color, GameState, PlayerId, PointsRules};
 use store::MoveRules;
 
 #[derive(Debug)]
@@ -36,20 +36,18 @@ impl BotStrategy for DefaultStrategy {
     }
 
     fn calculate_points(&self) -> u8 {
-        // let dice_roll_count = self
-        //     .get_game()
-        //     .players
-        //     .get(&self.player_id)
-        //     .unwrap()
-        //     .dice_roll_count;
-        // let points_rules = PointsRules::new(&Color::White, &self.game.board, self.game.dice);
-        // points_rules.get_points(dice_roll_count).0
-        self.game.dice_points.0
+        let dice_roll_count = self
+            .get_game()
+            .players
+            .get(&self.player_id)
+            .unwrap()
+            .dice_roll_count;
+        let points_rules = PointsRules::new(&Color::White, &self.game.board, self.game.dice);
+        points_rules.get_points(dice_roll_count).0
     }
 
     fn calculate_adv_points(&self) -> u8 {
-        // self.calculate_points()
-        self.game.dice_points.1
+        self.calculate_points()
     }
 
     fn choose_go(&self) -> bool {

bot/src/strategy/dqn.rs

@@ -1,175 +0,0 @@
-use crate::{BotStrategy, CheckerMove, Color, GameState, PlayerId};
-use std::path::Path;
-use store::MoveRules;
-
-use crate::dqn::dqn_common::{
-    get_valid_actions, sample_valid_action, SimpleNeuralNetwork, TrictracAction,
-};
-
-/// Stratégie DQN pour le bot - ne fait que charger et utiliser un modèle pré-entraîné
-#[derive(Debug)]
-pub struct DqnStrategy {
-    pub game: GameState,
-    pub player_id: PlayerId,
-    pub color: Color,
-    pub model: Option<SimpleNeuralNetwork>,
-}
-
-impl Default for DqnStrategy {
-    fn default() -> Self {
-        Self {
-            game: GameState::default(),
-            player_id: 2,
-            color: Color::Black,
-            model: None,
-        }
-    }
-}
-
-impl DqnStrategy {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn new_with_model<P: AsRef<Path>>(model_path: P) -> Self {
-        let mut strategy = Self::new();
-        if let Ok(model) = SimpleNeuralNetwork::load(model_path) {
-            strategy.model = Some(model);
-        }
-        strategy
-    }
-
-    /// Utilise le modèle DQN pour choisir une action valide
-    fn get_dqn_action(&self) -> Option<TrictracAction> {
-        if let Some(ref model) = self.model {
-            let state = self.game.to_vec_float();
-            let valid_actions = get_valid_actions(&self.game);
-
-            if valid_actions.is_empty() {
-                return None;
-            }
-
-            // Obtenir les Q-values pour toutes les actions
-            let q_values = model.forward(&state);
-
-            // Trouver la meilleure action valide
-            let mut best_action = &valid_actions[0];
-            let mut best_q_value = f32::NEG_INFINITY;
-
-            for action in &valid_actions {
-                let action_index = action.to_action_index();
-                if action_index < q_values.len() {
-                    let q_value = q_values[action_index];
-                    if q_value > best_q_value {
-                        best_q_value = q_value;
-                        best_action = action;
-                    }
-                }
-            }
-
-            Some(best_action.clone())
-        } else {
-            // Fallback : action aléatoire valide
-            sample_valid_action(&self.game)
-        }
-    }
-}
-
-impl BotStrategy for DqnStrategy {
-    fn get_game(&self) -> &GameState {
-        &self.game
-    }
-
-    fn get_mut_game(&mut self) -> &mut GameState {
-        &mut self.game
-    }
-
-    fn set_color(&mut self, color: Color) {
-        self.color = color;
-    }
-
-    fn set_player_id(&mut self, player_id: PlayerId) {
-        self.player_id = player_id;
-    }
-
-    fn calculate_points(&self) -> u8 {
-        self.game.dice_points.0
-    }
-
-    fn calculate_adv_points(&self) -> u8 {
-        self.game.dice_points.1
-    }
-
-    fn choose_go(&self) -> bool {
-        // Utiliser le DQN pour décider si on continue
-        if let Some(action) = self.get_dqn_action() {
-            matches!(action, TrictracAction::Go)
-        } else {
-            // Fallback : toujours continuer
-            true
-        }
-    }
-
-    fn choose_move(&self) -> (CheckerMove, CheckerMove) {
-        // Utiliser le DQN pour choisir le mouvement
-        if let Some(action) = self.get_dqn_action() {
-            if let TrictracAction::Move {
-                dice_order,
-                from1,
-                from2,
-            } = action
-            {
-                let dicevals = self.game.dice.values;
-                let (mut dice1, mut dice2) = if dice_order {
-                    (dicevals.0, dicevals.1)
-                } else {
-                    (dicevals.1, dicevals.0)
-                };
-
-                if from1 == 0 {
-                    // empty move
-                    dice1 = 0;
-                }
-                let mut to1 = from1 + dice1 as usize;
-                if 24 < to1 {
-                    // sortie
-                    to1 = 0;
-                }
-                if from2 == 0 {
-                    // empty move
-                    dice2 = 0;
-                }
-                let mut to2 = from2 + dice2 as usize;
-                if 24 < to2 {
-                    // sortie
-                    to2 = 0;
-                }
-
-                let checker_move1 = CheckerMove::new(from1, to1).unwrap_or_default();
-                let checker_move2 = CheckerMove::new(from2, to2).unwrap_or_default();
-
-                let chosen_move = if self.color == Color::White {
-                    (checker_move1, checker_move2)
-                } else {
-                    (checker_move1.mirror(), checker_move2.mirror())
-                };
-
-                return chosen_move;
-            }
-        }
-
-        // Fallback : utiliser la stratégie par défaut
-        let rules = MoveRules::new(&self.color, &self.game.board, self.game.dice);
-        let possible_moves = rules.get_possible_moves_sequences(true, vec![]);
-
-        let chosen_move = *possible_moves
-            .first()
-            .unwrap_or(&(CheckerMove::default(), CheckerMove::default()));
-
-        if self.color == Color::White {
-            chosen_move
-        } else {
-            (chosen_move.0.mirror(), chosen_move.1.mirror())
-        }
-    }
-}

bot/src/strategy/erroneous_moves.rs

@@ -1,62 +0,0 @@
-use crate::{BotStrategy, CheckerMove, Color, GameState, PlayerId, PointsRules};
-
-#[derive(Debug)]
-pub struct ErroneousStrategy {
-    pub game: GameState,
-    pub player_id: PlayerId,
-    pub color: Color,
-}
-
-impl Default for ErroneousStrategy {
-    fn default() -> Self {
-        let game = GameState::default();
-        Self {
-            game,
-            player_id: 2,
-            color: Color::Black,
-        }
-    }
-}
-
-impl BotStrategy for ErroneousStrategy {
-    fn get_game(&self) -> &GameState {
-        &self.game
-    }
-    fn get_mut_game(&mut self) -> &mut GameState {
-        &mut self.game
-    }
-
-    fn set_color(&mut self, color: Color) {
-        self.color = color;
-    }
-
-    fn set_player_id(&mut self, player_id: PlayerId) {
-        self.player_id = player_id;
-    }
-
-    fn calculate_points(&self) -> u8 {
-        let dice_roll_count = self
-            .get_game()
-            .players
-            .get(&self.player_id)
-            .unwrap()
-            .dice_roll_count;
-        let points_rules = PointsRules::new(&Color::White, &self.game.board, self.game.dice);
-        points_rules.get_points(dice_roll_count).0
-    }
-
-    fn calculate_adv_points(&self) -> u8 {
-        self.calculate_points()
-    }
-
-    fn choose_go(&self) -> bool {
-        true
-    }
-
-    fn choose_move(&self) -> (CheckerMove, CheckerMove) {
-        (
-            CheckerMove::new(1, 10).unwrap(),
-            CheckerMove::new(2, 7).unwrap(),
-        )
-    }
-}

bot/src/strategy/mod.rs

@@ -1,5 +0,0 @@
-pub mod client;
-pub mod default;
-pub mod dqn;
-pub mod erroneous_moves;
-pub mod stable_baselines3;

bot/src/strategy/stable_baselines3.rs

@@ -1,273 +0,0 @@
-use crate::{BotStrategy, CheckerMove, Color, GameState, PlayerId, PointsRules};
-use serde::{Deserialize, Serialize};
-use std::fs::File;
-use std::io::Read;
-use std::io::Write;
-use std::path::Path;
-use std::process::Command;
-use store::MoveRules;
-
-#[derive(Debug)]
-pub struct StableBaselines3Strategy {
-    pub game: GameState,
-    pub player_id: PlayerId,
-    pub color: Color,
-    pub model_path: String,
-}
-
-impl Default for StableBaselines3Strategy {
-    fn default() -> Self {
-        let game = GameState::default();
-        Self {
-            game,
-            player_id: 2,
-            color: Color::Black,
-            model_path: "models/trictrac_ppo.zip".to_string(),
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-struct GameStateJson {
-    board: Vec<i8>,
-    active_player: u8,
-    dice: [u8; 2],
-    white_points: u8,
-    white_holes: u8,
-    black_points: u8,
-    black_holes: u8,
-    turn_stage: u8,
-}
-
-#[derive(Deserialize)]
-struct ActionJson {
-    action_type: u8,
-    from1: usize,
-    to1: usize,
-    from2: usize,
-    to2: usize,
-}
-
-impl StableBaselines3Strategy {
-    pub fn new(model_path: &str) -> Self {
-        let game = GameState::default();
-        Self {
-            game,
-            player_id: 2,
-            color: Color::Black,
-            model_path: model_path.to_string(),
-        }
-    }
-
-    fn get_state_as_json(&self) -> GameStateJson {
-        // Convertir l'état du jeu en un format compatible avec notre modèle Python
-        let mut board = vec![0; 24];
-
-        // Remplir les positions des pièces blanches (valeurs positives)
-        for (pos, count) in self.game.board.get_color_fields(Color::White) {
-            if pos < 24 {
-                board[pos] = count as i8;
-            }
-        }
-
-        // Remplir les positions des pièces noires (valeurs négatives)
-        for (pos, count) in self.game.board.get_color_fields(Color::Black) {
-            if pos < 24 {
-                board[pos] = -(count as i8);
-            }
-        }
-
-        // Convertir l'étape du tour en entier
-        let turn_stage = match self.game.turn_stage {
-            store::TurnStage::RollDice => 0,
-            store::TurnStage::RollWaiting => 1,
-            store::TurnStage::MarkPoints => 2,
-            store::TurnStage::HoldOrGoChoice => 3,
-            store::TurnStage::Move => 4,
-            store::TurnStage::MarkAdvPoints => 5,
-        };
-
-        // Récupérer les points et trous des joueurs
-        let white_points = self.game.players.get(&1).map_or(0, |p| p.points);
-        let white_holes = self.game.players.get(&1).map_or(0, |p| p.holes);
-        let black_points = self.game.players.get(&2).map_or(0, |p| p.points);
-        let black_holes = self.game.players.get(&2).map_or(0, |p| p.holes);
-
-        // Créer l'objet JSON
-        GameStateJson {
-            board,
-            active_player: self.game.active_player_id as u8,
-            dice: [self.game.dice.values.0, self.game.dice.values.1],
-            white_points,
-            white_holes,
-            black_points,
-            black_holes,
-            turn_stage,
-        }
-    }
-
-    fn predict_action(&self) -> Option<ActionJson> {
-        // Convertir l'état du jeu en JSON
-        let state_json = self.get_state_as_json();
-        let state_str = serde_json::to_string(&state_json).unwrap();
-
-        // Écrire l'état dans un fichier temporaire
-        let temp_input_path = "temp_state.json";
-        let mut file = File::create(temp_input_path).ok()?;
-        file.write_all(state_str.as_bytes()).ok()?;
-
-        // Exécuter le script Python pour faire une prédiction
-        let output_path = "temp_action.json";
-        let python_script = format!(
-            r#"
-import sys
-import json
-import numpy as np
-from stable_baselines3 import PPO
-import torch
-
-# Charger le modèle
-model = PPO.load("{}")
-
-# Lire l'état du jeu
-with open("temp_state.json", "r") as f:
-    state_dict = json.load(f)
-
-# Convertir en format d'observation attendu par le modèle
-observation = {{
-    'board': np.array(state_dict['board'], dtype=np.int8),
-    'active_player': state_dict['active_player'],
-    'dice': np.array(state_dict['dice'], dtype=np.int32),
-    'white_points': state_dict['white_points'],
-    'white_holes': state_dict['white_holes'],
-    'black_points': state_dict['black_points'],
-    'black_holes': state_dict['black_holes'],
-    'turn_stage': state_dict['turn_stage'],
-}}
-
-# Prédire l'action
-action, _ = model.predict(observation)
-
-# Convertir l'action en format lisible
-action_dict = {{
-    'action_type': int(action[0]),
-    'from1': int(action[1]),
-    'to1': int(action[2]),
-    'from2': int(action[3]),
-    'to2': int(action[4]),
-}}
-
-# Écrire l'action dans un fichier
-with open("{}", "w") as f:
-    json.dump(action_dict, f)
-"#,
-            self.model_path, output_path
-        );
-
-        let temp_script_path = "temp_predict.py";
-        let mut script_file = File::create(temp_script_path).ok()?;
-        script_file.write_all(python_script.as_bytes()).ok()?;
-
-        // Exécuter le script Python
-        let status = Command::new("python").arg(temp_script_path).status().ok()?;
-
-        if !status.success() {
-            return None;
-        }
-
-        // Lire la prédiction
-        if Path::new(output_path).exists() {
-            let mut file = File::open(output_path).ok()?;
-            let mut contents = String::new();
-            file.read_to_string(&mut contents).ok()?;
-
-            // Nettoyer les fichiers temporaires
-            std::fs::remove_file(temp_input_path).ok();
-            std::fs::remove_file(temp_script_path).ok();
-            std::fs::remove_file(output_path).ok();
-
-            // Analyser la prédiction
-            let action: ActionJson = serde_json::from_str(&contents).ok()?;
-            Some(action)
-        } else {
-            None
-        }
-    }
-}
-
-impl BotStrategy for StableBaselines3Strategy {
-    fn get_game(&self) -> &GameState {
-        &self.game
-    }
-
-    fn get_mut_game(&mut self) -> &mut GameState {
-        &mut self.game
-    }
-
-    fn set_color(&mut self, color: Color) {
-        self.color = color;
-    }
-
-    fn set_player_id(&mut self, player_id: PlayerId) {
-        self.player_id = player_id;
-    }
-
-    fn calculate_points(&self) -> u8 {
-        // Utiliser la prédiction du modèle uniquement si c'est une action de type "mark" (1)
-        if let Some(action) = self.predict_action() {
-            if action.action_type == 1 {
-                // Marquer les points calculés par le modèle (ici on utilise la somme des dés comme proxy)
-                return self.game.dice.values.0 + self.game.dice.values.1;
-            }
-        }
-
-        // Fallback vers la méthode standard si la prédiction échoue
-        let dice_roll_count = self
-            .get_game()
-            .players
-            .get(&self.player_id)
-            .unwrap()
-            .dice_roll_count;
-        let points_rules = PointsRules::new(&Color::White, &self.game.board, self.game.dice);
-        points_rules.get_points(dice_roll_count).0
-    }
-
-    fn calculate_adv_points(&self) -> u8 {
-        self.calculate_points()
-    }
-
-    fn choose_go(&self) -> bool {
-        // Utiliser la prédiction du modèle uniquement si c'est une action de type "go" (2)
-        if let Some(action) = self.predict_action() {
-            return action.action_type == 2;
-        }
-
-        // Fallback vers la méthode standard si la prédiction échoue
-        true
-    }
-
-    fn choose_move(&self) -> (CheckerMove, CheckerMove) {
-        // Utiliser la prédiction du modèle uniquement si c'est une action de type "move" (0)
-        if let Some(action) = self.predict_action() {
-            if action.action_type == 0 {
-                let move1 = CheckerMove::new(action.from1, action.to1).unwrap_or_default();
-                let move2 = CheckerMove::new(action.from2, action.to2).unwrap_or_default();
-                return (move1, move2);
-            }
-        }
-
-        // Fallback vers la méthode standard si la prédiction échoue
-        let rules = MoveRules::new(&self.color, &self.game.board, self.game.dice);
-        let possible_moves = rules.get_possible_moves_sequences(true, vec![]);
-        let choosen_move = *possible_moves
-            .first()
-            .unwrap_or(&(CheckerMove::default(), CheckerMove::default()));
-
-        if self.color == Color::White {
-            choosen_move
-        } else {
-            (choosen_move.0.mirror(), choosen_move.1.mirror())
-        }
-    }
-}
-

client_cli/src/app.rs

@@ -1,4 +1,4 @@
-use bot::{BotStrategy, DefaultStrategy, DqnStrategy, ErroneousStrategy, StableBaselines3Strategy};
+use bot::{BotStrategy, DefaultStrategy};
 use itertools::Itertools;
 
 use crate::game_runner::GameRunner;
@@ -22,8 +22,8 @@ pub struct App {
 impl App {
     // Constructs a new instance of [`App`].
     pub fn new(args: AppArgs) -> Self {
-        let bot_strategies: Vec<Box<dyn BotStrategy>> =
-            args.bot
+        let bot_strategies: Vec<Box<dyn BotStrategy>> = args
+            .bot
             .as_deref()
             .map(|str_bots| {
                 str_bots
@@ -32,23 +32,6 @@ impl App {
                         "dummy" => {
                             Some(Box::new(DefaultStrategy::default()) as Box<dyn BotStrategy>)
                         }
-                            "erroneous" => {
-                                Some(Box::new(ErroneousStrategy::default()) as Box<dyn BotStrategy>)
-                            }
-                            "ai" => Some(Box::new(StableBaselines3Strategy::default())
-                                as Box<dyn BotStrategy>),
-                            "dqn" => Some(Box::new(DqnStrategy::default())
-                                as Box<dyn BotStrategy>),
-                            s if s.starts_with("ai:") => {
-                                let path = s.trim_start_matches("ai:");
-                                Some(Box::new(StableBaselines3Strategy::new(path))
-                                    as Box<dyn BotStrategy>)
-                            }
-                            s if s.starts_with("dqn:") => {
-                                let path = s.trim_start_matches("dqn:");
-                                Some(Box::new(DqnStrategy::new_with_model(path))
-                                    as Box<dyn BotStrategy>)
-                            }
                         _ => None,
                     })
                     .collect()

client_cli/src/game_runner.rs

@@ -58,17 +58,12 @@ impl GameRunner {
     }
 
     pub fn handle_event(&mut self, event: &GameEvent) -> Option<GameEvent> {
-        if event == &GameEvent::PlayError {
+        if !self.state.validate(event) {
+            println!("event not valid : {:?}", event);
             return None;
         }
-        let valid_event = if self.state.validate(event) {
+        // println!("consuming {:?}", event);
         self.state.consume(event);
-            event
-        } else {
-            println!("{}", self.state);
-            println!("event not valid : {:?}", event);
-            &GameEvent::PlayError
-        };
 
         // chain all successive bot actions
         if self.bots.is_empty() {
@@ -79,7 +74,7 @@ impl GameRunner {
         let bot_events: Vec<GameEvent> = self
             .bots
             .iter_mut()
-            .filter_map(|bot| bot.handle_event(valid_event))
+            .filter_map(|bot| bot.handle_event(event))
             .collect();
 
         // if bot_events.len() > 1 {

client_cli/src/main.rs

@@ -19,12 +19,6 @@ FLAGS:
 OPTIONS:
   --seed SEED         Sets the random generator seed
   --bot STRATEGY_BOT  Add a bot player with strategy STRATEGY, a second bot may be added to play against the first : --bot STRATEGY_BOT1,STRATEGY_BOT2
-                      Available strategies:
-                      - dummy: Default strategy selecting the first valid move
-                      - ai: AI strategy using the default model at models/trictrac_ppo.zip
-                      - ai:/path/to/model.zip: AI strategy using a custom model
-                      - dqn: DQN strategy using native Rust implementation with Burn
-                      - dqn:/path/to/model: DQN strategy using a custom model
 
 ARGS:
   <INPUT>

devenv.lock

@@ -3,10 +3,10 @@
     "devenv": {
       "locked": {
         "dir": "src/modules",
-        "lastModified": 1753667201,
+        "lastModified": 1729076865,
         "owner": "cachix",
         "repo": "devenv",
-        "rev": "4d584d7686a50387f975879788043e55af9f0ad4",
+        "rev": "9803535e5d124b502165e51d9caacf38b9dbe463",
         "type": "github"
       },
       "original": {
@@ -19,10 +19,10 @@
     "flake-compat": {
       "flake": false,
       "locked": {
-        "lastModified": 1747046372,
+        "lastModified": 1696426674,
         "owner": "edolstra",
         "repo": "flake-compat",
-        "rev": "9100a0f413b0c601e0533d1d94ffd501ce2e7885",
+        "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33",
         "type": "github"
       },
       "original": {
@@ -31,31 +31,10 @@
         "type": "github"
       }
     },
-    "git-hooks": {
-      "inputs": {
-        "flake-compat": "flake-compat",
-        "gitignore": "gitignore",
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1750779888,
-        "owner": "cachix",
-        "repo": "git-hooks.nix",
-        "rev": "16ec914f6fb6f599ce988427d9d94efddf25fe6d",
-        "type": "github"
-      },
-      "original": {
-        "owner": "cachix",
-        "repo": "git-hooks.nix",
-        "type": "github"
-      }
-    },
     "gitignore": {
       "inputs": {
         "nixpkgs": [
-          "git-hooks",
+          "pre-commit-hooks",
           "nixpkgs"
         ]
       },
@@ -74,10 +53,10 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1753432016,
+        "lastModified": 1728538411,
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "6027c30c8e9810896b92429f0092f624f7b1aace",
+        "rev": "b69de56fac8c2b6f8fd27f2eca01dcda8e0a4221",
         "type": "github"
       },
       "original": {
@@ -87,14 +66,48 @@
         "type": "github"
       }
     },
+    "nixpkgs-stable": {
+      "locked": {
+        "lastModified": 1728909085,
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "c0b1da36f7c34a7146501f684e9ebdf15d2bebf8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-24.05",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "pre-commit-hooks": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "gitignore": "gitignore",
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "nixpkgs-stable": "nixpkgs-stable"
+      },
+      "locked": {
+        "lastModified": 1728778939,
+        "owner": "cachix",
+        "repo": "pre-commit-hooks.nix",
+        "rev": "ff68f91754be6f3427e4986d7949e6273659be1d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "repo": "pre-commit-hooks.nix",
+        "type": "github"
+      }
+    },
     "root": {
       "inputs": {
         "devenv": "devenv",
-        "git-hooks": "git-hooks",
         "nixpkgs": "nixpkgs",
-        "pre-commit-hooks": [
-          "git-hooks"
-        ]
+        "pre-commit-hooks": "pre-commit-hooks"
       }
     }
   },

devenv.nix

@@ -1,22 +1,16 @@
 { pkgs, ... }:
 
 {
+  # https://devenv.sh/basics/
+  # env.GREET = "devenv";
 
   packages = [
 
-    # pour burn-rs
-    pkgs.SDL2_gfx
-    #  (compilation sdl2-sys)
-    pkgs.cmake
-    pkgs.libffi
-    pkgs.wayland-scanner
-
     # dev tools
     pkgs.samply # code profiler
-    pkgs.feedgnuplot # to visualize bots training results
 
     # for bevy
-    pkgs.alsa-lib
+    pkgs.alsaLib
     pkgs.udev
 
     # bevy fast compile
@@ -44,6 +38,11 @@
 
   ];
 
+  # enterShell = ''
+  #   hello
+  #   git --version
+  # '';
+
   # https://devenv.sh/languages/
   languages.rust.enable = true;
 

doc/backlog.md

@@ -1,32 +1,11 @@
 # Backlog
 
+position dans tutoriel :
+
 ## DONE
 
 ## TODO
 
-### stack overflow
-
-- <https://crates.io/crates/backtrace-on-stack-overflow>
-- <https://users.rust-lang.org/t/how-to-diagnose-a-stack-overflow-issues-cause/17320/11>
-- <https://www.reddit.com/r/rust/comments/1d8lxtd/debugging_stack_overflows/>
-
-Méthodes pour limiter la stack : réduire la taille de la pile avant de lancer ton binaire en ligne de commande :
-
-```sh
-ulimit -s 6144  # Limite la pile à 6Mo
-# just trainbot
-RUST_BACKTRACE=1 LD_LIBRARY_PATH=./target/debug  ./target/debug/train_dqn_burn
-ulimit -s unlimited # Pour revenir à la normale
-```
-
-- bot burn
-  - train = `just trainbot`
-    - durée d'entrainement selon params ?
-  - save
-  - load and run against default bot
-  - many configs, save models selon config
-  - retrain against himself ?
-
 ### Doc
 
 Cheatsheet : arbre des situations et priorité des règles

doc/diagrammes.md

@@ -1,143 +0,0 @@
-# Diagrammes d'architecture
-
-
-## Diagramme de Classes / Structures
-
-Ce diagramme montre les relations statiques entre les composants principaux.
-
-@startuml
-
-!theme vibrant
-
-package "client_cli" {
-  class GameRunner {
-    - state: GameState
-    - bots: Vec<Bot>
-    + new(Vec<Box<dyn BotStrategy>>)
-    + handle_event(&GameEvent)
-  }
-}
-
-package "bot" {
-  class Bot {
-    - strategy: Box<dyn BotStrategy>
-    + new(Box<dyn BotStrategy>)
-    + handle_event(&GameEvent): Option<GameEvent>
-  }
-
-  interface BotStrategy {
-    + choose_move(): (CheckerMove, CheckerMove)
-    + get_game(): &GameState
-    ' ... autres méthodes
-  }
-
-  class DefaultStrategy
-  class DqnStrategy
-  class ErroneousStrategy
-}
-
-package "store" {
-  class GameState {
-    + stage: Stage
-    + turn_stage: TurnStage
-    + board: Board
-    + active_player_id: PlayerId
-    ' ...
-    + validate(&GameEvent): bool
-    + consume(&GameEvent)
-  }
-
-  class GameEvent
-}
-
-GameRunner "1" *-- "1..2" Bot : contient
-Bot "1" *-- "1" BotStrategy : utilise
-BotStrategy <|.. DefaultStrategy : implémente
-BotStrategy <|.. DqnStrategy : implémente
-BotStrategy <|.. ErroneousStrategy : implémente
-
-GameRunner ..> GameState : dépend de
-GameRunner ..> GameEvent : gère
-Bot ..> GameState : dépend de
-Bot ..> GameEvent : traite et génère
-BotStrategy ..> GameState : analyse
-@enduml
-
-
-## Diagramme de Séquence : Boucle de jeu d'un Bot
-
-Ce diagramme montre les interactions dynamiques lors d'un tour de jeu où c'est à un bot de jouer.
-
-@startuml
-!theme vibrant
-autonumber
-
-participant "main (client_cli)" as Main
-participant "runner: GameRunner" as Runner
-participant "bot: Bot" as Bot
-participant "strategy: BotStrategy" as Strategy
-participant "state: GameState" as GameState
-
-Main -> Runner: new(strategies, seed)
-activate Runner
-Runner -> GameState: new()
-activate GameState
-GameState --> Runner: state
-deactivate GameState
-Runner -> Main: runner
-deactivate Runner
-
-... Boucle de jeu principale ...
-
-Main -> Runner: handle_event(event)
-activate Runner
-
-Runner -> GameState: validate(event)
-activate GameState
-GameState --> Runner: bool
-deactivate GameState
-
-Runner -> GameState: consume(event)
-activate GameState
-deactivate GameState
-
-Runner -> Bot: handle_event(event)
-activate Bot
-
-note right of Bot: Le bot vérifie si c'est son tour de jouer
-
-Bot -> Strategy: get_mut_game()
-activate Strategy
-Strategy --> Bot: &mut GameState
-deactivate Strategy
-
-' Supposons que c'est au bot de jouer un coup
-Bot -> Strategy: choose_move()
-activate Strategy
-Strategy -> GameState: Accède à l'état (board, dice, etc.)
-activate GameState
-deactivate GameState
-Strategy --> Bot: moves
-deactivate Strategy
-
-Bot --> Runner: Some(GameEvent::Move)
-deactivate Bot
-
-Runner -> Runner: handle_event(GameEvent::Move)
-note right of Runner: Appel récursif pour traiter le coup du bot
-
-Runner -> GameState: validate(GameEvent::Move)
-activate GameState
-GameState --> Runner: true
-deactivate GameState
-
-Runner -> GameState: consume(GameEvent::Move)
-activate GameState
-note right of GameState: L'état du jeu est mis à jour\n(pions déplacés, joueur actif changé)
-deactivate GameState
-
-Runner --> Main: Option<GameEvent> (ou None)
-deactivate Runner
-
-@enduml
-

doc/refs/claudeAIquestion.md

@@ -1,775 +0,0 @@
-# Description
-
-Je développe un jeu de TricTrac (<https://fr.wikipedia.org/wiki/Trictrac>) dans le langage rust.
-Pour le moment je me concentre sur l'application en ligne de commande simple, donc ne t'occupe pas des dossiers 'client_bevy', 'client_tui', et 'server' qui ne seront utilisés que pour de prochaines évolutions.
-
-Les règles du jeu et l'état d'une partie sont implémentées dans 'store', l'application ligne de commande est implémentée dans 'client_cli', elle permet déjà de jouer contre un bot, ou de faire jouer deux bots l'un contre l'autre.
-Les stratégies de bots sont implémentées dans le dossier 'bot'.
-
-Plus précisément, l'état du jeu est défini par le struct GameState dans store/src/game.rs, la méthode to_string_id() permet de coder cet état de manière compacte dans une chaîne de caractères, mais il n'y a pas l'historique des coups joués. Il y a aussi fmt::Display d'implémenté pour une representation textuelle plus lisible.
-
-'client_cli/src/game_runner.rs' contient la logique permettant de faire jouer deux bots l'un contre l'autre.
-'bot/src/default.rs' contient le code d'une stratégie de bot basique : il détermine la liste des mouvements valides (avec la méthode get_possible_moves_sequences de store::MoveRules) et joue simplement le premier de la liste.
-
-J'aimerais maintenant ajouter une stratégie de bot plus forte en entrainant un agent/bot avec OpenAI Gym.
-
-Pour bénéficier des bibliothèques disponibles en python, comme 'Stable-Baselines3', j'ai utilisé PyO3 pour appeler mon code rust depuis python. Le code rust exposé se trouve dans 'store/src/engine.rs', il ne contient pour le moment que du code d'exemple pour m'assurer que la passerelle entre python et rust fonctionne, mais tout est à implémenter : l'état du jeu, les mouvements disponibles, etc.
-
-La classe python 'store/python/trictracEnv.py' est elle aussi presque vide, elle ne contient pour le moment qu'un squelette avec des fonctions à implémenter.
-
-Peux-tu m'aider à modifier engine.rs et trictracenv.py pour permettre d'entrainer un agent (bot) ?
-
-J'aimerais utiliser ce que j'ai déjà implémenté en rust : l'état d'une partie et les règles, et la fonction renvoyant la liste des coups disponibles pour un joueur à partir d'un état du jeu (get_possible_moves_sequences), mais je ne sais pas trop comment m'y prendre.
-
-## Réponse de Claude
-
-Je vois que je n'ai pas l'autorisation d'utiliser l'outil Edit. Je vais vous montrer les modifications nécessaires pour les deux fichiers principaux.
-
-Voici le contenu à utiliser pour `store/src/engine.rs` :
-
-```rust
-//! # Expose trictrac game state and rules in a python module
-use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyTuple};
-
-use crate::board::CheckerMove;
-use crate::dice::Dice;
-use crate::game::{GameEvent, GameState, Stage, TurnStage};
-use crate::game_rules_moves::MoveRules;
-use crate::game_rules_points::{PointsRules, PossibleJans};
-use crate::player::{Color, Player, PlayerId};
-use std::collections::HashMap;
-
-#[pyclass]
-struct TricTrac {
-    game_state: GameState,
-    dice_roll_sequence: Vec<(u8, u8)>,
-    current_dice_index: usize,
-}
-
-#[pymethods]
-impl TricTrac {
-    #[new]
-    fn new() -> Self {
-        let mut game_state = GameState::new(false); // schools_enabled = false
-
-        // Initialiser 2 joueurs
-        game_state.init_player("player1");
-        game_state.init_player("bot");
-
-        // Commencer la partie avec le joueur 1
-        game_state.consume(&GameEvent::BeginGame { goes_first: 1 });
-
-        TricTrac {
-            game_state,
-            dice_roll_sequence: Vec::new(),
-            current_dice_index: 0,
-        }
-    }
-
-    /// Obtenir l'état du jeu sous forme de chaîne de caractères compacte
-    fn get_state_id(&self) -> String {
-        self.game_state.to_string_id()
-    }
-
-    /// Obtenir l'état du jeu sous forme de dictionnaire pour faciliter l'entrainement
-    fn get_state_dict(&self) -> PyResult<Py<PyDict>> {
-        let gil = Python::acquire_gil();
-        let py = gil.python();
-
-        let state_dict = PyDict::new(py);
-
-        // Informations essentielles sur l'état du jeu
-        state_dict.set_item("active_player", self.game_state.active_player_id)?;
-        state_dict.set_item("stage", format!("{:?}", self.game_state.stage))?;
-        state_dict.set_item("turn_stage", format!("{:?}", self.game_state.turn_stage))?;
-
-        // Dés
-        let (dice1, dice2) = self.game_state.dice.values;
-        state_dict.set_item("dice", (dice1, dice2))?;
-
-        // Points des joueurs
-        if let Some(white_player) = self.game_state.get_white_player() {
-            state_dict.set_item("white_points", white_player.points)?;
-            state_dict.set_item("white_holes", white_player.holes)?;
-        }
-
-        if let Some(black_player) = self.game_state.get_black_player() {
-            state_dict.set_item("black_points", black_player.points)?;
-            state_dict.set_item("black_holes", black_player.holes)?;
-        }
-
-        // Positions des pièces
-        let white_positions = self.get_checker_positions(Color::White);
-        let black_positions = self.get_checker_positions(Color::Black);
-
-        state_dict.set_item("white_positions", white_positions)?;
-        state_dict.set_item("black_positions", black_positions)?;
-
-        // État compact pour la comparaison d'états
-        state_dict.set_item("state_id", self.game_state.to_string_id())?;
-
-        Ok(state_dict.into())
-    }
-
-    /// Renvoie les positions des pièces pour un joueur spécifique
-    fn get_checker_positions(&self, color: Color) -> Vec<(usize, i8)> {
-        self.game_state.board.get_color_fields(color)
-    }
-
-    /// Obtenir la liste des mouvements légaux sous forme de paires (from, to)
-    fn get_available_moves(&self) -> Vec<((usize, usize), (usize, usize))> {
-        // L'agent joue toujours le joueur actif
-        let color = self.game_state.player_color_by_id(&self.game_state.active_player_id).unwrap_or(Color::White);
-
-        // Si ce n'est pas le moment de déplacer les pièces, retourner une liste vide
-        if self.game_state.turn_stage != TurnStage::Move && self.game_state.turn_stage != TurnStage::HoldOrGoChoice {
-            return vec![];
-        }
-
-        let rules = MoveRules::new(&color, &self.game_state.board, self.game_state.dice);
-        let possible_moves = rules.get_possible_moves_sequences(true, vec![]);
-
-        // Convertir les mouvements CheckerMove en tuples (from, to) pour Python
-        possible_moves.into_iter()
-            .map(|(move1, move2)| (
-                (move1.get_from(), move1.get_to()),
-                (move2.get_from(), move2.get_to())
-            )).collect()
-    }
-
-    /// Jouer un coup ((from1, to1), (from2, to2))
-    fn play_move(&mut self, moves: ((usize, usize), (usize, usize))) -> bool {
-        let ((from1, to1), (from2, to2)) = moves;
-
-        // Vérifier que c'est au tour du joueur de jouer
-        if self.game_state.turn_stage != TurnStage::Move && self.game_state.turn_stage != TurnStage::HoldOrGoChoice {
-            return false;
-        }
-
-        let move1 = CheckerMove::new(from1, to1).unwrap_or_default();
-        let move2 = CheckerMove::new(from2, to2).unwrap_or_default();
-
-        let event = GameEvent::Move {
-            player_id: self.game_state.active_player_id,
-            moves: (move1, move2),
-        };
-
-        // Vérifier si le mouvement est valide
-        if !self.game_state.validate(&event) {
-            return false;
-        }
-
-        // Exécuter le mouvement
-        self.game_state.consume(&event);
-
-        // Si l'autre joueur doit lancer les dés maintenant, simuler ce lancement
-        if self.game_state.turn_stage == TurnStage::RollDice {
-            self.roll_dice();
-        }
-
-        true
-    }
-
-    /// Lancer les dés (soit aléatoirement, soit en utilisant une séquence prédéfinie)
-    fn roll_dice(&mut self) -> (u8, u8) {
-        // Vérifier que c'est au bon moment pour lancer les dés
-        if self.game_state.turn_stage != TurnStage::RollDice && self.game_state.turn_stage != TurnStage::RollWaiting {
-            return self.game_state.dice.values;
-        }
-
-        // Simuler un lancer de dés
-        let dice_values = if !self.dice_roll_sequence.is_empty() && self.current_dice_index < self.dice_roll_sequence.len() {
-            // Utiliser la séquence prédéfinie
-            let dice = self.dice_roll_sequence[self.current_dice_index];
-            self.current_dice_index += 1;
-            dice
-        } else {
-            // Générer aléatoirement
-            (
-                (1 + (rand::random::<u8>() % 6)),
-                (1 + (rand::random::<u8>() % 6))
-            )
-        };
-
-        // Envoyer les événements appropriés
-        let roll_event = GameEvent::Roll {
-            player_id: self.game_state.active_player_id,
-        };
-
-        if self.game_state.validate(&roll_event) {
-            self.game_state.consume(&roll_event);
-        }
-
-        let roll_result_event = GameEvent::RollResult {
-            player_id: self.game_state.active_player_id,
-            dice: Dice { values: dice_values },
-        };
-
-        if self.game_state.validate(&roll_result_event) {
-            self.game_state.consume(&roll_result_event);
-        }
-
-        dice_values
-    }
-
-    /// Marquer des points
-    fn mark_points(&mut self, points: u8) -> bool {
-        // Vérifier que c'est au bon moment pour marquer des points
-        if self.game_state.turn_stage != TurnStage::MarkPoints && self.game_state.turn_stage != TurnStage::MarkAdvPoints {
-            return false;
-        }
-
-        let event = GameEvent::Mark {
-            player_id: self.game_state.active_player_id,
-            points,
-        };
-
-        // Vérifier si l'événement est valide
-        if !self.game_state.validate(&event) {
-            return false;
-        }
-
-        // Exécuter l'événement
-        self.game_state.consume(&event);
-
-        // Si l'autre joueur doit lancer les dés maintenant, simuler ce lancement
-        if self.game_state.turn_stage == TurnStage::RollDice {
-            self.roll_dice();
-        }
-
-        true
-    }
-
-    /// Choisir de "continuer" (Go) après avoir gagné un trou
-    fn choose_go(&mut self) -> bool {
-        // Vérifier que c'est au bon moment pour choisir de continuer
-        if self.game_state.turn_stage != TurnStage::HoldOrGoChoice {
-            return false;
-        }
-
-        let event = GameEvent::Go {
-            player_id: self.game_state.active_player_id,
-        };
-
-        // Vérifier si l'événement est valide
-        if !self.game_state.validate(&event) {
-            return false;
-        }
-
-        // Exécuter l'événement
-        self.game_state.consume(&event);
-
-        // Simuler le lancer de dés pour le prochain tour
-        self.roll_dice();
-
-        true
-    }
-
-    /// Calcule les points maximaux que le joueur actif peut obtenir avec les dés actuels
-    fn calculate_points(&self) -> u8 {
-        let active_player = self.game_state.players.get(&self.game_state.active_player_id);
-
-        if let Some(player) = active_player {
-            let dice_roll_count = player.dice_roll_count;
-            let color = player.color;
-
-            let points_rules = PointsRules::new(&color, &self.game_state.board, self.game_state.dice);
-            let (points, _) = points_rules.get_points(dice_roll_count);
-
-            points
-        } else {
-            0
-        }
-    }
-
-    /// Réinitialise la partie
-    fn reset(&mut self) {
-        self.game_state = GameState::new(false);
-
-        // Initialiser 2 joueurs
-        self.game_state.init_player("player1");
-        self.game_state.init_player("bot");
-
-        // Commencer la partie avec le joueur 1
-        self.game_state.consume(&GameEvent::BeginGame { goes_first: 1 });
-
-        // Réinitialiser l'index de la séquence de dés
-        self.current_dice_index = 0;
-    }
-
-    /// Vérifie si la partie est terminée
-    fn is_done(&self) -> bool {
-        self.game_state.stage == Stage::Ended || self.game_state.determine_winner().is_some()
-    }
-
-    /// Obtenir le gagnant de la partie
-    fn get_winner(&self) -> Option<PlayerId> {
-        self.game_state.determine_winner()
-    }
-
-    /// Obtenir le score du joueur actif (nombre de trous)
-    fn get_score(&self, player_id: PlayerId) -> i32 {
-        if let Some(player) = self.game_state.players.get(&player_id) {
-            player.holes as i32
-        } else {
-            -1
-        }
-    }
-
-    /// Obtenir l'ID du joueur actif
-    fn get_active_player_id(&self) -> PlayerId {
-        self.game_state.active_player_id
-    }
-
-    /// Définir une séquence de dés à utiliser (pour la reproductibilité)
-    fn set_dice_sequence(&mut self, sequence: Vec<(u8, u8)>) {
-        self.dice_roll_sequence = sequence;
-        self.current_dice_index = 0;
-    }
-
-    /// Afficher l'état du jeu (pour le débogage)
-    fn __str__(&self) -> String {
-        format!("{}", self.game_state)
-    }
-}
-
-/// A Python module implemented in Rust. The name of this function must match
-/// the `lib.name` setting in the `Cargo.toml`, else Python will not be able to
-/// import the module.
-#[pymodule]
-fn trictrac(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_class::<TricTrac>()?;
-
-    Ok(())
-}
-```
-
-Et pour `store/python/trictracEnv.py` :
-
-```python
-import gym
-import numpy as np
-from gym import spaces
-import trictrac  # module Rust exposé via PyO3
-from typing import Dict, List, Tuple, Optional, Any, Union
-
-class TricTracEnv(gym.Env):
-    """Environnement OpenAI Gym pour le jeu de Trictrac"""
-
-    metadata = {"render.modes": ["human"]}
-
-    def __init__(self, opponent_strategy="random"):
-        super(TricTracEnv, self).__init__()
-
-        # Instancier le jeu
-        self.game = trictrac.TricTrac()
-
-        # Stratégie de l'adversaire
-        self.opponent_strategy = opponent_strategy
-
-        # Constantes
-        self.MAX_FIELD = 24  # Nombre de cases sur le plateau
-        self.MAX_CHECKERS = 15  # Nombre maximum de pièces par joueur
-
-        # Définition de l'espace d'observation
-        # Format:
-        # - Position des pièces blanches (24)
-        # - Position des pièces noires (24)
-        # - Joueur actif (1: blanc, 2: noir) (1)
-        # - Valeurs des dés (2)
-        # - Points de chaque joueur (2)
-        # - Trous de chaque joueur (2)
-        # - Phase du jeu (1)
-        self.observation_space = spaces.Dict({
-            'board': spaces.Box(low=-self.MAX_CHECKERS, high=self.MAX_CHECKERS, shape=(self.MAX_FIELD,), dtype=np.int8),
-            'active_player': spaces.Discrete(3),  # 0: pas de joueur, 1: blanc, 2: noir
-            'dice': spaces.MultiDiscrete([7, 7]),  # Valeurs des dés (1-6)
-            'white_points': spaces.Discrete(13),  # Points du joueur blanc (0-12)
-            'white_holes': spaces.Discrete(13),   # Trous du joueur blanc (0-12)
-            'black_points': spaces.Discrete(13),  # Points du joueur noir (0-12)
-            'black_holes': spaces.Discrete(13),   # Trous du joueur noir (0-12)
-            'turn_stage': spaces.Discrete(6),     # Étape du tour
-        })
-
-        # Définition de l'espace d'action
-        # Format:
-        # - Action type: 0=move, 1=mark, 2=go
-        # - Move: (from1, to1, from2, to2) ou zeros
-        self.action_space = spaces.Dict({
-            'action_type': spaces.Discrete(3),
-            'move': spaces.MultiDiscrete([self.MAX_FIELD + 1, self.MAX_FIELD + 1,
-                                         self.MAX_FIELD + 1, self.MAX_FIELD + 1])
-        })
-
-        # État courant
-        self.state = self._get_observation()
-
-        # Historique des états pour éviter les situations sans issue
-        self.state_history = []
-
-        # Pour le débogage et l'entraînement
-        self.steps_taken = 0
-        self.max_steps = 1000  # Limite pour éviter les parties infinies
-
-    def reset(self):
-        """Réinitialise l'environnement et renvoie l'état initial"""
-        self.game.reset()
-        self.state = self._get_observation()
-        self.state_history = []
-        self.steps_taken = 0
-        return self.state
-
-    def step(self, action):
-        """
-        Exécute une action et retourne (state, reward, done, info)
-
-        Action format:
-        {
-            'action_type': 0/1/2,  # 0=move, 1=mark, 2=go
-            'move': [from1, to1, from2, to2]  # Utilisé seulement si action_type=0
-        }
-        """
-        action_type = action['action_type']
-        reward = 0
-        done = False
-        info = {}
-
-        # Vérifie que l'action est valide pour le joueur humain (id=1)
-        player_id = self.game.get_active_player_id()
-        is_agent_turn = player_id == 1  # L'agent joue toujours le joueur 1
-
-        if is_agent_turn:
-            # Exécute l'action selon son type
-            if action_type == 0:  # Move
-                from1, to1, from2, to2 = action['move']
-                move_made = self.game.play_move(((from1, to1), (from2, to2)))
-                if not move_made:
-                    # Pénaliser les mouvements invalides
-                    reward -= 2.0
-                    info['invalid_move'] = True
-                else:
-                    # Petit bonus pour un mouvement valide
-                    reward += 0.1
-            elif action_type == 1:  # Mark
-                points = self.game.calculate_points()
-                marked = self.game.mark_points(points)
-                if not marked:
-                    # Pénaliser les actions invalides
-                    reward -= 2.0
-                    info['invalid_mark'] = True
-                else:
-                    # Bonus pour avoir marqué des points
-                    reward += 0.1 * points
-            elif action_type == 2:  # Go
-                go_made = self.game.choose_go()
-                if not go_made:
-                    # Pénaliser les actions invalides
-                    reward -= 2.0
-                    info['invalid_go'] = True
-                else:
-                    # Petit bonus pour l'action valide
-                    reward += 0.1
-        else:
-            # Tour de l'adversaire
-            self._play_opponent_turn()
-
-        # Vérifier si la partie est terminée
-        if self.game.is_done():
-            done = True
-            winner = self.game.get_winner()
-            if winner == 1:
-                # Bonus si l'agent gagne
-                reward += 10.0
-                info['winner'] = 'agent'
-            else:
-                # Pénalité si l'adversaire gagne
-                reward -= 5.0
-                info['winner'] = 'opponent'
-
-        # Récompense basée sur la progression des trous
-        agent_holes = self.game.get_score(1)
-        opponent_holes = self.game.get_score(2)
-        reward += 0.5 * (agent_holes - opponent_holes)
-
-        # Mettre à jour l'état
-        new_state = self._get_observation()
-
-        # Vérifier les états répétés
-        if self._is_state_repeating(new_state):
-            reward -= 0.2  # Pénalité légère pour éviter les boucles
-            info['repeating_state'] = True
-
-        # Ajouter l'état à l'historique
-        self.state_history.append(self._get_state_id())
-
-        # Limiter la durée des parties
-        self.steps_taken += 1
-        if self.steps_taken >= self.max_steps:
-            done = True
-            info['timeout'] = True
-
-            # Comparer les scores en cas de timeout
-            if agent_holes > opponent_holes:
-                reward += 5.0
-                info['winner'] = 'agent'
-            elif opponent_holes > agent_holes:
-                reward -= 2.0
-                info['winner'] = 'opponent'
-
-        self.state = new_state
-        return self.state, reward, done, info
-
-    def _play_opponent_turn(self):
-        """Simule le tour de l'adversaire avec la stratégie choisie"""
-        player_id = self.game.get_active_player_id()
-
-        # Boucle tant qu'il est au tour de l'adversaire
-        while player_id == 2 and not self.game.is_done():
-            # Action selon l'étape du tour
-            state_dict = self._get_state_dict()
-            turn_stage = state_dict.get('turn_stage')
-
-            if turn_stage == 'RollDice' or turn_stage == 'RollWaiting':
-                self.game.roll_dice()
-            elif turn_stage == 'MarkPoints' or turn_stage == 'MarkAdvPoints':
-                points = self.game.calculate_points()
-                self.game.mark_points(points)
-            elif turn_stage == 'HoldOrGoChoice':
-                # Stratégie simple: toujours continuer (Go)
-                self.game.choose_go()
-            elif turn_stage == 'Move':
-                available_moves = self.game.get_available_moves()
-                if available_moves:
-                    if self.opponent_strategy == "random":
-                        # Choisir un mouvement au hasard
-                        move = available_moves[np.random.randint(0, len(available_moves))]
-                    else:
-                        # Par défaut, prendre le premier mouvement valide
-                        move = available_moves[0]
-                    self.game.play_move(move)
-
-            # Mise à jour de l'ID du joueur actif
-            player_id = self.game.get_active_player_id()
-
-    def _get_observation(self):
-        """Convertit l'état du jeu en un format utilisable par l'apprentissage par renforcement"""
-        state_dict = self._get_state_dict()
-
-        # Créer un tableau représentant le plateau
-        board = np.zeros(self.MAX_FIELD, dtype=np.int8)
-
-        # Remplir les positions des pièces blanches (valeurs positives)
-        white_positions = state_dict.get('white_positions', [])
-        for pos, count in white_positions:
-            if 1 <= pos <= self.MAX_FIELD:
-                board[pos-1] = count
-
-        # Remplir les positions des pièces noires (valeurs négatives)
-        black_positions = state_dict.get('black_positions', [])
-        for pos, count in black_positions:
-            if 1 <= pos <= self.MAX_FIELD:
-                board[pos-1] = -count
-
-        # Créer l'observation complète
-        observation = {
-            'board': board,
-            'active_player': state_dict.get('active_player', 0),
-            'dice': np.array([
-                state_dict.get('dice', (1, 1))[0],
-                state_dict.get('dice', (1, 1))[1]
-            ]),
-            'white_points': state_dict.get('white_points', 0),
-            'white_holes': state_dict.get('white_holes', 0),
-            'black_points': state_dict.get('black_points', 0),
-            'black_holes': state_dict.get('black_holes', 0),
-            'turn_stage': self._turn_stage_to_int(state_dict.get('turn_stage', 'RollDice')),
-        }
-
-        return observation
-
-    def _get_state_dict(self) -> Dict:
-        """Récupère l'état du jeu sous forme de dictionnaire depuis le module Rust"""
-        return self.game.get_state_dict()
-
-    def _get_state_id(self) -> str:
-        """Récupère l'identifiant unique de l'état actuel"""
-        return self.game.get_state_id()
-
-    def _is_state_repeating(self, new_state) -> bool:
-        """Vérifie si l'état se répète trop souvent"""
-        state_id = self.game.get_state_id()
-        # Compter les occurrences de l'état dans l'historique récent
-        count = sum(1 for s in self.state_history[-10:] if s == state_id)
-        return count >= 3  # Considéré comme répétitif si l'état apparaît 3 fois ou plus
-
-    def _turn_stage_to_int(self, turn_stage: str) -> int:
-        """Convertit l'étape du tour en entier pour l'observation"""
-        stages = {
-            'RollDice': 0,
-            'RollWaiting': 1,
-            'MarkPoints': 2,
-            'HoldOrGoChoice': 3,
-            'Move': 4,
-            'MarkAdvPoints': 5
-        }
-        return stages.get(turn_stage, 0)
-
-    def render(self, mode="human"):
-        """Affiche l'état actuel du jeu"""
-        if mode == "human":
-            print(str(self.game))
-            print(f"État actuel: {self._get_state_id()}")
-
-            # Afficher les actions possibles
-            if self.game.get_active_player_id() == 1:
-                turn_stage = self._get_state_dict().get('turn_stage')
-                print(f"Étape: {turn_stage}")
-
-                if turn_stage == 'Move' or turn_stage == 'HoldOrGoChoice':
-                    print("Mouvements possibles:")
-                    moves = self.game.get_available_moves()
-                    for i, move in enumerate(moves):
-                        print(f"  {i}: {move}")
-
-                if turn_stage == 'HoldOrGoChoice':
-                    print("Option: Go (continuer)")
-
-    def get_action_mask(self):
-        """Retourne un masque des actions valides dans l'état actuel"""
-        state_dict = self._get_state_dict()
-        turn_stage = state_dict.get('turn_stage')
-
-        # Masque par défaut (toutes les actions sont invalides)
-        mask = {
-            'action_type': np.zeros(3, dtype=bool),
-            'move': np.zeros((self.MAX_FIELD + 1, self.MAX_FIELD + 1,
-                             self.MAX_FIELD + 1, self.MAX_FIELD + 1), dtype=bool)
-        }
-
-        if self.game.get_active_player_id() != 1:
-            return mask  # Pas au tour de l'agent
-
-        # Activer les types d'actions valides selon l'étape du tour
-        if turn_stage == 'Move' or turn_stage == 'HoldOrGoChoice':
-            mask['action_type'][0] = True  # Activer l'action de mouvement
-
-            # Activer les mouvements valides
-            valid_moves = self.game.get_available_moves()
-            for ((from1, to1), (from2, to2)) in valid_moves:
-                mask['move'][from1, to1, from2, to2] = True
-
-        if turn_stage == 'MarkPoints' or turn_stage == 'MarkAdvPoints':
-            mask['action_type'][1] = True  # Activer l'action de marquer des points
-
-        if turn_stage == 'HoldOrGoChoice':
-            mask['action_type'][2] = True  # Activer l'action de continuer (Go)
-
-        return mask
-
-    def sample_valid_action(self):
-        """Échantillonne une action valide selon le masque d'actions"""
-        mask = self.get_action_mask()
-
-        # Trouver les types d'actions valides
-        valid_action_types = np.where(mask['action_type'])[0]
-
-        if len(valid_action_types) == 0:
-            # Aucune action valide (pas le tour de l'agent)
-            return {
-                'action_type': 0,
-                'move': np.zeros(4, dtype=np.int32)
-            }
-
-        # Choisir un type d'action
-        action_type = np.random.choice(valid_action_types)
-
-        action = {
-            'action_type': action_type,
-            'move': np.zeros(4, dtype=np.int32)
-        }
-
-        # Si c'est un mouvement, sélectionner un mouvement valide
-        if action_type == 0:
-            valid_moves = np.where(mask['move'])
-            if len(valid_moves[0]) > 0:
-                # Sélectionner un mouvement valide aléatoirement
-                idx = np.random.randint(0, len(valid_moves[0]))
-                from1 = valid_moves[0][idx]
-                to1 = valid_moves[1][idx]
-                from2 = valid_moves[2][idx]
-                to2 = valid_moves[3][idx]
-                action['move'] = np.array([from1, to1, from2, to2], dtype=np.int32)
-
-        return action
-
-    def close(self):
-        """Nettoie les ressources à la fermeture de l'environnement"""
-        pass
-
-# Exemple d'utilisation avec Stable-Baselines3
-def example_usage():
-    from stable_baselines3 import PPO
-    from stable_baselines3.common.vec_env import DummyVecEnv
-
-    # Fonction d'enveloppement pour créer l'environnement
-    def make_env():
-        return TricTracEnv()
-
-    # Créer un environnement vectorisé (peut être parallélisé)
-    env = DummyVecEnv([make_env])
-
-    # Créer le modèle
-    model = PPO("MultiInputPolicy", env, verbose=1)
-
-    # Entraîner le modèle
-    model.learn(total_timesteps=10000)
-
-    # Sauvegarder le modèle
-    model.save("trictrac_ppo")
-
-    print("Entraînement terminé et modèle sauvegardé")
-
-if __name__ == "__main__":
-    # Tester l'environnement
-    env = TricTracEnv()
-    obs = env.reset()
-
-    print("Environnement initialisé")
-    env.render()
-
-    # Jouer quelques coups aléatoires
-    for _ in range(10):
-        action = env.sample_valid_action()
-        obs, reward, done, info = env.step(action)
-
-        print(f"\nAction: {action}")
-        print(f"Reward: {reward}")
-        print(f"Info: {info}")
-        env.render()
-
-        if done:
-            print("Game over!")
-            break
-
-    env.close()
-```
-
-Ces implémentations vous permettront de créer un environnement Gym pour votre jeu Trictrac qui:
-
-1. Expose l'état du jeu dans un format approprié pour l'apprentissage par renforcement
-2. Gère le déroulement des parties et le tour de l'adversaire
-3. Définit un système de récompenses pour l'entraînement de l'agent
-4. Fournit des masques d'actions pour garantir que seules les actions valides sont sélectionnées
-5. Inclut des exemples pour l'intégration avec Stable-Baselines3
-
-Ce code nécessitera probablement quelques ajustements en fonction de la façon dont votre code Rust est organisé, mais il devrait vous donner une base solide pour commencer.
-
-Pour utiliser cette implémentation :
-
-1. Mettez à jour `engine.rs` pour exposer l'API nécessaire à Python
-2. Compilez la bibliothèque Rust avec maturin : `maturin build -m store/Cargo.toml --release`
-3. Implémentez `trictracEnv.py` avec l'environnement Gym
-4. Créez un script d'entraînement qui utilise Stable-Baselines3 ou une autre bibliothèque d'apprentissage par renforcement
-
-Voulez-vous que j'explique plus en détail certaines parties de l'implémentation ou que je vous aide à résoudre des problèmes spécifiques ?

doc/refs/claudeAIquestionOnlyRust.md

@@ -1,268 +0,0 @@
-# Description
-
-Je développe un jeu de TricTrac (<https://fr.wikipedia.org/wiki/Trictrac>) dans le langage rust.
-Pour le moment ne t'occupe pas des dossiers 'client_bevy', 'client_tui', et 'server' qui ne seront utilisés que pour de prochaines évolutions.
-
-Les règles du jeu et l'état d'une partie sont implémentées dans 'store', l'application ligne de commande est implémentée dans 'client_cli', elle permet de jouer contre un bot, ou de faire jouer deux bots l'un contre l'autre.
-Les stratégies de bots sont implémentées dans le dossier 'bot'.
-
-L'état du jeu est défini par le struct GameState dans store/src/game.rs, la méthode to_string_id() permet de coder cet état de manière compacte dans une chaîne de caractères, mais il n'y a pas l'historique des coups joués. Il y a aussi fmt::Display d'implémenté pour une representation textuelle plus lisible.
-
-'client_cli/src/game_runner.rs' contient la logique permettant de faire jouer deux bots l'un contre l'autre.
-'bot/src/default.rs' contient le code d'une stratégie de bot basique : il détermine la liste des mouvements valides (avec la méthode get_possible_moves_sequences de store::MoveRules) et joue simplement le premier de la liste.
-
-Dans une précédente session tu m'avais aidé à ajouter une stratégie de bot plus forte en entrainant un agent/bot avec OpenAI Gym en utilisant PyO3 et Stable-Baselines3. Tu m'avais fourni le code pour `store/src/engine.rs` et `store/python/trictracEnv.py`.
-
-Ça fonctionne, mais je voudrais maintenant passer à une solution entièrement rust.
-Je pensais utiliser burn et l'algorithme DQN implémenté dans s3-burn ( <https://github.com/will-maclean/sb3-burn> ). Peux-tu m'aider à faire ça ?
-
------ fin d'implémentation :
-
-Parfait ! Le jeu fonctionne maintenant avec la stratégie DQN ! Le bot DQN a même gagné la partie contre le bot
-dummy.
-
-Résumé
-
-J'ai réussi à migrer l'implémentation d'une solution Python/PyO3/Stable-Baselines3 vers une solution entièrement
-Rust avec DQN. Voici ce qui a été accompli :
-
-✅ Ce qui fonctionne maintenant :
-
-1. Suppression complète de PyO3 du module store pour éviter les conflits
-2. Implémentation DQN native en Rust avec :
-
-   - Réseau de neurones simplifié (3 couches, ReLU)
-   - Initialisation Xavier/Glorot des poids
-   - Buffer de replay pour l'expérience
-   - Stratégie epsilon-greedy
-   - Sauvegarde/chargement de modèles en JSON
-
-3. Intégration complète dans le CLI avec la commande :
-
-   - --bot dqn : DQN avec configuration par défaut
-   - --bot dqn:/path/to/model : DQN avec modèle personnalisé
-
-4. Compilation réussie sans dépendances Burn problématiques
-
-🔄 Points à améliorer plus tard :
-
-1. Entraînement complet : Actuellement la méthode train() simule l'entraînement. Il faudrait implémenter la
-   backpropagation complète.
-2. Espace d'actions plus sophistiqué : L'espace d'actions est simplifié (3 actions). On pourrait l'étendre pour
-   couvrir tous les mouvements possibles.
-3. Système de récompenses : Le système de récompenses est basique et pourrait être enrichi.
-4. Migration vers Burn : Quand les problèmes de compatibilité seront résolus, on pourra migrer vers Burn pour de
-   meilleures performances.
-
-La base DQN est maintenant fonctionnelle et entièrement en Rust ! 🎉
-
----
-
-Ton implémentation démarre avec un bot non entraîné et il s'entraîne lorsqu'il , le modèle n'est pas entraîné de manière séparée ? On démarre avec un modèle non entraîné et il s'entraîne en même temps que le bot joue ?
-
-Je voudrais que le fichier dqn.rs actuel ne contienne que le code nécessaire pour de charger un modèle entraîné et jouer contre les adversaires (c'est à dire l'implémentation de BotStrategy). Et donc que tu extraies le code qui permet d'entraîner le modèle dans un autre fichier, et que tu ajoutes une commande pour lancer l'entraînement.
-
----
-
-● Parfait ! Testons maintenant un entraînement court :
-
-● Bash(cd /home/henri/travaux/programmes/trictrac && cargo run --bin=train_dqn -- --episodes 10 --save-every 5)…
-⎿  Error: Command timed out after 2m 0.0s warning: unused import: `DqnConfig`
---> bot/src/strategy/dqn.rs:5:25
-|
-5 | use super::dqn_common::{DqnConfig, SimpleNeuralNetwork, game_state_to_vector};
-| ^^^^^^^^^
-|
-= note: `#[warn(unused_imports)]` on by default
-
-     warning: unused import: `store::MoveRules`
-      --> bot/src/strategy/erroneous_moves.rs:2:5
-     … +175 lines (ctrl+r to see all)
-
-● Il y a un problème dans la logique d'entraînement - il semble y avoir une boucle infinie avec des erreurs "rules not followed". Il faut corriger la logique du TrictracEnv. Le problème est probablement que l'environnement ne gère pas
-correctement les étapes du jeu.
-
-● Update Todos
-⎿  ☒ Analyser le code existant avec PyO3/Stable-Baselines3
-☒ Examiner l'environnement Gym Python actuel
-☒ Créer un environnement DQN natif en Rust
-☒ Implémenter la stratégie bot DQN en Rust
-☒ Ajouter les dépendances Burn et sb3-burn
-☒ Restructurer le code DQN
-☒ Créer un module d'entraînement séparé
-☒ Ajouter une commande d'entraînement
-
-● Parfait ! J'ai réussi à restructurer complètement le code DQN selon tes demandes :
-
-✅ Restructuration terminée avec succès
-
-📁 Structure du code :
-
-1. dqn.rs - Contient uniquement la stratégie DqnStrategy pour charger et utiliser un modèle pré-entraîné
-2. dqn_common.rs - Code partagé (réseau de neurones, configuration, utilitaires)
-3. dqn_trainer.rs - Logique d'entraînement complète avec environnement et agent
-4. train_dqn - Binaire dédié pour lancer l'entraînement
-
-🚀 Commandes disponibles :
-
-Pour jouer avec un modèle DQN :
-cargo run --bin=client_cli -- --bot dqn,dummy # Sans modèle (fallback)
-cargo run --bin=client_cli -- --bot dqn:/path/to/model.json,dummy # Avec modèle
-
-Pour entraîner un modèle DQN :
-cargo run --bin=train_dqn # Entraînement par défaut (1000 épisodes)
-cargo run --bin=train_dqn -- --help # Voir les options
-cargo run --bin=train_dqn -- --episodes 5000 --save-every 500
-
-⚠️ Note sur l'environnement d'entraînement :
-
-L'entraînement a révélé un problème dans la logique de l'environnement (boucle infinie avec "rules not followed"). C'est normal pour une première implémentation - l'environnement d'entraînement nécessite des ajustements pour bien
-gérer les règles du jeu Trictrac.
-
-Le code est maintenant parfaitement séparé entre :
-
-- Utilisation (stratégie simple qui charge un modèle)
-- Entraînement (environnement complet avec logique d'apprentissage)
-
----
-
-● ✅ Espace d'actions étendu implémenté avec succès !
-
-J'ai complètement étendu l'espace d'actions du DQN pour couvrir tous les choix possibles dans le jeu Trictrac :
-
-🎯 Nouvel espace d'actions :
-
-TrictracAction enum comprend :
-
-- Roll - Lancer les dés (index 0)
-- Mark { points } - Marquer des points (indices 1-13 pour 0-12 points)
-- Go - Continuer après avoir gagné un trou (index 14)
-- Move { move1, move2 } - Mouvement de pions (indices 15+)
-  - Encode (from, to) pour les deux pions
-  - Espace total : 331,791 actions possibles
-
-🧠 Améliorations intelligentes :
-
-1. Masquage d'actions valides - Le DQN ne considère que les actions légales dans l'état actuel
-2. Encodage compact - Mouvements encodés en un seul entier pour efficacité
-3. Décodage automatique - Conversion transparente entre indices et actions
-4. Stratégie adaptative - La stratégie DQN utilise maintenant le bon type d'action selon le contexte
-
-🔧 Fonctionnalités ajoutées :
-
-- get_valid_actions() - Obtient les actions valides pour l'état actuel
-- TrictracAction::to_action_index() / from_action_index() - Conversion bidirectionnelle
-- sample_valid_action() - Sélection aléatoire d'une action valide
-- Réseau de neurones élargi (512 neurones cachés) pour gérer l'espace étendu
-
-📊 Utilisation dans le jeu :
-
-Le bot DQN peut maintenant :
-
-- Choisir le nombre exact de points à marquer (pas seulement le maximum)
-- Sélectionner des mouvements spécifiques parmi toutes les combinaisons possibles
-- Décider intelligemment entre "Go" et les mouvements alternatifs
-
-L'espace d'actions est maintenant parfaitement aligné avec la complexité réelle du jeu Trictrac ! 🎲
-
----
-
-Pour réduire la taille de l'espace des actions, est-ce qu'on peut tenir compte de l'état du jeu pour le choix des actions ?
-Ça voudrait dire que pour le choix du mouvement par exemple, comme on connait la valeur des dés on a juste à choisir quel dé on joue en premier (2 choix), puis la position de départ du premier pion (25 choix), et la position de départ du deuxième pion (25 choix), la position de départ étant déduite de la valeur des dés.
-
-....
-
-● Parfait ! J'ai implémenté l'espace d'actions compactes basé sur le contexte du jeu. Voici les amélirations majeures apportées :
-
-✅ Réduction drastique de l'espace d'actions :
-
-- Avant : 331,791 actions possibles à chaque étape
-- Maintenant : 1-200 actions selon le contexte du jeu
-
-✅ Actions contextuelles :
-
-- Roll : Seulement quand c'est possible (1 action)
-- Mark : Seulement les points valides 0-12 (≤13 actions)
-- Go : Toujours 1 action
-- MoveChoice : 2 ordres de dés × ~10 positions de départ × ~10 positions = ~200 actions au lieu de 331,791
-
-✅ Architecture modulaire :
-
-- CompactAction : actions simplifiées basées sur le contexte
-- to_trictrac_action() : conversion automatique vers les actions complètes
-- get_valid_compact_actions() : génération contextuelle des actions valides
-- context_action_space_size() : taille dynamique de l'espace d'actions
-
-L'approche utilise exactement votre suggestion : pour les mouvements, au lieu d'encoder toutes les combinaisons possibles, on choisit :
-
-1. L'ordre des dés (2 choix max si dés différents)
-2. Les positions de départ (seulement celles avec des pions)
-3. Les destinations sont automatiquement calculées selon les règles
-
-Cela réduit l'espace d'actions de 99.94% tout en gardant toute la richesse du jeu !
-
----
-
-● Parfait ! J'ai créé le fichier train_burn_rl.rs qui utilise votre environnement Burn-RL corrigé.
-
-Pour lancer l'entraînement avec Burn-RL :
-
-cargo run --bin=train_burn_rl
-
-Ou avec des options personnalisées :
-
-cargo run --bin=train_burn_rl -- --episodes 2000 --save-every 200 --max-steps 1000
-
-Caractéristiques de cet entraîneur :
-
-✅ Utilise l'environnement Burn-RL que vous avez corrigé
-✅ Actions contextuelles via get_valid_actions()
-✅ Politique epsilon-greedy simple pour commencer
-✅ Statistiques détaillées avec moyennes mobiles
-✅ Configuration flexible via arguments CLI
-✅ Logging progressif pour suivre l'entraînement
-
-Options disponibles :
-
-- --episodes : nombre d'épisodes (défaut: 1000)
-- --save-every : fréquence d'affichage des stats (défaut: 100)
-- --max-steps : nombre max de steps par épisode (défaut: 500)
-- --help : aide complète
-
-Cet entraîneur sert de base pour tester l'environnement Burn-RL. Une fois que tout fonctionne bien, on pourra y intégrer un vrai agent DQN avec réseaux de neurones !
-
----
-
-Session où je n'ai cessé de recevoir ce message :
-
-⎿ API Error (429 {"type":"error","error":{"type":"rate_limit_error","message":"This request would exceed the rate limit for your organization (813e6b21-ec6f-44c3-a7f0-408244105e5c) of 20,000 input tokens per minute. For details, refer to: <https://docs.anthropic.com/en/api/rate-limits>. You can see the response headers for current usage. Please reduce the prompt length or the maximum tokens requested, or try again later. You may also contact sales at <https://www.anthropic.com/contact-sales> to discuss your options for a rate limit increase."}}) · Retrying in 391 seconds… (attempt 1/10)
-
-✶ Coaching… (403s · ↑ 382 tokens · esc to interrupt)
-
-Pour à la fin de la session avoir ce résumé :
-
-Total cost: $0.95
-Total duration (API): 1h 24m 22.8s
-Total duration (wall): 1h 43m 3.5s
-Total code changes: 746 lines added, 0 lines removed
-Token usage by model:
-claude-3-5-haiku: 18.8k input, 443 output, 0 cache read, 0 cache write
-claude-sonnet: 10 input, 666 output, 0 cache read, 245.6k cache write
-
-Mais pourtant 2 millions indiqués dans la page usage : <https://console.anthropic.com/usage>, et 7.88 dollars de consommés sur <https://console.anthropic.com/cost>.
-
-I just had a claude code session in which I kept having this error, even if the agent didn't seem to read a lot of files : API Error (429 {"type":"error","error":{"type":"rate_limit_error","message":"This request would exceed the rate limit for your organization (813e6b21-ec6f-44c3-a7f0-408244105e5c) of 20,000 input tokens per minute.
-
-at the end of the session the token usage and cost indicated was this :
-
-Total cost: $0.95
-Total duration (API): 1h 24m 22.8s
-Total duration (wall): 1h 43m 3.5s
-Total code changes: 746 lines added, 0 lines removed
-Token usage by model:
-claude-3-5-haiku: 18.8k input, 443 output, 0 cache read, 0 cache write
-claude-sonnet: 10 input, 666 output, 0 cache read, 245.6k cache write
-
-but the usage on the /usage page was 2,073,698 token in, and the cost on the /cost page was $7.90.
-
-When looking at the costs csv file, it seems that it is the "input cache write 5m" that consumed nearly all the tokens ( $7,71 ). Is it a bug ?

doc/refs/dqn-burn.md

@@ -1,56 +0,0 @@
-# DQN avec burn-rl
-
-## Paramètre d'entraînement dans dqn/burnrl/dqn_model.rs
-
-Ces constantes sont des hyperparamètres, c'est-à-dire des réglages que l'on fixe avant l'entraînement et qui conditionnent la manière dont le modèle va apprendre.
-
-MEMORY_SIZE
-
-- Ce que c'est : La taille de la "mémoire de rejeu" (Replay Memory/Buffer).
-- À quoi ça sert : L'agent interagit avec l'environnement (le jeu de TricTrac) et stocke ses expériences (un état, l'action prise, la récompense obtenue, et l'état suivant) dans cette mémoire. Pour s'entraîner, au
-  lieu d'utiliser uniquement la dernière expérience, il pioche un lot (batch) d'expériences aléatoires dans cette mémoire.
-- Pourquoi c'est important :
-  1.  Décorrélation : Ça casse la corrélation entre les expériences successives, ce qui rend l'entraînement plus stable et efficace.
-  2.  Réutilisation : Une même expérience peut être utilisée plusieurs fois pour l'entraînement, ce qui améliore l'efficacité des données.
-- Dans votre code : const MEMORY_SIZE: usize = 4096; signifie que l'agent gardera en mémoire les 4096 dernières transitions.
-
-DENSE_SIZE
-
-- Ce que c'est : La taille des couches cachées du réseau de neurones. "Dense" signifie que chaque neurone d'une couche est connecté à tous les neurones de la couche suivante.
-- À quoi ça sert : C'est la "capacité de réflexion" de votre agent. Le réseau de neurones (ici, Net) prend l'état du jeu en entrée, le fait passer à travers des couches de calcul (de taille DENSE_SIZE), et sort une
-  estimation de la qualité de chaque action possible.
-- Pourquoi c'est important :
-  - Une valeur trop petite : le modèle ne sera pas assez "intelligent" pour apprendre les stratégies complexes du TricTrac.
-  - Une valeur trop grande : l'entraînement sera plus lent et le modèle pourrait "sur-apprendre" (overfitting), c'est-à-dire devenir très bon sur les situations vues en entraînement mais incapable de généraliser
-    sur de nouvelles situations.
-- Dans votre code : const DENSE_SIZE: usize = 128; définit que les couches cachées du réseau auront 128 neurones.
-
-EPS_START, EPS_END et EPS_DECAY
-
-Ces trois constantes gèrent la stratégie d'exploration de l'agent, appelée "epsilon-greedy". Le but est de trouver un équilibre entre :
-
-- L'Exploitation : Jouer le coup que le modèle pense être le meilleur.
-- L'Exploration : Jouer un coup au hasard pour découvrir de nouvelles stratégies, potentiellement meilleures.
-
-epsilon (ε) est la probabilité de faire un choix aléatoire (explorer).
-
-- `EPS_START` (Epsilon de départ) :
-
-  - Ce que c'est : La valeur d'epsilon au tout début de l'entraînement.
-  - Rôle : Au début, le modèle ne sait rien. Il est donc crucial qu'il explore beaucoup pour accumuler des expériences variées. Une valeur élevée (proche de 1.0) est typique.
-  - Dans votre code : const EPS_START: f64 = 0.9; signifie qu'au début, l'agent a 90% de chances de jouer un coup au hasard.
-
-- `EPS_END` (Epsilon final) :
-
-  - Ce que c'est : La valeur minimale d'epsilon, atteinte après un certain nombre d'étapes.
-  - Rôle : Même après un long entraînement, on veut conserver une petite part d'exploration pour éviter que l'agent ne se fige dans une stratégie sous-optimale.
-  - Dans votre code : const EPS_END: f64 = 0.05; signifie qu'à la fin, l'agent explorera encore avec 5% de probabilité.
-
-- `EPS_DECAY` (Décroissance d'epsilon) :
-  - Ce que c'est : Contrôle la vitesse à laquelle epsilon passe de EPS_START à EPS_END.
-  - Rôle : C'est un facteur de "lissage" dans la formule de décroissance exponentielle. Plus cette valeur est élevée, plus la décroissance est lente, et donc plus l'agent passera de temps à explorer.
-  - Dans votre code : const EPS_DECAY: f64 = 1000.0; est utilisé dans la formule EPS_END + (EPS_START - EPS_END) \* f64::exp(-(step as f64) / EPS_DECAY); pour faire diminuer progressivement la valeur d'epsilon à
-    chaque étape (step) de l'entraînement.
-
-En résumé, ces constantes définissent l'architecture du "cerveau" de votre bot (DENSE*SIZE), sa mémoire à court terme (MEMORY_SIZE), et comment il apprend à équilibrer entre suivre sa stratégie et en découvrir de
-nouvelles (EPS*\*).

doc/refs/geminiQuestions.md

@@ -1,46 +0,0 @@
-# Description du projet et question
-
-Je développe un jeu de TricTrac (<https://fr.wikipedia.org/wiki/Trictrac>) dans le langage rust.
-Pour le moment je me concentre sur l'application en ligne de commande simple, donc ne t'occupe pas des dossiers 'client_bevy', 'client_tui', et 'server' qui ne seront utilisés que pour de prochaines évolutions.
-
-Les règles du jeu et l'état d'une partie sont implémentées dans 'store', l'application ligne de commande est implémentée dans 'client_cli', elle permet déjà de jouer contre un bot, ou de faire jouer deux bots l'un contre l'autre.
-Les stratégies de bots sont implémentées dans le dossier 'bot'.
-
-Plus précisément, l'état du jeu est défini par le struct GameState dans store/src/game.rs, la méthode to_string_id() permet de coder cet état de manière compacte dans une chaîne de caractères, mais il n'y a pas l'historique des coups joués. Il y a aussi fmt::Display d'implémenté pour une representation textuelle plus lisible.
-
-'client_cli/src/game_runner.rs' contient la logique permettant de faire jouer deux bots l'un contre l'autre.
-'bot/src/strategy/default.rs' contient le code d'une stratégie de bot basique : il détermine la liste des mouvements valides (avec la méthode get_possible_moves_sequences de store::MoveRules) et joue simplement le premier de la liste.
-
-Je cherche maintenant à ajouter des stratégies de bot plus fortes en entrainant un agent/bot par reinforcement learning.
-
-Une première version avec DQN fonctionne (entraînement avec `cargo run -bin=train_dqn`)
-Il gagne systématiquement contre le bot par défaut 'dummy' : `cargo run --bin=client_cli -- --bot dqn:./models/dqn_model_final.json,dummy`.
-
-Une version, toujours DQN, mais en utilisant la bibliothèque burn (<https://burn.dev/>) est en cours de développement.
-
-L'entraînement du modèle se passe dans la fonction "main" du fichier bot/src/burnrl/main.rs. On peut lancer l'exécution avec 'just trainbot'.
-
-Voici la sortie de l'entraînement lancé avec 'just trainbot' :
-
-```
-> Entraînement
-> {"episode": 0, "reward": -1692.3148, "duration": 1000}
-> {"episode": 1, "reward": -361.6962, "duration": 1000}
-> {"episode": 2, "reward": -126.1013, "duration": 1000}
-> {"episode": 3, "reward": -36.8000, "duration": 1000}
-> {"episode": 4, "reward": -21.4997, "duration": 1000}
-> {"episode": 5, "reward": -8.3000, "duration": 1000}
-> {"episode": 6, "reward": 3.1000, "duration": 1000}
-> {"episode": 7, "reward": -21.5998, "duration": 1000}
-> {"episode": 8, "reward": -10.1999, "duration": 1000}
-> {"episode": 9, "reward": 3.1000, "duration": 1000}
-> {"episode": 10, "reward": 14.5002, "duration": 1000}
-> {"episode": 11, "reward": 10.7000, "duration": 1000}
-> {"episode": 12, "reward": -0.7000, "duration": 1000}
-
-thread 'main' has overflowed its stack
-fatal runtime error: stack overflow
-error: Recipe `trainbot` was terminated on line 25 by signal 6
-```
-
-Au bout du 12ème épisode (plus de 6 heures sur ma machine), l'entraînement s'arrête avec une erreur stack overlow. Peux-tu m'aider à diagnostiquer d'où peut provenir le problème ? Y a-t-il des outils qui permettent de détecter les zones de code qui utilisent le plus la stack ? Pour information j'ai vu ce rapport de bug <https://github.com/yunjhongwu/burn-rl-examples/issues/40> , donc peut-être que le problème vient du paquet 'burl-rl'.

doc/refs/outputs.md

@@ -1,417 +0,0 @@
-# Outputs
-
-## 50 episodes - 1000 steps max - desktop
-
-{"episode": 0, "reward": -1798.7162, "steps count": 1000, "duration": 11}
-{"episode": 1, "reward": -1794.8162, "steps count": 1000, "duration": 32}
-{"episode": 2, "reward": -1387.7109, "steps count": 1000, "duration": 58}
-{"episode": 3, "reward": -42.5005, "steps count": 1000, "duration": 82}
-{"episode": 4, "reward": -48.2005, "steps count": 1000, "duration": 109}
-{"episode": 5, "reward": 1.2000, "steps count": 1000, "duration": 141}
-{"episode": 6, "reward": 8.8000, "steps count": 1000, "duration": 184}
-{"episode": 7, "reward": 6.9002, "steps count": 1000, "duration": 219}
-{"episode": 8, "reward": 16.5001, "steps count": 1000, "duration": 248}
-{"episode": 9, "reward": -2.6000, "steps count": 1000, "duration": 281}
-{"episode": 10, "reward": 3.0999, "steps count": 1000, "duration": 324}
-{"episode": 11, "reward": -34.7004, "steps count": 1000, "duration": 497}
-{"episode": 12, "reward": -15.7998, "steps count": 1000, "duration": 466}
-{"episode": 13, "reward": 6.9000, "steps count": 1000, "duration": 496}
-{"episode": 14, "reward": 6.3000, "steps count": 1000, "duration": 540}
-{"episode": 15, "reward": -2.6000, "steps count": 1000, "duration": 581}
-{"episode": 16, "reward": -33.0003, "steps count": 1000, "duration": 641}
-{"episode": 17, "reward": -36.8000, "steps count": 1000, "duration": 665}
-{"episode": 18, "reward": -10.1997, "steps count": 1000, "duration": 753}
-{"episode": 19, "reward": -88.1014, "steps count": 1000, "duration": 837}
-{"episode": 20, "reward": -57.5002, "steps count": 1000, "duration": 881}
-{"episode": 21, "reward": -17.7997, "steps count": 1000, "duration": 1159}
-{"episode": 22, "reward": -25.4000, "steps count": 1000, "duration": 1235}
-{"episode": 23, "reward": -104.4013, "steps count": 995, "duration": 1290}
-{"episode": 24, "reward": -268.6004, "steps count": 1000, "duration": 1322}
-{"episode": 25, "reward": -743.6052, "steps count": 1000, "duration": 1398}
-{"episode": 26, "reward": -821.5029, "steps count": 1000, "duration": 1427}
-{"episode": 27, "reward": -211.5993, "steps count": 1000, "duration": 1409}
-{"episode": 28, "reward": -276.1974, "steps count": 1000, "duration": 1463}
-{"episode": 29, "reward": -222.9980, "steps count": 1000, "duration": 1509}
-{"episode": 30, "reward": -298.9973, "steps count": 1000, "duration": 1560}
-{"episode": 31, "reward": -164.0011, "steps count": 1000, "duration": 1752}
-{"episode": 32, "reward": -221.0990, "steps count": 1000, "duration": 1807}
-{"episode": 33, "reward": -260.9996, "steps count": 1000, "duration": 1730}
-{"episode": 34, "reward": -420.5959, "steps count": 1000, "duration": 1767}
-{"episode": 35, "reward": -407.2964, "steps count": 1000, "duration": 1815}
-{"episode": 36, "reward": -291.2966, "steps count": 1000, "duration": 1870}
-
-thread 'main' has overflowed its stack
-fatal runtime error: stack overflow, aborting
-error: Recipe `trainbot` was terminated on line 24 by signal 6
-
-## 50 episodes - 700 steps max - desktop
-
-const MEMORY_SIZE: usize = 4096;
-const DENSE_SIZE: usize = 128;
-const EPS_DECAY: f64 = 1000.0;
-const EPS_START: f64 = 0.9;
-const EPS_END: f64 = 0.05;
-
-> Entraînement
-> {"episode": 0, "reward": -862.8993, "steps count": 700, "duration": 6}
-> {"episode": 1, "reward": -418.8971, "steps count": 700, "duration": 13}
-> {"episode": 2, "reward": -64.9999, "steps count": 453, "duration": 14}
-> {"episode": 3, "reward": -142.8002, "steps count": 700, "duration": 31}
-> {"episode": 4, "reward": -74.4004, "steps count": 700, "duration": 45}
-> {"episode": 5, "reward": -40.2002, "steps count": 700, "duration": 58}
-> {"episode": 6, "reward": -21.1998, "steps count": 700, "duration": 70}
-> {"episode": 7, "reward": 99.7000, "steps count": 642, "duration": 79}
-> {"episode": 8, "reward": -5.9999, "steps count": 700, "duration": 99}
-> {"episode": 9, "reward": -7.8999, "steps count": 700, "duration": 118}
-> {"episode": 10, "reward": 92.5000, "steps count": 624, "duration": 117}
-> {"episode": 11, "reward": -17.1998, "steps count": 700, "duration": 144}
-> {"episode": 12, "reward": 1.7000, "steps count": 700, "duration": 157}
-> {"episode": 13, "reward": -7.9000, "steps count": 700, "duration": 172}
-> {"episode": 14, "reward": -7.9000, "steps count": 700, "duration": 196}
-> {"episode": 15, "reward": -2.8000, "steps count": 700, "duration": 214}
-> {"episode": 16, "reward": 16.8002, "steps count": 700, "duration": 250}
-> {"episode": 17, "reward": -47.7001, "steps count": 700, "duration": 272}
-> k{"episode": 18, "reward": -13.6000, "steps count": 700, "duration": 288}
-> {"episode": 19, "reward": -79.9002, "steps count": 700, "duration": 304}
-> {"episode": 20, "reward": -355.5985, "steps count": 700, "duration": 317}
-> {"episode": 21, "reward": -205.5001, "steps count": 700, "duration": 333}
-> {"episode": 22, "reward": -207.3974, "steps count": 700, "duration": 348}
-> {"episode": 23, "reward": -161.7999, "steps count": 700, "duration": 367}
-
----
-
-const MEMORY_SIZE: usize = 8192;
-const DENSE_SIZE: usize = 128;
-const EPS_DECAY: f64 = 10000.0;
-const EPS_START: f64 = 0.9;
-const EPS_END: f64 = 0.05;
-
-> Entraînement
-> {"episode": 0, "reward": -1119.9921, "steps count": 700, "duration": 6}
-> {"episode": 1, "reward": -928.6963, "steps count": 700, "duration": 13}
-> {"episode": 2, "reward": -364.5009, "steps count": 380, "duration": 11}
-> {"episode": 3, "reward": -797.5981, "steps count": 700, "duration": 28}
-> {"episode": 4, "reward": -577.5994, "steps count": 599, "duration": 34}
-> {"episode": 5, "reward": -725.2992, "steps count": 700, "duration": 49}
-> {"episode": 6, "reward": -638.8995, "steps count": 700, "duration": 59}
-> {"episode": 7, "reward": -1039.1932, "steps count": 700, "duration": 73}
-> field invalid : White, 3, Board { positions: [13, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -2, 0, -11] }
-
-thread 'main' panicked at store/src/game.rs:556:65:
-called `Result::unwrap()` on an `Err` value: FieldInvalid
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-error: Recipe `trainbot` failed on line 27 with exit code 101
-
----
-
-# [allow(unused)]
-
-const MEMORY_SIZE: usize = 8192;
-const DENSE_SIZE: usize = 256;
-const EPS_DECAY: f64 = 10000.0;
-const EPS_START: f64 = 0.9;
-const EPS_END: f64 = 0.05;
-
-> Entraînement
-> {"episode": 0, "reward": -1102.6925, "steps count": 700, "duration": 9}
-> field invalid : White, 6, Board { positions: [14, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, 0, 0, -13] }
-
-thread 'main' panicked at store/src/game.rs:556:65:
-called `Result::unwrap()` on an `Err` value: FieldInvalid
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-error: Recipe `trainbot` failed on line 27 with exit code 101
-
----
-
-const MEMORY_SIZE: usize = 8192;
-const DENSE_SIZE: usize = 256;
-const EPS_DECAY: f64 = 1000.0;
-const EPS_START: f64 = 0.9;
-const EPS_END: f64 = 0.05;
-
-> Entraînement
-> {"episode": 0, "reward": -1116.2921, "steps count": 700, "duration": 9}
-> {"episode": 1, "reward": -1116.2922, "steps count": 700, "duration": 18}
-> {"episode": 2, "reward": -1119.9921, "steps count": 700, "duration": 29}
-> {"episode": 3, "reward": -1089.1927, "steps count": 700, "duration": 41}
-> {"episode": 4, "reward": -1116.2921, "steps count": 700, "duration": 53}
-> {"episode": 5, "reward": -684.8043, "steps count": 700, "duration": 66}
-> {"episode": 6, "reward": 0.3000, "steps count": 700, "duration": 80}
-> {"episode": 7, "reward": 2.0000, "steps count": 700, "duration": 96}
-> {"episode": 8, "reward": 30.9001, "steps count": 700, "duration": 112}
-> {"episode": 9, "reward": 0.3000, "steps count": 700, "duration": 128}
-> {"episode": 10, "reward": 0.3000, "steps count": 700, "duration": 141}
-> {"episode": 11, "reward": 8.8000, "steps count": 700, "duration": 155}
-> {"episode": 12, "reward": 7.1000, "steps count": 700, "duration": 169}
-> {"episode": 13, "reward": 17.3001, "steps count": 700, "duration": 190}
-> {"episode": 14, "reward": -107.9005, "steps count": 700, "duration": 210}
-> {"episode": 15, "reward": 7.1001, "steps count": 700, "duration": 236}
-> {"episode": 16, "reward": 17.3001, "steps count": 700, "duration": 268}
-> {"episode": 17, "reward": 7.1000, "steps count": 700, "duration": 283}
-> {"episode": 18, "reward": -5.9000, "steps count": 700, "duration": 300}
-> {"episode": 19, "reward": -36.8009, "steps count": 700, "duration": 316}
-> {"episode": 20, "reward": 19.0001, "steps count": 700, "duration": 332}
-> {"episode": 21, "reward": 113.3000, "steps count": 461, "duration": 227}
-> field invalid : White, 1, Board { positions: [0, 2, 2, 0, 2, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -3, -7, -2, -1, 0, -1, -1] }
-
-thread 'main' panicked at store/src/game.rs:556:65:
-called `Result::unwrap()` on an `Err` value: FieldInvalid
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-error: Recipe `trainbot` failed on line 27 with exit code 101
-
----
-
-num_episodes: 50,
-// memory_size: 8192, // must be set in dqn_model.rs with the MEMORY_SIZE constant
-// max_steps: 700, // must be set in environment.rs with the MAX_STEPS constant
-dense_size: 256, // neural network complexity
-eps_start: 0.9, // epsilon initial value (0.9 => more exploration)
-eps_end: 0.05,
-eps_decay: 1000.0,
-
-> Entraînement
-> {"episode": 0, "reward": -1118.8921, "steps count": 700, "duration": 9}
-> {"episode": 1, "reward": -1119.9921, "steps count": 700, "duration": 17}
-> {"episode": 2, "reward": -1118.8921, "steps count": 700, "duration": 28}
-> {"episode": 3, "reward": -283.5977, "steps count": 700, "duration": 41}
-> {"episode": 4, "reward": -23.4998, "steps count": 700, "duration": 54}
-> {"episode": 5, "reward": -31.9999, "steps count": 700, "duration": 68}
-> {"episode": 6, "reward": 2.0000, "steps count": 700, "duration": 82}
-> {"episode": 7, "reward": 109.3000, "steps count": 192, "duration": 26}
-> {"episode": 8, "reward": -4.8000, "steps count": 700, "duration": 102}
-> {"episode": 9, "reward": 15.6001, "steps count": 700, "duration": 124}
-> {"episode": 10, "reward": 15.6002, "steps count": 700, "duration": 144}
-> {"episode": 11, "reward": -65.7008, "steps count": 700, "duration": 162}
-> {"episode": 12, "reward": 19.0002, "steps count": 700, "duration": 182}
-> {"episode": 13, "reward": 20.7001, "steps count": 700, "duration": 197}
-> {"episode": 14, "reward": 12.2002, "steps count": 700, "duration": 229}
-> {"episode": 15, "reward": -32.0007, "steps count": 700, "duration": 242}
-> {"episode": 16, "reward": 10.5000, "steps count": 700, "duration": 287}
-> {"episode": 17, "reward": 24.1001, "steps count": 700, "duration": 318}
-> {"episode": 18, "reward": 25.8002, "steps count": 700, "duration": 335}
-> {"episode": 19, "reward": 29.2001, "steps count": 700, "duration": 367}
-> {"episode": 20, "reward": 9.1000, "steps count": 700, "duration": 366}
-> {"episode": 21, "reward": 3.7001, "steps count": 700, "duration": 398}
-> {"episode": 22, "reward": 10.5000, "steps count": 700, "duration": 417}
-> {"episode": 23, "reward": 10.5000, "steps count": 700, "duration": 438}
-> {"episode": 24, "reward": 13.9000, "steps count": 700, "duration": 444}
-> {"episode": 25, "reward": 7.1000, "steps count": 700, "duration": 486}
-> {"episode": 26, "reward": 12.2001, "steps count": 700, "duration": 499}
-> {"episode": 27, "reward": 8.8001, "steps count": 700, "duration": 554}
-> {"episode": 28, "reward": -6.5000, "steps count": 700, "duration": 608}
-> {"episode": 29, "reward": -3.1000, "steps count": 700, "duration": 633}
-> {"episode": 30, "reward": -32.0001, "steps count": 700, "duration": 696}
-> {"episode": 31, "reward": 22.4002, "steps count": 700, "duration": 843}
-> {"episode": 32, "reward": -77.9004, "steps count": 700, "duration": 817}
-> {"episode": 33, "reward": -368.5993, "steps count": 700, "duration": 827}
-> {"episode": 34, "reward": -254.6986, "steps count": 700, "duration": 852}
-> {"episode": 35, "reward": -433.1992, "steps count": 700, "duration": 884}
-> {"episode": 36, "reward": -521.6010, "steps count": 700, "duration": 905}
-> {"episode": 37, "reward": -71.1004, "steps count": 700, "duration": 930}
-> {"episode": 38, "reward": -251.0004, "steps count": 700, "duration": 956}
-> {"episode": 39, "reward": -594.7045, "steps count": 700, "duration": 982}
-> {"episode": 40, "reward": -154.4001, "steps count": 700, "duration": 1008}
-> {"episode": 41, "reward": -171.3994, "steps count": 700, "duration": 1033}
-> {"episode": 42, "reward": -118.7004, "steps count": 700, "duration": 1059}
-> {"episode": 43, "reward": -137.4003, "steps count": 700, "duration": 1087}
-
-thread 'main' has overflowed its stack
-fatal runtime error: stack overflow, aborting
-error: Recipe `trainbot` was terminated on line 27 by signal 6
-
----
-
-num_episodes: 40,
-// memory_size: 8192, // must be set in dqn_model.rs with the MEMORY_SIZE constant
-// max_steps: 1500, // must be set in environment.rs with the MAX_STEPS constant
-dense_size: 256, // neural network complexity
-eps_start: 0.9, // epsilon initial value (0.9 => more exploration)
-eps_end: 0.05,
-eps_decay: 1000.0,
-
-> Entraînement
-> {"episode": 0, "reward": -2399.9993, "steps count": 1500, "duration": 31}
-> {"episode": 1, "reward": -2061.6736, "steps count": 1500, "duration": 81}
-> {"episode": 2, "reward": -48.9010, "steps count": 1500, "duration": 145}
-> {"episode": 3, "reward": 3.8000, "steps count": 1500, "duration": 215}
-> {"episode": 4, "reward": -6.3999, "steps count": 1500, "duration": 302}
-> {"episode": 5, "reward": 20.8004, "steps count": 1500, "duration": 374}
-> {"episode": 6, "reward": 49.6992, "steps count": 1500, "duration": 469}
-> {"episode": 7, "reward": 29.3002, "steps count": 1500, "duration": 597}
-> {"episode": 8, "reward": 34.3999, "steps count": 1500, "duration": 710}
-> {"episode": 9, "reward": 115.3003, "steps count": 966, "duration": 515}
-> {"episode": 10, "reward": 25.9004, "steps count": 1500, "duration": 852}
-> {"episode": 11, "reward": -122.0007, "steps count": 1500, "duration": 1017}
-> {"episode": 12, "reward": -274.9966, "steps count": 1500, "duration": 1073}
-> {"episode": 13, "reward": 54.8994, "steps count": 651, "duration": 518}
-> {"episode": 14, "reward": -439.8978, "steps count": 1500, "duration": 1244}
-> {"episode": 15, "reward": -506.1997, "steps count": 1500, "duration": 1676}
-> {"episode": 16, "reward": -829.5031, "steps count": 1500, "duration": 1855}
-> {"episode": 17, "reward": -545.2961, "steps count": 1500, "duration": 1892}
-> {"episode": 18, "reward": -795.2026, "steps count": 1500, "duration": 2008}
-> {"episode": 19, "reward": -637.1031, "steps count": 1500, "duration": 2124}
-> {"episode": 20, "reward": -989.6997, "steps count": 1500, "duration": 2241}
-
-thread 'main' has overflowed its stack
-fatal runtime error: stack overflow, aborting
-error: Recipe `trainbot` was terminated on line 27 by signal 6
-
----
-
-num_episodes: 40,
-// memory_size: 8192, // must be set in dqn_model.rs with the MEMORY_SIZE constant
-// max_steps: 1000, // must be set in environment.rs with the MAX_STEPS constant
-dense_size: 256, // neural network complexity
-eps_start: 0.9, // epsilon initial value (0.9 => more exploration)
-eps_end: 0.05,
-eps_decay: 10000.0,
-
-> Entraînement
-> {"episode": 0, "reward": -1598.8848, "steps count": 1000, "duration": 16}
-> {"episode": 1, "reward": -1531.9866, "steps count": 1000, "duration": 34}
-> {"episode": 2, "reward": -515.6000, "steps count": 530, "duration": 25}
-> {"episode": 3, "reward": -396.1008, "steps count": 441, "duration": 27}
-> {"episode": 4, "reward": -540.6996, "steps count": 605, "duration": 43}
-> {"episode": 5, "reward": -976.0975, "steps count": 1000, "duration": 89}
-> {"episode": 6, "reward": -1014.2944, "steps count": 1000, "duration": 117}
-> {"episode": 7, "reward": -806.7012, "steps count": 1000, "duration": 140}
-> {"episode": 8, "reward": -1276.6891, "steps count": 1000, "duration": 166}
-> {"episode": 9, "reward": -1554.3855, "steps count": 1000, "duration": 197}
-> {"episode": 10, "reward": -1178.3925, "steps count": 1000, "duration": 219}
-> {"episode": 11, "reward": -1457.4869, "steps count": 1000, "duration": 258}
-> {"episode": 12, "reward": -1475.8882, "steps count": 1000, "duration": 291}
-
----
-
-num_episodes: 40,
-// memory_size: 8192, // must be set in dqn_model.rs with the MEMORY_SIZE constant
-// max_steps: 1000, // must be set in environment.rs with the MAX_STEPS constant
-dense_size: 256, // neural network complexity
-eps_start: 0.9, // epsilon initial value (0.9 => more exploration)
-eps_end: 0.05,
-eps_decay: 3000.0,
-
-> Entraînement
-> {"episode": 0, "reward": -1598.8848, "steps count": 1000, "duration": 15}
-> {"episode": 1, "reward": -1599.9847, "steps count": 1000, "duration": 33}
-> {"episode": 2, "reward": -751.7018, "steps count": 1000, "duration": 57}
-> {"episode": 3, "reward": -402.8979, "steps count": 1000, "duration": 81}
-> {"episode": 4, "reward": -289.2985, "steps count": 1000, "duration": 108}
-> {"episode": 5, "reward": -231.4988, "steps count": 1000, "duration": 140}
-> {"episode": 6, "reward": -138.0006, "steps count": 1000, "duration": 165}
-> {"episode": 7, "reward": -145.0998, "steps count": 1000, "duration": 200}
-> {"episode": 8, "reward": -60.4005, "steps count": 1000, "duration": 236}
-> {"episode": 9, "reward": -35.7999, "steps count": 1000, "duration": 276}
-> {"episode": 10, "reward": -42.2002, "steps count": 1000, "duration": 313}
-> {"episode": 11, "reward": 69.0002, "steps count": 874, "duration": 300}
-> {"episode": 12, "reward": 93.2000, "steps count": 421, "duration": 153}
-> {"episode": 13, "reward": -324.9010, "steps count": 866, "duration": 364}
-> {"episode": 14, "reward": -1331.3883, "steps count": 1000, "duration": 478}
-> {"episode": 15, "reward": -1544.5859, "steps count": 1000, "duration": 514}
-> {"episode": 16, "reward": -1599.9847, "steps count": 1000, "duration": 552}
-
----
-
-Nouveaux points...
-
-num_episodes: 40,
-// memory_size: 8192, // must be set in dqn_model.rs with the MEMORY_SIZE constant
-// max_steps: 1000, // must be set in environment.rs with the MAX_STEPS constant
-dense_size: 256, // neural network complexity
-eps_start: 0.9, // epsilon initial value (0.9 => more exploration)
-eps_end: 0.05,
-eps_decay: 3000.0,
-
-> Entraînement
-> {"episode": 0, "reward": -1798.1161, "steps count": 1000, "duration": 15}
-> {"episode": 1, "reward": -1800.0162, "steps count": 1000, "duration": 34}
-> {"episode": 2, "reward": -1718.6151, "steps count": 1000, "duration": 57}
-> {"episode": 3, "reward": -1369.5055, "steps count": 1000, "duration": 82}
-> {"episode": 4, "reward": -321.5974, "steps count": 1000, "duration": 115}
-> {"episode": 5, "reward": -213.2988, "steps count": 1000, "duration": 148}
-> {"episode": 6, "reward": -175.4995, "steps count": 1000, "duration": 172}
-> {"episode": 7, "reward": -126.1011, "steps count": 1000, "duration": 203}
-> {"episode": 8, "reward": -105.1011, "steps count": 1000, "duration": 242}
-> {"episode": 9, "reward": -46.3007, "steps count": 1000, "duration": 281}
-> {"episode": 10, "reward": -57.7006, "steps count": 1000, "duration": 323}
-> {"episode": 11, "reward": -15.7997, "steps count": 1000, "duration": 354}
-> {"episode": 12, "reward": -38.6999, "steps count": 1000, "duration": 414}
-> {"episode": 13, "reward": 10.7002, "steps count": 1000, "duration": 513}
-> {"episode": 14, "reward": -10.1999, "steps count": 1000, "duration": 585}
-> {"episode": 15, "reward": -8.3000, "steps count": 1000, "duration": 644}
-> {"episode": 16, "reward": -463.4984, "steps count": 973, "duration": 588}
-> {"episode": 17, "reward": -148.8951, "steps count": 1000, "duration": 646}
-> {"episode": 18, "reward": 3.0999, "steps count": 1000, "duration": 676}
-> {"episode": 19, "reward": -12.0999, "steps count": 1000, "duration": 753}
-> {"episode": 20, "reward": 6.9000, "steps count": 1000, "duration": 801}
-> {"episode": 21, "reward": 14.5001, "steps count": 1000, "duration": 850}
-> {"episode": 22, "reward": -19.6999, "steps count": 1000, "duration": 937}
-> {"episode": 23, "reward": 83.0000, "steps count": 456, "duration": 532}
-> {"episode": 24, "reward": -13.9998, "steps count": 1000, "duration": 1236}
-> {"episode": 25, "reward": 25.9003, "steps count": 1000, "duration": 1264}
-> {"episode": 26, "reward": 1.2002, "steps count": 1000, "duration": 1349}
-> {"episode": 27, "reward": 3.1000, "steps count": 1000, "duration": 1364}
-> {"episode": 28, "reward": -6.4000, "steps count": 1000, "duration": 1392}
-> {"episode": 29, "reward": -4.4998, "steps count": 1000, "duration": 1444}
-> {"episode": 30, "reward": 3.1000, "steps count": 1000, "duration": 1611}
-
-thread 'main' has overflowed its stack
-fatal runtime error: stack overflow, aborting
-
----
-
-num_episodes: 40,
-// memory_size: 8192, // must be set in dqn_model.rs with the MEMORY_SIZE constant
-// max_steps: 700, // must be set in environment.rs with the MAX_STEPS constant
-dense_size: 256, // neural network complexity
-eps_start: 0.9, // epsilon initial value (0.9 => more exploration)
-eps_end: 0.05,
-eps_decay: 3000.0,
-
-{"episode": 0, "reward": -1256.1014, "steps count": 700, "duration": 9}
-{"episode": 1, "reward": -1256.1013, "steps count": 700, "duration": 20}
-{"episode": 2, "reward": -1256.1014, "steps count": 700, "duration": 31}
-{"episode": 3, "reward": -1258.7015, "steps count": 700, "duration": 44}
-{"episode": 4, "reward": -1206.8009, "steps count": 700, "duration": 56}
-{"episode": 5, "reward": -473.2974, "steps count": 700, "duration": 68}
-{"episode": 6, "reward": -285.2984, "steps count": 700, "duration": 82}
-{"episode": 7, "reward": -332.6987, "steps count": 700, "duration": 103}
-{"episode": 8, "reward": -359.2984, "steps count": 700, "duration": 114}
-{"episode": 9, "reward": -118.7008, "steps count": 700, "duration": 125}
-{"episode": 10, "reward": -83.9004, "steps count": 700, "duration": 144}
-{"episode": 11, "reward": -68.7006, "steps count": 700, "duration": 165}
-{"episode": 12, "reward": -49.7002, "steps count": 700, "duration": 180}
-{"episode": 13, "reward": -68.7002, "steps count": 700, "duration": 204}
-{"episode": 14, "reward": -38.3001, "steps count": 700, "duration": 223}
-{"episode": 15, "reward": -19.2999, "steps count": 700, "duration": 240}
-{"episode": 16, "reward": -19.1998, "steps count": 700, "duration": 254}
-{"episode": 17, "reward": -21.1999, "steps count": 700, "duration": 250}
-{"episode": 18, "reward": -26.8998, "steps count": 700, "duration": 280}
-{"episode": 19, "reward": -11.6999, "steps count": 700, "duration": 301}
-{"episode": 20, "reward": -13.5998, "steps count": 700, "duration": 317}
-{"episode": 21, "reward": 5.4000, "steps count": 700, "duration": 334}
-{"episode": 22, "reward": 3.5000, "steps count": 700, "duration": 353}
-{"episode": 23, "reward": 13.0000, "steps count": 700, "duration": 374}
-{"episode": 24, "reward": 7.3001, "steps count": 700, "duration": 391}
-{"episode": 25, "reward": -4.1000, "steps count": 700, "duration": 408}
-{"episode": 26, "reward": -17.3998, "steps count": 700, "duration": 437}
-{"episode": 27, "reward": 11.1001, "steps count": 700, "duration": 480}
-{"episode": 28, "reward": -4.1000, "steps count": 700, "duration": 505}
-{"episode": 29, "reward": -13.5999, "steps count": 700, "duration": 522}
-{"episode": 30, "reward": -0.3000, "steps count": 700, "duration": 540}
-{"episode": 31, "reward": -15.4998, "steps count": 700, "duration": 572}
-{"episode": 32, "reward": 14.9001, "steps count": 700, "duration": 630}
-{"episode": 33, "reward": -4.1000, "steps count": 700, "duration": 729}
-{"episode": 34, "reward": 5.4000, "steps count": 700, "duration": 777}
-{"episode": 35, "reward": 7.3000, "steps count": 700, "duration": 748}
-{"episode": 36, "reward": 9.2001, "steps count": 700, "duration": 767}
-{"episode": 37, "reward": 13.0001, "steps count": 700, "duration": 791}
-{"episode": 38, "reward": -13.5999, "steps count": 700, "duration": 813}
-{"episode": 39, "reward": 26.3002, "steps count": 700, "duration": 838}
-
-> Sauvegarde du modèle de validation
-> Modèle de validation sauvegardé : models/burn_dqn_50_model.mpk
-> Chargement du modèle pour test
-> Chargement du modèle depuis : models/burn_dqn_50_model.mpk
-> Test avec le modèle chargé
-> Episode terminé. Récompense totale: 70.00, Étapes: 700

doc/workflow.md

@@ -1,25 +0,0 @@
-# Workflow
-
-@startuml
-
-state c <<choice>>
-state haswon <<choice>>
-state MarkPoints #lightblue
-state MarkAdvPoints #lightblue
-note right of MarkPoints : automatic 'Mark' transition\nwhen no school
-note right of MarkAdvPoints : automatic 'Mark' transition\nwhen no school
-
-[*] -> RollDice : BeginGame
-RollDice --> RollWaiting : Roll (current player)
-RollWaiting --> MarkPoints : RollResult (engine)
-MarkPoints --> c : Mark (current player)
-c --> HoldHorGoChoice : [new hole]
-c --> [*] : [has won]
-c --> Move : [not new hole]
-HoldHorGoChoice --> RollDice : Go
-HoldHorGoChoice --> MarkAdvPoints : Move
-Move --> MarkAdvPoints : Move
-MarkAdvPoints --> haswon : Mark (adversary)
-haswon --> RollDice : [has not won]
-haswon --> [*] : [has won]
-@enduml

justfile

@@ -9,31 +9,8 @@ shell:
 runcli:
 	RUST_LOG=info cargo run --bin=client_cli
 runclibots:
-	#RUST_LOG=info cargo run --bin=client_cli -- --bot dqn,dummy
-	RUST_LOG=info cargo run --bin=client_cli -- --bot dummy,dqn
-match:
-  cargo build --release --bin=client_cli
-  LD_LIBRARY_PATH=./target/release  ./target/release/client_cli -- --bot dummy,dqn
+	RUST_LOG=info cargo run --bin=client_cli -- --bot dummy,dummy
 profile:
   echo '1' | sudo tee /proc/sys/kernel/perf_event_paranoid
   cargo build --profile profiling
   samply record ./target/profiling/client_cli --bot dummy,dummy
-pythonlib:
-  maturin build -m store/Cargo.toml --release
-  pip install --no-deps --force-reinstall --prefix .devenv/state/venv target/wheels/*.whl
-trainbot:
-  #python ./store/python/trainModel.py
-  # cargo run --bin=train_dqn # ok
-  # cargo run --bin=train_dqn_burn # utilise debug (why ?)
-  cargo build --release --bin=train_dqn_burn
-  LD_LIBRARY_PATH=./target/release  ./target/release/train_dqn_burn | tee /tmp/train.out
-plottrainbot:
-  cat /tmp/train.out | awk -F '[ ,]' '{print $5}' | feedgnuplot --lines --points --unset grid
-  #tail -f /tmp/train.out | awk -F '[ ,]' '{print $5}' | feedgnuplot --lines --points --unset grid
-debugtrainbot:
-  cargo build --bin=train_dqn_burn
-  RUST_BACKTRACE=1 LD_LIBRARY_PATH=./target/debug  ./target/debug/train_dqn_burn
-profiletrainbot:
-  echo '1' | sudo tee /proc/sys/kernel/perf_event_paranoid
-  cargo build --profile profiling --bin=train_dqn_burn
-  LD_LIBRARY_PATH=./target/profiling  samply record ./target/profiling/train_dqn_burn

store/Cargo.toml

@@ -5,11 +5,6 @@ edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-[lib]
-name = "store"
-# Only "rlib" is needed for other Rust crates to use this library
-crate-type = ["rlib"]
-
 [dependencies]
 base64 = "0.21.7"
 # provides macros for creating log messages to be used by a logger (for example env_logger)

store/src/board.rs

@@ -153,10 +153,6 @@ impl Board {
             .unsigned_abs()
     }
 
-    pub fn to_vec(&self) -> Vec<i8> {
-        self.positions.to_vec()
-    }
-
     // maybe todo : operate on bits (cf. https://github.com/bungogood/bkgm/blob/a2fb3f395243bcb0bc9f146df73413f73f5ea1e0/src/position.rs#L217)
     pub fn to_gnupg_pos_id(&self) -> String {
         // Pieces placement -> 77bits (24 + 23 + 30 max)
@@ -564,7 +560,6 @@ impl Board {
         }
         let checker_color = self.get_checkers_color(field)?;
         if Some(color) != checker_color {
-            println!("field invalid : {:?}, {:?}, {:?}", color, field, self);
             return Err(Error::FieldInvalid);
         }
         let unit = match color {

store/src/game.rs

@@ -32,33 +32,6 @@ pub enum TurnStage {
     MarkAdvPoints,
 }
 
-impl From<u8> for TurnStage {
-    fn from(item: u8) -> Self {
-        match item {
-            0 => TurnStage::RollWaiting,
-            1 => TurnStage::RollDice,
-            2 => TurnStage::MarkPoints,
-            3 => TurnStage::HoldOrGoChoice,
-            4 => TurnStage::Move,
-            5 => TurnStage::MarkAdvPoints,
-            _ => TurnStage::RollWaiting,
-        }
-    }
-}
-
-impl From<TurnStage> for u8 {
-    fn from(stage: TurnStage) -> u8 {
-        match stage {
-            TurnStage::RollWaiting => 0,
-            TurnStage::RollDice => 1,
-            TurnStage::MarkPoints => 2,
-            TurnStage::HoldOrGoChoice => 3,
-            TurnStage::Move => 4,
-            TurnStage::MarkAdvPoints => 5,
-        }
-    }
-}
-
 /// Represents a TricTrac game
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct GameState {
@@ -71,7 +44,7 @@ pub struct GameState {
     /// last dice pair rolled
     pub dice: Dice,
     /// players points computed for the last dice pair rolled
-    pub dice_points: (u8, u8),
+    dice_points: (u8, u8),
     pub dice_moves: (CheckerMove, CheckerMove),
     pub dice_jans: PossibleJans,
     /// true if player needs to roll first
@@ -144,63 +117,6 @@ impl GameState {
     //                        accessors
     // -------------------------------------------------------------------------
 
-    pub fn to_vec_float(&self) -> Vec<f32> {
-        self.to_vec().iter().map(|&x| x as f32).collect()
-    }
-
-    /// Get state as a vector (to be used for bot training input) :
-    /// length = 36
-    pub fn to_vec(&self) -> Vec<i8> {
-        let state_len = 36;
-        let mut state = Vec::with_capacity(state_len);
-
-        // length = 24
-        state.extend(self.board.to_vec());
-
-        // active player -> length = 1
-        // white : 0 (false)
-        // black : 1 (true)
-        state.push(
-            self.who_plays()
-                .map(|player| if player.color == Color::Black { 1 } else { 0 })
-                .unwrap_or(0), // White by default
-        );
-
-        // step  -> length = 1
-        let turn_stage: u8 = self.turn_stage.into();
-        state.push(turn_stage as i8);
-
-        // dice roll -> length = 2
-        state.push(self.dice.values.0 as i8);
-        state.push(self.dice.values.1 as i8);
-
-        // points, trous, bredouille, grande bredouille length=4 x2 joueurs = 8
-        let white_player: Vec<i8> = self
-            .get_white_player()
-            .unwrap()
-            .to_vec()
-            .iter()
-            .map(|&x| x as i8)
-            .collect();
-        state.extend(white_player);
-        let black_player: Vec<i8> = self
-            .get_black_player()
-            .unwrap()
-            .to_vec()
-            .iter()
-            .map(|&x| x as i8)
-            .collect();
-        // .iter().map(|&x| x as i8) .collect()
-        state.extend(black_player);
-
-        // ensure state has length state_len
-        state.truncate(state_len);
-        while state.len() < state_len {
-            state.push(0);
-        }
-        state
-    }
-
     /// Calculate game state id :
     pub fn to_string_id(&self) -> String {
         // Pieces placement -> 77 bits (24 + 23 + 30 max)
@@ -415,9 +331,6 @@ impl GameState {
                     return false;
                 }
             }
-            PlayError => {
-                return true;
-            }
         }
 
         // We couldn't find anything wrong with the event so it must be good
@@ -505,8 +418,14 @@ impl GameState {
                 self.players.remove(player_id);
             }
             Roll { player_id: _ } => {
+                // Opponent has moved, we can mark pending points earned during opponent's turn
+                let new_hole = self.mark_points(self.active_player_id, self.dice_points.1);
+                if new_hole && self.get_active_player().unwrap().holes > 12 {
+                    self.stage = Stage::Ended;
+                } else {
                     self.turn_stage = TurnStage::RollWaiting;
                 }
+            }
             RollResult { player_id: _, dice } => {
                 self.dice = *dice;
                 self.inc_roll_count(self.active_player_id);
@@ -528,7 +447,6 @@ impl GameState {
                 }
             }
             Mark { player_id, points } => {
-                if self.schools_enabled {
                 let new_hole = self.mark_points(*player_id, *points);
                 if new_hole {
                     if self.get_active_player().unwrap().holes > 12 {
@@ -548,7 +466,6 @@ impl GameState {
                     };
                 }
             }
-            }
             Go { player_id: _ } => self.new_pick_up(),
             Move { player_id, moves } => {
                 let player = self.players.get(player_id).unwrap();
@@ -559,15 +476,9 @@ impl GameState {
                 self.turn_stage = if self.schools_enabled {
                     TurnStage::MarkAdvPoints
                 } else {
-                    // The player has moved, we can mark its opponent's points (which is now the current player)
-                    let new_hole = self.mark_points(self.active_player_id, self.dice_points.1);
-                    if new_hole && self.get_active_player().unwrap().holes > 12 {
-                        self.stage = Stage::Ended;
-                    }
                     TurnStage::RollDice
                 };
             }
-            PlayError => {}
         }
         self.history.push(valid_event.clone());
     }
@@ -610,9 +521,7 @@ impl GameState {
 
     fn inc_roll_count(&mut self, player_id: PlayerId) {
         self.players.get_mut(&player_id).map(|p| {
-            if p.dice_roll_count < u8::MAX {
             p.dice_roll_count += 1;
-            }
             p
         });
     }
@@ -711,7 +620,6 @@ pub enum GameEvent {
         player_id: PlayerId,
         moves: (CheckerMove, CheckerMove),
     },
-    PlayError,
 }
 
 impl GameEvent {
@@ -759,7 +667,6 @@ mod tests {
     #[test]
     fn hold_or_go() {
         let mut game_state = init_test_gamestate(TurnStage::MarkPoints);
-        game_state.schools_enabled = true;
         let pid = game_state.active_player_id;
         game_state.consume(
             &(GameEvent::Mark {
@@ -785,7 +692,6 @@ mod tests {
 
         // Hold
         let mut game_state = init_test_gamestate(TurnStage::MarkPoints);
-        game_state.schools_enabled = true;
         let pid = game_state.active_player_id;
         game_state.consume(
             &(GameEvent::Mark {
@@ -806,6 +712,6 @@ mod tests {
         assert_ne!(game_state.active_player_id, pid);
         assert_eq!(game_state.players.get(&pid).unwrap().points, 1);
         assert_eq!(game_state.get_active_player().unwrap().points, 0);
-        assert_eq!(game_state.turn_stage, TurnStage::MarkAdvPoints);
+        assert_eq!(game_state.turn_stage, TurnStage::RollDice);
     }
 }

store/src/game_rules_moves.rs

@@ -93,18 +93,6 @@ impl MoveRules {
     /// ---- moves_possibles : First of three checks for moves
     fn moves_possible(&self, moves: &(CheckerMove, CheckerMove)) -> bool {
         let color = &Color::White;
-
-        let move0_from = moves.0.get_from();
-        if 0 < move0_from && move0_from == moves.1.get_from() {
-            if let Ok((field_count, Some(field_color))) = self.board.get_field_checkers(move0_from)
-            {
-                if color != field_color || field_count < 2 {
-                    info!("Move not physically possible");
-                    return false;
-                }
-            }
-        }
-
         if let Ok(chained_move) = moves.0.chain(moves.1) {
             // Check intermediary move and chained_move : "Tout d'une"
             if !self.board.passage_possible(color, &moves.0)
@@ -1017,7 +1005,7 @@ mod tests {
 
     #[test]
     fn moves_possible() {
-        let mut state = MoveRules::default();
+        let state = MoveRules::default();
 
         // Chained moves
         let moves = (
@@ -1033,17 +1021,6 @@ mod tests {
         );
         assert!(!state.moves_possible(&moves));
 
-        // Can't move the same checker twice
-        state.board.set_positions([
-            3, 3, 1, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        ]);
-        state.dice.values = (2, 1);
-        let moves = (
-            CheckerMove::new(3, 5).unwrap(),
-            CheckerMove::new(3, 4).unwrap(),
-        );
-        assert!(!state.moves_possible(&moves));
-
         // black moves
         let state = MoveRules::new(&Color::Black, &Board::default(), Dice::default());
         let moves = (

store/src/player.rs

@@ -52,15 +52,6 @@ impl Player {
             self.points, self.holes, self.can_bredouille as u8, self.can_big_bredouille as u8
         )
     }
-
-    pub fn to_vec(&self) -> Vec<u8> {
-        vec![
-            self.points,
-            self.holes,
-            self.can_bredouille as u8,
-            self.can_big_bredouille as u8,
-        ]
-    }
 }
 
 /// Represents a player in the game.