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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server/COMBOS.md
View File

@ -64,7 +64,7 @@ Parry - (Block RR) Avoid all damage for this turn
# Destruction Type (blue) # # Destruction Type (blue) #
Blast - (Attack BB) Deal significant `Blue` damage Blast - (Attack BB) Deal significant `Blue` damage
Ruin - (Stun BB) - AOE stun on the enemy team for remaind of turn Ruin - (Stun BB) - AOE stun on the enemy player for remaind of turn
Amplify - (Buff BB) Increased blue damage dealt by target ally Amplify - (Buff BB) Increased blue damage dealt by target ally
Curse - (Debuff BB) Decrease damage dealt by target enemy Curse - (Debuff BB) Decrease damage dealt by target enemy
Plague Life - (Block BB) Apply dot debuff to attackers Plague Life - (Block BB) Apply dot debuff to attackers

4
server/ECONOMY.md
View File

@ -32,7 +32,7 @@ Base specs have a base 3 cost
Round #1 Round #1
All costs are base costs All costs are base costs
# Team #1 and Team #2 (They both bought the same things) # Player #1 and Player #2 (They both bought the same things)
Cryp #1 Strike (Attack + RR), (2 + 1 + 1) = (4) cost Cryp #1 Strike (Attack + RR), (2 + 1 + 1) = (4) cost
Cryp #1 Empower (Buff + RR), (2 + 1 + 1) = (4) cost Cryp #1 Empower (Buff + RR), (2 + 1 + 1) = (4) cost
Cryp #3 Attack, 2 cost Cryp #3 Attack, 2 cost
@ -51,7 +51,7 @@ The costs of red for round #2 are now (1 + 1) = 2
If they were to buy the same skill setup it would be as follows: If they were to buy the same skill setup it would be as follows:
# Team #1 and Team #2 (They both bought the same things) # Player #1 and Player #2 (They both bought the same things)
Cryp #1 Strike (Attack + RR), (2 + 2 + 2) = (6) cost Cryp #1 Strike (Attack + RR), (2 + 2 + 2) = (6) cost
Cryp #1 Empower (Buff + RR), (2 + 2 + 2) = (6) cost Cryp #1 Empower (Buff + RR), (2 + 2 + 2) = (6) cost
Cryp #3 Attack, 2 cost Cryp #3 Attack, 2 cost

14
server/README.md
View File

@ -4,16 +4,16 @@
skill phase: skill phase:
1.1 -> block (sp 10) -> on self 1.1 -> block (sp 10) -> on self
1.2 -> attack (sp 5) -> on team 2 1.2 -> attack (sp 5) -> on player 2
2.1 -> hex (sp 3) -> on team 1 2.1 -> hex (sp 3) -> on player 1
2.2 -> attack (sp 5) -> on team 1 2.2 -> attack (sp 5) -> on player 1
target phase: target phase:
team 2 targets 1.2 on 2.2 player 2 targets 1.2 on 2.2
team 1 targets 2.1 on 1.1 player 1 targets 2.1 on 1.1
team 1 targets 2.2 on 1.1 player 1 targets 2.2 on 1.1
resolve phase: resolve phase:
1.1 <- block 1.1 <- block
@ -116,7 +116,7 @@ Its members now scour the lands in search of magic, censoring its teaching, purg
* Silence * Silence
* Magic resistance * Magic resistance
* Information gathering * Information gathering
* team composition * player composition
* available skills etc * available skills etc
Universal Chaos Universal Chaos

46
server/SPECS.md
View File

