Merge branch 'develop' of ssh://mnml.gg:40022/~/mnml into develop

server/src/player.rs

@@ -136,12 +136,18 @@ impl Player {
                 }
 
                 // get 2 colours and something else
-                if self.vbox.free[0].len() < 2 {
+                let free_colours = self.vbox.free[0].iter().fold(0, |count, item| {
+                    match item.is_some() {
+                        true => count + 1,
+                        false => count
+                    }
+                });
+                if free_colours < 2 {
                     break;
                 }
-                self.vbox_accept(0, 0).expect("could't accept colour 0");
+                self.bot_vbox_accept(0).expect("could't accept colour 0");
-                self.vbox_accept(0, 0).expect("could't accept colour 1");
+                self.bot_vbox_accept(0).expect("could't accept colour 1");
-                self.vbox_accept(group_i, 0).expect("could't accept group 0");
+                self.bot_vbox_accept(group_i).expect("could't accept group 0");
             }
 
             // info!("{:?}", self.vbox.bound);
@@ -168,6 +174,11 @@ impl Player {
         Ok(self)
     }
 
+    pub fn bot_vbox_accept(&mut self, group: usize) -> Result<&mut Player, Error> {
+        self.vbox.bot_accept(group)?;
+        Ok(self)
+    }
+
     pub fn vbox_accept(&mut self, group: usize, index: usize) -> Result<&mut Player, Error> {
         self.vbox.accept(group, index)?;
         Ok(self)

server/src/vbox.rs

@@ -22,7 +22,7 @@ use item::*;
 #[derive(Debug,Clone,Serialize,Deserialize)]
 pub struct Vbox {
     pub bits: u16,
-    pub free: Vec<Vec<Item>>,
+    pub free: Vec<Vec<Option<Item>>>,
     pub bound: Vec<Item>,
 }
 
@@ -69,35 +69,32 @@ impl Vbox {
             .map(|item_type| {
                 let items = match item_type {
                     ItemType::Colours => vec![
-                        (Item::Red, 1),
+                        (Some(Item::Red), 1),
-                        (Item::Green, 1),
+                        (Some(Item::Green), 1),
-                        (Item::Blue, 1),
+                        (Some(Item::Blue), 1),
                     ],
                     ItemType::Skills => vec![
-                        (Item::Attack, 1),
+                        (Some(Item::Attack), 1),
-                        (Item::Block, 1),
+                        (Some(Item::Block), 1),
-                        (Item::Buff, 1),
+                        (Some(Item::Buff), 1),
-                        (Item::Debuff, 1),
+                        (Some(Item::Debuff), 1),
-                        (Item::Stun, 1),
+                        (Some(Item::Stun), 1),
                     ],
                     ItemType::Specs => vec![
-                        (Item::Power, 1),
+                        (Some(Item::Power), 1),
-                        (Item::Life, 1),
+                        (Some(Item::Life), 1),
-                        (Item::Speed, 1),
+                        (Some(Item::Speed), 1),
                     ],
                 };
 
                 let dist = WeightedIndex::new(items.iter().map(|item| item.1)).unwrap();
-                iter::repeat_with(|| {
+                iter::repeat_with(|| { 
-                    items[dist.sample(&mut rng)].0
+                    items[dist.sample(&mut rng)].0}).take(match item_type {
+                        ItemType::Colours => 6,
+                        _ => 3,
+                    }).collect::<Vec<Option<Item>>>()
                 })
-                .take(match item_type {
+            .collect::<Vec<Vec<Option<Item>>>>();
-                    ItemType::Colours => 6,
-                    _ => 3,
-                })
-                .collect::<Vec<Item>>()
-            })
-            .collect::<Vec<Vec<Item>>>();
 
         self
     }
@@ -113,16 +110,29 @@ impl Vbox {
             .get(j).ok_or(format_err!("no item at index {:?}", j))?;
 
         // check can purchase
-        let cost = self.free[i][j].cost();
+        let cost = match self.free[i][j] {
+            None => 0,
+            _ => self.free[i][j].unwrap().cost()
+        };
         self.balance_sub(cost)?;
 
         // actually move
-        self.bound.push(self.free[i].remove(j));
+        match self.free[i][j] {
+            None => (),
+            _ => self.bound.push(self.free[i][j].unwrap())
+        }
+        // self.bound.push(self.free[i][j].unwrap());
+        self.free[i][j] = None;
         // self.bound.sort_unstable();
 
         Ok(self)
     }
 
+    pub fn bot_accept(&mut self, i: usize) -> Result<&mut Vbox, Error> {
+        let buy_index = self.free[i].iter().position(|item| item.is_some());
+        self.accept(i, buy_index.expect("no valid buys"))
+    }
+
     pub fn reclaim(&mut self, i: usize) -> Result<&mut Vbox, Error> {
         self.bound.get(i).ok_or(format_err!("no item at index {:?}", i))?;
         let reclaimed = self.bound.remove(i);