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) #
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
Curse - (Debuff BB) Decrease damage dealt by target enemy
Plague Life - (Block BB) Apply dot debuff to attackers

14
server/ECONOMY.md
View File

@ -2,12 +2,12 @@
Items - Base colours / skills / specs and associated upgrades
### Sources of money
### Sources of money
- Start with money and gain income after each battle
- Higher income from winning
- Higher income from winning
- Selling items in inventory or equipped on character refunds
- Selling from inventory full refund
- Selling from inventory full refund
- Selling from charcter 50% refund
### Uses for money
@ -32,7 +32,7 @@ Base specs have a base 3 cost
Round #1
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 Empower (Buff + RR), (2 + 1 + 1) = (4) 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:
# 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 Empower (Buff + RR), (2 + 2 + 2) = (6) cost
Cryp #3 Attack, 2 cost
@ -60,8 +60,8 @@ Total cost - 14
### Philosophy of increasing item costs
- Two games will never feel exactly the same
- Costs change over rounds to diversify skill choice and gameplay
- Two games will never feel exactly the same
- Costs change over rounds to diversify skill choice and gameplay
- As optimal builds emerge the paths to reach them will change every game
- Rewarded for going (hipster) builds nobody else is trying
- Some reward for hoarding items in your inventory while they cheaper (hodl red)

14
server/README.md
View File

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

46
server/SPECS.md
View File

@ -1,10 +1,10 @@
### Specs ###
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
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)
- 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)
@ -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 #3 -> Give Stun -> Stun
Team Total (4 Red + 2 Basic gems)
Player Total (4 Red + 2 Basic gems)
### 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
`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
# Basic 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
# Basic Class Spec
@ -106,37 +106,37 @@ Generate by combining `Generic Spec (Basic Damage)` with respective RGB
# Red Damage (Dmg + RR)
Add 2 `red gems`
`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
# Blue Damage (Dmg + BB) #
Add 2 `blue gems`
`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
# Healing (Dmg + GG) #
Add 2 `green gems`
`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
# Red damage and healing (Dmg + RG)
Add 1 red 1 green gem
`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
# Red and blue damage (Dmg + RB)
Add 1 red and 1 blue gem
`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
# Blue damage and healing (Dmg + BG)
Add 1 blue and 1 green gem
`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
### Increased GreenLife Combos ###
@ -146,37 +146,37 @@ Generate by combining `Generic Spec (Basic GreenLife)` with respective RGB
# Increased % Red Life (Basic %HP + 2R)
Add 2 `red gems`
`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
# Increased % Red Life and GreenLife (Basic %HP + 1R1G)
Add 1 red 1 green gem
`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
# Increased % Blue Life (Basic %HP + 2B)
Add 2 `blue gems`
`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
# Increased % Blue Life and GreenLife (Basic %HP + 1B1G)
Add `1 blue and 1 green gems`
`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
# Increased % GreenLife (Basic %HP + 2G)
Add `2 green gems`
`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
# Increased % Blue and Red Life (Basic %HP + 1B1R)
Add `1 blue and 1 red gem`
`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
## Upgraded Attack Spec Combos
@ -185,31 +185,31 @@ Maximum +35% inc blue shield and 35% inc red shield
Cryp Requires `8 red gems`
Adds `6 red gems`
`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
# Improved Heal (Combine Heal + Healing Spec x 2)
Cryp Requires `8 green gems`
`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
# Increased Blast Damage (Combine Blast + Blue Spec x 2)
Cryp Requires `8 blue gems`
`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
# Increased Slay Damage (Combine Slay + Red Damage Spec + Healing Spec)
Cryp Requires `4 red 4 green gems`
`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
# Increased Banish Damage (Combine Slay + Red Damage Spec + Blue Damage Spec)
Cryp Requires `4 red 4 blue gems`
`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
## Other Combos
@ -217,7 +217,7 @@ Maximum 80% increased banish damage
# Increased % Red Speed (Basic Speed + 2R)
Add 2 red gems
`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
# Nature Affinity (Basic Class spec + 2R)

6
server/WORKLOG.md
View File

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

30
server/src/cryp.rs
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));

438
server/src/game.rs
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;
}

75
server/src/instance.rs
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");

20
server/src/mob.rs
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;
// }

71
server/src/player.rs
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();

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)]
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,

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 {
// 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
},
}
}

13
server/src/vbox.rs
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);