--- /dev/null
+using Content.Shared.Storage;
+using Content.Shared.Lock;
+using Robust.Client.GameObjects;
+
+namespace Content.Client.Lock.Visualizers;
+
+public sealed class LockVisualizerSystem : VisualizerSystem<LockVisualsComponent>
+{
+ protected override void OnAppearanceChange(EntityUid uid, LockVisualsComponent comp, ref AppearanceChangeEvent args)
+ {
+ if (args.Sprite == null
+ || !AppearanceSystem.TryGetData<bool>(uid, LockVisuals.Locked, out _, args.Component))
+ return;
+
+ // Lock state for the entity.
+ if (!AppearanceSystem.TryGetData<bool>(uid, LockVisuals.Locked, out var locked, args.Component))
+ locked = true;
+
+ var unlockedStateExist = args.Sprite.BaseRSI?.TryGetState(comp.StateUnlocked, out _);
+
+ if (AppearanceSystem.TryGetData<bool>(uid, StorageVisuals.Open, out var open, args.Component))
+ {
+ args.Sprite.LayerSetVisible(LockVisualLayers.Lock, !open);
+ }
+ else if (!(bool) unlockedStateExist!)
+ args.Sprite.LayerSetVisible(LockVisualLayers.Lock, locked);
+
+ if (!open && (bool) unlockedStateExist!)
+ {
+ args.Sprite.LayerSetState(LockVisualLayers.Lock, locked ? comp.StateLocked : comp.StateUnlocked);
+ }
+ }
+}
+
+public enum LockVisualLayers : byte
+{
+ Lock
+}
--- /dev/null
+namespace Content.Client.Lock.Visualizers;
+
+[RegisterComponent]
+[Access(typeof(LockVisualizerSystem))]
+public sealed partial class LockVisualsComponent : Component
+{
+ /// <summary>
+ /// The RSI state used for the lock indicator while the entity is locked.
+ /// </summary>
+ [DataField("stateLocked")]
+ [ViewVariables(VVAccess.ReadWrite)]
+ public string? StateLocked = "locked";
+
+ /// <summary>
+ /// The RSI state used for the lock indicator entity is unlocked.
+ /// </summary>
+ [DataField("stateUnlocked")]
+ [ViewVariables(VVAccess.ReadWrite)]
+ public string? StateUnlocked = "unlocked";
+}
-using Content.Client.Storage.Visualizers;
-using Content.Shared.Singularity.Components;
+using Content.Shared.Singularity.Components;
using Content.Shared.Singularity.EntitySystems;
-using Content.Shared.Storage;
using Robust.Client.GameObjects;
namespace Content.Client.Singularity.Systems;
if (args.Sprite == null)
return;
- if (args.Sprite.LayerMapTryGet(StorageVisualLayers.Lock, out var lockLayer))
- {
- if (!_appearance.TryGetData<bool>(uid, StorageVisuals.Locked, out var locked, args.Component))
- locked = false;
-
- args.Sprite.LayerSetVisible(lockLayer, locked);
- }
-
if (!_appearance.TryGetData<EmitterVisualState>(uid, EmitterVisuals.VisualState, out var state, args.Component))
state = EmitterVisualState.Off;
args.Sprite.LayerSetState(StorageVisualLayers.Base, comp.StateBaseClosed);
}
}
-
- // Lock state for the storage entity. TODO: Split into its own visualizer.
- if (AppearanceSystem.TryGetData<bool>(uid, StorageVisuals.CanLock, out var canLock, args.Component) && canLock)
- {
- if (!AppearanceSystem.TryGetData<bool>(uid, StorageVisuals.Locked, out var locked, args.Component))
- locked = true;
-
- args.Sprite.LayerSetVisible(StorageVisualLayers.Lock, !open);
- if (!open)
- {
- args.Sprite.LayerSetState(StorageVisualLayers.Lock, locked ? comp.StateLocked : comp.StateUnlocked);
- }
- }
}
}
public enum StorageVisualLayers : byte
{
Base,
- Door,
- Lock
+ Door
}
[ViewVariables(VVAccess.ReadWrite)]
public string? StateDoorClosed;
- /// <summary>
- /// The RSI state used for the lock indicator while the storage is locked.
- /// </summary>
- [DataField("stateLocked")]
- [ViewVariables(VVAccess.ReadWrite)]
- public string? StateLocked = "locked";
-
- /// <summary>
- /// The RSI state used for the lock indicator while the storage is unlocked.
- /// </summary>
- [DataField("stateUnlocked")]
- [ViewVariables(VVAccess.ReadWrite)]
- public string? StateUnlocked = "unlocked";
-
/// <summary>
/// The drawdepth the object has when it's open
/// </summary>
using Content.Shared.Interaction;
using Content.Shared.Lock;
using Robust.Server.GameObjects;
-using Robust.Shared.Audio;
using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Player;
SubscribeLocalEvent<GasCanisterComponent, GasCanisterHoldingTankEjectMessage>(OnHoldingTankEjectMessage);
SubscribeLocalEvent<GasCanisterComponent, GasCanisterChangeReleasePressureMessage>(OnCanisterChangeReleasePressure);
SubscribeLocalEvent<GasCanisterComponent, GasCanisterChangeReleaseValveMessage>(OnCanisterChangeReleaseValve);
- SubscribeLocalEvent<GasCanisterComponent, LockToggledEvent>(OnLockToggled);
}
/// <summary>
{
// Ensure container
_slots.AddItemSlot(uid, comp.ContainerName, comp.GasTankSlot);
-
- if (TryComp<LockComponent>(uid, out var lockComp))
- {
- _appearance.SetData(uid, GasCanisterVisuals.Locked, lockComp.Locked);
- }
}
private void DirtyUI(EntityUid uid,
args.GasMixtures = new Dictionary<string, GasMixture?> { {Name(uid), component.Air} };
}
- private void OnLockToggled(EntityUid uid, GasCanisterComponent component, ref LockToggledEvent args)
- {
- _appearance.SetData(uid, GasCanisterVisuals.Locked, args.Locked);
- }
-
/// <summary>
/// Check if the canister is locked, playing its sound and popup if so.
/// </summary>
public enum GasCanisterVisuals
{
PressureState,
- TankInserted,
- Locked
+ TankInserted
}
#endregion
return this;
}
}
+
+[NetSerializable]
+[Serializable]
+public enum LockVisuals : byte
+{
+ Locked
+}
using Content.Shared.IdentityManagement;
using Content.Shared.Interaction;
using Content.Shared.Popups;
-using Content.Shared.Storage;
using Content.Shared.Storage.Components;
using Content.Shared.Verbs;
using JetBrains.Annotations;
-using Robust.Shared.Audio;
using Robust.Shared.Audio.Systems;
using Robust.Shared.Utility;
private void OnStartup(EntityUid uid, LockComponent lockComp, ComponentStartup args)
{
- _appearanceSystem.SetData(uid, StorageVisuals.CanLock, true);
- _appearanceSystem.SetData(uid, StorageVisuals.Locked, lockComp.Locked);
+ _appearanceSystem.SetData(uid, LockVisuals.Locked, lockComp.Locked);
}
private void OnActivated(EntityUid uid, LockComponent lockComp, ActivateInWorldEvent args)
_audio.PlayPredicted(lockComp.LockSound, uid, user);
lockComp.Locked = true;
- _appearanceSystem.SetData(uid, StorageVisuals.Locked, true);
+ _appearanceSystem.SetData(uid, LockVisuals.Locked, true);
Dirty(uid, lockComp);
var ev = new LockToggledEvent(true);
_audio.PlayPredicted(lockComp.UnlockSound, uid, user);
lockComp.Locked = false;
- _appearanceSystem.SetData(uid, StorageVisuals.Locked, false);
+ _appearanceSystem.SetData(uid, LockVisuals.Locked, false);
Dirty(uid, lockComp);
var ev = new LockToggledEvent(false);
if (!component.Locked || !component.BreakOnEmag)
return;
_audio.PlayPredicted(component.UnlockSound, uid, null);
- _appearanceSystem.SetData(uid, StorageVisuals.Locked, false);
+ _appearanceSystem.SetData(uid, LockVisuals.Locked, false);
RemComp<LockComponent>(uid); //Literally destroys the lock as a tell it was emagged
args.Handled = true;
}
+++ /dev/null
-using Robust.Shared.Serialization;
-
-namespace Content.Shared.Security
-{
- [Serializable, NetSerializable]
- public enum DeployableBarrierVisuals : byte
- {
- State
- }
-
-
- [Serializable, NetSerializable]
- public enum DeployableBarrierState : byte
- {
- Idle,
- Deployed
- }
-}
public sealed class DeployableBarrierSystem : EntitySystem
{
- [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
[Dependency] private readonly FixtureSystem _fixtures = default!;
[Dependency] private readonly SharedPointLightSystem _pointLight = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
_physics.SetHard(uid, fixture, false);
}
- var state = isDeployed ? DeployableBarrierState.Deployed : DeployableBarrierState.Idle;
- _appearance.SetData(uid, DeployableBarrierVisuals.State, state);
-
if (TryComp(uid, out SharedPullableComponent? pullable))
_pulling.TryStopPull(pullable);
{
Open,
HasContents,
- CanLock,
- Locked,
StorageUsed,
Capacity
}
- type: Sprite
sprite: Objects/Specific/Security/barrier.rsi
layers:
- - state: "idle"
- map: ["deployableBarrierBase"]
+ - state: idle
+ - state: locked
+ map: ["enum.LockVisualLayers.Lock"]
- type: Appearance
- - type: GenericVisualizer
- visuals:
- enum.DeployableBarrierVisuals.State:
- deployableBarrierBase:
- enum.DeployableBarrierState.Idle: {state: "idle"}
- enum.DeployableBarrierState.Deployed: {state: "deployed"}
+ - type: LockVisuals
- type: InteractionOutline
- type: Physics
bodyType: Dynamic
visible: false
map: ["enum.WeldableLayers.BaseWelded"]
- state: locked
- map: ["enum.StorageVisualLayers.Lock"]
+ map: ["enum.LockVisualLayers.Lock"]
shader: unshaded
- type: InteractionOutline
- type: Physics
- type: EntityStorageVisuals
stateDoorOpen: artifact_container_open
stateDoorClosed: artifact_container_door
+ - type: LockVisuals
- type: ItemSlots
- type: ContainerContainer
containers:
- state: locked
shader: unshaded
visible: false
- map: ["enum.StorageVisualLayers.Lock"]
+ map: ["enum.LockVisualLayers.Lock"]
- type: Transform
noRot: false
- type: Fixtures
enum.PowerDeviceVisualLayers.Powered:
True: { visible: true }
False: { visible: false }
+ - type: LockVisuals
- type: DeviceNetwork
deviceNetId: Wireless
receiveFrequencyId: BasicDevice
shader: unshaded
visible: false
map: ["enum.EmitterVisualLayers.Lights"]
- - state: lock
+ - state: locked
shader: unshaded
visible: false
- map: ["enum.StorageVisualLayers.Lock"]
+ map: ["enum.LockVisualLayers.Lock"]
- type: Emitter
- type: Gun
showExamineText: false
- type: Appearance
- type: Lock
locked: false
+ - type: LockVisuals
- type: AccessReader
access: [[ "Engineering" ]]
- type: Machine
tankInserted:
False: { state: can-open, visible: false }
True: { state: can-open, visible: true }
- enum.GasCanisterVisuals.Locked:
+ enum.LockVisuals.Locked:
locked:
- False: { state: can-unlocked, shader: "unshaded" }
- True: { state: can-locked, shader: "unshaded" }
+ False: { state: unlocked, shader: "unshaded" }
+ True: { state: locked, shader: "unshaded" }
enum.GasCanisterVisuals.PressureState:
pressureLight:
0: { state: can-o0, shader: "unshaded" }
components:
- type: AccessReader
- type: Lock
+ - type: LockVisuals
- type: Sprite
sprite: Structures/Storage/closet.rsi
noRot: true
- state: generic_door
map: ["enum.StorageVisualLayers.Door"]
- state: locked
- map: ["enum.StorageVisualLayers.Lock"]
+ map: ["enum.LockVisualLayers.Lock"]
shader: unshaded
- state: welded
visible: false
components:
- type: AccessReader
- type: Lock
+ - type: LockVisuals
- type: Sprite
sprite: Structures/Storage/wall_locker.rsi
layers:
- state: generic_door
map: ["enum.StorageVisualLayers.Door"]
- state: locked
- map: ["enum.StorageVisualLayers.Lock"]
+ map: ["enum.LockVisualLayers.Lock"]
shader: unshaded
- state: welded
visible: false
visible: false
map: ["enum.WeldableLayers.BaseWelded"]
- state: locked
- map: ["enum.StorageVisualLayers.Lock"]
+ map: ["enum.LockVisualLayers.Lock"]
shader: unshaded
- type: MovedByPressure
- type: DamageOnHighSpeedImpact
- type: Appearance
- type: EntityStorageVisuals
stateBase: base
- stateLocked: locked
- stateUnlocked: unlocked
stateDoorOpen: base
stateDoorClosed: door
+ - type: LockVisuals
id: CrateBaseSecure
components:
- type: Lock
+ - type: LockVisuals
- type: AccessReader
- type: Icon
sprite: Structures/Storage/Crates/secure.rsi
visible: false
map: ["enum.WeldableLayers.BaseWelded"]
- state: locked
- map: ["enum.StorageVisualLayers.Lock"]
+ map: ["enum.LockVisualLayers.Lock"]
shader: unshaded
- type: Damageable
damageContainer: StructuralInorganic
"name": "idle"
},
{
- "name": "deployed",
+ "name": "locked",
"delays": [
[
0.1,
]
},
{
- "name": "lock",
+ "name": "locked",
"directions": 4
},
{
"name": "can-connector"
},
{
- "name": "can-locked"
+ "name": "locked"
},
{
- "name": "can-unlocked"
+ "name": "unlocked"
},
{
"name": "can-o0",
projects / space-station-14.git / commitdiff
