From 6007c2f2edbe124b1b2169ef36a35ffdabc9915c Mon Sep 17 00:00:00 2001
From: Bel LaPointe <153096461+breel-render@users.noreply.github.com>
Date: Thu, 20 Mar 2025 20:12:32 -0600
Subject: [PATCH] dont pass species but rather dex around

---
 src/purerust/src/src.rs | 546 +++++++++++++++++++++-------------------
 1 file changed, 291 insertions(+), 255 deletions(-)

diff --git a/src/purerust/src/src.rs b/src/purerust/src/src.rs
index 0a18403..757d6bd 100755
--- a/src/purerust/src/src.rs
+++ b/src/purerust/src/src.rs
@@ -1,301 +1,337 @@
 pub mod mon {
-   #[derive(Clone, Debug, PartialEq)]
-   pub struct Species {
-      pub name: String,
-      pub hp: i32,
-      pub atk: i32,
-      pub def: i32,
-      pub spd: i32,
-   }
+    #[derive(Clone, Debug, PartialEq)]
+    pub struct Species {
+        pub name: String,
+        pub hp: i32,
+        pub atk: i32,
+        pub def: i32,
+        pub spd: i32,
+    }
 
-   #[cfg(test)]
-   mod species_tests {
-      use super::*;
+    #[cfg(test)]
+    mod species_tests {
+        use super::*;
 
-      #[test]
-      fn test_literal() {
-         let _: Species = Species{
-            name: "".to_string(),
-            hp: 1,
-            atk: 2,
-            def: 3,
-            spd: 4,
-         };
-      }
-   }
+        #[test]
+        fn test_literal() {
+            let _: Species = Species {
+                name: "".to_string(),
+                hp: 1,
+                atk: 2,
+                def: 3,
+                spd: 4,
+            };
+        }
+    }
 
-   #[derive(Clone, Debug, PartialEq)]
-   pub enum Dex {
-      Pika,
-      Mari,
-   }
+    #[derive(Clone, Debug, PartialEq)]
+    pub enum Dex {
+        Pika,
+        Mari,
+    }
 
-   impl Dex {
-      pub fn new(&self) -> Species {
-         self.clone().into()
-      }
-   }
+    impl Dex {
+        pub fn new(&self) -> Species {
+            self.clone().into()
+        }
 
-   impl Into<Species> for Dex {
-      fn into(self) -> Species {
-         match self {
-            Dex::Pika => Species{
-               name: "Pika".to_string(),
-               hp: 10,
-               atk: 11,
-               def: 9,
-               spd: 11,
-            },
-            Dex::Mari => Species{
-               name: "Mari".to_string(),
-               hp: 10,
-               atk: 8,
-               def: 12,
-               spd: 9,
-            },
-         }
-      }
-   }
+        pub fn name(&self) -> String {
+            self.new().name
+        }
 
-   #[cfg(test)]
-   mod dex_tests {
-      use super::*;
+        pub fn hp(&self) -> i32 {
+            self.new().hp
+        }
 
-      #[test]
-      fn test_dex_to_species() {
-         let dex = Dex::Pika;
-         let _: Species = dex.new();
-         let _: Species = dex.into();
-         let _: Species = Dex::Pika.new();
-         let _: Species = Dex::Pika.into();
-      }
-   }
+        pub fn atk(&self) -> i32 {
+            self.new().atk
+        }
 
-   #[derive(Clone, Debug)]
-   pub struct Instance {
-      pub species: Species,
-      pub damage: i32,
-   }
+        pub fn def(&self) -> i32 {
+            self.new().def
+        }
 
-   impl Instance {
-      pub fn roll(dex: Dex) -> Instance {
-         Instance{
-            species: dex.into(),
-            damage: 0,
-         }
-      }
-   }
+        pub fn spd(&self) -> i32 {
+            self.new().spd
+        }
+    }
 
-   #[cfg(test)]
-   mod instance_tests {
-      use super::*;
+    impl Into<Species> for Dex {
+        fn into(self) -> Species {
+            match self {
+                Dex::Pika => Species {
+                    name: "Pika".to_string(),
+                    hp: 10,
+                    atk: 11,
+                    def: 9,
+                    spd: 11,
+                },
+                Dex::Mari => Species {
+                    name: "Mari".to_string(),
+                    hp: 10,
+                    atk: 8,
+                    def: 12,
+                    spd: 9,
+                },
+            }
+        }
+    }
 
-      #[test]
-      fn test_instance_roll() {
-         let i: Instance = Instance::roll(Dex::Pika);
-         assert_eq!(0, i.damage);
-         assert_eq!(Dex::Pika.new(), i.species);
-      }
-   }
+    #[cfg(test)]
+    mod dex_tests {
+        use super::*;
+
+        #[test]
+        fn test_dex_to_species() {
+            let dex = Dex::Pika;
+            let _: Species = dex.new();
+            let _: Species = dex.into();
+            let _: Species = Dex::Pika.new();
+            let _: Species = Dex::Pika.into();
+        }
+    }
+
+    #[derive(Clone, Debug)]
+    pub struct Instance {
+        pub dex: Dex,
+        pub damage: i32,
+    }
+
+    impl Instance {
+        pub fn roll(dex: Dex) -> Instance {
+            Instance {
+                dex: dex,
+                damage: 0,
+            }
+        }
+    }
+
+    #[cfg(test)]
+    mod instance_tests {
+        use super::*;
+
+        #[test]
+        fn test_instance_roll() {
+            let i: Instance = Instance::roll(Dex::Pika);
+            assert_eq!(0, i.damage);
+            assert_eq!(Dex::Pika, i.dex);
+        }
+    }
 }
 
 pub mod battle {
-   use super::*;
+    use super::*;
 
-   pub struct Engine {
-      teams: Vec<Team>,
-      q: Vec<Move>,
-   }
+    pub struct Engine {
+        teams: Vec<Team>,
+        q: Vec<Move>,
+    }
 
-   impl Engine {
-      pub fn new(first: Vec<mon::Instance>, second: Vec<mon::Instance>) -> Engine {
-         let mut result = Self{
-            teams: vec![],
-            q: vec![],
-         };
-         result.join(first);
-         result.join(second);
-         result
-      }
-
-      pub fn join(&mut self, third: Vec<mon::Instance>) {
-         self.teams.push(Team::new(third));
-      }
-
-      pub fn enqueue(&mut self, m: Move) {
-         self.q.push(m);
-      }
-
-      pub fn exec(&mut self) {
-         self.turn_order().iter().for_each(|idx| {
-            match self.q[*idx].clone() {
-               Move::Pass(_) => {},
-               Move::Attack(rIdx, wIdx) => {
-                  let r = self.teams[rIdx.team].mons[rIdx.mon].clone();
-                  if r.can_attack() {
-                     let w = self.teams[wIdx.team].mons[wIdx.mon].clone();
-                     if w.can_be_attacked() {
-                        self.teams[wIdx.team].mons[wIdx.mon].mon = Engine::attack(&w.mon, &r.mon);
-                     }
-                  }
-               },
+    impl Engine {
+        pub fn new(first: Vec<mon::Instance>, second: Vec<mon::Instance>) -> Engine {
+            let mut result = Self {
+                teams: vec![],
+                q: vec![],
             };
-         });
-         self.new_turn();
-      }
+            result.join(first);
+            result.join(second);
+            result
+        }
 
-      fn new_turn(&mut self) {
-         self.q = vec![];
-      }
+        pub fn join(&mut self, third: Vec<mon::Instance>) {
+            self.teams.push(Team::new(third));
+        }
 
-      fn turn_order(&self) -> Vec<usize> {
-         let mut order = vec![];
-         for i in 0..self.q.len() {
-            order.push((i, match &self.q[i] {
-               Move::Pass(_) => 0,
-               Move::Attack(w, _) => self.teams[w.team].mons[w.mon].mon.species.spd,
-            }));
-         }
-         order.sort_unstable_by(|a, b| a.1.cmp(&b.1));
-         order.iter().map(|x| x.0).collect()
-      }
+        pub fn enqueue(&mut self, m: Move) {
+            self.q.push(m);
+        }
 
-      fn attack(w: &mon::Instance, r: &mon::Instance) -> mon::Instance {
-         let mut w = w.clone();
-         let atk_delta = r.species.atk - 10;
-         let def_delta = w.species.def - 10;
+        pub fn exec(&mut self) {
+            self.turn_order().iter().for_each(|idx| {
+                match self.q[*idx].clone() {
+                    Move::Pass(_) => {}
+                    Move::Attack(r_idx, w_idx) => {
+                        let r = self.teams[r_idx.team].mons[r_idx.mon].clone();
+                        if r.can_attack() {
+                            let w = self.teams[w_idx.team].mons[w_idx.mon].clone();
+                            if w.can_be_attacked() {
+                                self.teams[w_idx.team].mons[w_idx.mon].mon =
+                                    Engine::attack(&w.mon, &r.mon);
+                            }
+                        }
+                    }
+                };
+            });
+            self.new_turn();
+        }
 
-         let power = match atk_delta - def_delta {
-            v if v < 1 => 1,
-            v => v,
-         };
+        fn new_turn(&mut self) {
+            self.q = vec![];
+        }
 
-         w.damage = match w.damage + power {
-            v if v < w.species.hp => v,
-            _ => w.species.hp,
-         };
+        fn turn_order(&self) -> Vec<usize> {
+            let mut order = vec![];
+            for i in 0..self.q.len() {
+                order.push((
+                    i,
+                    match &self.q[i] {
+                        Move::Pass(_) => 0,
+                        Move::Attack(w, _) => self.teams[w.team].mons[w.mon].mon.dex.new().spd,
+                    },
+                ));
+            }
+            order.sort_unstable_by(|a, b| a.1.cmp(&b.1));
+            order.iter().map(|x| x.0).collect()
+        }
 
-         w
-      }
-   }
+        fn attack(w: &mon::Instance, r: &mon::Instance) -> mon::Instance {
+            let mut w = w.clone();
+            let atk_delta = r.dex.new().atk - 10;
+            let def_delta = w.dex.new().def - 10;
 
-   #[cfg(test)]
-   mod engine_tests {
-      use super::*;
+            let power = match atk_delta - def_delta {
+                v if v < 1 => 1,
+                v => v,
+            };
 
-      #[test]
-      fn test_new() {
-         let mut engine = Engine::new(team_a(), team_b());
-         engine.join(team_b());
-      }
+            w.damage = match w.damage + power {
+                v if v < w.dex.new().hp => v,
+                _ => w.dex.new().hp,
+            };
 
-      #[test]
-      fn test_attack() {
-         let mut pika = mon::Instance::roll(mon::Dex::Pika);
-         let mut mari = mon::Instance::roll(mon::Dex::Mari);
+            w
+        }
+    }
 
-         pika = Engine::attack(&mut pika, &mut mari);
-         assert_eq!(1, pika.damage);
+    #[cfg(test)]
+    mod engine_tests {
+        use super::*;
 
-         mari = Engine::attack(&mut mari, &mut pika);
-         assert_eq!(1, mari.damage);
+        #[test]
+        fn test_new() {
+            let mut engine = Engine::new(team_a(), team_b());
+            engine.join(team_b());
+        }
+
+        #[test]
+        fn test_attack() {
+            let mut pika = mon::Instance::roll(mon::Dex::Pika);
+            let mut mari = mon::Instance::roll(mon::Dex::Mari);
 
-         for _ in 0..pika.species.hp+5 {
             pika = Engine::attack(&mut pika, &mut mari);
-         }
-         assert_eq!(pika.species.hp, pika.damage);
-         assert_eq!(1, mari.damage);
-      }
-      
-      #[test]
-      fn test_turn() {
-         let mut engine = Engine::new(team_a(), team_b());
-         engine.join(team_b());
+            assert_eq!(1, pika.damage);
 
-         // player 0 mon 0 attacks team 1 mon 0
-         engine.enqueue(Move::Attack(Idx{team: 0, mon: 0}, Idx{team: 1, mon: 0}));
-         // player 1 mon 0 passes
-         engine.enqueue(Move::Pass(Idx{team: 1, mon: 0}));
-         // player 1 mon 1 not out
-         engine.exec();
+            mari = Engine::attack(&mut mari, &mut pika);
+            assert_eq!(1, mari.damage);
 
-         assert_eq!(0, engine.teams[0].mons[0].mon.damage);
-         assert_eq!(1, engine.teams[1].mons[0].mon.damage);
-         assert_eq!(0, engine.teams[1].mons[1].mon.damage);
-      }
+            for _ in 0..pika.dex.new().hp + 5 {
+                pika = Engine::attack(&mut pika, &mut mari);
+            }
+            assert_eq!(pika.dex.new().hp, pika.damage);
+            assert_eq!(1, mari.damage);
+        }
 
-      fn team_a() -> Vec<mon::Instance> {
-         vec![mon::Instance::roll(mon::Dex::Pika)]
-      }
+        #[test]
+        fn test_turn() {
+            let mut engine = Engine::new(team_a(), team_b());
+            engine.join(team_b());
 
-      fn team_b() -> Vec<mon::Instance> {
-         vec![mon::Instance::roll(mon::Dex::Mari), mon::Instance::roll(mon::Dex::Pika)]
-      }
-   }
+            // player 0 mon 0 attacks team 1 mon 0
+            engine.enqueue(Move::Attack(
+                Idx { team: 0, mon: 0 },
+                Idx { team: 1, mon: 0 },
+            ));
+            // player 1 mon 0 passes
+            engine.enqueue(Move::Pass(Idx { team: 1, mon: 0 }));
+            // player 1 mon 1 not out
+            engine.exec();
 
-   #[derive(Debug)]
-   struct Team {
-      mons: Vec<Instance>,
-   }
+            assert_eq!(0, engine.teams[0].mons[0].mon.damage);
+            assert_eq!(1, engine.teams[1].mons[0].mon.damage);
+            assert_eq!(0, engine.teams[1].mons[1].mon.damage);
+        }
 
-   impl Team {
-      fn new(mons: Vec<mon::Instance>) -> Self {
-         assert!(mons.len() > 0);
-         let mut mons: Vec<_> = mons.iter().map(|m| Instance{mon: m.clone(), out: false}).collect();
-         mons[0].out = true;
-         Self{mons: mons}
-      }
-   }
+        fn team_a() -> Vec<mon::Instance> {
+            vec![mon::Instance::roll(mon::Dex::Pika)]
+        }
 
-   #[derive(Clone, Debug)]
-   struct Instance {
-      mon: mon::Instance,
-      out: bool,
-   }
+        fn team_b() -> Vec<mon::Instance> {
+            vec![
+                mon::Instance::roll(mon::Dex::Mari),
+                mon::Instance::roll(mon::Dex::Pika),
+            ]
+        }
+    }
 
-   impl Instance {
-      fn alive(&self) -> bool {
-         self.mon.damage < self.mon.species.hp
-      }
+    #[derive(Debug)]
+    struct Team {
+        mons: Vec<Instance>,
+    }
 
-      fn can_attack(&self) -> bool {
-         self.out && self.alive()
-      }
+    impl Team {
+        fn new(mons: Vec<mon::Instance>) -> Self {
+            assert!(mons.len() > 0);
+            let mut mons: Vec<_> = mons
+                .iter()
+                .map(|m| Instance {
+                    mon: m.clone(),
+                    out: false,
+                })
+                .collect();
+            mons[0].out = true;
+            Self { mons: mons }
+        }
+    }
 
-      fn can_be_attacked(&self) -> bool {
-         self.out && self.alive()
-      }
-   }
+    #[derive(Clone, Debug)]
+    struct Instance {
+        mon: mon::Instance,
+        out: bool,
+    }
 
-   #[cfg(test)]
-   mod instance_tests {
-      use super::*;
+    impl Instance {
+        fn alive(&self) -> bool {
+            self.mon.damage < self.mon.dex.new().hp
+        }
 
-      #[test]
-      fn test_checks() {
-         let mut i = Instance{
-            mon: mon::Instance::roll(mon::Dex::Pika),
-            out: true,
-         };
-         assert_eq!(true, i.alive());
-         assert_eq!(true, i.can_attack());
-         assert_eq!(true, i.can_be_attacked());
-         i.mon.damage = i.mon.species.hp;
-         assert_eq!(false, i.alive());
-         assert_eq!(false, i.can_attack());
-         assert_eq!(false, i.can_be_attacked());
-      }
-   }
+        fn can_attack(&self) -> bool {
+            self.out && self.alive()
+        }
 
-   #[derive(Clone, Debug)]
-   struct Idx {
-      pub team: usize,
-      pub mon: usize,
-   }
+        fn can_be_attacked(&self) -> bool {
+            self.out && self.alive()
+        }
+    }
 
-   #[derive(Clone, Debug)]
-   enum Move {
-      Pass(Idx),
-      Attack(Idx, Idx),
-   }
+    #[cfg(test)]
+    mod instance_tests {
+        use super::*;
+
+        #[test]
+        fn test_checks() {
+            let mut i = Instance {
+                mon: mon::Instance::roll(mon::Dex::Pika),
+                out: true,
+            };
+            assert_eq!(true, i.alive());
+            assert_eq!(true, i.can_attack());
+            assert_eq!(true, i.can_be_attacked());
+            i.mon.damage = i.mon.dex.new().hp;
+            assert_eq!(false, i.alive());
+            assert_eq!(false, i.can_attack());
+            assert_eq!(false, i.can_be_attacked());
+        }
+    }
+
+    #[derive(Clone, Debug)]
+    pub struct Idx {
+        pub team: usize,
+        pub mon: usize,
+    }
+
+    #[derive(Clone, Debug)]
+    pub enum Move {
+        Pass(Idx),
+        Attack(Idx, Idx),
+    }
 }