diff --git a/client/src/components/game.component.jsx b/client/src/components/game.component.jsx
index d9aaa8f4..008f141a 100644
--- a/client/src/components/game.component.jsx
+++ b/client/src/components/game.component.jsx
@@ -18,7 +18,7 @@ function GamePanel(props) {
         setActiveSkill,
         setActiveCryp,
         selectSkillTarget,
-        sendPlayerState,
+        sendInstanceState,
         activeCryp,
         account,
         showLog,
@@ -50,7 +50,7 @@ function GamePanel(props) {
 
     function backClick() {
         quit();
-        return sendPlayerState(game.instance);
+        return sendInstanceState(game.instance);
     }
 
     const header = (
diff --git a/client/src/components/game.container.jsx b/client/src/components/game.container.jsx
index 644e9554..e2be7224 100644
--- a/client/src/components/game.container.jsx
+++ b/client/src/components/game.container.jsx
@@ -23,9 +23,9 @@ const addState = connect(
             return false;
         }
 
-        function sendPlayerState(instanceId) {
+        function sendInstanceState(instanceId) {
             if (!instanceId) return false;
-            return ws.sendPlayerState(instanceId);
+            return ws.sendInstanceState(instanceId);
         }
 
         // intercept self casting skills
@@ -41,7 +41,7 @@ const addState = connect(
             activeSkill,
             activeCryp,
             selectSkillTarget,
-            sendPlayerState,
+            sendInstanceState,
         };
     },
 
diff --git a/client/src/components/menu.component.jsx b/client/src/components/menu.component.jsx
index c469d042..03dd167f 100644
--- a/client/src/components/menu.component.jsx
+++ b/client/src/components/menu.component.jsx
@@ -20,7 +20,7 @@ function Menu(args) {
         cryps,
         selectedCryps,
         setSelectedCryps,
-        sendPlayerState,
+        sendInstanceState,
         sendPlayerMmCrypsSet,
         sendInstanceJoin,
         sendCrypSpawn,
@@ -40,7 +40,7 @@ function Menu(args) {
                 <button
                     className={`menu-instance-btn right ${globalInstance ? 'full' : ''}`}
                     key={instance.id}
-                    onClick={() => sendPlayerState(instance)}>
+                    onClick={() => sendInstanceState(instance)}>
                     {name}
                 </button>
             );
diff --git a/client/src/components/menu.container.jsx b/client/src/components/menu.container.jsx
index 44f56952..dfd5b567 100644
--- a/client/src/components/menu.container.jsx
+++ b/client/src/components/menu.container.jsx
@@ -25,15 +25,15 @@ const addState = connect(
             return ws.sendCrypSpawn(name);
         }
 
-        function sendPlayerState(instance) {
-            return ws.sendPlayerState(instance.instance);
+        function sendInstanceState(instance) {
+            return ws.sendInstanceState(instance.instance);
         }
 
         return {
             cryps,
             selectedCryps,
             sendInstanceJoin,
-            sendPlayerState,
+            sendInstanceState,
             sendCrypSpawn,
             sendPlayerMmCrypsSet,
             instances,
diff --git a/client/src/socket.jsx b/client/src/socket.jsx
index 6290c5ba..a09e48c9 100644
--- a/client/src/socket.jsx
+++ b/client/src/socket.jsx
@@ -86,8 +86,8 @@ function createSocket(events) {
         send({ method: 'player_mm_cryps_set', params: { cryp_ids: crypIds } });
     }
 
-    function sendPlayerState(instanceId) {
-        send({ method: 'player_state', params: { instance_id: instanceId } });
+    function sendInstanceState(instanceId) {
+        send({ method: 'instanceState', params: { instance_id: instanceId } });
     }
 
     function sendVboxAccept(instanceId, group, index) {
@@ -205,7 +205,7 @@ function createSocket(events) {
         events.setZone(zone);
     }
 
-    function playerState(response) {
+    function instanceState(response) {
         const [structName, player] = response;
         events.setPlayer(player);
     }
@@ -234,7 +234,7 @@ function createSocket(events) {
         zone_create: res => console.log(res),
         zone_state: zoneState,
         zone_close: res => console.log(res),
-        player_state: playerState,
+        instanceState: instanceState,
     };
 
     function logout() {
@@ -337,7 +337,7 @@ function createSocket(events) {
         sendInstanceLobby,
         sendInstanceScores,
         sendPlayerMmCrypsSet,
-        sendPlayerState,
+        sendInstanceState,
         sendVboxAccept,
         sendVboxApply,
         sendVboxReclaim,
diff --git a/server/src/instance.rs b/server/src/instance.rs
index f329f1e4..7351965d 100644
--- a/server/src/instance.rs
+++ b/server/src/instance.rs
@@ -9,12 +9,13 @@ use failure::err_msg;
 
 use std::iter;
 
-use rpc::{InstanceLobbyParams, InstanceJoinParams, InstanceReadyParams};
+use rpc::{InstanceLobbyParams, InstanceJoinParams, InstanceReadyParams, InstanceStateParams};
 use account::Account;
 use player::{Player, Score, player_create, player_get, player_update};
 use cryp::{Cryp, cryp_get};
 use mob::{instance_mobs};
 use game::{Game, Team, game_get, game_write, game_instance_new, game_instance_join, game_global_get, game_global_set};
+use vbox::{Var};
 
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
 enum InstancePhase {
@@ -57,6 +58,19 @@ impl Instance {
         }
     }
 
+    pub fn global(player: Player) -> Instance {
+        Instance {
+            id: Uuid::nil(),
+            players: vec![player],
+            rounds: vec![],
+            phase: InstancePhase::Vbox,
+            open: false,
+            max_players: 0,
+            name: "Global Matchmaking".to_string(),
+            password: None,
+        }
+    }
+
     fn set_max_players(mut self, max: usize) -> Result<Instance, Error> {
         if max > 16 || max % 2 != 0 {
             return Err(err_msg("max players must be divisible by 2 and less than 16"));
@@ -189,7 +203,10 @@ impl Instance {
     fn vbox_phase_start(&mut self) -> &mut Instance {
         self.phase = InstancePhase::Vbox;
 
-        self.players.iter_mut().for_each(|p| p.ready = false);
+        self.players.iter_mut().for_each(|p| {
+            p.ready = false;
+            p.vbox.fill();
+        });
         self.generate_rounds();
         self.bot_vbox_phase();
 
@@ -352,6 +369,50 @@ impl Instance {
 
         scores
     }
+
+    // PLAYER ACTIONS
+    fn account_player(&mut self, account: Uuid) -> Result<&mut Player, Error> {
+        self.players
+            .iter_mut()
+            .find(|p| p.account == account)
+            .ok_or(err_msg("account not in instance"))
+    }
+
+    pub fn vbox_discard(mut self, account: Uuid) -> Result<Instance, Error> {
+        self.account_player(account)?
+            .vbox_discard()?;
+        Ok(self)
+    }
+
+    pub fn vbox_accept(mut self, account: Uuid, group: usize, index: usize) -> Result<Instance, Error> {
+        self.account_player(account)?
+            .vbox_accept(group, index)?;
+        Ok(self)
+    }
+
+    pub fn vbox_combine(mut self, account: Uuid, indices: Vec<usize>) -> Result<Instance, Error> {
+        self.account_player(account)?
+            .vbox_combine(indices)?;
+        Ok(self)
+    }
+
+    pub fn vbox_reclaim(mut self, account: Uuid, index: usize) -> Result<Instance, Error> {
+        self.account_player(account)?
+            .vbox_reclaim(index)?;
+        Ok(self)
+    }
+
+    pub fn vbox_apply(mut self, account: Uuid, index: usize, cryp_id: Uuid) -> Result<Instance, Error> {
+        self.account_player(account)?
+            .vbox_apply(index, cryp_id)?;
+        Ok(self)
+    }
+
+    pub fn vbox_unequip(mut self, account: Uuid, target: Var, cryp_id: Uuid) -> Result<Instance, Error> {
+        self.account_player(account)?
+            .vbox_unequip(target, cryp_id)?;
+        Ok(self)
+    }
 }
 
 pub fn instance_create(tx: &mut Transaction, instance: Instance) -> Result<Instance, Error> {
@@ -433,7 +494,7 @@ pub fn instance_get_open(tx: &mut Transaction) -> Result<Instance, Error> {
     return Ok(instance);
 }
 
-pub fn instance_lobby(params: InstanceLobbyParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
+pub fn instance_lobby(params: InstanceLobbyParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
     let mut instance = Instance::new()
         .set_max_players(params.players)?
         .set_name(params.name)?;
@@ -445,7 +506,7 @@ pub fn instance_lobby(params: InstanceLobbyParams, tx: &mut Transaction, account
 }
 
 
-pub fn instance_join(params: InstanceJoinParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
+pub fn instance_join(params: InstanceJoinParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
     let mut instance = instance_get(tx, params.instance_id)?;
 
     let cryps = params.cryp_ids
@@ -458,12 +519,9 @@ pub fn instance_join(params: InstanceJoinParams, tx: &mut Transaction, account:
     }
 
     let player = Player::new(account.id, instance.id, &account.name, cryps);
-    let player = player_create(tx, player, account)?;
+    instance.add_player(player);
 
-    instance.add_player(player.clone());
-    instance_update(tx, instance)?;
-
-    return Ok(player);
+    instance_update(tx, instance)
 }
 
 pub fn instance_ready_global(tx: &mut Transaction, _account: &Account, player: Player) -> Result<Game, Error> {
@@ -492,21 +550,16 @@ pub fn instance_scores(params: InstanceReadyParams, tx: &mut Transaction, _accou
     Ok(scores)
 }
 
-pub fn instance_lobby_ready(params: InstanceReadyParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
+pub fn instance_ready(params: InstanceReadyParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
     let player = player_get(tx, account.id, params.instance_id)?;
     let mut instance = instance_get(tx, params.instance_id)?;
     instance.player_ready(player.id)?;
 
-    if instance.can_start() {
-        instance.start();
-        for player in instance.players.iter_mut().filter(|p| !p.bot) {
-            player.vbox.fill();
-            player_update(tx, player.clone(), false)?;
-        }
-    }
+    instance_update(tx, instance)
+}
 
-    instance_update(tx, instance)?;
-    Ok(player)
+pub fn instance_state(params: InstanceStateParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
+    instance_get(tx, params.instance_id)
 }
 
 // pub fn instance_ready(params: InstanceReadyParams, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {
diff --git a/server/src/player.rs b/server/src/player.rs
index 5ee70cde..2016fa6b 100644
--- a/server/src/player.rs
+++ b/server/src/player.rs
@@ -11,8 +11,8 @@ use failure::err_msg;
 use account::Account;
 use cryp::{Cryp, Colours, cryp_get};
 use vbox::{Vbox, Var, VarEffect};
-use rpc::{PlayerStateParams, PlayerCrypsSetParams};
-use instance::{instance_get, instance_update};
+use rpc::{PlayerCrypsSetParams};
+use instance::{Instance, instance_get, instance_update};
 
 const DISCARD_COST: u16 = 5;
 
@@ -353,11 +353,7 @@ pub fn player_delete(tx: &mut Transaction, id: Uuid) -> Result<(), Error> {
     return Ok(());
 }
 
-pub fn player_state(params: PlayerStateParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
-    player_get(tx, account.id, params.instance_id)
-}
-
-pub fn player_mm_cryps_set(params: PlayerCrypsSetParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
+pub fn player_mm_cryps_set(params: PlayerCrypsSetParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
     if params.cryp_ids.len() != 3 {
         return Err(err_msg("team size is 3"));
     }
@@ -367,16 +363,19 @@ pub fn player_mm_cryps_set(params: PlayerCrypsSetParams, tx: &mut Transaction, a
         .map(|id| cryp_get(tx, *id, account.id))
         .collect::<Result<Vec<Cryp>, Error>>()?;
 
-    match player_get(tx, account.id, Uuid::nil()) {
+    let player = match player_get(tx, account.id, Uuid::nil()) {
         Ok(mut p) => {
             p.cryps = cryps;
             p.vbox = Vbox::new(account.id, Uuid::nil());
-            player_update(tx, p, false)
+            player_update(tx, p, false)?
         },
         Err(_) => {
-            return player_create(tx, Player::new(account.id, Uuid::nil(), &account.name, cryps), &account)
+            player_create(tx, Player::new(account.id, Uuid::nil(), &account.name, cryps), &account)?
         }
-    }
+    };
+
+    let instance = Instance::global(player);
+    Ok(instance)
 }
 
 #[cfg(test)]
diff --git a/server/src/rpc.rs b/server/src/rpc.rs
index 77ec567a..93e19189 100644
--- a/server/src/rpc.rs
+++ b/server/src/rpc.rs
@@ -21,8 +21,8 @@ use account::{Account, account_create, account_login, account_from_token, accoun
 use skill::{Skill};
 // use zone::{Zone, zone_create, zone_join, zone_close};
 use spec::{Spec};
-use player::{Score, player_state, player_mm_cryps_set, Player};
-use instance::{instance_lobby, instance_lobby_ready, instance_join, instance_scores};
+use player::{Score, player_mm_cryps_set, Player};
+use instance::{Instance, instance_state, instance_lobby, instance_ready, instance_join, instance_scores};
 use vbox::{Var, vbox_accept, vbox_apply, vbox_discard, vbox_combine, vbox_reclaim, vbox_unequip};
 
 pub struct Rpc;
@@ -70,19 +70,14 @@ impl Rpc {
                     "cryp_spawn" => Rpc::cryp_spawn(data, &mut tx, account.unwrap(), client),
 
                     "game_state" => Rpc::game_state(data, &mut tx, account.unwrap(), client),
-                    // "game_pve" => Rpc::game_pve(data, &mut tx, account.unwrap(), client),
                     "game_skill" => Rpc::game_skill(data, &mut tx, account.unwrap(), client),
 
-                    // "zone_create" => Rpc::zone_create(data, &mut tx, account.unwrap(), client),
-                    // "zone_join" => Rpc::zone_join(data, &mut tx, account.unwrap(), client),
-                    // "zone_close" => Rpc::zone_close(data, &mut tx, account.unwrap(), client),
-
                     "instance_join" => Rpc::instance_join(data, &mut tx, account.unwrap(), client),
-                    // "instance_ready" => Rpc::instance_ready(data, &mut tx, account.unwrap(), client),
+                    "instance_ready" => Rpc::instance_ready(data, &mut tx, account.unwrap(), client),
                     "instance_lobby" => Rpc::instance_lobby(data, &mut tx, account.unwrap(), client),
                     "instance_scores" => Rpc::instance_scores(data, &mut tx, account.unwrap(), client),
+                    "instance_state" => Rpc::instance_state(data, &mut tx, account.unwrap(), client),
 
-                    "player_state" => Rpc::player_state(data, &mut tx, account.unwrap(), client),
                     "player_mm_cryps_set" => Rpc::player_mm_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),
@@ -222,63 +217,23 @@ impl Rpc {
         })
     }
 
-    // fn account_zone(_data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
-    //     Ok(RpcResponse {
-    //         method: "zone_state".to_string(),
-    //         params: RpcResult::ZoneState(account_zone(tx, &account)?)
-    //     })
-    // }
-
-    // fn zone_create(_data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
-    //     // let _msg = from_slice::<ZoneCreateMsg>(&data).or(Err(err_msg("invalid params")))?;
-
-    //     let response = RpcResponse {
-    //         method: "zone_state".to_string(),
-    //         params: RpcResult::ZoneState(zone_create(tx, &account)?)
-    //     };
-
-    //     return Ok(response);
-    // }
-
-    // fn zone_join(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
-    //     let msg = from_slice::<ZoneJoinMsg>(&data).or(Err(err_msg("invalid params")))?;
-
-    //     let response = RpcResponse {
-    //         method: "game_state".to_string(),
-    //         params: RpcResult::GameState(zone_join(msg.params, tx, &account)?)
-    //     };
-
-    //     return Ok(response);
-    // }
-
-    // fn zone_close(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
-    //     let msg = from_slice::<ZoneCloseMsg>(&data).or(Err(err_msg("invalid params")))?;
-
-    //     let response = RpcResponse {
-    //         method: "zone_close".to_string(),
-    //         params: RpcResult::ZoneClose(zone_close(msg.params, tx, &account)?)
-    //     };
-
-    //     return Ok(response);
-    // }
-
     fn instance_lobby(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
         let msg = from_slice::<InstanceLobbyMsg>(&data).or(Err(err_msg("invalid params")))?;
 
         let response = RpcResponse {
-            method: "player_state".to_string(),
-            params: RpcResult::PlayerState(instance_lobby(msg.params, tx, &account)?)
+            method: "instance_state".to_string(),
+            params: RpcResult::InstanceState(instance_lobby(msg.params, tx, &account)?)
         };
 
         return Ok(response);
     }
 
-    fn instance_lobby_ready(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
+    fn instance_ready(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
         let msg = from_slice::<InstanceReadyMsg>(&data).or(Err(err_msg("invalid params")))?;
 
         let response = RpcResponse {
-            method: "player_state".to_string(),
-            params: RpcResult::PlayerState(instance_lobby_ready(msg.params, tx, &account)?)
+            method: "instance_state".to_string(),
+            params: RpcResult::InstanceState(instance_ready(msg.params, tx, &account)?)
         };
 
         return Ok(response);
@@ -288,8 +243,8 @@ impl Rpc {
         let msg = from_slice::<InstanceJoinMsg>(&data).or(Err(err_msg("invalid params")))?;
 
         let response = RpcResponse {
-            method: "player_state".to_string(),
-            params: RpcResult::PlayerState(instance_join(msg.params, tx, &account)?)
+            method: "instance_state".to_string(),
+            params: RpcResult::InstanceState(instance_join(msg.params, tx, &account)?)
         };
 
         return Ok(response);
@@ -317,14 +272,12 @@ impl Rpc {
         return Ok(response);
     }
 
-
-
-    fn player_state(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
-        let msg = from_slice::<PlayerStateMsg>(&data).or(Err(err_msg("invalid params")))?;
+    fn instance_state(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
+        let msg = from_slice::<InstanceStateMsg>(&data).or(Err(err_msg("invalid params")))?;
 
         let response = RpcResponse {
-            method: "player_state".to_string(),
-            params: RpcResult::PlayerState(player_state(msg.params, tx, &account)?)
+            method: "instance_state".to_string(),
+            params: RpcResult::InstanceState(instance_state(msg.params, tx, &account)?)
         };
 
         return Ok(response);
@@ -334,8 +287,8 @@ impl Rpc {
         let msg = from_slice::<PlayerCrypsSetMsg>(&data).or(Err(err_msg("invalid params")))?;
 
         let response = RpcResponse {
-            method: "player_state".to_string(),
-            params: RpcResult::PlayerState(player_mm_cryps_set(msg.params, tx, &account)?)
+            method: "instance_state".to_string(),
+            params: RpcResult::InstanceState(player_mm_cryps_set(msg.params, tx, &account)?)
         };
 
         return Ok(response);
@@ -345,8 +298,8 @@ impl Rpc {
         let msg = from_slice::<VboxAcceptMsg>(&data).or(Err(err_msg("invalid params")))?;
 
         let response = RpcResponse {
-            method: "player_state".to_string(),
-            params: RpcResult::PlayerState(vbox_accept(msg.params, tx, &account)?)
+            method: "instance_state".to_string(),
+            params: RpcResult::InstanceState(vbox_accept(msg.params, tx, &account)?)
         };
 
         return Ok(response);
@@ -356,8 +309,8 @@ impl Rpc {
         let msg = from_slice::<VboxDiscardMsg>(&data).or(Err(err_msg("invalid params")))?;
 
         let response = RpcResponse {
-            method: "player_state".to_string(),
-            params: RpcResult::PlayerState(vbox_discard(msg.params, tx, &account)?)
+            method: "instance_state".to_string(),
+            params: RpcResult::InstanceState(vbox_discard(msg.params, tx, &account)?)
         };
 
         return Ok(response);
@@ -368,8 +321,8 @@ impl Rpc {
         let msg = from_slice::<VboxCombineMsg>(&data).or(Err(err_msg("invalid params")))?;
 
         let response = RpcResponse {
-            method: "player_state".to_string(),
-            params: RpcResult::PlayerState(vbox_combine(msg.params, tx, &account)?)
+            method: "instance_state".to_string(),
+            params: RpcResult::InstanceState(vbox_combine(msg.params, tx, &account)?)
         };
 
         return Ok(response);
@@ -379,8 +332,8 @@ impl Rpc {
         let msg = from_slice::<VboxApplyMsg>(&data).or(Err(err_msg("invalid params")))?;
 
         let response = RpcResponse {
-            method: "player_state".to_string(),
-            params: RpcResult::PlayerState(vbox_apply(msg.params, tx, &account)?)
+            method: "instance_state".to_string(),
+            params: RpcResult::InstanceState(vbox_apply(msg.params, tx, &account)?)
         };
 
         Rpc::send_msg(client, RpcResponse {
@@ -395,8 +348,8 @@ impl Rpc {
         let msg = from_slice::<VboxReclaimMsg>(&data).or(Err(err_msg("invalid params")))?;
 
         let response = RpcResponse {
-            method: "player_state".to_string(),
-            params: RpcResult::PlayerState(vbox_reclaim(msg.params, tx, &account)?)
+            method: "instance_state".to_string(),
+            params: RpcResult::InstanceState(vbox_reclaim(msg.params, tx, &account)?)
         };
 
         return Ok(response);
@@ -406,8 +359,8 @@ impl Rpc {
         let msg = from_slice::<VboxUnequipMsg>(&data).or(Err(err_msg("invalid params")))?;
 
         let response = RpcResponse {
-            method: "player_state".to_string(),
-            params: RpcResult::PlayerState(vbox_unequip(msg.params, tx, &account)?)
+            method: "instance_state".to_string(),
+            params: RpcResult::InstanceState(vbox_unequip(msg.params, tx, &account)?)
         };
 
         Rpc::send_msg(client, RpcResponse {
@@ -417,8 +370,6 @@ impl Rpc {
 
         return Ok(response);
     }
-
-
 }
 
 #[derive(Debug,Clone,Serialize,Deserialize)]
@@ -441,7 +392,7 @@ pub enum RpcResult {
     // ZoneClose(()),
 
     PlayerList(Vec<Player>),
-    PlayerState(Player),
+    InstanceState(Instance),
 }
 
 #[derive(Debug,Clone,Serialize,Deserialize)]
@@ -601,13 +552,13 @@ pub struct InstanceReadyParams {
 }
 
 #[derive(Debug,Clone,Serialize,Deserialize)]
-struct PlayerStateMsg {
+struct InstanceStateMsg {
     method: String,
-    params: PlayerStateParams,
+    params: InstanceStateParams,
 }
 
 #[derive(Debug,Clone,Serialize,Deserialize)]
-pub struct PlayerStateParams {
+pub struct InstanceStateParams {
     pub instance_id: Uuid,
 }
 
diff --git a/server/src/vbox.rs b/server/src/vbox.rs
index d6a69aca..9f752f26 100644
--- a/server/src/vbox.rs
+++ b/server/src/vbox.rs
@@ -15,7 +15,8 @@ use account::Account;
 use rpc::{VboxAcceptParams, VboxDiscardParams, VboxCombineParams, VboxApplyParams, VboxReclaimParams, VboxUnequipParams};
 use skill::{Skill};
 use spec::{Spec};
-use player::{Player, player_get, player_update};
+use player::{Player};
+use instance::{Instance, instance_get, instance_update};
 use cryp::{Colours};
 
 #[derive(Debug,Copy,Clone,Serialize,Deserialize,PartialEq,PartialOrd,Ord,Eq)]
@@ -412,18 +413,14 @@ impl Vbox {
             Var::Attack,
         ];
 
-        let mut vbox = Vbox {
+        Vbox {
             id: Uuid::new_v4(),
             account: account_id,
             instance: instance_id,
-            free: vec![],
+            free: vec![vec![], vec![], vec![]],
             bound: starting_items,
             bits: 18,
-        };
-
-        // vbox.fill();
-
-        return vbox;
+        }
     }
 
     pub fn balance_sub(&mut self, amount: u16) -> Result<&mut Vbox, Error> {
@@ -542,40 +539,40 @@ impl Vbox {
     }
 }
 
-pub fn vbox_discard(params: VboxDiscardParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
-    let mut player = player_get(tx, account.id, params.instance_id)?;
-    player.vbox_discard()?;
-    return player_update(tx, player, false);
+pub fn vbox_discard(params: VboxDiscardParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
+    let instance = instance_get(tx, params.instance_id)?
+        .vbox_discard(account.id)?;
+    return instance_update(tx, instance);
 }
 
-pub fn vbox_accept(params: VboxAcceptParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
-    let mut player = player_get(tx, account.id, params.instance_id)?;
-    player.vbox_accept(params.group, params.index)?;
-    return player_update(tx, player, false);
+pub fn vbox_accept(params: VboxAcceptParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
+    let instance = instance_get(tx, params.instance_id)?
+        .vbox_accept(account.id, params.group, params.index)?;
+    return instance_update(tx, instance);
 }
 
-pub fn vbox_combine(params: VboxCombineParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
-    let mut player = player_get(tx, account.id, params.instance_id)?;
-    player.vbox_combine(params.indices)?;
-    return player_update(tx, player, false);
+pub fn vbox_combine(params: VboxCombineParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
+    let instance = instance_get(tx, params.instance_id)?
+        .vbox_combine(account.id, params.indices)?;
+    return instance_update(tx, instance);
 }
 
-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_reclaim(params.index)?;
-    return player_update(tx, player, false);
+pub fn vbox_reclaim(params: VboxReclaimParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
+    let mut instance = instance_get(tx, params.instance_id)?
+        .vbox_reclaim(account.id, params.index)?;
+    return instance_update(tx, instance);
 }
 
-pub fn vbox_apply(params: VboxApplyParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
-    let mut player = player_get(tx, account.id, params.instance_id)?;
-    player.vbox_apply(params.index, params.cryp_id)?;
-    return player_update(tx, player, false);
+pub fn vbox_apply(params: VboxApplyParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
+    let mut instance = instance_get(tx, params.instance_id)?
+        .vbox_apply(account.id, params.index, params.cryp_id)?;
+    return instance_update(tx, instance);
 }
 
-pub fn vbox_unequip(params: VboxUnequipParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
-    let mut player = player_get(tx, account.id, params.instance_id)?;
-    player.vbox_unequip(params.target, params.cryp_id)?;
-    return player_update(tx, player, false);
+pub fn vbox_unequip(params: VboxUnequipParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
+    let mut instance = instance_get(tx, params.instance_id)?
+        .vbox_unequip(account.id, params.target, params.cryp_id)?;
+    return instance_update(tx, instance);
 }
 
 #[cfg(test)]