Update formatting to use 4‑space indentation

- Adjust rustfmt.toml to set tab_spaces = 4.
- Reformat imports, struct definitions, function bodies, and match arms
  across the project to match the new style (aligned fields, added
  spacing, etc.).
- Ensure all code complies with the updated rustfmt settings.

tests/recruitment.rs

@@ -1,338 +1,337 @@
 use clap::Parser;
 use ratatui::{
-  Terminal,
-  backend::TestBackend,
-  buffer::Cell,
-  crossterm::event::{KeyCode, KeyEvent, KeyModifiers},
-  layout::Rect,
+    Terminal,
+    backend::TestBackend,
+    buffer::Cell,
+    crossterm::event::{KeyCode, KeyEvent, KeyModifiers},
+    layout::Rect,
 };
 use std::sync::mpsc::{Receiver, Sender, channel};
 use war_in_tunnels::{
-  app::{
-    Action, App, GameStates, View, available_skirmish_actions, handle_keybindings,
-    states::{
-      SkirmishState,
-      skirmish_states::{
-        MoveFocusedCell, Players, Resources,
-        structures::{BaseBuilding, Structures, Tunnel},
-        units::{MinerUnit, Unit, Units},
-      },
+    app::{
+        Action, App, GameStates, View, available_skirmish_actions, handle_keybindings,
+        states::{
+            SkirmishState,
+            skirmish_states::{
+                MoveFocusedCell, Players, Resources,
+                structures::{BaseBuilding, Structures, Tunnel},
+                units::{MinerUnit, Unit, Units},
+            },
+        },
+        threads::{AudioCmd, TICK_MS},
     },
-    threads::{AudioCmd, TICK_MS},
-  },
-  cli::Cli,
+    cli::Cli,
 };
 
 fn app() -> App {
-  let args: Cli = Cli::try_parse_from(["game", "--disable-audio"]).unwrap();
-  let (tx, _rx): (Sender<AudioCmd>, Receiver<AudioCmd>) = channel();
-  let mut app: App = App::new(args, tx);
-  app.view = View::Skirmish;
-  app.window_area = Rect::new(0, 0, 160, 50);
-  app.states = Some(GameStates::new(&app.args, &app.window_area));
-  app
+    let args: Cli = Cli::try_parse_from(["game", "--disable-audio"]).unwrap();
+    let (tx, _rx): (Sender<AudioCmd>, Receiver<AudioCmd>) = channel();
+    let mut app: App = App::new(args, tx);
+    app.view = View::Skirmish;
+    app.window_area = Rect::new(0, 0, 160, 50);
+    app.states = Some(GameStates::new(&app.args, &app.window_area));
+    app
 }
 
 fn base(game: &SkirmishState, coords: (usize, usize)) -> BaseBuilding {
-  let Structures::Base(base) = game.board.cells[coords.0][coords.1].get_structure() else {
-    panic!("base missing");
-  };
-  base
+    let Structures::Base(base) = game.board.cells[coords.0][coords.1].get_structure() else {
+        panic!("base missing");
+    };
+    base
 }
 
 fn press(app: &mut App, code: KeyCode, modifiers: KeyModifiers) -> () {
-  handle_keybindings(app, KeyEvent::new(code, modifiers));
+    handle_keybindings(app, KeyEvent::new(code, modifiers));
 }
 
 #[test]
 fn recruitment_is_owned_by_base_and_invalid_requests_do_not_charge() -> () {
-  let mut app: App = app();
-  let game: &mut SkirmishState = &mut app.states_mut().unwrap().skirmish;
-  let before: Resources = game.player_resources;
-  for coords in [(5, 39), (0, 0), (usize::MAX, 2)] {
-    assert!(!game.recruit_miner(coords, Players::Player));
-    assert_eq!(game.player_resources, before);
-  }
-  assert!(!game.recruit_miner((5, 2), Players::Unclaimed));
-  assert!(game.recruit_miner((5, 2), Players::Player));
-  assert_eq!(game.player_resources, Resources::new(40, 10));
-  assert_eq!(game.enemy_resources, Resources::new(50, 25));
-  assert_eq!(base(game, (5, 2)).queued_miners(), 1);
+    let mut app: App = app();
+    let game: &mut SkirmishState = &mut app.states_mut().unwrap().skirmish;
+    let before: Resources = game.player_resources;
+    for coords in [(5, 39), (0, 0), (usize::MAX, 2)] {
+        assert!(!game.recruit_miner(coords, Players::Player));
+        assert_eq!(game.player_resources, before);
+    }
+    assert!(!game.recruit_miner((5, 2), Players::Unclaimed));
+    assert!(game.recruit_miner((5, 2), Players::Player));
+    assert_eq!(game.player_resources, Resources::new(40, 10));
+    assert_eq!(game.enemy_resources, Resources::new(50, 25));
+    assert_eq!(base(game, (5, 2)).queued_miners(), 1);
 }
 
 #[test]
 fn recruitment_requires_both_resources_and_charges_each_queue_entry() -> () {
-  let mut app: App = app();
-  let game: &mut SkirmishState = &mut app.states_mut().unwrap().skirmish;
-  for resources in [
-    Resources { wood: 9, metal: 15 },
-    Resources {
-      wood: 10,
-      metal: 14,
-    },
-  ] {
-    game.player_resources = resources;
-    assert!(!game.can_recruit_miner((5, 2), Players::Player));
+    let mut app: App = app();
+    let game: &mut SkirmishState = &mut app.states_mut().unwrap().skirmish;
+    for resources in [
+        Resources { wood: 9, metal: 15 },
+        Resources {
+            wood: 10,
+            metal: 14,
+        },
+    ] {
+        game.player_resources = resources;
+        assert!(!game.can_recruit_miner((5, 2), Players::Player));
+        assert!(!game.recruit_miner((5, 2), Players::Player));
+        assert_eq!(game.player_resources, resources);
+        assert_eq!(base(game, (5, 2)).queued_miners(), 0);
+    }
+    game.player_resources = Resources::new(20, 30);
+    assert!(game.recruit_miner((5, 2), Players::Player));
+    assert!(game.recruit_miner((5, 2), Players::Player));
+    assert_eq!(base(game, (5, 2)).queued_miners(), 2);
+    assert_eq!(game.player_resources, Resources::new(0, 0));
     assert!(!game.recruit_miner((5, 2), Players::Player));
-    assert_eq!(game.player_resources, resources);
-    assert_eq!(base(game, (5, 2)).queued_miners(), 0);
-  }
-  game.player_resources = Resources::new(20, 30);
-  assert!(game.recruit_miner((5, 2), Players::Player));
-  assert!(game.recruit_miner((5, 2), Players::Player));
-  assert_eq!(base(game, (5, 2)).queued_miners(), 2);
-  assert_eq!(game.player_resources, Resources::new(0, 0));
-  assert!(!game.recruit_miner((5, 2), Players::Player));
 }
 
 #[test]
 fn first_recruit_waits_at_full_progress_and_following_recruits_pause_until_departure() -> () {
-  let mut app: App = app();
-  let game: &mut SkirmishState = &mut app.states_mut().unwrap().skirmish;
-  game.player_resources = Resources::new(100, 100);
-  assert!(game.recruit_miner((5, 2), Players::Player));
-  assert!(game.recruit_miner((5, 2), Players::Player));
-  let original: Option<Units> = game.board.cells[5][2].get_option_unit();
-  for _ in 0..2 * BaseBuilding::RECRUITMENT_TICKS {
+    let mut app: App = app();
+    let game: &mut SkirmishState = &mut app.states_mut().unwrap().skirmish;
+    game.player_resources = Resources::new(100, 100);
+    assert!(game.recruit_miner((5, 2), Players::Player));
+    assert!(game.recruit_miner((5, 2), Players::Player));
+    let original: Option<Units> = game.board.cells[5][2].get_option_unit();
+    for _ in 0..2 * BaseBuilding::RECRUITMENT_TICKS {
+        game.tick_update();
+    }
+    assert_eq!(base(game, (5, 2)).queued_miners(), 2);
+    assert_eq!(base(game, (5, 2)).recruitment_progress(), 100);
+    assert_eq!(game.board.cells[5][2].get_option_unit(), original);
+    game.board.cells[5][2].get_mut_option_unit().take();
     game.tick_update();
-  }
-  assert_eq!(base(game, (5, 2)).queued_miners(), 2);
-  assert_eq!(base(game, (5, 2)).recruitment_progress(), 100);
-  assert_eq!(game.board.cells[5][2].get_option_unit(), original);
-  game.board.cells[5][2].get_mut_option_unit().take();
-  game.tick_update();
-  let spawned: Option<Units> = game.board.cells[5][2].get_option_unit();
-  assert_eq!(spawned.get_owner(), Players::Player);
-  assert_eq!(spawned.get_coords(), (5, 2));
-  assert!(spawned.get_ref_tasks().is_empty());
-  assert_eq!(base(game, (5, 2)).queued_miners(), 1);
-  for _ in 0..2 * BaseBuilding::RECRUITMENT_TICKS {
+    let spawned: Option<Units> = game.board.cells[5][2].get_option_unit();
+    assert_eq!(spawned.get_owner(), Players::Player);
+    assert_eq!(spawned.get_coords(), (5, 2));
+    assert!(spawned.get_ref_tasks().is_empty());
+    assert_eq!(base(game, (5, 2)).queued_miners(), 1);
+    for _ in 0..2 * BaseBuilding::RECRUITMENT_TICKS {
+        game.tick_update();
+    }
+    assert_eq!(base(game, (5, 2)).queued_miners(), 1);
+    assert_eq!(base(game, (5, 2)).recruitment_progress(), 0);
+    assert_eq!(game.board.cells[5][2].get_option_unit(), spawned);
+    game.board.cells[5][2].get_mut_option_unit().take();
+    for _ in 1..BaseBuilding::RECRUITMENT_TICKS {
+        game.tick_update();
+    }
+    assert!(game.board.cells[5][2].get_ref_option_unit().is_none());
+    assert_eq!(base(game, (5, 2)).recruitment_progress(), 99);
     game.tick_update();
-  }
-  assert_eq!(base(game, (5, 2)).queued_miners(), 1);
-  assert_eq!(base(game, (5, 2)).recruitment_progress(), 0);
-  assert_eq!(game.board.cells[5][2].get_option_unit(), spawned);
-  game.board.cells[5][2].get_mut_option_unit().take();
-  for _ in 1..BaseBuilding::RECRUITMENT_TICKS {
-    game.tick_update();
-  }
-  assert!(game.board.cells[5][2].get_ref_option_unit().is_none());
-  assert_eq!(base(game, (5, 2)).recruitment_progress(), 99);
-  game.tick_update();
-  assert_eq!(base(game, (5, 2)).queued_miners(), 0);
-  assert_eq!(
-    game.board.cells[5][2].get_ref_option_unit().get_owner(),
-    Players::Player
-  );
+    assert_eq!(base(game, (5, 2)).queued_miners(), 0);
+    assert_eq!(
+        game.board.cells[5][2].get_ref_option_unit().get_owner(),
+        Players::Player
+    );
 }
 
 #[test]
 fn walking_out_of_base_resumes_recruitment_and_new_miner_can_receive_tasks() -> () {
-  let mut app: App = app();
-  let game: &mut SkirmishState = &mut app.states_mut().unwrap().skirmish;
-  assert!(game.recruit_miner((5, 2), Players::Player));
-  game.board.cells[5][3].set_structure(Structures::Tunnel(Tunnel::new()));
-  game.board.change_focused_cell(MoveFocusedCell::Left);
-  game.board.toggle_marking();
-  game.board.change_focused_cell(MoveFocusedCell::Right);
-  game.board.toggle_marking();
-  for _ in 0..3000_u16.div_ceil(u16::from(TICK_MS)) {
+    let mut app: App = app();
+    let game: &mut SkirmishState = &mut app.states_mut().unwrap().skirmish;
+    assert!(game.recruit_miner((5, 2), Players::Player));
+    game.board.cells[5][3].set_structure(Structures::Tunnel(Tunnel::new()));
+    game.board.change_focused_cell(MoveFocusedCell::Left);
+    game.board.toggle_marking();
+    game.board.change_focused_cell(MoveFocusedCell::Right);
+    game.board.toggle_marking();
+    for _ in 0..3000_u16.div_ceil(u16::from(TICK_MS)) {
+        game.tick_update();
+    }
+    assert!(game.board.cells[5][2].get_ref_option_unit().is_none());
+    for _ in 3000_u16.div_ceil(u16::from(TICK_MS))..BaseBuilding::RECRUITMENT_TICKS - 1 {
+        game.tick_update();
+    }
+    assert!(game.board.cells[5][2].get_ref_option_unit().is_none());
+    assert_eq!(base(game, (5, 2)).recruitment_progress(), 99);
     game.tick_update();
-  }
-  assert!(game.board.cells[5][2].get_ref_option_unit().is_none());
-  for _ in 3000_u16.div_ceil(u16::from(TICK_MS))..BaseBuilding::RECRUITMENT_TICKS - 1 {
-    game.tick_update();
-  }
-  assert!(game.board.cells[5][2].get_ref_option_unit().is_none());
-  assert_eq!(base(game, (5, 2)).recruitment_progress(), 99);
-  game.tick_update();
-  assert_eq!(base(game, (5, 2)).queued_miners(), 0);
-  assert_eq!(
-    game.board.cells[5][2].get_ref_option_unit().get_coords(),
-    (5, 2)
-  );
-  assert_eq!(
-    game.board.cells[5][3].get_ref_option_unit().get_coords(),
-    (5, 3)
-  );
-  game.board.change_focused_cell(MoveFocusedCell::Left);
-  game.board.toggle_marking();
-  game.board.change_focused_cell(MoveFocusedCell::Down);
-  game.board.toggle_marking();
-  assert_eq!(
-    game.board.cells[5][2]
-      .get_ref_option_unit()
-      .get_ref_tasks()
-      .len(),
-    1
-  );
+    assert_eq!(base(game, (5, 2)).queued_miners(), 0);
+    assert_eq!(
+        game.board.cells[5][2].get_ref_option_unit().get_coords(),
+        (5, 2)
+    );
+    assert_eq!(
+        game.board.cells[5][3].get_ref_option_unit().get_coords(),
+        (5, 3)
+    );
+    game.board.change_focused_cell(MoveFocusedCell::Left);
+    game.board.toggle_marking();
+    game.board.change_focused_cell(MoveFocusedCell::Down);
+    game.board.toggle_marking();
+    assert_eq!(
+        game.board.cells[5][2]
+            .get_ref_option_unit()
+            .get_ref_tasks()
+            .len(),
+        1
+    );
 }
 
 #[test]
 fn arrival_during_training_does_not_overwrite_visitor_and_ready_recruit_spawns_after_departure()
 -> () {
-  let mut app: App = app();
-  let game: &mut SkirmishState = &mut app.states_mut().unwrap().skirmish;
-  game.board.cells[5][2].get_mut_option_unit().take();
-  assert!(game.recruit_miner((5, 2), Players::Player));
-  for _ in 0..100 {
+    let mut app: App = app();
+    let game: &mut SkirmishState = &mut app.states_mut().unwrap().skirmish;
+    game.board.cells[5][2].get_mut_option_unit().take();
+    assert!(game.recruit_miner((5, 2), Players::Player));
+    for _ in 0..100 {
+        game.tick_update();
+    }
+    let visitor: Units = Units::Miner(MinerUnit::new(Players::Enemy, (5, 2)));
+    *game.board.cells[5][2].get_mut_option_unit() = Some(visitor.clone());
+    for _ in 0..BaseBuilding::RECRUITMENT_TICKS {
+        game.tick_update();
+    }
+    assert_eq!(base(game, (5, 2)).recruitment_progress(), 100);
+    assert_eq!(game.board.cells[5][2].get_option_unit(), Some(visitor));
+    game.board.cells[5][2].get_mut_option_unit().take();
     game.tick_update();
-  }
-  let visitor: Units = Units::Miner(MinerUnit::new(Players::Enemy, (5, 2)));
-  *game.board.cells[5][2].get_mut_option_unit() = Some(visitor.clone());
-  for _ in 0..BaseBuilding::RECRUITMENT_TICKS {
-    game.tick_update();
-  }
-  assert_eq!(base(game, (5, 2)).recruitment_progress(), 100);
-  assert_eq!(game.board.cells[5][2].get_option_unit(), Some(visitor));
-  game.board.cells[5][2].get_mut_option_unit().take();
-  game.tick_update();
-  assert_eq!(base(game, (5, 2)).queued_miners(), 0);
-  assert_eq!(
-    game.board.cells[5][2].get_ref_option_unit().get_owner(),
-    Players::Player
-  );
+    assert_eq!(base(game, (5, 2)).queued_miners(), 0);
+    assert_eq!(
+        game.board.cells[5][2].get_ref_option_unit().get_owner(),
+        Players::Player
+    );
 }
 
 #[test]
 fn bases_have_independent_queues_costs_and_spawn_ownership() -> () {
-  let mut app: App = app();
-  let game: &mut SkirmishState = &mut app.states_mut().unwrap().skirmish;
-  for (coords, owner) in [((5, 2), Players::Player), ((5, 39), Players::Enemy)] {
-    game.board.cells[coords.0][coords.1]
-      .get_mut_option_unit()
-      .take();
-    assert!(game.recruit_miner(coords, owner));
-  }
-  assert_eq!(game.player_resources.metal, 10);
-  assert_eq!(game.enemy_resources.metal, 10);
-  for _ in 0..BaseBuilding::RECRUITMENT_TICKS {
-    game.tick_update();
-  }
-  for (coords, owner) in [((5, 2), Players::Player), ((5, 39), Players::Enemy)] {
-    assert_eq!(base(game, coords).queued_miners(), 0);
-    assert_eq!(
-      game.board.cells[coords.0][coords.1]
-        .get_ref_option_unit()
-        .get_owner(),
-      owner
-    );
-    assert_eq!(
-      game.board.cells[coords.0][coords.1]
-        .get_ref_option_unit()
-        .get_coords(),
-      coords
-    );
-  }
+    let mut app: App = app();
+    let game: &mut SkirmishState = &mut app.states_mut().unwrap().skirmish;
+    for (coords, owner) in [((5, 2), Players::Player), ((5, 39), Players::Enemy)] {
+        game.board.cells[coords.0][coords.1]
+            .get_mut_option_unit()
+            .take();
+        assert!(game.recruit_miner(coords, owner));
+    }
+    assert_eq!(game.player_resources.metal, 10);
+    assert_eq!(game.enemy_resources.metal, 10);
+    for _ in 0..BaseBuilding::RECRUITMENT_TICKS {
+        game.tick_update();
+    }
+    for (coords, owner) in [((5, 2), Players::Player), ((5, 39), Players::Enemy)] {
+        assert_eq!(base(game, coords).queued_miners(), 0);
+        assert_eq!(
+            game.board.cells[coords.0][coords.1]
+                .get_ref_option_unit()
+                .get_owner(),
+            owner
+        );
+        assert_eq!(
+            game.board.cells[coords.0][coords.1]
+                .get_ref_option_unit()
+                .get_coords(),
+            coords
+        );
+    }
 }
 
 #[test]
 fn recruitment_panel_queues_with_enter_shows_ready_state_and_closes_without_losing_queue() -> () {
-  let mut app: App = app();
-  press(&mut app, KeyCode::Left, KeyModifiers::NONE);
-  assert!(
-    available_skirmish_actions(&app.states_ref().unwrap().skirmish).contains(&Action::Recruitment)
-  );
-  press(&mut app, KeyCode::Char(' '), KeyModifiers::ALT);
-  assert!(app.states_ref().unwrap().skirmish.recruitment_view);
-  press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
-  press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
-  assert_eq!(
-    base(&app.states_ref().unwrap().skirmish, (5, 2)).queued_miners(),
-    1
-  );
-  assert!(
-    !available_skirmish_actions(&app.states_ref().unwrap().skirmish).contains(&Action::Enter)
-  );
-  press(&mut app, KeyCode::Right, KeyModifiers::NONE);
-  press(&mut app, KeyCode::Char(' '), KeyModifiers::CONTROL);
-  assert_eq!(
-    app
-      .states_ref()
-      .unwrap()
-      .skirmish
-      .board
-      .get_focused_cell()
-      .get_coords(),
-    (5, 2)
-  );
-  assert!(!app.states_ref().unwrap().skirmish.building_view);
-  for _ in 0..BaseBuilding::RECRUITMENT_TICKS {
-    app.states_mut().unwrap().skirmish.tick_update();
-  }
-  let mut terminal: Terminal<TestBackend> = Terminal::new(TestBackend::new(160, 50)).unwrap();
-  terminal
-    .draw(|frame: &mut ratatui::Frame<'_>| -> () {
-      frame.render_widget(&mut app, frame.area());
-    })
-    .unwrap();
-  let text: String = terminal
-    .backend()
-    .buffer()
-    .content
-    .iter()
-    .map(|cell: &Cell| -> &str { cell.symbol() })
-    .collect();
-  assert!(text.contains("Cost: 10 Wood + 15 Metal"));
-  assert!(text.contains("Queued Miners: 1"));
-  assert!(text.contains("Current progress: 100%"));
-  assert!(text.contains("Ready: waiting for free base cell"));
-  assert!(text.contains("Close recruitment"));
-  press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
-  assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
-  assert_eq!(app.view, View::Skirmish);
-  press(&mut app, KeyCode::Char(' '), KeyModifiers::ALT);
-  press(&mut app, KeyCode::Char(' '), KeyModifiers::ALT);
-  assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
-  assert_eq!(
-    base(&app.states_ref().unwrap().skirmish, (5, 2)).queued_miners(),
-    1
-  );
+    let mut app: App = app();
+    press(&mut app, KeyCode::Left, KeyModifiers::NONE);
+    assert!(
+        available_skirmish_actions(&app.states_ref().unwrap().skirmish)
+            .contains(&Action::Recruitment)
+    );
+    press(&mut app, KeyCode::Char(' '), KeyModifiers::ALT);
+    assert!(app.states_ref().unwrap().skirmish.recruitment_view);
+    press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
+    press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
+    assert_eq!(
+        base(&app.states_ref().unwrap().skirmish, (5, 2)).queued_miners(),
+        1
+    );
+    assert!(
+        !available_skirmish_actions(&app.states_ref().unwrap().skirmish).contains(&Action::Enter)
+    );
+    press(&mut app, KeyCode::Right, KeyModifiers::NONE);
+    press(&mut app, KeyCode::Char(' '), KeyModifiers::CONTROL);
+    assert_eq!(
+        app.states_ref()
+            .unwrap()
+            .skirmish
+            .board
+            .get_focused_cell()
+            .get_coords(),
+        (5, 2)
+    );
+    assert!(!app.states_ref().unwrap().skirmish.building_view);
+    for _ in 0..BaseBuilding::RECRUITMENT_TICKS {
+        app.states_mut().unwrap().skirmish.tick_update();
+    }
+    let mut terminal: Terminal<TestBackend> = Terminal::new(TestBackend::new(160, 50)).unwrap();
+    terminal
+        .draw(|frame: &mut ratatui::Frame<'_>| -> () {
+            frame.render_widget(&mut app, frame.area());
+        })
+        .unwrap();
+    let text: String = terminal
+        .backend()
+        .buffer()
+        .content
+        .iter()
+        .map(|cell: &Cell| -> &str { cell.symbol() })
+        .collect();
+    assert!(text.contains("Cost: 10 Wood + 15 Metal"));
+    assert!(text.contains("Queued Miners: 1"));
+    assert!(text.contains("Current progress: 100%"));
+    assert!(text.contains("Ready: waiting for free base cell"));
+    assert!(text.contains("Close recruitment"));
+    press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
+    assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
+    assert_eq!(app.view, View::Skirmish);
+    press(&mut app, KeyCode::Char(' '), KeyModifiers::ALT);
+    press(&mut app, KeyCode::Char(' '), KeyModifiers::ALT);
+    assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
+    assert_eq!(
+        base(&app.states_ref().unwrap().skirmish, (5, 2)).queued_miners(),
+        1
+    );
 }
 
 #[test]
 fn recruitment_panel_is_unavailable_off_base_and_during_route_selection() -> () {
-  let mut app: App = app();
-  press(&mut app, KeyCode::Char('r'), KeyModifiers::NONE);
-  assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
-  press(&mut app, KeyCode::Char(' '), KeyModifiers::ALT);
-  assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
-  press(&mut app, KeyCode::Left, KeyModifiers::NONE);
-  press(&mut app, KeyCode::Char(' '), KeyModifiers::NONE);
-  press(&mut app, KeyCode::Char('r'), KeyModifiers::NONE);
-  assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
-  press(&mut app, KeyCode::Char(' '), KeyModifiers::ALT);
-  assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
-  assert!(
-    app
-      .states_ref()
-      .unwrap()
-      .skirmish
-      .board
-      .marked_cells
-      .marking_cells
-  );
-  press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
-  press(&mut app, KeyCode::Char(' '), KeyModifiers::ALT);
-  press(&mut app, KeyCode::Char('c'), KeyModifiers::CONTROL);
-  assert!(app.exit);
+    let mut app: App = app();
+    press(&mut app, KeyCode::Char('r'), KeyModifiers::NONE);
+    assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
+    press(&mut app, KeyCode::Char(' '), KeyModifiers::ALT);
+    assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
+    press(&mut app, KeyCode::Left, KeyModifiers::NONE);
+    press(&mut app, KeyCode::Char(' '), KeyModifiers::NONE);
+    press(&mut app, KeyCode::Char('r'), KeyModifiers::NONE);
+    assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
+    press(&mut app, KeyCode::Char(' '), KeyModifiers::ALT);
+    assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
+    assert!(
+        app.states_ref()
+            .unwrap()
+            .skirmish
+            .board
+            .marked_cells
+            .marking_cells
+    );
+    press(&mut app, KeyCode::Esc, KeyModifiers::NONE);
+    press(&mut app, KeyCode::Char(' '), KeyModifiers::ALT);
+    press(&mut app, KeyCode::Char('c'), KeyModifiers::CONTROL);
+    assert!(app.exit);
 }
 
 #[test]
 fn recruitment_fallback_opens_queues_and_closes_on_own_base() -> () {
-  let mut app: App = app();
-  press(&mut app, KeyCode::Left, KeyModifiers::NONE);
-  press(&mut app, KeyCode::Char('r'), KeyModifiers::NONE);
-  assert!(app.states_ref().unwrap().skirmish.recruitment_view);
-  press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
-  press(&mut app, KeyCode::Char('r'), KeyModifiers::NONE);
-  assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
-  assert_eq!(
-    base(&app.states_ref().unwrap().skirmish, (5, 2)).queued_miners(),
-    1
-  );
-  assert_eq!(
-    app.states_ref().unwrap().skirmish.player_resources,
-    Resources::new(40, 10)
-  );
+    let mut app: App = app();
+    press(&mut app, KeyCode::Left, KeyModifiers::NONE);
+    press(&mut app, KeyCode::Char('r'), KeyModifiers::NONE);
+    assert!(app.states_ref().unwrap().skirmish.recruitment_view);
+    press(&mut app, KeyCode::Enter, KeyModifiers::NONE);
+    press(&mut app, KeyCode::Char('r'), KeyModifiers::NONE);
+    assert!(!app.states_ref().unwrap().skirmish.recruitment_view);
+    assert_eq!(
+        base(&app.states_ref().unwrap().skirmish, (5, 2)).queued_miners(),
+        1
+    );
+    assert_eq!(
+        app.states_ref().unwrap().skirmish.player_resources,
+        Resources::new(40, 10)
+    );
 }