feat(backend): game engine #1

+83

CLAUDE.md

reviewed

··· 1 1 + # CLAUDE.md 2 2 + 3 3 + This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. 4 4 + 5 5 + ## Project 6 6 + 7 7 + A turn-based management game with a card-based UI, playable in a web browser. The player runs a citizen-managed football (soccer) club rebuilt from bankruptcy. 8 8 + 9 9 + ### Lore 10 10 + 11 11 + The club was driven into bankruptcy by its previous owner, a predatory financier obsessed with his own legacy. A citizen collective bought the name and crest from the commercial court. The player is the **general secretary**, elected by the collective. The club has been demoted to the lower divisions and must rebuild — but **the goal is to endure**, not to climb back to the top flight. The score is the number of turns survived. 12 12 + 13 13 + ### Current scope (engine) 14 14 + 15 15 + - Three gauges: `money`, `internal_support`, `mental_load`. 16 16 + - Game over: `money <= 0`, `internal_support <= 0`, or `mental_load >= 100`. 17 17 + - Turn-based, solo. One action played per turn. 18 18 + - Card-based actions. Hand of 3, draws 1 at the start of each turn → player picks 1 of 4. 19 19 + - Action effects are deterministic for now (no randomness on outcomes). 20 20 + 21 21 + ### Planned (not implemented yet) 22 22 + 23 23 + - Per-turn events with 3 player choices. 24 24 + - Match results affecting gauges. 25 25 + - Multiple teams (pro, youth, women's, solidarity squads). 26 26 + - More divisions, deeper club structure (academies, partnerships). 27 27 + 28 28 + This is a learning project — the user is discovering game development, Rust, and Svelte simultaneously. Prioritize explanations and trade-offs over raw code output. 29 29 + 30 30 + ## Learning mode (important) 31 31 + 32 32 + This is a learning project. Do NOT write implementation code on the user's behalf when they could learn by writing it themselves. Instead, leverage the Learning output style to orient them: explain concepts, compare trade-offs, point at the relevant patterns, and use the "Learn by Doing" request format to hand off meaningful code decisions. Scaffolding, configuration, and boilerplate are fair game to write directly — but core logic (game engine, state transitions, business rules, component architecture) should come from the user, with Claude guiding. 33 33 + 34 34 + ## Architecture 35 35 + 36 36 + - **`backend/`** — Rust (Axum + SQLx + Tokio). Serves the game API and owns the game state machine. Game state is stored as JSONB in PostgreSQL. 37 37 + - **`frontend/`** — Svelte 5 + TypeScript SPA (Vite, no SvelteKit). Communicates with the backend via REST. 38 38 + - **`infra/`** — Kubernetes manifests (deployment target). Not used for local dev. 39 39 + - **`docker-compose.yml`** — Local dev: PostgreSQL 17 only. 40 40 + 41 41 + ## Development 42 42 + 43 43 + ### Prerequisites 44 44 + - Rust toolchain, Node.js, Docker 45 45 + - `cargo install sqlx-cli --no-default-features --features postgres` 46 46 + 47 47 + ### Start local environment 48 48 + ```bash 49 49 + docker compose up -d # PostgreSQL 50 50 + cd backend && cargo run # API on :3000 (runs migrations automatically) 51 51 + cd frontend && npm run dev # Svelte dev server 52 52 + ``` 53 53 + 54 54 + ### Backend commands (from `backend/`) 55 55 + ```bash 56 56 + cargo run # build + run (migrations auto-applied) 57 57 + cargo build # compile only 58 58 + cargo sqlx prepare # generate offline query metadata for CI builds 59 59 + RUST_LOG=tower_http=debug cargo run # verbose HTTP request logging 60 60 + ``` 61 61 + 62 62 + ### Frontend commands (from `frontend/`) 63 63 + ```bash 64 64 + npm run dev # vite dev server with HMR 65 65 + npm run build # production build 66 66 + npm run check # svelte-check + tsc type checking 67 67 + ``` 68 68 + 69 69 + ### Database 70 70 + ```bash 71 71 + sqlx database create # create the dyfc database 72 72 + sqlx migrate run # apply migrations (also done on cargo run) 73 73 + docker compose down -v # full DB reset (destroys volume) 74 74 + ``` 75 75 + 76 76 + ### SQLx compile-time checking 77 77 + SQLx macros (`query!`, `query_scalar!`) verify SQL against the live database at compile time. PostgreSQL must be running and migrations applied before `cargo build` will succeed. Set `SQLX_OFFLINE=true` to build against cached metadata instead (run `cargo sqlx prepare` first). 78 78 + 79 79 + ## Key conventions 80 80 + 81 81 + - Backend environment variables live in `backend/.env` (loaded by dotenvy). Required: `DATABASE_URL`, `RUST_LOG`. 82 82 + - SQL migrations go in `backend/migrations/` with numeric prefix ordering. 83 83 + - Game state is serialized as a single JSONB column via serde. The game engine logic (state machine) should remain pure — no HTTP or DB concerns — for testability.

+6

backend/archi.md

reviewed

··· 1 1 + src/ 2 2 + main.rs # HTTP + DB glue 3 3 + game/ 4 4 + mod.rs # re-exports 5 5 + state.rs # GameState, Gauges, GameStatus 6 6 + action.rs # Action, GaugeDelta, apply_action

+162

backend/src/game/action.rs

reviewed

