private void OnDoAfter(EntityUid uid, SharpComponent component, DoAfterEvent args)
{
- if (args.Handled || args.Cancelled || !TryComp<ButcherableComponent>(args.Args.Target, out var butcher))
+ if (args.Handled || !TryComp<ButcherableComponent>(args.Args.Target, out var butcher))
return;
+ if (args.Cancelled)
+ {
+ component.Butchering.Remove(args.Args.Target.Value);
+ return;
+ }
+
component.Butchering.Remove(args.Args.Target.Value);
if (_containerSystem.IsEntityInContainer(args.Args.Target.Value))
[DataField("forceDrink")]
public bool ForceDrink;
+ /// <summary>
+ /// Is the entity currently drinking or trying to make someone else drink?
+ /// </summary>
+ [DataField("drinking")]
+ public bool Drinking;
+
/// <summary>
/// How long it takes to drink this yourself.
/// </summary>
/// <summary>
/// Is this entity being forcefed?
- /// Prevents the entity from being forced to eat multiple times if not self
/// </summary>
[DataField("forceFeed")]
public bool ForceFeed;
+ /// <summary>
+ /// Is this entity eating or being fed?
+ /// </summary>
+ [DataField(("eating"))]
+ public bool Eating;
+
/// <summary>
/// How long it takes to eat the food personally.
/// </summary>
private bool TryDrink(EntityUid user, EntityUid target, DrinkComponent drink, EntityUid item)
{
- if (!EntityManager.HasComponent<BodyComponent>(target) || drink.ForceDrink)
+ if (!EntityManager.HasComponent<BodyComponent>(target) || drink.Drinking)
return false;
if (!drink.Opened)
if (!_interactionSystem.InRangeUnobstructed(user, item, popup: true))
return true;
+ drink.Drinking = true;
drink.ForceDrink = user != target;
if (drink.ForceDrink)
/// </summary>
private void OnDoAfter(EntityUid uid, DrinkComponent component, DoAfterEvent<DrinkData> args)
{
- //Special cancel if they're force feeding someone.
- //Allows self to drink multiple times but prevents force feeding drinks to others rapidly.
- if (args.Cancelled && component.ForceDrink)
+ if (args.Cancelled)
{
component.ForceDrink = false;
+ component.Drinking = false;
return;
}
//TODO: Grab the stomach UIDs somehow without using Owner
_stomachSystem.TryTransferSolution(firstStomach.Value.Comp.Owner, drained, firstStomach.Value.Comp);
+ component.Drinking = false;
component.ForceDrink = false;
args.Handled = true;
}
if (food == user || EntityManager.TryGetComponent<MobStateComponent>(food, out var mobState) && _mobStateSystem.IsAlive(food, mobState)) // Suppresses eating alive mobs
return false;
- // Target can't be fed or they're already forcefeeding
- if (!EntityManager.HasComponent<BodyComponent>(target) || foodComp.ForceFeed)
+ // Target can't be fed or they're already eating
+ if (!EntityManager.HasComponent<BodyComponent>(target) || foodComp.Eating)
return false;
if (!_solutionContainerSystem.TryGetSolution(food, foodComp.SolutionName, out var foodSolution))
if (!_interactionSystem.InRangeUnobstructed(user, food, popup: true))
return true;
+ foodComp.Eating = true;
foodComp.ForceFeed = user != target;
if (foodComp.ForceFeed)
private void OnDoAfter(EntityUid uid, FoodComponent component, DoAfterEvent<FoodData> args)
{
//Prevents the target from being force fed food but allows the user to chow down
- if (args.Cancelled && component.ForceFeed)
+ if (args.Cancelled)
{
+ component.Eating = false;
component.ForceFeed = false;
return;
}
if (!_bodySystem.TryGetBodyOrganComponents<StomachComponent>(args.Args.Target.Value, out var stomachs, body))
return;
+ component.Eating = false;
+
var transferAmount = component.TransferAmount != null ? FixedPoint2.Min((FixedPoint2) component.TransferAmount, args.AdditionalData.FoodSolution.Volume) : args.AdditionalData.FoodSolution.Volume;
var split = _solutionContainerSystem.SplitSolution(uid, args.AdditionalData.FoodSolution, transferAmount);
using Content.Server.Administration.Logs;
-using Content.Server.Tools;
using Content.Shared.Damage;
using Content.Shared.Database;
using Content.Shared.Interaction;
public override void Initialize()
{
SubscribeLocalEvent<RepairableComponent, InteractUsingEvent>(Repair);
+ SubscribeLocalEvent<RepairableComponent, RepairFinishedEvent>(OnRepairFinished);
}
- public async void Repair(EntityUid uid, RepairableComponent component, InteractUsingEvent args)
+ private void OnRepairFinished(EntityUid uid, RepairableComponent component, RepairFinishedEvent args)
{
- // Only try repair the target if it is damaged
- if (!EntityManager.TryGetComponent(component.Owner, out DamageableComponent? damageable) || damageable.TotalDamage == 0)
- return;
-
- float delay = component.DoAfterDelay;
-
- // Add a penalty to how long it takes if the user is repairing itself
- if (args.User == args.Target)
- delay *= component.SelfRepairPenalty;
-
- var toolEvData = new ToolEventData(null);
-
- // Can the tool actually repair this, does it have enough fuel?
- if (!_toolSystem.UseTool(args.Used, args.User, uid, delay, component.QualityNeeded, toolEvData, component.FuelCost))
+ if (!EntityManager.TryGetComponent(uid, out DamageableComponent? damageable) || damageable.TotalDamage == 0)
return;
if (component.Damage != null)
var damageChanged = _damageableSystem.TryChangeDamage(uid, component.Damage, true, false, origin: args.User);
_adminLogger.Add(LogType.Healed, $"{ToPrettyString(args.User):user} repaired {ToPrettyString(uid):target} by {damageChanged?.Total}");
}
+
else
{
// Repair all damage
}
- component.Owner.PopupMessage(args.User,
+ uid.PopupMessage(args.User,
Loc.GetString("comp-repairable-repair",
- ("target", component.Owner),
+ ("target", uid),
("tool", args.Used)));
+ }
+
+ public async void Repair(EntityUid uid, RepairableComponent component, InteractUsingEvent args)
+ {
+ // Only try repair the target if it is damaged
+ if (!EntityManager.TryGetComponent(uid, out DamageableComponent? damageable) || damageable.TotalDamage == 0)
+ return;
+
+ float delay = component.DoAfterDelay;
+
+ // Add a penalty to how long it takes if the user is repairing itself
+ if (args.User == args.Target)
+ delay *= component.SelfRepairPenalty;
+
+ var toolEvData = new ToolEventData(new RepairFinishedEvent(args.User, args.Used), component.FuelCost, targetEntity:uid);
+
+ // Can the tool actually repair this, does it have enough fuel?
+ if (!_toolSystem.UseTool(args.Used, args.User, uid, delay, component.QualityNeeded, toolEvData, component.FuelCost))
+ return;
args.Handled = true;
}
}
+
+ public sealed class RepairFinishedEvent : EntityEventArgs
+ {
+ public EntityUid User;
+ public EntityUid Used;
+
+ public RepairFinishedEvent(EntityUid user, EntityUid used)
+ {
+ User = user;
+ Used = used;
+ }
+ }
}
_doAfterSystem.DoAfter(new DoAfterEventArgs(userUid, delay, target: targetUid, used: storageUid)
{
+ RaiseOnTarget = false,
BreakOnTargetMove = true,
BreakOnUserMove = true,
BreakOnStun = true,
foreach (var (_, comp) in EntityManager.EntityQuery<ActiveDoAfterComponent, DoAfterComponent>())
{
+ //Don't run the doafter if its comp or owner is deleted.
+ if (EntityManager.Deleted(comp.Owner) || comp.Deleted)
+ continue;
+
foreach (var doAfter in comp.DoAfters.Values.ToArray())
{
Run(comp.Owner, comp, doAfter);
return;
// all interactions should only happen when in range / unobstructed, so no range check is needed
+ //TODO: See why this is firing off multiple times
var interactUsingEvent = new InteractUsingEvent(user, used, target, clickLocation);
RaiseLocalEvent(target, interactUsingEvent, true);
DoContactInteraction(user, used, interactUsingEvent);
public Container KeyContainer = default!;
public const string KeyContainerName = "key_slots";
+ /// <summary>
+ /// Blocks multiple attempts to remove the key
+ /// </summary>
+ [DataField("removing")]
+ public bool Removing;
+
/// <summary>
/// Combined set of radio channels provided by all contained keys.
/// </summary>
SubscribeLocalEvent<EncryptionKeyHolderComponent, InteractUsingEvent>(OnInteractUsing);
SubscribeLocalEvent<EncryptionKeyHolderComponent, EntInsertedIntoContainerMessage>(OnContainerModified);
SubscribeLocalEvent<EncryptionKeyHolderComponent, EntRemovedFromContainerMessage>(OnContainerModified);
+ SubscribeLocalEvent<EncryptionKeyHolderComponent, EncryptionRemovalFinishedEvent>(OnKeyRemoval);
+ SubscribeLocalEvent<EncryptionKeyHolderComponent, EncryptionRemovalCancelledEvent>(OnKeyCancelled);
+ }
+
+ private void OnKeyCancelled(EntityUid uid, EncryptionKeyHolderComponent component, EncryptionRemovalCancelledEvent args)
+ {
+ component.Removing = false;
+ }
+
+ private void OnKeyRemoval(EntityUid uid, EncryptionKeyHolderComponent component, EncryptionRemovalFinishedEvent args)
+ {
+ var contained = component.KeyContainer.ContainedEntities.ToArray();
+ _container.EmptyContainer(component.KeyContainer, entMan: EntityManager);
+ foreach (var ent in contained)
+ {
+ _hands.PickupOrDrop(args.User, ent);
+ }
+
+ // if tool use ever gets predicted this needs changing.
+ _popupSystem.PopupEntity(Loc.GetString("headset-encryption-keys-all-extracted"), uid, args.User);
+ _audio.PlayPvs(component.KeyExtractionSound, uid);
+ component.Removing = false;
}
public void UpdateChannels(EntityUid uid, EncryptionKeyHolderComponent component)
private void OnInteractUsing(EntityUid uid, EncryptionKeyHolderComponent component, InteractUsingEvent args)
{
- if (!TryComp<ContainerManagerComponent>(uid, out var storage))
+ if (!TryComp<ContainerManagerComponent>(uid, out var storage) || args.Handled || component.Removing)
return;
if (TryComp<EncryptionKeyComponent>(args.Used, out var key))
if (!TryComp<ToolComponent>(args.Used, out var tool) || !tool.Qualities.Contains(component.KeysExtractionMethod))
return;
-
+
args.Handled = true;
if (component.KeyContainer.ContainedEntities.Count == 0)
return;
}
- var toolEvData = new ToolEventData(null);
+ //This is honestly the poor mans fix because the InteractUsingEvent fires off 12 times
+ component.Removing = true;
- if(!_toolSystem.UseTool(args.Used, args.User, uid, 0f, new[] { component.KeysExtractionMethod }, toolEvData, toolComponent: tool))
- return;
+ var toolEvData = new ToolEventData(new EncryptionRemovalFinishedEvent(args.User), cancelledEv: new EncryptionRemovalCancelledEvent(), targetEntity: uid);
- var contained = component.KeyContainer.ContainedEntities.ToArray();
- _container.EmptyContainer(component.KeyContainer, entMan: EntityManager);
- foreach (var ent in contained)
- {
- _hands.PickupOrDrop(args.User, ent);
- }
-
- // if tool use ever gets predicted this needs changing.
- _popupSystem.PopupEntity(Loc.GetString("headset-encryption-keys-all-extracted"), uid, args.User);
- _audio.PlayPvs(component.KeyExtractionSound, args.Target);
+ if(!_toolSystem.UseTool(args.Used, args.User, uid, 1f, new[] { component.KeysExtractionMethod }, toolEvData, toolComponent: tool))
+ return;
}
private void OnStartup(EntityUid uid, EncryptionKeyHolderComponent component, ComponentStartup args)
examineEvent.PushMarkup(msg);
}
}
+
+ public sealed class EncryptionRemovalFinishedEvent : EntityEventArgs
+ {
+ public EntityUid User;
+
+ public EncryptionRemovalFinishedEvent(EntityUid user)
+ {
+ User = user;
+ }
+ }
+
+ public sealed class EncryptionRemovalCancelledEvent : EntityEventArgs
+ {
+
+ }
}
projects / space-station-14.git / commitdiff