Add rustfmt configuration and reformat code

- Document new Rust formatting standards in AGENTS, CODE_MAP, and
  PROGRESS.
- Add rustfmt.toml with style 2024, 2‑space indents, 100‑char width, LF
  endings.
- Apply consistent 2‑space indentation and ordering across source files.
- Minor clean‑up of imports and whitespace to match the new style.

src/app/states/skirmish_states/units/miner.rs

@@ -1,124 +1,125 @@
 use ratatui::{style::Stylize, text::Line};
 
 use crate::app::states::skirmish_states::{
-    Players,
-    tasks::{Task, Tasks},
-    units::Unit,
+  Players,
+  tasks::{Task, Tasks},
+  units::Unit,
 };
 use std::collections::VecDeque;
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct MinerUnit {
-    owner: Players,
-    hp: u16,
-    can_dig: bool,
-    digging_power: f32,
-    coords: (usize, usize),
-    tasks: VecDeque<Tasks>,
+  owner: Players,
+  hp: u16,
+  can_dig: bool,
+  digging_power: f32,
+  coords: (usize, usize),
+  tasks: VecDeque<Tasks>,
 }
 
 impl MinerUnit {
-    pub fn new(owner: Players, coords: (usize, usize)) -> Self {
-        Self {
-            owner,
-            hp: 100,
-            can_dig: true,
-            digging_power: 0.55,
-            coords,
-            tasks: VecDeque::new(),
-        }
+  pub fn new(owner: Players, coords: (usize, usize)) -> Self {
+    Self {
+      owner,
+      hp: 100,
+      can_dig: true,
+      digging_power: 0.55,
+      coords,
+      tasks: VecDeque::new(),
+    }
+  }
+
+  fn col_to_letters(&self, col: usize) -> String {
+    let mut col: usize = col + 1;
+    let mut letters: Vec<char> = Vec::new();
+
+    while col > 0 {
+      letters.push((b'A' + ((col - 1) % 26) as u8) as char);
+      col = (col - 1) / 26;
     }
 
-    fn col_to_letters(&self, col: usize) -> String {
-        let mut col: usize = col + 1;
-        let mut letters: Vec<char> = Vec::new();
+    letters.iter().rev().collect()
+  }
 
-        while col > 0 {
-            letters.push((b'A' + ((col - 1) % 26) as u8) as char);
-            col = (col - 1) / 26;
-        }
-
-        letters.iter().rev().collect()
-    }
-
-    fn display_coords(&self, coords: &(usize, usize)) -> String {
-        format!("{}{}", self.col_to_letters(coords.0), coords.1)
-    }
+  fn display_coords(&self, coords: &(usize, usize)) -> String {
+    format!("{}{}", self.col_to_letters(coords.0), coords.1)
+  }
 }
 
 impl Unit for MinerUnit {
-    fn get_owner(&self) -> Players {
-        self.owner
-    }
+  fn get_owner(&self) -> Players {
+    self.owner
+  }
 
-    fn get_tag(&self) -> char {
-        'M'
-    }
+  fn get_tag(&self) -> char {
+    'M'
+  }
 
-    fn get_name(&self) -> &'static str {
-        "Miner"
-    }
+  fn get_name(&self) -> &'static str {
+    "Miner"
+  }
 
-    fn get_hp(&self) -> u16 {
-        self.hp
-    }
+  fn get_hp(&self) -> u16 {
+    self.hp
+  }
 
-    fn get_max_hp(&self) -> u16 {
-        100
-    }
+  fn get_max_hp(&self) -> u16 {
+    100
+  }
 
-    fn get_can_dig(&self) -> bool {
-        self.can_dig
-    }
+  fn get_can_dig(&self) -> bool {
+    self.can_dig
+  }
 
-    fn get_digging_power(&self) -> f32 {
-        self.digging_power
-    }
+  fn get_digging_power(&self) -> f32 {
+    self.digging_power
+  }
 
-    fn get_coords(&self) -> (usize, usize) {
-        self.coords
-    }
+  fn get_coords(&self) -> (usize, usize) {
+    self.coords
+  }
 