··· 1 1 + use std::collections::HashMap; 2 2 + 3 3 + use serde::{Deserialize, Serialize}; 4 4 + 5 5 + use crate::game::{GameState, GameStatus, Gauges}; 6 6 + 7 7 + #[derive(Default, PartialEq, Serialize, Deserialize, Debug, Clone)] 8 8 + #[serde(deny_unknown_fields)] 9 9 + pub struct GaugeDelta { 10 10 + pub money: i32, 11 11 + pub internal_support: i32, 12 12 + pub mental_load: i32, 13 13 + } 14 14 + 15 15 + #[derive(Debug, Serialize, Deserialize, Clone)] 16 16 + #[serde(deny_unknown_fields)] 17 17 + pub struct Action { 18 18 + pub id: String, 19 19 + pub label: String, 20 20 + pub effect: GaugeDelta, 21 21 + } 22 22 + 23 23 + #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)] 24 24 + pub enum GameError { 25 25 + GameOver, 26 26 + CardNotInHand, 27 27 + CardNotInGame, 28 28 + } 29 29 + 30 30 + pub fn apply_action( 31 31 + game_state: &GameState, 32 32 + action_id: &str, 33 33 + catalog: &HashMap<String, Action>, 34 34 + ) -> Result<GameState, GameError> { 35 35 + if game_state.status != GameStatus::Running { 36 36 + return Err(GameError::GameOver); 37 37 + } 38 38 + 39 39 + if game_state.hand.iter().any(|id| id == action_id) { 40 40 + let action = catalog.get(action_id).ok_or(GameError::CardNotInGame)?; 41 41 + let next_gauges = Gauges { 42 42 + money: game_state.gauges.money + action.effect.money, 43 43 + mental_load: game_state.gauges.mental_load + action.effect.mental_load, 44 44 + internal_support: game_state.gauges.internal_support + action.effect.internal_support, 45 45 + }; 46 46 + 47 47 + let next_game_status = GameStatus::from_gauges(next_gauges); 48 48 + 49 49 + let mut next_deck = game_state.deck.clone(); 50 50 + 51 51 + let mut next_hand = game_state 52 52 + .hand 53 53 + .iter() 54 54 + .filter(|id| id != &action_id) 55 55 + .cloned() 56 56 + .collect::<Vec<_>>(); 57 57 + 58 58 + match next_deck.pop() { 59 59 + Some(id) => { 60 60 + next_hand.push(id); 61 61 + } 62 62 + None => { 63 63 + // When the deck is empty refills it with the catalog minus the current hand 64 64 + let available: Vec<String> = catalog 65 65 + .keys() 66 66 + .filter(|id| !next_hand.contains(id)) 67 67 + .cloned() 68 68 + .collect(); 69 69 + next_deck = GameState::fresh_deck(&available); 70 70 + // fresh_deck panics if ids is empty so it garantise next_deck.pop() has a Some 71 71 + next_hand.push(next_deck.pop().unwrap()); 72 72 + } 73 73 + } 74 74 + 75 75 + Ok(GameState { 76 76 + turn: game_state.turn + 1, 77 77 + gauges: next_gauges, 78 78 + status: next_game_status, 79 79 + hand: next_hand, 80 80 + deck: next_deck, 81 81 + }) 82 82 + } else { 83 83 + Err(GameError::CardNotInHand) 84 84 + } 85 85 + } 86 86 + 87 87 + #[cfg(test)] 88 88 + mod tests { 89 89 + use crate::game::{GameOverReason, default_catalog, state::HAND_SIZE}; 90 90 + 91 91 + use super::*; 92 92 + 93 93 + #[test] 94 94 + fn test_apply_action_new_game() { 95 95 + let catalog = default_catalog(); 96 96 + let ids = catalog.keys().cloned().collect::<Vec<_>>(); 97 97 + let new_game = GameState::new(&ids); 98 98 + let next_action_id = new_game.hand[0].clone(); 99 99 + let next_game_state = apply_action(&new_game, &next_action_id, &catalog).unwrap(); 100 100 + assert_eq!(next_game_state.turn, 2); 101 101 + } 102 102 + 103 103 + #[test] 104 104 + fn test_apply_action_new_turn() { 105 105 + let catalog = default_catalog(); 106 106 + let ids = catalog.keys().cloned().collect::<Vec<_>>(); 107 107 + let new_game = GameState::new(&ids); 108 108 + let next_action_id = new_game.hand[0].clone(); 109 109 + let next_game_state = apply_action(&new_game, &next_action_id, &catalog).unwrap(); 110 110 + assert_eq!(next_game_state.turn, 2); 111 111 + assert_eq!(next_game_state.hand.len(), HAND_SIZE); 112 112 + assert_eq!(new_game.deck.len(), ids.len() - HAND_SIZE); 113 113 + assert!(next_game_state.hand.iter().all(|id| !id.is_empty())); 114 114 + } 115 115 + 116 116 + #[test] 117 117 + fn test_apply_action_reset_deck_when_empty() { 118 118 + let catalog = default_catalog(); 119 119 + let ids = catalog.keys().cloned().take(1).collect::<Vec<_>>(); 120 120 + let new_game = GameState::new(&ids); 121 121 + let next_action_id = new_game.hand[0].clone(); 122 122 + let next_game_state = apply_action(&new_game, &next_action_id, &catalog).unwrap(); 123 123 + assert_eq!(next_game_state.turn, 2); 124 124 + assert_eq!(next_game_state.hand.len(), 1); 125 125 + // All the catalog minus the action just played. 126 126 + assert_eq!(next_game_state.deck.len(), catalog.len() - 1); 127 127 + } 128 128 + 129 129 + #[test] 130 130 + fn test_apply_action_game_over() { 131 131 + let action_id = String::from("test_action"); 132 132 + let action = Action { 133 133 + id: action_id.clone(), 134 134 + label: String::from("Test action"), 135 135 + effect: GaugeDelta { 136 136 + money: 0, 137 137 + internal_support: -1, 138 138 + mental_load: 0, 139 139 + }, 140 140 + }; 141 141 + let mut catalog = default_catalog(); 142 142 + catalog.insert(action_id.clone(), action); 143 143 + let mut new_game = GameState { 144 144 + turn: 1, 145 145 + status: GameStatus::Running, 146 146 + gauges: Gauges { 147 147 + mental_load: 1, 148 148 + money: 50, 149 149 + internal_support: 1, 150 150 + }, 151 151 + hand: Vec::new(), 152 152 + deck: Vec::new(), 153 153 + }; 154 154 + // Manually add the cart into the hand 155 155 + new_game.hand.push(action_id.clone()); 156 156 + let next_game_state = apply_action(&new_game, &action_id, &catalog).unwrap(); 157 157 + assert_eq!( 158 158 + next_game_state.status, 159 159 + GameStatus::Lost(GameOverReason::LostSupport) 160 160 + ); 161 161 + } 162 162 + }

+8

backend/src/game/mod.rs

reviewed

··· 1 1 + pub mod state; 2 2 + pub use state::{GameOverReason, GameState, GameStatus, Gauges}; 3 3 + 4 4 + pub mod action; 5 5 + pub use action::{Action, GameError, GaugeDelta, apply_action}; 6 6 + 7 7 + pub mod catalog; 8 8 + pub use catalog::default_catalog;

+162

backend/src/game/state.rs

reviewed

