namespace Content.Server.Item;
/// <summary>
-/// Handles whether this item applies a disarm malus when active.
+/// Handles whether this item applies a disarm malus when active.
/// </summary>
[RegisterComponent]
public sealed partial class ItemToggleDisarmMalusComponent : Component
{
/// <summary>
/// Item has this modifier to the chance to disarm when activated.
+ /// If null, the value will be inferred from the current malus just before the malus is first deactivated.
/// </summary>
[ViewVariables(VVAccess.ReadOnly), DataField]
public float? ActivatedDisarmMalus = null;
/// <summary>
/// Item has this modifier to the chance to disarm when deactivated. If none is mentioned, it uses the item's default disarm modifier.
+ /// If null, the value will be inferred from the current malus just before the malus is first activated.
/// </summary>
[ViewVariables(VVAccess.ReadOnly), DataField]
public float? DeactivatedDisarmMalus = null;
namespace Content.Server.Item;
/// <summary>
-/// Handles whether this item is sharp when toggled on.
+/// Handles whether this item is sharp when toggled on.
/// </summary>
[RegisterComponent]
public sealed partial class ItemToggleSharpComponent : Component
{
- /// <summary>
- /// Item can be used to butcher when activated.
- /// </summary>
- [ViewVariables(VVAccess.ReadOnly), DataField]
- public bool ActivatedSharp = true;
}
-using Content.Shared.Item;
using Content.Server.CombatMode.Disarm;
using Content.Server.Kitchen.Components;
using Content.Shared.Item.ItemToggle;
using Content.Shared.Item.ItemToggle.Components;
-using ItemToggleComponent = Content.Shared.Item.ItemToggle.Components.ItemToggleComponent;
namespace Content.Server.Item;
{
base.Initialize();
- SubscribeLocalEvent<ItemToggleComponent, ItemToggledEvent>(Toggle);
+ SubscribeLocalEvent<ItemToggleSharpComponent, ItemToggledEvent>(ToggleSharp);
+ SubscribeLocalEvent<ItemToggleDisarmMalusComponent, ItemToggledEvent>(ToggleMalus);
}
- private void Toggle(EntityUid uid, ItemToggleComponent comp, ref ItemToggledEvent args)
+ private void ToggleSharp(Entity<ItemToggleSharpComponent> ent, ref ItemToggledEvent args)
{
- if (args.Activated == true)
- {
- if (TryComp<ItemToggleSharpComponent>(uid, out var itemSharpness))
- {
- if (itemSharpness.ActivatedSharp)
- EnsureComp<SharpComponent>(uid);
- }
-
- if (!TryComp<ItemToggleDisarmMalusComponent>(uid, out var itemToggleDisarmMalus) ||
- !TryComp<DisarmMalusComponent>(uid, out var malus))
- return;
-
- //Default the deactivated DisarmMalus to the item's value before activation happens.
- itemToggleDisarmMalus.DeactivatedDisarmMalus ??= malus.Malus;
-
- if (itemToggleDisarmMalus.ActivatedDisarmMalus != null)
- {
- malus.Malus = (float) itemToggleDisarmMalus.ActivatedDisarmMalus;
- }
- }
+ // TODO generalize this into a "ToggleComponentComponent", though probably with a better name
+ if (args.Activated)
+ EnsureComp<SharpComponent>(ent);
else
- {
- if (TryComp<ItemToggleSharpComponent>(uid, out var itemSharpness))
- {
- if (itemSharpness.ActivatedSharp)
- RemCompDeferred<SharpComponent>(uid);
- }
+ RemCompDeferred<SharpComponent>(ent);
+ }
- if (!TryComp<ItemToggleDisarmMalusComponent>(uid, out var itemToggleDisarmMalus) ||
- !TryComp<DisarmMalusComponent>(uid, out var malus))
- return;
+ private void ToggleMalus(Entity<ItemToggleDisarmMalusComponent> ent, ref ItemToggledEvent args)
+ {
+ if (!TryComp<DisarmMalusComponent>(ent, out var malus))
+ return;
- if (itemToggleDisarmMalus.DeactivatedDisarmMalus != null)
- {
- malus.Malus = (float) itemToggleDisarmMalus.DeactivatedDisarmMalus;
- }
+ if (args.Activated)
+ {
+ ent.Comp.DeactivatedDisarmMalus ??= malus.Malus;
+ if (ent.Comp.ActivatedDisarmMalus is {} activatedMalus)
+ malus.Malus = activatedMalus;
+ return;
}
+
+ ent.Comp.ActivatedDisarmMalus ??= malus.Malus;
+ if (ent.Comp.DeactivatedDisarmMalus is {} deactivatedMalus)
+ malus.Malus = deactivatedMalus;
}
}
private void ToggleDone(Entity<StunbatonComponent> entity, ref ItemToggledEvent args)
{
- if (!TryComp<ItemComponent>(entity, out var item))
- return;
-
- _item.SetHeldPrefix(entity.Owner, args.Activated ? "on" : "off", component: item);
+ _item.SetHeldPrefix(entity.Owner, args.Activated ? "on" : "off");
}
private void TryTurnOn(Entity<StunbatonComponent> entity, ref ItemToggleActivateAttemptEvent args)
using Content.Shared.Examine;
using Content.Shared.FixedPoint;
using Content.Shared.Interaction;
-using Content.Shared.Item;
using Content.Shared.Item.ItemToggle;
using Content.Shared.Tools.Components;
using Robust.Shared.GameStates;
SubscribeLocalEvent<WelderComponent, DoAfterAttemptEvent<ToolDoAfterEvent>>(OnWelderToolUseAttempt);
SubscribeLocalEvent<WelderComponent, ComponentShutdown>(OnWelderShutdown);
SubscribeLocalEvent<WelderComponent, ComponentGetState>(OnWelderGetState);
- SubscribeLocalEvent<WelderComponent, ItemToggleActivateAttemptEvent>(TryTurnOn);
- SubscribeLocalEvent<WelderComponent, ItemToggleDeactivateAttemptEvent>(TurnOff);
+ SubscribeLocalEvent<WelderComponent, ItemToggledEvent>(OnToggle);
+ SubscribeLocalEvent<WelderComponent, ItemToggleActivateAttemptEvent>(OnActivateAttempt);
}
public (FixedPoint2 fuel, FixedPoint2 capacity) GetWelderFuelAndCapacity(EntityUid uid, WelderComponent? welder = null, SolutionContainerManagerComponent? solutionContainer = null)
return (fuelSolution.GetTotalPrototypeQuantity(welder.FuelReagent), fuelSolution.MaxVolume);
}
- public void TryTurnOn(Entity<WelderComponent> entity, ref ItemToggleActivateAttemptEvent args)
+ private void OnToggle(Entity<WelderComponent> entity, ref ItemToggledEvent args)
{
- if (!_solutionContainer.ResolveSolution(entity.Owner, entity.Comp.FuelSolutionName, ref entity.Comp.FuelSolution, out var solution) ||
- !TryComp<TransformComponent>(entity, out var transform))
+ if (args.Activated)
+ TurnOn(entity, args.User);
+ else
+ TurnOff(entity, args.User);
+ }
+
+ private void OnActivateAttempt(Entity<WelderComponent> entity, ref ItemToggleActivateAttemptEvent args)
+ {
+ if (!_solutionContainer.ResolveSolution(entity.Owner, entity.Comp.FuelSolutionName, ref entity.Comp.FuelSolution, out var solution))
{
args.Cancelled = true;
+ args.Popup = Loc.GetString("welder-component-no-fuel-message");
return;
}
var fuel = solution.GetTotalPrototypeQuantity(entity.Comp.FuelReagent);
-
- // Not enough fuel to lit welder.
if (fuel == FixedPoint2.Zero || fuel < entity.Comp.FuelLitCost)
{
- if (args.User != null)
- {
- _popup.PopupEntity(Loc.GetString("welder-component-no-fuel-message"), entity, (EntityUid) args.User);
- }
+ args.Popup = Loc.GetString("welder-component-no-fuel-message");
args.Cancelled = true;
- return;
}
+ }
- _solutionContainer.RemoveReagent(entity.Comp.FuelSolution.Value, entity.Comp.FuelReagent, entity.Comp.FuelLitCost);
-
- // Logging
- AdminLogger.Add(LogType.InteractActivate, LogImpact.Low, $"{ToPrettyString(args.User):user} toggled {ToPrettyString(entity.Owner):welder} on");
+ public void TurnOn(Entity<WelderComponent> entity, EntityUid? user)
+ {
+ if (!_solutionContainer.ResolveSolution(entity.Owner, entity.Comp.FuelSolutionName, ref entity.Comp.FuelSolution))
+ return;
- _ignitionSource.SetIgnited(entity.Owner);
+ _solutionContainer.RemoveReagent(entity.Comp.FuelSolution.Value, entity.Comp.FuelReagent, entity.Comp.FuelLitCost);
+ AdminLogger.Add(LogType.InteractActivate, LogImpact.Low,
+ $"{ToPrettyString(user):user} toggled {ToPrettyString(entity.Owner):welder} on");
- if (transform.GridUid is { } gridUid)
+ var xform = Transform(entity);
+ if (xform.GridUid is { } gridUid)
{
- var position = _transformSystem.GetGridOrMapTilePosition(entity.Owner, transform);
+ var position = _transformSystem.GetGridOrMapTilePosition(entity.Owner, xform);
_atmosphereSystem.HotspotExpose(gridUid, position, 700, 50, entity.Owner, true);
}
- Dirty(entity);
-
_activeWelders.Add(entity);
}
- public void TurnOff(Entity<WelderComponent> entity, ref ItemToggleDeactivateAttemptEvent args)
+ public void TurnOff(Entity<WelderComponent> entity, EntityUid? user)
{
- // Logging
- AdminLogger.Add(LogType.InteractActivate, LogImpact.Low, $"{ToPrettyString(args.User):user} toggled {ToPrettyString(entity.Owner):welder} off");
-
- _ignitionSource.SetIgnited(entity.Owner, false);
-
- Dirty(entity);
-
+ AdminLogger.Add(LogType.InteractActivate, LogImpact.Low,
+ $"{ToPrettyString(user):user} toggled {ToPrettyString(entity.Owner):welder} off");
_activeWelders.Remove(entity);
}
if (_welderTimer < WelderUpdateTimer)
return;
- // TODO Use an "active welder" component instead, EntityQuery over that.
+ // TODO Serialization. _activeWelders is not serialized.
+ // Need to use some "active" component, and EntityQuery over that.
+ // Probably best to generalize it to a "ToggleableFuelDrain" component.
foreach (var tool in _activeWelders.ToArray())
{
if (!TryComp(tool, out WelderComponent? welder)
/// <summary>
/// The item's toggle state.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField, AutoNetworkedField]
+ [DataField, AutoNetworkedField]
public bool Activated = false;
/// <summary>
/// </summary>
[ViewVariables(VVAccess.ReadWrite), DataField, AutoNetworkedField]
public SoundSpecifier? SoundFailToActivate;
+
+ /// <summary>
+ /// Whether or not to toggle the entity's lights on or off.
+ /// </summary>
+ [ViewVariables(VVAccess.ReadWrite), DataField, AutoNetworkedField]
+ public bool ToggleLight = true;
}
/// <summary>
{
public bool Cancelled = false;
public readonly EntityUid? User = User;
+
+ /// <summary>
+ /// Pop-up that gets shown to users explaining why the attempt was cancelled.
+ /// </summary>
+ public string? Popup { get; set; }
}
/// <summary>
public readonly bool Activated = Activated;
public readonly EntityUid? User = User;
}
-
-/// <summary>
-/// Raised directed on an entity when an itemtoggle is activated.
-/// </summary>
-[ByRefEvent]
-public readonly record struct ItemToggleActivatedEvent(EntityUid? User)
-{
- public readonly EntityUid? User = User;
-}
-
-/// <summary>
-/// Raised directed on an entity when an itemtoggle is deactivated.
-/// </summary>
-[ByRefEvent]
-public readonly record struct ItemToggleDeactivatedEvent(EntityUid? User)
-{
- public readonly EntityUid? User = User;
-}
/// <summary>
/// Handles whether the item is hot when toggled on.
/// </summary>
-[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[RegisterComponent, NetworkedComponent]
public sealed partial class ItemToggleHotComponent : Component
{
- /// <summary>
- /// Item becomes hot when active.
- /// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField, AutoNetworkedField]
- public bool IsHotWhenActivated = true;
}
using Content.Shared.Interaction.Events;
using Content.Shared.Item.ItemToggle.Components;
+using Content.Shared.Popups;
using Content.Shared.Temperature;
using Content.Shared.Toggleable;
using Content.Shared.Wieldable;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
[Dependency] private readonly SharedPointLightSystem _light = default!;
[Dependency] private readonly INetManager _netManager = default!;
+ [Dependency] private readonly SharedPopupSystem _popup = default!;
public override void Initialize()
{
base.Initialize();
+ SubscribeLocalEvent<ItemToggleComponent, ComponentStartup>(OnStartup);
SubscribeLocalEvent<ItemToggleComponent, ItemUnwieldedEvent>(TurnOffonUnwielded);
SubscribeLocalEvent<ItemToggleComponent, ItemWieldedEvent>(TurnOnonWielded);
SubscribeLocalEvent<ItemToggleComponent, UseInHandEvent>(OnUseInHand);
SubscribeLocalEvent<ItemToggleActiveSoundComponent, ItemToggledEvent>(UpdateActiveSound);
}
+ private void OnStartup(Entity<ItemToggleComponent> ent, ref ComponentStartup args)
+ {
+ UpdateVisuals(ent);
+ }
+
private void OnUseInHand(EntityUid uid, ItemToggleComponent itemToggle, UseInHandEvent args)
{
if (args.Handled)
if (itemToggle.Activated)
return true;
+ if (!itemToggle.Predictable && _netManager.IsClient)
+ return true;
+
var attempt = new ItemToggleActivateAttemptEvent(user);
RaiseLocalEvent(uid, ref attempt);
else
_audio.PlayPvs(itemToggle.SoundFailToActivate, uid);
+ if (attempt.Popup != null && user != null)
+ {
+ if (predicted)
+ _popup.PopupClient(attempt.Popup, uid, user.Value);
+ else
+ _popup.PopupEntity(attempt.Popup, uid, user.Value);
+ }
+
return false;
}
- // If the item's toggle is unpredictable because of something like requiring fuel or charge, then clients exit here.
- // Otherwise you get stuff like an item activating client-side and then turning back off when it synchronizes with the server.
- if (predicted == false && _netManager.IsClient)
- return true;
Activate(uid, itemToggle, predicted, user);
if (!Resolve(uid, ref itemToggle))
return false;
+ if (!itemToggle.Predictable && _netManager.IsClient)
+ return true;
+
if (!itemToggle.Activated)
return true;
return false;
}
- // If the item's toggle is unpredictable because of something like requiring fuel or charge, then clients exit here.
- if (predicted == false && _netManager.IsClient)
- return true;
-
Deactivate(uid, itemToggle, predicted, user);
return true;
}
}
var soundToPlay = itemToggle.SoundActivate;
-
if (predicted)
_audio.PlayPredicted(soundToPlay, uid, user);
else
var toggleUsed = new ItemToggledEvent(predicted, Activated: true, user);
RaiseLocalEvent(uid, ref toggleUsed);
- var activev = new ItemToggleActivatedEvent(user);
- RaiseLocalEvent(uid, ref activev);
-
itemToggle.Activated = true;
+ UpdateVisuals((uid, itemToggle));
Dirty(uid, itemToggle);
}
/// </summary>
private void Deactivate(EntityUid uid, ItemToggleComponent itemToggle, bool predicted, EntityUid? user = null)
{
- // TODO: Fix this hardcoding
- TryComp(uid, out AppearanceComponent? appearance);
- _appearance.SetData(uid, ToggleableLightVisuals.Enabled, false, appearance);
- _appearance.SetData(uid, ToggleVisuals.Toggled, false, appearance);
-
- if (_light.TryGetLight(uid, out var light))
- {
- _light.SetEnabled(uid, false, light);
- }
-
var soundToPlay = itemToggle.SoundDeactivate;
-
if (predicted)
_audio.PlayPredicted(soundToPlay, uid, user);
else
_audio.PlayPvs(soundToPlay, uid);
-
// END FIX HARDCODING
var toggleUsed = new ItemToggledEvent(predicted, Activated: false, user);
RaiseLocalEvent(uid, ref toggleUsed);
- var activev = new ItemToggleDeactivatedEvent(user);
- RaiseLocalEvent(uid, ref activev);
-
itemToggle.Activated = false;
+ UpdateVisuals((uid, itemToggle));
Dirty(uid, itemToggle);
}
+ private void UpdateVisuals(Entity<ItemToggleComponent> ent)
+ {
+ if (TryComp(ent, out AppearanceComponent? appearance))
+ {
+ _appearance.SetData(ent, ToggleVisuals.Toggled, ent.Comp.Activated, appearance);
+
+ if (ent.Comp.ToggleLight)
+ _appearance.SetData(ent, ToggleableLightVisuals.Enabled, ent.Comp.Activated, appearance);
+ }
+
+ if (!ent.Comp.ToggleLight)
+ return;
+
+ if (_light.TryGetLight(ent, out var light))
+ _light.SetEnabled(ent, ent.Comp.Activated, light);
+ }
+
/// <summary>
/// Used for items that require to be wielded in both hands to activate. For instance the dual energy sword will turn off if not wielded.
/// </summary>
/// </summary>
private void OnIsHotEvent(EntityUid uid, ItemToggleHotComponent itemToggleHot, IsHotEvent args)
{
- if (itemToggleHot.IsHotWhenActivated)
- args.IsHot = IsActivated(uid);
+ args.IsHot |= IsActivated(uid);
}
/// <summary>
projects / space-station-14.git / commitdiff