From e5b2eb48c937d160253ca084e313ec75872bfc08 Mon Sep 17 00:00:00 2001 From: ntr Date: Wed, 10 Jul 2019 18:08:47 +1000 Subject: [PATCH] so fresh, so clean --- WORKLOG.md | 3 - client/src/socket.jsx | 6 +- server/src/account.rs | 3 +- server/src/construct.rs | 5 +- server/src/game.rs | 16 +- server/src/img.rs | 6 +- server/src/instance.rs | 31 +-- server/src/mtx.rs | 2 + server/src/net.rs | 16 +- server/src/rpc.rs | 570 +++++++++------------------------------- server/src/vbox.rs | 38 +-- 11 files changed, 195 insertions(+), 501 deletions(-) diff --git a/WORKLOG.md b/WORKLOG.md index 1b8a57c9..7137aefe 100644 --- a/WORKLOG.md +++ b/WORKLOG.md @@ -28,14 +28,11 @@ ## NOW *$$$* - -* rerolls cost 1cr * rename costs 1cr * invader set * new construct costs 5cr - * eth adapter diff --git a/client/src/socket.jsx b/client/src/socket.jsx index 8fb26a42..599d258d 100644 --- a/client/src/socket.jsx +++ b/client/src/socket.jsx @@ -140,7 +140,7 @@ function createSocket(events) { } function sendMtxApply(constructId, mtx) { - send({ method: 'mtx_apply', params: { construct_id: constructId, mtx } }); + send(['MtxConstructApply', { construct_id: constructId, mtx }]); // events.clearMtxActive(); } @@ -155,7 +155,7 @@ function createSocket(events) { function onAccountInstances(list) { events.setAccountInstances(list); - setTimeout(sendAccountInstances, 5000); + // setTimeout(sendAccountInstances, 5000); } function onAccountConstructs(constructs) { @@ -205,7 +205,7 @@ function createSocket(events) { let pongTimeout; function onPong() { events.setPing(Date.now() - ping); - pongTimeout = setTimeout(sendPing, 1000); + // pongTimeout = setTimeout(sendPing, 1000); } // ------------- diff --git a/server/src/account.rs b/server/src/account.rs index a310c595..3b56c25c 100644 --- a/server/src/account.rs +++ b/server/src/account.rs @@ -9,7 +9,6 @@ use serde_cbor::{from_slice}; use postgres::transaction::Transaction; use names::{name as generate_name}; -use rpc::{ConstructSpawnParams}; use construct::{Construct, construct_recover, construct_spawn}; use instance::{Instance, instance_delete}; use mtx::{Mtx, FREE_MTX}; @@ -253,7 +252,7 @@ pub fn create(name: &String, password: &String, code: &String, tx: &mut Transact // 3 constructs for a team and 1 to swap for _i in 0..4 { - construct_spawn(tx, ConstructSpawnParams { name: generate_name() }, id)?; + construct_spawn(tx, id, generate_name())?; } for mtx in FREE_MTX.iter() { diff --git a/server/src/construct.rs b/server/src/construct.rs index 61951553..0d2eba4a 100644 --- a/server/src/construct.rs +++ b/server/src/construct.rs @@ -7,7 +7,6 @@ use postgres::transaction::Transaction; use failure::Error; use failure::err_msg; -use rpc::{ConstructSpawnParams}; use skill::{Skill, Cast, Immunity, Disable, Event}; use effect::{Cooldown, Effect, Colour}; use spec::{Spec}; @@ -866,9 +865,9 @@ pub fn construct_select(tx: &mut Transaction, id: Uuid, account_id: Uuid) -> Res return Ok(construct); } -pub fn construct_spawn(tx: &mut Transaction, params: ConstructSpawnParams, account: Uuid) -> Result { +pub fn construct_spawn(tx: &mut Transaction, account: Uuid, name: String) -> Result { let construct = Construct::new() - .named(¶ms.name) + .named(&name) .set_account(account); let construct_bytes = to_vec(&construct)?; diff --git a/server/src/game.rs b/server/src/game.rs index da93c867..d557415c 100644 --- a/server/src/game.rs +++ b/server/src/game.rs @@ -12,7 +12,7 @@ use failure::Error; use failure::err_msg; use account::Account; -use rpc::{GameStateParams, GameSkillParams}; + use construct::{Construct}; use skill::{Skill, Cast, Resolution, Event, resolution_steps}; use effect::{Effect}; @@ -628,8 +628,8 @@ pub fn game_write(tx: &mut Transaction, game: &Game) -> Result<(), Error> { return Ok(()); } -pub fn game_state(params: GameStateParams, tx: &mut Transaction, _account: &Account) -> Result { - return game_get(tx, params.id) +pub fn game_state(tx: &mut Transaction, _account: &Account, id: Uuid) -> Result { + return game_get(tx, id) } pub fn game_get(tx: &mut Transaction, id: Uuid) -> Result { @@ -813,10 +813,10 @@ pub fn game_update(tx: &mut Transaction, game: &Game) -> Result<(), Error> { return Ok(()); } -pub fn game_skill(params: GameSkillParams, tx: &mut Transaction, account: &Account) -> Result { - let mut game = game_get(tx, params.game_id)?; +pub fn game_skill(tx: &mut Transaction, account: &Account, game_id: Uuid, construct_id: Uuid, target_construct_id: Option, skill: Skill) -> Result { + let mut game = game_get(tx, game_id)?; - game.add_skill(account.id, params.construct_id, params.target_construct_id, params.skill)?; + game.add_skill(account.id, construct_id, target_construct_id, skill)?; if game.skill_phase_finished() { game = game.resolve_phase_start(); @@ -827,8 +827,8 @@ pub fn game_skill(params: GameSkillParams, tx: &mut Transaction, account: &Accou Ok(game) } -pub fn game_ready(params: GameStateParams, tx: &mut Transaction, account: &Account) -> Result { - let mut game = game_get(tx, params.id)?; +pub fn game_ready(tx: &mut Transaction, account: &Account, id: Uuid) -> Result { + let mut game = game_get(tx, id)?; game.player_ready(account.id)?; diff --git a/server/src/img.rs b/server/src/img.rs index ce1b8ab4..557560ba 100644 --- a/server/src/img.rs +++ b/server/src/img.rs @@ -11,11 +11,11 @@ pub fn img_molecular_write(id: Uuid) -> Result { for _i in 0..100 { let mol: u32 = rng.gen_range(0, 10000); let src = format!("/var/lib/mnml/data/molecules/{}.svg", mol); - println!("{:?}", src); let dest = format!("/var/lib/mnml/public/imgs/{}.svg", id); - println!("{:?}", dest); + debug!("molecule src={:?}", src); + debug!("molecule dest={:?}", dest); if let Ok(_bytes) = copy(&src, &dest) { - info!("new molecule avatar generated src={:?} dest={:?}", src, dest); + info!("new molecule img generated src={:?} dest={:?}", src, dest); return Ok(id); } } diff --git a/server/src/instance.rs b/server/src/instance.rs index 9d30d29f..ba729358 100644 --- a/server/src/instance.rs +++ b/server/src/instance.rs @@ -7,13 +7,10 @@ use postgres::transaction::Transaction; use failure::Error; use failure::err_msg; -use std::iter; - // timekeeping use chrono::prelude::*; use chrono::Duration; -use rpc::{InstanceLobbyParams, InstanceJoinParams, InstanceReadyParams, InstanceStateParams}; use account::Account; use player::{Player, player_create}; use construct::{Construct, construct_get}; @@ -21,7 +18,7 @@ use mob::{bot_player, instance_mobs}; use game::{Game, Phase, game_get, game_write}; use item::{Item}; use rpc::{RpcResult}; -use names::{name}; + use img::{img_molecular_write}; #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] @@ -701,8 +698,8 @@ pub fn instances_idle(tx: &mut Transaction) -> Result, Error> { } -pub fn instance_new(params: InstanceLobbyParams, tx: &mut Transaction, account: &Account) -> Result { - let mut instance = match params.pve { +pub fn instance_new(tx: &mut Transaction, account: &Account, construct_ids: Vec, name: String, pve: bool, password: Option) -> Result { + let mut instance = match pve { true => { let bot = bot_player(); @@ -714,26 +711,24 @@ pub fn instance_new(params: InstanceLobbyParams, tx: &mut Transaction, account: let mut instance = Instance::new() .set_time_control(TimeControl::Practice) .set_max_rounds(10) - .set_name(params.name)?; + .set_name(name)?; instance.add_player(bot)?; instance }, false => Instance::new() - .set_name(params.name)? + .set_name(name)? }; instance = instance_create(tx, instance)?; - let join_params = InstanceJoinParams { instance_id: instance.id, construct_ids: params.construct_ids }; - - instance_join(join_params, tx, account) + instance_join(tx, account, instance.id, construct_ids) } -pub fn instance_join(params: InstanceJoinParams, tx: &mut Transaction, account: &Account) -> Result { - let mut instance = instance_get(tx, params.instance_id)?; +pub fn instance_join(tx: &mut Transaction, account: &Account, instance_id: Uuid, construct_ids: Vec) -> Result { + let mut instance = instance_get(tx, instance_id)?; - let constructs = params.construct_ids + let constructs = construct_ids .iter() .map(|id| construct_get(tx, *id, account.id)) .collect::, Error>>()?; @@ -749,8 +744,8 @@ pub fn instance_join(params: InstanceJoinParams, tx: &mut Transaction, account: instance_update(tx, instance) } -pub fn instance_ready(params: InstanceReadyParams, tx: &mut Transaction, account: &Account) -> Result { - let mut instance = instance_get(tx, params.instance_id)?; +pub fn instance_ready(tx: &mut Transaction, account: &Account, instance_id: Uuid) -> Result { + let mut instance = instance_get(tx, instance_id)?; let player_id = instance.account_player(account.id)?.id; if let Some(game) = instance.player_ready(player_id)? { @@ -760,8 +755,8 @@ pub fn instance_ready(params: InstanceReadyParams, tx: &mut Transaction, account instance_update(tx, instance) } -pub fn instance_state(params: InstanceStateParams, tx: &mut Transaction, _account: &Account) -> Result { - let instance = instance_get(tx, params.instance_id)?; +pub fn instance_state(tx: &mut Transaction, _account: &Account, instance_id: Uuid) -> Result { + let instance = instance_get(tx, instance_id)?; if let Some(game_id) = instance.current_game_id() { let game = game_get(tx, game_id)?; diff --git a/server/src/mtx.rs b/server/src/mtx.rs index bc76ddd0..009c0b57 100644 --- a/server/src/mtx.rs +++ b/server/src/mtx.rs @@ -33,6 +33,8 @@ impl MtxVariant { } } +// could use postgres-derive +// but enums in pg are a bit of a pain impl TryFrom for MtxVariant { type Error = Error; fn try_from(v: String) -> Result { diff --git a/server/src/net.rs b/server/src/net.rs index 87952602..cbab4b5b 100644 --- a/server/src/net.rs +++ b/server/src/net.rs @@ -12,7 +12,6 @@ use r2d2::{Pool}; use r2d2::{PooledConnection}; use r2d2_postgres::{TlsMode, PostgresConnectionManager}; -use rpc::{AccountLoginParams, AccountCreateParams}; use warden::{warden}; use pubsub::{pg_listen}; use ws::{connect}; @@ -98,6 +97,12 @@ fn logout_res() -> HttpResponse { .finish() } +#[derive(Debug,Clone,Serialize,Deserialize)] +struct AccountLoginParams { + name: String, + password: String, +} + fn login(state: web::Data, params: web::Json::) -> Result { let db = state.pool.get().or(Err(MnmlHttpError::ServerError))?; let mut tx = db.transaction().or(Err(MnmlHttpError::ServerError))?; @@ -133,7 +138,14 @@ fn logout(r: HttpRequest, state: web::Data) -> Result, params: web::Json::) -> Result { +#[derive(Debug,Clone,Serialize,Deserialize)] +struct AccountRegisterParams { + name: String, + password: String, + code: String, +} + +fn register(state: web::Data, params: web::Json::) -> Result { let db = state.pool.get().or(Err(MnmlHttpError::ServerError))?; let mut tx = db.transaction().or(Err(MnmlHttpError::ServerError))?; diff --git a/server/src/rpc.rs b/server/src/rpc.rs index bd0efa78..f77417c8 100644 --- a/server/src/rpc.rs +++ b/server/src/rpc.rs @@ -2,7 +2,6 @@ use std::time::{Instant}; use actix_web_actors::ws; -use postgres::transaction::Transaction; use serde_cbor::{from_slice}; use uuid::Uuid; use failure::Error; @@ -10,7 +9,7 @@ use failure::err_msg; use net::{Db}; use ws::{MnmlSocket}; -use construct::{Construct, construct_spawn, construct_delete}; +use construct::{Construct}; use game::{Game, game_state, game_skill, game_ready}; use account::{Account, account_constructs, account_instances}; use skill::{Skill, dev_resolve, Resolutions}; @@ -22,208 +21,6 @@ use mtx; type MnmlWs = ws::WebsocketContext; -pub fn receive(data: Vec, db: &Db, client: &mut MnmlWs, begin: Instant, account: Option<&Account>) -> Result { - // cast the msg to this type to receive method name - match from_slice::(&data) { - Ok(v) => { - if v.method == "ping" { - return Ok(RpcResult::Pong(())); - } - - let mut tx = db.transaction()?; - - let account_name = match account { - Some(a) => a.name.clone(), - None => "none".to_string(), - }; - - // check the method - // if no auth required - match v.method.as_ref() { - "item_info" => return Ok(RpcResult::ItemInfo(item_info())), - "dev_game_resolve" => return handle_dev_resolve(data), - _ => match account { - Some(_) => (), - None => return Err(err_msg("auth required")), - }, - }; - - let account = account.unwrap(); - - // now we have the method name - // match on that to determine what fn to call - let response = match v.method.as_ref() { - "account_state" => return Ok(RpcResult::AccountState(account.clone())), - "account_constructs" => handle_account_constructs(data, &mut tx, account), - "account_instances" => handle_account_instances(data, &mut tx, account), - - "construct_spawn" => handle_construct_spawn(data, &mut tx, account), - "construct_delete" => handle_construct_delete(data, &mut tx, account), - - "game_state" => handle_game_state(data, &mut tx, account), - "game_skill" => handle_game_skill(data, &mut tx, account), - "game_ready" => handle_game_ready(data, &mut tx, account), - - "instance_list" => handle_instance_list(data, &mut tx, account), - "instance_join" => handle_instance_join(data, &mut tx, account), - "instance_ready" => handle_instance_ready(data, &mut tx, account), - "instance_new" => handle_instance_new(data, &mut tx, account), - "instance_state" => handle_instance_state(data, &mut tx, account), - - "mtx_apply" => handle_mtx_apply(data, &mut tx, client, account), - - "vbox_accept" => handle_vbox_accept(data, &mut tx, account), - "vbox_apply" => handle_vbox_apply(data, &mut tx, account), - "vbox_combine" => handle_vbox_combine(data, &mut tx, account), - "vbox_discard" => handle_vbox_discard(data, &mut tx, account), - "vbox_reclaim" => handle_vbox_reclaim(data, &mut tx, account), - "vbox_unequip" => handle_vbox_unequip(data, &mut tx, account), - - _ => Err(format_err!("unknown method - {:?}", v.method)), - }; - - tx.commit()?; - - info!("method={:?} account={:?} duration={:?}", v.method, account_name, begin.elapsed()); - - return response; - }, - Err(e) => { - info!("{:?}", e); - Err(err_msg("unknown error")) - }, - } -} - -fn handle_game_state(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - return Ok(RpcResult::GameState(game_state(msg.params, tx, &account)?)); -} - -// fn handle_game_pve(data: Vec, tx: &mut Transaction, account: &Account) -> 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_pve(msg.params, tx, &account)?) -// }; - -// return Ok(game_response); -// } - -fn handle_game_skill(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - Ok(RpcResult::GameState(game_skill(msg.params, tx, &account)?)) -} - -fn handle_game_ready(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - Ok(RpcResult::GameState(game_ready(msg.params, tx, &account)?)) -} - -fn handle_construct_spawn(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - construct_spawn(tx, msg.params, account.id)?; - Ok(RpcResult::AccountConstructs(account_constructs(tx, account)?)) -} - -fn handle_construct_delete(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - construct_delete(tx, msg.params.id, account.id)?; - Ok(RpcResult::AccountConstructs(account_constructs(tx, &account)?)) -} - -// fn handle_account::create(data: Vec, tx: &mut Transaction) -> Result { -// let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; -// let account = account::create(msg.params, tx)?; -// Ok(RpcResult::Account(account)) -// } - -// fn handle_account_login(data: Vec, tx: &mut Transaction) -> Result { -// let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; -// Ok(RpcResult::Account(account_login(msg.params, tx)?)) -// } - -fn handle_account_constructs(_data: Vec, tx: &mut Transaction, account: &Account) -> Result { - Ok(RpcResult::AccountConstructs(account_constructs(tx, &account)?)) -} - -fn handle_account_instances(_data: Vec, tx: &mut Transaction, account: &Account) -> Result { - Ok(RpcResult::AccountInstances(account_instances(tx, &account)?)) -} - -fn handle_instance_new(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - Ok(RpcResult::InstanceState(instance_new(msg.params, tx, &account)?)) -} - -fn handle_instance_ready(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - Ok(RpcResult::InstanceState(instance_ready(msg.params, tx, &account)?)) -} - -fn handle_instance_join(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - Ok(RpcResult::InstanceState(instance_join(msg.params, tx, &account)?)) -} - -fn handle_instance_list(_data: Vec, tx: &mut Transaction, _account: &Account) -> Result { - Ok(RpcResult::OpenInstances(instance_list(tx)?)) -} - - -fn handle_instance_state(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - match instance_state(msg.params, tx, &account)? { - RpcResult::GameState(p) => Ok(RpcResult::GameState(p)), - RpcResult::InstanceState(p) => Ok(RpcResult::InstanceState(p)), - _ => Err(err_msg("unhandled instance state")) - } -} - -fn handle_mtx_apply(data: Vec, tx: &mut Transaction, client: &mut MnmlWs, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - mtx::apply(tx, msg.params.mtx, msg.params.construct_id, account.id)?; - - Ok(RpcResult::AccountConstructs(account_constructs(tx, &account)?)) -} - -fn handle_vbox_accept(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - Ok(RpcResult::InstanceState(vbox_accept(msg.params, tx, &account)?)) -} - -fn handle_vbox_discard(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - Ok(RpcResult::InstanceState(vbox_discard(msg.params, tx, &account)?)) -} - - -fn handle_vbox_combine(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - Ok(RpcResult::InstanceState(vbox_combine(msg.params, tx, &account)?)) -} - -fn handle_vbox_apply(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - Ok(RpcResult::InstanceState(vbox_apply(msg.params, tx, &account)?)) -} - -fn handle_vbox_reclaim(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - Ok(RpcResult::InstanceState(vbox_reclaim(msg.params, tx, &account)?)) -} - -fn handle_vbox_unequip(data: Vec, tx: &mut Transaction, account: &Account) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - Ok(RpcResult::InstanceState(vbox_unequip(msg.params, tx, &account)?)) -} - -fn handle_dev_resolve(data: Vec) -> Result { - let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; - Ok(RpcResult::DevResolutions(dev_resolve(msg.params.a, msg.params.b, msg.params.skill))) -} - #[derive(Debug,Clone,Serialize,Deserialize)] pub enum RpcResult { AccountState(Account), @@ -241,245 +38,136 @@ pub enum RpcResult { } #[derive(Debug,Clone,Serialize,Deserialize)] -pub struct RpcMessage { - method: String, - token: Option, +enum RpcRequest { + Ping {}, + ItemInfo {}, + DevResolve { a: Uuid, b: Uuid, skill: Skill }, + + MtxConstructApply { mtx: mtx::MtxVariant, construct_id: Uuid }, + MtxAccountApply { mtx: mtx::MtxVariant }, + + GameState { id: Uuid }, + GameReady { id: Uuid }, + GameSkill { game_id: Uuid, construct_id: Uuid, target_construct_id: Option, skill: Skill }, + + AccountState {}, + AccountConstructs {}, + AccountInstances {}, + + InstanceList {}, + InstanceLobby { construct_ids: Vec, name: String, pve: bool, password: Option }, + InstanceJoin { instance_id: Uuid, construct_ids: Vec }, + InstanceReady { instance_id: Uuid }, + InstanceState { instance_id: Uuid }, + + VboxAccept { instance_id: Uuid, group: usize, index: usize }, + VboxDiscard { instance_id: Uuid }, + VboxCombine { instance_id: Uuid, indices: Vec }, + VboxApply { instance_id: Uuid, construct_id: Uuid, index: usize }, + VboxUnequip { instance_id: Uuid, construct_id: Uuid, target: Item }, + VboxReclaim { instance_id: Uuid, index: usize }, } -#[derive(Debug,Clone,Serialize,Deserialize)] -struct ConstructSpawnMsg { - method: String, - params: ConstructSpawnParams, +pub fn receive(data: Vec, db: &Db, _client: &mut MnmlWs, begin: Instant, account: Option<&Account>) -> Result { + // cast the msg to this type to receive method name + match from_slice::(&data) { + Ok(v) => { + + // non authenticated + // non transactional reqs + match v { + RpcRequest::Ping {} => return Ok(RpcResult::Pong(())), + RpcRequest::ItemInfo {} => return Ok(RpcResult::ItemInfo(item_info())), + RpcRequest::DevResolve {a, b, skill } => + return Ok(RpcResult::DevResolutions(dev_resolve(a, b, skill))), + _ => (), + }; + + // check for authorization now + let account = match account { + Some(account) => account, + None => return Err(err_msg("auth required")), + }; + + // all good, let's make a tx and process + let mut tx = db.transaction()?; + + let request = v.clone(); + + let response = match v { + RpcRequest::AccountState {} => + return Ok(RpcResult::AccountState(account.clone())), + RpcRequest::AccountConstructs {} => + Ok(RpcResult::AccountConstructs(account_constructs(&mut tx, &account)?)), + RpcRequest::AccountInstances {} => + Ok(RpcResult::AccountInstances(account_instances(&mut tx, &account)?)), + + + // RpcRequest::ConstructDelete" => handle_construct_delete(data, &mut tx, account), + + RpcRequest::GameState { id } => + Ok(RpcResult::GameState(game_state(&mut tx, account, id)?)), + + RpcRequest::GameSkill { game_id, construct_id, target_construct_id, skill } => + Ok(RpcResult::GameState(game_skill(&mut tx, account, game_id, construct_id, target_construct_id, skill)?)), + + RpcRequest::GameReady { id } => + Ok(RpcResult::GameState(game_ready(&mut tx, account, id)?)), + + RpcRequest::InstanceList {} => + Ok(RpcResult::OpenInstances(instance_list(&mut tx)?)), + RpcRequest::InstanceLobby { construct_ids, name, pve, password } => + Ok(RpcResult::InstanceState(instance_new(&mut tx, account, construct_ids, name, pve, password)?)), + RpcRequest::InstanceJoin { instance_id, construct_ids } => + Ok(RpcResult::InstanceState(instance_join(&mut tx, account, instance_id, construct_ids)?)), + RpcRequest::InstanceReady { instance_id } => + Ok(RpcResult::InstanceState(instance_ready(&mut tx, account, instance_id)?)), + RpcRequest::InstanceState { instance_id } => + Ok(instance_state(&mut tx, account, instance_id)?), + + RpcRequest::VboxAccept { instance_id, group, index } => + Ok(RpcResult::InstanceState(vbox_accept(&mut tx, account, instance_id, group, index)?)), + + RpcRequest::VboxApply { instance_id, construct_id, index } => + Ok(RpcResult::InstanceState(vbox_apply(&mut tx, account, instance_id, construct_id, index)?)), + + RpcRequest::VboxCombine { instance_id, indices } => + Ok(RpcResult::InstanceState(vbox_combine(&mut tx, account, instance_id, indices)?)), + + RpcRequest::VboxDiscard { instance_id } => + Ok(RpcResult::InstanceState(vbox_discard(&mut tx, account, instance_id)?)), + + RpcRequest::VboxReclaim { instance_id, index } => + Ok(RpcResult::InstanceState(vbox_reclaim(&mut tx, account, instance_id, index)?)), + + RpcRequest::VboxUnequip { instance_id, construct_id, target } => + Ok(RpcResult::InstanceState(vbox_unequip(&mut tx, account, instance_id, construct_id, target)?)), + + // "mtx_apply" => handle_mtx_apply(data, &mut tx, account), + + _ => Err(format_err!("unknown request request={:?}", request)), + }; + + tx.commit()?; + + info!("request={:?} account={:?} duration={:?}", request, account.name, begin.elapsed()); + + return response; + }, + Err(e) => { + info!("{:?}", e); + Err(err_msg("invalid message")) + }, + } } -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct ConstructSpawnParams { - pub name: String, -} +// fn handle_mtx_apply(data: Vec, tx: &mut Transaction, account: &Account) -> Result { +// let msg = from_slice::(&data).or(Err(err_msg("invalid params")))?; +// match msg.params { +// MtxApplyParams::ConstructApply { construct_id, mtx } => +// mtx::apply(tx, mtx, construct_id, account.id)?, +// _ => unimplemented!(), +// }; -#[derive(Debug,Clone,Serialize,Deserialize)] -struct ConstructDeleteMsg { - method: String, - params: ConstructDeleteParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct ConstructDeleteParams { - pub id: Uuid, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct GameStateMsg { - method: String, - params: GameStateParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct GameStateParams { - pub id: Uuid, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct GameSkillMsg { - method: String, - params: GameSkillParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct GameSkillParams { - pub game_id: Uuid, - pub construct_id: Uuid, - pub target_construct_id: Option, - pub skill: Skill, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct AccountCreateMsg { - method: String, - params: AccountCreateParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct AccountCreateParams { - pub name: String, - pub password: String, - pub code: String, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct AccountLoginMsg { - method: String, - params: AccountLoginParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct AccountLoginParams { - pub name: String, - pub password: String, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct AccountConstructsMsg { - method: String, - params: (), -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct InstanceLobbyMsg { - method: String, - params: InstanceLobbyParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct InstanceLobbyParams { - pub construct_ids: Vec, - pub name: String, - pub pve: bool, - pub password: Option, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct InstanceJoinMsg { - method: String, - params: InstanceJoinParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct InstanceJoinParams { - pub instance_id: Uuid, - pub construct_ids: Vec, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct InstanceReadyMsg { - method: String, - params: InstanceReadyParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct InstanceReadyParams { - pub instance_id: Uuid, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct InstanceStateMsg { - method: String, - params: InstanceStateParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct InstanceStateParams { - pub instance_id: Uuid, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct MtxApplyMsg { - method: String, - params: MtxApplyParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct MtxApplyParams { - pub construct_id: Uuid, - pub mtx: mtx::MtxVariant, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct VboxAcceptMsg { - method: String, - params: VboxAcceptParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct VboxAcceptParams { - pub instance_id: Uuid, - pub group: usize, - pub index: usize, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct VboxDiscardMsg { - method: String, - params: VboxDiscardParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct VboxDiscardParams { - pub instance_id: Uuid, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct VboxCombineMsg { - method: String, - params: VboxCombineParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct VboxCombineParams { - pub instance_id: Uuid, - pub indices: Vec, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct VboxApplyMsg { - method: String, - params: VboxApplyParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct VboxApplyParams { - pub instance_id: Uuid, - pub construct_id: Uuid, - pub index: usize, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct VboxUnequipMsg { - method: String, - params: VboxUnequipParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct VboxUnequipParams { - pub instance_id: Uuid, - pub construct_id: Uuid, - pub target: Item, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct VboxReclaimMsg { - method: String, - params: VboxReclaimParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct VboxReclaimParams { - pub instance_id: Uuid, - pub index: usize, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -struct DevResolveMsg { - method: String, - params: DevResolveParams, -} - -#[derive(Debug,Clone,Serialize,Deserialize)] -pub struct DevResolveParams { - pub a: Uuid, - pub b: Uuid, - pub skill: Skill, -} - -// #[cfg(test)] -// mod tests { -// use super::*; -// use serde_cbor::to_vec; -// #[test] -// fn rpc_parse() { -// let rpc = Rpc {}; -// let msg = GenerateMsg { method: "construct_generate".to_string(), params: GenerateParams { level: 64 } }; -// let v = to_vec(&msg).unwrap(); -// let received = rpc.receive(Message::Binary(v)); -// } -// } \ No newline at end of file +// Ok(RpcResult::AccountConstructs(account_constructs(tx, &account)?)) +// } diff --git a/server/src/vbox.rs b/server/src/vbox.rs index 91161137..b41ab409 100644 --- a/server/src/vbox.rs +++ b/server/src/vbox.rs @@ -1,3 +1,5 @@ +use uuid::Uuid; + use std::iter; // reclaims @@ -11,7 +13,7 @@ use failure::Error; use failure::err_msg; use account::Account; -use rpc::{VboxAcceptParams, VboxDiscardParams, VboxCombineParams, VboxApplyParams, VboxReclaimParams, VboxUnequipParams}; + use instance::{Instance, instance_get, instance_update}; use construct::{Colours}; @@ -155,39 +157,39 @@ impl Vbox { } } -pub fn vbox_discard(params: VboxDiscardParams, tx: &mut Transaction, account: &Account) -> Result { - let instance = instance_get(tx, params.instance_id)? +pub fn vbox_discard(tx: &mut Transaction, account: &Account, instance_id: Uuid) -> Result { + let instance = instance_get(tx, instance_id)? .vbox_discard(account.id)?; return instance_update(tx, instance); } -pub fn vbox_accept(params: VboxAcceptParams, tx: &mut Transaction, account: &Account) -> Result { - let instance = instance_get(tx, params.instance_id)? - .vbox_accept(account.id, params.group, params.index)?; +pub fn vbox_accept(tx: &mut Transaction, account: &Account, instance_id: Uuid, group: usize, index: usize) -> Result { + let instance = instance_get(tx, instance_id)? + .vbox_accept(account.id, group, index)?; return instance_update(tx, instance); } -pub fn vbox_combine(params: VboxCombineParams, tx: &mut Transaction, account: &Account) -> Result { - let instance = instance_get(tx, params.instance_id)? - .vbox_combine(account.id, params.indices)?; +pub fn vbox_combine(tx: &mut Transaction, account: &Account, instance_id: Uuid, indices: Vec) -> Result { + let instance = instance_get(tx, instance_id)? + .vbox_combine(account.id, indices)?; return instance_update(tx, instance); } -pub fn vbox_reclaim(params: VboxReclaimParams, tx: &mut Transaction, account: &Account) -> Result { - let instance = instance_get(tx, params.instance_id)? - .vbox_reclaim(account.id, params.index)?; +pub fn vbox_reclaim(tx: &mut Transaction, account: &Account, instance_id: Uuid, index: usize) -> Result { + let instance = instance_get(tx, instance_id)? + .vbox_reclaim(account.id, index)?; return instance_update(tx, instance); } -pub fn vbox_apply(params: VboxApplyParams, tx: &mut Transaction, account: &Account) -> Result { - let instance = instance_get(tx, params.instance_id)? - .vbox_apply(account.id, params.index, params.construct_id)?; +pub fn vbox_apply(tx: &mut Transaction, account: &Account, instance_id: Uuid, construct_id: Uuid, index: usize) -> Result { + let instance = instance_get(tx, instance_id)? + .vbox_apply(account.id, index, construct_id)?; return instance_update(tx, instance); } -pub fn vbox_unequip(params: VboxUnequipParams, tx: &mut Transaction, account: &Account) -> Result { - let instance = instance_get(tx, params.instance_id)? - .vbox_unequip(account.id, params.target, params.construct_id)?; +pub fn vbox_unequip(tx: &mut Transaction, account: &Account, instance_id: Uuid, construct_id: Uuid, target: Item) -> Result { + let instance = instance_get(tx, instance_id)? + .vbox_unequip(account.id, target, construct_id)?; return instance_update(tx, instance); }