players on join

server/src/player.rs

@@ -56,7 +56,7 @@ pub fn player_get(tx: &mut Transaction, account_id: Uuid, instance_id: Uuid) ->
 
     let returned = match result.iter().next() {
         Some(row) => row,
-        None => return Err(err_msg("instance not found")),
+        None => return Err(err_msg("player not found")),
     };
 
     // tells from_slice to cast into a cryp
@@ -104,5 +104,5 @@ pub fn player_update(tx: &mut Transaction, player: Player) -> Result<Player, Err
 }
 
 pub fn player_state(params: PlayerStateParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
-    player_get(tx, params.instance_id, account.id)
+    player_get(tx, account.id, params.instance_id)
 }

server/src/rpc.rs

@@ -21,7 +21,7 @@ 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::{player_state, Player};
+use player::{player_state, player_create, Player};
 use instance::{instance_join};
 use vbox::{vbox_accept, vbox_apply, vbox_discard, vbox_combine, vbox_drop};
 
@@ -158,13 +158,16 @@ impl Rpc {
     }
 
     fn account_create(data: Vec<u8>, tx: &mut Transaction, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
-        match from_slice::<AccountCreateMsg>(&data) {
-            Ok(v) => Ok(RpcResponse {
-                method: v.method,
-                params: RpcResult::Account(account_create(v.params, tx)?)
-            }),
-            Err(_e) => Err(err_msg("invalid params")),
-        }
+        let msg = from_slice::<AccountCreateMsg>(&data).or(Err(err_msg("invalid params")))?;
+
+        let account = account_create(msg.params, tx)?;
+        let player = Player::new(account.id, Uuid::nil(), vec![]);
+        player_create(tx, &player, &account)?;
+
+        Ok(RpcResponse {
+            method: "account_create".to_string(),
+            params: RpcResult::Account(account)
+        })
     }
 
     fn account_login(data: Vec<u8>, tx: &mut Transaction, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {

server/src/vbox.rs

@@ -277,31 +277,31 @@ impl Vbox {
 }
 
 pub fn vbox_discard(params: VboxDiscardParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
-    let mut player = player_get(tx, params.instance_id, account.id)?;
+    let mut player = player_get(tx, account.id, params.instance_id)?;
     player.vbox.fill();
     return player_update(tx, player);
 }
 
 pub fn vbox_accept(params: VboxAcceptParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
-    let mut player = player_get(tx, params.instance_id, account.id)?;
+    let mut player = player_get(tx, account.id, params.instance_id)?;
     player.vbox.accept(params.index)?;
     return player_update(tx, player);
 }
 
 pub fn vbox_combine(params: VboxCombineParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
-    let mut player = player_get(tx, params.instance_id, account.id)?;
+    let mut player = player_get(tx, account.id, params.instance_id)?;
     player.vbox.combine(params.indices)?;
     return player_update(tx, player);
 }
 
 pub fn vbox_drop(params: VboxDropParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
-    let mut player = player_get(tx, params.instance_id, account.id)?;
+    let mut player = player_get(tx, account.id, params.instance_id)?;
     player.vbox.drop(params.index)?;
     return player_update(tx, player);
 }
 
 pub fn vbox_apply(params: VboxApplyParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
-    let mut player = player_get(tx, params.instance_id, account.id)?;
+    let mut player = player_get(tx, account.id, params.instance_id)?;
     let mut cryp = cryp_get(tx, params.cryp_id, account.id)?;
 
     let var = player.vbox.bound.remove(params.index);