281 lines
11 KiB
Rust
281 lines
11 KiB
Rust
// Creature personality: every kind loves one room and cannot stand certain other kinds (bad
|
|
// mood, now and then a brawl - never to the death), and learns an ability at a certain level.
|
|
|
|
use crate::game::*;
|
|
use crate::map::*;
|
|
use crate::particles::{abgr, RING};
|
|
|
|
pub struct Persona {
|
|
pub likes: Kind,
|
|
pub hates: &'static [EK],
|
|
pub ability: Option<(u32, &'static str)>, // level, id (ability.<id>.name / .desc)
|
|
}
|
|
|
|
pub fn persona(k: EK) -> Persona {
|
|
let p = |likes, hates, ability| Persona { likes, hates, ability };
|
|
match k {
|
|
EK::Worker => p(Kind::Treasury, &[], Some((3, "dig"))),
|
|
EK::Kobold => p(Kind::Training, &[EK::Mage], Some((5, "dash"))),
|
|
EK::Spider => p(Kind::Farm, &[EK::Bat], Some((4, "web"))),
|
|
EK::Mage => p(Kind::Library, &[EK::Kobold, EK::Ogre], Some((6, "teleport"))),
|
|
EK::Ogre => p(Kind::Training, &[EK::Mage, EK::Cogling], Some((4, "stomp"))),
|
|
EK::Jailer => p(Kind::Torture, &[EK::Priestess], Some((7, "shackle"))),
|
|
EK::Priestess => p(Kind::Temple, &[EK::Jailer], Some((5, "pulse"))),
|
|
EK::Chainbreaker => p(Kind::Training, &[], Some((6, "whirl"))),
|
|
EK::Bat => p(Kind::Aerie, &[EK::Spider], Some((5, "shriek"))),
|
|
EK::Gargoyle => p(Kind::Torture, &[EK::Owl], Some((5, "stoneform"))),
|
|
EK::Owl => p(Kind::Library, &[EK::Gargoyle], Some((5, "volley"))),
|
|
EK::Wyrm => p(Kind::Treasury, &[EK::Bat], Some((7, "inferno"))),
|
|
EK::Cogling => p(Kind::Forge, &[EK::Ogre], Some((4, "bomb"))),
|
|
EK::Revenant => p(Kind::Graveyard, &[EK::Priestess], Some((5, "drain"))),
|
|
_ => p(Kind::Lair, &[], None),
|
|
}
|
|
}
|
|
|
|
// has this unit learned its ability?
|
|
pub fn knows(e: &Ent, id: &str) -> bool {
|
|
!e.hero && persona(e.kind).ability.map_or(false, |(lv, a)| a == id && e.level >= lv)
|
|
}
|
|
|
|
fn works_in(e: &Ent, g: &Game, kind: Kind) -> bool {
|
|
match e.job {
|
|
Job::Train(t) | Job::Study(t) | Job::Pray(t) | Job::Forge(t) | Job::Sleep(t) | Job::Eat(t) => g.map.t[t].kind == kind && e.path.is_empty(),
|
|
Job::Torment(_) => kind == Kind::Torture && e.path.is_empty(),
|
|
_ => g.map.t[e.tile()].kind == kind,
|
|
}
|
|
}
|
|
|
|
impl Game {
|
|
// every few seconds: the favourite room cheers up, hated company sours the mood
|
|
pub(crate) fn mood_check(&mut self, e: &mut Ent, dt: f32) {
|
|
e.mood_t -= dt;
|
|
if e.mood_t > 0.0 {
|
|
return;
|
|
}
|
|
e.mood_t = 4.0;
|
|
let p = persona(e.kind);
|
|
if works_in(e, self, p.likes) {
|
|
e.happy = (e.happy + 0.03).min(1.0);
|
|
}
|
|
if p.hates.is_empty() || matches!(e.job, Job::Brawl(_) | Job::Attack(_)) {
|
|
return;
|
|
}
|
|
let foe = self.ents.iter().position(|o| o.alive && !o.held && o.creature() && p.hates.contains(&o.kind) && (o.x - e.x).powi(2) + (o.y - e.y).powi(2) < 9.0);
|
|
let Some(j) = foe else { return };
|
|
e.happy -= 0.015;
|
|
let idle = |job: Job| matches!(job, Job::None | Job::Wander);
|
|
if idle(e.job) && idle(self.ents[j].job) && self.rng.f() < 0.15 {
|
|
// a brawl breaks out
|
|
let other = self.ents[j].id;
|
|
e.job = Job::Brawl(other);
|
|
e.timer = 0.0;
|
|
e.path.clear();
|
|
self.ents[j].job = Job::Brawl(e.id);
|
|
self.ents[j].timer = 0.0;
|
|
self.ents[j].path.clear();
|
|
let (a, b) = (st(e.kind).name, st(self.ents[j].kind).name);
|
|
self.msg("msg.brawl", vec![format!("@{}", a), format!("@{}", b)]);
|
|
}
|
|
}
|
|
|
|
// two creatures scuffling: they stop at 30% health, after eight seconds or when slapped
|
|
pub(crate) fn brawl(&mut self, e: &mut Ent, id: u32, dt: f32) {
|
|
e.timer += dt;
|
|
let Some(j) = self.find(id) else {
|
|
e.job = Job::None;
|
|
return;
|
|
};
|
|
let over = e.timer > 8.0 || e.hp < e.max_hp * 0.3 || self.ents[j].hp < self.ents[j].max_hp * 0.3 || !matches!(self.ents[j].job, Job::Brawl(_));
|
|
if over {
|
|
e.job = Job::None;
|
|
if self.ents[j].job == Job::Brawl(e.id) {
|
|
self.ents[j].job = Job::None;
|
|
}
|
|
e.happy -= 0.03;
|
|
return;
|
|
}
|
|
let (tx, ty) = (self.ents[j].x, self.ents[j].y);
|
|
let d = ((tx - e.x).powi(2) + (ty - e.y).powi(2)).sqrt();
|
|
if d > 1.1 {
|
|
if e.path.is_empty() || e.repath <= 0.0 {
|
|
e.repath = 0.8;
|
|
if let Some(p) = self.map.creature_path(flies(e.kind), e.tile(), idx(tx as i32, ty as i32)) {
|
|
e.path = p;
|
|
}
|
|
}
|
|
self.step_path(e, dt);
|
|
return;
|
|
}
|
|
e.path.clear();
|
|
e.working = true;
|
|
e.face = if tx > e.x { 1.0 } else { -1.0 };
|
|
if e.cd <= 0.0 {
|
|
e.cd = st(e.kind).interval;
|
|
let o = &mut self.ents[j];
|
|
o.hp = (o.hp - e.atk() * 0.4).max(o.max_hp * 0.25);
|
|
o.flash = 0.15;
|
|
self.fx(2, tx, ty, 0.0, 0.0, 0.25, 0xffffffff);
|
|
self.sfx(Sfx::MeleeHit, tx, ty);
|
|
}
|
|
}
|
|
|
|
// active abilities in a fight; true = used instead of a normal blow
|
|
pub(crate) fn use_ability(&mut self, e: &mut Ent, j: usize) -> bool {
|
|
if e.ab_cd > 0.0 || e.hero || e.side != 0 {
|
|
return false;
|
|
}
|
|
let (tx, ty) = (self.ents[j].x, self.ents[j].y);
|
|
let me = e.side();
|
|
let foes_near = |g: &Game, x: f32, y: f32, r: f32| -> Vec<usize> {
|
|
(0..g.ents.len()).filter(|&o| {
|
|
let u = &g.ents[o];
|
|
u.alive && !u.held && u.side() != me && u.captive == 0 && !u.chained && (u.x - x).powi(2) + (u.y - y).powi(2) < r * r
|
|
}).collect()
|
|
};
|
|
let hurt = |g: &mut Game, o: usize, dmg: f32| {
|
|
let u = &mut g.ents[o];
|
|
u.hp -= if u.shield > 0.0 { dmg * 0.5 } else { dmg };
|
|
u.flash = 0.15;
|
|
if u.hp <= 0.0 {
|
|
g.kill(o);
|
|
}
|
|
};
|
|
if knows(e, "stomp") || knows(e, "whirl") || knows(e, "shriek") {
|
|
let (r, cd) = if knows(e, "shriek") { (2.0, 10.0) } else if knows(e, "whirl") { (1.6, 7.0) } else { (1.6, 8.0) };
|
|
let hit = foes_near(self, e.x, e.y, r);
|
|
if hit.len() < 2 && !knows(e, "shriek") {
|
|
return false;
|
|
}
|
|
for o in hit {
|
|
if knows(e, "shriek") {
|
|
self.ents[o].stun = self.ents[o].stun.max(1.2);
|
|
} else {
|
|
if knows(e, "stomp") {
|
|
self.ents[o].stun = self.ents[o].stun.max(1.0);
|
|
}
|
|
let dmg = e.atk() * if knows(e, "whirl") { 0.8 } else { 0.6 };
|
|
hurt(self, o, dmg);
|
|
}
|
|
}
|
|
self.part(RING, (e.x, e.y, 0.05), (0.0, 0.0, 0.0), 0.4, abgr(230, 200, 150), r);
|
|
self.sfx(Sfx::Cannon, e.x, e.y);
|
|
e.ab_cd = cd;
|
|
e.cd = st(e.kind).interval;
|
|
return true;
|
|
}
|
|
if knows(e, "bomb") {
|
|
self.shot(e.x, e.y, 0.5, tx, ty, 0.2, 0.4, 0xff303030);
|
|
self.style_last_fx(crate::particles::ST_CANNON);
|
|
for o in foes_near(self, tx, ty, 1.3) {
|
|
hurt(self, o, 40.0);
|
|
}
|
|
e.ab_cd = 10.0;
|
|
e.cd = st(e.kind).interval;
|
|
return true;
|
|
}
|
|
if knows(e, "dash") {
|
|
let d = ((tx - e.x).powi(2) + (ty - e.y).powi(2)).sqrt();
|
|
if d > 2.5 && d < 6.0 && self.los(e.x, e.y, tx, ty) {
|
|
let (nx, ny) = (tx - (tx - e.x) / d * 0.8, ty - (ty - e.y) / d * 0.8);
|
|
if self.map.walk(nx as i32, ny as i32) {
|
|
self.fx(0, e.x, e.y, nx, ny, 0.15, 0xffffffff);
|
|
e.x = nx;
|
|
e.y = ny;
|
|
e.path.clear();
|
|
hurt(self, j, e.atk() * 1.2);
|
|
e.ab_cd = 8.0;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
// abilities that work on their own (escape, protection, healing)
|
|
pub(crate) fn passive_abilities(&mut self, e: &mut Ent) {
|
|
if e.ab_cd > 0.0 || e.hero || e.side != 0 {
|
|
return;
|
|
}
|
|
let fighting = matches!(e.job, Job::Attack(_));
|
|
if knows(e, "teleport") && fighting && e.hp < e.max_hp * 0.3 {
|
|
let (cx, cy) = self.map.core;
|
|
let to = e.bed.map(|b| (xy(b).0 as f32 + 0.5, xy(b).1 as f32 + 0.5)).unwrap_or((cx as f32 - 0.5, cy as f32 + 1.5));
|
|
self.fx(7, e.x, e.y, 0.0, 0.0, 0.6, 0xffff66cc);
|
|
e.x = to.0;
|
|
e.y = to.1;
|
|
e.path.clear();
|
|
e.job = Job::None;
|
|
self.fx(7, e.x, e.y, 0.0, 0.0, 0.6, 0xffff66cc);
|
|
self.sfx(Sfx::Summon, e.x, e.y);
|
|
e.ab_cd = 30.0;
|
|
} else if knows(e, "stoneform") && e.hp < e.max_hp * 0.4 {
|
|
e.shield = 6.0;
|
|
e.ab_cd = 25.0;
|
|
self.fx(7, e.x, e.y, 0.0, 0.0, 0.6, 0xffa0a0a0);
|
|
} else if knows(e, "pulse") {
|
|
let hurt: Vec<usize> = (0..self.ents.len()).filter(|&o| {
|
|
let u = &self.ents[o];
|
|
u.alive && !u.held && u.creature() && u.hp < u.max_hp * 0.7 && (u.x - e.x).powi(2) + (u.y - e.y).powi(2) < 9.0
|
|
}).collect();
|
|
if hurt.len() >= 2 {
|
|
for o in hurt {
|
|
let u = &mut self.ents[o];
|
|
u.hp = (u.hp + 30.0).min(u.max_hp);
|
|
let (ux, uy) = (u.x, u.y);
|
|
self.fx(4, ux, uy, 0.0, 0.0, 0.8, 0xff60ff80);
|
|
}
|
|
self.part(RING, (e.x, e.y, 0.05), (0.0, 0.0, 0.0), 0.5, abgr(120, 255, 140), 3.0);
|
|
e.ab_cd = 12.0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn hated_neighbours_brawl_but_nobody_dies() {
|
|
let mut g = Game::new(8, 64, 64);
|
|
let (cx, cy) = g.map.core;
|
|
let a = g.spawn(EK::Mage, false, cx as f32 - 0.5, cy as f32 + 0.5, 2);
|
|
let b = g.spawn(EK::Ogre, false, cx as f32 - 0.5, cy as f32 + 1.5, 2);
|
|
for id in [a, b] {
|
|
let j = g.find(id).unwrap();
|
|
g.ents[j].settled = true;
|
|
}
|
|
let mut brawled = false;
|
|
for _ in 0..(20 * 120) {
|
|
g.update(0.05);
|
|
brawled |= g.ents.iter().any(|e| matches!(e.job, Job::Brawl(_)));
|
|
for id in [a, b] {
|
|
let j = g.find(id).unwrap();
|
|
g.ents[j].hunger = 0.0;
|
|
g.ents[j].energy = 1.0;
|
|
if !matches!(g.ents[j].job, Job::Brawl(_)) {
|
|
g.ents[j].job = Job::None;
|
|
g.ents[j].think = 99.0;
|
|
}
|
|
}
|
|
}
|
|
assert!(brawled, "they quarrel");
|
|
assert!(g.find(a).is_some() && g.find(b).is_some(), "nobody died");
|
|
}
|
|
|
|
#[test]
|
|
fn ogres_learn_to_stomp() {
|
|
let mut g = Game::new(8, 64, 64);
|
|
let (cx, cy) = g.map.core;
|
|
let o = g.spawn(EK::Ogre, false, cx as f32 - 0.5, cy as f32 + 1.5, 4);
|
|
for k in 0..2 {
|
|
g.spawn(EK::Knight, true, cx as f32 - 0.5 + k as f32 * 0.3, cy as f32 + 2.3, 1);
|
|
}
|
|
let j = g.find(o).unwrap();
|
|
let mut e = g.ents[j].clone();
|
|
let target = g.ents.iter().position(|x| x.hero).unwrap();
|
|
assert!(g.use_ability(&mut e, target));
|
|
assert!(g.ents.iter().filter(|x| x.hero).all(|x| x.stun > 0.0));
|
|
}
|
|
}
|