··· 1 1 + use rand::rng; 2 2 + use rand::seq::SliceRandom; 3 3 + use serde::{Deserialize, Serialize}; 4 4 + 5 5 + pub const HAND_SIZE: usize = 3; 6 6 + 7 7 + #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)] 8 8 + pub struct Gauges { 9 9 + pub money: i32, 10 10 + pub internal_support: i32, 11 11 + pub mental_load: i32, 12 12 + } 13 13 + 14 14 + impl Gauges { 15 15 + pub fn starting() -> Self { 16 16 + Self { 17 17 + money: 1000, 18 18 + internal_support: 50, 19 19 + mental_load: 20, 20 20 + } 21 21 + } 22 22 + } 23 23 + 24 24 + #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)] 25 25 + #[serde(tag = "kind", content = "reason")] 26 26 + pub enum GameStatus { 27 27 + Running, 28 28 + Lost(GameOverReason), 29 29 + } 30 30 + 31 31 + #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)] 32 32 + pub enum GameOverReason { 33 33 + Bankruptcy, 34 34 + LostSupport, 35 35 + Burnout, 36 36 + } 37 37 + 38 38 + impl GameStatus { 39 39 + pub fn from_gauges(gauges: Gauges) -> Self { 40 40 + // Priorité en cas de cumul: support > burnout > bankruptcy 41 41 + if gauges.internal_support <= 0 { 42 42 + return GameStatus::Lost(GameOverReason::LostSupport); 43 43 + } 44 44 + if gauges.mental_load >= 100 { 45 45 + return GameStatus::Lost(GameOverReason::Burnout); 46 46 + } 47 47 + if gauges.money <= 0 { 48 48 + return GameStatus::Lost(GameOverReason::Bankruptcy); 49 49 + } 50 50 + GameStatus::Running 51 51 + } 52 52 + } 53 53 + 54 54 + #[derive(Debug, Clone, Serialize, Deserialize)] 55 55 + pub struct GameState { 56 56 + pub turn: u32, 57 57 + pub gauges: Gauges, 58 58 + pub status: GameStatus, 59 59 + pub hand: Vec<String>, 60 60 + pub deck: Vec<String>, 61 61 + } 62 62 + 63 63 + impl GameState { 64 64 + pub fn new(catalog_ids: &[String]) -> Self { 65 65 + let starting_gauges = Gauges::starting(); 66 66 + 67 67 + let mut deck = GameState::fresh_deck(&catalog_ids); 68 68 + 69 69 + let hand: Vec<String> = deck.drain(0..HAND_SIZE.min(deck.len())).collect(); 70 70 + 71 71 + Self { 72 72 + turn: 1, 73 73 + gauges: starting_gauges, 74 74 + status: GameStatus::from_gauges(starting_gauges), 75 75 + deck, 76 76 + hand, 77 77 + } 78 78 + } 79 79 + 80 80 + pub fn fresh_deck(catalog_ids: &[String]) -> Vec<String> { 81 81 + if catalog_ids.is_empty() { 82 82 + panic!("Catalog must not be empty."); 83 83 + } 84 84 + let mut deck = catalog_ids.to_vec(); 85 85 + deck.shuffle(&mut rng()); 86 86 + deck 87 87 + } 88 88 + } 89 89 + 90 90 + #[cfg(test)] 91 91 + mod tests { 92 92 + use super::*; 93 93 + 94 94 + #[test] 95 95 + fn game_status_from_gauges() { 96 96 + let game_status = GameStatus::from_gauges(Gauges::starting()); 97 97 + assert_eq!(game_status, GameStatus::Running); 98 98 + 99 99 + assert_eq!( 100 100 + GameStatus::from_gauges(Gauges { 101 101 + money: 1, 102 102 + internal_support: 1, 103 103 + mental_load: 99 104 104 + }), 105 105 + GameStatus::Running 106 106 + ); 107 107 + 108 108 + assert_eq!( 109 109 + GameStatus::from_gauges(Gauges { 110 110 + money: 0, 111 111 + internal_support: 1, 112 112 + mental_load: 99 113 113 + }), 114 114 + GameStatus::Lost(GameOverReason::Bankruptcy) 115 115 + ); 116 116 + 117 117 + assert_eq!( 118 118 + GameStatus::from_gauges(Gauges { 119 119 + money: 1, 120 120 + internal_support: 0, 121 121 + mental_load: 99 122 122 + }), 123 123 + GameStatus::Lost(GameOverReason::LostSupport) 124 124 + ); 125 125 + 126 126 + assert_eq!( 127 127 + GameStatus::from_gauges(Gauges { 128 128 + money: 1, 129 129 + internal_support: 1, 130 130 + mental_load: 100 131 131 + }), 132 132 + GameStatus::Lost(GameOverReason::Burnout) 133 133 + ); 134 134 + 135 135 + assert_eq!( 136 136 + GameStatus::from_gauges(Gauges { 137 137 + money: 1, 138 138 + internal_support: 0, 139 139 + mental_load: 100 140 140 + }), 141 141 + GameStatus::Lost(GameOverReason::LostSupport) 142 142 + ); 143 143 + 144 144 + assert_eq!( 145 145 + GameStatus::from_gauges(Gauges { 146 146 + money: 0, 147 147 + internal_support: 1, 148 148 + mental_load: 100 149 149 + }), 150 150 + GameStatus::Lost(GameOverReason::Burnout) 151 151 + ); 152 152 + 153 153 + assert_eq!( 154 154 + GameStatus::from_gauges(Gauges { 155 155 + money: 0, 156 156 + internal_support: 0, 157 157 + mental_load: 100 158 158 + }), 159 159 + GameStatus::Lost(GameOverReason::LostSupport) 160 160 + ); 161 161 + } 162 162 + }

+214

todo.md

reviewed

