veloren_common_systems/
melee.rs

1use common::{
2    GroupTarget,
3    combat::{self, AttackOptions, AttackSource, AttackerInfo, TargetInfo},
4    comp::{
5        Alignment, Body, Buffs, CharacterState, Combo, Energy, Group, Health, Inventory, Mass,
6        Melee, Ori, PhysicsState, Player, Pos, Scale, Stats,
7        ability::Dodgeable,
8        agent::{Sound, SoundKind},
9        aura::EnteredAuras,
10        melee::MultiTarget,
11    },
12    consts::MAX_PICKUP_RANGE,
13    event::{self, EmitExt, EventBus},
14    event_emitters,
15    outcome::Outcome,
16    resources::Time,
17    terrain::TerrainGrid,
18    uid::{IdMaps, Uid},
19    util::{Dir, find_dist::Cylinder},
20    vol::ReadVol,
21};
22use common_ecs::{Job, Origin, Phase, System};
23use itertools::Itertools;
24use specs::{
25    Entities, Join, LendJoin, Read, ReadExpect, ReadStorage, SystemData, WriteStorage, shred,
26};
27use vek::*;
28
29event_emitters! {
30    struct ReadAttackEvents[AttackEmitters] {
31        health_change: event::HealthChangeEvent,
32        energy_change: event::EnergyChangeEvent,
33        poise_change: event::PoiseChangeEvent,
34        sound: event::SoundEvent,
35        mine_block: event::MineBlockEvent,
36        parry_hook: event::ParryHookEvent,
37        knockback: event::KnockbackEvent,
38        entity_attack_hook: event::EntityAttackedHookEvent,
39        combo_change: event::ComboChangeEvent,
40        buff: event::BuffEvent,
41        transform: event::TransformEvent,
42    }
43}
44
45#[derive(SystemData)]
46pub struct ReadData<'a> {
47    time: Read<'a, Time>,
48    terrain: ReadExpect<'a, TerrainGrid>,
49    id_maps: Read<'a, IdMaps>,
50    entities: Entities<'a>,
51    players: ReadStorage<'a, Player>,
52    uids: ReadStorage<'a, Uid>,
53    positions: ReadStorage<'a, Pos>,
54    orientations: ReadStorage<'a, Ori>,
55    alignments: ReadStorage<'a, Alignment>,
56    scales: ReadStorage<'a, Scale>,
57    bodies: ReadStorage<'a, Body>,
58    healths: ReadStorage<'a, Health>,
59    energies: ReadStorage<'a, Energy>,
60    inventories: ReadStorage<'a, Inventory>,
61    groups: ReadStorage<'a, Group>,
62    char_states: ReadStorage<'a, CharacterState>,
63    physic_states: ReadStorage<'a, PhysicsState>,
64    stats: ReadStorage<'a, Stats>,
65    combos: ReadStorage<'a, Combo>,
66    buffs: ReadStorage<'a, Buffs>,
67    entered_auras: ReadStorage<'a, EnteredAuras>,
68    events: ReadAttackEvents<'a>,
69    masses: ReadStorage<'a, Mass>,
70}
71
72/// This system is responsible for handling accepted inputs like moving or
73/// attacking
74#[derive(Default)]
75pub struct Sys;
76
77impl<'a> System<'a> for Sys {
78    type SystemData = (
79        ReadData<'a>,
80        WriteStorage<'a, Melee>,
81        Read<'a, EventBus<Outcome>>,
82    );
83
84    const NAME: &'static str = "melee";
85    const ORIGIN: Origin = Origin::Common;
86    const PHASE: Phase = Phase::Create;
87
88    fn run(_job: &mut Job<Self>, (read_data, mut melee_attacks, outcomes): Self::SystemData) {
89        let mut emitters = read_data.events.get_emitters();
90        let mut outcomes_emitter = outcomes.emitter();
91        let mut rng = rand::rng();
92
93        // Attacks
94        for (attacker, uid, pos, ori, melee_attack, body, scale) in (
95            &read_data.entities,
96            &read_data.uids,
97            &read_data.positions,
98            &read_data.orientations,
99            &mut melee_attacks,
100            &read_data.bodies,
101            read_data.scales.maybe(),
102        )
103            .join()
104        {
105            if melee_attack.applied && !melee_attack.sustained {
106                continue;
107            }
108            emitters.emit(event::SoundEvent {
109                sound: Sound::new(SoundKind::Melee, pos.0, 2.0, read_data.time.0),
110            });
111
112            melee_attack.applied = true;
113
114            // Scales
115            let eye_pos = pos.0 + Vec3::unit_z() * body.eye_height(scale.map_or(1.0, |s| s.0));
116            let scale = read_data.scales.get(attacker).map_or(1.0, |s| s.0);
117            let height = body.height() * scale;
118            // TODO: use Capsule Prisms instead of Cylinders
119            let rad = body.max_radius() * scale;
120
121            let melee_z = pos.0.z + 0.5 * body.height();
122            let melee_z_range = (melee_z - melee_attack.range)..(melee_z + melee_attack.range);
123
124            // Mine blocks broken by the attack
125            if let Some((block_pos, tool)) = melee_attack.break_block {
126                // Check distance to block
127                // TODO: Should this use melee attack range instead? Make sure voxygen supports
128                // it!
129                if eye_pos.distance_squared(block_pos.map(|e| e as f32 + 0.5))
130                    < MAX_PICKUP_RANGE.powi(2)
131                {
132                    emitters.emit(event::MineBlockEvent {
133                        entity: attacker,
134                        pos: block_pos,
135                        tool,
136                    });
137                }
138            }
139
140            // Go through all other entities
141            for (target, pos_b, health_b, body_b, uid_b) in (
142                &read_data.entities,
143                &read_data.positions,
144                &read_data.healths,
145                &read_data.bodies,
146                &read_data.uids,
147            )
148                .join()
149                .sorted_by_key(|(_, pos_b, _, _, _)| pos_b.0.distance_squared(pos.0) as u32)
150            {
151                // Unless the melee attack can hit multiple targets, stop after first hit
152                if melee_attack.multi_target.is_none()
153                    && !melee_attack.sustained
154                    && !melee_attack.hit_entities.is_empty()
155                {
156                    break;
157                }
158
159                // Skip already-hit entities to prevent duplicate hits
160                if melee_attack.hit_entities.contains(uid_b) {
161                    continue;
162                }
163
164                let look_dir = *ori.look_dir();
165
166                // 2D versions
167                let pos2 = Vec2::from(pos.0);
168                let pos_b2 = Vec2::<f32>::from(pos_b.0);
169                let ori2 = Vec2::from(look_dir);
170
171                // Scales
172                let scale_b = read_data.scales.get(target).map_or(1.0, |s| s.0);
173                let height_b = body_b.height() * scale_b;
174                let rad_b = body_b.max_radius() * scale_b;
175
176                // Check if entity is dodging
177                let target_dodging = match melee_attack.dodgeable {
178                    Dodgeable::Roll => read_data
179                        .char_states
180                        .get(target)
181                        .and_then(|cs| cs.roll_attack_immunities())
182                        .is_some_and(|i| i.melee),
183                    Dodgeable::Jump => read_data
184                        .physic_states
185                        .get(target)
186                        .is_some_and(|ps| ps.on_ground.is_none()),
187                    Dodgeable::No => false,
188                };
189
190                // Check if it is a hit
191                let hit = attacker != target
192                    && !health_b.is_dead
193                    // Spherical wedge shaped attack field
194                    && pos.0.distance_squared(pos_b.0) < (rad + rad_b + scale * melee_attack.range).powi(2)
195                    && (melee_z_range.contains(&pos_b.0.z) || melee_z_range.contains(&(pos_b.0.z + body_b.height())) || (pos_b.0.z..(pos_b.0.z + body_b.height())).contains(&melee_z))
196                    && ori2.angle_between(pos_b2 - pos2) < melee_attack.max_angle + (rad_b / pos2.distance(pos_b2)).atan();
197
198                //Check if target is behind a wall
199                let attacker_cylinder = Cylinder {
200                    center: pos.0 + (0.5 * height * Vec3::unit_z()),
201                    radius: rad,
202                    height,
203                };
204                let target_cylinder = Cylinder {
205                    center: pos_b.0 + (0.5 * height_b * Vec3::unit_z()),
206                    radius: rad_b,
207                    height: height_b,
208                };
209                let hit = hit
210                    && !is_blocked_by_wall(&read_data.terrain, attacker_cylinder, target_cylinder);
211
212                if hit {
213                    let allow_friendly_fire =
214                        combat::allow_friendly_fire(&read_data.entered_auras, attacker, target);
215                    // See if entities are in the same group
216                    let same_group = read_data
217                        .groups
218                        .get(attacker)
219                        .map(|group_a| Some(group_a) == read_data.groups.get(target))
220                        .unwrap_or(false);
221
222                    let target_group = if same_group {
223                        GroupTarget::InGroup
224                    } else {
225                        GroupTarget::OutOfGroup
226                    };
227
228                    let dir = Dir::new((pos_b.0 - pos.0).try_normalized().unwrap_or(look_dir));
229
230                    let attacker_info = Some(AttackerInfo {
231                        entity: attacker,
232                        uid: *uid,
233                        group: read_data.groups.get(attacker),
234                        energy: read_data.energies.get(attacker),
235                        combo: read_data.combos.get(attacker),
236                        inventory: read_data.inventories.get(attacker),
237                        stats: read_data.stats.get(attacker),
238                        mass: read_data.masses.get(attacker),
239                        pos: Some(pos.0),
240                    });
241
242                    let target_ori = read_data.orientations.get(target);
243                    let target_char_state = read_data.char_states.get(target);
244                    let target_info = TargetInfo {
245                        entity: target,
246                        uid: *uid_b,
247                        inventory: read_data.inventories.get(target),
248                        stats: read_data.stats.get(target),
249                        health: read_data.healths.get(target),
250                        pos: pos_b.0,
251                        ori: target_ori,
252                        char_state: target_char_state,
253                        energy: read_data.energies.get(target),
254                        buffs: read_data.buffs.get(target),
255                        mass: read_data.masses.get(target),
256                        player: read_data.players.get(target),
257                    };
258
259                    // PvP check
260                    let permit_pvp = combat::permit_pvp(
261                        &read_data.alignments,
262                        &read_data.players,
263                        &read_data.entered_auras,
264                        &read_data.id_maps,
265                        Some(attacker),
266                        target,
267                    );
268
269                    // Note: Don't use ori.look_vec() here, it leads to incorrect results for wide
270                    // angle melee attacks
271                    let precision_from_flank = combat::precision_mult_from_flank(
272                        (pos_b.0 - pos.0)
273                            .with_z(0.0)
274                            .try_normalized()
275                            .unwrap_or(ori.look_vec()),
276                        target_ori,
277                        melee_attack.precision_flank_multipliers,
278                        melee_attack.precision_flank_invert,
279                    );
280
281                    let precision_from_poise = {
282                        if let Some(CharacterState::Stunned(data)) = target_char_state {
283                            Some(
284                                combat::MAX_MELEE_POISE_PRECISION
285                                    * data.static_data.poise_state.damage_multiplier(),
286                            )
287                        } else {
288                            None
289                        }
290                    };
291
292                    let precision_mult = match (precision_from_flank, precision_from_poise) {
293                        (Some(a), Some(b)) => Some(a.max(b)),
294                        (Some(a), None) | (None, Some(a)) => Some(a),
295                        (None, None) => None,
296                    };
297
298                    let attack_options = AttackOptions {
299                        target_dodging,
300                        permit_pvp,
301                        allow_friendly_fire,
302                        target_group,
303                        precision_mult,
304                    };
305
306                    let strength =
307                        if let Some(MultiTarget::Scaling(scaling)) = melee_attack.multi_target {
308                            1.0 + melee_attack.hit_entities.len() as f32 * scaling
309                        } else {
310                            1.0
311                        };
312
313                    let mut is_applied = false;
314                    for offset in 0..melee_attack.simultaneous_hits {
315                        is_applied = melee_attack.attack.apply_attack(
316                            attacker_info,
317                            &target_info,
318                            dir,
319                            attack_options,
320                            strength,
321                            AttackSource::Melee,
322                            *read_data.time,
323                            &mut emitters,
324                            |o| outcomes_emitter.emit(o),
325                            &mut rng,
326                            offset as u64,
327                        ) || is_applied;
328                    }
329
330                    if is_applied {
331                        melee_attack.hit_entities.push(*uid_b);
332                    }
333                }
334            }
335        }
336    }
337}
338
339// Cast rays from the corners of an Axis Aligned Box centered at the attacker to
340// one centered at the target. We use multiple rays to ensure that target is at
341// least almost completly behind a wall.
342fn is_blocked_by_wall(terrain: &TerrainGrid, attacker: Cylinder, target: Cylinder) -> bool {
343    let attacker_v = Vec3::new(
344        attacker.radius / f32::sqrt(2.),
345        attacker.radius / f32::sqrt(2.),
346        attacker.height / 2.0,
347    );
348    let attacker_aabb = Aabb {
349        min: attacker.center - attacker_v,
350        max: attacker.center + attacker_v,
351    };
352
353    let target_v = Vec3::new(
354        target.radius / f32::sqrt(2.),
355        target.radius / f32::sqrt(2.),
356        target.height / 2.0,
357    );
358    let target_aabb = Aabb {
359        min: target.center - target_v,
360        max: target.center + target_v,
361    };
362
363    let mut segments = Vec::with_capacity(9);
364    segments.push(LineSegment3 {
365        start: attacker.center,
366        end: target.center,
367    });
368    for i in 0..2 {
369        for j in 0..2 {
370            for l in 0..2 {
371                let (x1, x2) = if i == 0 {
372                    (attacker_aabb.min.x, target_aabb.min.x)
373                } else {
374                    (attacker_aabb.max.x, target_aabb.max.x)
375                };
376
377                let (y1, y2) = if j == 0 {
378                    (attacker_aabb.min.y, target_aabb.min.y)
379                } else {
380                    (attacker_aabb.max.y, target_aabb.max.y)
381                };
382
383                let (z1, z2) = if l == 0 {
384                    (attacker_aabb.min.z, target_aabb.min.z)
385                } else {
386                    (attacker_aabb.max.z, target_aabb.max.z)
387                };
388
389                segments.push(LineSegment3 {
390                    start: Vec3::new(x1, y1, z1),
391                    end: Vec3::new(x2, y2, z2),
392                });
393            }
394        }
395    }
396
397    for &segment in segments.iter() {
398        let ray_dist = terrain
399            .ray(segment.start, segment.end)
400            .until(|b| b.is_filled())
401            .cast()
402            .0;
403        if let Some(ray_direction) = (segment.end - segment.start).try_normalized() {
404            let ray_end = segment.start + ray_dist * ray_direction;
405            let ray = LineSegment3 {
406                start: segment.start,
407                end: ray_end,
408            };
409            let proj = ray.projected_point(target_aabb.center());
410
411            if target_aabb.contains_point(proj) {
412                return false;
413            }
414        } else {
415            return false;
416        }
417    }
418    true
419}
veloren_common_systems/melee.rs

veloren_common_systems/
melee.rs
