1use std::f32::consts::PI;
2
3use common::{
4 GroupTarget,
5 combat::{self, AttackOptions, AttackSource, AttackerInfo, TargetInfo},
6 comp::{
7 Alignment, Beam, Body, Buffs, CharacterState, Combo, Energy, Group, Health, Inventory,
8 Mass, Ori, PhysicsState, Player, Pos, Scale, Stats,
9 ability::Dodgeable,
10 agent::{Sound, SoundKind},
11 aura::EnteredAuras,
12 },
13 event::{self, EmitExt, EventBus},
14 event_emitters,
15 outcome::Outcome,
16 resources::{DeltaTime, Time},
17 terrain::TerrainGrid,
18 uid::{IdMaps, Uid},
19 vol::ReadVol,
20};
21use common_ecs::{Job, Origin, ParMode, Phase, System};
22use rand::Rng;
23use rayon::iter::ParallelIterator;
24use specs::{
25 Entities, LendJoin, ParJoin, 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 parry_hook: event::ParryHookEvent,
36 knockback: event::KnockbackEvent,
37 entity_attack_hoow: event::EntityAttackedHookEvent,
38 combo_change: event::ComboChangeEvent,
39 buff: event::BuffEvent,
40 }
41}
42
43#[derive(SystemData)]
44pub struct ReadData<'a> {
45 entities: Entities<'a>,
46 players: ReadStorage<'a, Player>,
47 time: Read<'a, Time>,
48 dt: Read<'a, DeltaTime>,
49 terrain: ReadExpect<'a, TerrainGrid>,
50 id_maps: Read<'a, IdMaps>,
51 cached_spatial_grid: Read<'a, common::CachedSpatialGrid>,
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 inventories: ReadStorage<'a, Inventory>,
60 groups: ReadStorage<'a, Group>,
61 energies: ReadStorage<'a, Energy>,
62 stats: ReadStorage<'a, Stats>,
63 combos: ReadStorage<'a, Combo>,
64 character_states: ReadStorage<'a, CharacterState>,
65 physics_states: ReadStorage<'a, PhysicsState>,
66 buffs: ReadStorage<'a, Buffs>,
67 entered_auras: ReadStorage<'a, EnteredAuras>,
68 outcomes: Read<'a, EventBus<Outcome>>,
69 events: ReadAttackEvents<'a>,
70 masses: ReadStorage<'a, Mass>,
71}
72
73#[derive(Default)]
75pub struct Sys;
76impl<'a> System<'a> for Sys {
77 type SystemData = (ReadData<'a>, WriteStorage<'a, Beam>);
78
79 const NAME: &'static str = "beam";
80 const ORIGIN: Origin = Origin::Common;
81 const PHASE: Phase = Phase::Create;
82
83 fn run(job: &mut Job<Self>, (read_data, mut beams): Self::SystemData) {
84 let mut outcomes_emitter = read_data.outcomes.emitter();
85
86 (
87 &read_data.positions,
88 &read_data.orientations,
89 read_data.character_states.maybe(),
90 &mut beams,
91 )
92 .lend_join()
93 .for_each(|(pos, ori, char_state, mut beam)| {
94 if read_data.time.0 % beam.tick_dur.0 < read_data.dt.0 as f64 {
96 let (hit_entities, hit_durations) = beam.hit_entities_and_durations();
97 hit_durations.retain(|e, _| hit_entities.contains(e));
98 for entity in hit_entities {
99 *hit_durations.entry(*entity).or_insert(0) += 1;
100 }
101 beam.hit_entities.clear();
102 }
103 let (offset, target_dir) = char_state
105 .and_then(|char_state| {
106 if let CharacterState::BasicBeam(data) = char_state {
107 Some(data)
108 } else {
109 None
110 }
111 })
112 .map_or((Vec3::zero(), ori.look_dir()), |data| {
113 (data.beam_offset, data.aim_dir)
114 });
115 beam.bezier.start = pos.0 + offset;
116 const REL_CTRL_DIST: f32 = 0.3;
117 let target_ctrl = beam.bezier.start + *target_dir * beam.range * REL_CTRL_DIST;
118 let ctrl_translate = (target_ctrl - beam.bezier.ctrl) * read_data.dt.0
119 / (beam.duration.0 as f32 * REL_CTRL_DIST);
120 beam.bezier.ctrl += ctrl_translate;
121 let target_end = beam.bezier.start + *target_dir * beam.range;
122 let end_translate =
123 (target_end - beam.bezier.end) * read_data.dt.0 / beam.duration.0 as f32;
124 beam.bezier.end += end_translate;
125 });
126
127 job.cpu_stats.measure(ParMode::Rayon);
128
129 let (_emitters, add_hit_entities, new_outcomes) = (
132 &read_data.entities,
133 &read_data.positions,
134 &read_data.orientations,
135 &read_data.uids,
136 &beams,
137 )
138 .par_join()
139 .fold(
140 || (read_data.events.get_emitters(), Vec::new(), Vec::new()),
141 |(mut emitters, mut add_hit_entities, mut outcomes),
142 (entity, pos, ori, uid, beam)| {
143 let mut rng = rand::thread_rng();
146 if rng.gen_bool(0.005) {
147 emitters.emit(event::SoundEvent {
148 sound: Sound::new(SoundKind::Beam, pos.0, 13.0, read_data.time.0),
149 });
150 }
151 outcomes.push(Outcome::Beam {
152 pos: pos.0,
153 specifier: beam.specifier,
154 });
155
156 let group = read_data.groups.get(entity);
159
160 let target_iter = read_data
162 .cached_spatial_grid
163 .0
164 .in_circle_aabr(beam.bezier.start.xy(), beam.range)
165 .filter_map(|target| {
166 read_data
167 .positions
168 .get(target)
169 .and_then(|l| read_data.healths.get(target).map(|r| (l, r)))
170 .and_then(|l| read_data.uids.get(target).map(|r| (l, r)))
171 .and_then(|l| read_data.bodies.get(target).map(|r| (l, r)))
172 .map(|(((pos_b, health_b), uid_b), body_b)| {
173 (target, uid_b, pos_b, health_b, body_b)
174 })
175 });
176 target_iter.for_each(|(target, uid_b, pos_b, health_b, body_b)| {
177 if beam.hit_entities.iter().any(|&e| e == target) {
179 return;
180 }
181
182 let scale_b = read_data.scales.get(target).map_or(1.0, |s| s.0);
184 let rad_b = body_b.max_radius() * scale_b;
185 let height_b = body_b.height() * scale_b;
186
187 let hit = entity != target
190 && !health_b.is_dead
191 && conical_bezier_cylinder_collision(
192 beam.bezier,
193 beam.start_radius,
194 beam.end_radius,
195 beam.range,
196 pos_b.0,
197 rad_b,
198 height_b,
199 );
200
201 let tgt_dist = beam.bezier.start.distance(pos_b.0);
205 let beam_dir = (beam.bezier.ctrl - beam.bezier.start)
206 / beam.bezier.start.distance(beam.bezier.ctrl).max(0.01);
207 let hit = hit
208 && read_data
209 .terrain
210 .ray(
211 beam.bezier.start,
212 beam.bezier.start + beam_dir * (tgt_dist + 1.0),
213 )
214 .until(|b| b.is_filled())
215 .cast()
216 .0
217 >= tgt_dist;
218
219 if hit {
220 let allow_friendly_fire = combat::allow_friendly_fire(
221 &read_data.entered_auras,
222 entity,
223 target,
224 );
225
226 let same_group = group
228 .map(|group_a| Some(group_a) == read_data.groups.get(target))
229 .unwrap_or(false);
230
231 let target_group = if same_group {
232 GroupTarget::InGroup
233 } else {
234 GroupTarget::OutOfGroup
235 };
236
237 let attacker_info = Some(AttackerInfo {
238 entity,
239 uid: *uid,
240 group: read_data.groups.get(entity),
241 energy: read_data.energies.get(entity),
242 combo: read_data.combos.get(entity),
243 inventory: read_data.inventories.get(entity),
244 stats: read_data.stats.get(entity),
245 mass: read_data.masses.get(entity),
246 });
247
248 let target_info = TargetInfo {
249 entity: target,
250 uid: *uid_b,
251 inventory: read_data.inventories.get(target),
252 stats: read_data.stats.get(target),
253 health: read_data.healths.get(target),
254 pos: pos_b.0,
255 ori: read_data.orientations.get(target),
256 char_state: read_data.character_states.get(target),
257 energy: read_data.energies.get(target),
258 buffs: read_data.buffs.get(target),
259 mass: read_data.masses.get(target),
260 };
261
262 let target_dodging = match beam.dodgeable {
263 Dodgeable::Roll => read_data
264 .character_states
265 .get(target)
266 .and_then(|cs| cs.roll_attack_immunities())
267 .is_some_and(|i| i.beams),
268 Dodgeable::Jump => read_data
269 .physics_states
270 .get(target)
271 .is_some_and(|ps| ps.on_ground.is_none()),
272 Dodgeable::No => false,
273 };
274 let permit_pvp = combat::permit_pvp(
276 &read_data.alignments,
277 &read_data.players,
278 &read_data.entered_auras,
279 &read_data.id_maps,
280 Some(entity),
281 target,
282 );
283
284 let precision_from_flank = combat::precision_mult_from_flank(
285 beam.bezier.ctrl - beam.bezier.start,
286 target_info.ori,
287 Default::default(),
288 false,
289 );
290
291 let precision_from_time = {
292 if let Some(ticks) = beam.hit_durations.get(&target) {
293 let dur = *ticks as f32 * beam.tick_dur.0 as f32;
294 let mult =
295 (dur / combat::BEAM_DURATION_PRECISION).clamp(0.0, 1.0);
296 Some(combat::MAX_BEAM_DUR_PRECISION * mult)
297 } else {
298 None
299 }
300 };
301
302 let precision_mult = match (precision_from_flank, precision_from_time) {
303 (Some(a), Some(b)) => Some(a.max(b)),
304 (Some(a), None) | (None, Some(a)) => Some(a),
305 (None, None) => None,
306 };
307
308 let attack_options = AttackOptions {
309 target_dodging,
310 permit_pvp,
311 allow_friendly_fire,
312 target_group,
313 precision_mult,
314 };
315
316 beam.attack.apply_attack(
317 attacker_info,
318 &target_info,
319 ori.look_dir(),
320 attack_options,
321 1.0,
322 AttackSource::Beam,
323 *read_data.time,
324 &mut emitters,
325 |o| outcomes.push(o),
326 &mut rng,
327 0,
328 );
329
330 add_hit_entities.push((entity, target));
331 }
332 });
333 (emitters, add_hit_entities, outcomes)
334 },
335 )
336 .reduce(
337 || (read_data.events.get_emitters(), Vec::new(), Vec::new()),
338 |(mut events_a, mut hit_entities_a, mut outcomes_a),
339 (events_b, mut hit_entities_b, mut outcomes_b)| {
340 events_a.append(events_b);
341 hit_entities_a.append(&mut hit_entities_b);
342 outcomes_a.append(&mut outcomes_b);
343 (events_a, hit_entities_a, outcomes_a)
344 },
345 );
346 job.cpu_stats.measure(ParMode::Single);
347
348 outcomes_emitter.emit_many(new_outcomes);
349
350 for (entity, hit_entity) in add_hit_entities {
351 if let Some(ref mut beam) = beams.get_mut(entity) {
352 beam.hit_entities.push(hit_entity);
353 }
354 }
355 }
356}
357
358fn conical_bezier_cylinder_collision(
360 bezier: QuadraticBezier3<f32>,
362 start_rad: f32, end_rad: f32, range: f32, bottom_pos_b: Vec3<f32>, rad_b: f32,
368 length_b: f32,
369) -> bool {
370 let center_pos_b = bottom_pos_b.with_z(bottom_pos_b.z + length_b / 2.0);
375 let (t, closest_pos) =
376 bezier.binary_search_point_by_steps(center_pos_b, (range * 5.0) as u16, 0.1);
377 let bezier_rad = start_rad + t * (end_rad - start_rad);
378 let z_check = {
379 let dist = (closest_pos.z - center_pos_b.z).abs();
380 dist < bezier_rad + length_b / 2.0
381 };
382 let rad_check = {
383 let dist_sqrd = closest_pos.xy().distance_squared(center_pos_b.xy());
384 dist_sqrd < (bezier_rad + rad_b).powi(2)
385 };
386 let endpoints_check = {
387 let tangent = bezier.evaluate_derivative(t);
388 let dir = center_pos_b - closest_pos;
389 tangent.angle_between(dir) >= 0.45 * PI
392 };
393
394 z_check && rad_check && endpoints_check
395}