+++ /dev/null
-using Content.Shared.Nutrition.EntitySystems;
-
-namespace Content.Client.Nutrition.EntitySystems;
-
-public sealed class OpenableSystem : SharedOpenableSystem
-{
-}
using Content.Server.Chemistry.Components;
using Content.Server.Chemistry.Containers.EntitySystems;
-using Content.Server.Nutrition.EntitySystems;
+using Content.Server.Nutrition.Components;
using Content.Shared.Chemistry;
using Content.Shared.Chemistry.Dispenser;
using Content.Shared.Chemistry.EntitySystems;
using Content.Shared.Containers.ItemSlots;
using Content.Shared.FixedPoint;
+using Content.Shared.Nutrition.EntitySystems;
using JetBrains.Annotations;
using Robust.Server.Audio;
using Robust.Server.GameObjects;
+++ /dev/null
-using Content.Server.Administration.Logs;
-using Content.Server.Chemistry.Containers.EntitySystems;
-using Content.Shared.Chemistry;
-using Content.Shared.Chemistry.Components;
-using Content.Shared.Database;
-using Content.Shared.FixedPoint;
-using Content.Shared.Interaction;
-using Content.Shared.Popups;
-using Content.Shared.Verbs;
-using JetBrains.Annotations;
-using Robust.Server.GameObjects;
-using Robust.Shared.Player;
-
-namespace Content.Server.Chemistry.EntitySystems
-{
- [UsedImplicitly]
- public sealed class SolutionTransferSystem : EntitySystem
- {
- [Dependency] private readonly SharedPopupSystem _popupSystem = default!;
- [Dependency] private readonly SolutionContainerSystem _solutionContainerSystem = default!;
- [Dependency] private readonly UserInterfaceSystem _userInterfaceSystem = default!;
- [Dependency] private readonly IAdminLogManager _adminLogger = default!;
-
- /// <summary>
- /// Default transfer amounts for the set-transfer verb.
- /// </summary>
- public static readonly List<int> DefaultTransferAmounts = new() { 1, 5, 10, 25, 50, 100, 250, 500, 1000 };
-
- public override void Initialize()
- {
- base.Initialize();
-
- SubscribeLocalEvent<SolutionTransferComponent, GetVerbsEvent<AlternativeVerb>>(AddSetTransferVerbs);
- SubscribeLocalEvent<SolutionTransferComponent, AfterInteractEvent>(OnAfterInteract);
- SubscribeLocalEvent<SolutionTransferComponent, TransferAmountSetValueMessage>(OnTransferAmountSetValueMessage);
- }
-
- private void OnTransferAmountSetValueMessage(Entity<SolutionTransferComponent> entity, ref TransferAmountSetValueMessage message)
- {
- var newTransferAmount = FixedPoint2.Clamp(message.Value, entity.Comp.MinimumTransferAmount, entity.Comp.MaximumTransferAmount);
- entity.Comp.TransferAmount = newTransferAmount;
-
- if (message.Session.AttachedEntity is { Valid: true } user)
- _popupSystem.PopupEntity(Loc.GetString("comp-solution-transfer-set-amount", ("amount", newTransferAmount)), entity.Owner, user);
- }
-
- private void AddSetTransferVerbs(Entity<SolutionTransferComponent> entity, ref GetVerbsEvent<AlternativeVerb> args)
- {
- var (uid, component) = entity;
-
- if (!args.CanAccess || !args.CanInteract || !component.CanChangeTransferAmount || args.Hands == null)
- return;
-
- if (!EntityManager.TryGetComponent(args.User, out ActorComponent? actor))
- return;
-
- // Custom transfer verb
- AlternativeVerb custom = new();
- custom.Text = Loc.GetString("comp-solution-transfer-verb-custom-amount");
- custom.Category = VerbCategory.SetTransferAmount;
- custom.Act = () => _userInterfaceSystem.TryOpen(uid, TransferAmountUiKey.Key, actor.PlayerSession);
- custom.Priority = 1;
- args.Verbs.Add(custom);
-
- // Add specific transfer verbs according to the container's size
- var priority = 0;
- var user = args.User;
- foreach (var amount in DefaultTransferAmounts)
- {
- if (amount < component.MinimumTransferAmount.Int() || amount > component.MaximumTransferAmount.Int())
- continue;
-
- AlternativeVerb verb = new();
- verb.Text = Loc.GetString("comp-solution-transfer-verb-amount", ("amount", amount));
- verb.Category = VerbCategory.SetTransferAmount;
- verb.Act = () =>
- {
- component.TransferAmount = FixedPoint2.New(amount);
- _popupSystem.PopupEntity(Loc.GetString("comp-solution-transfer-set-amount", ("amount", amount)), uid, user);
- };
-
- // we want to sort by size, not alphabetically by the verb text.
- verb.Priority = priority;
- priority--;
-
- args.Verbs.Add(verb);
- }
- }
-
- private void OnAfterInteract(Entity<SolutionTransferComponent> entity, ref AfterInteractEvent args)
- {
- if (!args.CanReach || args.Target == null)
- return;
-
- var target = args.Target!.Value;
- var (uid, component) = entity;
-
- //Special case for reagent tanks, because normally clicking another container will give solution, not take it.
- if (component.CanReceive && !EntityManager.HasComponent<RefillableSolutionComponent>(target) // target must not be refillable (e.g. Reagent Tanks)
- && _solutionContainerSystem.TryGetDrainableSolution(target, out var targetSoln, out _) // target must be drainable
- && EntityManager.TryGetComponent(uid, out RefillableSolutionComponent? refillComp)
- && _solutionContainerSystem.TryGetRefillableSolution((uid, refillComp, null), out var ownerSoln, out var ownerRefill))
-
- {
-
- var transferAmount = component.TransferAmount; // This is the player-configurable transfer amount of "uid," not the target reagent tank.
-
- if (EntityManager.TryGetComponent(uid, out RefillableSolutionComponent? refill) && refill.MaxRefill != null) // uid is the entity receiving solution from target.
- {
- transferAmount = FixedPoint2.Min(transferAmount, (FixedPoint2) refill.MaxRefill); // if the receiver has a smaller transfer limit, use that instead
- }
-
- var transferred = Transfer(args.User, target, targetSoln.Value, uid, ownerSoln.Value, transferAmount);
- if (transferred > 0)
- {
- var toTheBrim = ownerRefill.AvailableVolume == 0;
- var msg = toTheBrim
- ? "comp-solution-transfer-fill-fully"
- : "comp-solution-transfer-fill-normal";
-
- _popupSystem.PopupEntity(Loc.GetString(msg, ("owner", args.Target), ("amount", transferred), ("target", uid)), uid, args.User);
-
- args.Handled = true;
- return;
- }
- }
-
- // if target is refillable, and owner is drainable
- if (component.CanSend && _solutionContainerSystem.TryGetRefillableSolution(target, out targetSoln, out var targetRefill)
- && _solutionContainerSystem.TryGetDrainableSolution(uid, out ownerSoln, out var ownerDrain))
- {
- var transferAmount = component.TransferAmount;
-
- if (EntityManager.TryGetComponent(target, out RefillableSolutionComponent? refill) && refill.MaxRefill != null)
- {
- transferAmount = FixedPoint2.Min(transferAmount, (FixedPoint2) refill.MaxRefill);
- }
-
- var transferred = Transfer(args.User, uid, ownerSoln.Value, target, targetSoln.Value, transferAmount);
-
- if (transferred > 0)
- {
- var message = Loc.GetString("comp-solution-transfer-transfer-solution", ("amount", transferred), ("target", target));
- _popupSystem.PopupEntity(message, uid, args.User);
-
- args.Handled = true;
- }
- }
- }
-
- /// <summary>
- /// Transfer from a solution to another.
- /// </summary>
- /// <returns>The actual amount transferred.</returns>
- public FixedPoint2 Transfer(EntityUid user,
- EntityUid sourceEntity,
- Entity<SolutionComponent> source,
- EntityUid targetEntity,
- Entity<SolutionComponent> target,
- FixedPoint2 amount)
- {
- var transferAttempt = new SolutionTransferAttemptEvent(sourceEntity, targetEntity);
-
- // Check if the source is cancelling the transfer
- RaiseLocalEvent(sourceEntity, transferAttempt, broadcast: true);
- if (transferAttempt.Cancelled)
- {
- _popupSystem.PopupEntity(transferAttempt.CancelReason!, sourceEntity, user);
- return FixedPoint2.Zero;
- }
-
- var sourceSolution = source.Comp.Solution;
- if (sourceSolution.Volume == 0)
- {
- _popupSystem.PopupEntity(Loc.GetString("comp-solution-transfer-is-empty", ("target", sourceEntity)), sourceEntity, user);
- return FixedPoint2.Zero;
- }
-
- // Check if the target is cancelling the transfer
- RaiseLocalEvent(targetEntity, transferAttempt, broadcast: true);
- if (transferAttempt.Cancelled)
- {
- _popupSystem.PopupEntity(transferAttempt.CancelReason!, sourceEntity, user);
- return FixedPoint2.Zero;
- }
-
- var targetSolution = target.Comp.Solution;
- if (targetSolution.AvailableVolume == 0)
- {
- _popupSystem.PopupEntity(Loc.GetString("comp-solution-transfer-is-full", ("target", targetEntity)), targetEntity, user);
- return FixedPoint2.Zero;
- }
-
- var actualAmount = FixedPoint2.Min(amount, FixedPoint2.Min(sourceSolution.Volume, targetSolution.AvailableVolume));
-
- var solution = _solutionContainerSystem.Drain(sourceEntity, source, actualAmount);
- _solutionContainerSystem.Refill(targetEntity, target, solution);
-
- _adminLogger.Add(LogType.Action, LogImpact.Medium,
- $"{EntityManager.ToPrettyString(user):player} transferred {string.Join(", ", solution.Contents)} to {EntityManager.ToPrettyString(targetEntity):entity}, which now contains {SolutionContainerSystem.ToPrettyString(targetSolution)}");
-
- return actualAmount;
- }
- }
-
- /// <summary>
- /// Raised when attempting to transfer from one solution to another.
- /// </summary>
- public sealed class SolutionTransferAttemptEvent : CancellableEntityEventArgs
- {
- public SolutionTransferAttemptEvent(EntityUid from, EntityUid to)
- {
- From = from;
- To = to;
- }
-
- public EntityUid From { get; }
- public EntityUid To { get; }
-
- /// <summary>
- /// Why the transfer has been cancelled.
- /// </summary>
- public string? CancelReason { get; private set; }
-
- /// <summary>
- /// Cancels the transfer.
- /// </summary>
- public void Cancel(string reason)
- {
- base.Cancel();
- CancelReason = reason;
- }
- }
-}
-using Content.Server.Nutrition.EntitySystems;
+using Content.Shared.Nutrition.EntitySystems;
namespace Content.Server.Destructible.Thresholds.Behaviors;
args.Handled = true;
+ // TODO: why is this copy paste shit here just have fire extinguisher cancel transfer when safety is on
var transfer = containerSolution.AvailableVolume;
if (TryComp<SolutionTransferComponent>(entity.Owner, out var solTrans))
{
using Content.Server.Chemistry.Containers.EntitySystems;
-using Content.Server.Nutrition.EntitySystems;
+using Content.Server.Fluids.Components;
using Content.Shared.Chemistry.Components;
using Content.Shared.Chemistry.EntitySystems;
using Content.Shared.Chemistry.Reaction;
using Content.Shared.Fluids.Components;
using Content.Shared.IdentityManagement;
using Content.Shared.Inventory.Events;
+using Content.Shared.Nutrition.EntitySystems;
using Content.Shared.Popups;
using Content.Shared.Spillable;
using Content.Shared.Throwing;
using Content.Server.Administration.Logs;
using Content.Server.Chemistry.Containers.EntitySystems;
-using Content.Server.Nutrition.EntitySystems;
using Content.Shared.Database;
using Content.Shared.Glue;
using Content.Shared.Hands;
using Content.Shared.Interaction;
using Content.Shared.Interaction.Components;
using Content.Shared.Item;
+using Content.Shared.Nutrition.EntitySystems;
using Content.Shared.Popups;
using Content.Shared.Verbs;
using Robust.Shared.Audio.Systems;
using Content.Server.Administration.Logs;
using Content.Server.Chemistry.Containers.EntitySystems;
-using Content.Server.Nutrition.EntitySystems;
using Content.Shared.Database;
using Content.Shared.Glue;
using Content.Shared.IdentityManagement;
using Content.Shared.Interaction;
using Content.Shared.Item;
using Content.Shared.Lube;
+using Content.Shared.Nutrition.EntitySystems;
using Content.Shared.Popups;
using Content.Shared.Verbs;
using Robust.Shared.Audio;
using Content.Server.Chemistry.Containers.EntitySystems;
-using Content.Server.Chemistry.EntitySystems;
using Content.Server.Fluids.EntitySystems;
using Content.Server.GameTicking;
-using Content.Server.Nutrition.EntitySystems;
using Content.Server.Popups;
using Content.Server.Power.Components;
using Content.Server.Stack;
using Content.Shared.Body.Systems;
using Content.Shared.Chemistry.Components;
using Content.Shared.Chemistry.Components.SolutionManager;
+using Content.Shared.Chemistry.EntitySystems;
using Content.Shared.IdentityManagement;
using Content.Shared.Interaction;
using Content.Shared.Interaction.Events;
using Content.Shared.Materials;
using Content.Shared.Mind;
+using Content.Shared.Nutrition.EntitySystems;
using Robust.Server.GameObjects;
using Robust.Shared.Player;
using Robust.Shared.Utility;
using Content.Shared.Mobs.Systems;
using Content.Shared.NPC.Systems;
using Content.Shared.Nutrition.Components;
+using Content.Shared.Nutrition.EntitySystems;
using Content.Shared.Tools.Systems;
using Content.Shared.Weapons.Melee;
using Content.Shared.Weapons.Ranged.Components;
using Content.Shared.Mobs.Systems;
using Content.Shared.Nutrition;
using Content.Shared.Nutrition.Components;
+using Content.Shared.Nutrition.EntitySystems;
using Content.Shared.Throwing;
using Content.Shared.Verbs;
using Robust.Shared.Audio;
using Content.Shared.Inventory;
using Content.Shared.Mobs.Systems;
using Content.Shared.Nutrition;
+using Content.Shared.Nutrition.EntitySystems;
using Content.Shared.Stacks;
using Content.Shared.Storage;
using Content.Shared.Verbs;
+++ /dev/null
-using Content.Server.Chemistry.EntitySystems;
-using Content.Shared.Nutrition.EntitySystems;
-using Content.Shared.Nutrition.Components;
-
-namespace Content.Server.Nutrition.EntitySystems;
-
-/// <summary>
-/// Provides API for openable food and drinks, handles opening on use and preventing transfer when closed.
-/// </summary>
-public sealed class OpenableSystem : SharedOpenableSystem
-{
- public override void Initialize()
- {
- base.Initialize();
-
- SubscribeLocalEvent<OpenableComponent, SolutionTransferAttemptEvent>(OnTransferAttempt);
- }
-
- private void OnTransferAttempt(EntityUid uid, OpenableComponent comp, SolutionTransferAttemptEvent args)
- {
- if (!comp.Opened)
- {
- // message says its just for drinks, shouldn't matter since you typically dont have a food that is openable and can be poured out
- args.Cancel(Loc.GetString("drink-component-try-use-drink-not-open", ("owner", uid)));
- }
- }
-}
--- /dev/null
+using Content.Shared.Chemistry.EntitySystems;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Chemistry.Components;
+
+/// <summary>
+/// Basically reverse spiking, instead of using the solution-entity on a beaker, you use the beaker on the solution-entity.
+/// If there is not enough volume it will stay in the solution-entity rather than spill onto the floor.
+/// </summary>
+[RegisterComponent, NetworkedComponent, Access(typeof(ScoopableSolutionSystem))]
+public sealed partial class ScoopableSolutionComponent : Component
+{
+ /// <summary>
+ /// Solution name that can be scooped from.
+ /// </summary>
+ [DataField]
+ public string Solution = "default";
+
+ /// <summary>
+ /// If true, when the whole solution is scooped up the entity will be deleted.
+ /// </summary>
+ [DataField]
+ public bool Delete = true;
+
+ /// <summary>
+ /// Popup to show the user when scooping.
+ /// Passed entities "scooped" and "beaker".
+ /// </summary>
+ [DataField]
+ public LocId Popup = "scoopable-component-popup";
+}
--- /dev/null
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Interaction;
+using Content.Shared.Popups;
+using Robust.Shared.Network;
+
+namespace Content.Shared.Chemistry.EntitySystems;
+
+/// <summary>
+/// Handles solution transfer when a beaker is used on a scoopable entity.
+/// </summary>
+public sealed class ScoopableSolutionSystem : EntitySystem
+{
+ [Dependency] private readonly INetManager _netManager = default!;
+ [Dependency] private readonly SharedPopupSystem _popup = default!;
+ [Dependency] private readonly SharedSolutionContainerSystem _solution = default!;
+ [Dependency] private readonly SolutionTransferSystem _solutionTransfer = default!;
+
+ public override void Initialize()
+ {
+ base.Initialize();
+
+ SubscribeLocalEvent<ScoopableSolutionComponent, InteractUsingEvent>(OnInteractUsing);
+ }
+
+ private void OnInteractUsing(Entity<ScoopableSolutionComponent> ent, ref InteractUsingEvent args)
+ {
+ TryScoop(ent, args.Used, args.User);
+ }
+
+ public bool TryScoop(Entity<ScoopableSolutionComponent> ent, EntityUid beaker, EntityUid user)
+ {
+ if (!_solution.TryGetSolution(ent.Owner, ent.Comp.Solution, out var src, out var srcSolution) ||
+ !_solution.TryGetRefillableSolution(beaker, out var target, out _))
+ return false;
+
+ var scooped = _solutionTransfer.Transfer(user, ent, src.Value, beaker, target.Value, srcSolution.Volume);
+ if (scooped == 0)
+ return false;
+
+ _popup.PopupClient(Loc.GetString(ent.Comp.Popup, ("scooped", ent.Owner), ("beaker", beaker)), user, user);
+
+ if (srcSolution.Volume == 0 && ent.Comp.Delete)
+ {
+ // deletion isnt predicted so do this to prevent spam clicking to see "the ash is empty!"
+ RemCompDeferred<ScoopableSolutionComponent>(ent);
+
+ if (!_netManager.IsClient)
+ QueueDel(ent);
+ }
+
+ return true;
+ }
+}
--- /dev/null
+using Content.Shared.Administration.Logs;
+using Content.Shared.Chemistry;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Database;
+using Content.Shared.FixedPoint;
+using Content.Shared.Interaction;
+using Content.Shared.Popups;
+using Content.Shared.Verbs;
+using Robust.Shared.Network;
+using Robust.Shared.Player;
+
+namespace Content.Shared.Chemistry.EntitySystems;
+
+/// <summary>
+/// Allows an entity to transfer solutions with a customizable amount per click.
+/// Also provides <see cref="Transfer"/> API for other systems.
+/// </summary>
+public sealed class SolutionTransferSystem : EntitySystem
+{
+ [Dependency] private readonly INetManager _net = default!;
+ [Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
+ [Dependency] private readonly SharedPopupSystem _popup = default!;
+ [Dependency] private readonly SharedSolutionContainerSystem _solution = default!;
+ [Dependency] private readonly SharedUserInterfaceSystem _ui = default!;
+
+ /// <summary>
+ /// Default transfer amounts for the set-transfer verb.
+ /// </summary>
+ public static readonly FixedPoint2[] DefaultTransferAmounts = new FixedPoint2[] { 1, 5, 10, 25, 50, 100, 250, 500, 1000 };
+
+ public override void Initialize()
+ {
+ base.Initialize();
+
+ SubscribeLocalEvent<SolutionTransferComponent, GetVerbsEvent<AlternativeVerb>>(AddSetTransferVerbs);
+ SubscribeLocalEvent<SolutionTransferComponent, AfterInteractEvent>(OnAfterInteract);
+ SubscribeLocalEvent<SolutionTransferComponent, TransferAmountSetValueMessage>(OnTransferAmountSetValueMessage);
+ }
+
+ private void OnTransferAmountSetValueMessage(Entity<SolutionTransferComponent> ent, ref TransferAmountSetValueMessage message)
+ {
+ var newTransferAmount = FixedPoint2.Clamp(message.Value, ent.Comp.MinimumTransferAmount, ent.Comp.MaximumTransferAmount);
+ ent.Comp.TransferAmount = newTransferAmount;
+
+ if (message.Session.AttachedEntity is { Valid: true } user)
+ _popup.PopupClient(Loc.GetString("comp-solution-transfer-set-amount", ("amount", newTransferAmount)), ent, user);
+ }
+
+ private void AddSetTransferVerbs(Entity<SolutionTransferComponent> ent, ref GetVerbsEvent<AlternativeVerb> args)
+ {
+ var (uid, comp) = ent;
+
+ if (!args.CanAccess || !args.CanInteract || !comp.CanChangeTransferAmount || args.Hands == null)
+ return;
+
+ if (!TryComp<ActorComponent>(args.User, out var actor))
+ return;
+
+ // Custom transfer verb
+ args.Verbs.Add(new AlternativeVerb()
+ {
+ Text = Loc.GetString("comp-solution-transfer-verb-custom-amount"),
+ Category = VerbCategory.SetTransferAmount,
+ // TODO: remove server check when bui prediction is a thing
+ Act = () =>
+ {
+ if (_net.IsServer)
+ _ui.TryOpen(uid, TransferAmountUiKey.Key, actor.PlayerSession);
+ },
+ Priority = 1
+ });
+
+ // Add specific transfer verbs according to the container's size
+ var priority = 0;
+ var user = args.User;
+ foreach (var amount in DefaultTransferAmounts)
+ {
+ AlternativeVerb verb = new();
+ verb.Text = Loc.GetString("comp-solution-transfer-verb-amount", ("amount", amount));
+ verb.Category = VerbCategory.SetTransferAmount;
+ verb.Act = () =>
+ {
+ comp.TransferAmount = amount;
+ _popup.PopupClient(Loc.GetString("comp-solution-transfer-set-amount", ("amount", amount)), uid, user);
+ };
+
+ // we want to sort by size, not alphabetically by the verb text.
+ verb.Priority = priority;
+ priority--;
+
+ args.Verbs.Add(verb);
+ }
+ }
+
+ private void OnAfterInteract(Entity<SolutionTransferComponent> ent, ref AfterInteractEvent args)
+ {
+ if (!args.CanReach || args.Target is not {} target)
+ return;
+
+ var (uid, comp) = ent;
+
+ //Special case for reagent tanks, because normally clicking another container will give solution, not take it.
+ if (comp.CanReceive
+ && !HasComp<RefillableSolutionComponent>(target) // target must not be refillable (e.g. Reagent Tanks)
+ && _solution.TryGetDrainableSolution(target, out var targetSoln, out _) // target must be drainable
+ && TryComp<RefillableSolutionComponent>(uid, out var refill)
+ && _solution.TryGetRefillableSolution((uid, refill, null), out var ownerSoln, out var ownerRefill))
+ {
+ var transferAmount = comp.TransferAmount; // This is the player-configurable transfer amount of "uid," not the target reagent tank.
+
+ // if the receiver has a smaller transfer limit, use that instead
+ if (refill?.MaxRefill is {} maxRefill)
+ transferAmount = FixedPoint2.Min(transferAmount, maxRefill);
+
+ var transferred = Transfer(args.User, target, targetSoln.Value, uid, ownerSoln.Value, transferAmount);
+ if (transferred > 0)
+ {
+ var toTheBrim = ownerRefill.AvailableVolume == 0;
+ var msg = toTheBrim
+ ? "comp-solution-transfer-fill-fully"
+ : "comp-solution-transfer-fill-normal";
+
+ _popup.PopupClient(Loc.GetString(msg, ("owner", args.Target), ("amount", transferred), ("target", uid)), uid, args.User);
+
+ args.Handled = true;
+ return;
+ }
+ }
+
+ // if target is refillable, and owner is drainable
+ if (comp.CanSend
+ && TryComp<RefillableSolutionComponent>(target, out var targetRefill)
+ && _solution.TryGetRefillableSolution((target, targetRefill, null), out targetSoln, out _)
+ && _solution.TryGetDrainableSolution(uid, out ownerSoln, out _))
+ {
+ var transferAmount = comp.TransferAmount;
+
+ if (targetRefill?.MaxRefill is {} maxRefill)
+ transferAmount = FixedPoint2.Min(transferAmount, maxRefill);
+
+ var transferred = Transfer(args.User, uid, ownerSoln.Value, target, targetSoln.Value, transferAmount);
+
+ if (transferred > 0)
+ {
+ var message = Loc.GetString("comp-solution-transfer-transfer-solution", ("amount", transferred), ("target", target));
+ _popup.PopupClient(message, uid, args.User);
+
+ args.Handled = true;
+ }
+ }
+ }
+
+ /// <summary>
+ /// Transfer from a solution to another, allowing either entity to cancel it and show a popup.
+ /// </summary>
+ /// <returns>The actual amount transferred.</returns>
+ public FixedPoint2 Transfer(EntityUid user,
+ EntityUid sourceEntity,
+ Entity<SolutionComponent> source,
+ EntityUid targetEntity,
+ Entity<SolutionComponent> target,
+ FixedPoint2 amount)
+ {
+ var transferAttempt = new SolutionTransferAttemptEvent(sourceEntity, targetEntity);
+
+ // Check if the source is cancelling the transfer
+ RaiseLocalEvent(sourceEntity, ref transferAttempt);
+ if (transferAttempt.CancelReason is {} reason)
+ {
+ _popup.PopupClient(reason, sourceEntity, user);
+ return FixedPoint2.Zero;
+ }
+
+ var sourceSolution = source.Comp.Solution;
+ if (sourceSolution.Volume == 0)
+ {
+ _popup.PopupClient(Loc.GetString("comp-solution-transfer-is-empty", ("target", sourceEntity)), sourceEntity, user);
+ return FixedPoint2.Zero;
+ }
+
+ // Check if the target is cancelling the transfer
+ RaiseLocalEvent(targetEntity, ref transferAttempt);
+ if (transferAttempt.CancelReason is {} targetReason)
+ {
+ _popup.PopupClient(targetReason, targetEntity, user);
+ return FixedPoint2.Zero;
+ }
+
+ var targetSolution = target.Comp.Solution;
+ if (targetSolution.AvailableVolume == 0)
+ {
+ _popup.PopupClient(Loc.GetString("comp-solution-transfer-is-full", ("target", targetEntity)), targetEntity, user);
+ return FixedPoint2.Zero;
+ }
+
+ var actualAmount = FixedPoint2.Min(amount, FixedPoint2.Min(sourceSolution.Volume, targetSolution.AvailableVolume));
+
+ var solution = _solution.SplitSolution(source, actualAmount);
+ _solution.Refill(targetEntity, target, solution);
+
+ _adminLogger.Add(LogType.Action, LogImpact.Medium,
+ $"{ToPrettyString(user):player} transferred {SharedSolutionContainerSystem.ToPrettyString(solution)} to {ToPrettyString(targetEntity):target}, which now contains {SharedSolutionContainerSystem.ToPrettyString(targetSolution)}");
+
+ return actualAmount;
+ }
+}
+
+/// <summary>
+/// Raised when attempting to transfer from one solution to another.
+/// Raised on both the source and target entities so either can cancel the transfer.
+/// To not mispredict this should always be cancelled in shared code and not server or client.
+/// </summary>
+[ByRefEvent]
+public record struct SolutionTransferAttemptEvent(EntityUid From, EntityUid To, string? CancelReason = null)
+{
+ /// <summary>
+ /// Cancels the transfer.
+ /// </summary>
+ public void Cancel(string reason)
+ {
+ CancelReason = reason;
+ }
+}
public abstract partial class SharedPuddleSystem
{
- [Dependency] protected readonly SharedOpenableSystem Openable = default!;
+ [Dependency] protected readonly OpenableSystem Openable = default!;
protected virtual void InitializeSpillable()
{
/// Starts closed, open it with Z or E.
/// </summary>
[NetworkedComponent, AutoGenerateComponentState]
-[RegisterComponent, Access(typeof(SharedOpenableSystem))]
+[RegisterComponent, Access(typeof(OpenableSystem))]
public sealed partial class OpenableComponent : Component
{
/// <summary>
+using Content.Shared.Chemistry.EntitySystems;
using Content.Shared.Examine;
using Content.Shared.Interaction;
using Content.Shared.Interaction.Events;
/// <summary>
/// Provides API for openable food and drinks, handles opening on use and preventing transfer when closed.
/// </summary>
-public abstract partial class SharedOpenableSystem : EntitySystem
+public sealed partial class OpenableSystem : EntitySystem
{
[Dependency] protected readonly SharedAppearanceSystem Appearance = default!;
[Dependency] protected readonly SharedAudioSystem Audio = default!;
SubscribeLocalEvent<OpenableComponent, MeleeHitEvent>(HandleIfClosed);
SubscribeLocalEvent<OpenableComponent, AfterInteractEvent>(HandleIfClosed);
SubscribeLocalEvent<OpenableComponent, GetVerbsEvent<Verb>>(AddOpenCloseVerbs);
+ SubscribeLocalEvent<OpenableComponent, SolutionTransferAttemptEvent>(OnTransferAttempt);
}
private void OnInit(EntityUid uid, OpenableComponent comp, ComponentInit args)
args.Verbs.Add(verb);
}
+ private void OnTransferAttempt(Entity<OpenableComponent> ent, ref SolutionTransferAttemptEvent args)
+ {
+ if (!ent.Comp.Opened)
+ {
+ // message says its just for drinks, shouldn't matter since you typically dont have a food that is openable and can be poured out
+ args.Cancel(Loc.GetString("drink-component-try-use-drink-not-open", ("owner", ent.Owner)));
+ }
+ }
+
/// <summary>
/// Returns true if the entity either does not have OpenableComponent or it is opened.
/// Drinks that don't have OpenableComponent are automatically open, so it returns true.
{
base.Initialize();
- SubscribeLocalEvent<SealableComponent, ExaminedEvent>(OnExamined, after: new[] { typeof(SharedOpenableSystem) });
+ SubscribeLocalEvent<SealableComponent, ExaminedEvent>(OnExamined, after: new[] { typeof(OpenableSystem) });
SubscribeLocalEvent<SealableComponent, OpenableOpenedEvent>(OnOpened);
}
--- /dev/null
+scoopable-component-popup = You scoop up {$scooped} into {THE($beaker)}.
- type: SmokeVisuals
- type: Transform
anchored: true
+ - type: Clickable
- type: Physics
- type: Fixtures
fixtures:
animationState: foam-dissolve
- type: Slippery
- type: StepTrigger
+ - type: ScoopableSolution
+ solution: solutionArea
- type: entity
id: MetalFoam
- type: SolutionSpiker
sourceSolution: food
ignoreEmpty: true
+ - type: ScoopableSolution
+ solution: food
- type: Extractable
grindableSolutionName: food
projects / space-station-14.git / commitdiff