-    fn set_coords(&mut self, coords: (usize, usize)) {
-        self.coords = coords;
-    }
+  fn set_coords(&mut self, coords: (usize, usize)) {
+    self.coords = coords;
+  }
 
-    fn get_ref_tasks(&self) -> &VecDeque<Tasks> {
-        &self.tasks
-    }
+  fn get_ref_tasks(&self) -> &VecDeque<Tasks> {
+    &self.tasks
+  }
 
-    fn get_mut_tasks(&mut self) -> &mut VecDeque<Tasks> {
-        &mut self.tasks
-    }
+  fn get_mut_tasks(&mut self) -> &mut VecDeque<Tasks> {
+    &mut self.tasks
+  }
 
-    fn get_tasks_formatted(&self) -> Vec<Line<'_>> {
-        Vec::from(
-            self.tasks
-                .iter()
-                .enumerate()
-                .flat_map(|(i, task): (usize, &Tasks)| -> [Line<'_>; 2] {
-                    [
-                        Line::from_iter([
-                            format!("{}. ", i + 1).gray(),
-                            task.get_icon().gray(),
-                            "  ".gray(),
-                            self.display_coords(task.get_path_front_coords()).green(),
-                            " -> ".gray(),
-                            self.display_coords(task.get_path_back_coords()).yellow(),
-                        ]),
-                        Line::from(format!(
-                            "   Step: {}% | Total: {}%",
-                            task.get_progress() as u16,
-                            task.get_total_progress() as u16,
-                        ))
-                        .cyan(),
-                    ]
-                })
-                .collect::<Vec<Line<'_>>>(),
-        )
-    }
+  fn get_tasks_formatted(&self) -> Vec<Line<'_>> {
+    Vec::from(
+      self
+        .tasks
+        .iter()
+        .enumerate()
+        .flat_map(|(i, task): (usize, &Tasks)| -> [Line<'_>; 2] {
+          [
+            Line::from_iter([
+              format!("{}. ", i + 1).gray(),
+              task.get_icon().gray(),
+              "  ".gray(),
+              self.display_coords(task.get_path_front_coords()).green(),
+              " -> ".gray(),
+              self.display_coords(task.get_path_back_coords()).yellow(),
+            ]),
+            Line::from(format!(
+              "   Step: {}% | Total: {}%",
+              task.get_progress() as u16,
+              task.get_total_progress() as u16,
+            ))
+            .cyan(),
+          ]
+        })
+        .collect::<Vec<Line<'_>>>(),
+    )
+  }
 
-    fn set_task(&mut self, task: Tasks) {
-        self.tasks.push_back(task);
-    }
+  fn set_task(&mut self, task: Tasks) {
+    self.tasks.push_back(task);
+  }
 }

src/app/states/skirmish_states/units/unit_trait.rs

