{
public static class ReusableAnimations
{
- public static void AnimateEntityPickup(EntityUid entity, EntityCoordinates initialPosition, Vector2 finalPosition, Angle initialAngle, IEntityManager? entMan = null)
+ public static void AnimateEntityPickup(EntityUid entity, EntityCoordinates initialCoords, Vector2 finalPosition, Angle initialAngle, IEntityManager? entMan = null)
{
IoCManager.Resolve(ref entMan);
- if (entMan.Deleted(entity) || !initialPosition.IsValid(entMan))
+ if (entMan.Deleted(entity) || !initialCoords.IsValid(entMan))
return;
var metadata = entMan.GetComponent<MetaDataComponent>(entity);
if (entMan.IsPaused(entity, metadata))
return;
- var animatableClone = entMan.SpawnEntity("clientsideclone", initialPosition);
+ var animatableClone = entMan.SpawnEntity("clientsideclone", initialCoords);
string val = entMan.GetComponent<MetaDataComponent>(entity).EntityName;
entMan.System<MetaDataSystem>().SetEntityName(animatableClone, val);
sprite.Visible = true;
var animations = entMan.GetComponent<AnimationPlayerComponent>(animatableClone);
- animations.AnimationCompleted += (_) => {
+ animations.AnimationCompleted += (_) =>
+ {
entMan.DeleteEntity(animatableClone);
};
InterpolationMode = AnimationInterpolationMode.Linear,
KeyFrames =
{
- new AnimationTrackProperty.KeyFrame(initialPosition.Position, 0),
+ new AnimationTrackProperty.KeyFrame(initialCoords.Position, 0),
new AnimationTrackProperty.KeyFrame(finalPosition, 0.125f)
}
},
SubscribeLocalEvent<HandsComponent, ComponentHandleState>(HandleComponentState);
SubscribeLocalEvent<HandsComponent, VisualsChangedEvent>(OnVisualsChanged);
- SubscribeNetworkEvent<PickupAnimationEvent>(HandlePickupAnimation);
-
OnHandSetActive += OnHandActivated;
}
}
#endregion
- #region PickupAnimation
- private void HandlePickupAnimation(PickupAnimationEvent msg)
- {
- PickupAnimation(GetEntity(msg.ItemUid), GetCoordinates(msg.InitialPosition), msg.FinalPosition, msg.InitialAngle);
- }
-
- public override void PickupAnimation(EntityUid item, EntityCoordinates initialPosition, Vector2 finalPosition, Angle initialAngle,
- EntityUid? exclude)
- {
- PickupAnimation(item, initialPosition, finalPosition, initialAngle);
- }
-
- public void PickupAnimation(EntityUid item, EntityCoordinates initialPosition, Vector2 finalPosition, Angle initialAngle)
- {
- if (!_gameTiming.IsFirstTimePredicted)
- return;
-
- if (finalPosition.EqualsApprox(initialPosition.Position, tolerance: 0.1f))
- return;
-
- ReusableAnimations.AnimateEntityPickup(item, initialPosition, finalPosition, initialAngle);
- }
- #endregion
-
public void ReloadHandButtons()
{
if (!TryGetPlayerHands(out var hands))
using Content.Client.Animations;
+using Content.Shared.Hands;
using Content.Shared.Storage;
using Content.Shared.Storage.EntitySystems;
+using Robust.Shared.Map;
using Robust.Shared.Timing;
namespace Content.Client.Storage.Systems;
{
base.Initialize();
+ SubscribeNetworkEvent<PickupAnimationEvent>(HandlePickupAnimation);
SubscribeNetworkEvent<AnimateInsertingEntitiesEvent>(HandleAnimatingInsertingEntities);
}
StorageUpdated?.Invoke(uid, component);
}
+ /// <inheritdoc />
+ public override void PlayPickupAnimation(EntityUid uid, EntityCoordinates initialCoordinates, EntityCoordinates finalCoordinates,
+ Angle initialRotation, EntityUid? user = null)
+ {
+ if (!_timing.IsFirstTimePredicted)
+ return;
+
+ PickupAnimation(uid, initialCoordinates, finalCoordinates, initialRotation);
+ }
+
+ private void HandlePickupAnimation(PickupAnimationEvent msg)
+ {
+ PickupAnimation(GetEntity(msg.ItemUid), GetCoordinates(msg.InitialPosition), GetCoordinates(msg.FinalPosition), msg.InitialAngle);
+ }
+
+ public void PickupAnimation(EntityUid item, EntityCoordinates initialCoords, EntityCoordinates finalCoords, Angle initialAngle)
+ {
+ if (!_timing.IsFirstTimePredicted)
+ return;
+
+ if (finalCoords.InRange(EntityManager, _transform, initialCoords, 0.1f) ||
+ !Exists(initialCoords.EntityId) || !Exists(finalCoords.EntityId))
+ {
+ return;
+ }
+
+ var finalMapPos = finalCoords.ToMapPos(EntityManager, _transform);
+ var finalPos = _transform.GetInvWorldMatrix(initialCoords.EntityId).Transform(finalMapPos);
+
+ ReusableAnimations.AnimateEntityPickup(item, initialCoords, finalPos, initialAngle);
+ }
+
/// <summary>
/// Animate the newly stored entities in <paramref name="msg"/> flying towards this storage's position
/// </summary>
{
var playerEnt = SEntMan.GetEntity(Player);
- Assert.That(HandSys.TryPickup(playerEnt, item, Hands.ActiveHand, false, false, false, Hands));
+ Assert.That(HandSys.TryPickup(playerEnt, item, Hands.ActiveHand, false, false, Hands));
// turn on welders
if (enableWelder && SEntMan.TryGetComponent(item, out welder) && !welder.Lit)
await Server.WaitPost(() =>
{
- Assert.That(HandSys.TryPickup(SEntMan.GetEntity(Player), uid.Value, Hands.ActiveHand, false, false, false, Hands, item));
+ Assert.That(HandSys.TryPickup(SEntMan.GetEntity(Player), uid.Value, Hands.ActiveHand, false, false, Hands, item));
});
await RunTicks(1);
for (var i = 0; i < message.Number; i++)
{
var item = Spawn(PillPrototypeId, Transform(container).Coordinates);
- _storageSystem.Insert(container, item, user, storage);
+ _storageSystem.Insert(container, item, out _, user: user, storage);
_labelSystem.Label(item, message.Label);
var itemSolution = _solutionContainerSystem.EnsureSolution(item, SharedChemMaster.PillSolutionName);
//put the unused parts back into rped. (this also does the "swapping")
foreach (var (unused, _) in machineParts)
{
- _storage.Insert(storageUid, unused, playSound: false);
+ _storage.Insert(storageUid, unused, out _, playSound: false);
}
_construction.RefreshParts(uid, machine);
}
//put the unused parts back into rped. (this also does the "swapping")
foreach (var (unused, _) in machineParts)
{
- _storage.Insert(storageEnt, unused, playSound: false);
+ _storage.Insert(storageEnt, unused, out _, playSound: false);
}
}
[Dependency] private readonly PullingSystem _pullingSystem = default!;
[Dependency] private readonly ThrowingSystem _throwingSystem = default!;
[Dependency] private readonly StorageSystem _storageSystem = default!;
- [Dependency] private readonly ISharedPlayerManager _player = default!;
- [Dependency] private readonly IConfigurationManager _configuration = default!;
public override void Initialize()
{
args.Handled = true; // no shove/stun.
}
- public override void PickupAnimation(EntityUid item, EntityCoordinates initialPosition, Vector2 finalPosition, Angle initialAngle,
- EntityUid? exclude)
- {
- if (finalPosition.EqualsApprox(initialPosition.Position, tolerance: 0.1f))
- return;
-
- var filter = Filter.Pvs(item, entityManager: EntityManager, playerManager: _player, cfgManager: _configuration);
-
- if (exclude != null)
- filter = filter.RemoveWhereAttachedEntity(entity => entity == exclude);
-
- RaiseNetworkEvent(new PickupAnimationEvent(GetNetEntity(item), GetNetCoordinates(initialPosition), finalPosition, initialAngle), filter);
- }
-
protected override void HandleEntityRemoved(EntityUid uid, HandsComponent hands, EntRemovedFromContainerMessage args)
{
base.HandleEntityRemoved(uid, hands, args);
if (entityStorageComp != null && EntityStorage.Insert(ent, uid))
continue;
- if (storageComp != null && Insert(uid, ent, storageComp: storageComp, playSound: false))
+ if (storageComp != null && Insert(uid, ent, out _, storageComp: storageComp, playSound: false))
continue;
Log.Error($"Tried to StorageFill {item} inside {ToPrettyString(uid)} but can't.");
using Content.Server.Administration.Managers;
using Content.Shared.Administration;
using Content.Shared.Ghost;
+using Content.Shared.Hands;
using Content.Shared.Lock;
using Content.Shared.Storage;
using Content.Shared.Storage.Components;
using Content.Shared.Verbs;
using Robust.Server.GameObjects;
using Robust.Server.Player;
+using Robust.Shared.Map;
using Robust.Shared.Player;
using Robust.Shared.Players;
using Robust.Shared.Utility;
_uiSystem.OpenUi(bui, player.PlayerSession);
}
+ /// <inheritdoc />
+ public override void PlayPickupAnimation(EntityUid uid, EntityCoordinates initialCoordinates, EntityCoordinates finalCoordinates,
+ Angle initialRotation, EntityUid? user = null)
+ {
+ var filter = Filter.Pvs(uid).RemoveWhereAttachedEntity(e => e == user);
+ RaiseNetworkEvent(new PickupAnimationEvent(GetNetEntity(uid), GetNetCoordinates(initialCoordinates), GetNetCoordinates(finalCoordinates), initialRotation), filter);
+ }
+
/// <summary>
/// If the user has nested-UIs open (e.g., PDA UI open when pda is in a backpack), close them.
/// </summary>
if (hand == null)
return false;
- return TryPickup(uid, entity, hand, checkActionBlocker, animateUser, animate, handsComp, item);
+ return TryPickup(uid, entity, hand, checkActionBlocker, animate, handsComp, item);
}
/// <summary>
if (!TryGetEmptyHand(uid, out var hand, handsComp))
return false;
- return TryPickup(uid, entity, hand, checkActionBlocker, animateUser, animate, handsComp, item);
+ return TryPickup(uid, entity, hand, checkActionBlocker, animate, handsComp, item);
}
public bool TryPickup(
EntityUid entity,
Hand hand,
bool checkActionBlocker = true,
- bool animateUser = false,
bool animate = true,
HandsComponent? handsComp = null,
ItemComponent? item = null)
&& MetaData(entity).VisibilityMask == MetaData(uid).VisibilityMask) // Don't animate aghost pickups.
{
var initialPosition = EntityCoordinates.FromMap(coordinateEntity, itemPos, EntityManager);
- PickupAnimation(entity, initialPosition, xform.LocalPosition, itemXform.LocalRotation, animateUser ? null : uid);
+ _storage.PlayPickupAnimation(entity, initialPosition, xform.Coordinates, itemXform.LocalRotation, uid);
}
}
DoPickup(uid, hand, entity, handsComp);
if (uid == null
|| !Resolve(uid.Value, ref handsComp, false)
|| !TryGetEmptyHand(uid.Value, out var hand, handsComp)
- || !TryPickup(uid.Value, entity, hand, checkActionBlocker, animateUser, animate, handsComp, item))
+ || !TryPickup(uid.Value, entity, hand, checkActionBlocker, animate, handsComp, item))
{
// TODO make this check upwards for any container, and parent to that.
// Currently this just checks the direct parent, so items can still teleport through containers.
_adminLogger.Add(LogType.Pickup, LogImpact.Low, $"{ToPrettyString(uid):user} picked up {ToPrettyString(entity):entity}");
- Dirty(hands);
+ Dirty(uid, hands);
if (hand == hands.ActiveHand)
RaiseLocalEvent(entity, new HandSelectedEvent(uid), false);
}
-
- public abstract void PickupAnimation(EntityUid item, EntityCoordinates initialPosition, Vector2 finalPosition, Angle initialAngle,
- EntityUid? exclude);
}
using Content.Shared.Hands.Components;
using Content.Shared.Interaction;
using Content.Shared.Item;
+using Content.Shared.Storage.EntitySystems;
using Robust.Shared.Containers;
using Robust.Shared.Input.Binding;
[Dependency] private readonly SharedContainerSystem _containerSystem = default!;
[Dependency] private readonly SharedInteractionSystem _interactionSystem = default!;
[Dependency] private readonly SharedItemSystem _items = default!;
+ [Dependency] private readonly SharedStorageSystem _storage = default!;
+ [Dependency] protected readonly SharedTransformSystem TransformSystem = default!;
protected event Action<HandsComponent?>? OnHandSetActive;
}
}
+ /// <summary>
+ /// Plays a clientside pickup animation by copying the specified entity.
+ /// </summary>
[Serializable, NetSerializable]
public sealed class PickupAnimationEvent : EntityEventArgs
{
- public NetEntity ItemUid { get; }
- public NetCoordinates InitialPosition { get; }
- public Vector2 FinalPosition { get; }
- public Angle InitialAngle { get; }
-
- public PickupAnimationEvent(NetEntity itemUid, NetCoordinates initialPosition,
- Vector2 finalPosition, Angle initialAngle)
+ /// <summary>
+ /// Entity to be copied for the clientside animation.
+ /// </summary>
+ public readonly NetEntity ItemUid;
+ public readonly NetCoordinates InitialPosition;
+ public readonly NetCoordinates FinalPosition;
+ public readonly Angle InitialAngle;
+
+ public PickupAnimationEvent(NetEntity itemUid,
+ NetCoordinates initialPosition,
+ NetCoordinates finalPosition,
+ Angle initialAngle)
{
ItemUid = itemUid;
FinalPosition = finalPosition;
using System.Numerics;
using Content.Shared.Examine;
+using Content.Shared.Hands;
using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Interaction;
using Content.Shared.Popups;
+using Content.Shared.Storage.EntitySystems;
using JetBrains.Annotations;
using Robust.Shared.GameStates;
using Robust.Shared.Physics.Systems;
[Dependency] protected readonly SharedAppearanceSystem Appearance = default!;
[Dependency] protected readonly SharedHandsSystem Hands = default!;
[Dependency] protected readonly SharedTransformSystem Xform = default!;
- [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
- [Dependency] private readonly SharedPhysicsSystem _physics = default!;
+ [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
+ [Dependency] private readonly SharedPhysicsSystem _physics = default!;
[Dependency] protected readonly SharedPopupSystem Popup = default!;
+ [Dependency] private readonly SharedStorageSystem _storage = default!;
public override void Initialize()
{
if (!TryComp(args.Used, out StackComponent? recipientStack))
return;
+ var localRotation = Transform(args.Used).LocalRotation;
+
if (!TryMergeStacks(uid, args.Used, out var transfered, stack, recipientStack))
return;
return;
var popupPos = args.ClickLocation;
+ var userCoords = Transform(args.User).Coordinates;
if (!popupPos.IsValid(EntityManager))
{
- popupPos = Transform(args.User).Coordinates;
+ popupPos = userCoords;
}
switch (transfered)
Popup.PopupCoordinates(Loc.GetString("comp-stack-already-full"), popupPos, Filter.Local(), false);
break;
}
+
+ _storage.PlayPickupAnimation(args.Used, popupPos, userCoords, localRotation, args.User);
}
private bool TryMergeStacks(
EntityUid donor,
EntityUid recipient,
- out int transfered,
+ out int transferred,
StackComponent? donorStack = null,
StackComponent? recipientStack = null)
{
- transfered = 0;
+ transferred = 0;
if (donor == recipient)
return false;
if (string.IsNullOrEmpty(recipientStack.StackTypeId) || !recipientStack.StackTypeId.Equals(donorStack.StackTypeId))
return false;
- transfered = Math.Min(donorStack.Count, GetAvailableSpace(recipientStack));
- SetCount(donor, donorStack.Count - transfered, donorStack);
- SetCount(recipient, recipientStack.Count + transfered, recipientStack);
- return true;
+ transferred = Math.Min(donorStack.Count, GetAvailableSpace(recipientStack));
+ SetCount(donor, donorStack.Count - transferred, donorStack);
+ SetCount(recipient, recipientStack.Count + transferred, recipientStack);
+ return transferred > 0;
}
/// <summary>
--- /dev/null
+using Content.Shared.Inventory;
+using Content.Shared.Tag;
+using Content.Shared.Whitelist;
+
+namespace Content.Server.Storage.Components;
+
+/// <summary>
+/// Applies an ongoing pickup area around the attached entity.
+/// </summary>
+[RegisterComponent]
+public sealed partial class MagnetPickupComponent : Component
+{
+ [ViewVariables(VVAccess.ReadWrite), DataField("nextScan")]
+ public TimeSpan NextScan = TimeSpan.Zero;
+
+ /// <summary>
+ /// What container slot the magnet needs to be in to work.
+ /// </summary>
+ [ViewVariables(VVAccess.ReadWrite), DataField("slotFlags")]
+ public SlotFlags SlotFlags = SlotFlags.BELT;
+
+ [ViewVariables(VVAccess.ReadWrite), DataField("range")]
+ public float Range = 1f;
+
+ [ValidatePrototypeId<TagPrototype>]
+ private const string DefaultTag = "Ore";
+
+ [ViewVariables(VVAccess.ReadWrite), DataField("whitelist")]
+ public EntityWhitelist? Whitelist = new()
+ {
+ Tags = new List<string>()
+ {
+ DefaultTag,
+ }
+ };
+}
--- /dev/null
+using Content.Server.Storage.Components;
+using Content.Shared.Hands;
+using Content.Shared.Inventory;
+using Content.Shared.Stacks;
+using Robust.Shared.Map;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Player;
+using Robust.Shared.Timing;
+
+namespace Content.Shared.Storage.EntitySystems;
+
+/// <summary>
+/// <see cref="MagnetPickupComponent"/>
+/// </summary>
+public sealed class MagnetPickupSystem : EntitySystem
+{
+ [Dependency] private readonly IGameTiming _timing = default!;
+ [Dependency] private readonly EntityLookupSystem _lookup = default!;
+ [Dependency] private readonly InventorySystem _inventory = default!;
+ [Dependency] private readonly SharedTransformSystem _transform = default!;
+ [Dependency] private readonly SharedStorageSystem _storage = default!;
+
+ private static readonly TimeSpan ScanDelay = TimeSpan.FromSeconds(1);
+
+ private EntityQuery<PhysicsComponent> _physicsQuery;
+
+ public override void Initialize()
+ {
+ base.Initialize();
+ _physicsQuery = GetEntityQuery<PhysicsComponent>();
+ SubscribeLocalEvent<MagnetPickupComponent, MapInitEvent>(OnMagnetMapInit);
+ SubscribeLocalEvent<MagnetPickupComponent, EntityUnpausedEvent>(OnMagnetUnpaused);
+ }
+
+ private void OnMagnetUnpaused(EntityUid uid, MagnetPickupComponent component, ref EntityUnpausedEvent args)
+ {
+ component.NextScan += args.PausedTime;
+ }
+
+ private void OnMagnetMapInit(EntityUid uid, MagnetPickupComponent component, MapInitEvent args)
+ {
+ component.NextScan = _timing.CurTime;
+ }
+
+ public override void Update(float frameTime)
+ {
+ base.Update(frameTime);
+ var query = EntityQueryEnumerator<MagnetPickupComponent, StorageComponent, TransformComponent>();
+ var currentTime = _timing.CurTime;
+
+ while (query.MoveNext(out var uid, out var comp, out var storage, out var xform))
+ {
+ if (comp.NextScan < currentTime)
+ continue;
+
+ comp.NextScan += ScanDelay;
+
+ // No space
+ if (storage.StorageUsed >= storage.StorageCapacityMax)
+ continue;
+
+ if (!_inventory.TryGetContainingSlot(uid, out var slotDef))
+ continue;
+
+ if ((slotDef.SlotFlags & comp.SlotFlags) == 0x0)
+ continue;
+
+ var parentUid = xform.ParentUid;
+ var playedSound = false;
+ var finalCoords = xform.Coordinates;
+ var moverCoords = _transform.GetMoverCoordinates(uid, xform);
+
+ foreach (var near in _lookup.GetEntitiesInRange(uid, comp.Range, LookupFlags.Dynamic | LookupFlags.Sundries))
+ {
+ if (comp.Whitelist?.IsValid(near, EntityManager) == false)
+ continue;
+
+ if (!_physicsQuery.TryGetComponent(near, out var physics) || physics.BodyStatus != BodyStatus.OnGround)
+ continue;
+
+ if (near == parentUid)
+ continue;
+
+ // TODO: Probably move this to storage somewhere when it gets cleaned up
+ // TODO: This sucks but you need to fix a lot of stuff to make it better
+ // the problem is that stack pickups delete the original entity, which is fine, but due to
+ // game state handling we can't show a lerp animation for it.
+ var nearXform = Transform(near);
+ var nearMap = nearXform.MapPosition;
+ var nearCoords = EntityCoordinates.FromMap(moverCoords.EntityId, nearMap, _transform, EntityManager);
+
+ if (!_storage.Insert(uid, near, out var stacked, storageComp: storage, playSound: !playedSound))
+ continue;
+
+ // Play pickup animation for either the stack entity or the original entity.
+ if (stacked != null)
+ _storage.PlayPickupAnimation(stacked.Value, nearCoords, finalCoords, nearXform.LocalRotation);
+ else
+ _storage.PlayPickupAnimation(near, nearCoords, finalCoords, nearXform.LocalRotation);
+
+ playedSound = true;
+ }
+ }
+ }
+}
using Content.Shared.Containers.ItemSlots;
using Content.Shared.Destructible;
using Content.Shared.DoAfter;
+using Content.Shared.Hands;
using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Implants.Components;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
[Dependency] protected readonly SharedAudioSystem Audio = default!;
[Dependency] private readonly SharedCombatModeSystem _combatMode = default!;
- [Dependency] private readonly SharedTransformSystem _transform = default!;
+ [Dependency] protected readonly SharedTransformSystem _transform = default!;
[Dependency] private readonly SharedStackSystem _stack = default!;
[Dependency] protected readonly UseDelaySystem UseDelay = default!;
foreach (var entity in entities.ToArray())
{
- Insert(target, entity, user, targetComp, playSound: false);
+ Insert(target, entity, out _, user: user, targetComp, playSound: false);
}
Audio.PlayPredicted(sourceComp.StorageInsertSound, target, user);
/// Inserts into the storage container
/// </summary>
/// <returns>true if the entity was inserted, false otherwise</returns>
- public bool Insert(EntityUid uid, EntityUid insertEnt, EntityUid? user = null, StorageComponent? storageComp = null, bool playSound = true)
+ public bool Insert(EntityUid uid, EntityUid insertEnt, out EntityUid? stackedEntity, EntityUid? user = null, StorageComponent? storageComp = null, bool playSound = true)
{
+ stackedEntity = null;
+
if (!Resolve(uid, ref storageComp) || !CanInsert(uid, insertEnt, out _, storageComp))
return false;
if (!_stack.TryAdd(insertEnt, ent, insertStack, containedStack))
continue;
+ stackedEntity = ent;
var remaining = insertStack.Count;
toInsertCount -= toInsertCount - remaining;
if (!Resolve(uid, ref storageComp) || !_sharedInteractionSystem.InRangeUnobstructed(player, uid))
return false;
- if (!Insert(uid, toInsert, player, storageComp))
+ if (!Insert(uid, toInsert, out _, user: player, storageComp))
{
_popupSystem.PopupClient(Loc.GetString("comp-storage-cant-insert"), uid, player);
return false;
}
return true;
}
+
+ /// <summary>
+ /// Plays a clientside pickup animation for the specified uid.
+ /// </summary>
+ public abstract void PlayPickupAnimation(EntityUid uid, EntityCoordinates initialCoordinates,
+ EntityCoordinates finalCoordinates, Angle initialRotation, EntityUid? user = null);
}
name: ore bag
id: OreBag
parent: BaseStorageItem
- description: A robust bag for salvage specialists and miners alike to carry large amounts of ore.
+ description: A robust bag for salvage specialists and miners alike to carry large amounts of ore. Magnetises any nearby ores when attached to a belt.
components:
+ - type: MagnetPickup
- type: Sprite
sprite: Objects/Specific/Mining/ore_bag.rsi
state: icon
<GuideEntityEmbed Entity="OreBag"/>
<GuideEntityEmbed Entity="ClothingBeltUtilityFilled"/>
</Box>
-Mining equipment and a full utility belt are needed to be able to plunder the full value of a salvage. The mining to quickly gather ore for the ore processor to make usefull, and the tools of the utility belt for breaking things apart and moving high value objects out.
+The pickaxe and mining drill are both useful for mining rocks or breaking structures quickly.
+The ore bag magnetises nearby ore and automatically picks it up if equipped to a belt slot.
+The utility belt can be useful for holding miscellaneous items when not occupied by your ore bag.
## How to make money as a salvager
<Box>
projects / space-station-14.git / commitdiff