@ -1,10 +1,10 @@
### Specs ### ### Specs ###
Numbers are placeholder Numbers are placeholder
`Specs get a bonus dependent on the total of Red / Green / Blue in team skills & specs` `Specs get a bonus dependent on the total of Red / Green / Blue in player skills & specs`
# Example to meet 5 red gem bonus from skills only # Example to meet 5 red gem bonus from skills only
In your team Cryp #1 has `Strike`, Cryp #2 has `Slay` and `Heal`, Cryp #3 has `Snare` In your player Cryp #1 has `Strike`, Cryp #2 has `Slay` and `Heal`, Cryp #3 has `Snare`
- RR skill `Strike` contributes 2 red gems to the total red gems (2 total) - RR skill `Strike` contributes 2 red gems to the total red gems (2 total)
- RG skill `Slay` contributes 1 red gem to the total red gems (3 total) - RG skill `Slay` contributes 1 red gem to the total red gems (3 total)
- GG skill `Heal` contirubtes 0 red gems to the total red gems (3 total) - GG skill `Heal` contirubtes 0 red gems to the total red gems (3 total)
@ -30,7 +30,7 @@ In your team Cryp #1 has `Strike`, Cryp #2 has `Slay` and `Heal`, Cryp #3 has `S
Cryp #2 -> Give Attack -> Attack Cryp #2 -> Give Attack -> Attack
Cryp #3 -> Give Stun -> Stun Cryp #3 -> Give Stun -> Stun
Team Total (4 Red + 2 Basic gems) Player Total (4 Red + 2 Basic gems)
### Round 2 ### Round 2
@ -87,12 +87,12 @@ In your team Cryp #1 has `Strike`, Cryp #2 has `Slay` and `Heal`, Cryp #3 has `S
# Basic % GreenLife # Basic % GreenLife
`Base` -> 5% inc hp `Base` -> 5% inc hp
`Team Bonus` -> 3 basic gems -> +5% // 6 basic gems -> +10% // 12 basic gems -> +15% `Player Bonus` -> 3 basic gems -> +5% // 6 basic gems -> +10% // 12 basic gems -> +15%
Maximum 35% inc hp Maximum 35% inc hp
# Basic Speed # Basic Speed
`Base` -> 5% inc speed `Base` -> 5% inc speed
`Team Bonus` -> 3 basic gems -> +10% // 6 basic gems -> +15% // 12 basic gems -> +20% `Player Bonus` -> 3 basic gems -> +10% // 6 basic gems -> +15% // 12 basic gems -> +20%
Maximum 50% inc speed Maximum 50% inc speed
# Basic Class Spec # Basic Class Spec
@ -106,37 +106,37 @@ Generate by combining `Generic Spec (Basic Damage)` with respective RGB
# Red Damage (Dmg + RR) # Red Damage (Dmg + RR)
Add 2 `red gems` Add 2 `red gems`
`Base` -> 10% inc red dmg `Base` -> 10% inc red dmg
`Team Bonus` 5 red gems -> +10% // 10 red gems -> +15% // 20 red gems -> +25% `Player Bonus` 5 red gems -> +10% // 10 red gems -> +15% // 20 red gems -> +25%
Maximum +60% red damage Maximum +60% red damage
# Blue Damage (Dmg + BB) # # Blue Damage (Dmg + BB) #
Add 2 `blue gems` Add 2 `blue gems`
`Base` -> 10% inc blue dmg `Base` -> 10% inc blue dmg
`Team Bonus` 5 blue gems -> +10% // 10 blue gems -> +15% // 20 blue gems -> +25% `Player Bonus` 5 blue gems -> +10% // 10 blue gems -> +15% // 20 blue gems -> +25%
Maximum +60% blue damage Maximum +60% blue damage
# Healing (Dmg + GG) # # Healing (Dmg + GG) #
Add 2 `green gems` Add 2 `green gems`
`Base` -> 10% inc healing `Base` -> 10% inc healing
`Team Bonus` 5 green gems -> +10% // 10 green gems -> +15% // 20 green gems -> +25% `Player Bonus` 5 green gems -> +10% // 10 green gems -> +15% // 20 green gems -> +25%
Maximum +60% inc healing Maximum +60% inc healing
# Red damage and healing (Dmg + RG) # Red damage and healing (Dmg + RG)
Add 1 red 1 green gem Add 1 red 1 green gem
`Base` -> 5% inc red damage and 5% inc healing `Base` -> 5% inc red damage and 5% inc healing
`Team Bonus` (2R + 2G gems) -> +5% + 5% // (5R + 5G gems) -> +10% + 10% % // (10R + 10G) gems -> +15% + 15% `Player Bonus` (2R + 2G gems) -> +5% + 5% // (5R + 5G gems) -> +10% + 10% % // (10R + 10G) gems -> +15% + 15%
Maximum +35% inc red damage and 35% inc healing Maximum +35% inc red damage and 35% inc healing
# Red and blue damage (Dmg + RB) # Red and blue damage (Dmg + RB)
Add 1 red and 1 blue gem Add 1 red and 1 blue gem
`Base` -> 5% inc red damage and 5% inc healing `Base` -> 5% inc red damage and 5% inc healing
`Team Bonus` (2 red + 2 green gems) -> +5% + 5% // (5 red + 5 green gems) -> +10% + 10% % // 20 green gems -> +15% + 15% `Player Bonus` (2 red + 2 green gems) -> +5% + 5% // (5 red + 5 green gems) -> +10% + 10% % // 20 green gems -> +15% + 15%
Maximum +35% inc damage and 35% inc healing Maximum +35% inc damage and 35% inc healing
# Blue damage and healing (Dmg + BG) # Blue damage and healing (Dmg + BG)
Add 1 blue and 1 green gem Add 1 blue and 1 green gem
`Base` -> 5% inc blue damage and 5% inc healing `Base` -> 5% inc blue damage and 5% inc healing
`Team Bonus` (2B + 2G gems) -> +5% + 5% // (5B + 5G gems) -> +10% + 10% % // (10B + 10G) gems -> +15% + 15% `Player Bonus` (2B + 2G gems) -> +5% + 5% // (5B + 5G gems) -> +10% + 10% % // (10B + 10G) gems -> +15% + 15%
Maximum +35% inc blue damage and 35% inc healing Maximum +35% inc blue damage and 35% inc healing
### Increased GreenLife Combos ### ### Increased GreenLife Combos ###
@ -146,37 +146,37 @@ Generate by combining `Generic Spec (Basic GreenLife)` with respective RGB
# Increased % Red Life (Basic %HP + 2R) # Increased % Red Life (Basic %HP + 2R)
Add 2 `red gems` Add 2 `red gems`
`Base` -> 10% inc red shield `Base` -> 10% inc red shield
`Team Bonus` 5 red gems -> +10% // 10 red gems -> +15% // 20 red gems -> +20% `Player Bonus` 5 red gems -> +10% // 10 red gems -> +15% // 20 red gems -> +20%
Maximum +55% inc red shield Maximum +55% inc red shield
# Increased % Red Life and GreenLife (Basic %HP + 1R1G) # Increased % Red Life and GreenLife (Basic %HP + 1R1G)
Add 1 red 1 green gem Add 1 red 1 green gem
`Base` -> 5% inc red shield and 5% inc hp `Base` -> 5% inc red shield and 5% inc hp
`Team Bonus` (2R + 2G gems) -> +5% + 5% // (5R + 5G gems) -> +10% + 10% % // (10R + 10G) gems -> +15% + 15% `Player Bonus` (2R + 2G gems) -> +5% + 5% // (5R + 5G gems) -> +10% + 10% % // (10R + 10G) gems -> +15% + 15%
Maximum +35% inc red shield and 35% inc hp Maximum +35% inc red shield and 35% inc hp
# Increased % Blue Life (Basic %HP + 2B) # Increased % Blue Life (Basic %HP + 2B)
Add 2 `blue gems` Add 2 `blue gems`
`Base` -> 10% inc red shield `Base` -> 10% inc red shield
`Team Bonus` 5 blue gems -> +10% // 10 blue gems -> +15% // 20 blue gems -> +20% `Player Bonus` 5 blue gems -> +10% // 10 blue gems -> +15% // 20 blue gems -> +20%
Maximum +55% inc blue shield Maximum +55% inc blue shield
# Increased % Blue Life and GreenLife (Basic %HP + 1B1G) # Increased % Blue Life and GreenLife (Basic %HP + 1B1G)
Add `1 blue and 1 green gems` Add `1 blue and 1 green gems`
`Base` -> 5% inc red shield and 5% inc hp `Base` -> 5% inc red shield and 5% inc hp
`Team Bonus` (2B + 2G gems) -> +5% + 5% // (5B + 5G gems) -> +10% + 10% % // (10B + 10G) gems -> +15% + 15% `Player Bonus` (2B + 2G gems) -> +5% + 5% // (5B + 5G gems) -> +10% + 10% % // (10B + 10G) gems -> +15% + 15%
Maximum +35% inc blue shield and 35% inc hp Maximum +35% inc blue shield and 35% inc hp
# Increased % GreenLife (Basic %HP + 2G) # Increased % GreenLife (Basic %HP + 2G)
Add `2 green gems` Add `2 green gems`
`Base` -> 10% inc hp `Base` -> 10% inc hp
`Team Bonus` 5 green gems -> +10% // 10 green gems -> +15% // 20 green gems -> +20% `Player Bonus` 5 green gems -> +10% // 10 green gems -> +15% // 20 green gems -> +20%
Maximum +55% inc hp Maximum +55% inc hp
# Increased % Blue and Red Life (Basic %HP + 1B1R) # Increased % Blue and Red Life (Basic %HP + 1B1R)
Add `1 blue and 1 red gem` Add `1 blue and 1 red gem`
`Base` -> 5% inc red shield and 5% inc hp `Base` -> 5% inc red shield and 5% inc hp
`Team Bonus` (2B + 2R gems) -> +5% + 5% // (5B + 5R gems) -> +10% + 10% % // (10B + 10R) gems -> +15% + 15% `Player Bonus` (2B + 2R gems) -> +5% + 5% // (5B + 5R gems) -> +10% + 10% % // (10B + 10R) gems -> +15% + 15%
Maximum +35% inc blue shield and 35% inc red shield Maximum +35% inc blue shield and 35% inc red shield
## Upgraded Attack Spec Combos ## Upgraded Attack Spec Combos
@ -185,31 +185,31 @@ Maximum +35% inc blue shield and 35% inc red shield
Cryp Requires `8 red gems` Cryp Requires `8 red gems`
Adds `6 red gems` Adds `6 red gems`
`Base` -> 15% increased strike damage `Base` -> 15% increased strike damage
`Team Bonus` 15 red gems -> +15% // 20 red gems -> +20% // 30 red gems -> +30% `Player Bonus` 15 red gems -> +15% // 20 red gems -> +20% // 30 red gems -> +30%
Maximum 80% increased strike damage Maximum 80% increased strike damage
# Improved Heal (Combine Heal + Healing Spec x 2) # Improved Heal (Combine Heal + Healing Spec x 2)
Cryp Requires `8 green gems` Cryp Requires `8 green gems`
`Base` -> 15% increased heal healing `Base` -> 15% increased heal healing
`Team Bonus` 15 green gems -> +15% // 20 green gems -> +20% // 30 green gems -> +30% `Player Bonus` 15 green gems -> +15% // 20 green gems -> +20% // 30 green gems -> +30%
Maximum 80% increased heal healing Maximum 80% increased heal healing
# Increased Blast Damage (Combine Blast + Blue Spec x 2) # Increased Blast Damage (Combine Blast + Blue Spec x 2)
Cryp Requires `8 blue gems` Cryp Requires `8 blue gems`
`Base` -> 15% increased blast damage `Base` -> 15% increased blast damage
`Team Bonus` 15 blue gems -> +15% // 20 blue gems -> +20% // 30 blue gems -> +30% `Player Bonus` 15 blue gems -> +15% // 20 blue gems -> +20% // 30 blue gems -> +30%
Maximum 80% increased blast damage Maximum 80% increased blast damage
# Increased Slay Damage (Combine Slay + Red Damage Spec + Healing Spec) # Increased Slay Damage (Combine Slay + Red Damage Spec + Healing Spec)
Cryp Requires `4 red 4 green gems` Cryp Requires `4 red 4 green gems`
`Base` -> 15% increased slay damage `Base` -> 15% increased slay damage
`Team Bonus` (8R + 8G) gems -> +15% // (10R + 10G) gems -> +20% // (15R + 15G) gems -> +30% `Player Bonus` (8R + 8G) gems -> +15% // (10R + 10G) gems -> +20% // (15R + 15G) gems -> +30%
Maximum 80% increased slay damage Maximum 80% increased slay damage
# Increased Banish Damage (Combine Slay + Red Damage Spec + Blue Damage Spec) # Increased Banish Damage (Combine Slay + Red Damage Spec + Blue Damage Spec)
Cryp Requires `4 red 4 blue gems` Cryp Requires `4 red 4 blue gems`
`Base` -> 15% increased slay damage `Base` -> 15% increased slay damage
`Team Bonus` (8R + 8B) gems -> +15% // (10R + 10B) gems -> +20% // (15R + 15B) gems -> +30% `Player Bonus` (8R + 8B) gems -> +15% // (10R + 10B) gems -> +20% // (15R + 15B) gems -> +30%
Maximum 80% increased banish damage Maximum 80% increased banish damage
## Other Combos ## Other Combos
@ -217,7 +217,7 @@ Maximum 80% increased banish damage
# Increased % Red Speed (Basic Speed + 2R) # Increased % Red Speed (Basic Speed + 2R)
Add 2 red gems Add 2 red gems
`Base` -> 15% inc red speed `Base` -> 15% inc red speed
`Team Bonus` 5 red gems -> +15% // 10 red gems -> +20% // 20 red gems -> +25% `Player Bonus` 5 red gems -> +15% // 10 red gems -> +20% // 20 red gems -> +25%
Maximum 80% inc red speed Maximum 80% inc red speed
# Nature Affinity (Basic Class spec + 2R) # Nature Affinity (Basic Class spec + 2R)