··· 1 1 + # TODO — Moteur de jeu (première itération) 2 2 + 3 3 + Suivi de ce qu'il reste à implémenter pour avoir un moteur de jeu minimal: 4 4 + jauges + action simple, vérifiable par `cargo check` puis testable via l'API. 5 5 + 6 6 + --- 7 7 + 8 8 + ## 1. Créer la structure du module `game` 9 9 + 10 10 + - [x] Créer le dossier `backend/src/game/`. 11 11 + - [x] Créer `backend/src/game/mod.rs` — déclare les sous-modules (`pub mod state;`, 12 12 + `pub mod action;`) et re-exporte les types publics (`pub use state::...;`). 13 13 + - [x] Ajouter `mod game;` au début de `backend/src/main.rs` pour que le compilateur 14 14 + découvre le module. 15 15 + 16 16 + ## 2. Définir les types d'état (`backend/src/game/state.rs`) 17 17 + 18 18 + - [x] `Gauges` — struct avec `money: i32`, `internal_support: i32`, `mental_load: i32`. 19 19 + Dérive `Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq`. 20 20 + - [x] `Gauges::starting()` — valeurs de départ (`money: 1000`, `internal_support: 50`, 21 21 + `mental_load: 20`). 22 22 + - [x] `GameOverReason` — enum unitaire: `Bankruptcy`, `LostSupport`, `Burnout`. 23 23 + - [ ] `GameStatus` — enum: `Running` | `Lost(GameOverReason)`. Utiliser 24 24 + `#[serde(tag = "kind", content = "reason")]` pour un JSON propre. 25 25 + - [x] `GameState` — struct: `turn: u32`, `gauges: Gauges`, `status: GameStatus`. 26 26 + - [x] `GameState::new()` — construit l'état initial en utilisant `Gauges::starting()` 27 27 + et `GameStatus::from_gauges(...)`. 28 28 + 29 29 + ## 3. Règle de fin de partie (`backend/src/game/state.rs`) 30 30 + 31 31 + - [x] `GameStatus::from_gauges(Gauges) -> GameStatus`. 32 32 + - `money <= 0` → `Lost(Bankruptcy)` 33 33 + - `internal_support <= 0` → `Lost(LostSupport)` 34 34 + - `mental_load >= 100` → `Lost(Burnout)` 35 35 + - sinon → `Running` 36 36 + - Attention: inégalités strictes côté règles (`0` et `100` sont déjà perdants). 37 37 + - Décision à faire: ordre de priorité si plusieurs conditions sont vraies en même temps. 38 38 + 39 39 + ## 4. Actions et transition (`backend/src/game/action.rs`) 40 40 + 41 41 + - [x] `GaugeDelta` — même forme que `Gauges`. Dérive `Default` pour construire avec 42 42 + `..Default::default()`. 43 43 + - [x] `Action` — struct: `id: String`, `label: String`, `effect: GaugeDelta`. 44 44 + - [x] `GameError` — enum avec au moins `GameOver` pour l'instant. 45 45 + - [x] `apply_action(&GameState, &Action) -> Result<GameState, GameError>`. 46 46 + - Si `state.status` n'est pas `Running` → `Err(GameOver)`. 47 47 + - Sinon: additionner `effect` à `gauges`, `turn + 1`, recalculer `status`. 48 48 + - Cœur de la boucle de jeu — état immuable en entrée, nouvel état en sortie. 49 49 + 50 50 + ## 5. Câblage dans `main.rs` 51 51 + 52 52 + - [x] Supprimer les anciens `struct GameState` et `struct Resources` (placeholders 53 53 + `gold/food/population`) devenus obsolètes. 54 54 + - [x] Adapter `create_game` pour utiliser le nouveau `game::GameState::new()`. 55 55 + - [ ] Vérifier que `cargo build` passe (SQLx a besoin de Postgres lancé). 56 56 + 57 57 + ## 6. Tests unitaires (optionnel mais recommandé) 58 58 + 59 59 + - [x] Dans `state.rs`, module `#[cfg(test)]` qui vérifie `from_gauges` sur chaque 60 60 + condition de fin + cas de coexistence (money ET support à 0 en même temps). 61 61 + - [x] Dans `action.rs`, test qui applique une action et vérifie le nouvel état 62 62 + (gauges, turn, status). 63 63 + 64 64 + --- 65 65 + 66 66 + # Phase 2 — Boucle d'actions HTTP (cartes en main) 67 67 + 68 68 + Objectif: jouable de bout en bout depuis un client HTTP. Le joueur démarre avec 69 69 + 3 cartes en main, pioche 1 au début de chaque tour, joue 1 parmi 4. 70 70 + 71 71 + ## 7. Catalogue d'actions 72 72 + 73 73 + - [x] `src/game/catalog.rs` créé par Claude (10 actions thématiques). 74 74 + - [x] Déclarer `pub mod catalog;` dans `mod.rs` et re-exporter `default_catalog`. 75 75 + - [x] Vérifier que ça compile (`cargo check`) — révèlera probablement les 76 76 + éléments à corriger ci-dessous. 77 77 + 78 78 + ## 8. Finir la "publication" d'`Action` 79 79 + 80 80 + `catalog.rs` construit des `Action { id, label, effect }` directement → les 81 81 + champs doivent être `pub` (idem pour `GaugeDelta`). Sinon erreur "field is 82 82 + private". 83 83 + 84 84 + - [x] `pub` sur les champs d'`Action`. 85 85 + - [x] Vérifier que `GaugeDelta` a aussi tous ses champs en `pub`. 86 86 + 87 87 + ## 9. Sérialisation d'`Action` et `GaugeDelta` 88 88 + 89 89 + - [x] Dériver `Serialize, Deserialize, Clone, Debug, PartialEq` sur les deux. 90 90 + - [x] Ajouter `#[serde(deny_unknown_fields)]` sur les deux. (Ces types 91 91 + ne sont jamais persistés en JSONB — uniquement reçus en requête, 92 92 + donc on peut être strict.) 93 93 + 94 94 + ## 10. Mécanique de main et pioche dans `GameState` 95 95 + 96 96 + Le cœur de la phase 2. Décision d'architecture à prendre: 97 97 + 98 98 + **Question A — quoi stocker dans la main?** 99 99 + - (a) `hand: Vec<String>` (ids d'actions, on relie au catalogue à la lecture). 100 100 + - (b) `hand: Vec<Action>` (actions complètes dupliquées dans le state). 101 101 + 102 102 + → Reco: **(a)**. Plus léger, plus cohérent (le catalogue reste source unique 103 103 + de vérité). Coût: chaque lecture du JSONB doit "hydrater" les ids depuis le 104 104 + catalogue avant de répondre — pas grave. 105 105 + 106 106 + **Question B — gérer un discard pile ou pas?** 107 107 + - (a) `deck: Vec<String>` + `discard: Vec<String>`, on reshuffle quand le 108 108 + deck est vide. 109 109 + - (b) Juste `deck: Vec<String>`, les cartes jouées sont consommées; partie 110 110 + perdue par épuisement du deck (ou règle alternative). 111 111 + 112 112 + → Reco: **(b)** pour démarrer. Tu pourras ajouter un discard plus tard quand 113 113 + ça aura un sens gameplay (ex: certaines cartes "se recyclent", d'autres pas). 114 114 + 115 115 + À implémenter: 116 116 + - [x] Étendre `GameState` avec `hand: Vec<String>` et `deck: Vec<String>`. 117 117 + - [x] Constante (ou fonction) `HAND_SIZE: usize = 3`. 118 118 + - [x] `GameState::new(catalog_ids: &[String])` — prend la liste des ids 119 119 + disponibles, les mélange dans le deck, pioche `HAND_SIZE` dans la main. 120 120 + Note: `GameState::new` doit rester un constructeur **pur** (pas de 121 121 + dépendance HTTP/DB). Lui passer la liste d'ids est plus propre que 122 122 + lui passer la `HashMap` du catalogue. 123 123 + - [x] Ajouter la dépendance `rand` à `Cargo.toml` (`rand = "0.8"` ou récent) 124 124 + pour `SliceRandom::shuffle`. 125 125 + 126 126 + ## 11. Étendre `apply_action` 127 127 + 128 128 + L'API change. Nouvelle signature à débattre: 129 129 + 130 130 + ```rust 131 131 + pub fn apply_action( 132 132 + state: &GameState, 133 133 + action_id: &str, 134 134 + catalog: &HashMap<String, Action>, 135 135 + ) -> Result<GameState, GameError> 136 136 + ``` 137 137 + 138 138 + Logique: 139 139 + 1. Vérifier `status == Running` (existant). 140 140 + 2. Vérifier que `action_id` est dans `state.hand` → sinon 141 141 + `Err(GameError::CardNotInHand)`. 142 142 + 3. Récupérer l'`Action` depuis le catalogue → sinon `UnknownAction`. 143 143 + 4. Retirer la carte jouée de la main. 144 144 + 5. Piocher la prochaine carte du deck (si vide → décision: continuer sans 145 145 + pioche? `Err(GameError::DeckEmpty)`? À toi de trancher pour la sensation 146 146 + de jeu). 147 147 + 6. Appliquer l'effet, incrémenter le tour, recalculer le status. 148 148 + 149 149 + - [x] Étendre `GameError` avec les nouvelles variantes (`CardNotInHand`, 150 150 + `UnknownAction`, et éventuellement `DeckEmpty`). 151 151 + - [x] Mettre à jour les tests unitaires existants (signature changée). 152 152 + 153 153 + ## 12. `AppState` partage le catalogue 154 154 + 155 155 + Actuellement `AppState` n'a que `db`. Le handler HTTP aura besoin du 156 156 + catalogue. Comme `AppState` est cloné à chaque requête, il faut éviter de 157 157 + cloner la `HashMap` à chaque fois. 158 158 + 159 159 + - [x] Ajouter `catalog: Arc<HashMap<String, Action>>` à `AppState`. 160 160 + - [x] Dans `main`, construire le catalogue une fois et l'envelopper dans 161 161 + `Arc::new(...)` avant de le passer à `AppState`. 162 162 + 163 163 + ## 13. Étendre `AppError` 164 164 + 165 165 + Pour mapper `GameError` vers du HTTP: 166 166 + 167 167 + - [x] Ajouter au moins `BadRequest(String)` (→ 400) et `Conflict(String)` 168 168 + (→ 409, pour les erreurs de règle comme `GameOver`/`CardNotInHand`). 169 169 + - [x] Implémenter `From<GameError> for AppError` — choix: lesquelles 170 170 + mappent vers 400 vs 409 vs 422? (`GameOver` = 409 conflict, le client 171 171 + ne peut plus jouer; `UnknownAction` = 400 bad input; etc.) 172 172 + 173 173 + ## 14. Handler `POST /games/{id}/actions` 174 174 + 175 175 + - [x] Définir un type `PlayActionRequest { action_id: String }` avec 176 176 + `Deserialize` et `deny_unknown_fields`. 177 177 + - [x] Handler async: 178 178 + 1. Charger la ligne `games` par id (`fetch_optional` → 404 si absent). 179 179 + 2. Désérialiser le `state` JSONB en `GameState`. 180 180 + 3. Appeler `apply_action(&game_state, &body.action_id, &state.catalog)`. 181 181 + 4. Sérialiser le nouvel état. 182 182 + 5. `UPDATE games SET state = $1, updated_at = NOW() WHERE id = $2`. 183 183 + 6. Retourner le nouvel état en JSON. 184 184 + - [x] Enregistrer la route: `.route("/games/{id}/actions", post(...))`. 185 185 + 186 186 + Pas de transaction pour l'instant (jeu solo, on accepte le risque de race). 187 187 + À durcir plus tard avec `pool.begin()` + `SELECT ... FOR UPDATE`. 188 188 + 189 189 + ## 15. Mettre à jour `create_game` 190 190 + 191 191 + - [x] `GameState::new(...)` prend maintenant la liste d'ids du catalogue. 192 192 + Récupérer `state.catalog.keys()` et les passer. 193 193 + - [x] La réponse renvoie le nouvel état (avec `hand` peuplée) — le frontend 194 194 + verra ses 3 cartes initiales. 195 195 + 196 196 + ## 16. Test bout en bout (manuel) 197 197 + 198 198 + - [ ] `curl -X POST localhost:3000/games` → noter l'`id` et regarder la `hand`. 199 199 + - [ ] `curl -X POST localhost:3000/games/{id}/actions -d '{"action_id":"..."}'` 200 200 + avec un id de la main → vérifier que le nouvel état revient avec une 201 201 + main rafraîchie et un tour incrémenté. 202 202 + - [ ] Tenter une action_id qui n'est pas dans la main → 409. 203 203 + - [ ] Tenter une action_id inexistante → 400. 204 204 + 205 205 + --- 206 206 + 207 207 + ## Plus tard (toujours hors scope) 208 208 + 209 209 + - Système d'événements (3 choix par tour, tirés d'un pool d'événements). 210 210 + - Résultats de matchs (équipes pro/jeunes/féminines/solidaires) et leur 211 211 + influence sur les jauges. 212 212 + - Persistence du nombre de tours survécus comme score. 213 213 + - Concurrence: `SELECT ... FOR UPDATE` dans une transaction. 214 214 + - Système de discard / recyclage de cartes.

