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-12-20 15:11:12 +10:00
commit f71c8ed8e1
8 changed files with 90 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server/Cargo.toml
View File

@ -4,7 +4,7 @@ version = "0.1.0"
authors = ["ntr <ntr@smokestack.io>"]
[dependencies]
rand = "0.5"
rand = "0.6"
uuid = { version = "0.5", features = ["serde", "v4"] }
serde = "1"
serde_derive = "1"

6
server/WORKLOG.md
View File

@ -13,7 +13,6 @@ strangle
## NOW
* pve granted stat reroll items
## SOON
* tutorial
* aoe skills
@ -21,13 +20,10 @@ strangle
* modifies skill base speed
* skills
* handle setting account better maybe?
* calculate
* hp increase/decrease
* private fields for opponents
* handle unserializable cryps
## LATER
* redis for game events
* chat
* notifications
* rejoin in progress games

6
server/src/account.rs
View File

@ -8,7 +8,6 @@ use serde_cbor::{from_slice};
use postgres::transaction::Transaction;
use rpc::{AccountCreateParams, AccountLoginParams};
use item::{Item, ItemAction, item_create};
use cryp::{Cryp, CrypRecover, cryp_write};
use game::Game;
@ -102,11 +101,6 @@ pub fn account_create(params: AccountCreateParams, tx: &mut Transaction) -> Resu
println!("{:?} registered", entry.name);
// give them a revive
let revive = Item::new(ItemAction::Revive, &entry);
item_create(revive, tx, &entry)?;
return Ok(entry);
}

48
server/src/cryp.rs
View File

@ -558,51 +558,3 @@ mod tests {
return;
}
}
// pub fn assign_str(&mut self, opp: &Cryp, plr_t: &mut Turn, opp_t: &Turn) -> &mut Cryp {
// // let final_str = opp_t.phys_dmg.result.saturating_sub(plr_t.agi.result);
// // let blocked = opp_t.phys_dmg.result.saturating_sub(final_str);
// let final_str = opp_t.phys_dmg.result & !plr_t.agi.result;
// let blocked = opp_t.phys_dmg.result & plr_t.agi.result;
// plr_t.log.push(format!("{:064b} <- attacking roll {:?}", opp_t.phys_dmg.result, opp_t.phys_dmg.result));
// // plr_t.log.push(format!("{:064b} <- blocking roll {:?}", plr_t.agi.result, plr_t.agi.result));
// plr_t.log.push(format!("{:064b} <- final str {:?} ({:?} blocked)", final_str, final_str, blocked));
// self.hp.reduce(final_str);
// plr_t.log.push(format!("{:?} deals {:?} str to {:?} ({:?} blocked / {:?} hp remaining)"
// ,opp.name
// ,final_str
// ,self.name
// ,blocked
// ,self.hp.base));
// plr_t.log.push(format!(""));
// self
// }
// fn roll(&self, c: &Cryp, log: &mut Vec<String>) -> Roll {
// let mut rng = thread_rng();
// let base: u64 = rng.gen();
// let mut roll = Roll { kind: self.kind, base, result: base };
// log.push(format!("{:?}", self.kind));
// log.push(format!("{:064b} <- base roll", base));
// // apply skills
// roll = c.skills.iter().fold(roll, |roll, s| s.apply(roll));
// // finally combine with CrypStat
// log.push(format!("{:064b} <- finalised", roll.result));
// roll.result = roll.result & self.base;
// log.push(format!("{:064b} & <- attribute roll", self.base));
// log.push(format!("{:064b} = {:?}", roll.result, roll.result));
// log.push(format!(""));
// return roll;
// }

20
server/src/game.rs
View File

