Merge branch 'vbox-combine' into develop

server/src/instance.rs

@@ -480,10 +480,10 @@ impl Instance {
         Ok(self)
     }
 
-    pub fn vbox_combine(mut self, account: Uuid, indices: Vec<usize>) -> Result<Instance, Error> {
+    pub fn vbox_combine(mut self, account: Uuid, inv_indices: Vec<usize>, vbox_indices: Vec<Vec<usize>>) -> Result<Instance, Error> {
         self.vbox_action_allowed(account)?;
         self.account_player(account)?
-            .vbox_combine(indices)?;
+            .vbox_combine(inv_indices, vbox_indices)?;
         Ok(self)
     }
 

server/src/player.rs

@@ -229,7 +229,7 @@ impl Player {
             };
 
             // first 2 colours can be whatever
-            self.vbox_combine(vec![0, 1, combo_i]).ok();
+            self.vbox_combine(vec![0, 1, combo_i], vec![]).ok();
             let item_i = self.vbox.bound.len() - 1;
             self.vbox_apply(item_i, target_construct_id).ok();
         }
@@ -257,8 +257,8 @@ impl Player {
         Ok(self)
     }
 
-    pub fn vbox_combine(&mut self, indices: Vec<usize>) -> Result<&mut Player, Error> {
-        self.vbox.combine(indices)?;
+    pub fn vbox_combine(&mut self, inv_indices: Vec<usize>, vbox_indices: Vec<Vec<usize>>) -> Result<&mut Player, Error> {
+        self.vbox.combine(inv_indices, vbox_indices)?;
         Ok(self)
     }
 

server/src/rpc.rs

@@ -117,7 +117,7 @@ pub enum RpcRequest {
     VboxAccept { instance_id: Uuid, group: usize, index: usize },
     VboxAcceptEquip { instance_id: Uuid, group: usize, index: usize, construct_id: Uuid },
     VboxDiscard { instance_id: Uuid },
-    VboxCombine { instance_id: Uuid, indices: Vec<usize> },
+    VboxCombine { instance_id: Uuid, inv_indices: Vec<usize>, vbox_indices: Vec<Vec<usize>> },
     VboxApply { instance_id: Uuid, construct_id: Uuid, index: usize },
     VboxUnequip { instance_id: Uuid, construct_id: Uuid, target: Item },
     VboxUnequipApply { instance_id: Uuid, construct_id: Uuid, target: Item, target_construct_id: Uuid },
@@ -254,8 +254,8 @@ impl Connection {
                             RpcRequest::VboxApply { instance_id, construct_id, index } =>
                                 Ok(RpcMessage::InstanceState(vbox_apply(&mut tx, account, instance_id, construct_id, index)?)),
 
-                            RpcRequest::VboxCombine { instance_id, indices } =>
-                                Ok(RpcMessage::InstanceState(vbox_combine(&mut tx, account, instance_id, indices)?)),
+                            RpcRequest::VboxCombine { instance_id, inv_indices, vbox_indices } =>
+                                Ok(RpcMessage::InstanceState(vbox_combine(&mut tx, account, instance_id, inv_indices, vbox_indices)?)),
 
                             RpcRequest::VboxDiscard { instance_id } =>
                                 Ok(RpcMessage::InstanceState(vbox_discard(&mut tx, account, instance_id)?)),

server/src/vbox.rs

@@ -142,19 +142,20 @@ impl Vbox {
         Ok(self)
     }
 
-    pub fn combine(&mut self, mut indices: Vec<usize>) -> Result<&mut Vbox, Error> {
-        if indices.len() != 3 {
-            return Err(err_msg("exactly 3 indices required"));
-        }
-
-        if !indices.iter().all(|i| self.bound.get(*i).is_some()) {
+    pub fn combine(&mut self, mut inv_indices: Vec<usize>, vbox_indicies: Vec<Vec<usize>>) -> Result<&mut Vbox, Error> {
+        if !inv_indices.iter().all(|i| self.bound.get(*i).is_some()) {
             return Err(err_msg("item missing index"));
         }
+        // try to buy up the vbox indicies and add them to the inventory indicies for combining
+        for vi in vbox_indicies.iter() {
+            inv_indices.push(self.bound.len());
+            self.accept(vi[0], vi[1], Some(Uuid::nil()))?;
+        } 
 
         // have to sort the indices and keep track of the iteration
         // because when removing the elements the array shifts
-        indices.sort_unstable();
-        let mut input = indices
+        inv_indices.sort_unstable();
+        let mut input = inv_indices
             .iter()
             .enumerate()
             .map(|(i, index)| {
@@ -170,7 +171,9 @@ impl Vbox {
 
         self.bound.push(combo.item);
         // self.bound.sort_unstable();
-
+        if self.bound.len() >= 10 {
+            return Err(err_msg("too many items bound"));
+        }
         Ok(self)
     }
 }
@@ -187,9 +190,9 @@ pub fn vbox_accept(tx: &mut Transaction, account: &Account, instance_id: Uuid, g
     return instance_update(tx, instance);
 }
 
-pub fn vbox_combine(tx: &mut Transaction, account: &Account, instance_id: Uuid, indices: Vec<usize>) -> Result<Instance, Error> {
+pub fn vbox_combine(tx: &mut Transaction, account: &Account, instance_id: Uuid, inv_indices: Vec<usize>, vbox_indices: Vec<Vec<usize>>) -> Result<Instance, Error> {
     let instance = instance_get(tx, instance_id)?
-        .vbox_combine(account.id, indices)?;
+        .vbox_combine(account.id, inv_indices, vbox_indices)?;
     return instance_update(tx, instance);
 }
 
@@ -219,7 +222,7 @@ mod tests {
     fn combine_test() {
         let mut vbox = Vbox::new();
         vbox.bound = vec![Item::Attack, Item::Green, Item::Green];
-        vbox.combine(vec![1,2,0]).unwrap();
+        vbox.combine(vec![1,2,0], vec![]).unwrap();
         assert_eq!(vbox.bound[0], Item::Heal);
     }
 
@@ -240,7 +243,7 @@ mod tests {
         let mut vbox = Vbox::new();
         vbox.bound = vec![Item::Strike];
         vbox.reclaim(0).unwrap();
-        assert_eq!(vbox.bits, 20);
+        assert_eq!(vbox.bits, 32);
     }
 
     #[test]