+272 -20

backend/Cargo.lock

reviewed

··· 48 48 49 49 50 50 51 51 + checksum = "31b698c5f9a010f6573133b09e0de5408834d0c82f8d7475a89fc1867a71cd90" 52 52 + dependencies = [ 53 53 + "axum-core", 54 54 + "axum-macros", 55 55 + "bytes", 56 56 + "form_urlencoded", 57 57 + "futures-util", 51 58 52 59 53 60 ··· 87 94 88 95 89 96 97 97 + "tracing", 98 98 + ] 90 99 100 100 + [[package]] 101 101 + name = "axum-macros" 102 102 + version = "0.5.1" 103 103 + source = "registry+https://github.com/rust-lang/crates.io-index" 104 104 + checksum = "7aa268c23bfbbd2c4363b9cd302a4f504fb2a9dfe7e3451d66f35dd392e20aca" 105 105 + dependencies = [ 106 106 + "proc-macro2", 107 107 + "quote", 108 108 + "syn", 109 109 + ] 91 110 92 92 - 93 93 - 94 94 - 95 95 - 96 96 - 97 97 - 98 98 - 99 99 - 100 100 - 101 101 - 111 111 + [[package]] 112 112 + name = "backend" 113 113 + version = "0.1.0" 102 114 103 115 "anyhow", 104 116 "axum", 105 117 "dotenvy", 118 118 + "rand 0.10.1", 106 119 "serde", 107 120 "serde_json", 108 121 "sqlx", ··· 161 174 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" 162 175 163 176 [[package]] 177 177 + name = "chacha20" 178 178 + version = "0.10.0" 179 179 + source = "registry+https://github.com/rust-lang/crates.io-index" 180 180 + checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601" 181 181 + dependencies = [ 182 182 + "cfg-if", 183 183 + "cpufeatures 0.3.0", 184 184 + "rand_core 0.10.1", 185 185 + ] 186 186 + 187 187 + [[package]] 164 188 name = "concurrent-queue" 165 189 version = "2.5.0" 166 190 ··· 185 209 ] 186 210 187 211 [[package]] 212 212 + name = "cpufeatures" 213 213 + version = "0.3.0" 214 214 + source = "registry+https://github.com/rust-lang/crates.io-index" 215 215 + checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201" 216 216 + dependencies = [ 217 217 + "libc", 218 218 + ] 219 219 + 220 220 + [[package]] 188 221 name = "crc" 189 222 version = "3.4.0" 190 223 ··· 430 463 ] 431 464 432 465 [[package]] 466 466 + name = "getrandom" 467 467 + version = "0.4.2" 468 468 + source = "registry+https://github.com/rust-lang/crates.io-index" 469 469 + checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" 470 470 + dependencies = [ 471 471 + "cfg-if", 472 472 + "libc", 473 473 + "r-efi", 474 474 + "rand_core 0.10.1", 475 475 + "wasip2", 476 476 + "wasip3", 477 477 + ] 478 478 + 479 479 + [[package]] 433 480 name = "hashbrown" 434 481 version = "0.15.5" 435 482 ··· 657 704 ] 658 705 659 706 [[package]] 707 707 + name = "id-arena" 708 708 + version = "2.3.0" 709 709 + source = "registry+https://github.com/rust-lang/crates.io-index" 710 710 + checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" 711 711 + 712 712 + [[package]] 660 713 name = "idna" 661 714 version = "1.1.0" 662 715 ··· 685 738 dependencies = [ 686 739 "equivalent", 687 740 "hashbrown 0.17.0", 741 741 + "serde", 742 742 + "serde_core", 688 743 ] 689 744 690 745 [[package]] ··· 703 758 ] 704 759 705 760 [[package]] 761 761 + name = "leb128fmt" 762 762 + version = "0.1.0" 763 763 + source = "registry+https://github.com/rust-lang/crates.io-index" 764 764 + checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" 765 765 + 766 766 + [[package]] 706 767 name = "libc" 707 768 version = "0.2.185" 708 769 ··· 825 886 "num-integer", 826 887 "num-iter", 827 888 "num-traits", 828 828 - "rand", 889 889 + "rand 0.8.6", 829 890 "smallvec", 830 891 "zeroize", 831 892 ] ··· 968 1029 ] 969 1030 970 1031 [[package]] 1032 1032 + name = "prettyplease" 1033 1033 + version = "0.2.37" 1034 1034 + source = "registry+https://github.com/rust-lang/crates.io-index" 1035 1035 + checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" 1036 1036 + dependencies = [ 1037 1037 + "proc-macro2", 1038 1038 + "syn", 1039 1039 + ] 1040 1040 + 1041 1041 + [[package]] 971 1042 name = "proc-macro2" 972 1043 version = "1.0.106" 973 1044 ··· 986 1057 ] 987 1058 988 1059 [[package]] 1060 1060 + name = "r-efi" 1061 1061 + version = "6.0.0" 1062 1062 + source = "registry+https://github.com/rust-lang/crates.io-index" 1063 1063 + checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" 1064 1064 + 1065 1065 + [[package]] 989 1066 name = "rand" 990 1067 version = "0.8.6" 991 1068 ··· 993 1070 dependencies = [ 994 1071 "libc", 995 1072 "rand_chacha", 996 996 - "rand_core", 1073 1073 + "rand_core 0.6.4", 1074 1074 + ] 1075 1075 + 1076 1076 + [[package]] 1077 1077 + name = "rand" 1078 1078 + version = "0.10.1" 1079 1079 + source = "registry+https://github.com/rust-lang/crates.io-index" 1080 1080 + checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207" 1081 1081 + dependencies = [ 1082 1082 + "chacha20", 1083 1083 + "getrandom 0.4.2", 1084 1084 + "rand_core 0.10.1", 997 1085 ] 998 1086 999 1087 [[package]] ··· 1003 1091 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" 1004 1092 dependencies = [ 1005 1093 "ppv-lite86", 1006 1006 - "rand_core", 1094 1094 + "rand_core 0.6.4", 1007 1095 ] 1008 1096 1009 1097 [[package]] ··· 1012 1100 source = "registry+https://github.com/rust-lang/crates.io-index" 1013 1101 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" 1014 1102 dependencies = [ 1015 1015 - "getrandom", 1103 1103 + "getrandom 0.2.17", 1016 1104 ] 1017 1105 1018 1106 [[package]] 1107 1107 + name = "rand_core" 1108 1108 + version = "0.10.1" 1109 1109 + source = "registry+https://github.com/rust-lang/crates.io-index" 1110 1110 + checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69" 1111 1111 + 1112 1112 + [[package]] 1019 1113 name = "redox_syscall" 1020 1114 version = "0.5.18" 1021 1115 ··· 1063 1157 "num-traits", 1064 1158 "pkcs1", 1065 1159 "pkcs8", 1066 1066 - "rand_core", 1160 1160 + "rand_core 0.6.4", 1067 1161 "signature", 1068 1162 "spki", 1069 1163 "subtle", ··· 1083 1177 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" 1084 1178 1085 1179 [[package]] 1180 1180 + name = "semver" 1181 1181 + version = "1.0.28" 1182 1182 + source = "registry+https://github.com/rust-lang/crates.io-index" 1183 1183 + checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" 1184 1184 + 1185 1185 + [[package]] 1086 1186 name = "serde" 1087 1187 version = "1.0.228" 1088 1188 ··· 1155 1255 checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" 1156 1256 dependencies = [ 1157 1257 "cfg-if", 1158 1158 - "cpufeatures", 1258 1258 + "cpufeatures 0.2.17", 1159 1259 "digest", 1160 1260 ] 1161 1261 ··· 1166 1266 checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" 1167 1267 dependencies = [ 1168 1268 "cfg-if", 1169 1169 - "cpufeatures", 1269 1269 + "cpufeatures 0.2.17", 1170 1270 "digest", 1171 1271 ] 1172 1272 ··· 1196 1296 checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" 1197 1297 dependencies = [ 1198 1298 "digest", 1199 1199 - "rand_core", 1299 1299 + "rand_core 0.6.4", 1200 1300 ] 1201 1301 1202 1302 [[package]] ··· 1357 1457 "memchr", 1358 1458 "once_cell", 1359 1459 "percent-encoding", 1360 1360 - "rand", 1460 1460 + "rand 0.8.6", 1361 1461 "rsa", 1362 1462 "serde", 1363 1463 "sha1", ··· 1395 1495 "md-5", 1396 1496 "memchr", 1397 1497 "once_cell", 1398 1398 - "rand", 1498 1498 + "rand 0.8.6", 1399 1499 "serde", 1400 1500 "serde_json", 1401 1501 "sha2", ··· 1715 1815 checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d" 1716 1816 1717 1817 [[package]] 1818 1818 + name = "unicode-xid" 1819 1819 + version = "0.2.6" 1820 1820 + source = "registry+https://github.com/rust-lang/crates.io-index" 1821 1821 + checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" 1822 1822 + 1823 1823 + [[package]] 1718 1824 name = "url" 1719 1825 version = "2.5.8" 1720 1826 ··· 1757 1863 checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" 1758 1864 1759 1865 [[package]] 1866 1866 + name = "wasip2" 1867 1867 + version = "1.0.3+wasi-0.2.9" 1868 1868 + source = "registry+https://github.com/rust-lang/crates.io-index" 1869 1869 + checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6" 1870 1870 + dependencies = [ 1871 1871 + "wit-bindgen 0.57.1", 1872 1872 + ] 1873 1873 + 1874 1874 + [[package]] 1875 1875 + name = "wasip3" 1876 1876 + version = "0.4.0+wasi-0.3.0-rc-2026-01-06" 1877 1877 + source = "registry+https://github.com/rust-lang/crates.io-index" 1878 1878 + checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" 1879 1879 + dependencies = [ 1880 1880 + "wit-bindgen 0.51.0", 1881 1881 + ] 1882 1882 + 1883 1883 + [[package]] 1760 1884 name = "wasite" 1761 1885 version = "0.1.0" 1762 1886 source = "registry+https://github.com/rust-lang/crates.io-index" 1763 1887 checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b" 1764 1888 1765 1889 [[package]] 1890 1890 + name = "wasm-encoder" 1891 1891 + version = "0.244.0" 1892 1892 + source = "registry+https://github.com/rust-lang/crates.io-index" 1893 1893 + checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" 1894 1894 + dependencies = [ 1895 1895 + "leb128fmt", 1896 1896 + "wasmparser", 1897 1897 + ] 1898 1898 + 1899 1899 + [[package]] 1900 1900 + name = "wasm-metadata" 1901 1901 + version = "0.244.0" 1902 1902 + source = "registry+https://github.com/rust-lang/crates.io-index" 1903 1903 + checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" 1904 1904 + dependencies = [ 1905 1905 + "anyhow", 1906 1906 + "indexmap", 1907 1907 + "wasm-encoder", 1908 1908 + "wasmparser", 1909 1909 + ] 1910 1910 + 1911 1911 + [[package]] 1912 1912 + name = "wasmparser" 1913 1913 + version = "0.244.0" 1914 1914 + source = "registry+https://github.com/rust-lang/crates.io-index" 1915 1915 + checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" 1916 1916 + dependencies = [ 1917 1917 + "bitflags", 1918 1918 + "hashbrown 0.15.5", 1919 1919 + "indexmap", 1920 1920 + "semver", 1921 1921 + ] 1922 1922 + 1923 1923 + [[package]] 1766 1924 name = "whoami" 1767 1925 version = "1.6.1" 1768 1926 ··· 1854 2012 checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" 1855 2013 1856 2014 [[package]] 2015 2015 + name = "wit-bindgen" 2016 2016 + version = "0.51.0" 2017 2017 + source = "registry+https://github.com/rust-lang/crates.io-index" 2018 2018 + checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" 2019 2019 + dependencies = [ 2020 2020 + "wit-bindgen-rust-macro", 2021 2021 + ] 2022 2022 + 2023 2023 + [[package]] 2024 2024 + name = "wit-bindgen" 2025 2025 + version = "0.57.1" 2026 2026 + source = "registry+https://github.com/rust-lang/crates.io-index" 2027 2027 + checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" 2028 2028 + 2029 2029 + [[package]] 2030 2030 + name = "wit-bindgen-core" 2031 2031 + version = "0.51.0" 2032 2032 + source = "registry+https://github.com/rust-lang/crates.io-index" 2033 2033 + checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" 2034 2034 + dependencies = [ 2035 2035 + "anyhow", 2036 2036 + "heck", 2037 2037 + "wit-parser", 2038 2038 + ] 2039 2039 + 2040 2040 + [[package]] 2041 2041 + name = "wit-bindgen-rust" 2042 2042 + version = "0.51.0" 2043 2043 + source = "registry+https://github.com/rust-lang/crates.io-index" 2044 2044 + checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" 2045 2045 + dependencies = [ 2046 2046 + "anyhow", 2047 2047 + "heck", 2048 2048 + "indexmap", 2049 2049 + "prettyplease", 2050 2050 + "syn", 2051 2051 + "wasm-metadata", 2052 2052 + "wit-bindgen-core", 2053 2053 + "wit-component", 2054 2054 + ] 2055 2055 + 2056 2056 + [[package]] 2057 2057 + name = "wit-bindgen-rust-macro" 2058 2058 + version = "0.51.0" 2059 2059 + source = "registry+https://github.com/rust-lang/crates.io-index" 2060 2060 + checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" 2061 2061 + dependencies = [ 2062 2062 + "anyhow", 2063 2063 + "prettyplease", 2064 2064 + "proc-macro2", 2065 2065 + "quote", 2066 2066 + "syn", 2067 2067 + "wit-bindgen-core", 2068 2068 + "wit-bindgen-rust", 2069 2069 + ] 2070 2070 + 2071 2071 + [[package]] 2072 2072 + name = "wit-component" 2073 2073 + version = "0.244.0" 2074 2074 + source = "registry+https://github.com/rust-lang/crates.io-index" 2075 2075 + checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" 2076 2076 + dependencies = [ 2077 2077 + "anyhow", 2078 2078 + "bitflags", 2079 2079 + "indexmap", 2080 2080 + "log", 2081 2081 + "serde", 2082 2082 + "serde_derive", 2083 2083 + "serde_json", 2084 2084 + "wasm-encoder", 2085 2085 + "wasm-metadata", 2086 2086 + "wasmparser", 2087 2087 + "wit-parser", 2088 2088 + ] 2089 2089 + 2090 2090 + [[package]] 2091 2091 + name = "wit-parser" 2092 2092 + version = "0.244.0" 2093 2093 + source = "registry+https://github.com/rust-lang/crates.io-index" 2094 2094 + checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" 2095 2095 + dependencies = [ 2096 2096 + "anyhow", 2097 2097 + "id-arena", 2098 2098 + "indexmap", 2099 2099 + "log", 2100 2100 + "semver", 2101 2101 + "serde", 2102 2102 + "serde_derive", 2103 2103 + "serde_json", 2104 2104 + "unicode-xid", 2105 2105 + "wasmparser", 2106 2106 + ] 2107 2107 + 2108 2108 + [[package]] 1857 2109 name = "writeable" 1858 2110 version = "0.6.3"