@ -14,6 +14,7 @@ use account::Account;
use rpc::{GameStateParams, GameSkillParams, GamePveParams, GamePvpParams, GameTargetParams, GameJoinParams};
use cryp::{Cryp, cryp_get};
use skill::{Skill, Cast, ResolutionResult};
use item::{item_drop};
pub type Log = Vec<String>;
@ -514,7 +515,7 @@ impl Game {
// handle cooldowns and statuses
self.progress_durations();
if self.is_finished() {
if self.finished() {
return self.finish()
}
@ -551,13 +552,18 @@ impl Game {
self
}
fn is_finished(&self) -> bool {
fn finished(&self) -> bool {
self.teams.iter().any(|t| t.cryps.iter().all(|c| c.is_ko()))
}
fn winner(&self) -> Option<&Team> {
self.teams.iter().find(|t| t.cryps.iter().any(|c| !c.is_ko()))
}
fn finish(&mut self) -> &mut Game {
self.phase = Phase::Finish;
self.log.push(format!("Game finished."));
self.stack.clear();
{
let winner = self.teams.iter().find(|t| t.cryps.iter().any(|c| !c.is_ko()));
@ -567,8 +573,6 @@ impl Game {
};
}
self.stack.clear();
self
}
}
@ -717,7 +721,13 @@ pub fn game_update(game: &Game, tx: &mut Transaction) -> Result<(), Error> {
result.iter().next().ok_or(format_err!("game {:?} could not be written", game))?;
// println!("{:} wrote game", game.id);
if game.finished() {
if let Some(t) = game.winner() {
if !t.id.is_nil() {
item_drop(tx, t.id)?;
}
}
}
return Ok(());
}

88
server/src/item.rs
View File

@ -3,7 +3,11 @@ use uuid::Uuid;
use postgres::transaction::Transaction;
use failure::Error;
use failure::err_msg;
// drops
use rand::prelude::*;
use rand::{thread_rng, Rng};
use rand::distributions::{WeightedIndex};
use account::Account;
use rpc::{ItemUseParams};
@ -12,7 +16,9 @@ use cryp::{cryp_get, cryp_write};
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
pub enum ItemAction {
Revive,
RerollPhysDamage,
RerollSpellDamage,
RerollStamina,
}
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
@ -24,18 +30,20 @@ pub struct Item {
}
impl Item {
pub fn new(action: ItemAction, account: &Account) -> Item {
pub fn new(action: ItemAction, account_id: Uuid) -> Item {
let id = Uuid::new_v4();
return Item {
id,
account: account.id,
account: account_id,
action,
};
}
fn apply(&mut self, tx: &mut Transaction, target: Uuid) -> Result<(), Error> {
match self.action {
ItemAction::Revive => revive(self, tx, target),
ItemAction::RerollStamina => revive(self, tx, target),
ItemAction::RerollPhysDamage => revive(self, tx, target),
ItemAction::RerollSpellDamage => revive(self, tx, target),
}
}
}
@ -47,7 +55,26 @@ fn revive(item: &mut Item, tx: &mut Transaction, target: Uuid) -> Result<(), Err
return Ok(());
}
pub fn item_create(item: Item, tx: &mut Transaction, account: &Account) -> Result<Item, Error> {
pub fn item_drop(tx: &mut Transaction, account_id: Uuid) -> Result<Item, Error> {
let mut rng = thread_rng();
let actions = [
(ItemAction::RerollStamina, 1),
(ItemAction::RerollPhysDamage, 1),
(ItemAction::RerollSpellDamage, 1)
];
let dist = WeightedIndex::new(actions.iter().map(|item| item.1)).unwrap();
let kind = actions[dist.sample(&mut rng)].0;
let item = Item::new(kind, account_id);
println!("{:?} dropped {:?}", account_id, item);
return item_create(item, tx, account_id);
}
pub fn item_create(item: Item, tx: &mut Transaction, account_id: Uuid) -> Result<Item, Error> {
let item_bytes = to_vec(&item)?;
let query = "
@ -57,11 +84,11 @@ pub fn item_create(item: Item, tx: &mut Transaction, account: &Account) -> Resul
";
let result = tx
.query(query, &[&item.id, &account.id, &item_bytes])?;
.query(query, &[&item.id, &account_id, &item_bytes])?;
let _returned = result.iter().next().expect("no row returned");
result.iter().next().expect("no row returned");
println!("{:?} wrote item {:}", account.id, item.id);
println!("{:?} wrote item {:}", account_id, item.id);
return Ok(item);
}
@ -84,13 +111,33 @@ pub fn item_use(params: ItemUseParams, tx: &mut Transaction, account: &Account)
let mut item = from_slice::<Item>(&item_bytes)?;
item.apply(tx, params.target)?;
item_delete(tx, params.item)?;
return Ok(());
}
pub fn item_delete(tx: &mut Transaction, id: Uuid) -> Result<(), Error> {
let query = "
DELETE
FROM items
WHERE id = $1;
";
let result = tx
.execute(query, &[&id])?;
if result != 1 {
return Err(format_err!("unable to delete item {:?}", id));
}
println!("invalid item deleted {:?}", id);
return Ok(());
}
pub fn items_list(tx: &mut Transaction, account: &Account) -> Result<Vec<Item>, Error> {
let query = "
SELECT data
SELECT data, id
FROM items
WHERE account = $1;
";
@ -98,18 +145,21 @@ pub fn items_list(tx: &mut Transaction, account: &Account) -> Result<Vec<Item>,
let result = tx
.query(query, &[&account.id])?;
let items: Result<Vec<Item>, _> = result.iter().map(|row| {
let item_bytes: Vec<u8> = row.get(0);
from_slice::<Item>(&item_bytes)
}).collect();
let mut items = vec![];
// catch any errors
if items.is_err() {
return Err(err_msg("could not deserialize an item"));
for row in result.into_iter() {
let item_bytes: Vec<u8> = row.get(0);
let id = row.get(1);
match from_slice::<Item>(&item_bytes) {
Ok(i) => items.push(i),
Err(_e) => {
item_delete(tx, id)?;
}
};
}
// now unwrap is safe
return Ok(items.unwrap());
return Ok(items);
}
// # max damage potion

12
server/src/rpc.rs
View File

@ -7,7 +7,7 @@ use std::net::{TcpStream};
// demo
use std::iter;
use rand::{thread_rng, Rng};
use rand::distributions::Alphanumeric;
use rand::distributions::{Alphanumeric};
use serde_cbor::{from_slice, to_vec};
use uuid::Uuid;
@ -164,11 +164,6 @@ impl Rpc {
params: RpcResult::GameState(game_skill(msg.params, tx, &account)?)
};
// Rpc::send_msg(client, RpcResponse {
// method: "account_cryps".to_string(),
// params: RpcResult::CrypList(account_cryps(tx, &account)?)
// })?;
return Ok(game_response);
}
@ -180,11 +175,6 @@ impl Rpc {
params: RpcResult::GameState(game_target(msg.params, tx, &account)?)
};
// Rpc::send_msg(client, RpcResponse {
// method: "account_cryps".to_string(),
// params: RpcResult::CrypList(account_cryps(tx, &account)?)
// })?;
return Ok(game_response);
}

3
server/src/skill.rs
View File

@ -355,6 +355,9 @@ pub enum Skill {
Calm,
Rez,
// Sleep,
// Nightmare,
// -------------------
// Destruction
// -------------------