keleusma 0.2.2

Total Functional Stream Processor with definitive WCET and WCMU verification, targeting no_std + alloc embedded scripting
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! Combat resolution. The host samples the d20 roll, dispatches
//! the combat virtual machine for the hit and damage decision,
//! and applies the result. The rules live in
//! `examples/scripts/rogue/rogue_combat.kel`. This module is
//! the thin glue between the world state and the script.

use crate::ai::AiPool;
use crate::bestiary;
use crate::items::ItemKind;
use crate::world::{Item, World};

/// Result of an attack. Used by the message-log formatter and
/// by post-attack book keeping.
#[derive(Clone, Copy, Debug)]
pub struct AttackOutcome {
    pub hit: bool,
    pub damage: i32,
    pub critical: bool,
}

/// Resolve the player attacking the monster at `monster_idx`.
/// The monster's hit points are reduced by the damage dealt; if
/// the result is zero or less, the monster is removed from the
/// world and gold equal to its score is added to the player's
/// score-as-gold counter.
pub fn player_attacks(world: &mut World, ai: &mut AiPool, monster_idx: usize) -> AttackOutcome {
    let monster_kind_idx = world.monsters[monster_idx].kind as usize;
    let kind = bestiary::kind(monster_kind_idx);
    let roll = (world.rng_next() % 20) as i64 + 1;
    let (hit_kind, damage) = ai
        .dispatch_combat(
            world.player.skill as i64,
            world.player.weapon_damage() as i64,
            kind.evasion as i64,
            kind.armor as i64,
            roll,
        )
        .unwrap_or((0, 0));
    if hit_kind == 0 {
        return AttackOutcome {
            hit: false,
            damage: 0,
            critical: false,
        };
    }
    let damage = damage as i32;
    let critical = hit_kind == 2;
    let kind_name = kind.name;
    let score = kind.score;
    let new_hp = world.monsters[monster_idx].hp - damage;
    if new_hp <= 0 {
        let mx = world.monsters[monster_idx].x;
        let my = world.monsters[monster_idx].y;
        let drop_chance = kind.corpse_drop_chance;
        world.monsters.swap_remove(monster_idx);
        world.player.gold += score;
        world.push_message(format!("You slay the {}.", kind_name));
        if drop_chance > 0 {
            let roll = (world.rng_next() % 100) as u8;
            if roll < drop_chance {
                world.items.push(Item {
                    kind: ItemKind::Corpse,
                    subtype: monster_kind_idx as u8,
                    x: mx,
                    y: my,
                });
            }
        }
    } else {
        world.monsters[monster_idx].hp = new_hp;
        let label = if critical { "critical hit" } else { "hit" };
        world.push_message(format!(
            "You {} the {} for {} damage.",
            label, kind_name, damage
        ));
    }
    AttackOutcome {
        hit: true,
        damage,
        critical,
    }
}

/// Resolve a monster at `monster_idx` attacking the player. The
/// player's hit points are reduced. The caller checks for player
/// death.
pub fn monster_attacks_player(
    world: &mut World,
    ai: &mut AiPool,
    monster_idx: usize,
) -> AttackOutcome {
    let monster_kind_idx = world.monsters[monster_idx].kind as usize;
    let kind = bestiary::kind(monster_kind_idx);
    let roll = (world.rng_next() % 20) as i64 + 1;
    let (hit_kind, damage) = ai
        .dispatch_combat(
            kind.skill as i64,
            kind.damage as i64,
            world.player.level as i64,
            world.player.armor_value() as i64,
            roll,
        )
        .unwrap_or((0, 0));
    if hit_kind == 0 {
        let name = kind.name;
        world.push_message(format!("The {} misses.", name));
        return AttackOutcome {
            hit: false,
            damage: 0,
            critical: false,
        };
    }
    let damage = damage as i32;
    let critical = hit_kind == 2;
    world.player.hp -= damage;
    let name = kind.name;
    let label = if critical { "crits" } else { "hits" };
    world.push_message(format!("The {} {} you for {} damage.", name, label, damage));
    AttackOutcome {
        hit: true,
        damage,
        critical,
    }
}