veloren_server/events/
inventory_manip.rs

1use hashbrown::HashSet;
2use rand::seq::IteratorRandom;
3use specs::{
4    DispatcherBuilder, Entities, Entity as EcsEntity, Read, ReadExpect, ReadStorage, SystemData,
5    Write, WriteStorage, join::Join, shred,
6};
7use tracing::{debug, error, warn};
8use vek::{Rgb, Vec3};
9
10use common::{
11    comp::{
12        self, InventoryUpdate, LootOwner, PickupItem,
13        group::members,
14        item::{self, MaterialStatManifest, flatten_counted_items, tool::AbilityMap},
15        loot_owner::LootOwnerKind,
16        slot::{self, Slot},
17    },
18    consts::MAX_PICKUP_RANGE,
19    event::{
20        BuffEvent, ChangeBodyEvent, CreateItemDropEvent, CreateObjectEvent, DeleteEvent, EmitExt,
21        HealthChangeEvent, InventoryManipEvent, PoiseChangeEvent, TamePetEvent,
22    },
23    event_emitters, match_some,
24    mounting::VolumePos,
25    outcome::Outcome,
26    recipe::{self, RecipeBookManifest, default_component_recipe_book, default_repair_recipe_book},
27    resources::{ProgramTime, Time},
28    terrain::{Block, SpriteKind},
29    trade::Trades,
30    uid::{IdMaps, Uid},
31    util::find_dist::{self, FindDist},
32    vol::ReadVol,
33};
34use comp::LightEmitter;
35
36use crate::client::Client;
37use common::comp::{Alignment, CollectFailedReason, Group, InventoryUpdateEvent, pet::is_tameable};
38use common_net::msg::ServerGeneral;
39
40use super::{ServerEvent, entity_manipulation::emit_effect_events, event_dispatch};
41
42pub(super) fn register_event_systems(builder: &mut DispatcherBuilder) {
43    event_dispatch::<InventoryManipEvent>(builder, &[]);
44}
45
46pub fn swap_lantern(
47    storage: &mut WriteStorage<LightEmitter>,
48    entity: EcsEntity,
49    (lantern_color, lantern_strength): (Rgb<f32>, f32),
50) {
51    if let Some(mut light) = storage.get_mut(entity) {
52        light.strength = lantern_strength;
53        light.col = lantern_color;
54    }
55}
56
57pub fn snuff_lantern(storage: &mut WriteStorage<LightEmitter>, entity: EcsEntity) {
58    storage.remove(entity);
59}
60
61event_emitters! {
62    struct Events[Emitters] {
63        tame_pet: TamePetEvent,
64        delete: DeleteEvent,
65        create_item_drop: CreateItemDropEvent,
66        create_object: CreateObjectEvent,
67        health_change: HealthChangeEvent,
68        poise_change: PoiseChangeEvent,
69        buff: BuffEvent,
70        change_body: ChangeBodyEvent,
71        outcome: Outcome,
72    }
73}
74#[derive(SystemData)]
75pub struct InventoryManipData<'a> {
76    entities: Entities<'a>,
77    events: Events<'a>,
78    block_change: Write<'a, common_state::BlockChange>,
79    trades: Write<'a, Trades>,
80    #[cfg(feature = "worldgen")]
81    rtsim: specs::WriteExpect<'a, crate::rtsim::RtSim>,
82    terrain: ReadExpect<'a, common::terrain::TerrainGrid>,
83    id_maps: Read<'a, IdMaps>,
84    time: Read<'a, Time>,
85    #[cfg(feature = "worldgen")]
86    world: ReadExpect<'a, std::sync::Arc<world::World>>,
87    #[cfg(feature = "worldgen")]
88    index: ReadExpect<'a, world::IndexOwned>,
89    program_time: ReadExpect<'a, ProgramTime>,
90    ability_map: ReadExpect<'a, AbilityMap>,
91    msm: ReadExpect<'a, MaterialStatManifest>,
92    rbm: ReadExpect<'a, RecipeBookManifest>,
93    inventories: WriteStorage<'a, comp::Inventory>,
94    items: WriteStorage<'a, comp::PickupItem>,
95    inventory_updates: WriteStorage<'a, comp::InventoryUpdate>,
96    light_emitters: WriteStorage<'a, comp::LightEmitter>,
97    positions: ReadStorage<'a, comp::Pos>,
98    scales: ReadStorage<'a, comp::Scale>,
99    colliders: ReadStorage<'a, comp::Collider>,
100    character_states: ReadStorage<'a, comp::CharacterState>,
101    healths: ReadStorage<'a, comp::Health>,
102    uids: ReadStorage<'a, Uid>,
103    loot_owners: ReadStorage<'a, comp::LootOwner>,
104    alignments: ReadStorage<'a, comp::Alignment>,
105    bodies: ReadStorage<'a, comp::Body>,
106    players: ReadStorage<'a, comp::Player>,
107    groups: ReadStorage<'a, comp::Group>,
108    stats: ReadStorage<'a, comp::Stats>,
109    clients: ReadStorage<'a, Client>,
110    orientations: ReadStorage<'a, comp::Ori>,
111    agents: ReadStorage<'a, comp::Agent>,
112    pets: ReadStorage<'a, comp::Pet>,
113    masses: ReadStorage<'a, comp::Mass>,
114    #[cfg(feature = "worldgen")]
115    presences: ReadStorage<'a, comp::Presence>,
116    #[cfg(feature = "worldgen")]
117    rtsim_entities: ReadStorage<'a, common::rtsim::RtSimEntity>,
118}
119
120impl ServerEvent for InventoryManipEvent {
121    type SystemData<'a> = InventoryManipData<'a>;
122
123    fn handle(events: impl ExactSizeIterator<Item = Self>, mut data: Self::SystemData<'_>) {
124        let mut emitters = data.events.get_emitters();
125        let get_cylinder = |entity| {
126            data.positions.get(entity).map(|p| {
127                find_dist::Cylinder::from_components(
128                    p.0,
129                    data.scales.get(entity).copied(),
130                    data.colliders.get(entity),
131                    data.character_states.get(entity),
132                )
133            })
134        };
135        let mut rng = rand::rng();
136
137        let mut dropped_items = Vec::new();
138
139        for InventoryManipEvent(entity, manip) in events {
140            let uid = if let Some(uid) = data.uids.get(entity) {
141                uid
142            } else {
143                warn!(
144                    "Couldn't get uid for entity {:?} at start of handle_inventory",
145                    entity
146                );
147                continue;
148            };
149            if data.trades.in_immutable_trade(uid) {
150                // manipulating the inventory can mutate the trade
151                continue;
152            }
153
154            if comp::is_downed_or_dead(data.healths.get(entity), data.character_states.get(entity))
155            {
156                // Can't manipulate the inventory while downed or dead.
157                continue;
158            }
159
160            let mut inventory = if let Some(inventory) = data.inventories.get_mut(entity) {
161                inventory
162            } else {
163                error!(
164                    ?entity,
165                    "Can't manipulate inventory, entity doesn't have one"
166                );
167                continue;
168            };
169            match manip {
170                comp::InventoryManip::Pickup(pickup_uid) => {
171                    let item_entity = if let Some(item_entity) = data.id_maps.uid_entity(pickup_uid)
172                    {
173                        item_entity
174                    } else {
175                        // Item entity could not be found - most likely because the entity
176                        // attempted to pick up the same item very quickly before its deletion
177                        // of the world from the first pickup
178                        // attempt was processed.
179                        debug!("Failed to get entity for item Uid: {}", pickup_uid);
180                        continue;
181                    };
182                    let entity_cylinder = get_cylinder(entity);
183
184                    // FIXME: Raycast so we can't pick up items through walls.
185                    if !within_pickup_range(entity_cylinder, || get_cylinder(item_entity)) {
186                        debug!(
187                            ?entity_cylinder,
188                            "Failed to pick up item as not within range, Uid: {}", pickup_uid
189                        );
190                        continue;
191                    }
192
193                    // If there's a loot owner for the item being picked up, then
194                    // determine whether the pickup should be rejected.
195                    let ownership_check_passed =
196                        data.loot_owners.get(item_entity).is_none_or(|loot_owner| {
197                            let can_pickup = loot_owner.can_pickup(
198                                *uid,
199                                data.groups.get(entity),
200                                data.alignments.get(entity),
201                                data.stats
202                                    .get(entity)
203                                    .map(|stats| &stats.original_body)
204                                    .or_else(|| data.bodies.get(entity)),
205                                data.players.get(entity),
206                            );
207                            if !can_pickup {
208                                let event = comp::InventoryUpdate::new(
209                                    InventoryUpdateEvent::EntityCollectFailed {
210                                        entity: pickup_uid,
211                                        reason: CollectFailedReason::LootOwned {
212                                            owner: loot_owner.owner(),
213                                            expiry_secs: loot_owner
214                                                .time_until_expiration()
215                                                .as_secs(),
216                                        },
217                                    },
218                                );
219                                data.inventory_updates.insert(entity, event).unwrap();
220                            }
221                            can_pickup
222                        });
223
224                    if !ownership_check_passed {
225                        continue;
226                    }
227
228                    // First, we remove the item, assuming picking it up will succeed (we do this to
229                    // avoid cloning the item, as we should not call Item::clone and it
230                    // may be removed!).
231                    let item = if let Some(item) = data.items.remove(item_entity) {
232                        item
233                    } else {
234                        // Item component could not be found - most likely because the entity
235                        // attempted to pick up the same item very quickly before its deletion of
236                        // the world from the first pickup attempt was
237                        // processed.
238                        debug!(
239                            "Failed to delete item component for entity, Uid: {}",
240                            pickup_uid
241                        );
242                        continue;
243                    };
244
245                    const ITEM_ENTITY_EXPECT_MESSAGE: &str = "We know item_entity still exist \
246                                                              since we just successfully removed \
247                                                              its PickupItem component.";
248
249                    let (item, reinsert_item) = item.pick_up();
250
251                    let mut item_msg = item.frontend_item(&data.ability_map, &data.msm);
252
253                    // Next, we try to equip the picked up item
254                    let event = match inventory.try_equip(item).or_else(|returned_item| {
255                        // If we couldn't equip it (no empty slot for it or unequippable) then
256                        // attempt to add the item to the entity's inventory
257                        inventory.pickup_item(returned_item)
258                    }) {
259                        Err((returned_item, inserted)) => {
260                            // If we had a `reinsert_item`, merge returned_item into it
261                            let returned_item = if let Some(mut reinsert_item) = reinsert_item {
262                                reinsert_item
263                                    .try_merge(PickupItem::new(
264                                        returned_item,
265                                        *data.program_time,
266                                        true,
267                                    ))
268                                    .expect(
269                                        "We know this item must be mergeable since it is a \
270                                         duplicate",
271                                    );
272                                reinsert_item
273                            } else {
274                                PickupItem::new(returned_item, *data.program_time, true)
275                            };
276
277                            // Inventory was full, so we need to put back the item (note that we
278                            // know there was no old item component for
279                            // this entity).
280                            data.items
281                                .insert(item_entity, returned_item)
282                                .expect(ITEM_ENTITY_EXPECT_MESSAGE);
283
284                            // If the item was partially picked up, send a loot annoucement.
285                            if let Some(inserted) = inserted {
286                                // Update the frontend item to the new amount
287                                item_msg
288                                    .set_amount(inserted.get())
289                                    .expect("Inserted must be > 0 and <= item.max_amount()");
290
291                                if let Some(group_id) = data.groups.get(entity) {
292                                    announce_loot_to_group(
293                                        group_id,
294                                        entity,
295                                        item_msg.duplicate(&data.ability_map, &data.msm),
296                                        &data.clients,
297                                        &data.uids,
298                                        &data.groups,
299                                        &data.alignments,
300                                        &data.entities,
301                                        &data.ability_map,
302                                        &data.msm,
303                                    );
304                                }
305                                comp::InventoryUpdate::new(InventoryUpdateEvent::Collected(
306                                    item_msg,
307                                ))
308                            } else {
309                                comp::InventoryUpdate::new(
310                                    InventoryUpdateEvent::EntityCollectFailed {
311                                        entity: pickup_uid,
312                                        reason: CollectFailedReason::InventoryFull,
313                                    },
314                                )
315                            }
316                        },
317                        Ok(_) => {
318                            // We succeeded in picking up the item, so we may now delete its old
319                            // entity entirely.
320                            if let Some(reinsert_item) = reinsert_item {
321                                data.items
322                                    .insert(item_entity, reinsert_item)
323                                    .expect(ITEM_ENTITY_EXPECT_MESSAGE);
324                            } else {
325                                emitters.emit(DeleteEvent(item_entity));
326                            }
327
328                            if let Some(group_id) = data.groups.get(entity) {
329                                announce_loot_to_group(
330                                    group_id,
331                                    entity,
332                                    item_msg.duplicate(&data.ability_map, &data.msm),
333                                    &data.clients,
334                                    &data.uids,
335                                    &data.groups,
336                                    &data.alignments,
337                                    &data.entities,
338                                    &data.ability_map,
339                                    &data.msm,
340                                );
341                            }
342                            comp::InventoryUpdate::new(InventoryUpdateEvent::Collected(item_msg))
343                        },
344                    };
345
346                    data.inventory_updates
347                        .insert(entity, event)
348                        .expect("We know entity exists since we got its inventory.");
349                },
350                comp::InventoryManip::Collect {
351                    sprite_pos,
352                    required_item,
353                } => {
354                    let block = data.terrain.get(sprite_pos).ok().copied();
355                    let mut drop_items = Vec::new();
356                    let inventory_update = data
357                        .inventory_updates
358                        .entry(entity)
359                        .expect("We know entity exists since we got its inventory.")
360                        .or_insert_with(InventoryUpdate::default);
361
362                    if let Some(block) = block {
363                        // If there are items to be reclaimed from the block, add it to the
364                        // inventory
365                        if block.is_directly_collectible()
366                            && data.block_change.can_set_block(sprite_pos)
367                        {
368                            // Send event to rtsim if something was stolen.
369                            #[cfg(feature = "worldgen")]
370                            if block.is_owned()
371                                && let Some(actor) = super::entity_manipulation::entity_as_actor(
372                                    entity,
373                                    &data.rtsim_entities,
374                                    &data.presences,
375                                )
376                            {
377                                data.rtsim.hook_pickup_owned_sprite(
378                                    &data.world,
379                                    data.index.as_index_ref(),
380                                    block
381                                        .get_sprite()
382                                        .expect("If the block is owned, it is a sprite"),
383                                    sprite_pos,
384                                    actor,
385                                );
386                            }
387                            // If an item was required to collect the sprite, consume it now
388                            if let Some((inv_slot, true)) = required_item {
389                                inventory.take(inv_slot, &data.ability_map, &data.msm);
390                            }
391
392                            let sprite_cfg = data.terrain.sprite_cfg_at(sprite_pos);
393                            if let Some(items) =
394                                comp::Item::try_reclaim_from_block(block, sprite_cfg)
395                            {
396                                for item in
397                                    flatten_counted_items(&items, &data.ability_map, &data.msm)
398                                {
399                                    let mut item_msg =
400                                        item.frontend_item(&data.ability_map, &data.msm);
401                                    let do_announce = match inventory.push(item) {
402                                        Ok(_) => true,
403                                        Err((item, inserted)) => {
404                                            drop_items.push(item);
405                                            if let Some(inserted) = inserted {
406                                                // Update the amount of the frontend item
407                                                item_msg.set_amount(inserted.get()).expect(
408                                                    "Inserted must be > 0 and <= item.max_amount()",
409                                                );
410                                                true
411                                            } else {
412                                                false
413                                            }
414                                        },
415                                    };
416
417                                    if do_announce {
418                                        if let Some(group_id) = data.groups.get(entity) {
419                                            announce_loot_to_group(
420                                                group_id,
421                                                entity,
422                                                item_msg.duplicate(&data.ability_map, &data.msm),
423                                                &data.clients,
424                                                &data.uids,
425                                                &data.groups,
426                                                &data.alignments,
427                                                &data.entities,
428                                                &data.ability_map,
429                                                &data.msm,
430                                            );
431                                        }
432                                        inventory_update
433                                            .push(InventoryUpdateEvent::Collected(item_msg));
434                                    }
435                                }
436                            }
437
438                            // We made sure earlier the block was not already modified this tick
439                            data.block_change.set(sprite_pos, block.into_collected());
440
441                            // If the block was a keyhole, remove nearby door blocks
442                            // TODO: Abstract this code into a generalised way to do block updates?
443                            if let Some(kind_to_destroy) = match block.get_sprite() {
444                                Some(SpriteKind::Keyhole) => Some(SpriteKind::KeyDoor),
445                                Some(SpriteKind::BoneKeyhole) => Some(SpriteKind::BoneKeyDoor),
446                                Some(SpriteKind::HaniwaKeyhole) => Some(SpriteKind::HaniwaKeyDoor),
447                                Some(SpriteKind::SahaginKeyhole) => {
448                                    Some(SpriteKind::SahaginKeyDoor)
449                                },
450                                Some(SpriteKind::GlassKeyhole) => Some(SpriteKind::GlassBarrier),
451                                Some(SpriteKind::KeyholeBars) => Some(SpriteKind::DoorBars),
452                                Some(SpriteKind::TerracottaKeyhole) => {
453                                    Some(SpriteKind::TerracottaKeyDoor)
454                                },
455                                Some(SpriteKind::VampireKeyhole) => {
456                                    Some(SpriteKind::VampireKeyDoor)
457                                },
458                                Some(SpriteKind::MyrmidonKeyhole | SpriteKind::MinotaurKeyhole) => {
459                                    Some(SpriteKind::MyrmidonKeyDoor)
460                                },
461                                _ => None,
462                            } {
463                                let dirs = [
464                                    Vec3::unit_x(),
465                                    -Vec3::unit_x(),
466                                    Vec3::unit_y(),
467                                    -Vec3::unit_y(),
468                                    Vec3::unit_z(),
469                                    -Vec3::unit_z(),
470                                ];
471                                let mut destroyed = HashSet::<Vec3<i32>>::default();
472                                let mut pending = dirs
473                                    .into_iter()
474                                    .map(|dir| sprite_pos + dir)
475                                    .collect::<HashSet<_>>();
476                                // TODO: Replace with `entry` eventually
477                                while destroyed.len() < 450 {
478                                    if let Some(pos) = pending.iter().next().copied() {
479                                        pending.remove(&pos);
480
481                                        if !destroyed.contains(&pos)
482                                            && data
483                                                .terrain
484                                                .get(pos)
485                                                .ok()
486                                                .and_then(|b| b.get_sprite())
487                                                == Some(kind_to_destroy)
488                                        {
489                                            data.block_change.try_set(pos, Block::empty());
490                                            destroyed.insert(pos);
491                                            pending.extend(dirs.into_iter().map(|dir| pos + dir));
492                                        }
493                                    } else {
494                                        break;
495                                    }
496                                }
497                            }
498                        } else {
499                            debug!(
500                                "Can't reclaim item from block at pos={}: block is not \
501                                 collectable or was already set this tick.",
502                                sprite_pos
503                            );
504                        }
505                    }
506                    if !drop_items.is_empty() {
507                        inventory_update.push(InventoryUpdateEvent::BlockCollectFailed {
508                            pos: sprite_pos,
509                            reason: CollectFailedReason::InventoryFull,
510                        })
511                    }
512
513                    for item in drop_items {
514                        emitters.emit(CreateItemDropEvent {
515                            pos: comp::Pos(
516                                Vec3::new(
517                                    sprite_pos.x as f32,
518                                    sprite_pos.y as f32,
519                                    sprite_pos.z as f32,
520                                ) + Vec3::one().with_z(0.0) * 0.5,
521                            ),
522                            vel: comp::Vel(Vec3::zero()),
523                            ori: data.orientations.get(entity).copied().unwrap_or_default(),
524                            item: PickupItem::new(item, *data.program_time, true),
525                            loot_owner: Some(LootOwner::new(LootOwnerKind::Player(*uid), false)),
526                        });
527                    }
528                },
529                comp::InventoryManip::Use(slot) => {
530                    let mut maybe_effect = None;
531
532                    let event = match slot {
533                        Slot::Inventory(slot) => {
534                            use item::ItemKind;
535
536                            let (is_equippable, lantern_info) =
537                                inventory.get(slot).map_or((false, None), |i| {
538                                    let kind = i.kind();
539                                    let is_equippable = kind.is_equippable();
540                                    let lantern_info = match_some!(&*kind, ItemKind::Lantern(l) => (l.color(), l.strength()));
541                                    (is_equippable, lantern_info)
542                                });
543                            if is_equippable {
544                                if let Some(lantern_info) = lantern_info {
545                                    swap_lantern(&mut data.light_emitters, entity, lantern_info);
546                                }
547                                if let Some(pos) = data.positions.get(entity)
548                                    && let Ok(Some(unloaded_items)) = inventory.equip(
549                                        slot,
550                                        *data.time,
551                                        &data.ability_map,
552                                        &data.msm,
553                                    )
554                                {
555                                    dropped_items.extend(unloaded_items.into_iter().map(|item| {
556                                        (
557                                            *pos,
558                                            data.orientations
559                                                .get(entity)
560                                                .copied()
561                                                .unwrap_or_default(),
562                                            PickupItem::new(item, *data.program_time, true),
563                                            *uid,
564                                        )
565                                    }));
566                                }
567                                Some(InventoryUpdateEvent::Used)
568                            } else if let Some(item) =
569                                inventory.take(slot, &data.ability_map, &data.msm)
570                            {
571                                match &*item.kind() {
572                                    ItemKind::Consumable {
573                                        effects, container, ..
574                                    } => {
575                                        maybe_effect = Some(effects.clone());
576
577                                        if let Some(container) = container
578                                            && let Ok(container_item) =
579                                                comp::Item::new_from_item_definition_id(
580                                                    container.as_ref(),
581                                                    &data.ability_map,
582                                                    &data.msm,
583                                                )
584                                        {
585                                            let result = inventory.push(container_item);
586
587                                            if let Err((overflow_item, _)) = result
588                                                && let Some(pos) = data.positions.get(entity)
589                                            {
590                                                dropped_items.push((
591                                                    *pos,
592                                                    data.orientations
593                                                        .get(entity)
594                                                        .copied()
595                                                        .unwrap_or_default(),
596                                                    PickupItem::new(
597                                                        overflow_item,
598                                                        *data.program_time,
599                                                        true,
600                                                    ),
601                                                    *uid,
602                                                ));
603                                            }
604                                        }
605
606                                        Some(InventoryUpdateEvent::Consumed((&item).into()))
607                                    },
608                                    ItemKind::Utility {
609                                        kind: item::Utility::Collar,
610                                        ..
611                                    } => {
612                                        const MAX_PETS: usize = 3;
613                                        let reinsert = if let Some(pos) = data.positions.get(entity)
614                                        {
615                                            if (&data.alignments, &data.agents, data.pets.mask())
616                                                .join()
617                                                .filter(|(alignment, _, _)| {
618                                                    alignment == &&comp::Alignment::Owned(*uid)
619                                                })
620                                                .count()
621                                                >= MAX_PETS
622                                            {
623                                                true
624                                            } else if let Some(tameable_entity) = {
625                                                (
626                                                    &data.entities,
627                                                    &data.bodies,
628                                                    &data.positions,
629                                                    &data.alignments,
630                                                )
631                                                    .join()
632                                                    .filter(|(_, _, wild_pos, _)| {
633                                                        wild_pos.0.distance_squared(pos.0)
634                                                            < 5.0f32.powi(2)
635                                                    })
636                                                    .filter(|(_, body, _, alignment)| {
637                                                        alignment == &&Alignment::Wild
638                                                            && is_tameable(body)
639                                                    })
640                                                    .min_by_key(|(_, _, wild_pos, _)| {
641                                                        (wild_pos.0.distance_squared(pos.0) * 100.0)
642                                                            as i32
643                                                    })
644                                                    .map(|(entity, _, _, _)| entity)
645                                            } {
646                                                emitters.emit(TamePetEvent {
647                                                    owner_entity: entity,
648                                                    pet_entity: tameable_entity,
649                                                });
650                                                false
651                                            } else {
652                                                true
653                                            }
654                                        } else {
655                                            true
656                                        };
657
658                                        if reinsert {
659                                            let _ = inventory.insert_or_stack_at(slot, item);
660                                        }
661
662                                        Some(InventoryUpdateEvent::Used)
663                                    },
664                                    ItemKind::RecipeGroup { .. } => {
665                                        match inventory.push_recipe_group(item) {
666                                            Ok(()) => {
667                                                if let Some(client) = data.clients.get(entity) {
668                                                    client.send_fallible(
669                                                        ServerGeneral::UpdateRecipes,
670                                                    );
671                                                }
672                                                Some(InventoryUpdateEvent::Used)
673                                            },
674                                            Err(item) => {
675                                                inventory.insert_or_stack_at(slot, item).expect(
676                                                    "slot was just vacated of item, so it \
677                                                     definitely fits there.",
678                                                );
679                                                None
680                                            },
681                                        }
682                                    },
683                                    _ => {
684                                        inventory.insert_or_stack_at(slot, item).expect(
685                                            "slot was just vacated of item, so it definitely fits \
686                                             there.",
687                                        );
688                                        None
689                                    },
690                                }
691                            } else {
692                                None
693                            }
694                        },
695                        Slot::Equip(slot) => {
696                            if slot == slot::EquipSlot::Lantern {
697                                snuff_lantern(&mut data.light_emitters, entity);
698                            }
699
700                            if let Some(pos) = data.positions.get(entity) {
701                                // Unequip the item, any items that no longer fit within the
702                                // inventory (due to unequipping a
703                                // bag for example) will be dropped on the floor
704                                if let Ok(Some(leftover_items)) =
705                                    inventory.unequip(slot, *data.time)
706                                {
707                                    dropped_items.extend(leftover_items.into_iter().map(|item| {
708                                        (
709                                            *pos,
710                                            data.orientations
711                                                .get(entity)
712                                                .copied()
713                                                .unwrap_or_default(),
714                                            PickupItem::new(item, *data.program_time, true),
715                                            *uid,
716                                        )
717                                    }));
718                                }
719                            }
720                            Some(InventoryUpdateEvent::Used)
721                        },
722                        // Items in overflow slots cannot be used
723                        Slot::Overflow(_) => None,
724                    };
725
726                    if let Some(effects) = maybe_effect {
727                        match effects {
728                            item::Effects::Any(effects) => {
729                                if let Some(effect) = effects.into_iter().choose(&mut rng) {
730                                    emit_effect_events(
731                                        &mut emitters,
732                                        *data.time,
733                                        entity,
734                                        effect,
735                                        None,
736                                        data.inventories.get(entity),
737                                        &data.msm,
738                                        data.character_states.get(entity),
739                                        data.stats.get(entity),
740                                        data.masses.get(entity),
741                                        None,
742                                        data.bodies.get(entity),
743                                        data.positions.get(entity),
744                                    );
745                                }
746                            },
747                            item::Effects::All(effects) => {
748                                for effect in effects {
749                                    emit_effect_events(
750                                        &mut emitters,
751                                        *data.time,
752                                        entity,
753                                        effect,
754                                        None,
755                                        data.inventories.get(entity),
756                                        &data.msm,
757                                        data.character_states.get(entity),
758                                        data.stats.get(entity),
759                                        data.masses.get(entity),
760                                        None,
761                                        data.bodies.get(entity),
762                                        data.positions.get(entity),
763                                    );
764                                }
765                            },
766                            item::Effects::One(effect) => {
767                                emit_effect_events(
768                                    &mut emitters,
769                                    *data.time,
770                                    entity,
771                                    effect,
772                                    None,
773                                    data.inventories.get(entity),
774                                    &data.msm,
775                                    data.character_states.get(entity),
776                                    data.stats.get(entity),
777                                    data.masses.get(entity),
778                                    None,
779                                    data.bodies.get(entity),
780                                    data.positions.get(entity),
781                                );
782                            },
783                        }
784                    }
785                    if let Some(event) = event {
786                        data.inventory_updates
787                            .insert(entity, comp::InventoryUpdate::new(event))
788                            .expect("We know entity exists since we got its inventory.");
789                    }
790                },
791                comp::InventoryManip::Swap(a, b) => {
792                    use item::ItemKind;
793
794                    if let Some(lantern_info) = match (a, b) {
795                        // Only current possible lantern swap is between Slot::Inventory and
796                        // Slot::Equip add more cases if needed
797                        (Slot::Equip(slot::EquipSlot::Lantern), Slot::Inventory(slot))
798                        | (Slot::Inventory(slot), Slot::Equip(slot::EquipSlot::Lantern)) => {
799                            inventory.get(slot).and_then(|i| {
800                                match_some!(&*i.kind(), ItemKind::Lantern(l) => (l.color(), l.strength()))
801                            })
802                        },
803                        _ => None,
804                    } {
805                        swap_lantern(&mut data.light_emitters, entity, lantern_info);
806                    }
807
808                    if let Some(pos) = data.positions.get(entity) {
809                        let mut merged_stacks = false;
810
811                        // If both slots have items and we're attempting to drag from one stack
812                        // into another, stack the items.
813                        if let (Slot::Inventory(slot_a), Slot::Inventory(slot_b)) = (a, b) {
814                            merged_stacks |= inventory.merge_stack_into(slot_a, slot_b);
815                        }
816
817                        // If the stacks weren't mergable carry out a swap.
818                        if !merged_stacks {
819                            dropped_items.extend(inventory.swap(a, b, *data.time).into_iter().map(
820                                |item| {
821                                    (
822                                        *pos,
823                                        data.orientations.get(entity).copied().unwrap_or_default(),
824                                        PickupItem::new(item, *data.program_time, true),
825                                        *uid,
826                                    )
827                                },
828                            ));
829                        }
830                    }
831
832                    data.inventory_updates
833                        .insert(
834                            entity,
835                            comp::InventoryUpdate::new(InventoryUpdateEvent::Swapped),
836                        )
837                        .expect("We know entity exists since we got its inventory.");
838                },
839                comp::InventoryManip::SplitSwap(slot, target) => {
840                    // If both slots have items and we're attempting to split from one stack
841                    // into another, ensure that they are the same type of item. If they are
842                    // the same type do nothing, as you don't want to overwrite the existing item.
843
844                    if let (
845                        Slot::Inventory(source_inv_slot_id),
846                        Slot::Inventory(target_inv_slot_id),
847                    ) = (slot, target)
848                        && let Some(source_item) = inventory.get(source_inv_slot_id)
849                        && let Some(target_item) = inventory.get(target_inv_slot_id)
850                        && source_item != target_item
851                    {
852                        continue;
853                    }
854
855                    let item = match slot {
856                        Slot::Inventory(slot) => {
857                            inventory.take_half(slot, &data.ability_map, &data.msm)
858                        },
859                        Slot::Equip(_) => None,
860                        Slot::Overflow(_) => None,
861                    };
862
863                    if let Some(item) = item
864                        && let Slot::Inventory(target) = target
865                    {
866                        inventory.insert_or_stack_at(target, item).ok();
867                    }
868
869                    data.inventory_updates
870                        .insert(
871                            entity,
872                            comp::InventoryUpdate::new(InventoryUpdateEvent::Swapped),
873                        )
874                        .expect("We know entity exists since we got its inventory.");
875                },
876                comp::InventoryManip::Drop(slot) => {
877                    let item = match slot {
878                        Slot::Inventory(slot) => inventory.remove(slot),
879                        Slot::Equip(slot) => inventory.replace_loadout_item(slot, None, *data.time),
880                        Slot::Overflow(slot) => inventory.overflow_remove(slot),
881                    };
882
883                    // FIXME: We should really require the drop and write to be atomic!
884                    if let (Some(mut item), Some(pos)) = (item, data.positions.get(entity)) {
885                        item.put_in_world();
886                        dropped_items.push((
887                            *pos,
888                            data.orientations.get(entity).copied().unwrap_or_default(),
889                            PickupItem::new(item, *data.program_time, true),
890                            *uid,
891                        ));
892                    }
893                    data.inventory_updates
894                        .insert(
895                            entity,
896                            comp::InventoryUpdate::new(InventoryUpdateEvent::Dropped),
897                        )
898                        .expect("We know entity exists since we got its inventory.");
899                },
900                comp::InventoryManip::SplitDrop(slot) => {
901                    let item = match slot {
902                        Slot::Inventory(slot) => {
903                            inventory.take_half(slot, &data.ability_map, &data.msm)
904                        },
905                        Slot::Equip(_) => None,
906                        Slot::Overflow(o) => {
907                            inventory.overflow_take_half(o, &data.ability_map, &data.msm)
908                        },
909                    };
910
911                    // FIXME: We should really require the drop and write to be atomic!
912                    if let (Some(mut item), Some(pos)) = (item, data.positions.get(entity)) {
913                        item.put_in_world();
914                        dropped_items.push((
915                            *pos,
916                            data.orientations.get(entity).copied().unwrap_or_default(),
917                            PickupItem::new(item, *data.program_time, true),
918                            *uid,
919                        ));
920                    }
921                    data.inventory_updates
922                        .insert(
923                            entity,
924                            comp::InventoryUpdate::new(InventoryUpdateEvent::Dropped),
925                        )
926                        .expect("We know entity exists since we got its inventory.");
927                },
928                comp::InventoryManip::CraftRecipe {
929                    craft_event,
930                    craft_sprite,
931                } => {
932                    use comp::controller::CraftEvent;
933                    use recipe::ComponentKey;
934
935                    let get_craft_sprite = |sprite_pos: Option<VolumePos>| {
936                        sprite_pos
937                            .filter(|pos| {
938                                let entity_cylinder = get_cylinder(entity);
939                                let in_range = within_pickup_range(entity_cylinder, || {
940                                    pos.get_block_and_transform(
941                                        &data.terrain,
942                                        &data.id_maps,
943                                        |e| {
944                                            data.positions
945                                                .get(e)
946                                                .copied()
947                                                .zip(data.orientations.get(e).copied())
948                                        },
949                                        &data.colliders,
950                                    )
951                                    .map(|(mat, _)| mat.mul_point(Vec3::broadcast(0.5)))
952                                });
953                                if !in_range {
954                                    debug!(
955                                        ?entity_cylinder,
956                                        "Failed to craft recipe as not within range of required \
957                                         sprite, sprite pos: {:?}",
958                                        pos
959                                    );
960                                }
961                                in_range
962                            })
963                            .and_then(|pos| {
964                                pos.get_block(&data.terrain, &data.id_maps, &data.colliders)
965                            })
966                            .and_then(|block| block.get_sprite())
967                    };
968
969                    let crafted_items = match craft_event {
970                        CraftEvent::Simple {
971                            recipe,
972                            slots,
973                            amount,
974                        } => {
975                            let filtered_recipe = inventory
976                                .get_recipe(&recipe, &data.rbm)
977                                .cloned()
978                                .filter(|r| {
979                                    if let Some(needed_sprite) = r.craft_sprite {
980                                        let sprite = get_craft_sprite(craft_sprite);
981                                        Some(needed_sprite) == sprite
982                                    } else {
983                                        true
984                                    }
985                                });
986                            if let Some(recipe) = filtered_recipe {
987                                let items = (0..amount)
988                                    .filter_map(|_| {
989                                        recipe
990                                            .craft_simple(
991                                                &mut inventory,
992                                                slots.clone(),
993                                                &data.ability_map,
994                                                &data.msm,
995                                            )
996                                            .ok()
997                                    })
998                                    .flatten()
999                                    .collect::<Vec<_>>();
1000
1001                                if items.is_empty() { None } else { Some(items) }
1002                            } else {
1003                                None
1004                            }
1005                        },
1006                        CraftEvent::Salvage(slot) => {
1007                            let sprite = get_craft_sprite(craft_sprite);
1008                            if matches!(sprite, Some(SpriteKind::DismantlingBench)) {
1009                                recipe::try_salvage(
1010                                    &mut inventory,
1011                                    slot,
1012                                    &data.ability_map,
1013                                    &data.msm,
1014                                )
1015                                .ok()
1016                            } else {
1017                                None
1018                            }
1019                        },
1020                        CraftEvent::ModularWeapon {
1021                            primary_component,
1022                            secondary_component,
1023                        } => {
1024                            let sprite = get_craft_sprite(craft_sprite);
1025                            if matches!(sprite, Some(SpriteKind::CraftingBench)) {
1026                                recipe::modular_weapon(
1027                                    &mut inventory,
1028                                    primary_component,
1029                                    secondary_component,
1030                                    &data.ability_map,
1031                                    &data.msm,
1032                                )
1033                                .ok()
1034                                .map(|item| vec![item])
1035                            } else {
1036                                None
1037                            }
1038                        },
1039                        CraftEvent::ModularWeaponPrimaryComponent {
1040                            toolkind,
1041                            material,
1042                            modifier,
1043                            slots,
1044                        } => {
1045                            let component_recipes = default_component_recipe_book().read();
1046                            let item_id = |slot| {
1047                                inventory.get(slot).and_then(|item| {
1048                                    item.item_definition_id().itemdef_id().map(String::from)
1049                                })
1050                            };
1051                            if let Some(material_item_id) = item_id(material) {
1052                                component_recipes
1053                                    .get(&ComponentKey {
1054                                        toolkind,
1055                                        material: material_item_id,
1056                                        modifier: modifier.and_then(item_id),
1057                                    })
1058                                    .filter(|r| {
1059                                        let sprite = if let Some(needed_sprite) = r.craft_sprite {
1060                                            let sprite = get_craft_sprite(craft_sprite);
1061                                            Some(needed_sprite) == sprite
1062                                        } else {
1063                                            true
1064                                        };
1065                                        let known = inventory.recipe_is_known(&r.recipe_book_key);
1066                                        sprite && known
1067                                    })
1068                                    .and_then(|r| {
1069                                        r.craft_component(
1070                                            &mut inventory,
1071                                            material,
1072                                            modifier,
1073                                            slots,
1074                                            &data.ability_map,
1075                                            &data.msm,
1076                                        )
1077                                        .ok()
1078                                    })
1079                            } else {
1080                                None
1081                            }
1082                        },
1083                        CraftEvent::Repair { item, slots } => {
1084                            let repair_recipes = default_repair_recipe_book().read();
1085                            let sprite = get_craft_sprite(craft_sprite);
1086                            if matches!(sprite, Some(SpriteKind::RepairBench)) {
1087                                let _ = repair_recipes.repair_item(
1088                                    &mut inventory,
1089                                    item,
1090                                    slots,
1091                                    &data.ability_map,
1092                                    &data.msm,
1093                                );
1094                            }
1095                            None
1096                        },
1097                    };
1098
1099                    // Attempt to insert items into inventory, dropping them if there is not enough
1100                    // space
1101                    let items_were_crafted = if let Some(crafted_items) = crafted_items {
1102                        let mut dropped: Vec<PickupItem> = Vec::new();
1103                        for item in crafted_items {
1104                            if let Err((item, _inserted)) = inventory.push(item) {
1105                                let item = PickupItem::new(item, *data.program_time, true);
1106                                if let Some(can_merge) =
1107                                    dropped.iter_mut().find(|other| other.can_merge(&item))
1108                                {
1109                                    can_merge
1110                                        .try_merge(item)
1111                                        .expect("We know these items can be merged");
1112                                } else {
1113                                    dropped.push(item);
1114                                }
1115                            }
1116                        }
1117
1118                        if !dropped.is_empty()
1119                            && let Some(pos) = data.positions.get(entity)
1120                        {
1121                            for item in dropped {
1122                                dropped_items.push((
1123                                    *pos,
1124                                    data.orientations.get(entity).copied().unwrap_or_default(),
1125                                    item,
1126                                    *uid,
1127                                ));
1128                            }
1129                        }
1130
1131                        true
1132                    } else {
1133                        false
1134                    };
1135
1136                    // FIXME: We should really require the drop and write to be atomic!
1137                    if items_were_crafted {
1138                        let _ = data.inventory_updates.insert(
1139                            entity,
1140                            comp::InventoryUpdate::new(InventoryUpdateEvent::Craft),
1141                        );
1142                    }
1143                },
1144                comp::InventoryManip::Sort(sort_order) => {
1145                    inventory.sort(sort_order);
1146                },
1147                comp::InventoryManip::SwapEquippedWeapons => {
1148                    inventory.swap_equipped_weapons(*data.time);
1149                },
1150            }
1151            if data.trades.in_mutable_trade(uid) {
1152                // manipulating the inventory mutated the trade, so reset the accept flags
1153                data.trades.implicit_mutation_occurred(uid);
1154            }
1155        }
1156
1157        // Drop items, Debug items should simply disappear when dropped
1158        for (pos, ori, mut item, owner) in dropped_items
1159            .into_iter()
1160            .filter(|(_, _, i, _)| !matches!(i.item().quality(), item::Quality::Debug))
1161        {
1162            item.remove_debug_items();
1163
1164            emitters.emit(CreateItemDropEvent {
1165                pos,
1166                vel: comp::Vel::default(),
1167                ori,
1168                item,
1169                loot_owner: Some(LootOwner::new(LootOwnerKind::Player(owner), true)),
1170            })
1171        }
1172    }
1173}
1174
1175fn within_pickup_range<S: FindDist<find_dist::Cylinder>>(
1176    entity_cylinder: Option<find_dist::Cylinder>,
1177    shape_fn: impl FnOnce() -> Option<S>,
1178) -> bool {
1179    entity_cylinder
1180        .and_then(|entity_cylinder| {
1181            shape_fn().map(|shape| shape.min_distance(entity_cylinder) < MAX_PICKUP_RANGE)
1182        })
1183        .unwrap_or(false)
1184}
1185
1186fn announce_loot_to_group(
1187    group_id: &Group,
1188    entity: EcsEntity,
1189    item: comp::FrontendItem,
1190    clients: &ReadStorage<Client>,
1191    uids: &ReadStorage<Uid>,
1192    groups: &ReadStorage<comp::Group>,
1193    alignments: &ReadStorage<comp::Alignment>,
1194    entities: &Entities,
1195    ability_map: &AbilityMap,
1196    msm: &MaterialStatManifest,
1197) {
1198    if let Some(uid) = uids.get(entity) {
1199        members(*group_id, groups, entities, alignments, uids)
1200            .filter(|(member_e, _)| member_e != &entity)
1201            .for_each(|(e, _)| {
1202                clients.get(e).map(|c| {
1203                    c.send_fallible(ServerGeneral::GroupInventoryUpdate(
1204                        item.duplicate(ability_map, msm),
1205                        *uid,
1206                    ));
1207                });
1208            });
1209    }
1210}
1211
1212#[cfg(test)]
1213mod tests {
1214    use vek::Vec3;
1215
1216    use common::comp::Pos;
1217    use find_dist::*;
1218
1219    use super::*;
1220
1221    // Helper function
1222    fn test_cylinder(pos: Pos) -> Option<Cylinder> {
1223        Some(Cylinder::from_components(pos.0, None, None, None))
1224    }
1225
1226    #[test]
1227    fn pickup_distance_within_range() {
1228        let position = Pos(Vec3::zero());
1229        let item_position = Pos(Vec3::one());
1230
1231        assert!(within_pickup_range(test_cylinder(position), || {
1232            test_cylinder(item_position)
1233        },),);
1234    }
1235
1236    #[test]
1237    fn pickup_distance_not_within_range() {
1238        let position = Pos(Vec3::zero());
1239        let item_position = Pos(Vec3::one() * 500.0);
1240
1241        assert!(!within_pickup_range(test_cylinder(position), || {
1242            test_cylinder(item_position)
1243        },),);
1244    }
1245}