@@ -1,82 +1,82 @@
 use crate::app::states::skirmish_states::{Players, tasks::Tasks};
 use ratatui::{
-    style::Stylize,
-    text::{Line, Span},
+  style::Stylize,
+  text::{Line, Span},
 };
 use std::collections::VecDeque;
 
 pub trait Unit {
-    fn is_unit(&self) -> bool {
-        true
+  fn is_unit(&self) -> bool {
+    true
+  }
+
+  fn get_owner(&self) -> Players;
+
+  fn get_tag(&self) -> char;
+
+  fn get_name(&self) -> &'static str;
+
+  fn get_hp(&self) -> u16;
+
+  fn get_max_hp(&self) -> u16;
+
+  fn get_can_dig(&self) -> bool;
+
+  fn get_digging_power(&self) -> f32;
+
+  fn get_coords(&self) -> (usize, usize);
+
+  fn set_coords(&mut self, coords: (usize, usize));
+
+  fn get_ref_tasks(&self) -> &VecDeque<Tasks>;
+
+  fn get_mut_tasks(&mut self) -> &mut VecDeque<Tasks>;
+
+  fn set_task(&mut self, task: Tasks);
+
+  fn get_tasks_formatted(&self) -> Vec<Line<'_>>;
+
+  fn base_text(&self) -> Vec<Line<'_>> {
+    let owner: Span<'_> = self.get_owner().get_span();
+    let hp: u16 = self.get_hp();
+    let max_hp: u16 = self.get_max_hp();
+    let hp_percent: u16 = hp * 100 / max_hp;
+    let can_dig: bool = self.get_can_dig();
+    let digging_power: f32 = self.get_digging_power();
+    let have_any_tasks: bool = self.get_ref_tasks().is_empty();
+    let tasks: Vec<Line<'_>> = self.get_tasks_formatted();
+
+    let mut lines: Vec<Line<'_>> = Vec::from([
+      Line::from_iter(["Owner: ".gray(), owner]),
+      Line::from_iter([
+        "HP: ".gray(),
+        hp.green(),
+        "/".gray(),
+        max_hp.green(),
+        " ( ".gray(),
+        hp_percent.green(),
+        "% )".gray(),
+      ]),
+    ]);
+
+    if can_dig {
+      lines.push(Line::from_iter([
+        "Digging power: ".gray(),
+        digging_power.green(),
+      ]));
     }
 
-    fn get_owner(&self) -> Players;
-
-    fn get_tag(&self) -> char;
-
-    fn get_name(&self) -> &'static str;
-
-    fn get_hp(&self) -> u16;
-
-    fn get_max_hp(&self) -> u16;
-
-    fn get_can_dig(&self) -> bool;
-
-    fn get_digging_power(&self) -> f32;
-
-    fn get_coords(&self) -> (usize, usize);
-
-    fn set_coords(&mut self, coords: (usize, usize));
-
-    fn get_ref_tasks(&self) -> &VecDeque<Tasks>;
-
-    fn get_mut_tasks(&mut self) -> &mut VecDeque<Tasks>;
-
-    fn set_task(&mut self, task: Tasks);
-
-    fn get_tasks_formatted(&self) -> Vec<Line<'_>>;
-
-    fn base_text(&self) -> Vec<Line<'_>> {
-        let owner: Span<'_> = self.get_owner().get_span();
-        let hp: u16 = self.get_hp();
-        let max_hp: u16 = self.get_max_hp();
-        let hp_percent: u16 = hp * 100 / max_hp;
-        let can_dig: bool = self.get_can_dig();
-        let digging_power: f32 = self.get_digging_power();
-        let have_any_tasks: bool = self.get_ref_tasks().is_empty();
-        let tasks: Vec<Line<'_>> = self.get_tasks_formatted();
-
-        let mut lines: Vec<Line<'_>> = Vec::from([
-            Line::from_iter(["Owner: ".gray(), owner]),
-            Line::from_iter([
-                "HP: ".gray(),
-                hp.green(),
-                "/".gray(),
-                max_hp.green(),
-                " ( ".gray(),
-                hp_percent.green(),
-                "% )".gray(),
-            ]),
-        ]);
-
-        if can_dig {
-            lines.push(Line::from_iter([
-                "Digging power: ".gray(),
-                digging_power.green(),
-            ]));
-        }
-
-        if !have_any_tasks {
-            lines.push(Line::from("Tasks Queue: ".gray()));
-            for task in tasks {
-                lines.push(task);
-            }
-        }
-
-        lines
+    if !have_any_tasks {
+      lines.push(Line::from("Tasks Queue: ".gray()));
+      for task in tasks {
+        lines.push(task);
+      }
     }
 
-    fn text(&self) -> Vec<Line<'_>> {
-        self.base_text()
-    }
+    lines
+  }
+
+  fn text(&self) -> Vec<Line<'_>> {
+    self.base_text()
+  }
 }

src/app/states/skirmish_states/units/units_enum.rs

