instance lists

server/src/account.rs

@@ -10,7 +10,7 @@ use postgres::transaction::Transaction;
 use rpc::{AccountCreateParams, AccountLoginParams};
 
 use cryp::{Cryp, cryp_recover};
-use player::{Player, player_delete};
+use instance::{Instance, instance_delete};
 
 use failure::Error;
 use failure::err_msg;
@@ -177,11 +177,16 @@ pub fn account_cryps(tx: &mut Transaction, account: &Account) -> Result<Vec<Cryp
     return Ok(cryps);
 }
 
-pub fn account_players(tx: &mut Transaction, account: &Account) -> Result<Vec<Player>, Error> {
+pub fn account_instances(tx: &mut Transaction, account: &Account) -> Result<Vec<Instance>, Error> {
     let query = "
         SELECT data, id
-        FROM players
-        WHERE account = $1;
+        FROM instances
+        WHERE open = true
+        OR id IN (
+            SELECT instance
+            FROM players
+            WHERE account = $1
+        );
     ";
 
     let result = tx
@@ -193,15 +198,15 @@ pub fn account_players(tx: &mut Transaction, account: &Account) -> Result<Vec<Pl
         let bytes: Vec<u8> = row.get(0);
         let id = row.get(1);
 
-        match from_slice::<Player>(&bytes) {
+        match from_slice::<Instance>(&bytes) {
             Ok(i) => list.push(i),
             Err(_e) => {
-                player_delete(tx, id)?;
+                instance_delete(tx, id)?;
             }
         };
     }
 
-    list.sort_by_key(|c| c.instance);
+    list.sort_unstable_by_key(|c| c.name.clone());
 
     return Ok(list);
 }

server/src/instance.rs

@@ -41,7 +41,7 @@ pub struct Instance {
     open: bool,
     max_players: usize,
     password: Option<String>,
-    name: String,
+    pub name: String,
 }
 
 impl Instance {
@@ -141,7 +141,7 @@ impl Instance {
                     self.start();
                 }
             },
-            InstancePhase::Vbox =>
+            InstancePhase::Vbox => {
                 if self.all_ready() {
                     self.games_phase_start();
                 }
@@ -306,7 +306,10 @@ impl Instance {
                     game = game.start();
 
                     assert!(game.finished());
-                    let winner = game.winner().unwrap();
+                    let winner = match game.winner() {
+                        Some(w) => w,
+                        None => panic!("game has no winner {:?}", game),
+                    };
 
                     round.finished = true;
 
@@ -479,6 +482,25 @@ pub fn instance_get(tx: &mut Transaction, instance_id: Uuid) -> Result<Instance,
     return Ok(instance);
 }
 
+pub fn instance_delete(tx: &mut Transaction, id: Uuid) -> Result<(), Error> {
+    let query = "
+        DELETE
+        FROM instances
+        WHERE id = $1;
+    ";
+
+    let result = tx
+        .execute(query, &[&id])?;
+
+    if result != 1 {
+        return Err(format_err!("unable to delete instance {:?}", id));
+    }
+
+    println!("instance deleted {:?}", id);
+
+    return Ok(());
+}
+
 pub fn instance_get_open(tx: &mut Transaction) -> Result<Instance, Error> {
     let query = "
         SELECT *
@@ -511,7 +533,6 @@ pub fn instance_lobby(params: InstanceLobbyParams, tx: &mut Transaction, account
     instance_join(join_params, tx, account)
 }
 
-
 pub fn instance_join(params: InstanceJoinParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
     let mut instance = instance_get(tx, params.instance_id)?;
 
@@ -557,9 +578,9 @@ pub fn instance_scores(params: InstanceReadyParams, tx: &mut Transaction, _accou
 }
 
 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)?;
+    let player_id = instance.account_player(account.id)?.id;
+    instance.player_ready(player_id)?;
 
     instance_update(tx, instance)
 }

server/src/rpc.rs

@@ -17,7 +17,7 @@ use failure::err_msg;
 use net::Db;
 use cryp::{Cryp, cryp_spawn};
 use game::{Game, game_state, game_skill};
-use account::{Account, account_create, account_login, account_from_token, account_cryps, account_players};
+use account::{Account, account_create, account_login, account_from_token, account_cryps, account_instances};
 use skill::{Skill};
 // use zone::{Zone, zone_create, zone_join, zone_close};
 use spec::{Spec};
@@ -64,7 +64,7 @@ impl Rpc {
 
                     // auth methods
                     "account_cryps" => Rpc::account_cryps(data, &mut tx, account.unwrap(), client),
-                    "account_players" => Rpc::account_players(data, &mut tx, account.unwrap(), client),
+                    "account_instances" => Rpc::account_instances(data, &mut tx, account.unwrap(), client),
                     // "account_zone" => Rpc::account_zone(data, &mut tx, account.unwrap(), client),
 
                     "cryp_spawn" => Rpc::cryp_spawn(data, &mut tx, account.unwrap(), client),
@@ -210,10 +210,10 @@ impl Rpc {
         })
     }
 
-    fn account_players(_data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
+    fn account_instances(_data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
         Ok(RpcResponse {
-            method: "account_players".to_string(),
-            params: RpcResult::PlayerList(account_players(tx, &account)?)
+            method: "account_instances".to_string(),
+            params: RpcResult::InstanceList(account_instances(tx, &account)?)
         })
     }
 
@@ -391,7 +391,7 @@ pub enum RpcResult {
     // ZoneState(Zone),
     // ZoneClose(()),
 
-    PlayerList(Vec<Player>),
+    InstanceList(Vec<Instance>),
     InstanceState(Instance),
 }