ntr/mnml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of ssh://cryps.gg:40022/~/cryps

Browse Source
This commit is contained in:
Mashy 2018-11-23 15:07:48 +10:00
commit 47547ed657
4 changed files with 76 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
server/WORKLOG.md
View File

@ -11,9 +11,6 @@
* Global rolls * Global rolls
* Stats
* Scrabble grid
* skills * skills
* handle setting account better maybe? * handle setting account better maybe?
* ensure cryp untargetable and doesn't resolve when KO * ensure cryp untargetable and doesn't resolve when KO
@ -22,8 +19,6 @@
* private fields for opponents * private fields for opponents
* attack * attack
* can you attack yourself? * can you attack yourself?
* fetch existing battles
* check for game participation
* write players row for every team+cryp added * write players row for every team+cryp added
* return results<> * return results<>
* defensive * defensive
@ -40,25 +35,6 @@
* Bosses * Bosses
* rez ✔
* move rpc functions out ✔
* cooldowns reduce each turn ✔
* statuses reduce each turn ✔
* teach cyps skills ✔
* spell/phys dmg ✔
* offensive -> choose target ✔
* ws reconnect ✔
* Levelling ✔
* Logins ✔️
* Cryp Ownership ✔
* Matchmaking ✔
* Lobbies ✔
* Create ✔
* Join ✔
* Resolve ✔
# Db maintenance # Db maintenance
* delete games when a cryp is deleted * delete games when a cryp is deleted
* does this need to happen? can have historical games * does this need to happen? can have historical games

6
server/src/cryp.rs
View File

