drop -> reclaim

server/src/rpc.rs

@@ -23,7 +23,7 @@ use skill::{Skill};
 use spec::{Spec};
 use player::{player_state, player_cryps_set, Player};
 use instance::{instance_join, instance_ready};
-use vbox::{vbox_accept, vbox_apply, vbox_discard, vbox_combine, vbox_drop};
+use vbox::{vbox_accept, vbox_apply, vbox_discard, vbox_combine, vbox_reclaim};
 
 pub struct Rpc;
 
@@ -84,7 +84,7 @@ impl Rpc {
                     "player_cryps_set" => Rpc::player_cryps_set(data, &mut tx, account.unwrap(), client),
                     "player_vbox_accept" => Rpc::player_vbox_accept(data, &mut tx, account.unwrap(), client),
                     "player_vbox_apply" => Rpc::player_vbox_apply(data, &mut tx, account.unwrap(), client),
-                    "player_vbox_drop" => Rpc::player_vbox_drop(data, &mut tx, account.unwrap(), client),
+                    "player_vbox_reclaim" => Rpc::player_vbox_reclaim(data, &mut tx, account.unwrap(), client),
                     "player_vbox_combine" => Rpc::player_vbox_combine(data, &mut tx, account.unwrap(), client),
                     "player_vbox_discard" => Rpc::player_vbox_discard(data, &mut tx, account.unwrap(), client),
 
@@ -354,12 +354,12 @@ impl Rpc {
         return Ok(response);
     }
 
-    fn player_vbox_drop(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
-        let msg = from_slice::<VboxDropMsg>(&data).or(Err(err_msg("invalid params")))?;
+    fn player_vbox_reclaim(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
+        let msg = from_slice::<VboxReclaimMsg>(&data).or(Err(err_msg("invalid params")))?;
 
         let response = RpcResponse {
             method: "player_state".to_string(),
-            params: RpcResult::PlayerState(vbox_drop(msg.params, tx, &account)?)
+            params: RpcResult::PlayerState(vbox_reclaim(msg.params, tx, &account)?)
         };
 
         return Ok(response);
@@ -633,13 +633,13 @@ pub struct VboxApplyParams {
 }
 
 #[derive(Debug,Clone,Serialize,Deserialize)]
-struct VboxDropMsg {
+struct VboxReclaimMsg {
     method: String,
-    params: VboxDropParams,
+    params: VboxReclaimParams,
 }
 
 #[derive(Debug,Clone,Serialize,Deserialize)]
-pub struct VboxDropParams {
+pub struct VboxReclaimParams {
     pub instance_id: Uuid,
     pub index: usize,
 }

server/src/vbox.rs

@@ -1,7 +1,7 @@
 use std::iter;
 use uuid::Uuid;
 
-// drops
+// reclaims
 use rand::prelude::*;
 use rand::{thread_rng};
 use rand::distributions::{WeightedIndex};
@@ -12,7 +12,7 @@ use failure::Error;
 use failure::err_msg;
 
 use account::Account;
-use rpc::{VboxAcceptParams, VboxDiscardParams, VboxCombineParams, VboxApplyParams, VboxDropParams};
+use rpc::{VboxAcceptParams, VboxDiscardParams, VboxCombineParams, VboxApplyParams, VboxReclaimParams};
 use skill::{Skill};
 use spec::{Spec};
 use player::{Player, player_get, player_update};
@@ -340,11 +340,11 @@ impl Vbox {
         Ok(self)
     }
 
-    pub fn drop(&mut self, i: usize) -> Result<&mut Vbox, Error> {
+    pub fn reclaim(&mut self, i: usize) -> Result<&mut Vbox, Error> {
         self.bound.get(i).ok_or(format_err!("no var at index {:?}", i))?;
-        let dropped = self.bound.remove(i);
-        let refund = dropped.cost();
-        println!("refunding {:?} for {:?}", refund, dropped);
+        let reclaimed = self.bound.remove(i);
+        let refund = reclaimed.cost();
+        println!("reclaiming {:?} for {:?}", refund, reclaimed);
         self.balance_add(refund);
         Ok(self)
     }
@@ -402,9 +402,9 @@ pub fn vbox_combine(params: VboxCombineParams, tx: &mut Transaction, account: &A
     return player_update(tx, player, false);
 }
 
-pub fn vbox_drop(params: VboxDropParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
+pub fn vbox_reclaim(params: VboxReclaimParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
     let mut player = player_get(tx, account.id, params.instance_id)?;
-    player.vbox.drop(params.index)?;
+    player.vbox.reclaim(params.index)?;
     return player_update(tx, player, false);
 }
 
@@ -462,10 +462,10 @@ mod tests {
     }
 
     #[test]
-    fn drop_test() {
+    fn reclaim_test() {
         let mut vbox = Vbox::new(Uuid::new_v4(), Uuid::new_v4());
         vbox.bound = vec![Var::Strike];
-        vbox.drop(0).unwrap();
+        vbox.reclaim(0).unwrap();
         assert_eq!(vbox.bits, 22);
     }