Implemented more hotkeys🌶️

src/game.rs

@@ -53,8 +53,10 @@ enum Event {
     Bounce(Player),
     Tap(Uuid),
     Discard(Player),
+    Undiscard(Player),
     Kill(Uuid, bool),
     Unkill(Uuid, bool),
+    TransferDeadCard(Uuid, bool)
 }
 
 #[derive(Serialize, Clone, Debug)]
@@ -298,6 +300,23 @@ pub fn discard(game_state: &mut GameState, hand_index: usize, player: Player, sh
     }
 }
 
+pub fn undiscard(game_state: &mut GameState, pile_index: usize, player: Player, shadow: bool) {
+    let player_hand = match player {
+        Player::A => &mut game_state.hands[0],
+        Player::B => &mut game_state.hands[1],
+    };
+    game_state.events.push(CountedEvent {
+        id: game_state.events.len(),
+        event: Event::Undiscard(player.clone()),
+    });
+    let card = if shadow {
+        game_state.shadow_realm.remove(pile_index)
+    } else {
+        game_state.discard_pile.remove(pile_index)
+    };
+    player_hand.cards.push(card);
+}
+
 pub fn kill(game_state: &mut GameState, play_id: Uuid, shadow: bool) {
     let played_card = game_state.play.remove(&play_id).unwrap();
     game_state.events.push(CountedEvent {
@@ -334,3 +353,21 @@ pub fn unkill(game_state: &mut GameState, player: Player, pile_index: usize, sha
         },
     );
 }
+
+pub fn transfer_dead_card(game_state: &mut GameState, pile_index: usize, shadow_to_discard: bool) {
+    let card_id = if shadow_to_discard {
+        let card = game_state.shadow_realm.remove(pile_index);
+        let ret = card.clone();
+        game_state.discard_pile.push(card);
+        ret
+    } else {
+        let card = game_state.discard_pile.remove(pile_index);
+        let ret = card.clone();
+        game_state.shadow_realm.push(card);
+        ret
+    };
+    game_state.events.push(CountedEvent {
+        id: game_state.events.len(),
+        event: Event::TransferDeadCard(card_id, shadow_to_discard),
+    });
+}

src/main.rs

@@ -230,6 +230,74 @@ fn banish(
     Ok(format!("{}", game::get_events(&game_state)))
 }
 
+#[get("/<uuid>/unshadow/<index>")]
+fn unshadow(
+    uuid: Uuid,
+    index: usize,
+    game_state_arc: &State<ArcMutexGameState>,
+    player_uuids: &State<PlayerUuids>,
+) -> Result<String, BadRequest<String>> {
+    match player_uuids.map.get(&uuid) {
+        Some(_) => (),
+        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
+    };
+    let game_state_mutex = Arc::clone(&game_state_arc.state);
+    let mut game_state = game_state_mutex.lock().unwrap();
+    game::transfer_dead_card(&mut game_state, index, true);
+    Ok(format!("{}", game::get_events(&game_state)))
+}
+
+#[get("/<uuid>/undiscard/<index>")]
+fn undiscard(
+    uuid: Uuid,
+    index: usize,
+    game_state_arc: &State<ArcMutexGameState>,
+    player_uuids: &State<PlayerUuids>,
+) -> Result<String, BadRequest<String>> {
+    let player = match player_uuids.map.get(&uuid) {
+        Some(player) => player,
+        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
+    };
+    let game_state_mutex = Arc::clone(&game_state_arc.state);
+    let mut game_state = game_state_mutex.lock().unwrap();
+    game::undiscard(&mut game_state, index, player.clone(), false);
+    Ok(format!("{}", game::get_events(&game_state)))
+}
+
+#[get("/<uuid>/remember/<index>")]
+fn remember(
+    uuid: Uuid,
+    index: usize,
+    game_state_arc: &State<ArcMutexGameState>,
+    player_uuids: &State<PlayerUuids>,
+) -> Result<String, BadRequest<String>> {
+    let player = match player_uuids.map.get(&uuid) {
+        Some(player) => player,
+        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
+    };
+    let game_state_mutex = Arc::clone(&game_state_arc.state);
+    let mut game_state = game_state_mutex.lock().unwrap();
+    game::undiscard(&mut game_state, index, player.clone(), true);
+    Ok(format!("{}", game::get_events(&game_state)))
+}
+
+#[get("/<uuid>/shadow/<index>")]
+fn shadow(
+    uuid: Uuid,
+    index: usize,
+    game_state_arc: &State<ArcMutexGameState>,
+    player_uuids: &State<PlayerUuids>,
+) -> Result<String, BadRequest<String>> {
+    match player_uuids.map.get(&uuid) {
+        Some(_) => (),
+        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
+    };
+    let game_state_mutex = Arc::clone(&game_state_arc.state);
+    let mut game_state = game_state_mutex.lock().unwrap();
+    game::transfer_dead_card(&mut game_state, index, false);
+    Ok(format!("{}", game::get_events(&game_state)))
+}
+
 #[get("/<uuid>/get_state")]
 fn get_state(
     uuid: Uuid,
@@ -389,7 +457,11 @@ fn rocket() -> _ {
                 forget,
                 banish,
                 unkill,
-                unbanish
+                unbanish,
+                shadow,
+                unshadow,
+                undiscard,
+                remember,
             ],
         )
         .manage(ArcMutexGameState {