@ -359,6 +359,12 @@ pub fn cryp_spawn(params: CrypSpawnParams, tx: &mut Transaction, account: &Accou
pub fn cryp_learn(params: CrypLearnParams, tx: &mut Transaction, account: &Account) -> Result<Cryp, Error> { pub fn cryp_learn(params: CrypLearnParams, tx: &mut Transaction, account: &Account) -> Result<Cryp, Error> {
let mut cryp = cryp_get(tx, params.id, account.id)?; let mut cryp = cryp_get(tx, params.id, account.id)?;
let max_skills = 4;
if cryp.skills.len() >= max_skills {
return Err(format_err!("cryp at max skills ({:?})", max_skills));
}
cryp = cryp.learn(params.skill); cryp = cryp.learn(params.skill);
return cryp_write(cryp, tx); return cryp_write(cryp, tx);
} }

2
server/src/game.rs
View File

@ -747,7 +747,7 @@ mod tests {
use cryp::*; use cryp::*;
fn create_test_game() -> Game { fn create_test_game() -> Game {
let x = Cryp::new() let mut x = Cryp::new()
.named(&"pronounced \"creeep\"".to_string()) .named(&"pronounced \"creeep\"".to_string())
.level(8) .level(8)
.learn(Skill::TestStun) .learn(Skill::TestStun)

187
server/src/rpc.rs
View File

@ -33,26 +33,38 @@ impl Rpc {
None => None, None => None,
}; };
println!("{:?}", account); // check the method
// if no auth required
match v.method.as_ref() {
"account_create" => (),
"account_login" => (),
_ => match account {
Some(_) => (),
None => return Err(err_msg("auth required")),
},
};
// now we have the method name // now we have the method name
// match on that to determine what fn to call // match on that to determine what fn to call
let response = match v.method.as_ref() { let response = match v.method.as_ref() {
"cryp_spawn" => Rpc::cryp_spawn(data, &mut tx, account, client), // no auth methods
"cryp_learn" => Rpc::cryp_learn(data, &mut tx, account, client), "account_create" => Rpc::account_create(data, &mut tx, client),
"cryp_forget" => Rpc::cryp_forget(data, &mut tx, account, client), "account_login" => Rpc::account_login(data, &mut tx, client),
"game_state" => Rpc::game_state(data, &mut tx, account, client),
"game_pve" => Rpc::game_pve(data, &mut tx, account, client), // auth methods
"game_pvp" => Rpc::game_pvp(data, &mut tx, account, client), "cryp_spawn" => Rpc::cryp_spawn(data, &mut tx, account.unwrap(), client),
"game_join" => Rpc::game_join(data, &mut tx, account, client), "cryp_learn" => Rpc::cryp_learn(data, &mut tx, account.unwrap(), client),
"game_joinable_list" => Rpc::game_joinable_list(data, &mut tx, account, client), "cryp_forget" => Rpc::cryp_forget(data, &mut tx, account.unwrap(), client),
"game_skill" => Rpc::game_skill(data, &mut tx, account, client), "game_state" => Rpc::game_state(data, &mut tx, account.unwrap(), client),
"game_target" => Rpc::game_target(data, &mut tx, account, client), "game_pve" => Rpc::game_pve(data, &mut tx, account.unwrap(), client),
"account_create" => Rpc::account_create(data, &mut tx, account, client), "game_pvp" => Rpc::game_pvp(data, &mut tx, account.unwrap(), client),
"account_login" => Rpc::account_login(data, &mut tx, account, client), "game_join" => Rpc::game_join(data, &mut tx, account.unwrap(), client),
"account_cryps" => Rpc::account_cryps(data, &mut tx, account, client), "game_joinable_list" => Rpc::game_joinable_list(data, &mut tx, account.unwrap(), client),
"item_list" => Rpc::item_list(data, &mut tx, account, client), "game_skill" => Rpc::game_skill(data, &mut tx, account.unwrap(), client),
"item_use" => Rpc::item_use(data, &mut tx, account, client), "game_target" => Rpc::game_target(data, &mut tx, account.unwrap(), client),
"account_cryps" => Rpc::account_cryps(data, &mut tx, account.unwrap(), client),
"item_list" => Rpc::item_list(data, &mut tx, account.unwrap(), client),
"item_use" => Rpc::item_use(data, &mut tx, account.unwrap(), client),
_ => Err(err_msg("unknown method")), _ => Err(err_msg("unknown method")),
}; };
@ -73,88 +85,63 @@ impl Rpc {
} }
} }
fn game_state(data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn game_state(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let a = match account {
Some(a) => a,
None => return Err(err_msg("auth required")),
};
let msg = from_slice::<GameStateMsg>(&data).or(Err(err_msg("invalid params")))?; let msg = from_slice::<GameStateMsg>(&data).or(Err(err_msg("invalid params")))?;
let game_response = RpcResponse { let game_response = RpcResponse {
method: "game_state".to_string(), method: "game_state".to_string(),
params: RpcResult::GameState(game_state(msg.params, tx, &a)?) params: RpcResult::GameState(game_state(msg.params, tx, &account)?)
}; };
return Ok(game_response); return Ok(game_response);
} }
fn game_pve(data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn game_pve(data: Vec<u8>, tx: &mut Transaction, account: Account, client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let a = match account {
Some(a) => a,
None => return Err(err_msg("auth required")),
};
let msg = from_slice::<GamePveMsg>(&data).or(Err(err_msg("invalid params")))?; let msg = from_slice::<GamePveMsg>(&data).or(Err(err_msg("invalid params")))?;
let game_response = RpcResponse { let game_response = RpcResponse {
method: "game_state".to_string(), method: "game_state".to_string(),
params: RpcResult::GameState(game_pve(msg.params, tx, &a)?) params: RpcResult::GameState(game_pve(msg.params, tx, &account)?)
}; };
Rpc::send_msg(client, RpcResponse { Rpc::send_msg(client, RpcResponse {
method: "account_cryps".to_string(), method: "account_cryps".to_string(),
params: RpcResult::CrypList(account_cryps(tx, &a)?) params: RpcResult::CrypList(account_cryps(tx, &account)?)
})?; })?;
return Ok(game_response); return Ok(game_response);
} }
fn game_pvp(data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn game_pvp(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let a = match account {
Some(a) => a,
None => return Err(err_msg("auth required")),
};
let msg = from_slice::<GamePvpMsg>(&data).or(Err(err_msg("invalid params")))?; let msg = from_slice::<GamePvpMsg>(&data).or(Err(err_msg("invalid params")))?;
let game_response = RpcResponse { let game_response = RpcResponse {
method: "game_state".to_string(), method: "game_state".to_string(),
params: RpcResult::GameState(game_pvp(msg.params, tx, &a)?) params: RpcResult::GameState(game_pvp(msg.params, tx, &account)?)
}; };
return Ok(game_response); return Ok(game_response);
} }
fn game_join(data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn game_join(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let a = match account {
Some(a) => a,
None => return Err(err_msg("auth required")),
};
let msg = from_slice::<GameJoinMsg>(&data).or(Err(err_msg("invalid params")))?; let msg = from_slice::<GameJoinMsg>(&data).or(Err(err_msg("invalid params")))?;
let game_response = RpcResponse { let game_response = RpcResponse {
method: "game_state".to_string(), method: "game_state".to_string(),
params: RpcResult::GameState(game_join(msg.params, tx, &a)?) params: RpcResult::GameState(game_join(msg.params, tx, &account)?)
}; };
return Ok(game_response); return Ok(game_response);
} }
fn game_joinable_list(_data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn game_joinable_list(_data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let a = match account {
Some(a) => a,
None => return Err(err_msg("auth required")),
};
// let msg = from_slice::<GameJoinMsg>(&data).or(Err(err_msg("invalid params")))?; // let msg = from_slice::<GameJoinMsg>(&data).or(Err(err_msg("invalid params")))?;
let game_list = RpcResponse { let game_list = RpcResponse {
method: "game_joinable_list".to_string(), method: "game_joinable_list".to_string(),
params: RpcResult::GameJoinableList(game_joinable_list(tx, &a)?) params: RpcResult::GameJoinableList(game_joinable_list(tx, &account)?)
}; };
return Ok(game_list); return Ok(game_list);
@ -162,114 +149,89 @@ impl Rpc {
fn game_skill(data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn game_skill(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let a = match account {
Some(a) => a,
None => return Err(err_msg("auth required")),
};
let msg = from_slice::<GameSkillMsg>(&data).or(Err(err_msg("invalid params")))?; let msg = from_slice::<GameSkillMsg>(&data).or(Err(err_msg("invalid params")))?;
let game_response = RpcResponse { let game_response = RpcResponse {
method: "game_state".to_string(), method: "game_state".to_string(),
params: RpcResult::GameState(game_skill(msg.params, tx, &a)?) params: RpcResult::GameState(game_skill(msg.params, tx, &account)?)
}; };
// Rpc::send_msg(client, RpcResponse { // Rpc::send_msg(client, RpcResponse {
// method: "account_cryps".to_string(), // method: "account_cryps".to_string(),
// params: RpcResult::CrypList(account_cryps(tx, &a)?) // params: RpcResult::CrypList(account_cryps(tx, &account)?)
// })?; // })?;
return Ok(game_response); return Ok(game_response);
} }
fn game_target(data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn game_target(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let a = match account {
Some(a) => a,
None => return Err(err_msg("auth required")),
};
let msg = from_slice::<GameTargetMsg>(&data).or(Err(err_msg("invalid params")))?; let msg = from_slice::<GameTargetMsg>(&data).or(Err(err_msg("invalid params")))?;
let game_response = RpcResponse { let game_response = RpcResponse {
method: "game_state".to_string(), method: "game_state".to_string(),
params: RpcResult::GameState(game_target(msg.params, tx, &a)?) params: RpcResult::GameState(game_target(msg.params, tx, &account)?)
}; };
// Rpc::send_msg(client, RpcResponse { // Rpc::send_msg(client, RpcResponse {
// method: "account_cryps".to_string(), // method: "account_cryps".to_string(),
// params: RpcResult::CrypList(account_cryps(tx, &a)?) // params: RpcResult::CrypList(account_cryps(tx, &account)?)
// })?; // })?;
return Ok(game_response); return Ok(game_response);
} }
fn cryp_spawn(data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn cryp_spawn(data: Vec<u8>, tx: &mut Transaction, account: Account, client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let a = match account {
Some(a) => a,
None => return Err(err_msg("auth required")),
};
let msg = from_slice::<CrypSpawnMsg>(&data).or(Err(err_msg("invalid params")))?; let msg = from_slice::<CrypSpawnMsg>(&data).or(Err(err_msg("invalid params")))?;
Rpc::send_msg(client, RpcResponse { Rpc::send_msg(client, RpcResponse {
method: "cryp_spawn".to_string(), method: "cryp_spawn".to_string(),
params: RpcResult::CrypSpawn(cryp_spawn(msg.params, tx, &a)?) params: RpcResult::CrypSpawn(cryp_spawn(msg.params, tx, &account)?)
})?; })?;
let cryp_list = RpcResponse { let cryp_list = RpcResponse {
method: "account_cryps".to_string(), method: "account_cryps".to_string(),
params: RpcResult::CrypList(account_cryps(tx, &a)?) params: RpcResult::CrypList(account_cryps(tx, &account)?)
}; };
Ok(cryp_list) Ok(cryp_list)
} }
fn cryp_learn(data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn cryp_learn(data: Vec<u8>, tx: &mut Transaction, account: Account, client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let a = match account {
Some(a) => a,
None => return Err(err_msg("auth required")),
};
let msg = from_slice::<CrypLearnMsg>(&data).or(Err(err_msg("invalid params")))?; let msg = from_slice::<CrypLearnMsg>(&data).or(Err(err_msg("invalid params")))?;
Rpc::send_msg(client, RpcResponse { Rpc::send_msg(client, RpcResponse {
method: "cryp_learn".to_string(), method: "cryp_learn".to_string(),
params: RpcResult::CrypLearn(cryp_learn(msg.params, tx, &a)?) params: RpcResult::CrypLearn(cryp_learn(msg.params, tx, &account)?)
})?; })?;
let cryp_list = RpcResponse { let cryp_list = RpcResponse {
method: "account_cryps".to_string(), method: "account_cryps".to_string(),
params: RpcResult::CrypList(account_cryps(tx, &a)?) params: RpcResult::CrypList(account_cryps(tx, &account)?)
}; };
Ok(cryp_list) Ok(cryp_list)
} }
fn cryp_forget(data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn cryp_forget(data: Vec<u8>, tx: &mut Transaction, account: Account, client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let a = match account {
Some(a) => a,
None => return Err(err_msg("auth required")),
};
let msg = from_slice::<CrypForgetMsg>(&data).or(Err(err_msg("invalid params")))?; let msg = from_slice::<CrypForgetMsg>(&data).or(Err(err_msg("invalid params")))?;
Rpc::send_msg(client, RpcResponse { Rpc::send_msg(client, RpcResponse {
method: "cryp_forget".to_string(), method: "cryp_forget".to_string(),
params: RpcResult::CrypForget(cryp_forget(msg.params, tx, &a)?) params: RpcResult::CrypForget(cryp_forget(msg.params, tx, &account)?)
})?; })?;
let cryp_list = RpcResponse { let cryp_list = RpcResponse {
method: "account_cryps".to_string(), method: "account_cryps".to_string(),
params: RpcResult::CrypList(account_cryps(tx, &a)?) params: RpcResult::CrypList(account_cryps(tx, &account)?)
}; };
Ok(cryp_list) Ok(cryp_list)
} }
fn account_create(data: Vec<u8>, tx: &mut Transaction, _account: Option<Account>, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn account_create(data: Vec<u8>, tx: &mut Transaction, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
match from_slice::<AccountCreateMsg>(&data) { match from_slice::<AccountCreateMsg>(&data) {
Ok(v) => Ok(RpcResponse { Ok(v) => Ok(RpcResponse {
method: v.method, method: v.method,
@ -279,7 +241,7 @@ impl Rpc {
} }
} }
fn account_login(data: Vec<u8>, tx: &mut Transaction, _account: Option<Account>, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn account_login(data: Vec<u8>, tx: &mut Transaction, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
match from_slice::<AccountLoginMsg>(&data) { match from_slice::<AccountLoginMsg>(&data) {
Ok(v) => Ok(RpcResponse { Ok(v) => Ok(RpcResponse {
method: v.method, method: v.method,
@ -289,39 +251,28 @@ impl Rpc {
} }
} }
fn account_cryps(_data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn account_cryps(_data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
match account { Ok(RpcResponse {
Some(a) => Ok(RpcResponse { method: "account_cryps".to_string(),
method: "account_cryps".to_string(), params: RpcResult::CrypList(account_cryps(tx, &account)?)
params: RpcResult::CrypList(account_cryps(tx, &a)?) })
}),
None => Err(err_msg("auth required")),
}
} }
fn item_list(_data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn item_list(_data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
match account { Ok(RpcResponse {
Some(a) => Ok(RpcResponse { method: "item_list".to_string(),
method: "item_list".to_string(), params: RpcResult::ItemList(items_list(tx, &account)?)
params: RpcResult::ItemList(items_list(tx, &a)?) })
}),
None => Err(err_msg("auth required")),
}
} }
fn item_use(data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> { fn item_use(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let a = match account {
Some(a) => a,
None => return Err(err_msg("auth required")),
};
let msg = from_slice::<ItemUseMsg>(&data).or(Err(err_msg("invalid params")))?; let msg = from_slice::<ItemUseMsg>(&data).or(Err(err_msg("invalid params")))?;
item_use(msg.params, tx, &a)?; item_use(msg.params, tx, &account)?;
let cryps_list = RpcResponse { let cryps_list = RpcResponse {
method: "account_cryps".to_string(), method: "account_cryps".to_string(),
params: RpcResult::CrypList(account_cryps(tx, &a)?) params: RpcResult::CrypList(account_cryps(tx, &account)?)
}; };
return Ok(cryps_list); return Ok(cryps_list);