+3 -2

backend/Cargo.toml

reviewed

··· 3 3 4 4 5 5 6 6 - 6 6 + [dependencies] 7 7 anyhow = "1.0.102" 8 8 - axum = "0.8.9" 8 8 + axum = { version = "0.8.9", features = ["macros"] } 9 9 dotenvy = "0.15.7" 10 10 + rand = "0.10.1" 10 11 serde = { version = "1.0.228", features = ["derive"] } 11 12 serde_json = "1.0.149" 12 13 sqlx = { version = "0.8.6", features = ["runtime-tokio", "postgres", "json"] }

+100

backend/src/game/catalog.rs

reviewed

··· 1 1 + use std::collections::HashMap; 2 2 + 3 3 + use super::action::{Action, GaugeDelta}; 4 4 + 5 5 + pub fn default_catalog() -> HashMap<String, Action> { 6 6 + let actions = vec![ 7 7 + Action { 8 8 + id: "tombola_associative".to_string(), 9 9 + label: "Organiser une tombola associative".to_string(), 10 10 + effect: GaugeDelta { 11 11 + money: 150, 12 12 + internal_support: 5, 13 13 + mental_load: 5, 14 14 + }, 15 15 + }, 16 16 + Action { 17 17 + id: "vente_jeune_espoir".to_string(), 18 18 + label: "Vendre un jeune joueur formé au club".to_string(), 19 19 + effect: GaugeDelta { 20 20 + money: 400, 21 21 + internal_support: -20, 22 22 + mental_load: 10, 23 23 + }, 24 24 + }, 25 25 + Action { 26 26 + id: "partenariat_boulangerie".to_string(), 27 27 + label: "Sceller un partenariat avec la boulangerie du quartier".to_string(), 28 28 + effect: GaugeDelta { 29 29 + money: 80, 30 30 + internal_support: 5, 31 31 + mental_load: 0, 32 32 + }, 33 33 + }, 34 34 + Action { 35 35 + id: "journee_chantier_benevole".to_string(), 36 36 + label: "Organiser une journée de chantier au stade".to_string(), 37 37 + effect: GaugeDelta { 38 38 + money: 50, 39 39 + internal_support: 10, 40 40 + mental_load: -5, 41 41 + }, 42 42 + }, 43 43 + Action { 44 44 + id: "assemblee_generale".to_string(), 45 45 + label: "Convoquer une assemblée générale du collectif".to_string(), 46 46 + effect: GaugeDelta { 47 47 + money: -20, 48 48 + internal_support: 15, 49 49 + mental_load: 10, 50 50 + }, 51 51 + }, 52 52 + Action { 53 53 + id: "reporter_salaires".to_string(), 54 54 + label: "Reporter les salaires de l'équipe pro d'un mois".to_string(), 55 55 + effect: GaugeDelta { 56 56 + money: 300, 57 57 + internal_support: -25, 58 58 + mental_load: 15, 59 59 + }, 60 60 + }, 61 61 + Action { 62 62 + id: "dossier_subvention_municipale".to_string(), 63 63 + label: "Déposer un dossier de subvention municipale".to_string(), 64 64 + effect: GaugeDelta { 65 65 + money: 200, 66 66 + internal_support: 0, 67 67 + mental_load: 15, 68 68 + }, 69 69 + }, 70 70 + Action { 71 71 + id: "refus_sponsor_petrolier".to_string(), 72 72 + label: "Refuser un sponsor pétrolier".to_string(), 73 73 + effect: GaugeDelta { 74 74 + money: -100, 75 75 + internal_support: 20, 76 76 + mental_load: 0, 77 77 + }, 78 78 + }, 79 79 + Action { 80 80 + id: "weekend_repos".to_string(), 81 81 + label: "S'accorder un week-end de repos".to_string(), 82 82 + effect: GaugeDelta { 83 83 + money: -30, 84 84 + internal_support: -3, 85 85 + mental_load: -20, 86 86 + }, 87 87 + }, 88 88 + Action { 89 89 + id: "entrainement_ouvert_quartier".to_string(), 90 90 + label: "Ouvrir les entraînements aux écoles du quartier".to_string(), 91 91 + effect: GaugeDelta { 92 92 + money: -40, 93 93 + internal_support: 10, 94 94 + mental_load: 5, 95 95 + }, 96 96 + }, 97 97 + ]; 98 98 + 99 99 + actions.into_iter().map(|a| (a.id.clone(), a)).collect() 100 100 + }