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}