veloren_server/events/
interaction.rs

1use std::{f32::consts::PI, ops::Mul};
2
3use common::{comp::loot_owner::ONWERSHIP_TIMEOUT_FAST, rtsim::DialogueKind};
4use common_state::{BlockChange, ScheduledBlockChange};
5use specs::{DispatcherBuilder, Join, ReadExpect, ReadStorage, WriteExpect, WriteStorage};
6use tracing::error;
7use vek::*;
8
9use common::{
10    assets::{AssetCombined, AssetHandle, Ron},
11    comp::{
12        self, InventoryUpdateEvent,
13        agent::{AgentEvent, Sound, SoundKind},
14        inventory::slot::EquipSlot,
15        item::{MaterialStatManifest, flatten_counted_items},
16        loot_owner::LootOwnerKind,
17        tool::AbilityMap,
18    },
19    consts::{MAX_INTERACT_RANGE, MAX_NPCINTERACT_RANGE, SOUND_TRAVEL_DIST_PER_VOLUME},
20    event::{
21        CreateItemDropEvent, CreateSpriteEvent, DialogueEvent, EventBus, MineBlockEvent,
22        NpcInteractEvent, SetLanternEvent, SetPetStayEvent, SoundEvent, TamePetEvent,
23        ToggleSpriteLightEvent,
24    },
25    link::Is,
26    mounting::Mount,
27    outcome::Outcome,
28    resources::ProgramTime,
29    terrain::{self, Block, SpriteKind, TerrainGrid},
30    uid::Uid,
31    util::Dir,
32    vol::ReadVol,
33};
34
35use crate::{Server, ServerGeneral, Time, client::Client};
36
37use crate::pet::tame_pet;
38use hashbrown::{HashMap, HashSet};
39use lazy_static::lazy_static;
40
41use super::{ServerEvent, event_dispatch, mounting::within_mounting_range};
42
43pub(super) fn register_event_systems(builder: &mut DispatcherBuilder) {
44    event_dispatch::<SetLanternEvent>(builder, &[]);
45    event_dispatch::<NpcInteractEvent>(builder, &[]);
46    event_dispatch::<DialogueEvent>(builder, &[]);
47    event_dispatch::<SetPetStayEvent>(builder, &[]);
48    event_dispatch::<MineBlockEvent>(builder, &[]);
49    event_dispatch::<SoundEvent>(builder, &[]);
50    event_dispatch::<CreateSpriteEvent>(builder, &[]);
51    event_dispatch::<ToggleSpriteLightEvent>(builder, &[]);
52}
53
54impl ServerEvent for SetLanternEvent {
55    type SystemData<'a> = (
56        WriteStorage<'a, comp::LightEmitter>,
57        ReadStorage<'a, comp::Inventory>,
58        ReadStorage<'a, comp::Health>,
59    );
60
61    fn handle(
62        events: impl ExactSizeIterator<Item = Self>,
63        (mut light_emitters, inventories, healths): Self::SystemData<'_>,
64    ) {
65        for SetLanternEvent(entity, enable) in events {
66            let lantern_exists = light_emitters
67                .get(entity)
68                .is_some_and(|light| light.strength > 0.0);
69
70            if lantern_exists != enable {
71                if !enable {
72                    light_emitters.remove(entity);
73                }
74                // Only enable lantern if entity is alive
75                else if healths.get(entity).is_none_or(|h| !h.is_dead) {
76                    inventories
77                        .get(entity)
78                        .and_then(|inventory| inventory.equipped(EquipSlot::Lantern))
79                        .map(|item| {
80                            if let comp::item::ItemKind::Lantern(l) = &*item.kind() {
81                                let _ = light_emitters.insert(entity, comp::LightEmitter {
82                                    col: l.color(),
83                                    strength: l.strength(),
84                                    flicker: l.flicker(),
85                                    animated: true,
86                                    dir: l.dir,
87                                });
88                            }
89                        });
90                }
91            }
92        }
93    }
94}
95
96impl ServerEvent for NpcInteractEvent {
97    type SystemData<'a> = (
98        WriteStorage<'a, comp::Agent>,
99        ReadStorage<'a, comp::Pos>,
100        ReadStorage<'a, Uid>,
101    );
102
103    fn handle(
104        events: impl ExactSizeIterator<Item = Self>,
105        (mut agents, positions, uids): Self::SystemData<'_>,
106    ) {
107        for NpcInteractEvent(interactor, npc_entity) in events {
108            let within_range = {
109                positions
110                    .get(interactor)
111                    .zip(positions.get(npc_entity))
112                    .is_some_and(|(interactor_pos, npc_pos)| {
113                        interactor_pos.0.distance_squared(npc_pos.0)
114                            <= MAX_NPCINTERACT_RANGE.powi(2)
115                    })
116            };
117
118            if within_range
119                && let Some(agent) = agents.get_mut(npc_entity)
120                && agent.target.is_none()
121                && let Some(interactor_uid) = uids.get(interactor)
122            {
123                agent.inbox.push_back(AgentEvent::Talk(*interactor_uid));
124            }
125        }
126    }
127}
128
129impl ServerEvent for DialogueEvent {
130    type SystemData<'a> = (
131        ReadStorage<'a, Uid>,
132        ReadStorage<'a, comp::Pos>,
133        ReadStorage<'a, Client>,
134        WriteStorage<'a, comp::Agent>,
135        WriteStorage<'a, comp::Inventory>,
136        ReadExpect<'a, AbilityMap>,
137        ReadExpect<'a, MaterialStatManifest>,
138        WriteStorage<'a, comp::InventoryUpdate>,
139    );
140
141    fn handle(
142        events: impl ExactSizeIterator<Item = Self>,
143        (
144            uids,
145            positions,
146            clients,
147            mut agents,
148            mut inventories,
149            ability_map,
150            msm,
151            mut inventory_updates,
152        ): Self::SystemData<'_>,
153    ) {
154        for DialogueEvent(sender, target, dialogue) in events {
155            let within_range = positions
156                .get(sender)
157                .zip(positions.get(target))
158                .is_some_and(|(sender_pos, target_pos)| {
159                    sender_pos.0.distance_squared(target_pos.0) <= MAX_NPCINTERACT_RANGE.powi(2)
160                });
161
162            if within_range && let Some(sender_uid) = uids.get(sender) {
163                // Perform item transfer, if required
164                let given_item = match &dialogue.kind {
165                    DialogueKind::Start
166                    | DialogueKind::End
167                    | DialogueKind::Question { .. }
168                    | DialogueKind::Marker { .. }
169                    | DialogueKind::Ack { .. } => None,
170                    DialogueKind::Statement { given_item, .. } => given_item.as_ref(),
171                    DialogueKind::Response { response, .. } => response.given_item.as_ref(),
172                };
173                // If the response requires an item to be given, perform exchange (or exit)
174                if let Some((item_def, amount)) = given_item {
175                    // Check that the target's inventory has enough space for the item
176                    if let Some(target_inv) = inventories.get(target)
177                        && target_inv.has_space_for(item_def, *amount)
178                        // Check that the sender has enough of the item
179                        && let Some(mut sender_inv) = inventories.get_mut(sender)
180                        && sender_inv.item_count(item_def) >= *amount as u64
181                        // First, remove the item from the sender's inventory
182                        && let Some(items) = sender_inv.remove_item_amount(item_def, *amount, &ability_map, &msm)
183                        && let Some(mut target_inv) = inventories.get_mut(target)
184                    {
185                        for item in items {
186                            let item_event = InventoryUpdateEvent::Collected(
187                                item.frontend_item(&ability_map, &msm),
188                            );
189                            // Push the items to the target's inventory
190                            if target_inv.push(item).is_err() {
191                                error!(
192                                    "Failed to insert dialogue given item despite target \
193                                     inventory claiming to have space, dropping remaining items..."
194                                );
195                                break;
196                            } else {
197                                inventory_updates
198                                    .insert(target, comp::InventoryUpdate::new(item_event))
199                                    .expect("The entity must exist because we have its inventory");
200                            }
201                        }
202                    } else {
203                        // TODO: Respond with error message on failure?
204                        continue;
205                    }
206                }
207
208                let dialogue = dialogue.into_validated_unchecked();
209
210                if let Some(agent) = agents.get_mut(target) {
211                    agent
212                        .inbox
213                        .push_back(AgentEvent::Dialogue(*sender_uid, dialogue.clone()));
214                }
215
216                if let Some(client) = clients.get(target) {
217                    client.send_fallible(ServerGeneral::Dialogue(*sender_uid, dialogue));
218                }
219            }
220        }
221    }
222}
223
224impl ServerEvent for SetPetStayEvent {
225    type SystemData<'a> = (
226        WriteStorage<'a, comp::Agent>,
227        WriteStorage<'a, comp::CharacterActivity>,
228        ReadStorage<'a, comp::Pos>,
229        ReadStorage<'a, comp::Alignment>,
230        ReadStorage<'a, Is<Mount>>,
231        ReadStorage<'a, Uid>,
232    );
233
234    fn handle(
235        events: impl ExactSizeIterator<Item = Self>,
236        (mut agents, mut character_activities, positions, alignments, is_mounts, uids): Self::SystemData<'_>,
237    ) {
238        for SetPetStayEvent(command_giver, pet, stay) in events {
239            let is_owner = uids.get(command_giver).is_some_and(|owner_uid| {
240                matches!(
241                    alignments.get(pet),
242                    Some(comp::Alignment::Owned(pet_owner)) if *pet_owner == *owner_uid,
243                )
244            });
245
246            let current_pet_position = positions.get(pet).copied();
247            let stay = stay && current_pet_position.is_some();
248            if is_owner
249                && within_mounting_range(positions.get(command_giver), positions.get(pet))
250                && is_mounts.get(pet).is_none()
251            {
252                character_activities
253                    .get_mut(pet)
254                    .map(|mut activity| activity.is_pet_staying = stay);
255                agents
256                    .get_mut(pet)
257                    .map(|s| s.stay_pos = current_pet_position.filter(|_| stay));
258            }
259        }
260    }
261}
262
263lazy_static! {
264    static ref RESOURCE_EXPERIENCE_MANIFEST: AssetHandle<Ron<HashMap<String, u32>>> =
265        Ron::load_expect_combined_static("server.manifests.resource_experience_manifest");
266}
267
268impl ServerEvent for MineBlockEvent {
269    type SystemData<'a> = (
270        WriteExpect<'a, BlockChange>,
271        ReadExpect<'a, TerrainGrid>,
272        ReadExpect<'a, MaterialStatManifest>,
273        ReadExpect<'a, AbilityMap>,
274        ReadExpect<'a, EventBus<CreateItemDropEvent>>,
275        ReadExpect<'a, EventBus<SoundEvent>>,
276        ReadExpect<'a, EventBus<Outcome>>,
277        ReadExpect<'a, ProgramTime>,
278        ReadExpect<'a, Time>,
279        WriteStorage<'a, comp::SkillSet>,
280        ReadStorage<'a, Uid>,
281    );
282
283    fn handle(
284        events: impl ExactSizeIterator<Item = Self>,
285        (
286            mut block_change,
287            terrain,
288            msm,
289            ability_map,
290            create_item_drop_events,
291            sound_events,
292            outcomes,
293            program_time,
294            time,
295            mut skill_sets,
296            uids,
297        ): Self::SystemData<'_>,
298    ) {
299        use rand::Rng;
300        let mut rng = rand::rng();
301        let mut create_item_drop_emitter = create_item_drop_events.emitter();
302        let mut sound_event_emitter = sound_events.emitter();
303        let mut outcome_emitter = outcomes.emitter();
304        for ev in events {
305            if block_change.can_set_block(ev.pos) {
306                let block = terrain.get(ev.pos).ok().copied();
307                if let Some(mut block) =
308                    block.filter(|b| b.mine_tool().is_some_and(|t| Some(t) == ev.tool))
309                {
310                    // Attempt to increase the resource's damage
311                    let damage = if let Ok(damage) = block.get_attr::<terrain::sprite::Damage>() {
312                        let updated_damage = damage.0.saturating_add(1);
313                        block
314                            .set_attr(terrain::sprite::Damage(updated_damage))
315                            .expect(
316                                "We just read the Damage attribute from the block, writing should \
317                                 be possible too",
318                            );
319
320                        Some(updated_damage)
321                    } else {
322                        None
323                    };
324
325                    let sprite = block.get_sprite();
326
327                    // Maximum damage has reached, destroy the block
328                    let is_broken = damage
329                        .and_then(|damage| Some((sprite?.required_mine_damage(), damage)))
330                        .is_some_and(|(required_damage, damage)| {
331                            required_damage.is_none_or(|required| damage >= required)
332                        });
333
334                    // Stage changes happen in damage interval of `mine_drop_intevral`
335                    let stage_changed = damage
336                        .and_then(|damage| Some((sprite?.mine_drop_interval(), damage)))
337                        .is_some_and(|(interval, damage)| damage % interval == 0);
338
339                    let sprite_cfg = terrain.sprite_cfg_at(ev.pos);
340                    if (stage_changed || is_broken)
341                        && let Some(items) = comp::Item::try_reclaim_from_block(block, sprite_cfg)
342                    {
343                        let mut items: Vec<_> =
344                            flatten_counted_items(&items, &ability_map, &msm).collect();
345                        let maybe_uid = uids.get(ev.entity).copied();
346
347                        if let Some(mut skillset) = skill_sets.get_mut(ev.entity) {
348                            use common::comp::skills::{MiningSkill, SKILL_MODIFIERS, Skill};
349
350                            if is_broken
351                                && let (Some(tool), Some(uid), exp_reward @ 1..) = (
352                                    ev.tool,
353                                    maybe_uid,
354                                    items
355                                        .iter()
356                                        .filter_map(|item| {
357                                            item.item_definition_id().itemdef_id().and_then(|id| {
358                                                RESOURCE_EXPERIENCE_MANIFEST
359                                                    .read()
360                                                    .0
361                                                    .get(id)
362                                                    .copied()
363                                            })
364                                        })
365                                        .sum(),
366                                )
367                            {
368                                let skill_group = comp::SkillGroupKind::Weapon(tool);
369                                if let Some(level_outcome) =
370                                    skillset.add_experience(skill_group, exp_reward)
371                                {
372                                    outcome_emitter.emit(Outcome::SkillPointGain {
373                                        uid,
374                                        skill_tree: skill_group,
375                                        total_points: level_outcome,
376                                    });
377                                }
378                                outcome_emitter.emit(Outcome::ExpChange {
379                                    uid,
380                                    exp: exp_reward,
381                                    xp_pools: HashSet::from([skill_group]),
382                                });
383                            }
384
385                            let stage_ore_chance = || {
386                                let chance_mod = f64::from(SKILL_MODIFIERS.mining_tree.ore_gain);
387                                let skill_level = skillset
388                                    .skill_level(Skill::Pick(MiningSkill::OreGain))
389                                    .unwrap_or(0);
390
391                                chance_mod * f64::from(skill_level)
392                            };
393                            let stage_gem_chance = || {
394                                let chance_mod = f64::from(SKILL_MODIFIERS.mining_tree.gem_gain);
395                                let skill_level = skillset
396                                    .skill_level(Skill::Pick(MiningSkill::GemGain))
397                                    .unwrap_or(0);
398
399                                chance_mod * f64::from(skill_level)
400                            };
401
402                            // If the resource hasn't been fully broken, only drop certain resources
403                            // with a chance
404                            if !is_broken {
405                                items.retain(|item| {
406                                    rng.random_bool(
407                                        0.5 + item
408                                            .item_definition_id()
409                                            .itemdef_id()
410                                            .map(|id| {
411                                                if id.contains("mineral.ore.") {
412                                                    stage_ore_chance()
413                                                } else if id.contains("mineral.gem.") {
414                                                    stage_gem_chance()
415                                                } else {
416                                                    0.0
417                                                }
418                                            })
419                                            .unwrap_or(0.0),
420                                    )
421                                });
422                            }
423                        }
424                        for item in items {
425                            let loot_owner = maybe_uid.map(LootOwnerKind::Player).map(|owner| {
426                                comp::LootOwner::new(owner, false, ONWERSHIP_TIMEOUT_FAST)
427                            });
428                            create_item_drop_emitter.emit(CreateItemDropEvent {
429                                pos: comp::Pos(ev.pos.map(|e| e as f32) + Vec3::broadcast(0.5)),
430                                vel: comp::Vel(
431                                    Vec2::unit_x()
432                                        .rotated_z(rng.random::<f32>() * PI * 2.0)
433                                        .mul(4.0)
434                                        .with_z(rng.random_range(5.0..10.0)),
435                                ),
436                                ori: comp::Ori::from(Dir::random_2d(&mut rng)),
437                                item: comp::PickupItem::new(item, *program_time, false),
438                                loot_owner,
439                            });
440                        }
441                    }
442
443                    if damage.is_some() && !is_broken {
444                        block_change.set(ev.pos, block);
445                    } else {
446                        block_change.set(ev.pos, block.into_vacant());
447                    }
448                    outcome_emitter.emit(if is_broken {
449                        Outcome::BreakBlock {
450                            pos: ev.pos,
451                            tool: ev.tool,
452                            color: block.get_color(),
453                        }
454                    } else {
455                        Outcome::DamagedBlock {
456                            pos: ev.pos,
457                            stage_changed,
458                            tool: ev.tool,
459                        }
460                    });
461
462                    // Emit mining sound
463                    sound_event_emitter.emit(SoundEvent {
464                        sound: Sound::new(SoundKind::Mine, ev.pos.as_(), 20.0, time.0),
465                    });
466                }
467            }
468        }
469    }
470}
471
472impl ServerEvent for SoundEvent {
473    type SystemData<'a> = (
474        ReadExpect<'a, EventBus<Outcome>>,
475        WriteStorage<'a, comp::Agent>,
476        ReadStorage<'a, comp::Pos>,
477    );
478
479    fn handle(
480        events: impl ExactSizeIterator<Item = Self>,
481        (outcomes, mut agents, positions): Self::SystemData<'_>,
482    ) {
483        let mut outcome_emitter = outcomes.emitter();
484        for SoundEvent { sound } in events {
485            // TODO: Reduce the complexity of this problem by using spatial partitioning
486            // system
487            for (agent, agent_pos) in (&mut agents, &positions).join() {
488                // TODO: Use pathfinding for more dropoff around obstacles
489                let agent_dist_sqrd = agent_pos.0.distance_squared(sound.pos);
490                let sound_travel_dist_sqrd = (sound.vol * SOUND_TRAVEL_DIST_PER_VOLUME).powi(2);
491
492                let vol_dropoff = agent_dist_sqrd / sound_travel_dist_sqrd * sound.vol;
493                let propagated_sound = sound.with_new_vol(sound.vol - vol_dropoff);
494
495                let can_hear_sound = propagated_sound.vol > 0.00;
496                let should_hear_sound = agent_dist_sqrd < agent.psyche.listen_dist.powi(2);
497
498                if can_hear_sound && should_hear_sound {
499                    agent
500                        .inbox
501                        .push_back(AgentEvent::ServerSound(propagated_sound));
502                }
503            }
504
505            // Attempt to turn this sound into an outcome to be received by frontends.
506            if let Some(outcome) = match sound.kind {
507                SoundKind::Utterance(kind, body) => Some(Outcome::Utterance {
508                    kind,
509                    pos: sound.pos,
510                    body,
511                }),
512                _ => None,
513            } {
514                outcome_emitter.emit(outcome);
515            }
516        }
517    }
518}
519
520impl ServerEvent for CreateSpriteEvent {
521    type SystemData<'a> = (
522        WriteExpect<'a, BlockChange>,
523        WriteExpect<'a, ScheduledBlockChange>,
524        ReadExpect<'a, TerrainGrid>,
525        ReadExpect<'a, Time>,
526    );
527
528    fn handle(
529        events: impl ExactSizeIterator<Item = Self>,
530        (mut block_change, mut scheduled_block_change, terrain, time): Self::SystemData<'_>,
531    ) {
532        for ev in events {
533            if block_change.can_set_block(ev.pos) {
534                let block = terrain.get(ev.pos).ok().copied();
535                if block.is_some_and(|b| (*b).is_fluid()) {
536                    let old_block = block.unwrap_or_else(|| Block::air(SpriteKind::Empty));
537                    let new_block = old_block.with_sprite(ev.sprite);
538                    block_change.set(ev.pos, new_block);
539                    // Remove sprite after del_timeout and offset if specified
540                    if let Some((timeout, del_offset)) = ev.del_timeout {
541                        use rand::Rng;
542                        let mut rng = rand::rng();
543                        let offset = rng.random_range(0.0..del_offset);
544                        let current_time: f64 = time.0;
545                        let replace_time = current_time + (timeout + offset) as f64;
546                        if old_block != new_block {
547                            scheduled_block_change.set(ev.pos, old_block, replace_time);
548                            scheduled_block_change.outcome_set(ev.pos, new_block, replace_time);
549                        }
550                    }
551                }
552            }
553        }
554    }
555}
556
557impl ServerEvent for ToggleSpriteLightEvent {
558    type SystemData<'a> = (
559        WriteExpect<'a, BlockChange>,
560        ReadExpect<'a, TerrainGrid>,
561        ReadStorage<'a, comp::Pos>,
562    );
563
564    fn handle(
565        events: impl ExactSizeIterator<Item = Self>,
566        (mut block_change, terrain, positions): Self::SystemData<'_>,
567    ) {
568        for ev in events.into_iter() {
569            if let Some(entity_pos) = positions.get(ev.entity)
570                && entity_pos.0.distance_squared(ev.pos.as_()) < MAX_INTERACT_RANGE.powi(2)
571                && block_change.can_set_block(ev.pos)
572                && let Some(new_block) = terrain
573                    .get(ev.pos)
574                    .ok()
575                    .and_then(|block| block.with_toggle_light(ev.enable))
576            {
577                block_change.set(ev.pos, new_block);
578                // TODO: Emit outcome
579            }
580        }
581    }
582}
583
584pub fn handle_tame_pet(server: &mut Server, ev: TamePetEvent) {
585    // TODO: Raise outcome to send to clients to play sound/render an indicator
586    // showing taming success?
587    tame_pet(server.state.ecs(), ev.pet_entity, ev.owner_entity);
588}
veloren_server/events/interaction.rs

veloren_server/events/
interaction.rs