@@ -1,147 +1,150 @@
 use crate::app::states::skirmish_states::{
-    Players,
-    tasks::Tasks,
-    units::{MinerUnit, Unit},
+  Players,
+  tasks::Tasks,
+  units::{MinerUnit, Unit},
 };
 use ratatui::text::Line;
 use std::collections::VecDeque;
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Units {
-    Miner(MinerUnit),
+  Miner(MinerUnit),
 }
 
 impl Units {
-    #[inline]
-    pub fn u(&self) -> &dyn Unit {
-        match self {
-            Self::Miner(m) => m,
-        }
+  #[inline]
+  pub fn u(&self) -> &dyn Unit {
+    match self {
+      Self::Miner(m) => m,
     }
+  }
 
-    #[inline]
-    pub fn u_mut(&mut self) -> &mut dyn Unit {
-        match self {
-            Self::Miner(m) => m,
-        }
+  #[inline]
+  pub fn u_mut(&mut self) -> &mut dyn Unit {
+    match self {
+      Self::Miner(m) => m,
     }
+  }
 }
 
 impl Unit for Units {
-    fn get_tag(&self) -> char {
-        self.u().get_tag()
-    }
+  fn get_tag(&self) -> char {
+    self.u().get_tag()
+  }
 
-    fn get_name(&self) -> &'static str {
-        self.u().get_name()
-    }
+  fn get_name(&self) -> &'static str {
+    self.u().get_name()
+  }
 
-    fn get_owner(&self) -> Players {
-        self.u().get_owner()
-    }
+  fn get_owner(&self) -> Players {
+    self.u().get_owner()
+  }
 
-    fn get_hp(&self) -> u16 {
-        self.u().get_hp()
-    }
+  fn get_hp(&self) -> u16 {
+    self.u().get_hp()
+  }
 
-    fn get_max_hp(&self) -> u16 {
-        self.u().get_max_hp()
-    }
+  fn get_max_hp(&self) -> u16 {
+    self.u().get_max_hp()
+  }
 
-    fn get_can_dig(&self) -> bool {
-        self.u().get_can_dig()
-    }
+  fn get_can_dig(&self) -> bool {
+    self.u().get_can_dig()
+  }
 
-    fn get_digging_power(&self) -> f32 {
-        self.u().get_digging_power()
-    }
+  fn get_digging_power(&self) -> f32 {
+    self.u().get_digging_power()
+  }
 
-    fn get_coords(&self) -> (usize, usize) {
-        self.u().get_coords()
-    }
+  fn get_coords(&self) -> (usize, usize) {
+    self.u().get_coords()
+  }
 
-    fn set_coords(&mut self, coords: (usize, usize)) {
-        self.u_mut().set_coords(coords);
-    }
+  fn set_coords(&mut self, coords: (usize, usize)) {
+    self.u_mut().set_coords(coords);
+  }
 
-    fn get_ref_tasks(&self) -> &VecDeque<Tasks> {
-        self.u().get_ref_tasks()
-    }
+  fn get_ref_tasks(&self) -> &VecDeque<Tasks> {
+    self.u().get_ref_tasks()
+  }
 
-    fn get_mut_tasks(&mut self) -> &mut VecDeque<Tasks> {
-        self.u_mut().get_mut_tasks()
-    }
+  fn get_mut_tasks(&mut self) -> &mut VecDeque<Tasks> {
+    self.u_mut().get_mut_tasks()
+  }
 
-    fn get_tasks_formatted(&self) -> Vec<Line<'_>> {
-        self.u().get_tasks_formatted()
-    }
+  fn get_tasks_formatted(&self) -> Vec<Line<'_>> {
+    self.u().get_tasks_formatted()
+  }
 
-    fn set_task(&mut self, task: Tasks) {
-        self.u_mut().set_task(task);
-    }
+  fn set_task(&mut self, task: Tasks) {
+    self.u_mut().set_task(task);
+  }
 }
 
 impl Unit for Option<Units> {
-    fn is_unit(&self) -> bool {
-        self.as_ref().map_or(false, |u| u.is_unit())
-    }
+  fn is_unit(&self) -> bool {
+    self.as_ref().map_or(false, |u| u.is_unit())
+  }
 
-    fn get_tag(&self) -> char {
-        self.as_ref().map_or(' ', |u| u.get_tag())
-    }
+  fn get_tag(&self) -> char {
+    self.as_ref().map_or(' ', |u| u.get_tag())
+  }
 
-    fn get_name(&self) -> &'static str {
-        self.as_ref().map_or("", |u| u.get_name())
-    }
+  fn get_name(&self) -> &'static str {
+    self.as_ref().map_or("", |u| u.get_name())
+  }
 
