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

buildling

Browse Source
This commit is contained in:
ntr
2019-04-29 17:24:58 +10:00
parent 15ae93e70f
commit a8a000e1ff
13 changed files with 399 additions and 458 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/src/cryp.rs
+15 -15
View File
@@ -122,7 +122,7 @@ impl CrypStat {
// self.recalculate(specs)
// }
pub fn recalculate(&mut self, specs: &Vec<Spec>, team_colours: &Colours) -> &mut CrypStat {
pub fn recalculate(&mut self, specs: &Vec<Spec>, player_colours: &Colours) -> &mut CrypStat {
let specs = specs
.iter()
.filter(|s| s.affects().contains(&self.stat))
@@ -131,7 +131,7 @@ impl CrypStat {
// applied with fold because it can be zeroed or multiplied
// but still needs access to the base amount
let value = specs.iter().fold(self.base, |acc, s| s.apply(acc, self.base, team_colours));
let value = specs.iter().fold(self.base, |acc, s| s.apply(acc, self.base, player_colours));
self.value = value;
self.max = value;
@@ -259,17 +259,17 @@ impl Cryp {
self
}
pub fn apply_modifiers(&mut self, team_colours: &Colours) -> &mut Cryp {
pub fn apply_modifiers(&mut self, player_colours: &Colours) -> &mut Cryp {
self.specs.sort_unstable();
self.red_damage.recalculate(&self.specs, team_colours);
self.red_life.recalculate(&self.specs, team_colours);
self.blue_damage.recalculate(&self.specs, team_colours);
self.blue_life.recalculate(&self.specs, team_colours);
self.evasion.recalculate(&self.specs, team_colours);
self.speed.recalculate(&self.specs, team_colours);
self.green_damage.recalculate(&self.specs, team_colours);
self.green_life.recalculate(&self.specs, team_colours);
self.red_damage.recalculate(&self.specs, player_colours);
self.red_life.recalculate(&self.specs, player_colours);
self.blue_damage.recalculate(&self.specs, player_colours);
self.blue_life.recalculate(&self.specs, player_colours);
self.evasion.recalculate(&self.specs, player_colours);
self.speed.recalculate(&self.specs, player_colours);
self.green_damage.recalculate(&self.specs, player_colours);
self.green_life.recalculate(&self.specs, player_colours);
self
}
@@ -836,21 +836,21 @@ mod tests {
}
#[test]
fn cryp_team_modifiers_test() {
fn cryp_player_modifiers_test() {
let mut cryp = Cryp::new()
.named(&"team player".to_string());
.named(&"player player".to_string());
cryp.spec_add(Spec::RedDamageI).unwrap();
cryp.spec_add(Spec::GreenDamageI).unwrap();
cryp.spec_add(Spec::BlueDamageI).unwrap();
let team_colours = Colours {
let player_colours = Colours {
red: 5,
green: 15,
blue: 25,
};
cryp.apply_modifiers(&team_colours);
cryp.apply_modifiers(&player_colours);
assert!(cryp.red_damage.value == cryp.red_damage.base + cryp.red_damage.base.pct(20));
assert!(cryp.green_damage.value == cryp.green_damage.base + cryp.green_damage.base.pct(40));
server/src/game.rs
+193 -245
View File
@@ -18,56 +18,6 @@ use skill::{Skill, Effect, Cast, Resolution, Event, resolve};
use player::{Player};
use instance::{instance_game_finished, global_game_finished};
#[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Team {
pub id: Uuid,
pub player: Option<Uuid>,
pub bot: bool,
pub cryps: Vec<Cryp>,
pub ready: bool,
}
impl Team {
pub fn new(account: Uuid) -> Team {
return Team {
id: account,
player: None,
cryps: vec![],
bot: false,
ready: false,
};
}
pub fn set_bot(&mut self) -> &mut Team {
self.bot = true;
self
}
fn skills_required(&self) -> usize {
let required = self.cryps.iter()
.filter(|c| !c.is_ko())
.filter(|c| c.available_skills().len() > 0)
.collect::<Vec<&Cryp>>().len();
// println!("{:} requires {:} skills this turn", self.id, required);
return required;
}
fn taunting(&self) -> Option<&Cryp> {
self.cryps.iter()
.find(|c| c.affected(Effect::Taunt))
}
pub fn set_cryps(&mut self, mut cryps: Vec<Cryp>) -> &mut Team {
cryps.sort_unstable_by_key(|c| c.id);
self.cryps = cryps;
self
}
pub fn cryp_by_id(&mut self, id: Uuid) -> Option<&mut Cryp> {
self.cryps.iter_mut().find(|c| c.id == id)
}
}
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
pub enum Phase {
Start,
@@ -90,9 +40,9 @@ pub enum GameMode {
#[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Game {
pub id: Uuid,
pub team_size: usize,
pub team_num: usize,
pub teams: Vec<Team>,
pub player_cryps: usize,
pub player_num: usize,
pub players: Vec<Player>,
pub phase: Phase,
pub stack: Vec<Cast>,
pub resolved: Vec<Resolution>,
@@ -106,9 +56,9 @@ impl Game {
pub fn new() -> Game {
return Game {
id: Uuid::new_v4(),
team_size: 0,
team_num: 0,
teams: vec![],
player_cryps: 0,
player_num: 0,
players: vec![],
phase: Phase::Start,
stack: vec![],
resolved: vec![],
@@ -119,13 +69,13 @@ impl Game {
};
}
pub fn set_team_num(&mut self, size: usize) -> &mut Game {
self.team_num = size;
pub fn set_player_num(&mut self, size: usize) -> &mut Game {
self.player_num = size;
self
}
pub fn set_team_size(&mut self, size: usize) -> &mut Game {
self.team_size = size;
pub fn set_player_cryps(&mut self, size: usize) -> &mut Game {
self.player_cryps = size;
self
}
@@ -143,47 +93,47 @@ impl Game {
self.can_start()
}
pub fn team_add(&mut self, team: Team) -> Result<&mut Game, Error> {
if self.teams.len() == self.team_num {
return Err(err_msg("maximum number of teams"));
pub fn player_add(&mut self, player: Player) -> Result<&mut Game, Error> {
if self.players.len() == self.player_num {
return Err(err_msg("maximum number of players"));
}
if self.teams.iter().any(|t| t.id == team.id) {
return Err(err_msg("team already in game"));
if self.players.iter().any(|t| t.id == player.id) {
return Err(err_msg("player already in game"));
}
if team.cryps.iter().all(|c| c.skills.len() == 0) {
if player.cryps.iter().all(|c| c.skills.len() == 0) {
return Err(err_msg("your cryps have no skills"));
}
let team_description = team.cryps.iter().map(|c| c.name.clone()).collect::<Vec<String>>().join(", ");
self.log.push(format!("{:} has joined the game.", team_description));
let player_description = player.cryps.iter().map(|c| c.name.clone()).collect::<Vec<String>>().join(", ");
self.log.push(format!("{:} has joined the game.", player_description));
self.teams.push(team);
self.players.push(player);
Ok(self)
}
// handle missing team properly
pub fn team_by_id(&mut self, id: Uuid) -> &mut Team {
match self.teams.iter_mut().find(|t| t.id == id) {
Some(t) => t,
None => panic!("id not in game {:}", id),
}
// handle missing player properly
pub fn player_by_id(&mut self, id: Uuid) -> Result<&mut Player, Error> {
self.players
.iter_mut()
.find(|t| t.id == id)
.ok_or(format_err!("{:?} not in game", id))
}
pub fn cryp_by_id(&mut self, id: Uuid) -> Option<&mut Cryp> {
match self.teams.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == id)) {
Some(team) => team.cryps.iter_mut().find(|c| c.id == id),
match self.players.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == id)) {
Some(player) => player.cryps.iter_mut().find(|c| c.id == id),
None => None,
}
}
pub fn cryp_by_id_take(&mut self, id: Uuid) -> Cryp {
match self.teams.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == id)) {
Some(team) => {
let i = team.cryps.iter().position(|c| c.id == id).unwrap();
team.cryps.remove(i)
match self.players.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == id)) {
Some(player) => {
let i = player.cryps.iter().position(|c| c.id == id).unwrap();
player.cryps.remove(i)
}
None => panic!("id not in game {:}", id),
}
@@ -191,7 +141,7 @@ impl Game {
fn all_cryps(&self) -> Vec<Cryp> {
self.teams.clone()
self.players.clone()
.into_iter()
.flat_map(
|t| t.cryps
@@ -200,12 +150,12 @@ impl Game {
}
fn update_cryp(&mut self, cryp: &mut Cryp) -> &mut Game {
match self.teams.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == cryp.id)) {
Some(team) => {
let index = team.cryps.iter().position(|t| t.id == cryp.id).unwrap();
team.cryps.remove(index);
team.cryps.push(cryp.clone());
team.cryps.sort_unstable_by_key(|c| c.id);
match self.players.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == cryp.id)) {
Some(player) => {
let index = player.cryps.iter().position(|t| t.id == cryp.id).unwrap();
player.cryps.remove(index);
player.cryps.push(cryp.clone());
player.cryps.sort_unstable_by_key(|c| c.id);
},
None => panic!("cryp not in game"),
};
@@ -214,8 +164,8 @@ impl Game {
}
fn can_start(&self) -> bool {
return self.teams.len() == self.team_num
&& self.teams.iter().all(|t| t.cryps.len() == self.team_size)
return self.players.len() == self.player_num
&& self.players.iter().all(|t| t.cryps.len() == self.player_cryps)
}
pub fn start(mut self) -> Game {
@@ -244,10 +194,10 @@ impl Game {
fn pve_add_skills(&mut self) -> &mut Game {
let mut pve_skills = vec![];
for mobs in self.teams
for mobs in self.players
.iter()
.filter(|t| t.bot) {
let player_team = self.teams.iter().find(|t| t.id != mobs.id).unwrap();
let player_player = self.players.iter().find(|t| t.id != mobs.id).unwrap();
for mob in mobs.cryps.iter() {
let skill = mob.mob_select_skill();
@@ -261,7 +211,7 @@ impl Game {
let mut find_target = || {
match s.defensive() {
true => &mobs.cryps[rng.gen_range(0, mobs.cryps.len())],
false => &player_team.cryps[rng.gen_range(0, player_team.cryps.len())],
false => &player_player.cryps[rng.gen_range(0, player_player.cryps.len())],
}
};
@@ -278,8 +228,8 @@ impl Game {
}
}
for (team_id, mob_id, target_id, s) in pve_skills {
match self.add_skill(team_id, mob_id, target_id, s) {
for (player_id, mob_id, target_id, s) in pve_skills {
match self.add_skill(player_id, mob_id, target_id, s) {
Ok(_) => (),
Err(e) => {
println!("{:?}", self.cryp_by_id(mob_id));
@@ -291,7 +241,10 @@ impl Game {
self
}
fn add_skill(&mut self, team_id: Uuid, source_cryp_id: Uuid, target_cryp_id: Option<Uuid>, skill: Skill) -> Result<Uuid, Error> {
fn add_skill(&mut self, player_id: Uuid, source_cryp_id: Uuid, target_cryp_id: Option<Uuid>, skill: Skill) -> Result<Uuid, Error> {
// check player in game
self.player_by_id(player_id)?;
if self.phase != Phase::Skill {
return Err(err_msg("game not in skill phase"));
}
@@ -348,20 +301,27 @@ impl Game {
self.stack.remove(s);
}
let skill = Cast::new(source_cryp_id, team_id, final_target_id, skill);
let skill = Cast::new(source_cryp_id, player_id, final_target_id, skill);
let skill_id = skill.id;
self.stack.push(skill);
return Ok(skill_id);
}
fn player_ready(&mut self, player_id: Uuid) -> Result<&mut Game, Error> {
self.player_by_id(player_id)?
.set_ready(true);
Ok(self)
}
fn skill_phase_finished(&self) -> bool {
self.teams.iter().all(|t| t.ready)
// self.teams.iter()
// // for every team
self.players.iter().all(|t| t.ready)
// self.players.iter()
// // for every player
// .all(|t| self.stack.iter()
// // the number of skills they have cast
// .filter(|s| s.source_team_id == t.id).collect::<Vec<&Cast>>()
// .filter(|s| s.source_player_id == t.id).collect::<Vec<&Cast>>()
// // should equal the number required this turn
// .len() == t.skills_required()
// )
@@ -398,7 +358,7 @@ impl Game {
}
fn cryp_aoe_targets(&self, cryp_id: Uuid) -> Vec<Uuid> {
self.teams.iter()
self.players.iter()
.find(|t| t.cryps.iter().any(|c| c.id == cryp_id))
.unwrap()
.cryps
@@ -408,11 +368,11 @@ impl Game {
}
fn get_targets(&self, skill: Skill, source: &Cryp, target_cryp_id: Uuid) -> Vec<Uuid> {
let target_team = self.teams.iter()
let target_player = self.players.iter()
.find(|t| t.cryps.iter().any(|c| c.id == target_cryp_id))
.unwrap();
if let Some(t) = target_team.taunting() {
if let Some(t) = target_player.taunting() {
return vec![t.id];
}
@@ -576,11 +536,11 @@ impl Game {
}
pub fn finished(&self) -> bool {
self.teams.iter().any(|t| t.cryps.iter().all(|c| c.is_ko()))
self.players.iter().any(|t| t.cryps.iter().all(|c| c.is_ko()))
}
pub fn winner(&self) -> Option<&Team> {
self.teams.iter().find(|t| t.cryps.iter().any(|c| !c.is_ko()))
pub fn winner(&self) -> Option<&Player> {
self.players.iter().find(|t| t.cryps.iter().any(|c| !c.is_ko()))
}
fn finish(mut self) -> Game {
@@ -588,7 +548,7 @@ impl Game {
self.log.push(format!("Game finished."));
{
let winner = self.teams.iter().find(|t| t.cryps.iter().any(|c| !c.is_ko()));
let winner = self.players.iter().find(|t| t.cryps.iter().any(|c| !c.is_ko()));
match winner {
Some(w) => self.log.push(format!("Winner: {:}", w.id)),
None => self.log.push(format!("Game was drawn.")),
@@ -603,7 +563,7 @@ impl Game {
}
pub fn upkeep(mut self) -> Game {
// give teams a ready status
// give players a ready status
// on time out if not enough skills selected
// add a warning
// on 3 warnings forfeit
@@ -723,8 +683,8 @@ pub fn game_global_startup(tx: &mut Transaction) -> Result<(), Error> {
let mut game = Game::new();
game
.set_team_num(2)
.set_team_size(3)
.set_player_num(2)
.set_player_cryps(3)
.set_mode(GameMode::Pvp);
game_write(tx, &game)?;
@@ -843,7 +803,7 @@ pub fn game_skill(params: GameSkillParams, tx: &mut Transaction, account: &Accou
pub fn game_ready(params: GameSkillParams, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {
let mut game = game_get(tx, params.game_id)?;
game.player_ready(account.id, params.cryp_id, params.target_cryp_id, params.skill)?;
game.player_ready(account.id)?;
if game.skill_phase_finished() {
game = game.resolve_phase_start();
@@ -865,7 +825,7 @@ pub fn game_ready(params: GameSkillParams, tx: &mut Transaction, account: &Accou
// .collect::<Result<Vec<Cryp>, Error>>()?;
// if cryps.len() > 3 {
// return Err(err_msg("team size too large (3 max)"));
// return Err(err_msg("player size too large (3 max)"));
// }
// // create the game
@@ -873,22 +833,22 @@ pub fn game_ready(params: GameSkillParams, tx: &mut Transaction, account: &Accou
// // let game_id = game.id;
// game;
// .set_team_num(2)
// .set_team_size(cryps.len())
// .set_player_num(2)
// .set_player_cryps(cryps.len())
// .set_mode(mode);
// // create the mob team
// let mob_team = generate_mob_team(mode, &cryps);
// // create the mob player
// let mob_player = generate_mob_player(mode, &cryps);
// // add the players
// let mut plr_team = Team::new(account.id);
// plr_team
// let mut plr_player = Player::new(account.id);
// plr_player
// .set_cryps(cryps);
// game
// .team_add(plr_team)?
// .team_add(mob_team)?;
// .player_add(plr_player)?
// .player_add(mob_player)?;
// game.start();
@@ -910,16 +870,14 @@ pub fn game_instance_new(tx: &mut Transaction, players: Vec<Player>, game_id: Uu
game.id = game_id;
game
.set_team_num(2)
.set_team_size(3)
.set_player_num(2)
.set_player_cryps(3)
.set_instance(instance_id)
.set_mode(GameMode::Pvp);
// create the initiators team
// create the initiators player
for player in players {
let mut team = Team::new(player.id);
team.set_cryps(player.cryps);
game.team_add(team)?;
game.player_add(player)?;
}
if game.can_start() {
@@ -935,9 +893,7 @@ pub fn game_instance_new(tx: &mut Transaction, players: Vec<Player>, game_id: Uu
pub fn game_instance_join(tx: &mut Transaction, player: Player, game_id: Uuid) -> Result<Game, Error> {
let mut game = game_get(tx, game_id)?;
let mut team = Team::new(player.id);
team.set_cryps(player.cryps);
game.team_add(team)?;
game.player_add(player)?;
if game.can_start() {
game = game.start();
@@ -983,24 +939,20 @@ mod tests {
let mut game = Game::new();
game
.set_team_num(2)
.set_team_size(1);
.set_player_num(2)
.set_player_cryps(1);
let x_team_id = Uuid::new_v4();
x.account = x_team_id;
let mut x_team = Team::new(x_team_id);
x_team
.set_cryps(vec![x]);
let x_player_id = Uuid::new_v4();
x.account = x_player_id;
let mut x_player = Player::new(x_player_id, &"ntr".to_string(), vec![x]);
let y_team_id = Uuid::new_v4();
y.account = y_team_id;
let mut y_team = Team::new(y_team_id);
y_team
.set_cryps(vec![y]);
let y_player_id = Uuid::new_v4();
y.account = y_player_id;
let mut y_player = Player::new(y_player_id, &"mash".to_string(), vec![y]);
game
.team_add(x_team).unwrap()
.team_add(y_team).unwrap();
.player_add(x_player).unwrap()
.player_add(y_player).unwrap();
assert!(game.can_start());
@@ -1031,26 +983,22 @@ mod tests {
let mut game = Game::new();
game
.set_team_num(2)
.set_team_size(2);
.set_player_num(2)
.set_player_cryps(2);
let i_team_id = Uuid::new_v4();
i.account = i_team_id;
j.account = i_team_id;
let mut i_team = Team::new(i_team_id);
i_team
.set_cryps(vec![i,j]);
let i_player_id = Uuid::new_v4();
i.account = i_player_id;
j.account = i_player_id;
let mut i_player = Player::new(i_player_id, &"ntr".to_string(), vec![i, j]);
let x_team_id = Uuid::new_v4();
x.account = x_team_id;
y.account = x_team_id;
let mut x_team = Team::new(x_team_id);
x_team
.set_cryps(vec![x,y]);
let x_player_id = Uuid::new_v4();
x.account = x_player_id;
y.account = x_player_id;
let mut x_player = Player::new(x_player_id, &"mashy".to_string(), vec![x, y]);
game
.team_add(i_team).unwrap()
.team_add(x_team).unwrap();
.player_add(i_player).unwrap()
.player_add(x_player).unwrap();
assert!(game.can_start());
@@ -1061,14 +1009,14 @@ mod tests {
fn phase_test() {
let mut game = create_test_game();
let x_team = game.teams[0].clone();
let y_team = game.teams[1].clone();
let x_player = game.players[0].clone();
let y_player = game.players[1].clone();
let x_cryp = x_team.cryps[0].clone();
let y_cryp = y_team.cryps[0].clone();
let x_cryp = x_player.cryps[0].clone();
let y_cryp = y_player.cryps[0].clone();
game.add_skill(x_team.id, x_cryp.id, Some(y_cryp.id), Skill::Attack).unwrap();
game.add_skill(y_team.id, y_cryp.id, Some(x_cryp.id), Skill::Attack).unwrap();
game.add_skill(x_player.id, x_cryp.id, Some(y_cryp.id), Skill::Attack).unwrap();
game.add_skill(y_player.id, y_cryp.id, Some(x_cryp.id), Skill::Attack).unwrap();
assert!(game.skill_phase_finished());
@@ -1083,14 +1031,14 @@ mod tests {
fn stun_test() {
let mut game = create_test_game();
let x_team = game.teams[0].clone();
let y_team = game.teams[1].clone();
let x_player = game.players[0].clone();
let y_player = game.players[1].clone();
let x_cryp = x_team.cryps[0].clone();
let y_cryp = y_team.cryps[0].clone();
let x_cryp = x_player.cryps[0].clone();
let y_cryp = y_player.cryps[0].clone();
let _x_stun_id = game.add_skill(x_team.id, x_cryp.id, Some(y_cryp.id), Skill::TestStun).unwrap();
game.add_skill(y_team.id, y_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
let _x_stun_id = game.add_skill(x_player.id, x_cryp.id, Some(y_cryp.id), Skill::TestStun).unwrap();
game.add_skill(y_player.id, y_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
assert!(game.skill_phase_finished());
game = game.resolve_phase_start();
@@ -1098,34 +1046,34 @@ mod tests {
// should auto progress back to skill phase
assert!(game.phase == Phase::Skill);
// assert!(game.team_by_id(y_team.id).cryps[0].is_stunned());
// assert!(game.team_by_id(y_team.id).skills_required() == 0);
// assert!(game.player_by_id(y_player.id).cryps[0].is_stunned());
// assert!(game.player_by_id(y_player.id).skills_required() == 0);
}
#[test]
fn ko_resolution_test() {
let mut game = create_test_game();
let x_team = game.teams[0].clone();
let y_team = game.teams[1].clone();
let x_player = game.players[0].clone();
let y_player = game.players[1].clone();
let x_cryp = x_team.cryps[0].clone();
let y_cryp = y_team.cryps[0].clone();
let x_cryp = x_player.cryps[0].clone();
let y_cryp = y_player.cryps[0].clone();
game.team_by_id(y_team.id).cryp_by_id(y_cryp.id).unwrap().red_damage.force(u64::max_value());
game.team_by_id(y_team.id).cryp_by_id(y_cryp.id).unwrap().speed.force(u64::max_value());
game.player_by_id(y_player.id).unwrap().cryp_by_id(y_cryp.id).unwrap().red_damage.force(u64::max_value());
game.player_by_id(y_player.id).unwrap().cryp_by_id(y_cryp.id).unwrap().speed.force(u64::max_value());
// just in case
// remove all mitigation
game.team_by_id(x_team.id).cryp_by_id(x_cryp.id).unwrap().red_life.force(0);
game.player_by_id(x_player.id).unwrap().cryp_by_id(x_cryp.id).unwrap().red_life.force(0);
let _x_stun_id = game.add_skill(x_team.id, x_cryp.id, Some(y_cryp.id), Skill::TestStun).unwrap();
game.add_skill(y_team.id, y_cryp.id, Some(x_cryp.id), Skill::Attack).unwrap();
let _x_stun_id = game.add_skill(x_player.id, x_cryp.id, Some(y_cryp.id), Skill::TestStun).unwrap();
game.add_skill(y_player.id, y_cryp.id, Some(x_cryp.id), Skill::Attack).unwrap();
assert!(game.skill_phase_finished());
game = game.resolve_phase_start();
assert!(!game.team_by_id(y_team.id).cryps[0].is_stunned());
assert!(!game.player_by_id(y_player.id).unwrap().cryps[0].is_stunned());
assert!(game.phase == Phase::Finish);
}
@@ -1133,71 +1081,71 @@ mod tests {
fn cooldown_test() {
let mut game = create_test_game();
let x_team = game.teams[0].clone();
let y_team = game.teams[1].clone();
let x_player = game.players[0].clone();
let y_player = game.players[1].clone();
let x_cryp = x_team.cryps[0].clone();
let y_cryp = y_team.cryps[0].clone();
let x_cryp = x_player.cryps[0].clone();
let y_cryp = y_player.cryps[0].clone();
// should auto progress back to skill phase
assert!(game.phase == Phase::Skill);
assert!(game.team_by_id(y_team.id).cryps[0].skill_on_cd(Skill::Block).is_none());
assert!(game.team_by_id(y_team.id).cryps[0].skill_on_cd(Skill::Stun).is_some());
assert!(game.team_by_id(x_team.id).cryps[0].skill_on_cd(Skill::Block).is_none());
assert!(game.player_by_id(y_player.id).unwrap().cryps[0].skill_on_cd(Skill::Block).is_none());
assert!(game.player_by_id(y_player.id).unwrap().cryps[0].skill_on_cd(Skill::Stun).is_some());
assert!(game.player_by_id(x_player.id).unwrap().cryps[0].skill_on_cd(Skill::Block).is_none());
let _x_stun_id = game.add_skill(x_team.id, x_cryp.id, Some(y_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(y_team.id, y_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
let _x_stun_id = game.add_skill(x_player.id, x_cryp.id, Some(y_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(y_player.id, y_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game = game.resolve_phase_start();
// should auto progress back to skill phase
assert!(game.phase == Phase::Skill);
assert!(game.team_by_id(y_team.id).cryps[0].skill_on_cd(Skill::Stun).is_none());
assert!(game.player_by_id(y_player.id).unwrap().cryps[0].skill_on_cd(Skill::Stun).is_none());
// second round
// now we block and it should go back on cd
let _x_block_id = game.add_skill(x_team.id, x_cryp.id, Some(y_cryp.id), Skill::Stun).unwrap();
let _y_touch_id = game.add_skill(y_team.id, y_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
let _x_block_id = game.add_skill(x_player.id, x_cryp.id, Some(y_cryp.id), Skill::Stun).unwrap();
let _y_touch_id = game.add_skill(y_player.id, y_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game = game.resolve_phase_start();
assert!(game.team_by_id(x_team.id).cryps[0].skill_on_cd(Skill::Stun).is_some());
assert!(game.team_by_id(y_team.id).cryps[0].skill_on_cd(Skill::Block).is_none());
assert!(game.player_by_id(x_player.id).unwrap().cryps[0].skill_on_cd(Skill::Stun).is_some());
assert!(game.player_by_id(y_player.id).unwrap().cryps[0].skill_on_cd(Skill::Block).is_none());
}
#[test]
fn parry_test() {
let mut game = create_test_game();
let x_team = game.teams[0].clone();
let y_team = game.teams[1].clone();
let x_player = game.players[0].clone();
let y_player = game.players[1].clone();
let x_cryp = x_team.cryps[0].clone();
let y_cryp = y_team.cryps[0].clone();
let x_cryp = x_player.cryps[0].clone();
let y_cryp = y_player.cryps[0].clone();
let _x_block_id = game.add_skill(x_team.id, x_cryp.id, None, Skill::TestParry).unwrap();
game.add_skill(y_team.id, y_cryp.id, Some(x_cryp.id), Skill::TestStun).unwrap();
let _x_block_id = game.add_skill(x_player.id, x_cryp.id, None, Skill::TestParry).unwrap();
game.add_skill(y_player.id, y_cryp.id, Some(x_cryp.id), Skill::TestStun).unwrap();
game = game.resolve_phase_start();
// should not be stunned because of parry
assert!(game.team_by_id(x_team.id).cryps[0].is_stunned() == false);
assert!(game.player_by_id(x_player.id).unwrap().cryps[0].is_stunned() == false);
// riposte
assert!(game.team_by_id(y_team.id).cryps[0].green_life() == 768);
assert!(game.player_by_id(y_player.id).unwrap().cryps[0].green_life() == 768);
}
#[test]
fn aoe_test() {
let mut game = create_2v2_test_game();
let i_team = game.teams[0].clone();
let x_team = game.teams[1].clone();
let i_player = game.players[0].clone();
let x_player = game.players[1].clone();
let i_cryp = i_team.cryps[0].clone();
let j_cryp = i_team.cryps[1].clone();
let x_cryp = x_team.cryps[0].clone();
let y_cryp = x_team.cryps[1].clone();
let i_cryp = i_player.cryps[0].clone();
let j_cryp = i_player.cryps[1].clone();
let x_cryp = x_player.cryps[0].clone();
let y_cryp = x_player.cryps[1].clone();
game.cryp_by_id(x_cryp.id).unwrap().learn_mut(Skill::Ruin);
@@ -1205,10 +1153,10 @@ mod tests {
game.cryp_by_id(x_cryp.id).unwrap().reduce_cooldowns();
}
game.add_skill(i_team.id, i_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(i_team.id, j_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(x_team.id, x_cryp.id, Some(i_cryp.id), Skill::Ruin).unwrap();
game.add_skill(x_team.id, y_cryp.id, Some(i_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(i_player.id, i_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(i_player.id, j_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(x_player.id, x_cryp.id, Some(i_cryp.id), Skill::Ruin).unwrap();
game.add_skill(x_player.id, y_cryp.id, Some(i_cryp.id), Skill::TestTouch).unwrap();
assert!(game.skill_phase_finished());
game = game.resolve_phase_start();
@@ -1238,13 +1186,13 @@ mod tests {
fn taunt_test() {
let mut game = create_2v2_test_game();
let i_team = game.teams[0].clone();
let x_team = game.teams[1].clone();
let i_player = game.players[0].clone();
let x_player = game.players[1].clone();
let i_cryp = i_team.cryps[0].clone();
let j_cryp = i_team.cryps[1].clone();
let x_cryp = x_team.cryps[0].clone();
let y_cryp = x_team.cryps[1].clone();
let i_cryp = i_player.cryps[0].clone();
let j_cryp = i_player.cryps[1].clone();
let x_cryp = x_player.cryps[0].clone();
let y_cryp = x_player.cryps[1].clone();
game.cryp_by_id(x_cryp.id).unwrap().learn_mut(Skill::Taunt);
@@ -1252,10 +1200,10 @@ mod tests {
game.cryp_by_id(x_cryp.id).unwrap().reduce_cooldowns();
}
game.add_skill(i_team.id, i_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(i_team.id, j_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(x_team.id, x_cryp.id, Some(i_cryp.id), Skill::Taunt).unwrap();
game.add_skill(x_team.id, y_cryp.id, Some(i_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(i_player.id, i_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(i_player.id, j_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(x_player.id, x_cryp.id, Some(i_cryp.id), Skill::Taunt).unwrap();
game.add_skill(x_player.id, y_cryp.id, Some(i_cryp.id), Skill::TestTouch).unwrap();
assert!(game.skill_phase_finished());
game = game.resolve_phase_start();
@@ -1273,18 +1221,18 @@ mod tests {
fn ko_pve_test() {
let mut game = create_2v2_test_game();
let i_team = game.teams[0].clone();
let x_team = game.teams[1].clone();
let i_player = game.players[0].clone();
let x_player = game.players[1].clone();
let i_cryp = i_team.cryps[0].clone();
let j_cryp = i_team.cryps[1].clone();
let x_cryp = x_team.cryps[0].clone();
let y_cryp = x_team.cryps[1].clone();
let i_cryp = i_player.cryps[0].clone();
let j_cryp = i_player.cryps[1].clone();
let x_cryp = x_player.cryps[0].clone();
let y_cryp = x_player.cryps[1].clone();
game.add_skill(i_team.id, i_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(i_team.id, j_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(x_team.id, x_cryp.id, Some(i_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(x_team.id, y_cryp.id, Some(i_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(i_player.id, i_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(i_player.id, j_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(x_player.id, x_cryp.id, Some(i_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(x_player.id, y_cryp.id, Some(i_cryp.id), Skill::TestTouch).unwrap();
assert!(game.skill_phase_finished());
game = game.resolve_phase_start();
@@ -1292,22 +1240,22 @@ mod tests {
assert!([Phase::Skill, Phase::Finish].contains(&game.phase));
// kill a cryp
game.team_by_id(i_team.id).cryp_by_id(i_cryp.id).unwrap().green_life.reduce(u64::max_value());
game.player_by_id(i_player.id).unwrap().cryp_by_id(i_cryp.id).unwrap().green_life.reduce(u64::max_value());
assert!(game.team_by_id(i_team.id).skills_required() == 1);
assert!(game.team_by_id(x_team.id).skills_required() == 2);
assert!(game.player_by_id(i_player.id).unwrap().skills_required() == 1);
assert!(game.player_by_id(x_player.id).unwrap().skills_required() == 2);
// add some more skills
game.add_skill(i_team.id, j_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(x_team.id, x_cryp.id, Some(j_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(x_team.id, y_cryp.id, Some(j_cryp.id), Skill::TestTouch).unwrap();
assert!(game.add_skill(x_team.id, x_cryp.id, Some(i_cryp.id), Skill::TestTouch).is_err());
game.add_skill(i_player.id, j_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(x_player.id, x_cryp.id, Some(j_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(x_player.id, y_cryp.id, Some(j_cryp.id), Skill::TestTouch).unwrap();
assert!(game.add_skill(x_player.id, x_cryp.id, Some(i_cryp.id), Skill::TestTouch).is_err());
assert!(game.skill_phase_finished());
game = game.resolve_phase_start();
assert!(game.team_by_id(i_team.id).skills_required() == 1);
assert!(game.team_by_id(x_team.id).skills_required() == 2);
assert!(game.player_by_id(i_player.id).unwrap().skills_required() == 1);
assert!(game.player_by_id(x_player.id).unwrap().skills_required() == 2);
return;
}
server/src/instance.rs
+29 -46
View File
@@ -11,10 +11,10 @@ use std::iter;
use rpc::{InstanceLobbyParams, InstanceJoinParams, InstanceReadyParams, InstanceStateParams};
use account::Account;
use player::{Player, Score, player_create, player_get, player_update};
use player::{Player, player_create, player_get, player_global_update};
use cryp::{Cryp, cryp_get};
use mob::{instance_mobs};
use game::{Game, Phase, Team, game_get, game_write, game_instance_new, game_instance_join, game_global_get, game_global_set};
use game::{Game, Phase, game_get, game_write, game_instance_new, game_instance_join, game_global_get, game_global_set};
use vbox::{Var};
use rpc::{RpcResult};
use names::{name};
@@ -99,7 +99,7 @@ impl Instance {
self.players = iter::repeat_with(|| {
let bot_id = Uuid::new_v4();
let cryps = instance_mobs(bot_id);
let mut p = Player::new(bot_id, self.id, &name(), cryps).set_bot(true);
let mut p = Player::new(bot_id, &name(), cryps).set_bot(true);
p.set_ready(true);
p
})
@@ -180,21 +180,13 @@ impl Instance {
let mut game = Game::new();
game.id = current_round.game_id;
game
.set_team_num(2)
.set_team_size(3)
.set_player_num(2)
.set_player_cryps(3)
.set_instance(self.id);
// add the players
let mut plr_team = Team::new(plr.id);
plr_team.set_cryps(plr.cryps);
let mut bot_team = Team::new(bot.id);
bot_team.set_cryps(bot.cryps);
bot_team.set_bot();
game
.team_add(plr_team)?
.team_add(bot_team)?;
.player_add(plr)?
.player_add(bot)?;
game = game.start();
@@ -240,9 +232,9 @@ impl Instance {
let winner = game.winner().ok_or(err_msg("game not finished"))?;
for team in game.teams.iter() {
let mut player = self.account_player(team.id)?;
match team.id == winner.id {
for player in game.players.iter() {
let mut player = self.account_player(player.id)?;
match player.id == winner.id {
true => player.add_win(),
false => player.add_loss(),
};
@@ -293,21 +285,12 @@ impl Instance {
let mut game = Game::new();
game
.set_team_num(2)
.set_team_size(3);
// add the players
let mut a_team = Team::new(a.id);
a_team.set_cryps(a.cryps);
a_team.set_bot();
let mut b_team = Team::new(b.id);
b_team.set_cryps(b.cryps);
b_team.set_bot();
.set_player_num(2)
.set_player_cryps(3);
game
.team_add(a_team).unwrap()
.team_add(b_team).unwrap();
.player_add(a).unwrap()
.player_add(b).unwrap();
game = game.start();
@@ -319,9 +302,9 @@ impl Instance {
round.finished = true;
for team in game.teams.iter() {
let mut player = self.players.iter_mut().find(|p| p.id == team.id).unwrap();
match team.id == winner.id {
for player in game.players.iter() {
let mut player = self.players.iter_mut().find(|p| p.id == player.id).unwrap();
match player.id == winner.id {
true => player.add_win(),
false => player.add_loss(),
};
@@ -611,10 +594,10 @@ pub fn instance_join(params: InstanceJoinParams, tx: &mut Transaction, account:
.collect::<Result<Vec<Cryp>, Error>>()?;
if cryps.len() != 3 {
return Err(format_err!("incorrect team size. ({:})", 3));
return Err(format_err!("incorrect player size. ({:})", 3));
}
let player = player_create(tx, Player::new(account.id, instance.id, &account.name, cryps), account)?;
let player = player_create(tx, Player::new(account.id, &account.name, cryps), instance.id, account)?;
instance.add_player(player)?;
@@ -667,8 +650,8 @@ pub fn instance_ready(params: InstanceReadyParams, tx: &mut Transaction, account
let a = instance.account_player(account.id)?.clone();
let b = instance.account_player(opponent_id)?.clone();
let teams = vec![a, b];
game_instance_new(tx, teams, game_id, instance.id)?
let players = vec![a, b];
game_instance_new(tx, players, game_id, instance.id)?
}
};
}
@@ -694,14 +677,14 @@ pub fn instance_state(params: InstanceStateParams, tx: &mut Transaction, account
pub fn global_game_finished(tx: &mut Transaction, game: &Game) -> Result<(), Error> {
let winner = game.winner().ok_or(err_msg("game not finished"))?;
for team in game.teams.iter() {
let mut player = player_get(tx, team.id, Uuid::nil())?;
match team.id == winner.id {
for player in game.players.iter() {
let mut player = player_get(tx, player.id, Uuid::nil())?;
match player.id == winner.id {
true => player.add_win(),
false => player.add_loss(),
};
player.vbox.fill();
player_update(tx, player, true)?;
player_global_update(tx, player, true)?;
}
Ok(())
@@ -729,7 +712,7 @@ mod tests {
let player_account = Uuid::new_v4();
let cryps = instance_mobs(player_account);
let player = Player::new(player_account, instance.id, &"test".to_string(), cryps).set_bot(true);
let player = Player::new(player_account, &"test".to_string(), cryps).set_bot(true);
let player_id = player.id;
instance.add_player(player).expect("could not add player");
@@ -759,7 +742,7 @@ mod tests {
let instance = Instance::new();
let player_account = Uuid::new_v4();
let cryps = instance_mobs(player_account);
let _player = Player::new(player_account, instance.id, &"test".to_string(), cryps).set_bot(true);
let _player = Player::new(player_account, &"test".to_string(), cryps).set_bot(true);
}
#[test]
@@ -772,7 +755,7 @@ mod tests {
let player_account = Uuid::new_v4();
let cryps = instance_mobs(player_account);
let player = Player::new(player_account, instance.id, &"a".to_string(), cryps);
let player = Player::new(player_account, &"a".to_string(), cryps);
let a_id = player.id;
instance.add_player(player).expect("could not add player");
@@ -780,7 +763,7 @@ mod tests {
let player_account = Uuid::new_v4();
let cryps = instance_mobs(player_account);
let player = Player::new(player_account, instance.id, &"b".to_string(), cryps);
let player = Player::new(player_account, &"b".to_string(), cryps);
let b_id = player.id;
instance.add_player(player).expect("could not add player");
server/src/mob.rs
+10 -10
View File
@@ -21,19 +21,19 @@ pub fn generate_mob() -> Cryp {
return mob;
}
// fn quick_game(team_size: usize) -> Vec<Cryp> {
// fn quick_game(player_size: usize) -> Vec<Cryp> {
// iter::repeat_with(||
// generate_mob()
// .set_account(Uuid::nil())
// .learn(Skill::Attack))
// .take(team_size)
// .take(player_size)
// .collect::<Vec<Cryp>>()
// }
pub fn instance_mobs(team_id: Uuid) -> Vec<Cryp> {
pub fn instance_mobs(player_id: Uuid) -> Vec<Cryp> {
iter::repeat_with(||
generate_mob()
.set_account(team_id))
.set_account(player_id))
// .learn(Skill::Attack))
.take(3)
.collect::<Vec<Cryp>>()
@@ -104,14 +104,14 @@ pub fn instance_mobs(team_id: Uuid) -> Vec<Cryp> {
// }
// pub fn generate_mob_team(mode: GameMode, cryps: &Vec<Cryp>) -> Team {
// let mut mob_team = Team::new(Uuid::nil());
// pub fn generate_mob_player(mode: GameMode, cryps: &Vec<Cryp>) -> Player {
// let mut mob_player = Player::new(Uuid::nil());
// let cryp_lvl = cryps.iter().max_by_key(|c| c.lvl).unwrap().lvl;
// let team_size = cryps.len();
// let player_size = cryps.len();
// let mobs = match mode {
// GameMode::Normal => quick_game(cryp_lvl, team_size),
// GameMode::Normal => quick_game(cryp_lvl, player_size),
// GameMode::Zone3v2Attack => zone_3v2_attack(cryp_lvl),
// GameMode::Zone2v2Caster => zone_2v2_caster(cryp_lvl),
// GameMode::Zone3v3MeleeMiniboss => zone_3v3_melee_miniboss(cryp_lvl),
@@ -119,8 +119,8 @@ pub fn instance_mobs(team_id: Uuid) -> Vec<Cryp> {
// _ => panic!("{:?} not handled for pve mobs", mode),
// };
// mob_team.set_cryps(mobs);
// mob_player.set_cryps(mobs);
// return mob_team;
// return mob_player;
// }
server/src/player.rs
+44 -27
View File
@@ -13,6 +13,7 @@ use cryp::{Cryp, Colours, cryp_get};
use vbox::{Vbox, Var, VarEffect};
use rpc::{PlayerCrypsSetParams};
use instance::{Instance, instance_get, instance_update};
use skill::{Effect};
const DISCARD_COST: u16 = 5;
@@ -25,7 +26,6 @@ pub struct Score {
#[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Player {
pub id: Uuid,
pub instance: Uuid,
pub name: String,
pub vbox: Vbox,
pub score: Score,
@@ -35,12 +35,11 @@ pub struct Player {
}
impl Player {
pub fn new(account: Uuid, instance: Uuid, name: &String, cryps: Vec<Cryp>) -> Player {
pub fn new(account: Uuid, name: &String, cryps: Vec<Cryp>) -> Player {
Player {
id: account,
instance,
name: name.clone(),
vbox: Vbox::new(account, instance),
vbox: Vbox::new(),
score: Score { wins: 0, losses: 0 },
cryps,
bot: false,
@@ -205,8 +204,8 @@ impl Player {
}
// now the var has been applied
// recalculate the stats of the whole team
let team_colours = self.cryps.iter().fold(Colours::new(), |tc, c| {
// recalculate the stats of the whole player
let player_colours = self.cryps.iter().fold(Colours::new(), |tc, c| {
Colours {
red: tc.red + c.colours.red,
green: tc.green + c.colours.green,
@@ -215,7 +214,7 @@ impl Player {
});
for cryp in self.cryps.iter_mut() {
cryp.apply_modifiers(&team_colours);
cryp.apply_modifiers(&player_colours);
}
Ok(self)
@@ -241,8 +240,8 @@ impl Player {
}
// now the var has been applied
// recalculate the stats of the whole team
let team_colours = self.cryps.iter().fold(Colours::new(), |tc, c| {
// recalculate the stats of the whole player
let player_colours = self.cryps.iter().fold(Colours::new(), |tc, c| {
Colours {
red: tc.red + c.colours.red,
green: tc.green + c.colours.green,
@@ -251,7 +250,7 @@ impl Player {
});
for cryp in self.cryps.iter_mut() {
cryp.apply_modifiers(&team_colours);
cryp.apply_modifiers(&player_colours);
}
self.vbox.bound.push(target);
@@ -259,6 +258,32 @@ impl Player {
Ok(self)
}
// GAME METHODS
pub fn skills_required(&self) -> usize {
let required = self.cryps.iter()
.filter(|c| !c.is_ko())
.filter(|c| c.available_skills().len() > 0)
.collect::<Vec<&Cryp>>().len();
// println!("{:} requires {:} skills this turn", self.id, required);
return required;
}
pub fn taunting(&self) -> Option<&Cryp> {
self.cryps.iter()
.find(|c| c.affected(Effect::Taunt))
}
pub fn set_cryps(&mut self, mut cryps: Vec<Cryp>) -> &mut Player {
cryps.sort_unstable_by_key(|c| c.id);
self.cryps = cryps;
self
}
pub fn cryp_by_id(&mut self, id: Uuid) -> Option<&mut Cryp> {
self.cryps.iter_mut().find(|c| c.id == id)
}
}
pub fn player_get(tx: &mut Transaction, account_id: Uuid, instance_id: Uuid) -> Result<Player, Error> {
@@ -285,7 +310,7 @@ pub fn player_get(tx: &mut Transaction, account_id: Uuid, instance_id: Uuid) ->
return Ok(data);
}
pub fn player_create(tx: &mut Transaction, player: Player, account: &Account) -> Result<Player, Error> {
pub fn player_create(tx: &mut Transaction, player: Player, instance: Uuid, account: &Account) -> Result<Player, Error> {
let player_bytes = to_vec(&player)?;
let query = "
@@ -295,27 +320,19 @@ pub fn player_create(tx: &mut Transaction, player: Player, account: &Account) ->
";
let result = tx
.query(query, &[&Uuid::new_v4(), &player.instance, &account.id, &player_bytes])?;
.query(query, &[&Uuid::new_v4(), &instance, &account.id, &player_bytes])?;
let _returned = result.iter().next().expect("no row written");
println!("wrote player {:} joined instance: {:}", account.name, player.instance);
println!("wrote player {:} joined instance: {:}", account.name, instance);
return Ok(player);
}
pub fn player_update(tx: &mut Transaction, mut player: Player, ignore_phase: bool) -> Result<Player, Error> {
pub fn player_global_update(tx: &mut Transaction, mut player: Player, ignore_phase: bool) -> Result<Player, Error> {
// sort vbox for niceness
player.vbox.bound.sort_unstable();
// update the instance this player is associated with
// if not a global player
if player.instance != Uuid::nil() {
let instance = instance_get(tx, player.instance)?
.player_update(player.clone(), ignore_phase)?;
instance_update(tx, instance)?;
}
let bytes = to_vec(&player)?;
let query = "
@@ -354,7 +371,7 @@ pub fn player_delete(tx: &mut Transaction, id: Uuid) -> Result<(), Error> {
pub fn player_mm_cryps_set(params: PlayerCrypsSetParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
if params.cryp_ids.len() != 3 {
return Err(err_msg("team size is 3"));
return Err(err_msg("player size is 3"));
}
let cryps = params.cryp_ids
@@ -365,11 +382,11 @@ pub fn player_mm_cryps_set(params: PlayerCrypsSetParams, tx: &mut Transaction, a
let player = match player_get(tx, account.id, Uuid::nil()) {
Ok(mut p) => {
p.cryps = cryps;
p.vbox = Vbox::new(account.id, Uuid::nil());
player_update(tx, p, false)?
p.vbox = Vbox::new();
player_global_update(tx, p, false)?
},
Err(_) => {
player_create(tx, Player::new(account.id, Uuid::nil(), &account.name, cryps), &account)?
player_create(tx, Player::new(account.id, &account.name, cryps), Uuid::nil(), &account)?
}
};
@@ -386,7 +403,7 @@ mod tests {
fn player_bot_vbox_test() {
let player_account = Uuid::new_v4();
let cryps = instance_mobs(player_account);
let mut player = Player::new(player_account, Uuid::new_v4(), &"test".to_string(), cryps).set_bot(true);
let mut player = Player::new(player_account, &"test".to_string(), cryps).set_bot(true);
player.vbox.fill();
player.autobuy();
server/src/skill.rs
+3 -3
View File
@@ -125,7 +125,7 @@ pub fn resolve(skill: Skill, source: &mut Cryp, target: &mut Cryp, mut resolutio
#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
pub struct Cast {
pub id: Uuid,
pub source_team_id: Uuid,
pub source_player_id: Uuid,
pub source_cryp_id: Uuid,
pub target_cryp_id: Uuid,
pub skill: Skill,
@@ -134,11 +134,11 @@ pub struct Cast {
}
impl Cast {
pub fn new(source_cryp_id: Uuid, source_team_id: Uuid, target_cryp_id: Uuid, skill: Skill) -> Cast {
pub fn new(source_cryp_id: Uuid, source_player_id: Uuid, target_cryp_id: Uuid, skill: Skill) -> Cast {
return Cast {
id: Uuid::new_v4(),
source_cryp_id,
source_team_id,
source_player_id,
target_cryp_id,
skill,
speed: 0,
server/src/spec.rs
+61 -61
View File
@@ -68,94 +68,94 @@ impl Spec {
}
}
pub fn apply(&self, modified: u64, base: u64, team_colours: &Colours) -> u64 {
pub fn apply(&self, modified: u64, base: u64, player_colours: &Colours) -> u64 {
match *self {
// Upgrades to Damage Spec
Spec::Damage => modified + base.pct(5),
Spec::RedDamageI => modified + {
let mut pct = 10;
if team_colours.red >= 5 { pct += 10 };
if team_colours.red >= 10 { pct += 20 };
if team_colours.red >= 20 { pct += 40 };
if player_colours.red >= 5 { pct += 10 };
if player_colours.red >= 10 { pct += 20 };
if player_colours.red >= 20 { pct += 40 };
base.pct(pct)
},
Spec::GreenDamageI => modified + {
let mut pct = 10;
if team_colours.green >= 5 { pct += 10 };
if team_colours.green >= 10 { pct += 20 };
if team_colours.green >= 20 { pct += 40 };
if player_colours.green >= 5 { pct += 10 };
if player_colours.green >= 10 { pct += 20 };
if player_colours.green >= 20 { pct += 40 };
base.pct(pct)
},
Spec::BlueDamageI => modified + {
let mut pct = 10;
if team_colours.blue >= 5 { pct += 10 };
if team_colours.blue >= 10 { pct += 20 };
if team_colours.blue >= 20 { pct += 40 };
if player_colours.blue >= 5 { pct += 10 };
if player_colours.blue >= 10 { pct += 20 };
if player_colours.blue >= 20 { pct += 40 };
base.pct(pct)
},
Spec::GRDI => modified + {
let mut pct = 5;
if team_colours.green >= 2 && team_colours.red >= 2 { pct += 10 };
if team_colours.green >= 5 && team_colours.red >= 5 { pct += 15 };
if team_colours.green >= 10 && team_colours.red >= 10 { pct += 30 };
if player_colours.green >= 2 && player_colours.red >= 2 { pct += 10 };
if player_colours.green >= 5 && player_colours.red >= 5 { pct += 15 };
if player_colours.green >= 10 && player_colours.red >= 10 { pct += 30 };
base.pct(pct)
},
Spec::GBDI => modified + {
let mut pct = 5;
if team_colours.green >= 2 && team_colours.blue >= 2 { pct += 10 };
if team_colours.green >= 5 && team_colours.blue >= 5 { pct += 15 };
if team_colours.green >= 10 && team_colours.blue >= 10 { pct += 30 };
if player_colours.green >= 2 && player_colours.blue >= 2 { pct += 10 };
if player_colours.green >= 5 && player_colours.blue >= 5 { pct += 15 };
if player_colours.green >= 10 && player_colours.blue >= 10 { pct += 30 };
base.pct(pct)
},
Spec::RBDI => modified + {
let mut pct = 5;
if team_colours.blue >= 2 && team_colours.red >= 2 { pct += 10 };
if team_colours.blue >= 5 && team_colours.red >= 5 { pct += 15 };
if team_colours.blue >= 10 && team_colours.red >= 10 { pct += 30 };
if player_colours.blue >= 2 && player_colours.red >= 2 { pct += 10 };
if player_colours.blue >= 5 && player_colours.red >= 5 { pct += 15 };
if player_colours.blue >= 10 && player_colours.red >= 10 { pct += 30 };
base.pct(pct)
},
// Upgrades to speed Spec
Spec::Speed => modified + base.pct(5),
Spec::RedSpeedI => modified + {
let mut pct = 5;
if team_colours.red >= 5 { pct += 5 };
if team_colours.red >= 10 { pct += 10 };
if team_colours.red >= 20 { pct += 20 };
if player_colours.red >= 5 { pct += 5 };
if player_colours.red >= 10 { pct += 10 };
if player_colours.red >= 20 { pct += 20 };
base.pct(pct)
},
Spec::GreenSpeedI => 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 };
if player_colours.green >= 5 { pct += 5 };
if player_colours.green >= 10 { pct += 10 };
if player_colours.green >= 20 { pct += 20 };
base.pct(pct)
},
Spec::BlueSpeedI => modified + {
let mut pct = 5;
if team_colours.blue >= 5 { pct += 5 };
if team_colours.blue >= 10 { pct += 10 };
if team_colours.blue >= 20 { pct += 20 };
if player_colours.blue >= 5 { pct += 5 };
if player_colours.blue >= 10 { pct += 10 };
if player_colours.blue >= 20 { pct += 20 };
base.pct(pct)
},
Spec::GRSpeedI => modified + {
let mut pct = 5;
if team_colours.green >= 2 && team_colours.red >= 2 { pct += 5 };
if team_colours.green >= 5 && team_colours.red >= 5 { pct += 10 };
if team_colours.green >= 10 && team_colours.red >= 10 { pct += 20 };
if player_colours.green >= 2 && player_colours.red >= 2 { pct += 5 };
if player_colours.green >= 5 && player_colours.red >= 5 { pct += 10 };
if player_colours.green >= 10 && player_colours.red >= 10 { pct += 20 };
base.pct(pct)
},
Spec::GBSpeedI => modified + {
let mut pct = 5;
if team_colours.green >= 2 && team_colours.blue >= 2 { pct += 5 };
if team_colours.green >= 5 && team_colours.blue >= 5 { pct += 10 };
if team_colours.green >= 10 && team_colours.blue >= 10 { pct += 20 };
if player_colours.green >= 2 && player_colours.blue >= 2 { pct += 5 };
if player_colours.green >= 5 && player_colours.blue >= 5 { pct += 10 };
if player_colours.green >= 10 && player_colours.blue >= 10 { pct += 20 };
base.pct(pct)
},
Spec::RBSpeedI => modified + {
let mut pct = 5;
if team_colours.blue >= 2 && team_colours.red >= 2 { pct += 5 };
if team_colours.blue >= 5 && team_colours.red >= 5 { pct += 10 };
if team_colours.blue >= 10 && team_colours.red >= 10 { pct += 20 };
if player_colours.blue >= 2 && player_colours.red >= 2 { pct += 5 };
if player_colours.blue >= 5 && player_colours.red >= 5 { pct += 10 };
if player_colours.blue >= 10 && player_colours.red >= 10 { pct += 20 };
base.pct(pct)
},
@@ -163,45 +163,45 @@ impl Spec {
Spec::Life => modified + base.pct(5),
Spec::GreenLifeI => modified + {
let mut mult: u64 = 15;
if team_colours.green >= 5 { mult += 25 };
if team_colours.green >= 10 { mult += 50 };
if team_colours.green >= 20 { mult += 75 };
mult * team_colours.green as u64
if player_colours.green >= 5 { mult += 25 };
if player_colours.green >= 10 { mult += 50 };
if player_colours.green >= 20 { mult += 75 };
mult * player_colours.green as u64
},
Spec::RedLifeI => modified + {
let mut mult: u64 = 15;
if team_colours.red >= 5 { mult += 25 };
if team_colours.red >= 10 { mult += 50 };
if team_colours.red >= 20 { mult += 75 };
mult * team_colours.red as u64
if player_colours.red >= 5 { mult += 25 };
if player_colours.red >= 10 { mult += 50 };
if player_colours.red >= 20 { mult += 75 };
mult * player_colours.red as u64
},
Spec::BlueLifeI => modified + {
let mut mult: u64 = 15;
if team_colours.blue >= 5 { mult += 25 };
if team_colours.blue >= 10 { mult += 50 };
if team_colours.blue >= 20 { mult += 75 };
mult * team_colours.blue as u64
if player_colours.blue >= 5 { mult += 25 };
if player_colours.blue >= 10 { mult += 50 };
if player_colours.blue >= 20 { mult += 75 };
mult * player_colours.blue as u64
},
Spec::GRLI => modified + {
let mut mult: u64 = 10;
if team_colours.green >= 2 && team_colours.red >= 2 { mult += 10 };
if team_colours.green >= 5 && team_colours.red >= 5 { mult += 25 };
if team_colours.green >= 10 && team_colours.red >= 10 { mult += 50 };
mult * (team_colours.green + team_colours.red) as u64
if player_colours.green >= 2 && player_colours.red >= 2 { mult += 10 };
if player_colours.green >= 5 && player_colours.red >= 5 { mult += 25 };
if player_colours.green >= 10 && player_colours.red >= 10 { mult += 50 };
mult * (player_colours.green + player_colours.red) as u64
},
Spec::GBLI => modified + {
let mut mult: u64 = 10;
if team_colours.green >= 2 && team_colours.red >= 2 { mult += 10 };
if team_colours.green >= 5 && team_colours.red >= 5 { mult += 25 };
if team_colours.green >= 10 && team_colours.red >= 10 { mult += 50 };
mult * (team_colours.green + team_colours.red) as u64
if player_colours.green >= 2 && player_colours.red >= 2 { mult += 10 };
if player_colours.green >= 5 && player_colours.red >= 5 { mult += 25 };
if player_colours.green >= 10 && player_colours.red >= 10 { mult += 50 };
mult * (player_colours.green + player_colours.red) as u64
},
Spec::RBLI => modified + {
let mut mult: u64 = 10;
if team_colours.blue >= 2 && team_colours.red >= 2 { mult += 10 };
if team_colours.blue >= 5 && team_colours.red >= 5 { mult += 25 };
if team_colours.blue >= 10 && team_colours.red >= 10 { mult += 50 };
mult * (team_colours.blue + team_colours.red) as u64
if player_colours.blue >= 2 && player_colours.red >= 2 { mult += 10 };
if player_colours.blue >= 5 && player_colours.red >= 5 { mult += 25 };
if player_colours.blue >= 10 && player_colours.red >= 10 { mult += 50 };
mult * (player_colours.blue + player_colours.red) as u64
},
}
}
server/src/vbox.rs
+3 -10
View File
@@ -15,7 +15,6 @@ use account::Account;
use rpc::{VboxAcceptParams, VboxDiscardParams, VboxCombineParams, VboxApplyParams, VboxReclaimParams, VboxUnequipParams};
use skill::{Skill};
use spec::{Spec};
use player::{Player};
use instance::{Instance, instance_get, instance_update};
use cryp::{Colours};
@@ -397,16 +396,13 @@ fn get_combos() -> Vec<Combo> {
#[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Vbox {
pub id: Uuid,
pub bits: u16,
pub free: Vec<Vec<Var>>,
pub bound: Vec<Var>,
pub instance: Uuid,
pub account: Uuid,
}
impl Vbox {
pub fn new(account_id: Uuid, instance_id: Uuid) -> Vbox {
pub fn new() -> Vbox {
let starting_items = vec![
Var::Attack,
Var::Attack,
@@ -414,9 +410,6 @@ impl Vbox {
];
Vbox {
id: Uuid::new_v4(),
account: account_id,
instance: instance_id,
free: vec![vec![], vec![], vec![]],
bound: starting_items,
bits: 18,
@@ -581,7 +574,7 @@ mod tests {
#[test]
fn combine_test() {
let mut vbox = Vbox::new(Uuid::new_v4(), Uuid::new_v4());
let mut vbox = Vbox::new();
vbox.bound = vec![Var::Attack, Var::Green, Var::Green];
vbox.combine(vec![1,2,0]).unwrap();
assert_eq!(vbox.bound[0], Var::Heal);
@@ -601,7 +594,7 @@ mod tests {
#[test]
fn reclaim_test() {
let mut vbox = Vbox::new(Uuid::new_v4(), Uuid::new_v4());
let mut vbox = Vbox::new();
vbox.bound = vec![Var::Strike];
vbox.reclaim(0).unwrap();
assert_eq!(vbox.bits, 22);