diff --git a/doc/backlog.md b/doc/backlog.md
index df1da9c..5c5bb51 100644
--- a/doc/backlog.md
+++ b/doc/backlog.md
@@ -65,3 +65,29 @@ Encodage efficace : https://www.gnu.org/software/gnubg/manual/html_node/A-techni
   * grande bredouille possible 1bit
 
 Total : 77 + 1 + 2 + 6 + 20 = 105 bits = 17.666 * 6 -> 18 u32 (108 possible)
+
+## TODO
+
+### Epic : jeu simple
+
+Store
+- gestion des évènements 
+  - déplacement de dames
+  - jet des dés
+- déplacements physiques possibles 
+- déplacements autorisés par les règles (pourront être validés physiquement si jeu avec écoles)
+- calcul des points automatique (pas d'écoles)
+
+Server
+- 
+
+Client
+- client tui (ratatui)
+- client desktop (bevy)
+- client web
+
+### Epic : jeu avec écoles
+- déplacement de fiches points : validation physique
+- évenements de déclaration d'école & contre école
+
+### Epic : Bot
diff --git a/store/src/board.rs b/store/src/board.rs
index 9145b75..e2adf21 100644
--- a/store/src/board.rs
+++ b/store/src/board.rs
@@ -112,7 +112,7 @@ impl Board {
 
     /// Check if a field is blocked for a player
     pub fn blocked(&self, player: &Player, field: usize) -> Result<bool, Error> {
-        if field > 24 {
+        if field < 1 || 24 < field {
             return Err(Error::FieldInvalid);
         }
 
@@ -159,188 +159,65 @@ mod tests {
     }
 
     #[test]
-    fn blocked_player0() -> Result<(), Error> {
+    fn blocked_outofrange() -> Result<(), Error> {
         let board = Board::new();
-        assert!(board.blocked(
-            &Player {
-                name: "".into(),
-                color: Color::White,
-                holes: 0,
-                points: 0,
-                can_bredouille: true,
-                can_big_bredouille: true
-            },
-            0
-        )?);
+        let player = Player::new("".into(), Color::White);
+        assert!(board.blocked( &player, 0).is_err());
+        assert!(board.blocked( &player, 28).is_err());
         Ok(())
     }
 
     #[test]
-    fn blocked_player1() -> Result<(), Error> {
+    fn blocked_otherplayer() -> Result<(), Error> {
         let board = Board::new();
-        assert!(board.blocked(
-            &Player {
-                name: "".into(),
-                color: Color::Black,
-                holes: 0,
-                points: 0,
-                can_bredouille: true,
-                can_big_bredouille: true
-            },
-            0
-        )?);
+        let player = Player::new("".into(), Color::White);
+        assert!(board.blocked( &player, 24)?);
         Ok(())
     }
 
     #[test]
-    fn blocked_player0_a() -> Result<(), Error> {
-        let mut board = Board::new();
-        board.set(
-            &Player {
-                name: "".into(),
-                color: Color::Black,
-                holes: 0,
-                points: 0,
-                can_bredouille: true,
-                can_big_bredouille: true
-            },
-            1,
-            2,
-        )?;
-        assert!(board.blocked(
-            &Player {
-                name: "".into(),
-                color: Color::White,
-                holes: 0,
-                points: 0,
-                can_bredouille: true,
-                can_big_bredouille: true
-            },
-            22
-        )?);
-        Ok(())
-    }
-
-    #[test]
-    fn blocked_player1_a() -> Result<(), Error> {
-        let mut board = Board::new();
-        board.set(
-            &Player {
-                name: "".into(),
-                color: Color::White,
-                holes: 0,
-                points: 0,
-                can_bredouille: true,
-                can_big_bredouille: true
-            },
-            1,
-            2,
-        )?;
-        assert!(board.blocked(
-            &Player {
-                name: "".into(),
-                color: Color::Black,
-                holes: 0,
-                points: 0,
-                can_bredouille: true,
-                can_big_bredouille: true
-            },
-            22
-        )?);
-        Ok(())
-    }
-
-    #[test]
-    fn blocked_invalid_field() {
+    fn blocked_notblocked() -> Result<(), Error> {
         let board = Board::new();
-        assert!(board
-            .blocked(
-                &Player {
-                    name: "".into(),
-                    color: Color::White,
-                    holes: 0,
-                    points: 0,
-                    can_bredouille: true,
-                    can_big_bredouille: true
-                },
-                24
-            )
-            .is_err());
+        let player = Player::new("".into(), Color::White);
+        assert!(!board.blocked( &player, 6)?);
+        Ok(())
     }
 
+
     #[test]
     fn set_field_blocked() {
         let mut board = Board::new();
-        assert!(board
-            .set(
-                &Player {
-                    name: "".into(),
-                    color: Color::White,
-                holes: 0,
-                points: 0,
-                can_bredouille: true,
-                can_big_bredouille: true
-                },
-                0,
-                2
-            )
-            .is_err());
+        let player = Player::new("".into(), Color::White);
+        assert!(
+            board.set( &player, 0, 24)
+            .is_err()
+            );
     }
 
     #[test]
     fn set_wrong_field1() {
         let mut board = Board::new();
+        let player = Player::new("".into(), Color::White);
         assert!(board
-            .set(
-                &Player {
-                    name: "".into(),
-                    color: Color::White,
-                holes: 0,
-                points: 0,
-                can_bredouille: true,
-                can_big_bredouille: true
-                },
-                50,
-                2
-            )
+            .set( &player, 50, 2)
             .is_err());
     }
 
     #[test]
     fn set_wrong_amount0() {
         let mut board = Board::new();
+        let player = Player::new("".into(), Color::White);
         assert!(board
-            .set(
-                &Player {
-                    name: "".into(),
-                    color: Color::White,
-                holes: 0,
-                points: 0,
-                can_bredouille: true,
-                can_big_bredouille: true
-                },
-                23,
-                -3
-            )
+            .set(&player , 23, -3)
             .is_err());
     }
 
     #[test]
     fn set_wrong_amount1() {
         let mut board = Board::new();
+        let player = Player::new("".into(), Color::White);
         assert!(board
-            .set(
-                &Player {
-                    name: "".into(),
-                    color: Color::Black,
-                holes: 0,
-                points: 0,
-                can_bredouille: true,
-                can_big_bredouille: true
-                },
-                23,
-                -3
-            )
+            .set( &player, 23, -3)
             .is_err());
     }
 }