-    fn get_owner(&self) -> Players {
-        self.as_ref().map_or(Players::Unclaimed, |u| u.get_owner())
-    }
+  fn get_owner(&self) -> Players {
+    self.as_ref().map_or(Players::Unclaimed, |u| u.get_owner())
+  }
 
-    fn get_hp(&self) -> u16 {
-        self.as_ref().map_or(0, |u| u.get_hp())
-    }
+  fn get_hp(&self) -> u16 {
+    self.as_ref().map_or(0, |u| u.get_hp())
+  }
 
-    fn get_max_hp(&self) -> u16 {
-        self.as_ref().map_or(0, |u| u.get_max_hp())
-    }
+  fn get_max_hp(&self) -> u16 {
+    self.as_ref().map_or(0, |u| u.get_max_hp())
+  }
 
-    fn get_can_dig(&self) -> bool {
-        self.as_ref().map_or(false, |u| u.get_can_dig())
-    }
+  fn get_can_dig(&self) -> bool {
+    self.as_ref().map_or(false, |u| u.get_can_dig())
+  }
 
-    fn get_digging_power(&self) -> f32 {
-        self.as_ref().map_or(0.0, |u| u.get_digging_power())
-    }
+  fn get_digging_power(&self) -> f32 {
+    self.as_ref().map_or(0.0, |u| u.get_digging_power())
+  }
 
-    fn get_coords(&self) -> (usize, usize) {
-        self.as_ref().map_or((0, 0), |u| u.get_coords())
-    }
+  fn get_coords(&self) -> (usize, usize) {
+    self.as_ref().map_or((0, 0), |u| u.get_coords())
+  }
 
-    fn set_coords(&mut self, coords: (usize, usize)) {
-        if let Some(unit) = self.as_mut() {
-            unit.set_coords(coords);
-        }
+  fn set_coords(&mut self, coords: (usize, usize)) {
+    if let Some(unit) = self.as_mut() {
+      unit.set_coords(coords);
     }
+  }
 
-    fn get_ref_tasks(&self) -> &VecDeque<Tasks> {
-        self.as_ref()
-            .expect("attempted to get referenced tasks from `None`")
-            .get_ref_tasks()
-    }
+  fn get_ref_tasks(&self) -> &VecDeque<Tasks> {
+    self
+      .as_ref()
+      .expect("attempted to get referenced tasks from `None`")
+      .get_ref_tasks()
+  }
 
-    fn get_mut_tasks(&mut self) -> &mut VecDeque<Tasks> {
-        self.as_mut()
-            .expect("attempted to get mutable tasks from `None`")
-            .get_mut_tasks()
-    }
+  fn get_mut_tasks(&mut self) -> &mut VecDeque<Tasks> {
+    self
+      .as_mut()
+      .expect("attempted to get mutable tasks from `None`")
+      .get_mut_tasks()
+  }
 
-    fn get_tasks_formatted(&self) -> Vec<Line<'_>> {
-        self.as_ref()
-            .map_or(Vec::new(), |u| u.get_tasks_formatted())
-    }
+  fn get_tasks_formatted(&self) -> Vec<Line<'_>> {
+    self
+      .as_ref()
+      .map_or(Vec::new(), |u| u.get_tasks_formatted())
+  }
 
-    fn set_task(&mut self, task: Tasks) {
-        self.as_mut().map_or((), |u| u.set_task(task))
-    }
+  fn set_task(&mut self, task: Tasks) {
+    self.as_mut().map_or((), |u| u.set_task(task))
+  }
 }