6
server/WORKLOG.md
View File

@ -21,7 +21,7 @@
* games * games
check updated timestamps check updated timestamps
once a second? once a second?
add a timestamp to each team add a timestamp to each player
after 30s issue warning (client) after 30s issue warning (client)
after 1m automove after 1m automove
increment warnings increment warnings
@ -89,7 +89,7 @@ make strike *really* hit first / resolve at same time?
* not sure hwo to get sets of player games * not sure hwo to get sets of player games
* set joined_games_$account [game_id] * set joined_games_$account [game_id]
* move team -> player * move player -> player
* chat * chat
* notifications * notifications
@ -121,7 +121,7 @@ $$$
* empower on ko * empower on ko
# Mechanic Ideas # Mechanic Ideas
teams players
1v1 2v2 3v3 1v1 2v2 3v3
gem td style attr combinations gem td style attr combinations

30
server/src/cryp.rs
View File

@ -122,7 +122,7 @@ impl CrypStat {
// self.recalculate(specs) // 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 let specs = specs
.iter() .iter()
.filter(|s| s.affects().contains(&self.stat)) .filter(|s| s.affects().contains(&self.stat))
@ -131,7 +131,7 @@ impl CrypStat {
// applied with fold because it can be zeroed or multiplied // applied with fold because it can be zeroed or multiplied
// but still needs access to the base amount // 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.value = value;
self.max = value; self.max = value;
@ -259,17 +259,17 @@ impl Cryp {
self 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.specs.sort_unstable();
self.red_damage.recalculate(&self.specs, team_colours); self.red_damage.recalculate(&self.specs, player_colours);
self.red_life.recalculate(&self.specs, team_colours); self.red_life.recalculate(&self.specs, player_colours);
self.blue_damage.recalculate(&self.specs, team_colours); self.blue_damage.recalculate(&self.specs, player_colours);
self.blue_life.recalculate(&self.specs, team_colours); self.blue_life.recalculate(&self.specs, player_colours);
self.evasion.recalculate(&self.specs, team_colours); self.evasion.recalculate(&self.specs, player_colours);
self.speed.recalculate(&self.specs, team_colours); self.speed.recalculate(&self.specs, player_colours);
self.green_damage.recalculate(&self.specs, team_colours); self.green_damage.recalculate(&self.specs, player_colours);
self.green_life.recalculate(&self.specs, team_colours); self.green_life.recalculate(&self.specs, player_colours);
self self
} }
@ -836,21 +836,21 @@ mod tests {
} }
#[test] #[test]
fn cryp_team_modifiers_test() { fn cryp_player_modifiers_test() {
let mut cryp = Cryp::new() 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::RedDamageI).unwrap();
cryp.spec_add(Spec::GreenDamageI).unwrap(); cryp.spec_add(Spec::GreenDamageI).unwrap();
cryp.spec_add(Spec::BlueDamageI).unwrap(); cryp.spec_add(Spec::BlueDamageI).unwrap();
let team_colours = Colours { let player_colours = Colours {
red: 5, red: 5,
green: 15, green: 15,
blue: 25, 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.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)); assert!(cryp.green_damage.value == cryp.green_damage.base + cryp.green_damage.base.pct(40));

438
server/src/game.rs
View File

@ -18,56 +18,6 @@ use skill::{Skill, Effect, Cast, Resolution, Event, resolve};
use player::{Player}; use player::{Player};
use instance::{instance_game_finished, global_game_finished}; 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)] #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
pub enum Phase { pub enum Phase {
Start, Start,
@ -90,9 +40,9 @@ pub enum GameMode {
#[derive(Debug,Clone,Serialize,Deserialize)] #[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Game { pub struct Game {
pub id: Uuid, pub id: Uuid,
pub team_size: usize, pub player_cryps: usize,
pub team_num: usize, pub player_num: usize,
pub teams: Vec<Team>, pub players: Vec<Player>,
pub phase: Phase, pub phase: Phase,
pub stack: Vec<Cast>, pub stack: Vec<Cast>,
pub resolved: Vec<Resolution>, pub resolved: Vec<Resolution>,
@ -106,9 +56,9 @@ impl Game {
pub fn new() -> Game { pub fn new() -> Game {
return Game { return Game {
id: Uuid::new_v4(), id: Uuid::new_v4(),
team_size: 0, player_cryps: 0,
team_num: 0, player_num: 0,
teams: vec![], players: vec![],
phase: Phase::Start, phase: Phase::Start,
stack: vec![], stack: vec![],
resolved: vec![], resolved: vec![],
@ -119,13 +69,13 @@ impl Game {
}; };
} }
pub fn set_team_num(&mut self, size: usize) -> &mut Game { pub fn set_player_num(&mut self, size: usize) -> &mut Game {
self.team_num = size; self.player_num = size;
self self
} }
pub fn set_team_size(&mut self, size: usize) -> &mut Game { pub fn set_player_cryps(&mut self, size: usize) -> &mut Game {
self.team_size = size; self.player_cryps = size;
self self
} }
@ -143,47 +93,47 @@ impl Game {
self.can_start() self.can_start()
} }
pub fn team_add(&mut self, team: Team) -> Result<&mut Game, Error> { pub fn player_add(&mut self, player: Player) -> Result<&mut Game, Error> {
if self.teams.len() == self.team_num { if self.players.len() == self.player_num {
return Err(err_msg("maximum number of teams")); return Err(err_msg("maximum number of players"));
} }
if self.teams.iter().any(|t| t.id == team.id) { if self.players.iter().any(|t| t.id == player.id) {
return Err(err_msg("team already in game")); 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")); return Err(err_msg("your cryps have no skills"));
} }
let team_description = team.cryps.iter().map(|c| c.name.clone()).collect::<Vec<String>>().join(", "); let player_description = player.cryps.iter().map(|c| c.name.clone()).collect::<Vec<String>>().join(", ");
self.log.push(format!("{:} has joined the game.", team_description)); self.log.push(format!("{:} has joined the game.", player_description));
self.teams.push(team); self.players.push(player);
Ok(self) Ok(self)
} }
// handle missing team properly // handle missing player properly
pub fn team_by_id(&mut self, id: Uuid) -> &mut Team { pub fn player_by_id(&mut self, id: Uuid) -> Result<&mut Player, Error> {
match self.teams.iter_mut().find(|t| t.id == id) { self.players
Some(t) => t, .iter_mut()
None => panic!("id not in game {:}", id), .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> { 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)) { match self.players.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == id)) {
Some(team) => team.cryps.iter_mut().find(|c| c.id == id), Some(player) => player.cryps.iter_mut().find(|c| c.id == id),
None => None, None => None,
} }
} }
pub fn cryp_by_id_take(&mut self, id: Uuid) -> Cryp { 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)) { match self.players.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == id)) {
Some(team) => { Some(player) => {
let i = team.cryps.iter().position(|c| c.id == id).unwrap(); let i = player.cryps.iter().position(|c| c.id == id).unwrap();
team.cryps.remove(i) player.cryps.remove(i)
} }
None => panic!("id not in game {:}", id), None => panic!("id not in game {:}", id),
} }
@ -191,7 +141,7 @@ impl Game {
fn all_cryps(&self) -> Vec<Cryp> { fn all_cryps(&self) -> Vec<Cryp> {
self.teams.clone() self.players.clone()
.into_iter() .into_iter()
.flat_map( .flat_map(
|t| t.cryps |t| t.cryps
@ -200,12 +150,12 @@ impl Game {
} }
fn update_cryp(&mut self, cryp: &mut Cryp) -> &mut 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)) { match self.players.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == cryp.id)) {
Some(team) => { Some(player) => {
let index = team.cryps.iter().position(|t| t.id == cryp.id).unwrap(); let index = player.cryps.iter().position(|t| t.id == cryp.id).unwrap();
team.cryps.remove(index); player.cryps.remove(index);
team.cryps.push(cryp.clone()); player.cryps.push(cryp.clone());
team.cryps.sort_unstable_by_key(|c| c.id); player.cryps.sort_unstable_by_key(|c| c.id);
}, },
None => panic!("cryp not in game"), None => panic!("cryp not in game"),
}; };
@ -214,8 +164,8 @@ impl Game {
} }
fn can_start(&self) -> bool { fn can_start(&self) -> bool {
return self.teams.len() == self.team_num return self.players.len() == self.player_num
&& self.teams.iter().all(|t| t.cryps.len() == self.team_size) && self.players.iter().all(|t| t.cryps.len() == self.player_cryps)
} }
pub fn start(mut self) -> Game { pub fn start(mut self) -> Game {
@ -244,10 +194,10 @@ impl Game {
fn pve_add_skills(&mut self) -> &mut Game { fn pve_add_skills(&mut self) -> &mut Game {
let mut pve_skills = vec![]; let mut pve_skills = vec![];
for mobs in self.teams for mobs in self.players
.iter() .iter()
.filter(|t| t.bot) { .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() { for mob in mobs.cryps.iter() {
let skill = mob.mob_select_skill(); let skill = mob.mob_select_skill();
@ -261,7 +211,7 @@ impl Game {
let mut find_target = || { let mut find_target = || {
match s.defensive() { match s.defensive() {
true => &mobs.cryps[rng.gen_range(0, mobs.cryps.len())], 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 { for (player_id, mob_id, target_id, s) in pve_skills {
match self.add_skill(team_id, mob_id, target_id, s) { match self.add_skill(player_id, mob_id, target_id, s) {
Ok(_) => (), Ok(_) => (),
Err(e) => { Err(e) => {
println!("{:?}", self.cryp_by_id(mob_id)); println!("{:?}", self.cryp_by_id(mob_id));
@ -291,7 +241,10 @@ impl Game {
self 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 { if self.phase != Phase::Skill {
return Err(err_msg("game not in skill phase")); return Err(err_msg("game not in skill phase"));
} }
@ -348,20 +301,27 @@ impl Game {
self.stack.remove(s); 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; let skill_id = skill.id;
self.stack.push(skill); self.stack.push(skill);
return Ok(skill_id); 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 { fn skill_phase_finished(&self) -> bool {
self.teams.iter().all(|t| t.ready) self.players.iter().all(|t| t.ready)
// self.teams.iter() // self.players.iter()
// // for every team // // for every player
// .all(|t| self.stack.iter() // .all(|t| self.stack.iter()
// // the number of skills they have cast // // 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 // // should equal the number required this turn
// .len() == t.skills_required() // .len() == t.skills_required()
// ) // )
@ -398,7 +358,7 @@ impl Game {
} }
fn cryp_aoe_targets(&self, cryp_id: Uuid) -> Vec<Uuid> { 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)) .find(|t| t.cryps.iter().any(|c| c.id == cryp_id))
.unwrap() .unwrap()
.cryps .cryps
@ -408,11 +368,11 @@ impl Game {
} }
fn get_targets(&self, skill: Skill, source: &Cryp, target_cryp_id: Uuid) -> Vec<Uuid> { 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)) .find(|t| t.cryps.iter().any(|c| c.id == target_cryp_id))
.unwrap(); .unwrap();
if let Some(t) = target_team.taunting() { if let Some(t) = target_player.taunting() {
return vec![t.id]; return vec![t.id];
} }
@ -576,11 +536,11 @@ impl Game {
} }
pub fn finished(&self) -> bool { 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> { pub fn winner(&self) -> Option<&Player> {
self.teams.iter().find(|t| t.cryps.iter().any(|c| !c.is_ko())) self.players.iter().find(|t| t.cryps.iter().any(|c| !c.is_ko()))
} }
fn finish(mut self) -> Game { fn finish(mut self) -> Game {
@ -588,7 +548,7 @@ impl Game {
self.log.push(format!("Game finished.")); 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 { match winner {
Some(w) => self.log.push(format!("Winner: {:}", w.id)), Some(w) => self.log.push(format!("Winner: {:}", w.id)),
None => self.log.push(format!("Game was drawn.")), None => self.log.push(format!("Game was drawn.")),
@ -603,7 +563,7 @@ impl Game {
} }
pub fn upkeep(mut self) -> 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 // on time out if not enough skills selected
// add a warning // add a warning
// on 3 warnings forfeit // on 3 warnings forfeit
@ -723,8 +683,8 @@ pub fn game_global_startup(tx: &mut Transaction) -> Result<(), Error> {
let mut game = Game::new(); let mut game = Game::new();
game game
.set_team_num(2) .set_player_num(2)
.set_team_size(3) .set_player_cryps(3)
.set_mode(GameMode::Pvp); .set_mode(GameMode::Pvp);
game_write(tx, &game)?; 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> { pub fn game_ready(params: GameSkillParams, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {
let mut game = game_get(tx, params.game_id)?; 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() { if game.skill_phase_finished() {
game = game.resolve_phase_start(); 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>>()?; // .collect::<Result<Vec<Cryp>, Error>>()?;
// if cryps.len() > 3 { // 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 // // create the game
@ -873,22 +833,22 @@ pub fn game_ready(params: GameSkillParams, tx: &mut Transaction, account: &Accou
// // let game_id = game.id; // // let game_id = game.id;
// game; // game;
// .set_team_num(2) // .set_player_num(2)
// .set_team_size(cryps.len()) // .set_player_cryps(cryps.len())
// .set_mode(mode); // .set_mode(mode);
// // create the mob team // // create the mob player
// let mob_team = generate_mob_team(mode, &cryps); // let mob_player = generate_mob_player(mode, &cryps);
// // add the players // // add the players
// let mut plr_team = Team::new(account.id); // let mut plr_player = Player::new(account.id);
// plr_team // plr_player
// .set_cryps(cryps); // .set_cryps(cryps);
// game // game
// .team_add(plr_team)? // .player_add(plr_player)?
// .team_add(mob_team)?; // .player_add(mob_player)?;
// game.start(); // 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.id = game_id;
game game
.set_team_num(2) .set_player_num(2)
.set_team_size(3) .set_player_cryps(3)
.set_instance(instance_id) .set_instance(instance_id)
.set_mode(GameMode::Pvp); .set_mode(GameMode::Pvp);
// create the initiators team // create the initiators player
for player in players { for player in players {
let mut team = Team::new(player.id); game.player_add(player)?;
team.set_cryps(player.cryps);
game.team_add(team)?;
} }
if game.can_start() { 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> { 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 game = game_get(tx, game_id)?;
let mut team = Team::new(player.id); game.player_add(player)?;
team.set_cryps(player.cryps);
game.team_add(team)?;
if game.can_start() { if game.can_start() {
game = game.start(); game = game.start();
@ -983,24 +939,20 @@ mod tests {
let mut game = Game::new(); let mut game = Game::new();
game game
.set_team_num(2) .set_player_num(2)
.set_team_size(1); .set_player_cryps(1);
let x_team_id = Uuid::new_v4(); let x_player_id = Uuid::new_v4();
x.account = x_team_id; x.account = x_player_id;
let mut x_team = Team::new(x_team_id); let mut x_player = Player::new(x_player_id, &"ntr".to_string(), vec![x]);
x_team
.set_cryps(vec![x]);
let y_team_id = Uuid::new_v4(); let y_player_id = Uuid::new_v4();
y.account = y_team_id; y.account = y_player_id;
let mut y_team = Team::new(y_team_id); let mut y_player = Player::new(y_player_id, &"mash".to_string(), vec![y]);
y_team
.set_cryps(vec![y]);
game game
.team_add(x_team).unwrap() .player_add(x_player).unwrap()
.team_add(y_team).unwrap(); .player_add(y_player).unwrap();
assert!(game.can_start()); assert!(game.can_start());
@ -1031,26 +983,22 @@ mod tests {
let mut game = Game::new(); let mut game = Game::new();
game game
.set_team_num(2) .set_player_num(2)
.set_team_size(2); .set_player_cryps(2);
let i_team_id = Uuid::new_v4(); let i_player_id = Uuid::new_v4();
i.account = i_team_id; i.account = i_player_id;
j.account = i_team_id; j.account = i_player_id;
let mut i_team = Team::new(i_team_id); let mut i_player = Player::new(i_player_id, &"ntr".to_string(), vec![i, j]);
i_team
.set_cryps(vec![i,j]);
let x_team_id = Uuid::new_v4(); let x_player_id = Uuid::new_v4();
x.account = x_team_id; x.account = x_player_id;
y.account = x_team_id; y.account = x_player_id;
let mut x_team = Team::new(x_team_id); let mut x_player = Player::new(x_player_id, &"mashy".to_string(), vec![x, y]);
x_team
.set_cryps(vec![x,y]);
game game
.team_add(i_team).unwrap() .player_add(i_player).unwrap()
.team_add(x_team).unwrap(); .player_add(x_player).unwrap();
assert!(game.can_start()); assert!(game.can_start());
@ -1061,14 +1009,14 @@ mod tests {
fn phase_test() { fn phase_test() {
let mut game = create_test_game(); let mut game = create_test_game();
let x_team = game.teams[0].clone(); let x_player = game.players[0].clone();
let y_team = game.teams[1].clone(); let y_player = game.players[1].clone();
let x_cryp = x_team.cryps[0].clone(); let x_cryp = x_player.cryps[0].clone();
let y_cryp = y_team.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(x_player.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(y_player.id, y_cryp.id, Some(x_cryp.id), Skill::Attack).unwrap();
assert!(game.skill_phase_finished()); assert!(game.skill_phase_finished());
@ -1083,14 +1031,14 @@ mod tests {
fn stun_test() { fn stun_test() {
let mut game = create_test_game(); let mut game = create_test_game();
let x_team = game.teams[0].clone(); let x_player = game.players[0].clone();
let y_team = game.teams[1].clone(); let y_player = game.players[1].clone();
let x_cryp = x_team.cryps[0].clone(); let x_cryp = x_player.cryps[0].clone();
let y_cryp = y_team.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(); let _x_stun_id = game.add_skill(x_player.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(); game.add_skill(y_player.id, y_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
assert!(game.skill_phase_finished()); assert!(game.skill_phase_finished());
game = game.resolve_phase_start(); game = game.resolve_phase_start();
@ -1098,34 +1046,34 @@ mod tests {
// should auto progress back to skill phase // should auto progress back to skill phase
assert!(game.phase == Phase::Skill); assert!(game.phase == Phase::Skill);
// assert!(game.team_by_id(y_team.id).cryps[0].is_stunned()); // assert!(game.player_by_id(y_player.id).cryps[0].is_stunned());
// assert!(game.team_by_id(y_team.id).skills_required() == 0); // assert!(game.player_by_id(y_player.id).skills_required() == 0);
} }
#[test] #[test]
fn ko_resolution_test() { fn ko_resolution_test() {
let mut game = create_test_game(); let mut game = create_test_game();
let x_team = game.teams[0].clone(); let x_player = game.players[0].clone();
let y_team = game.teams[1].clone(); let y_player = game.players[1].clone();
let x_cryp = x_team.cryps[0].clone(); let x_cryp = x_player.cryps[0].clone();
let y_cryp = y_team.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.player_by_id(y_player.id).unwrap().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().speed.force(u64::max_value());
// just in case // just in case
// remove all mitigation // 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(); let _x_stun_id = game.add_skill(x_player.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(); game.add_skill(y_player.id, y_cryp.id, Some(x_cryp.id), Skill::Attack).unwrap();
assert!(game.skill_phase_finished()); assert!(game.skill_phase_finished());
game = game.resolve_phase_start(); 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); assert!(game.phase == Phase::Finish);
} }
@ -1133,71 +1081,71 @@ mod tests {
fn cooldown_test() { fn cooldown_test() {
let mut game = create_test_game(); let mut game = create_test_game();
let x_team = game.teams[0].clone(); let x_player = game.players[0].clone();
let y_team = game.teams[1].clone(); let y_player = game.players[1].clone();
let x_cryp = x_team.cryps[0].clone(); let x_cryp = x_player.cryps[0].clone();
let y_cryp = y_team.cryps[0].clone(); let y_cryp = y_player.cryps[0].clone();
// should auto progress back to skill phase // should auto progress back to skill phase
assert!(game.phase == Phase::Skill); assert!(game.phase == Phase::Skill);
assert!(game.team_by_id(y_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.team_by_id(y_team.id).cryps[0].skill_on_cd(Skill::Stun).is_some()); assert!(game.player_by_id(y_player.id).unwrap().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(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(); let _x_stun_id = game.add_skill(x_player.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(); game.add_skill(y_player.id, y_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game = game.resolve_phase_start(); game = game.resolve_phase_start();
// should auto progress back to skill phase // should auto progress back to skill phase
assert!(game.phase == Phase::Skill); 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 // second round
// now we block and it should go back on cd // 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 _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_team.id, y_cryp.id, Some(x_cryp.id), Skill::TestTouch).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(); game = game.resolve_phase_start();
assert!(game.team_by_id(x_team.id).cryps[0].skill_on_cd(Skill::Stun).is_some()); assert!(game.player_by_id(x_player.id).unwrap().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(y_player.id).unwrap().cryps[0].skill_on_cd(Skill::Block).is_none());
} }
#[test] #[test]
fn parry_test() { fn parry_test() {
let mut game = create_test_game(); let mut game = create_test_game();
let x_team = game.teams[0].clone(); let x_player = game.players[0].clone();
let y_team = game.teams[1].clone(); let y_player = game.players[1].clone();
let x_cryp = x_team.cryps[0].clone(); let x_cryp = x_player.cryps[0].clone();
let y_cryp = y_team.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(); let _x_block_id = game.add_skill(x_player.id, x_cryp.id, None, Skill::TestParry).unwrap();
game.add_skill(y_team.id, y_cryp.id, Some(x_cryp.id), Skill::TestStun).unwrap(); game.add_skill(y_player.id, y_cryp.id, Some(x_cryp.id), Skill::TestStun).unwrap();
game = game.resolve_phase_start(); game = game.resolve_phase_start();
// should not be stunned because of parry // 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 // 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] #[test]
fn aoe_test() { fn aoe_test() {
let mut game = create_2v2_test_game(); let mut game = create_2v2_test_game();
let i_team = game.teams[0].clone(); let i_player = game.players[0].clone();
let x_team = game.teams[1].clone(); let x_player = game.players[1].clone();
let i_cryp = i_team.cryps[0].clone(); let i_cryp = i_player.cryps[0].clone();
let j_cryp = i_team.cryps[1].clone(); let j_cryp = i_player.cryps[1].clone();
let x_cryp = x_team.cryps[0].clone(); let x_cryp = x_player.cryps[0].clone();
let y_cryp = x_team.cryps[1].clone(); let y_cryp = x_player.cryps[1].clone();
game.cryp_by_id(x_cryp.id).unwrap().learn_mut(Skill::Ruin); 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.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_player.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(i_player.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_player.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(x_player.id, y_cryp.id, Some(i_cryp.id), Skill::TestTouch).unwrap();
assert!(game.skill_phase_finished()); assert!(game.skill_phase_finished());
game = game.resolve_phase_start(); game = game.resolve_phase_start();
@ -1238,13 +1186,13 @@ mod tests {
fn taunt_test() { fn taunt_test() {
let mut game = create_2v2_test_game(); let mut game = create_2v2_test_game();
let i_team = game.teams[0].clone(); let i_player = game.players[0].clone();
let x_team = game.teams[1].clone(); let x_player = game.players[1].clone();
let i_cryp = i_team.cryps[0].clone(); let i_cryp = i_player.cryps[0].clone();
let j_cryp = i_team.cryps[1].clone(); let j_cryp = i_player.cryps[1].clone();
let x_cryp = x_team.cryps[0].clone(); let x_cryp = x_player.cryps[0].clone();
let y_cryp = x_team.cryps[1].clone(); let y_cryp = x_player.cryps[1].clone();
game.cryp_by_id(x_cryp.id).unwrap().learn_mut(Skill::Taunt); 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.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_player.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(i_player.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_player.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(x_player.id, y_cryp.id, Some(i_cryp.id), Skill::TestTouch).unwrap();
assert!(game.skill_phase_finished()); assert!(game.skill_phase_finished());
game = game.resolve_phase_start(); game = game.resolve_phase_start();
@ -1273,18 +1221,18 @@ mod tests {
fn ko_pve_test() { fn ko_pve_test() {
let mut game = create_2v2_test_game(); let mut game = create_2v2_test_game();
let i_team = game.teams[0].clone(); let i_player = game.players[0].clone();
let x_team = game.teams[1].clone(); let x_player = game.players[1].clone();
let i_cryp = i_team.cryps[0].clone(); let i_cryp = i_player.cryps[0].clone();
let j_cryp = i_team.cryps[1].clone(); let j_cryp = i_player.cryps[1].clone();
let x_cryp = x_team.cryps[0].clone(); let x_cryp = x_player.cryps[0].clone();
let y_cryp = x_team.cryps[1].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_player.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(i_player.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_player.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(x_player.id, y_cryp.id, Some(i_cryp.id), Skill::TestTouch).unwrap();
assert!(game.skill_phase_finished()); assert!(game.skill_phase_finished());
game = game.resolve_phase_start(); game = game.resolve_phase_start();
@ -1292,22 +1240,22 @@ mod tests {
assert!([Phase::Skill, Phase::Finish].contains(&game.phase)); assert!([Phase::Skill, Phase::Finish].contains(&game.phase));
// kill a cryp // 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.player_by_id(i_player.id).unwrap().skills_required() == 1);
assert!(game.team_by_id(x_team.id).skills_required() == 2); assert!(game.player_by_id(x_player.id).unwrap().skills_required() == 2);
// add some more skills // add some more skills
game.add_skill(i_team.id, j_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_team.id, x_cryp.id, Some(j_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_team.id, y_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_team.id, x_cryp.id, Some(i_cryp.id), Skill::TestTouch).is_err()); assert!(game.add_skill(x_player.id, x_cryp.id, Some(i_cryp.id), Skill::TestTouch).is_err());
assert!(game.skill_phase_finished()); assert!(game.skill_phase_finished());
game = game.resolve_phase_start(); game = game.resolve_phase_start();
assert!(game.team_by_id(i_team.id).skills_required() == 1); assert!(game.player_by_id(i_player.id).unwrap().skills_required() == 1);
assert!(game.team_by_id(x_team.id).skills_required() == 2); assert!(game.player_by_id(x_player.id).unwrap().skills_required() == 2);
return; return;
} }

75
server/src/instance.rs
View File

@ -11,10 +11,10 @@ use std::iter;
use rpc::{InstanceLobbyParams, InstanceJoinParams, InstanceReadyParams, InstanceStateParams}; use rpc::{InstanceLobbyParams, InstanceJoinParams, InstanceReadyParams, InstanceStateParams};
use account::Account; 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 cryp::{Cryp, cryp_get};
use mob::{instance_mobs}; 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 vbox::{Var};
use rpc::{RpcResult}; use rpc::{RpcResult};
use names::{name}; use names::{name};
@ -99,7 +99,7 @@ impl Instance {
self.players = iter::repeat_with(|| { self.players = iter::repeat_with(|| {
let bot_id = Uuid::new_v4(); let bot_id = Uuid::new_v4();
let cryps = instance_mobs(bot_id); 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.set_ready(true);
p p
}) })
@ -180,21 +180,13 @@ impl Instance {
let mut game = Game::new(); let mut game = Game::new();
game.id = current_round.game_id; game.id = current_round.game_id;
game game
.set_team_num(2) .set_player_num(2)
.set_team_size(3) .set_player_cryps(3)
.set_instance(self.id); .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 game
.team_add(plr_team)? .player_add(plr)?
.team_add(bot_team)?; .player_add(bot)?;
game = game.start(); game = game.start();
@ -240,9 +232,9 @@ impl Instance {
let winner = game.winner().ok_or(err_msg("game not finished"))?; let winner = game.winner().ok_or(err_msg("game not finished"))?;
for team in game.teams.iter() { for player in game.players.iter() {
let mut player = self.account_player(team.id)?; let mut player = self.account_player(player.id)?;
match team.id == winner.id { match player.id == winner.id {
true => player.add_win(), true => player.add_win(),
false => player.add_loss(), false => player.add_loss(),
}; };
@ -293,21 +285,12 @@ impl Instance {
let mut game = Game::new(); let mut game = Game::new();
game game
.set_team_num(2) .set_player_num(2)
.set_team_size(3); .set_player_cryps(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();
game game
.team_add(a_team).unwrap() .player_add(a).unwrap()
.team_add(b_team).unwrap(); .player_add(b).unwrap();
game = game.start(); game = game.start();
@ -319,9 +302,9 @@ impl Instance {
round.finished = true; round.finished = true;
for team in game.teams.iter() { for player in game.players.iter() {
let mut player = self.players.iter_mut().find(|p| p.id == team.id).unwrap(); let mut player = self.players.iter_mut().find(|p| p.id == player.id).unwrap();
match team.id == winner.id { match player.id == winner.id {
true => player.add_win(), true => player.add_win(),
false => player.add_loss(), false => player.add_loss(),
}; };
@ -611,10 +594,10 @@ pub fn instance_join(params: InstanceJoinParams, tx: &mut Transaction, account:
.collect::<Result<Vec<Cryp>, Error>>()?; .collect::<Result<Vec<Cryp>, Error>>()?;
if cryps.len() != 3 { 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)?; 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 a = instance.account_player(account.id)?.clone();
let b = instance.account_player(opponent_id)?.clone(); let b = instance.account_player(opponent_id)?.clone();
let teams = vec![a, b]; let players = vec![a, b];
game_instance_new(tx, teams, game_id, instance.id)? 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> { pub fn global_game_finished(tx: &mut Transaction, game: &Game) -> Result<(), Error> {
let winner = game.winner().ok_or(err_msg("game not finished"))?; let winner = game.winner().ok_or(err_msg("game not finished"))?;
for team in game.teams.iter() { for player in game.players.iter() {
let mut player = player_get(tx, team.id, Uuid::nil())?; let mut player = player_get(tx, player.id, Uuid::nil())?;
match team.id == winner.id { match player.id == winner.id {
true => player.add_win(), true => player.add_win(),
false => player.add_loss(), false => player.add_loss(),
}; };
player.vbox.fill(); player.vbox.fill();
player_update(tx, player, true)?; player_global_update(tx, player, true)?;
} }
Ok(()) Ok(())
@ -729,7 +712,7 @@ mod tests {
let player_account = Uuid::new_v4(); let player_account = Uuid::new_v4();
let cryps = instance_mobs(player_account); 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; let player_id = player.id;
instance.add_player(player).expect("could not add player"); instance.add_player(player).expect("could not add player");
@ -759,7 +742,7 @@ mod tests {
let instance = Instance::new(); let instance = Instance::new();
let player_account = Uuid::new_v4(); let player_account = Uuid::new_v4();
let cryps = instance_mobs(player_account); 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] #[test]
@ -772,7 +755,7 @@ mod tests {
let player_account = Uuid::new_v4(); let player_account = Uuid::new_v4();
let cryps = instance_mobs(player_account); 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; let a_id = player.id;
instance.add_player(player).expect("could not add player"); instance.add_player(player).expect("could not add player");
@ -780,7 +763,7 @@ mod tests {
let player_account = Uuid::new_v4(); let player_account = Uuid::new_v4();
let cryps = instance_mobs(player_account); 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; let b_id = player.id;
instance.add_player(player).expect("could not add player"); instance.add_player(player).expect("could not add player");

20
server/src/mob.rs
View File

@ -21,19 +21,19 @@ pub fn generate_mob() -> Cryp {
return mob; return mob;
} }
// fn quick_game(team_size: usize) -> Vec<Cryp> { // fn quick_game(player_size: usize) -> Vec<Cryp> {
// iter::repeat_with(|| // iter::repeat_with(||
// generate_mob() // generate_mob()
// .set_account(Uuid::nil()) // .set_account(Uuid::nil())
// .learn(Skill::Attack)) // .learn(Skill::Attack))
// .take(team_size) // .take(player_size)
// .collect::<Vec<Cryp>>() // .collect::<Vec<Cryp>>()
// } // }
pub fn instance_mobs(team_id: Uuid) -> Vec<Cryp> { pub fn instance_mobs(player_id: Uuid) -> Vec<Cryp> {
iter::repeat_with(|| iter::repeat_with(||
generate_mob() generate_mob()
.set_account(team_id)) .set_account(player_id))
// .learn(Skill::Attack)) // .learn(Skill::Attack))
.take(3) .take(3)
.collect::<Vec<Cryp>>() .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 { // pub fn generate_mob_player(mode: GameMode, cryps: &Vec<Cryp>) -> Player {
// let mut mob_team = Team::new(Uuid::nil()); // let mut mob_player = Player::new(Uuid::nil());
// let cryp_lvl = cryps.iter().max_by_key(|c| c.lvl).unwrap().lvl; // 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 { // 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::Zone3v2Attack => zone_3v2_attack(cryp_lvl),
// GameMode::Zone2v2Caster => zone_2v2_caster(cryp_lvl), // GameMode::Zone2v2Caster => zone_2v2_caster(cryp_lvl),
// GameMode::Zone3v3MeleeMiniboss => zone_3v3_melee_miniboss(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), // _ => panic!("{:?} not handled for pve mobs", mode),
// }; // };
// mob_team.set_cryps(mobs); // mob_player.set_cryps(mobs);
// return mob_team; // return mob_player;
// } // }

71
server/src/player.rs
View File

@ -13,6 +13,7 @@ use cryp::{Cryp, Colours, cryp_get};
use vbox::{Vbox, Var, VarEffect}; use vbox::{Vbox, Var, VarEffect};
use rpc::{PlayerCrypsSetParams}; use rpc::{PlayerCrypsSetParams};
use instance::{Instance, instance_get, instance_update}; use instance::{Instance, instance_get, instance_update};
use skill::{Effect};
const DISCARD_COST: u16 = 5; const DISCARD_COST: u16 = 5;
@ -25,7 +26,6 @@ pub struct Score {
#[derive(Debug,Clone,Serialize,Deserialize)] #[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Player { pub struct Player {
pub id: Uuid, pub id: Uuid,
pub instance: Uuid,
pub name: String, pub name: String,
pub vbox: Vbox, pub vbox: Vbox,
pub score: Score, pub score: Score,
@ -35,12 +35,11 @@ pub struct Player {
} }
impl 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 { Player {
id: account, id: account,
instance,
name: name.clone(), name: name.clone(),
vbox: Vbox::new(account, instance), vbox: Vbox::new(),
score: Score { wins: 0, losses: 0 }, score: Score { wins: 0, losses: 0 },
cryps, cryps,
bot: false, bot: false,
@ -205,8 +204,8 @@ impl Player {
} }
// now the var has been applied // now the var has been applied
// recalculate the stats of the whole team // recalculate the stats of the whole player
let team_colours = self.cryps.iter().fold(Colours::new(), |tc, c| { let player_colours = self.cryps.iter().fold(Colours::new(), |tc, c| {
Colours { Colours {
red: tc.red + c.colours.red, red: tc.red + c.colours.red,
green: tc.green + c.colours.green, green: tc.green + c.colours.green,
@ -215,7 +214,7 @@ impl Player {
}); });
for cryp in self.cryps.iter_mut() { for cryp in self.cryps.iter_mut() {
cryp.apply_modifiers(&team_colours); cryp.apply_modifiers(&player_colours);
} }
Ok(self) Ok(self)
@ -241,8 +240,8 @@ impl Player {
} }
// now the var has been applied // now the var has been applied
// recalculate the stats of the whole team // recalculate the stats of the whole player
let team_colours = self.cryps.iter().fold(Colours::new(), |tc, c| { let player_colours = self.cryps.iter().fold(Colours::new(), |tc, c| {
Colours { Colours {
red: tc.red + c.colours.red, red: tc.red + c.colours.red,
green: tc.green + c.colours.green, green: tc.green + c.colours.green,
@ -251,7 +250,7 @@ impl Player {
}); });
for cryp in self.cryps.iter_mut() { for cryp in self.cryps.iter_mut() {
cryp.apply_modifiers(&team_colours); cryp.apply_modifiers(&player_colours);
} }
self.vbox.bound.push(target); self.vbox.bound.push(target);
@ -259,6 +258,32 @@ impl Player {
Ok(self) 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> { 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); 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 player_bytes = to_vec(&player)?;
let query = " let query = "
@ -295,27 +320,19 @@ pub fn player_create(tx: &mut Transaction, player: Player, account: &Account) ->
"; ";
let result = tx 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"); 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); 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 // sort vbox for niceness
player.vbox.bound.sort_unstable(); 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 bytes = to_vec(&player)?;
let query = " 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> { pub fn player_mm_cryps_set(params: PlayerCrypsSetParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
if params.cryp_ids.len() != 3 { 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 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()) { let player = match player_get(tx, account.id, Uuid::nil()) {
Ok(mut p) => { Ok(mut p) => {
p.cryps = cryps; p.cryps = cryps;
p.vbox = Vbox::new(account.id, Uuid::nil()); p.vbox = Vbox::new();
player_update(tx, p, false)? player_global_update(tx, p, false)?
}, },
Err(_) => { 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() { fn player_bot_vbox_test() {
let player_account = Uuid::new_v4(); let player_account = Uuid::new_v4();
let cryps = instance_mobs(player_account); 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.vbox.fill();
player.autobuy(); player.autobuy();

6
server/src/skill.rs
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)] #[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
pub struct Cast { pub struct Cast {
pub id: Uuid, pub id: Uuid,
pub source_team_id: Uuid, pub source_player_id: Uuid,
pub source_cryp_id: Uuid, pub source_cryp_id: Uuid,
pub target_cryp_id: Uuid, pub target_cryp_id: Uuid,
pub skill: Skill, pub skill: Skill,
@ -134,11 +134,11 @@ pub struct Cast {
} }
impl 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 { return Cast {
id: Uuid::new_v4(), id: Uuid::new_v4(),
source_cryp_id, source_cryp_id,
source_team_id, source_player_id,
target_cryp_id, target_cryp_id,
skill, skill,
speed: 0, speed: 0,

122
server/src/spec.rs
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 { match *self {
// Upgrades to Damage Spec // Upgrades to Damage Spec
Spec::Damage => modified + base.pct(5), Spec::Damage => modified + base.pct(5),
Spec::RedDamageI => modified + { Spec::RedDamageI => modified + {
let mut pct = 10; let mut pct = 10;
if team_colours.red >= 5 { pct += 10 }; if player_colours.red >= 5 { pct += 10 };
if team_colours.red >= 10 { pct += 20 }; if player_colours.red >= 10 { pct += 20 };
if team_colours.red >= 20 { pct += 40 }; if player_colours.red >= 20 { pct += 40 };
base.pct(pct) base.pct(pct)
}, },
Spec::GreenDamageI => modified + { Spec::GreenDamageI => modified + {
let mut pct = 10; let mut pct = 10;
if team_colours.green >= 5 { pct += 10 }; if player_colours.green >= 5 { pct += 10 };
if team_colours.green >= 10 { pct += 20 }; if player_colours.green >= 10 { pct += 20 };
if team_colours.green >= 20 { pct += 40 }; if player_colours.green >= 20 { pct += 40 };
base.pct(pct) base.pct(pct)
}, },
Spec::BlueDamageI => modified + { Spec::BlueDamageI => modified + {
let mut pct = 10; let mut pct = 10;
if team_colours.blue >= 5 { pct += 10 }; if player_colours.blue >= 5 { pct += 10 };
if team_colours.blue >= 10 { pct += 20 }; if player_colours.blue >= 10 { pct += 20 };
if team_colours.blue >= 20 { pct += 40 }; if player_colours.blue >= 20 { pct += 40 };
base.pct(pct) base.pct(pct)
}, },
Spec::GRDI => modified + { Spec::GRDI => modified + {
let mut pct = 5; let mut pct = 5;
if team_colours.green >= 2 && team_colours.red >= 2 { pct += 10 }; if player_colours.green >= 2 && player_colours.red >= 2 { pct += 10 };
if team_colours.green >= 5 && team_colours.red >= 5 { pct += 15 }; if player_colours.green >= 5 && player_colours.red >= 5 { pct += 15 };
if team_colours.green >= 10 && team_colours.red >= 10 { pct += 30 }; if player_colours.green >= 10 && player_colours.red >= 10 { pct += 30 };
base.pct(pct) base.pct(pct)
}, },
Spec::GBDI => modified + { Spec::GBDI => modified + {
let mut pct = 5; let mut pct = 5;
if team_colours.green >= 2 && team_colours.blue >= 2 { pct += 10 }; if player_colours.green >= 2 && player_colours.blue >= 2 { pct += 10 };
if team_colours.green >= 5 && team_colours.blue >= 5 { pct += 15 }; if player_colours.green >= 5 && player_colours.blue >= 5 { pct += 15 };
if team_colours.green >= 10 && team_colours.blue >= 10 { pct += 30 }; if player_colours.green >= 10 && player_colours.blue >= 10 { pct += 30 };
base.pct(pct) base.pct(pct)
}, },
Spec::RBDI => modified + { Spec::RBDI => modified + {
let mut pct = 5; let mut pct = 5;
if team_colours.blue >= 2 && team_colours.red >= 2 { pct += 10 }; if player_colours.blue >= 2 && player_colours.red >= 2 { pct += 10 };
if team_colours.blue >= 5 && team_colours.red >= 5 { pct += 15 }; if player_colours.blue >= 5 && player_colours.red >= 5 { pct += 15 };
if team_colours.blue >= 10 && team_colours.red >= 10 { pct += 30 }; if player_colours.blue >= 10 && player_colours.red >= 10 { pct += 30 };
base.pct(pct) base.pct(pct)
}, },
// Upgrades to speed Spec // Upgrades to speed Spec
Spec::Speed => modified + base.pct(5), Spec::Speed => modified + base.pct(5),
Spec::RedSpeedI => modified + { Spec::RedSpeedI => modified + {
let mut pct = 5; let mut pct = 5;
if team_colours.red >= 5 { pct += 5 }; if player_colours.red >= 5 { pct += 5 };
if team_colours.red >= 10 { pct += 10 }; if player_colours.red >= 10 { pct += 10 };
if team_colours.red >= 20 { pct += 20 }; if player_colours.red >= 20 { pct += 20 };
base.pct(pct) base.pct(pct)
}, },
Spec::GreenSpeedI => modified + { Spec::GreenSpeedI => modified + {
let mut pct = 5; let mut pct = 5;
if team_colours.green >= 5 { pct += 5 }; if player_colours.green >= 5 { pct += 5 };
if team_colours.green >= 10 { pct += 10 }; if player_colours.green >= 10 { pct += 10 };
if team_colours.green >= 20 { pct += 20 }; if player_colours.green >= 20 { pct += 20 };
base.pct(pct) base.pct(pct)
}, },
Spec::BlueSpeedI => modified + { Spec::BlueSpeedI => modified + {
let mut pct = 5; let mut pct = 5;
if team_colours.blue >= 5 { pct += 5 }; if player_colours.blue >= 5 { pct += 5 };
if team_colours.blue >= 10 { pct += 10 }; if player_colours.blue >= 10 { pct += 10 };
if team_colours.blue >= 20 { pct += 20 }; if player_colours.blue >= 20 { pct += 20 };
base.pct(pct) base.pct(pct)
}, },
Spec::GRSpeedI => modified + { Spec::GRSpeedI => modified + {
let mut pct = 5; let mut pct = 5;
if team_colours.green >= 2 && team_colours.red >= 2 { pct += 5 }; if player_colours.green >= 2 && player_colours.red >= 2 { pct += 5 };
if team_colours.green >= 5 && team_colours.red >= 5 { pct += 10 }; if player_colours.green >= 5 && player_colours.red >= 5 { pct += 10 };
if team_colours.green >= 10 && team_colours.red >= 10 { pct += 20 }; if player_colours.green >= 10 && player_colours.red >= 10 { pct += 20 };
base.pct(pct) base.pct(pct)
}, },
Spec::GBSpeedI => modified + { Spec::GBSpeedI => modified + {
let mut pct = 5; let mut pct = 5;
if team_colours.green >= 2 && team_colours.blue >= 2 { pct += 5 }; if player_colours.green >= 2 && player_colours.blue >= 2 { pct += 5 };
if team_colours.green >= 5 && team_colours.blue >= 5 { pct += 10 }; if player_colours.green >= 5 && player_colours.blue >= 5 { pct += 10 };
if team_colours.green >= 10 && team_colours.blue >= 10 { pct += 20 }; if player_colours.green >= 10 && player_colours.blue >= 10 { pct += 20 };
base.pct(pct) base.pct(pct)
}, },
Spec::RBSpeedI => modified + { Spec::RBSpeedI => modified + {
let mut pct = 5; let mut pct = 5;
if team_colours.blue >= 2 && team_colours.red >= 2 { pct += 5 }; if player_colours.blue >= 2 && player_colours.red >= 2 { pct += 5 };
if team_colours.blue >= 5 && team_colours.red >= 5 { pct += 10 }; if player_colours.blue >= 5 && player_colours.red >= 5 { pct += 10 };
if team_colours.blue >= 10 && team_colours.red >= 10 { pct += 20 }; if player_colours.blue >= 10 && player_colours.red >= 10 { pct += 20 };
base.pct(pct) base.pct(pct)
}, },
@ -163,45 +163,45 @@ impl Spec {
Spec::Life => modified + base.pct(5), Spec::Life => modified + base.pct(5),
Spec::GreenLifeI => modified + { Spec::GreenLifeI => modified + {
let mut mult: u64 = 15; let mut mult: u64 = 15;
if team_colours.green >= 5 { mult += 25 }; if player_colours.green >= 5 { mult += 25 };
if team_colours.green >= 10 { mult += 50 }; if player_colours.green >= 10 { mult += 50 };
if team_colours.green >= 20 { mult += 75 }; if player_colours.green >= 20 { mult += 75 };
mult * team_colours.green as u64 mult * player_colours.green as u64
}, },
Spec::RedLifeI => modified + { Spec::RedLifeI => modified + {
let mut mult: u64 = 15; let mut mult: u64 = 15;
if team_colours.red >= 5 { mult += 25 }; if player_colours.red >= 5 { mult += 25 };
if team_colours.red >= 10 { mult += 50 }; if player_colours.red >= 10 { mult += 50 };
if team_colours.red >= 20 { mult += 75 }; if player_colours.red >= 20 { mult += 75 };
mult * team_colours.red as u64 mult * player_colours.red as u64
}, },
Spec::BlueLifeI => modified + { Spec::BlueLifeI => modified + {
let mut mult: u64 = 15; let mut mult: u64 = 15;
if team_colours.blue >= 5 { mult += 25 }; if player_colours.blue >= 5 { mult += 25 };
if team_colours.blue >= 10 { mult += 50 }; if player_colours.blue >= 10 { mult += 50 };
if team_colours.blue >= 20 { mult += 75 }; if player_colours.blue >= 20 { mult += 75 };
mult * team_colours.blue as u64 mult * player_colours.blue as u64
}, },
Spec::GRLI => modified + { Spec::GRLI => modified + {
let mut mult: u64 = 10; let mut mult: u64 = 10;
if team_colours.green >= 2 && team_colours.red >= 2 { mult += 10 }; if player_colours.green >= 2 && player_colours.red >= 2 { mult += 10 };
if team_colours.green >= 5 && team_colours.red >= 5 { mult += 25 }; if player_colours.green >= 5 && player_colours.red >= 5 { mult += 25 };
if team_colours.green >= 10 && team_colours.red >= 10 { mult += 50 }; if player_colours.green >= 10 && player_colours.red >= 10 { mult += 50 };
mult * (team_colours.green + team_colours.red) as u64 mult * (player_colours.green + player_colours.red) as u64
}, },
Spec::GBLI => modified + { Spec::GBLI => modified + {
let mut mult: u64 = 10; let mut mult: u64 = 10;
if team_colours.green >= 2 && team_colours.red >= 2 { mult += 10 }; if player_colours.green >= 2 && player_colours.red >= 2 { mult += 10 };
if team_colours.green >= 5 && team_colours.red >= 5 { mult += 25 }; if player_colours.green >= 5 && player_colours.red >= 5 { mult += 25 };
if team_colours.green >= 10 && team_colours.red >= 10 { mult += 50 }; if player_colours.green >= 10 && player_colours.red >= 10 { mult += 50 };
mult * (team_colours.green + team_colours.red) as u64 mult * (player_colours.green + player_colours.red) as u64
}, },
Spec::RBLI => modified + { Spec::RBLI => modified + {
let mut mult: u64 = 10; let mut mult: u64 = 10;
if team_colours.blue >= 2 && team_colours.red >= 2 { mult += 10 }; if player_colours.blue >= 2 && player_colours.red >= 2 { mult += 10 };
if team_colours.blue >= 5 && team_colours.red >= 5 { mult += 25 }; if player_colours.blue >= 5 && player_colours.red >= 5 { mult += 25 };
if team_colours.blue >= 10 && team_colours.red >= 10 { mult += 50 }; if player_colours.blue >= 10 && player_colours.red >= 10 { mult += 50 };
mult * (team_colours.blue + team_colours.red) as u64 mult * (player_colours.blue + player_colours.red) as u64
}, },
} }
} }

13
server/src/vbox.rs
View File

@ -15,7 +15,6 @@ use account::Account;
use rpc::{VboxAcceptParams, VboxDiscardParams, VboxCombineParams, VboxApplyParams, VboxReclaimParams, VboxUnequipParams}; use rpc::{VboxAcceptParams, VboxDiscardParams, VboxCombineParams, VboxApplyParams, VboxReclaimParams, VboxUnequipParams};
use skill::{Skill}; use skill::{Skill};
use spec::{Spec}; use spec::{Spec};
use player::{Player};
use instance::{Instance, instance_get, instance_update}; use instance::{Instance, instance_get, instance_update};
use cryp::{Colours}; use cryp::{Colours};
@ -397,16 +396,13 @@ fn get_combos() -> Vec<Combo> {
#[derive(Debug,Clone,Serialize,Deserialize)] #[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Vbox { pub struct Vbox {
pub id: Uuid,
pub bits: u16, pub bits: u16,
pub free: Vec<Vec<Var>>, pub free: Vec<Vec<Var>>,
pub bound: Vec<Var>, pub bound: Vec<Var>,
pub instance: Uuid,
pub account: Uuid,
} }
impl Vbox { impl Vbox {
pub fn new(account_id: Uuid, instance_id: Uuid) -> Vbox { pub fn new() -> Vbox {
let starting_items = vec![ let starting_items = vec![
Var::Attack, Var::Attack,
Var::Attack, Var::Attack,
@ -414,9 +410,6 @@ impl Vbox {
]; ];
Vbox { Vbox {
id: Uuid::new_v4(),
account: account_id,
instance: instance_id,
free: vec![vec![], vec![], vec![]], free: vec![vec![], vec![], vec![]],
bound: starting_items, bound: starting_items,
bits: 18, bits: 18,
@ -581,7 +574,7 @@ mod tests {
#[test] #[test]
fn combine_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.bound = vec![Var::Attack, Var::Green, Var::Green];
vbox.combine(vec![1,2,0]).unwrap(); vbox.combine(vec![1,2,0]).unwrap();
assert_eq!(vbox.bound[0], Var::Heal); assert_eq!(vbox.bound[0], Var::Heal);
@ -601,7 +594,7 @@ mod tests {
#[test] #[test]
fn reclaim_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.bound = vec![Var::Strike];
vbox.reclaim(0).unwrap(); vbox.reclaim(0).unwrap();
assert_eq!(vbox.bits, 22); assert_eq!(vbox.bits, 22);