scores

server/src/instance.rs

@@ -11,7 +11,7 @@ use std::iter;
 
 use rpc::{InstanceJoinParams, InstanceReadyParams};
 use account::Account;
-use player::{Player, player_create, player_get, player_update};
+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};
@@ -307,6 +307,16 @@ impl Instance {
 
         current_round
     }
+
+    fn scores(&self) -> Vec<(String, Score)> {
+        let mut scores = self.players.iter()
+            .map(|p| (p.name.clone(), p.score))
+            .collect::<Vec<(String, Score)>>();
+        scores.sort_unstable_by_key(|s| s.1.wins);
+        scores.reverse();
+
+        scores
+    }
 }
 
 pub fn instance_create(tx: &mut Transaction, instance: Instance) -> Result<Instance, Error> {
@@ -445,8 +455,9 @@ pub fn instance_ready_global(tx: &mut Transaction, _account: &Account, player: P
     Ok(game)
 }
 
-pub fn instance_score(params: InstanceReadyParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
-    instance_get(tx, params.instance_id)
+pub fn instance_scores(params: InstanceReadyParams, tx: &mut Transaction, account: &Account) -> Result<Vec<(String, Score)>, Error> {
+    let scores = instance_get(tx, params.instance_id)?.scores();
+    Ok(scores)
 }
 
 pub fn instance_ready(params: InstanceReadyParams, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {

server/src/player.rs

@@ -13,10 +13,10 @@ use vbox::{Vbox};
 use rpc::{PlayerStateParams, PlayerCrypsSetParams};
 use instance::{instance_get, instance_update};
 
-#[derive(Debug,Clone,Serialize,Deserialize)]
+#[derive(Debug,Clone,Copy,Serialize,Deserialize)]
 pub struct Score {
-    wins: u8,
-    losses: u8,
+    pub wins: u8,
+    pub losses: u8,
 }
 
 #[derive(Debug,Clone,Serialize,Deserialize)]

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::{player_state, player_cryps_set, Player};
-use instance::{Instance, instance_join, instance_ready, instance_score};
+use player::{Score, player_state, player_cryps_set, Player};
+use instance::{instance_join, instance_ready, instance_scores};
 use vbox::{Var, vbox_accept, vbox_apply, vbox_discard, vbox_combine, vbox_reclaim, vbox_unequip};
 
 pub struct Rpc;
@@ -79,7 +79,7 @@ impl Rpc {
 
                     "instance_join" => Rpc::instance_join(data, &mut tx, account.unwrap(), client),
                     "instance_ready" => Rpc::instance_ready(data, &mut tx, account.unwrap(), client),
-                    "instance_score" => Rpc::instance_score(data, &mut tx, account.unwrap(), client),
+                    "instance_scores" => Rpc::instance_scores(data, &mut tx, account.unwrap(), client),
 
                     "player_state" => Rpc::player_state(data, &mut tx, account.unwrap(), client),
                     "player_cryps_set" => Rpc::player_cryps_set(data, &mut tx, account.unwrap(), client),
@@ -283,12 +283,12 @@ impl Rpc {
         return Ok(response);
     }
 
-    fn instance_score(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
+    fn instance_scores(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: "instance_score".to_string(),
-            params: RpcResult::InstanceScore(instance_score(msg.params, tx, &account)?)
+            method: "instance_scores".to_string(),
+            params: RpcResult::InstanceScores(instance_scores(msg.params, tx, &account)?)
         };
 
         return Ok(response);
@@ -413,7 +413,7 @@ pub enum RpcResult {
     Account(Account),
     CrypList(Vec<Cryp>),
     GameState(Game),
-    InstanceScore(Instance),
+    InstanceScores(Vec<(String, Score)>),
     // ZoneState(Zone),
     // ZoneClose(()),
 

server/src/spec.rs

@@ -63,17 +63,19 @@ impl Spec {
                 if team_colours.red >= 20 { pct += 20 };
                 base.pct(pct)
             },
-            Spec::GreenDamageI      => modified + match team_colours.green {
-                0...5   => base.pct(5),
-                6...10  => base.pct(10),
-                11...15 => base.pct(15),
-                _       => base.pct(20)
+            Spec::GreenDamageI        => modified + {
+                let mut pct = 5;
+                if team_colours.green >= 5  { pct += 5 };
+                if team_colours.green >= 10 { pct += 10 };
+                if team_colours.green >= 20 { pct += 20 };
+                base.pct(pct)
             },
-            Spec::BlueDamageI       => modified + match team_colours.blue {
-                0...5   => base.pct(5),
-                6...10  => base.pct(10),
-                11...15 => base.pct(15),
-                _       => base.pct(20)
+            Spec::BlueDamageI        => modified + {
+                let mut pct = 5;
+                if team_colours.blue >= 5  { pct += 10 };
+                if team_colours.blue >= 10 { pct += 20 };
+                if team_colours.blue >= 20 { pct += 30 };
+                base.pct(pct)
             },
 
             Spec::SpeedI            => modified + base.pct(5),