diff --git a/server/src/game.rs b/server/src/game.rs index 8f0bd01f..8f4ca467 100644 --- a/server/src/game.rs +++ b/server/src/game.rs @@ -8,7 +8,7 @@ use failure::Error; use failure::err_msg; use account::Account; -use rpc::{GameStateParams, GameSkillParams, GamePveParams, GamePvpParams, GameJoinParams}; +use rpc::{GameStateParams, GameSkillParams, GamePveParams}; use cryp::{Cryp, cryp_get}; use skill::{Skill, Cast, ResolutionResult}; use zone::{node_finish}; @@ -725,92 +725,6 @@ pub fn game_pve(params: GamePveParams, tx: &mut Transaction, account: &Account) Ok(game) } -pub fn game_pvp(params: GamePvpParams, tx: &mut Transaction, account: &Account) -> Result { - let cryps = params.cryp_ids - .iter() - .map(|id| cryp_get(tx, *id, account.id)) - .collect::, Error>>()?; - - // create the game - let mut game = Game::new(); - let game_id = game.id; - - game - .set_pve(false) - .set_team_num(2) - .set_team_size(cryps.len()) - .set_mode(GameMode::Pvp); - - // create the initiators team - let mut team = Team::new(account.id); - team.set_cryps(cryps); - - game.team_add(team)?; - - // persist - game_write(&game, tx)?; - - Ok(game) -} - -pub fn game_join(params: GameJoinParams, tx: &mut Transaction, account: &Account) -> Result { - let mut game = game_get(tx, params.game_id)?; - - // rejoining a game from the FE list - if game.already_joined(account.id) { - return Ok(game); - } - - // ok actually adding a new team - let game_id = game.id; - - let cryps = params.cryp_ids - .iter() - .map(|id| cryp_get(tx, *id, account.id)) - .collect::, Error>>()?; - - if cryps.len() != game.team_size { - return Err(format_err!("incorrect team size. ({:})", game.team_size)); - } - - let mut team = Team::new(account.id); - team.set_cryps(cryps); - game.team_add(team)?; - - if game.can_start() { - game.start(); - } - - game_update(&game, tx)?; - - Ok(game) -} - -pub fn game_joinable_list(tx: &mut Transaction, _account: &Account) -> Result, Error> { - let query = " - SELECT games.data - FROM games - WHERE joinable; - "; - - let result = tx - .query(query, &[])?; - - let games: Result, _> = result.iter().map(|row| { - let cryp_bytes: Vec = row.get(0); - from_slice::(&cryp_bytes) - }).collect(); - - // catch any errors - if games.is_err() { - return Err(err_msg("could not deserialize a game")); - } - - // now unwrap is safe - return Ok(games.unwrap()); -} - - #[cfg(test)] mod tests { use game::*; diff --git a/server/src/instance.rs b/server/src/instance.rs index 298e4be6..34dc61ca 100644 --- a/server/src/instance.rs +++ b/server/src/instance.rs @@ -7,8 +7,10 @@ use postgres::transaction::Transaction; use failure::Error; use failure::err_msg; +use rpc::{InstanceJoinParams}; use account::Account; -use player::{Player, player_write}; +use player::{Player, player_create}; +use cryp::{Cryp, cryp_get}; #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] enum InstancePhase { @@ -36,7 +38,7 @@ impl Instance { } } - fn add_player(&mut self, player: Player) -> &mut Instance { + fn add_player(&mut self, player: &Player) -> &mut Instance { self.players.push(player.id); self } @@ -122,16 +124,26 @@ pub fn instance_get_open(tx: &mut Transaction) -> Result { } -pub fn join_instance(tx: &mut Transaction, account: &Account) -> Result { +pub fn instance_join(params: InstanceJoinParams, tx: &mut Transaction, account: &Account) -> Result { let mut instance = match instance_get_open(tx) { Ok(i) => i, - Err(_) => instance_create(Instance::new())?, + Err(_) => instance_create(Instance::new(), tx)?, }; - // get add them - let player = Player::new(account, instance.id); - instance.add_player(account); + let cryps = params.cryp_ids + .iter() + .map(|id| cryp_get(tx, *id, account.id)) + .collect::, Error>>()?; + if cryps.len() != 3 { + return Err(format_err!("incorrect team size. ({:})", 3)); + } + + let player = Player::new(account.id, instance.id, cryps); + instance.add_player(&player); + + player_create(tx, &player, account)?; instance_write(instance, tx)?; - return player_write(player, tx); + + return Ok(player); } diff --git a/server/src/player.rs b/server/src/player.rs index 1fedd3e1..3dfba59a 100644 --- a/server/src/player.rs +++ b/server/src/player.rs @@ -8,28 +8,34 @@ use failure::Error; use failure::err_msg; use account::Account; -use rpc::{VboxStateParams, VboxAcceptParams, VboxDiscardParams, VboxCombineParams, VboxApplyParams, VboxDropParams}; -use cryp::{Cryp, cryp_get, cryp_write}; -use game::{Team, GameMode}; +use instance::Instance; +use cryp::{Cryp}; use vbox::{Vbox}; +use rpc::{PlayerStateParams}; +#[derive(Debug,Clone,Serialize,Deserialize)] pub struct Score { wins: u8, losses: u8, } +#[derive(Debug,Clone,Serialize,Deserialize)] pub struct Player { - id: Uuid, + pub id: Uuid, + pub instance: Uuid, + pub account: Uuid, // name: String, - vbox: Vbox, - score: Score, - cryps: Vec, + pub vbox: Vbox, + pub score: Score, + pub cryps: Vec, } impl Player { pub fn new(account: Uuid, instance: Uuid, cryps: Vec) -> Player { Player { - id: account, + id: Uuid::new_v4(), + account, + instance, vbox: Vbox::new(account, instance), score: Score { wins: 0, losses: 0 }, cryps, @@ -37,7 +43,7 @@ impl Player { } } -pub fn player_get(tx: &mut Transaction, instance_id: Uuid) -> Result { +pub fn player_get(tx: &mut Transaction, account_id: Uuid, instance_id: Uuid) -> Result { let query = " SELECT * FROM players @@ -46,7 +52,7 @@ pub fn player_get(tx: &mut Transaction, instance_id: Uuid) -> Result row, @@ -54,17 +60,15 @@ pub fn player_get(tx: &mut Transaction, instance_id: Uuid) -> Result = returned.get("data"); - let instance = from_slice::(&instance_bytes)?; + let bytes: Vec = returned.get("data"); + let data = from_slice::(&bytes)?; - return Ok(instance); + return Ok(data); } -pub fn player_create(player: Player, account: &Account, instance_id: Uuid, tx: &mut Transaction) -> Result<(), Error> { +pub fn player_create(tx: &mut Transaction, player: &Player, account: &Account) -> Result<(), Error> { let player_bytes = to_vec(&player)?; - let id = Uuid::new_v4(); - let query = " INSERT INTO players (id, instance, account, data) VALUES ($1, $2, $3, $4) @@ -72,11 +76,33 @@ pub fn player_create(player: Player, account: &Account, instance_id: Uuid, tx: & "; let result = tx - .query(query, &[&id, &instance_id, &account.id, player_bytes])?; + .query(query, &[&player.id, &player.instance, &account.id, &player_bytes])?; let _returned = result.iter().next().expect("no row written"); - println!("wrote player {:} joined game: {:}", account.name, instance_id); + println!("wrote player {:} joined instance: {:}", account.name, player.instance); return Ok(()); -} \ No newline at end of file +} + +pub fn player_update(tx: &mut Transaction, player: Player) -> Result { + let bytes = to_vec(&player)?; + + let query = " + UPDATE players + SET data = $1 + WHERE id = $2 + RETURNING id, data; + "; + + let result = tx + .query(query, &[&bytes, &player.id])?; + + result.iter().next().ok_or(format_err!("player {:?} could not be written", player))?; + + return Ok(player) +} + +pub fn player_state(params: PlayerStateParams, tx: &mut Transaction, account: &Account) -> Result { + player_get(tx, params.instance_id, account.id) +} diff --git a/server/src/rpc.rs b/server/src/rpc.rs index 3bf8ea2f..f9c693c6 100644 --- a/server/src/rpc.rs +++ b/server/src/rpc.rs @@ -15,13 +15,15 @@ use failure::Error; use failure::err_msg; use net::Db; -use cryp::{Cryp, cryp_spawn, cryp_learn, cryp_forget, cryp_unspec}; -use game::{Game, game_state, game_pve, game_pvp, game_join, game_joinable_list, game_skill}; +use cryp::{Cryp, cryp_spawn, cryp_learn}; +use game::{Game, game_state, game_pve, game_skill}; use account::{Account, account_create, account_login, account_from_token, account_cryps, account_zone}; use skill::{Skill}; use zone::{Zone, zone_create, zone_join, zone_close}; use spec::{Spec}; -use vbox::{Vbox, vbox_state, vbox_accept, vbox_apply, vbox_discard, vbox_combine, vbox_drop}; +use player::{player_state, Player}; +use instance::{instance_join}; +use vbox::{vbox_accept, vbox_apply, vbox_discard, vbox_combine, vbox_drop}; pub struct Rpc; @@ -61,25 +63,21 @@ impl Rpc { "account_demo" => Rpc::account_demo(data, &mut tx, client), // auth methods - "cryp_spawn" => Rpc::cryp_spawn(data, &mut tx, account.unwrap(), client), - // "cryp_learn" => Rpc::cryp_learn(data, &mut tx, account.unwrap(), client), - // "cryp_forget" => Rpc::cryp_forget(data, &mut tx, account.unwrap(), client), - // "cryp_unspec" => Rpc::cryp_unspec(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_pvp" => Rpc::game_pvp(data, &mut tx, account.unwrap(), client), - // "game_join" => Rpc::game_join(data, &mut tx, account.unwrap(), client), - // "game_joinable_list" => Rpc::game_joinable_list(data, &mut tx, account.unwrap(), client), - "game_skill" => Rpc::game_skill(data, &mut tx, account.unwrap(), client), - // "game_target" => Rpc::game_target(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), "account_cryps" => Rpc::account_cryps(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), + + "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), - "player_state" => Rpc::vbox_state(data, &mut tx, account.unwrap(), client), + "player_state" => Rpc::player_state(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), @@ -116,7 +114,6 @@ impl Rpc { return Ok(game_response); } - fn game_pve(data: Vec, tx: &mut Transaction, account: Account, client: &mut WebSocket) -> Result { let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; @@ -133,42 +130,6 @@ impl Rpc { return Ok(game_response); } - fn game_pvp(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - - let game_response = RpcResponse { - method: "game_state".to_string(), - params: RpcResult::GameState(game_pvp(msg.params, tx, &account)?) - }; - - return Ok(game_response); - } - - - fn game_join(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - - let game_response = RpcResponse { - method: "game_state".to_string(), - params: RpcResult::GameState(game_join(msg.params, tx, &account)?) - }; - - return Ok(game_response); - } - - fn game_joinable_list(_data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { - // let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - - let game_list = RpcResponse { - method: "game_joinable_list".to_string(), - params: RpcResult::GameJoinableList(game_joinable_list(tx, &account)?) - }; - - return Ok(game_list); - } - - - fn game_skill(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; @@ -180,17 +141,6 @@ impl Rpc { return Ok(game_response); } - // fn game_target(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { - // let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - - // let game_response = RpcResponse { - // method: "game_state".to_string(), - // params: RpcResult::GameState(game_target(msg.params, tx, &account)?) - // }; - - // return Ok(game_response); - // } - fn cryp_spawn(data: Vec, tx: &mut Transaction, account: Account, client: &mut WebSocket) -> Result { let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; @@ -207,54 +157,6 @@ impl Rpc { Ok(cryp_list) } - fn cryp_learn(data: Vec, tx: &mut Transaction, account: Account, client: &mut WebSocket) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - - Rpc::send_msg(client, RpcResponse { - method: "cryp_learn".to_string(), - params: RpcResult::CrypLearn(cryp_learn(msg.params, tx, &account)?) - })?; - - let cryp_list = RpcResponse { - method: "account_cryps".to_string(), - params: RpcResult::CrypList(account_cryps(tx, &account)?) - }; - - Ok(cryp_list) - } - - fn cryp_forget(data: Vec, tx: &mut Transaction, account: Account, client: &mut WebSocket) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - - Rpc::send_msg(client, RpcResponse { - method: "cryp_forget".to_string(), - params: RpcResult::CrypForget(cryp_forget(msg.params, tx, &account)?) - })?; - - let cryp_list = RpcResponse { - method: "account_cryps".to_string(), - params: RpcResult::CrypList(account_cryps(tx, &account)?) - }; - - Ok(cryp_list) - } - - fn cryp_unspec(data: Vec, tx: &mut Transaction, account: Account, client: &mut WebSocket) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - - Rpc::send_msg(client, RpcResponse { - method: "cryp_unspec".to_string(), - params: RpcResult::CrypUnspec(cryp_unspec(msg.params, tx, &account)?) - })?; - - let cryp_list = RpcResponse { - method: "account_cryps".to_string(), - params: RpcResult::CrypList(account_cryps(tx, &account)?) - }; - - Ok(cryp_list) - } - fn account_create(data: Vec, tx: &mut Transaction, _client: &mut WebSocket) -> Result { match from_slice::(&data) { Ok(v) => Ok(RpcResponse { @@ -356,57 +258,69 @@ impl Rpc { return Ok(response); } - fn vbox_state(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; + fn instance_join(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { + let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; let response = RpcResponse { - method: "vbox_state".to_string(), - params: RpcResult::VboxState(vbox_state(msg.params, tx, &account)?) + method: "player_state".to_string(), + params: RpcResult::PlayerState(instance_join(msg.params, tx, &account)?) }; return Ok(response); } - fn vbox_accept(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { + + fn player_state(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { + let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; + + let response = RpcResponse { + method: "player_state".to_string(), + params: RpcResult::PlayerState(player_state(msg.params, tx, &account)?) + }; + + return Ok(response); + } + + fn player_vbox_accept(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; let response = RpcResponse { - method: "vbox_state".to_string(), - params: RpcResult::VboxState(vbox_accept(msg.params, tx, &account)?) + method: "player_state".to_string(), + params: RpcResult::PlayerState(vbox_accept(msg.params, tx, &account)?) }; return Ok(response); } - fn vbox_discard(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { + fn player_vbox_discard(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; let response = RpcResponse { - method: "vbox_state".to_string(), - params: RpcResult::VboxState(vbox_discard(msg.params, tx, &account)?) + method: "player_state".to_string(), + params: RpcResult::PlayerState(vbox_discard(msg.params, tx, &account)?) }; return Ok(response); } - fn vbox_combine(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { + fn player_vbox_combine(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; let response = RpcResponse { - method: "vbox_state".to_string(), - params: RpcResult::VboxState(vbox_combine(msg.params, tx, &account)?) + method: "player_state".to_string(), + params: RpcResult::PlayerState(vbox_combine(msg.params, tx, &account)?) }; return Ok(response); } - fn vbox_apply(data: Vec, tx: &mut Transaction, account: Account, client: &mut WebSocket) -> Result { + fn player_vbox_apply(data: Vec, tx: &mut Transaction, account: Account, client: &mut WebSocket) -> Result { let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; let response = RpcResponse { - method: "vbox_state".to_string(), - params: RpcResult::VboxState(vbox_apply(msg.params, tx, &account)?) + method: "player_state".to_string(), + params: RpcResult::PlayerState(vbox_apply(msg.params, tx, &account)?) }; Rpc::send_msg(client, RpcResponse { @@ -417,23 +331,12 @@ impl Rpc { return Ok(response); } - fn vbox_drop(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { + fn player_vbox_drop(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; let response = RpcResponse { - method: "vbox_state".to_string(), - params: RpcResult::VboxState(vbox_drop(msg.params, tx, &account)?) - }; - - return Ok(response); - } - - fn vbox_drop(data: Vec, tx: &mut Transaction, account: Account, _client: &mut WebSocket) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - - let response = RpcResponse { - method: "vbox_state".to_string(), - params: RpcResult::VboxState(vbox_drop(msg.params, tx, &account)?) + method: "player_state".to_string(), + params: RpcResult::PlayerState(vbox_drop(msg.params, tx, &account)?) }; return Ok(response); @@ -460,7 +363,7 @@ pub enum RpcResult { ZoneState(Zone), ZoneClose(()), - VboxState(Vbox), + PlayerState(Player), } #[derive(Debug,Clone,Serialize,Deserialize)] @@ -538,48 +441,6 @@ pub struct GamePveParams { pub cryp_ids: Vec, } -#[derive(Debug,Clone,Serialize,Deserialize)] -struct GamePvpMsg { - method: String, - params: GamePvpParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct GamePvpParams { - pub cryp_ids: Vec, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct GameJoinMsg { - method: String, - params: GameJoinParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct GameJoinParams { - pub game_id: Uuid, - pub cryp_ids: Vec, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct GameJoinableListMsg { - method: String, - params: (), -} - -// #[derive(Debug,Clone,Serialize,Deserialize)] -// struct GameTargetMsg { -// method: String, -// params: GameTargetParams, -// } - -// #[derive(Debug,Clone,Serialize,Deserialize)] -// pub struct GameTargetParams { -// pub game_id: Uuid, -// pub cryp_id: Uuid, -// pub skill_id: Uuid, -// } - #[derive(Debug,Clone,Serialize,Deserialize)] struct GameSkillMsg { method: String, @@ -655,14 +516,25 @@ pub struct ZoneCloseParams { } #[derive(Debug,Clone,Serialize,Deserialize)] -struct VboxStateMsg { +struct InstanceJoinMsg { method: String, - params: VboxStateParams, + params: InstanceJoinParams, } #[derive(Debug,Clone,Serialize,Deserialize)] -pub struct VboxStateParams { - pub game_id: Uuid, +pub struct InstanceJoinParams { + pub cryp_ids: Vec, +} + +#[derive(Debug,Clone,Serialize,Deserialize)] +struct PlayerStateMsg { + method: String, + params: PlayerStateParams, +} + +#[derive(Debug,Clone,Serialize,Deserialize)] +pub struct PlayerStateParams { + pub instance_id: Uuid, } #[derive(Debug,Clone,Serialize,Deserialize)] @@ -673,7 +545,7 @@ struct VboxAcceptMsg { #[derive(Debug,Clone,Serialize,Deserialize)] pub struct VboxAcceptParams { - pub game_id: Uuid, + pub instance_id: Uuid, pub index: usize, } @@ -685,7 +557,7 @@ struct VboxDiscardMsg { #[derive(Debug,Clone,Serialize,Deserialize)] pub struct VboxDiscardParams { - pub game_id: Uuid, + pub instance_id: Uuid, } #[derive(Debug,Clone,Serialize,Deserialize)] @@ -696,7 +568,7 @@ struct VboxCombineMsg { #[derive(Debug,Clone,Serialize,Deserialize)] pub struct VboxCombineParams { - pub game_id: Uuid, + pub instance_id: Uuid, pub indices: Vec, } @@ -708,7 +580,7 @@ struct VboxApplyMsg { #[derive(Debug,Clone,Serialize,Deserialize)] pub struct VboxApplyParams { - pub game_id: Uuid, + pub instance_id: Uuid, pub cryp_id: Uuid, pub index: usize, } @@ -721,7 +593,7 @@ struct VboxDropMsg { #[derive(Debug,Clone,Serialize,Deserialize)] pub struct VboxDropParams { - pub game_id: Uuid, + pub instance_id: Uuid, pub index: usize, } diff --git a/server/src/vbox.rs b/server/src/vbox.rs index 9ce99389..35eb43ee 100644 --- a/server/src/vbox.rs +++ b/server/src/vbox.rs @@ -6,16 +6,15 @@ use rand::prelude::*; use rand::{thread_rng}; use rand::distributions::{WeightedIndex}; -use serde_cbor::{from_slice, to_vec}; - use postgres::transaction::Transaction; use failure::Error; use failure::err_msg; use account::Account; -use rpc::{VboxStateParams, VboxAcceptParams, VboxDiscardParams, VboxCombineParams, VboxApplyParams, VboxDropParams}; +use rpc::{VboxAcceptParams, VboxDiscardParams, VboxCombineParams, VboxApplyParams, VboxDropParams}; use skill::{Skill}; +use player::{Player, player_get, player_update}; use cryp::{cryp_get, cryp_write}; #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] @@ -118,23 +117,23 @@ pub struct Vbox { pub balance: u16, pub free: Vec, pub bound: Vec, - pub game: Uuid, + pub instance: Uuid, pub account: Uuid, } impl Vbox { - pub fn new(account_id: Uuid, game_id: Uuid) -> Vbox { + pub fn new(account_id: Uuid, instance_id: Uuid) -> Vbox { Vbox { id: Uuid::new_v4(), account: account_id, - game: game_id, + instance: instance_id, free: vec![], bound: vec![], balance: 0, } } - pub fn fill(mut self: Vbox) -> Vbox { + pub fn fill(&mut self) -> &mut Vbox { let vars = vec![ (Var::Red, 1), (Var::Green, 1), @@ -277,107 +276,35 @@ impl Vbox { } } -pub fn vbox_create(vbox: Vbox, tx: &mut Transaction, account: &Account) -> Result { - let vbox_bytes = to_vec(&vbox)?; - - let query = " - INSERT INTO vbox (id, account, game, data) - VALUES ($1, $2, $3, $4) - RETURNING id; - "; - - let result = tx - .query(query, &[&vbox.id, &account.id, &vbox.game, &vbox_bytes])?; - - result.iter().next().ok_or(format_err!("no vbox written"))?; - - // println!("{:} wrote vbox", vbox.id); - - return Ok(vbox); +pub fn vbox_discard(params: VboxDiscardParams, tx: &mut Transaction, account: &Account) -> Result { + let mut player = player_get(tx, params.instance_id, account.id)?; + player.vbox.fill(); + return player_update(tx, player); } -pub fn vbox_write(vbox: Vbox, tx: &mut Transaction) -> Result { - let vbox_bytes = to_vec(&vbox)?; - - let query = " - UPDATE vbox - SET data = $1 - WHERE id = $2 - RETURNING id, account, data; - "; - - let result = tx - .query(query, &[&vbox_bytes, &vbox.id])?; - - result.iter().next().ok_or(err_msg("no vbox row returned"))?; - - // println!("{:?} wrote vbox", vbox.id); - - return Ok(vbox); +pub fn vbox_accept(params: VboxAcceptParams, tx: &mut Transaction, account: &Account) -> Result { + let mut player = player_get(tx, params.instance_id, account.id)?; + player.vbox.accept(params.index)?; + return player_update(tx, player); } - -pub fn vbox_get(tx: &mut Transaction, game_id: Uuid, account: &Account) -> Result { - let query = " - SELECT * - FROM vbox - WHERE account = $1 - AND game = $2; - "; - - let result = tx - .query(query, &[&account.id, &game_id])?; - - let returned = match result.iter().next() { - Some(row) => row, - None => return Err(err_msg("vbox not found")), - }; - - // tells from_slice to cast into a cryp - let vbox_bytes: Vec = returned.get("data"); - let vbox = from_slice::(&vbox_bytes)?; - - return Ok(vbox); +pub fn vbox_combine(params: VboxCombineParams, tx: &mut Transaction, account: &Account) -> Result { + let mut player = player_get(tx, params.instance_id, account.id)?; + player.vbox.combine(params.indices)?; + return player_update(tx, player); } -pub fn vbox_state(params: VboxStateParams, tx: &mut Transaction, account: &Account) -> Result { - match vbox_get(tx, params.game_id, account) { - Ok(v) => Ok(v), - Err(e) => { - println!("{:?}", e); - vbox_create(Vbox::new(account.id, params.game_id).fill(), tx, account) - } - } +pub fn vbox_drop(params: VboxDropParams, tx: &mut Transaction, account: &Account) -> Result { + let mut player = player_get(tx, params.instance_id, account.id)?; + player.vbox.drop(params.index)?; + return player_update(tx, player); } -pub fn vbox_discard(params: VboxDiscardParams, tx: &mut Transaction, account: &Account) -> Result { - let vbox = vbox_get(tx, params.game_id, account)?; - return vbox_write(vbox.fill(), tx); -} - -pub fn vbox_accept(params: VboxAcceptParams, tx: &mut Transaction, account: &Account) -> Result { - let mut vbox = vbox_get(tx, params.game_id, account)?; - vbox.accept(params.index)?; - return vbox_write(vbox, tx); -} - -pub fn vbox_combine(params: VboxCombineParams, tx: &mut Transaction, account: &Account) -> Result { - let mut vbox = vbox_get(tx, params.game_id, account)?; - vbox.combine(params.indices)?; - return vbox_write(vbox, tx); -} - -pub fn vbox_drop(params: VboxDropParams, tx: &mut Transaction, account: &Account) -> Result { - let mut vbox = vbox_get(tx, params.game_id, account)?; - vbox.drop(params.index)?; - return vbox_write(vbox, tx); -} - -pub fn vbox_apply(params: VboxApplyParams, tx: &mut Transaction, account: &Account) -> Result { - let mut vbox = vbox_get(tx, params.game_id, account)?; +pub fn vbox_apply(params: VboxApplyParams, tx: &mut Transaction, account: &Account) -> Result { + let mut player = player_get(tx, params.instance_id, account.id)?; let mut cryp = cryp_get(tx, params.cryp_id, account.id)?; - let var = vbox.bound.remove(params.index); + let var = player.vbox.bound.remove(params.index); // done here because i teach them a tonne of skills for tests let max_skills = 4; @@ -388,7 +315,7 @@ pub fn vbox_apply(params: VboxApplyParams, tx: &mut Transaction, account: &Accou let skill = var.skill()?; cryp = cryp.learn(skill); cryp_write(cryp, tx)?; - return vbox_write(vbox, tx); + return player_update(tx, player); }