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

Merge branch 'master' of ssh://cryps.gg:40022/~/cryps

Browse Source
This commit is contained in:
Mashy 2018-12-17 18:02:19 +10:00
commit 2b1fc76f58
4 changed files with 154 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

162
client/src/scenes/constants.js
View File

@ -27,6 +27,7 @@ const statsX = () => crypListWidth() + gameListWidth();
const statsKnownX = () => Math.floor(statsX() + statsWidth() / 4); const statsKnownX = () => Math.floor(statsX() + statsWidth() / 4);
const statsLearnableX = () => Math.floor(statsX() + statsWidth() / 2); const statsLearnableX = () => Math.floor(statsX() + statsWidth() / 2);
const statsTextMargin = () => 24; const statsTextMargin = () => 24;
const statsLearnableMargin = () => 12;
const logWidth = () => combatWidth(); const logWidth = () => combatWidth();
const logHeight = () => combatHeight() * 0.3; const logHeight = () => combatHeight() * 0.3;
@ -37,6 +38,7 @@ const logX = () => combatWidth() * 0.6;
module.exports = { module.exports = {
TEXT: { TEXT: {
NORMAL: { fontFamily: 'monospace', fontSize: 16, color: '#ffffff' }, NORMAL: { fontFamily: 'monospace', fontSize: 16, color: '#ffffff' },
LEARNABLE: { fontFamily: 'monospace', fontSize: 12, color: '#ffffff' },
HEADER: { fontFamily: 'monospace', fontSize: 24, color: '#ffffff', fontStyle: 'bold' }, HEADER: { fontFamily: 'monospace', fontSize: 24, color: '#ffffff', fontStyle: 'bold' },
}, },
@ -63,6 +65,7 @@ module.exports = {
knownX: statsKnownX, knownX: statsKnownX,
learnableX: statsLearnableX, learnableX: statsLearnableX,
textMargin: statsTextMargin, textMargin: statsTextMargin,
learnableMargin: statsLearnableMargin,
}, },
COMBAT: { COMBAT: {
@ -117,77 +120,94 @@ module.exports = {
SKILLS: { SKILLS: {
LEARNABLE: [ LEARNABLE: [
'Attack', {
name: 'Attack',
// ----------------- description: 'a fast physical attack with phys dmg',
// Nature },
// ----------------- {
'Block', // reduce dmg name: 'Block',
'Parry', // avoid all dmg description: 'decreases incoming physical damage for 1T',
'Snare', },
{
// 'Paralyse', name: 'Parry',
description: 'prevents all physical damage for 1T',
// 'Strangle', // physical dot and disable },
{
'Stun', name: 'Evade',
'Throw', description: 'gives a chance to evade physical damage for 1T',
'Evade', // actively evade },
'Evasion', // adds evasion to cryp {
name: 'Snare',
description: 'prevents physical skills from being used for 2T',
// ----------------- },
// Technology {
// ----------------- name: 'Stun',
// 'Replicate', description: 'physical skill that prevents target cryp from using any skills',
// 'Swarm', },
// 'Orbit', {
// 'Repair', name: 'Evasion',
// 'Scan', // track? description: 'grants Evade effect to a cryp',
},
// ----------------- {
// Nonviolence name: 'Heal',
// ----------------- description: 'heal a cryp with spell dmg',
'Heal', },
'Triage', // hot {
// 'TriageTick', name: 'Triage',
// 'Charm', description: 'grants a spell dmg based healing over time buff',
// 'Calm', },
// 'Rez', {
name: 'Throw',
// ------------------- description: 'stuns and makes the target take increased physical damage',
// Destruction },
// ------------------- {
'Blast', name: 'Blast',
'Amplify', description: 'blast the target with magic damage',
'Decay', // dot },
// 'DecayTick', // dot {
'Drain', name: 'Amplify',
// 'DrainTick', description: 'increase the magic damage dealt by a cryp',
'Curse', },
// 'Plague', // aoe dot {
// 'Ruin', // aoe name: 'Decay',
description: 'afflict a cryp with a spell damage based damage over time debuff',
// ----------------- },
// Purity {
// ----------------- name: 'Drain',
'Empower', description: 'drain hp from target cryp with a spell damage based debuff',
// 'Slay', },
'Shield', {
'Silence', name: 'Curse',
// 'Inquiry', description: 'target cryp takes increased magic damage',
'Purify', },
'Purge', {
// '// Precision', name: 'Empower',
description: 'increase the physical damage dealt by a cryp',
// ----------------- },
// Chaos {
// ----------------- name: 'Shield',
'Banish', // disables everything, incoming and outgoing description: 'grants immunity to magical skills to target cryp',
'Hex', // stun but as a spell },
// 'Fear', {
// 'Taunt', name: 'Silence',
// 'Pause', // speed slow description: 'prevent target cryp from casting magical skills',
},
{
name: 'Purify',
description: 'remove physical debuffs from target cryp',
},
{
name: 'Purge',
description: 'remove magical debuffs from target cryp',
},
{
name: 'Banish',
description: 'target cryp is prevented from casting any skills and taking any damage',
},
{
name: 'Hex',
description: 'magical based skill that prevents target cryp from using any skills',
},
], ],
}, },
}; };

3
client/src/scenes/cryp.page.js
View File

@ -33,10 +33,11 @@ class CrypPage extends Phaser.GameObjects.Group {
}; };
const learnable = (skill, i) => { const learnable = (skill, i) => {
console.log(skill);
const SKILL_X = STATS.learnableX(); const SKILL_X = STATS.learnableX();
const SKILL_Y = (i * TEXT_MARGIN) + STATS.y() + TEXT_MARGIN; const SKILL_Y = (i * TEXT_MARGIN) + STATS.y() + TEXT_MARGIN;
const text = scene.add.text(SKILL_X, SKILL_Y, skill, TEXT.NORMAL) const text = scene.add.text(SKILL_X, SKILL_Y, `${skill.name}\n${skill.description}`, TEXT.NORMAL)
.setInteractive(); .setInteractive();
text.on('pointerdown', () => { text.on('pointerdown', () => {

6
client/src/scenes/statsheet.skills.js
View File

@ -76,12 +76,12 @@ class Skills extends Phaser.Scene {
this.learnSkills = this.add.group(); this.learnSkills = this.add.group();
const learnable = (skill, i) => { const learnable = (skill, i) => {
const SKILL_X = X_ORIG_LEARN; const SKILL_X = X_ORIG_LEARN;
const SKILL_Y = Y_ORIG + (i * TEXT_MARGIN) + TEXT_MARGIN; const SKILL_Y = Y_ORIG + (i * STATS.learnableMargin() * 3) + TEXT_MARGIN;
this.learnSkills.add(this.add.text(SKILL_X, SKILL_Y, skill, TEXT.NORMAL) this.learnSkills.add(this.add.text(SKILL_X, SKILL_Y, [skill.name, skill.description], TEXT.LEARNABLE)
.setInteractive() .setInteractive()
.on('pointerdown', () => { .on('pointerdown', () => {
this.registry.get('ws').sendCrypLearn(cryp.id, skill); this.registry.get('ws').sendCrypLearn(cryp.id, skill.name);
})); }));
}; };

105
server/src/skill.rs
View File

@ -196,9 +196,12 @@ impl Effect {
pub fn modifications(&self) -> Vec<Stat> { pub fn modifications(&self) -> Vec<Stat> {
match self { match self {
Effect::Amplify => vec![Stat::SpellDmg],
Effect::Empower => vec![Stat::PhysDmg], Effect::Empower => vec![Stat::PhysDmg],
Effect::Vulnerable => vec![Stat::PhysDmg],
Effect::Block => vec![Stat::PhysDmg], Effect::Block => vec![Stat::PhysDmg],
Effect::Amplify => vec![Stat::SpellDmg],
Effect::Curse => vec![Stat::SpellDmg],
_ => vec![], _ => vec![],
} }
} }
@ -208,10 +211,16 @@ impl Effect {
// and OR with base stat // and OR with base stat
pub fn apply(&self, value: u64) -> u64 { pub fn apply(&self, value: u64) -> u64 {
match self { match self {
Effect::Block => value >> 1, Effect::Empower => value << 1,
Effect::Amplify => value << 1, Effect::Vulnerable => value << 1,
Effect::Empower => value << 1, Effect::Block => value >> 1,
_ => panic!("{:?} does not have a mod effect", self),
Effect::Amplify => value << 1,
Effect::Curse => value << 1,
_ => {
println!("{:?} does not have a mod effect", self);
return value;
},
} }
} }
@ -260,6 +269,33 @@ impl Effect {
Effect::Ko => Category::Ko, Effect::Ko => Category::Ko,
} }
} }
pub fn duration(&self) -> u8 {
match self {
Effect::Evasion => 1,
Effect::Block => 1,
Effect::Parry => 1,
Effect::Stun => 2,
Effect::Vulnerable => 2,
Effect::Snare => 1,
Effect::Empower => 2,
Effect::Decay => 2,
Effect::Drain => 2,
Effect::Triage => 2,
Effect::Amplify => 2,
Effect::Silence => 2,
_ => {
println!("{:?} does not have a duration", self);
return 1;
},
}
}
} }
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
@ -723,31 +759,6 @@ impl Skill {
} }
} }
pub fn duration(&self) -> u8 {
match self {
Skill::Evade => 1,
Skill::Stun => 2,
Skill::Block => 1,
Skill::Empower => 2,
Skill::Decay => 3,
Skill::Drain => 3,
Skill::Triage => 3,
Skill::Amplify => 2,
Skill::Silence => 3,
Skill::TestBlock => 1,
Skill::TestParry => 1,
Skill::TestStun => 2,
_ => {
println!("{:?} does not have a duration", self);
return 2;
},
}
}
pub fn self_targeting(&self) -> bool { pub fn self_targeting(&self) -> bool {
match self { match self {
Skill::Block => true, Skill::Block => true,
@ -782,7 +793,7 @@ fn attack(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Res
} }
fn stun(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn stun(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration(), tick: None }; let stun = CrypEffect { effect: Effect::Stun, duration: Effect::Stun.duration(), tick: None };
let immunity = target.immune(Skill::Stun); let immunity = target.immune(Skill::Stun);
let immune = immunity.immune; let immune = immunity.immune;
@ -802,8 +813,8 @@ fn stun(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Reso
} }
fn throw(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn throw(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration(), tick: None }; let stun = CrypEffect { effect: Effect::Stun, duration: Effect::Stun.duration(), tick: None };
let vulnerable = CrypEffect { effect: Effect::Vulnerable, duration: Skill::Stun.duration(), tick: None }; let vulnerable = CrypEffect { effect: Effect::Vulnerable, duration: Effect::Vulnerable.duration(), tick: None };
let immunity = target.immune(Skill::Throw); let immunity = target.immune(Skill::Throw);
let immune = immunity.immune; let immune = immunity.immune;
@ -832,7 +843,7 @@ fn throw(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Res
fn block(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn block(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let block = CrypEffect { effect: Effect::Block, duration: Skill::Block.duration(), tick: None }; let block = CrypEffect { effect: Effect::Block, duration: Effect::Block.duration(), tick: None };
let immunity = target.immune(Skill::Block); let immunity = target.immune(Skill::Block);
let immune = immunity.immune; let immune = immunity.immune;
@ -852,7 +863,7 @@ fn block(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Res
} }
fn parry(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn parry(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let parry = CrypEffect { effect: Effect::Parry, duration: Skill::Parry.duration(), tick: None }; let parry = CrypEffect { effect: Effect::Parry, duration: Effect::Parry.duration(), tick: None };
let immunity = target.immune(Skill::Parry); let immunity = target.immune(Skill::Parry);
let immune = immunity.immune; let immune = immunity.immune;
@ -873,7 +884,7 @@ fn parry(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Res
fn evade(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn evade(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let evade = CrypEffect { effect: Effect::Evasion, duration: Skill::Evade.duration(), tick: None }; let evade = CrypEffect { effect: Effect::Evasion, duration: Effect::Evasion.duration(), tick: None };
let immunity = target.immune(Skill::Evade); let immunity = target.immune(Skill::Evade);
let immune = immunity.immune; let immune = immunity.immune;
@ -898,7 +909,7 @@ fn evade_roll() -> bool {
} }
fn snare(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn snare(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let snare = CrypEffect { effect: Effect::Snare, duration: Skill::Snare.duration(), tick: None }; let snare = CrypEffect { effect: Effect::Snare, duration: Effect::Snare.duration(), tick: None };
let immunity = target.immune(Skill::Snare); let immunity = target.immune(Skill::Snare);
let immune = immunity.immune; let immune = immunity.immune;
@ -918,7 +929,7 @@ fn snare(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Res
} }
fn empower(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn empower(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let empower = CrypEffect { effect: Effect::Empower, duration: Skill::Empower.duration(), tick: None }; let empower = CrypEffect { effect: Effect::Empower, duration: Effect::Empower.duration(), tick: None };
let immunity = target.immune(Skill::Empower); let immunity = target.immune(Skill::Empower);
let immune = immunity.immune; let immune = immunity.immune;
@ -963,7 +974,7 @@ fn heal(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resol
fn triage(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn triage(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let triage = CrypEffect { let triage = CrypEffect {
effect: Effect::Triage, effect: Effect::Triage,
duration: Skill::Triage.duration(), duration: Effect::Triage.duration(),
tick: Some(Cast::new_tick(cryp, target, Skill::TriageTick)), tick: Some(Cast::new_tick(cryp, target, Skill::TriageTick)),
}; };
let immunity = target.immune(Skill::Triage); let immunity = target.immune(Skill::Triage);
@ -1026,7 +1037,7 @@ fn blast(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Reso
} }
fn amplify(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn amplify(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let amplify = CrypEffect { effect: Effect::Amplify, duration: Skill::Amplify.duration(), tick: None }; let amplify = CrypEffect { effect: Effect::Amplify, duration: Effect::Amplify.duration(), tick: None };
let immunity = target.immune(Skill::Amplify); let immunity = target.immune(Skill::Amplify);
let immune = immunity.immune; let immune = immunity.immune;
@ -1048,7 +1059,7 @@ fn amplify(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> R
fn decay(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn decay(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let decay = CrypEffect { let decay = CrypEffect {
effect: Effect::Decay, effect: Effect::Decay,
duration: Skill::Decay.duration(), duration: Effect::Decay.duration(),
tick: Some(Cast::new_tick(cryp, target, Skill::DecayTick)), tick: Some(Cast::new_tick(cryp, target, Skill::DecayTick)),
}; };
let immunity = target.immune(Skill::Empower); let immunity = target.immune(Skill::Empower);
@ -1090,7 +1101,7 @@ fn decay_tick(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) ->
} }
fn hex(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn hex(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let hex = CrypEffect { effect: Effect::Hex, duration: Skill::Hex.duration(), tick: None }; let hex = CrypEffect { effect: Effect::Hex, duration: Effect::Hex.duration(), tick: None };
let immunity = target.immune(Skill::Hex); let immunity = target.immune(Skill::Hex);
let immune = immunity.immune; let immune = immunity.immune;
@ -1110,7 +1121,7 @@ fn hex(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resol
} }
fn curse(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn curse(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let curse = CrypEffect { effect: Effect::Curse, duration: Skill::Curse.duration(), tick: None }; let curse = CrypEffect { effect: Effect::Curse, duration: Effect::Curse.duration(), tick: None };
let immunity = target.immune(Skill::Curse); let immunity = target.immune(Skill::Curse);
let immune = immunity.immune; let immune = immunity.immune;
@ -1132,7 +1143,7 @@ fn curse(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Res
fn drain(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn drain(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let drain = CrypEffect { let drain = CrypEffect {
effect: Effect::Drain, effect: Effect::Drain,
duration: Skill::Drain.duration(), duration: Effect::Drain.duration(),
tick: Some(Cast::new_tick(cryp, target, Skill::DrainTick)), tick: Some(Cast::new_tick(cryp, target, Skill::DrainTick)),
}; };
let immunity = target.immune(Skill::Drain); let immunity = target.immune(Skill::Drain);
@ -1184,7 +1195,7 @@ fn drain_tick(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) ->
} }
fn shield(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn shield(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let shield = CrypEffect { effect: Effect::Shield, duration: Skill::Shield.duration(), tick: None }; let shield = CrypEffect { effect: Effect::Shield, duration: Effect::Shield.duration(), tick: None };
let immunity = target.immune(Skill::Shield); let immunity = target.immune(Skill::Shield);
let immune = immunity.immune; let immune = immunity.immune;
@ -1204,7 +1215,7 @@ fn shield(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Re
} }
fn silence(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn silence(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let silence = CrypEffect { effect: Effect::Silence, duration: Skill::Silence.duration(), tick: None }; let silence = CrypEffect { effect: Effect::Silence, duration: Effect::Silence.duration(), tick: None };
let immunity = target.immune(Skill::Silence); let immunity = target.immune(Skill::Silence);
let immune = immunity.immune; let immune = immunity.immune;
@ -1256,7 +1267,7 @@ fn purify(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Re
} }
fn banish(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn banish(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let banish = CrypEffect { effect: Effect::Banish, duration: Skill::Banish.duration(), tick: None }; let banish = CrypEffect { effect: Effect::Banish, duration: Effect::Banish.duration(), tick: None };
let immunity = target.immune(Skill::Banish); let immunity = target.immune(Skill::Banish);
let immune = immunity.immune; let immune = immunity.immune;