1061 lines
29 KiB
Rust
Executable File
1061 lines
29 KiB
Rust
Executable File
use uuid::Uuid;
|
|
use rand::prelude::*;
|
|
|
|
use std::iter;
|
|
|
|
// Db Commons
|
|
use serde_cbor::{from_slice, to_vec};
|
|
use postgres::transaction::Transaction;
|
|
use failure::Error;
|
|
use failure::err_msg;
|
|
|
|
use account::Account;
|
|
use rpc::{GameStateParams, GameSkillParams, GamePveParams, GamePvpParams, GameTargetParams, GameJoinParams};
|
|
use cryp::{Cryp, cryp_get};
|
|
use skill::{Skill, Cast};
|
|
|
|
pub type Log = Vec<String>;
|
|
|
|
#[derive(Debug,Clone,Serialize,Deserialize)]
|
|
pub struct Team {
|
|
id: Uuid,
|
|
cryps: Vec<Cryp>,
|
|
}
|
|
|
|
impl Team {
|
|
pub fn new(account: Uuid) -> Team {
|
|
return Team {
|
|
id: account,
|
|
cryps: vec![],
|
|
};
|
|
}
|
|
|
|
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 set_cryps(&mut self, cryps: Vec<Cryp>) -> &mut Team {
|
|
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,
|
|
Skill,
|
|
Target,
|
|
Resolve,
|
|
Finish,
|
|
}
|
|
|
|
#[derive(Debug,Clone,Serialize,Deserialize)]
|
|
pub struct Game {
|
|
pub id: Uuid,
|
|
pub team_size: usize,
|
|
pub team_num: usize,
|
|
pub teams: Vec<Team>,
|
|
pub is_pve: bool,
|
|
pub phase: Phase,
|
|
pub stack: Vec<Cast>,
|
|
pub resolved: Vec<Cast>,
|
|
pub log: Vec<String>,
|
|
}
|
|
|
|
impl Game {
|
|
fn new() -> Game {
|
|
return Game {
|
|
id: Uuid::new_v4(),
|
|
team_size: 0,
|
|
team_num: 0,
|
|
teams: vec![],
|
|
is_pve: true,
|
|
phase: Phase::Start,
|
|
stack: vec![],
|
|
resolved: vec![],
|
|
log: vec![],
|
|
};
|
|
}
|
|
|
|
fn set_team_num(&mut self, size: usize) -> &mut Game {
|
|
self.team_num = size;
|
|
self
|
|
}
|
|
|
|
fn set_team_size(&mut self, size: usize) -> &mut Game {
|
|
self.team_size = size;
|
|
self
|
|
}
|
|
|
|
fn set_pve(&mut self, pve: bool) -> &mut Game {
|
|
self.is_pve = pve;
|
|
self
|
|
}
|
|
|
|
fn already_joined(&self, team_id: Uuid) -> bool {
|
|
self.teams.iter().any(|t| t.id == team_id)
|
|
}
|
|
|
|
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"));
|
|
}
|
|
|
|
if self.teams.iter().any(|t| t.id == team.id) {
|
|
return Err(err_msg("team already in game"));
|
|
}
|
|
|
|
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));
|
|
|
|
self.teams.push(team);
|
|
|
|
Ok(self)
|
|
}
|
|
|
|
// handle missing team properly
|
|
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),
|
|
}
|
|
}
|
|
|
|
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) => {
|
|
return team.cryps.iter_mut().find(|c| c.id == id);
|
|
},
|
|
None => panic!("cryp not in game"),
|
|
};
|
|
}
|
|
|
|
fn all_cryps(&self) -> Vec<Cryp> {
|
|
self.teams.clone()
|
|
.into_iter()
|
|
.flat_map(
|
|
|t| t.cryps
|
|
.into_iter())
|
|
.collect::<Vec<Cryp>>()
|
|
}
|
|
|
|
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());
|
|
},
|
|
None => panic!("cryp not in game"),
|
|
};
|
|
|
|
self
|
|
}
|
|
|
|
fn joinable(&self) -> bool {
|
|
self.phase == Phase::Start
|
|
}
|
|
|
|
fn can_start(&self) -> bool {
|
|
self.teams.len() == self.team_num
|
|
}
|
|
|
|
fn start(&mut self) -> &mut Game {
|
|
self.log.push("Game starting...".to_string());
|
|
|
|
self.skill_phase_start();
|
|
self
|
|
}
|
|
|
|
fn skill_phase_start(&mut self) -> &mut Game {
|
|
self.log.push("<Skill Phase>".to_string());
|
|
|
|
if ![Phase::Start, Phase::Resolve].contains(&self.phase) {
|
|
panic!("game not in Resolve or start phase");
|
|
}
|
|
|
|
self.phase = Phase::Skill;
|
|
|
|
self.stack.clear();
|
|
|
|
if self.is_pve {
|
|
self.pve_add_skills();
|
|
}
|
|
|
|
self
|
|
}
|
|
|
|
fn pve_add_skills(&mut self) -> &mut Game {
|
|
{
|
|
let mob_team_id = Uuid::nil();
|
|
let mobs = self.team_by_id(mob_team_id).clone();
|
|
|
|
// TODO attack multiple players based on some criteria
|
|
let player_team_id = self.teams.iter().find(|t| t.id != mob_team_id).unwrap().id;
|
|
for mob in &mobs.cryps {
|
|
// doesn't matter if the cryp can't cast
|
|
self.add_skill(mob_team_id, mob.id, Some(player_team_id), Skill::Attack).ok();
|
|
}
|
|
}
|
|
|
|
self
|
|
}
|
|
|
|
fn add_skill(&mut self, team_id: Uuid, source_cryp_id: Uuid, target_team_id: Option<Uuid>, skill: Skill) -> Result<Uuid, Error> {
|
|
if self.phase != Phase::Skill {
|
|
return Err(err_msg("game not in skill phase"));
|
|
}
|
|
|
|
{
|
|
let cryp = match self.cryp_by_id(source_cryp_id) {
|
|
Some(c) => c,
|
|
None => return Err(err_msg("cryp not in team")),
|
|
};
|
|
|
|
if cryp.is_ko() {
|
|
return Err(err_msg("cryp is ko"));
|
|
}
|
|
|
|
// check the cryp has the skill
|
|
if !cryp.knows(skill) {
|
|
return Err(err_msg("cryp does not have that skill"));
|
|
}
|
|
|
|
if cryp.skill_on_cd(skill).is_some() {
|
|
return Err(err_msg("abiltity on cooldown"));
|
|
}
|
|
|
|
if skill.self_targeting() && target_team_id.is_some() {
|
|
return Err(err_msg("skill is self targeting"));
|
|
}
|
|
|
|
if !skill.self_targeting() && target_team_id.is_none() {
|
|
return Err(err_msg("skill requires a target"));
|
|
}
|
|
|
|
// check here as well so uncastable spells don't go on the stack
|
|
if !skill.castable(&cryp) {
|
|
return Err(err_msg("cryp cannot cast that skill"));
|
|
}
|
|
}
|
|
|
|
|
|
// replace cryp skill
|
|
if let Some(s) = self.stack.iter_mut().position(|s| s.source_cryp_id == source_cryp_id) {
|
|
self.stack.remove(s);
|
|
}
|
|
|
|
let skill = Cast::new(source_cryp_id, team_id, target_team_id, skill);
|
|
let skill_id = skill.id;
|
|
self.stack.push(skill);
|
|
|
|
return Ok(skill_id);
|
|
}
|
|
|
|
fn skill_phase_finished(&self) -> bool {
|
|
self.teams.iter()
|
|
// for every team
|
|
.all(|t| self.stack.iter()
|
|
// the number of skills they have cast
|
|
.filter(|s| s.source_team_id == t.id).collect::<Vec<&Cast>>()
|
|
// should equal the number required this turn
|
|
.len() == t.skills_required()
|
|
)
|
|
}
|
|
|
|
fn target_phase_start(&mut self) -> &mut Game {
|
|
assert!(self.skill_phase_finished());
|
|
self.log.push("<Target Phase>".to_string());
|
|
|
|
if self.phase != Phase::Skill {
|
|
panic!("game not in skill phase");
|
|
}
|
|
|
|
self.phase = Phase::Target;
|
|
|
|
if self.is_pve {
|
|
self.pve_add_targets();
|
|
}
|
|
|
|
// all cryps are stunned or otherwise inactive
|
|
if self.target_phase_finished() {
|
|
self.resolve_phase_start();
|
|
}
|
|
|
|
self
|
|
}
|
|
|
|
fn pve_add_targets(&mut self) -> &mut Game {
|
|
{
|
|
let mob_team_id = Uuid::nil();
|
|
let mobs = self.team_by_id(mob_team_id).clone();
|
|
let target_id = mobs.cryps.iter().find(|c| !c.is_ko()).map(|c| c.id).unwrap();
|
|
println!("targeting {:?}", target_id);
|
|
// TODO attack multiple players based on some criteria
|
|
for incoming_skill_id in self.stack.clone().iter()
|
|
.filter(|s| s.target_cryp_id.is_none() && s.target_team_id == mob_team_id)
|
|
.map(|s| s.id) {
|
|
self.add_target(mob_team_id, target_id, incoming_skill_id).unwrap();
|
|
}
|
|
}
|
|
|
|
self
|
|
}
|
|
|
|
// targets can only be added by the owner of the team
|
|
fn add_target(&mut self, team_id: Uuid, cryp_id: Uuid, skill_id: Uuid) -> Result<&mut Cast, Error> {
|
|
if self.phase != Phase::Target {
|
|
return Err(err_msg("game not in target phase"));
|
|
}
|
|
|
|
{
|
|
// whose team is this?
|
|
let team = self.team_by_id(team_id);
|
|
|
|
// is the target in the team?
|
|
match team.cryp_by_id(cryp_id) {
|
|
Some(c) => c,
|
|
None => return Err(err_msg("cryp not in team")),
|
|
};
|
|
}
|
|
|
|
// set the target
|
|
let cast = match self.stack.iter_mut().find(|s| s.id == skill_id) {
|
|
Some(c) => c,
|
|
None => return Err(err_msg("skill_id not found")),
|
|
};
|
|
|
|
if cast.skill.self_targeting() {
|
|
return Err(err_msg("skill is self targeting"));
|
|
}
|
|
|
|
if cast.target_team_id != team_id {
|
|
return Err(err_msg("you cannot target that skill"));
|
|
}
|
|
|
|
Ok(cast.set_target(cryp_id))
|
|
}
|
|
|
|
fn target_phase_finished(&self) -> bool {
|
|
self.stack.iter().all(|s| s.target_cryp_id.is_some())
|
|
}
|
|
|
|
// requires no input
|
|
// just do it
|
|
fn resolve_phase_start(&mut self) -> &mut Game {
|
|
if self.phase != Phase::Target {
|
|
panic!("game not in target phase");
|
|
}
|
|
assert!(self.target_phase_finished());
|
|
|
|
self.phase = Phase::Resolve;
|
|
self.log.push("<Resolve Phase>".to_string());
|
|
|
|
self.resolve_skills()
|
|
}
|
|
|
|
fn resolve_skills(&mut self) -> &mut Game {
|
|
if self.phase != Phase::Resolve {
|
|
panic!("game not in Resolve phase");
|
|
}
|
|
|
|
// find their statuses with ticks
|
|
let mut ticks = self.all_cryps()
|
|
.iter()
|
|
.flat_map(
|
|
|c| c.effects
|
|
.iter()
|
|
.cloned()
|
|
.filter_map(|e| e.tick))
|
|
.collect::<Vec<Cast>>();
|
|
|
|
// add them to the stack
|
|
self.stack.append(&mut ticks);
|
|
|
|
self.stack.sort_unstable_by_key(|s| s.skill.speed());
|
|
self.stack.reverse();
|
|
|
|
// update the stack with the resolved skills
|
|
self.stack = self.stack.clone().iter_mut().map(|skill| {
|
|
println!("{:?} resolving ", skill);
|
|
let mut source = self.cryp_by_id(skill.source_cryp_id).unwrap().clone();
|
|
let mut target = self.cryp_by_id(skill.target_cryp_id.unwrap()).unwrap().clone();
|
|
|
|
skill.set_resolution(&mut source, &mut target);
|
|
self.resolved.push(skill.clone());
|
|
|
|
self.update_cryp(&mut source);
|
|
self.update_cryp(&mut target);
|
|
|
|
return skill.clone();
|
|
}).collect::<Vec<Cast>>();
|
|
|
|
// now Resolve has all been assigned
|
|
// handle cooldowns and statuses
|
|
self.progress_durations();
|
|
|
|
if self.is_finished() {
|
|
return self.finish()
|
|
}
|
|
|
|
self.skill_phase_start()
|
|
}
|
|
|
|
fn progress_durations(&mut self) -> &mut Game {
|
|
for mut cryp in self.all_cryps() {
|
|
// println!("progressing durations for {:?}", cryp.name);
|
|
|
|
if cryp.is_ko() {
|
|
continue;
|
|
}
|
|
|
|
// only reduce cooldowns if no cd was used
|
|
// have to borrow self for the skill check
|
|
{
|
|
let skill = self.stack.iter_mut().find(|s| s.source_cryp_id == cryp.id).unwrap();
|
|
if skill.used_cooldown() {
|
|
cryp.skill_set_cd(skill.skill);
|
|
} else {
|
|
cryp.reduce_cooldowns();
|
|
}
|
|
}
|
|
|
|
// always reduce durations
|
|
cryp.reduce_effect_durations(&mut self.log);
|
|
self.update_cryp(&mut cryp);
|
|
}
|
|
|
|
self
|
|
}
|
|
|
|
fn is_finished(&self) -> bool {
|
|
self.teams.iter().any(|t| t.cryps.iter().all(|c| c.is_ko()))
|
|
}
|
|
|
|
fn finish(&mut self) -> &mut Game {
|
|
self.phase = Phase::Finish;
|
|
self.log.push(format!("Game finished."));
|
|
|
|
{
|
|
let winner = self.teams.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.")),
|
|
};
|
|
}
|
|
|
|
self.stack.clear();
|
|
|
|
self
|
|
}
|
|
}
|
|
|
|
pub fn game_skill(params: GameSkillParams, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {
|
|
let query = "
|
|
SELECT *
|
|
FROM games
|
|
WHERE id = $1
|
|
";
|
|
|
|
let result = tx
|
|
.query(query, &[¶ms.game_id])?;
|
|
|
|
let returned = match result.iter().next() {
|
|
Some(row) => row,
|
|
None => return Err(err_msg("game not found")),
|
|
};
|
|
|
|
// tells from_slice to cast into a cryp
|
|
let game_bytes: Vec<u8> = returned.get("data");
|
|
let mut game = from_slice::<Game>(&game_bytes)?;
|
|
|
|
if game.phase != Phase::Skill {
|
|
return Err(err_msg("game not in skill phase"))
|
|
}
|
|
|
|
game.add_skill(account.id, params.cryp_id, params.target_team_id, params.skill)?;
|
|
|
|
if game.skill_phase_finished() {
|
|
game.target_phase_start();
|
|
}
|
|
|
|
game_update(&game, tx)?;
|
|
|
|
Ok(game)
|
|
}
|
|
|
|
pub fn game_target(params: GameTargetParams, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {
|
|
let query = "
|
|
SELECT *
|
|
FROM games
|
|
WHERE id = $1
|
|
";
|
|
|
|
let result = tx
|
|
.query(query, &[¶ms.game_id])?;
|
|
|
|
let returned = match result.iter().next() {
|
|
Some(row) => row,
|
|
None => return Err(err_msg("game not found")),
|
|
};
|
|
|
|
// tells from_slice to cast into a cryp
|
|
let game_bytes: Vec<u8> = returned.get("data");
|
|
let mut game = from_slice::<Game>(&game_bytes)?;
|
|
|
|
game.add_target(account.id, params.cryp_id, params.skill_id)?;
|
|
|
|
if game.target_phase_finished() {
|
|
game.resolve_phase_start();
|
|
}
|
|
|
|
game_update(&game, tx)?;
|
|
|
|
Ok(game)
|
|
}
|
|
|
|
pub fn game_new(game: &Game, tx: &mut Transaction) -> Result<(), Error> {
|
|
let game_bytes = to_vec(&game)?;
|
|
|
|
let query = "
|
|
INSERT INTO games (id, joinable, data)
|
|
VALUES ($1, $2, $3)
|
|
RETURNING id;
|
|
";
|
|
|
|
let result = tx
|
|
.query(query, &[&game.id, &game.joinable(), &game_bytes])?;
|
|
|
|
result.iter().next().ok_or(format_err!("no game written"))?;
|
|
|
|
println!("{:?} wrote game", game.id);
|
|
|
|
return Ok(());
|
|
}
|
|
|
|
pub fn game_state(params: GameStateParams, tx: &mut Transaction, _account: &Account) -> Result<Game, Error> {
|
|
return game_get(tx, params.id)
|
|
}
|
|
|
|
pub fn game_get(tx: &mut Transaction, id: Uuid) -> Result<Game, Error> {
|
|
let query = "
|
|
SELECT *
|
|
FROM games
|
|
WHERE id = $1
|
|
";
|
|
|
|
let result = tx
|
|
.query(query, &[&id])?;
|
|
|
|
let returned = match result.iter().next() {
|
|
Some(row) => row,
|
|
None => return Err(err_msg("game not found")),
|
|
};
|
|
|
|
// tells from_slice to cast into a cryp
|
|
let game_bytes: Vec<u8> = returned.get("data");
|
|
let game = from_slice::<Game>(&game_bytes)?;
|
|
|
|
return Ok(game);
|
|
}
|
|
|
|
/// write a row for every cryp in a team when added to a battle
|
|
pub fn players_write(team: &Team, game_id: Uuid, tx: &mut Transaction) -> Result<(), Error> {
|
|
// pve
|
|
if !team.id.is_nil() {
|
|
for cryp in &team.cryps {
|
|
let id = Uuid::new_v4();
|
|
|
|
let query = "
|
|
INSERT INTO players (id, game, cryp, account)
|
|
VALUES ($1, $2, $3, $4)
|
|
RETURNING id, account;
|
|
";
|
|
|
|
let result = tx
|
|
.query(query, &[&id, &game_id, &cryp.id, &team.id])?;
|
|
|
|
let _returned = result.iter().next().expect("no row written");
|
|
|
|
println!("wrote player entry game:{:?} cryp:{:?} account:{:?}", game_id, cryp.id, team.id);
|
|
}
|
|
}
|
|
|
|
return Ok(());
|
|
}
|
|
|
|
pub fn game_update(game: &Game, tx: &mut Transaction) -> Result<(), Error> {
|
|
let game_bytes = to_vec(&game)?;
|
|
|
|
let query = "
|
|
UPDATE games
|
|
SET data = $1, joinable = $2
|
|
WHERE id = $3
|
|
RETURNING id, data;
|
|
";
|
|
|
|
let result = tx
|
|
.query(query, &[&game_bytes, &game.joinable(), &game.id])?;
|
|
|
|
result.iter().next().ok_or(format_err!("game {:?} could not be written", game))?;
|
|
|
|
println!("{:?} wrote game", game.id);
|
|
|
|
return Ok(());
|
|
}
|
|
|
|
fn generate_mob(lvl: u8) -> Cryp {
|
|
let mut rng = thread_rng();
|
|
|
|
// rng panics on min == max
|
|
let mob_lvl: u8 = match lvl {
|
|
1 => 1,
|
|
_ => rng.gen_range(lvl.saturating_sub(2), lvl)
|
|
};
|
|
|
|
return Cryp::new()
|
|
.named(&"bamboo basher".to_string())
|
|
.level(mob_lvl)
|
|
.create();
|
|
|
|
}
|
|
|
|
pub fn game_pve(params: GamePveParams, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {
|
|
let cryps = params.cryp_ids
|
|
.iter()
|
|
.map(|id| cryp_get(tx, *id, account.id))
|
|
.collect::<Result<Vec<Cryp>, Error>>()?;
|
|
|
|
if cryps.len() > 3 {
|
|
return Err(err_msg("team size too large (3 max)"));
|
|
}
|
|
|
|
// create the game
|
|
let mut game = Game::new();
|
|
// let game_id = game.id;
|
|
|
|
game
|
|
.set_pve(true)
|
|
.set_team_num(2)
|
|
.set_team_size(cryps.len());
|
|
|
|
// create the mob team
|
|
let mut mob_team = Team::new(Uuid::nil());
|
|
let mob_lvl = cryps.iter().max_by_key(|c| c.lvl).unwrap().lvl;
|
|
let mobs = iter::repeat_with(|| generate_mob(mob_lvl).set_account(Uuid::nil()))
|
|
.take(cryps.len())
|
|
.collect::<Vec<Cryp>>();
|
|
|
|
// add the players
|
|
let mut plr_team = Team::new(account.id);
|
|
plr_team
|
|
.set_cryps(cryps);
|
|
|
|
mob_team
|
|
.set_cryps(mobs);
|
|
|
|
game
|
|
.team_add(plr_team)?
|
|
.team_add(mob_team)?;
|
|
|
|
game.start();
|
|
|
|
// persist
|
|
game_new(&game, tx)?;
|
|
// players_write(&game.team_by_id(account.id), game_id, tx)?;
|
|
|
|
Ok(game)
|
|
}
|
|
|
|
pub fn game_pvp(params: GamePvpParams, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {
|
|
let cryps = params.cryp_ids
|
|
.iter()
|
|
.map(|id| cryp_get(tx, *id, account.id))
|
|
.collect::<Result<Vec<Cryp>, Error>>()?;
|
|
|
|
// create the game
|
|
let mut game = Game::new();
|
|
let game_id = game.id;
|
|
|
|
game
|
|
.set_pve(false)
|
|
.set_team_num(2)
|
|
.set_team_size(cryps.len());
|
|
|
|
// create the initiators team
|
|
let mut team = Team::new(account.id);
|
|
team.set_cryps(cryps);
|
|
|
|
game.team_add(team)?;
|
|
|
|
// persist
|
|
game_new(&game, tx)?;
|
|
players_write(&game.team_by_id(account.id), game_id, tx)?;
|
|
|
|
Ok(game)
|
|
}
|
|
|
|
pub fn game_join(params: GameJoinParams, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {
|
|
let mut game = game_get(tx, params.game_id)?;
|
|
|
|
// rejoining a game from the FE list
|
|
if game.already_joined(account.id) {
|
|
return Ok(game);
|
|
}
|
|
|
|
// ok actually adding a new team
|
|
let game_id = game.id;
|
|
|
|
let cryps = params.cryp_ids
|
|
.iter()
|
|
.map(|id| cryp_get(tx, *id, account.id))
|
|
.collect::<Result<Vec<Cryp>, Error>>()?;
|
|
|
|
if cryps.len() != game.team_size {
|
|
return Err(format_err!("incorrect team size. ({:?})", game.team_size));
|
|
}
|
|
|
|
let mut team = Team::new(account.id);
|
|
team.set_cryps(cryps);
|
|
game.team_add(team)?;
|
|
|
|
if game.can_start() {
|
|
game.start();
|
|
}
|
|
|
|
game_update(&game, tx)?;
|
|
players_write(&game.team_by_id(account.id), game_id, tx)?;
|
|
|
|
Ok(game)
|
|
}
|
|
|
|
pub fn game_joinable_list(tx: &mut Transaction, _account: &Account) -> Result<Vec<Game>, Error> {
|
|
let query = "
|
|
SELECT games.data
|
|
FROM games
|
|
WHERE joinable;
|
|
";
|
|
|
|
let result = tx
|
|
.query(query, &[])?;
|
|
|
|
let games: Result<Vec<Game>, _> = result.iter().map(|row| {
|
|
let cryp_bytes: Vec<u8> = row.get(0);
|
|
from_slice::<Game>(&cryp_bytes)
|
|
}).collect();
|
|
|
|
// catch any errors
|
|
if games.is_err() {
|
|
return Err(err_msg("could not deserialize a game"));
|
|
}
|
|
|
|
// now unwrap is safe
|
|
return Ok(games.unwrap());
|
|
}
|
|
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use game::*;
|
|
use cryp::*;
|
|
|
|
fn create_test_game() -> Game {
|
|
let x = Cryp::new()
|
|
.named(&"pronounced \"creeep\"".to_string())
|
|
.level(8)
|
|
.learn(Skill::TestStun)
|
|
.learn(Skill::TestTouch)
|
|
.learn(Skill::TestBlock)
|
|
.learn(Skill::TestDrain)
|
|
.learn(Skill::Block)
|
|
.create();
|
|
|
|
let y = Cryp::new()
|
|
.named(&"lemongrass tea".to_string())
|
|
.level(8)
|
|
.learn(Skill::TestStun)
|
|
.learn(Skill::TestTouch)
|
|
.learn(Skill::TestBlock)
|
|
.learn(Skill::TestDrain)
|
|
.learn(Skill::Block)
|
|
.create();
|
|
|
|
let mut game = Game::new();
|
|
|
|
game
|
|
.set_team_num(2)
|
|
.set_team_size(1)
|
|
.set_pve(false);
|
|
|
|
let x_team_id = Uuid::new_v4();
|
|
let mut x_team = Team::new(x_team_id);
|
|
x_team
|
|
.set_cryps(vec![x]);
|
|
|
|
let y_team_id = Uuid::new_v4();
|
|
let mut y_team = Team::new(y_team_id);
|
|
y_team
|
|
.set_cryps(vec![y]);
|
|
|
|
game
|
|
.team_add(x_team).unwrap()
|
|
.team_add(y_team).unwrap();
|
|
|
|
assert!(game.can_start());
|
|
|
|
game.start();
|
|
|
|
return game;
|
|
}
|
|
|
|
// fn create_2v2_test_game() -> Game {
|
|
// let mut i = Cryp::new()
|
|
// .named(&"pretaliate".to_string())
|
|
// .level(8)
|
|
// .learn(Skill::Attack)
|
|
// .create();
|
|
|
|
// let mut j = Cryp::new()
|
|
// .named(&"poy sian".to_string())
|
|
// .level(8)
|
|
// .learn(Skill::Attack)
|
|
// .create();
|
|
|
|
// let mut x = Cryp::new()
|
|
// .named(&"pronounced \"creeep\"".to_string())
|
|
// .level(8)
|
|
// .learn(Skill::Attack)
|
|
// .create();
|
|
|
|
// let mut y = Cryp::new()
|
|
// .named(&"lemongrass tea".to_string())
|
|
// .level(8)
|
|
// .learn(Skill::Attack)
|
|
// .create();
|
|
|
|
// let mut game = Game::new();
|
|
|
|
// game
|
|
// .set_team_num(2)
|
|
// .set_team_size(2)
|
|
// .set_pve(false);
|
|
|
|
// let x_team_id = Uuid::new_v4();
|
|
// let mut x_team = Team::new(x_team_id);
|
|
// x_team
|
|
// .set_cryps(vec![x]);
|
|
|
|
// let y_team_id = Uuid::new_v4();
|
|
// let mut y_team = Team::new(y_team_id);
|
|
// y_team
|
|
// .set_cryps(vec![y]);
|
|
|
|
// game
|
|
// .team_add(x_team).unwrap()
|
|
// .team_add(y_team).unwrap();
|
|
|
|
// assert!(game.can_start());
|
|
|
|
// game.start();
|
|
|
|
// return game;
|
|
// }
|
|
|
|
#[test]
|
|
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_cryp = x_team.cryps[0].clone();
|
|
let y_cryp = y_team.cryps[0].clone();
|
|
|
|
let x_attack_id = game.add_skill(x_team.id, x_cryp.id, Some(y_team.id), Skill::Attack).unwrap();
|
|
let y_attack_id = game.add_skill(y_team.id, y_cryp.id, Some(x_team.id), Skill::Attack).unwrap();
|
|
|
|
assert!(game.skill_phase_finished());
|
|
|
|
game.target_phase_start();
|
|
|
|
game.add_target(x_team.id, x_cryp.id, y_attack_id).unwrap();
|
|
game.add_target(y_team.id, y_cryp.id, x_attack_id).unwrap();
|
|
|
|
assert!(game.target_phase_finished());
|
|
|
|
game.resolve_phase_start();
|
|
|
|
assert!([Phase::Skill, Phase::Finish].contains(&game.phase));
|
|
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
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_cryp = x_team.cryps[0].clone();
|
|
let y_cryp = y_team.cryps[0].clone();
|
|
|
|
let x_stun_id = game.add_skill(x_team.id, x_cryp.id, Some(y_team.id), Skill::TestStun).unwrap();
|
|
let y_attack_id = game.add_skill(y_team.id, y_cryp.id, Some(x_team.id), Skill::TestTouch).unwrap();
|
|
|
|
assert!(game.skill_phase_finished());
|
|
game.target_phase_start();
|
|
|
|
game.add_target(x_team.id, x_cryp.id, y_attack_id).unwrap();
|
|
game.add_target(y_team.id, y_cryp.id, x_stun_id).unwrap();
|
|
|
|
assert!(game.target_phase_finished());
|
|
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].is_stunned());
|
|
assert!(game.team_by_id(y_team.id).skills_required() == 0);
|
|
}
|
|
|
|
#[test]
|
|
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_cryp = x_team.cryps[0].clone();
|
|
let y_cryp = y_team.cryps[0].clone();
|
|
|
|
let x_stun_id = game.add_skill(x_team.id, x_cryp.id, Some(y_team.id), Skill::TestTouch).unwrap();
|
|
let y_attack_id = game.add_skill(y_team.id, y_cryp.id, Some(x_team.id), Skill::TestTouch).unwrap();
|
|
|
|
game.target_phase_start();
|
|
game.add_target(x_team.id, x_cryp.id, y_attack_id).unwrap();
|
|
game.add_target(y_team.id, y_cryp.id, x_stun_id).unwrap();
|
|
|
|
game.resolve_phase_start();
|
|
|
|
// should auto progress back to skill phase
|
|
assert!(game.phase == Phase::Skill);
|
|
|
|
// after 1 turn block should be off cooldown
|
|
assert!(game.team_by_id(y_team.id).cryps[0].skill_on_cd(Skill::Block).is_none());
|
|
assert!(game.team_by_id(x_team.id).cryps[0].skill_on_cd(Skill::Block).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, None, Skill::Block).unwrap();
|
|
let _y_block_id = game.add_skill(y_team.id, y_cryp.id, None, Skill::Block).unwrap();
|
|
|
|
game.target_phase_start();
|
|
|
|
assert!(game.team_by_id(y_team.id).cryps[0].skill_on_cd(Skill::Block).is_some());
|
|
assert!(game.team_by_id(x_team.id).cryps[0].skill_on_cd(Skill::Block).is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn block_test() {
|
|
let mut game = create_test_game();
|
|
|
|
let x_team = game.teams[0].clone();
|
|
let y_team = game.teams[1].clone();
|
|
|
|
let x_cryp = x_team.cryps[0].clone();
|
|
let y_cryp = y_team.cryps[0].clone();
|
|
|
|
// ensure that you can't pass a target for a block
|
|
assert!(game.add_skill(x_team.id, x_cryp.id, Some(y_cryp.id), Skill::TestBlock).is_err());
|
|
|
|
let x_block_id = game.add_skill(x_team.id, x_cryp.id, None, Skill::TestBlock).unwrap();
|
|
let y_attack_id = game.add_skill(y_team.id, y_cryp.id, Some(x_team.id), Skill::TestStun).unwrap();
|
|
|
|
game.target_phase_start();
|
|
|
|
// ensure you can't target a self targeting skill
|
|
assert!(game.add_target(y_team.id, y_cryp.id, x_block_id).is_err());
|
|
|
|
// ensure you can't target another team's skills
|
|
assert!(game.add_target(x_team.id, y_cryp.id, y_attack_id).is_err());
|
|
|
|
game.add_target(x_team.id, x_cryp.id, y_attack_id).unwrap();
|
|
|
|
game.resolve_phase_start();
|
|
|
|
// should not be stunned because of block
|
|
assert!(game.team_by_id(x_team.id).cryps[0].is_stunned() == false);
|
|
}
|
|
|
|
#[test]
|
|
fn drain_test() {
|
|
let mut game = create_test_game();
|
|
|
|
let x_team = game.teams[0].clone();
|
|
let y_team = game.teams[1].clone();
|
|
|
|
let x_cryp = x_team.cryps[0].clone();
|
|
let y_cryp = y_team.cryps[0].clone();
|
|
|
|
let x_drain_id = game.add_skill(x_team.id, x_cryp.id, Some(y_team.id), Skill::TestDrain).unwrap();
|
|
let y_touch_id = game.add_skill(y_team.id, y_cryp.id, Some(x_team.id), Skill::TestTouch).unwrap();
|
|
|
|
game.target_phase_start();
|
|
|
|
game.add_target(x_team.id, x_cryp.id, y_touch_id).unwrap();
|
|
game.add_target(y_team.id, y_cryp.id, x_drain_id).unwrap();
|
|
|
|
game.resolve_phase_start();
|
|
|
|
game.add_skill(x_team.id, x_cryp.id, None, Skill::TestBlock).unwrap();
|
|
game.add_skill(y_team.id, y_cryp.id, None, Skill::TestBlock).unwrap();
|
|
|
|
game.target_phase_start();
|
|
|
|
assert!(game.resolved.iter().any(|r| r.skill == Skill::DrainTick));
|
|
|
|
// println!("{:#?}", game);
|
|
}
|
|
|
|
#[test]
|
|
fn ko_pve_test() {
|
|
let mut game = create_test_game();
|
|
|
|
let x_team = game.teams[0].clone();
|
|
let y_team = game.teams[1].clone();
|
|
|
|
let x_cryp = x_team.cryps[0].clone();
|
|
let y_cryp = y_team.cryps[0].clone();
|
|
|
|
let x_attack_id = game.add_skill(x_team.id, x_cryp.id, Some(y_team.id), Skill::Attack).unwrap();
|
|
let y_attack_id = game.add_skill(y_team.id, y_cryp.id, Some(x_team.id), Skill::Attack).unwrap();
|
|
|
|
assert!(game.skill_phase_finished());
|
|
|
|
game.target_phase_start();
|
|
|
|
game.add_target(x_team.id, x_cryp.id, y_attack_id).unwrap();
|
|
game.add_target(y_team.id, y_cryp.id, x_attack_id).unwrap();
|
|
|
|
assert!(game.target_phase_finished());
|
|
|
|
game.resolve_phase_start();
|
|
|
|
assert!([Phase::Skill, Phase::Finish].contains(&game.phase));
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
}
|