juni/crystall-punk-14
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Keys & Locks crafting (#1207)

Browse Source 
* keeye

* random locks for demiplanes

* blank keys, material keys

* craft blank keys

* key file

* fix skill tree UIScaling

* fix audio and sounds and prediction

* delete crowbar, merge its into pickaxe

* QoL key shaping

* lock introdusing

* QoL progress lockpicking

* examinable lock

* lock insert

* mithril lockkpick

* Update wall_dirt.yml
This commit is contained in:
Ed
2025-04-24 17:10:52 +03:00
committed by GitHub
parent a2ed3154bb
commit 4bb614981f
78 changed files with 949 additions and 358 deletions
Download Patch File Download Diff File Expand all files Collapse all files

388
Content.Shared/_CP14/LockKey/SharedCP14LockKeySystem.cs
View File

@@ -1,3 +1,5 @@
using System.Linq;
using System.Text;
using Content.Shared._CP14.LockKey.Components;
using Content.Shared.DoAfter;
using Content.Shared.Interaction;
@@ -6,9 +8,14 @@ using Content.Shared.Popups;
using Content.Shared.Storage;
using Content.Shared.Verbs;
using Content.Shared.Doors.Components;
using Content.Shared.Examine;
using Content.Shared.IdentityManagement;
using Content.Shared.Timing;
using Robust.Shared.Audio.Systems;
using Robust.Shared.Network;
using Robust.Shared.Random;
using Robust.Shared.Serialization;
using Robust.Shared.Timing;
namespace Content.Shared._CP14.LockKey;
@@ -19,6 +26,9 @@ public sealed class SharedCP14LockKeySystem : EntitySystem
[Dependency] private readonly LockSystem _lock = default!;
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly IGameTiming _timing = default!;
[Dependency] private readonly INetManager _net = default!;
[Dependency] private readonly UseDelaySystem _useDelay = default!;
private EntityQuery<LockComponent> _lockQuery;
private EntityQuery<CP14LockComponent> _cp14LockQuery;
@@ -36,12 +46,22 @@ public sealed class SharedCP14LockKeySystem : EntitySystem
_keyQuery = GetEntityQuery<CP14KeyComponent>();
_doorQuery = GetEntityQuery<DoorComponent>();
//Interact
SubscribeLocalEvent<CP14KeyComponent, AfterInteractEvent>(OnKeyInteract);
SubscribeLocalEvent<CP14KeyRingComponent, AfterInteractEvent>(OnKeyRingInteract);
SubscribeLocalEvent<CP14KeyComponent, GetVerbsEvent<UtilityVerb>>(OnKeyToLockVerb);
SubscribeLocalEvent<CP14LockComponent, AfterInteractEvent>(OnLockInteract);
//Verbs
SubscribeLocalEvent<CP14KeyComponent, GetVerbsEvent<UtilityVerb>>(GetKeysVerbs);
SubscribeLocalEvent<CP14KeyFileComponent, GetVerbsEvent<UtilityVerb>>(GetKeyFileVerbs);
SubscribeLocalEvent<CP14LockpickComponent, GetVerbsEvent<UtilityVerb>>(GetLockpickVerbs);
SubscribeLocalEvent<CP14LockEditerComponent, GetVerbsEvent<UtilityVerb>>(GetLockEditerVerbs);
SubscribeLocalEvent<CP14LockpickComponent, GetVerbsEvent<UtilityVerb>>(OnLockPickToLockVerb);
SubscribeLocalEvent<CP14LockComponent, LockPickHackDoAfterEvent>(OnLockHacked);
SubscribeLocalEvent<CP14LockComponent, LockInsertDoAfterEvent>(OnLockInserted);
SubscribeLocalEvent<CP14KeyComponent, ExaminedEvent>(OnKeyExamine);
SubscribeLocalEvent<CP14LockComponent, ExaminedEvent>(OnLockExamine);
}
private void OnKeyRingInteract(Entity<CP14KeyRingComponent> keyring, ref AfterInteractEvent args)
@@ -61,6 +81,11 @@ public sealed class SharedCP14LockKeySystem : EntitySystem
if (!_cp14LockQuery.TryComp(args.Target, out var cp14LockComp))
return;
if (!_timing.IsFirstTimePredicted)
return;
args.Handled = true;
foreach (var (key, _) in storageComp.StoredItems)
{
if (!_keyQuery.TryComp(key, out var keyComp))
@@ -69,12 +94,15 @@ public sealed class SharedCP14LockKeySystem : EntitySystem
if (keyComp.LockShape != cp14LockComp.LockShape)
continue;
TryUseKeyOnLock(args.User, new Entity<CP14LockComponent>(args.Target.Value, cp14LockComp), new Entity<CP14KeyComponent>(key, keyComp));
TryUseKeyOnLock(args.User,
new Entity<CP14LockComponent>(args.Target.Value, cp14LockComp),
new Entity<CP14KeyComponent>(key, keyComp));
args.Handled = true;
return;
}
_popup.PopupEntity(Loc.GetString("cp14-lock-key-no-fit"), args.Target.Value, args.User);
if (_timing.IsFirstTimePredicted)
_popup.PopupPredicted(Loc.GetString("cp14-lock-key-no-fit"), args.Target.Value, args.User);
}
private void OnKeyInteract(Entity<CP14KeyComponent> key, ref AfterInteractEvent args)
@@ -91,48 +119,85 @@ public sealed class SharedCP14LockKeySystem : EntitySystem
if (!_cp14LockQuery.TryComp(args.Target, out var cp14LockComp))
return;
if (!_timing.IsFirstTimePredicted)
return;
args.Handled = true;
TryUseKeyOnLock(args.User, new Entity<CP14LockComponent>(args.Target.Value, cp14LockComp), key);
args.Handled = true;
}
private void OnLockPickToLockVerb(Entity<CP14LockpickComponent> lockPick, ref GetVerbsEvent<UtilityVerb> args)
private void OnLockInteract(Entity<CP14LockComponent> ent, ref AfterInteractEvent args)
{
if (!args.CanInteract || !args.CanAccess)
if (args.Handled)
return;
if (!_lockQuery.TryComp(args.Target, out var lockComp) || !lockComp.Locked)
if (!_timing.IsFirstTimePredicted)
return;
if (!_cp14LockQuery.TryComp(args.Target, out _))
if (!ent.Comp.CanEmbedded)
return;
var target = args.Target;
var user = args.User;
if (!_lockQuery.TryComp(args.Target, out _))
return;
for (var i = DepthComplexity; i >= -DepthComplexity; i--)
if (!_cp14LockQuery.TryComp(args.Target, out var targetCp14LockComp))
return;
args.Handled = true;
if (targetCp14LockComp.LockShape is not null)
{
var height = i;
var verb = new UtilityVerb()
{
Act = () =>
{
_doAfter.TryStartDoAfter(new DoAfterArgs(EntityManager, user, lockPick.Comp.HackTime, new LockPickHackDoAfterEvent(height), target, target, lockPick)
{
BreakOnDamage = true,
BreakOnMove = true,
BreakOnDropItem = true,
BreakOnHandChange = true,
});
},
Text = Loc.GetString("cp14-lock-verb-lock-pick-use-text") + $" {height}",
Message = Loc.GetString("cp14-lock-verb-lock-pick-use-message"),
Category = VerbCategory.CP14LockPick,
Priority = height,
CloseMenu = false,
};
args.Verbs.Add(verb);
_popup.PopupPredicted(Loc.GetString("cp14-lock-insert-fail-have-lock",
("name", MetaData(args.Target.Value).EntityName)),
ent,
args.User);
return;
}
//Ok, all checks passed, we ready to install lock into entity
args.Handled = true;
_popup.PopupPredicted(Loc.GetString("cp14-lock-insert-start", ("name", MetaData(args.Target.Value).EntityName), ("player", Identity.Name(args.User, EntityManager))),
ent,
args.User);
_doAfter.TryStartDoAfter(new DoAfterArgs(EntityManager,
args.User,
TimeSpan.FromSeconds(2f), //Boo, hardcoding
new LockInsertDoAfterEvent(),
args.Target,
args.Target,
ent)
{
BreakOnDamage = true,
BreakOnMove = true,
BreakOnDropItem = true,
BreakOnHandChange = true,
});
}
private void OnLockInserted(Entity<CP14LockComponent> ent, ref LockInsertDoAfterEvent args)
{
if (args.Cancelled || args.Handled)
return;
if (!_cp14LockQuery.TryComp(args.Used, out var usedLock))
return;
ent.Comp.LockShape = usedLock.LockShape;
DirtyField(ent, ent.Comp, nameof(CP14LockComponent.LockShape));
_popup.PopupPredicted(Loc.GetString("cp14-lock-insert-success", ("name", MetaData(ent).EntityName)),
ent,
args.User);
_audio.PlayPredicted(usedLock.EmbedSound, ent, args.User);
if (_net.IsServer)
QueueDel(args.Used);
}
private void OnLockHacked(Entity<CP14LockComponent> ent, ref LockPickHackDoAfterEvent args)
@@ -149,53 +214,72 @@ public sealed class SharedCP14LockKeySystem : EntitySystem
if (!TryComp<CP14LockpickComponent>(args.Used, out var lockPick))
return;
if (!_timing.IsFirstTimePredicted)
return;
if (args.Height == ent.Comp.LockShape[ent.Comp.LockPickStatus]) //Success
{
_audio.PlayPvs(lockPick.SuccessSound, ent);
_audio.PlayPredicted(lockPick.SuccessSound, ent, args.User);
ent.Comp.LockPickStatus++;
DirtyField(ent, ent.Comp, nameof(CP14LockComponent.LockPickStatus));
if (ent.Comp.LockPickStatus >= ent.Comp.LockShape.Count) // Final success
{
if (lockComp.Locked)
{
_lock.TryUnlock(ent, args.User, lockComp);
_popup.PopupEntity(Loc.GetString("cp14-lock-unlock", ("lock", MetaData(ent).EntityName)), ent, args.User);
_popup.PopupPredicted(Loc.GetString("cp14-lock-unlock", ("lock", MetaData(ent).EntityName)),
ent,
args.User);
ent.Comp.LockPickStatus = 0;
DirtyField(ent, ent.Comp, nameof(CP14LockComponent.LockPickStatus));
return;
}
_lock.TryLock(ent, args.User, lockComp);
_popup.PopupEntity(Loc.GetString("cp14-lock-lock", ("lock", MetaData(ent).EntityName)), ent, args.User);
_popup.PopupPredicted(Loc.GetString("cp14-lock-lock", ("lock", MetaData(ent).EntityName)),
ent,
args.User);
ent.Comp.LockPickStatus = 0;
DirtyField(ent, ent.Comp, nameof(CP14LockComponent.LockPickStatus));
return;
}
_popup.PopupEntity(Loc.GetString("cp14-lock-lock-pick-success"), ent, args.User);
_popup.PopupClient(Loc.GetString("cp14-lock-lock-pick-success") +
$" ({ent.Comp.LockPickStatus}/{ent.Comp.LockShape.Count})",
ent,
args.User);
}
else //Fail
{
_audio.PlayPvs(lockPick.FailSound, ent);
if (_random.Prob(ent.Comp.LockPickDamageChance)) // Damage lock pick
_audio.PlayPredicted(lockPick.FailSound, ent, args.User);
if (_net.IsServer)
{
lockPick.Health--;
if (lockPick.Health > 0)
{
_popup.PopupEntity(Loc.GetString("cp14-lock-lock-pick-failed-damage", ("lock", MetaData(ent).EntityName)), ent, args.User);
_popup.PopupEntity(Loc.GetString("cp14-lock-lock-pick-failed", ("lock", MetaData(ent).EntityName)),
ent,
args.User);
}
else
{
_popup.PopupEntity(Loc.GetString("cp14-lock-lock-pick-failed-break", ("lock", MetaData(ent).EntityName)), ent, args.User);
_popup.PopupEntity(
Loc.GetString("cp14-lock-lock-pick-failed-break", ("lock", MetaData(ent).EntityName)),
ent,
args.User);
QueueDel(args.Used);
}
}
else
{
_popup.PopupEntity(Loc.GetString("cp14-lock-lock-pick-failed", ("lock", MetaData(ent).EntityName)), ent, args.User);
}
ent.Comp.LockPickedFailMarkup = true;
ent.Comp.LockPickStatus = 0;
DirtyField(ent, ent.Comp, nameof(CP14LockComponent.LockPickStatus));
}
}
private void OnKeyToLockVerb(Entity<CP14KeyComponent> key, ref GetVerbsEvent<UtilityVerb> args)
private void GetKeysVerbs(Entity<CP14KeyComponent> key, ref GetVerbsEvent<UtilityVerb> args)
{
if (!args.CanInteract || !args.CanAccess)
return;
@@ -216,13 +300,167 @@ public sealed class SharedCP14LockKeySystem : EntitySystem
TryUseKeyOnLock(user, new Entity<CP14LockComponent>(target, cp14LockComponent), key);
},
IconEntity = GetNetEntity(key),
Text = Loc.GetString(lockComp.Locked ? "cp14-lock-verb-use-key-text-open" : "cp14-lock-verb-use-key-text-close", ("item", MetaData(args.Target).EntityName)),
Text = Loc.GetString(
lockComp.Locked ? "cp14-lock-verb-use-key-text-open" : "cp14-lock-verb-use-key-text-close",
("item", MetaData(args.Target).EntityName)),
Message = Loc.GetString("cp14-lock-verb-use-key-message", ("item", MetaData(args.Target).EntityName)),
};
args.Verbs.Add(verb);
}
private void GetKeyFileVerbs(Entity<CP14KeyFileComponent> ent, ref GetVerbsEvent<UtilityVerb> args)
{
if (!args.CanInteract || !args.CanAccess)
return;
if (!_keyQuery.TryComp(args.Target, out var keyComp))
return;
if (keyComp.LockShape == null)
return;
var target = args.Target;
var user = args.User;
var lockShapeCount = keyComp.LockShape.Count;
for (var i = 0; i <= lockShapeCount - 1; i++)
{
var i1 = i;
var verb = new UtilityVerb
{
Act = () =>
{
if (keyComp.LockShape[i1] <= -DepthComplexity)
return;
if (!_timing.IsFirstTimePredicted)
return;
if (TryComp<UseDelayComponent>(ent, out var useDelayComp) &&
_useDelay.IsDelayed((ent, useDelayComp)))
return;
if (!_net.IsServer)
return;
keyComp.LockShape[i1]--;
DirtyField(target, keyComp, nameof(CP14KeyComponent.LockShape));
_audio.PlayPvs(ent.Comp.UseSound, Transform(target).Coordinates);
Spawn("EffectSparks", Transform(target).Coordinates);
var shapeString = "[" + string.Join(", ", keyComp.LockShape) + "]";
_popup.PopupEntity(Loc.GetString("cp14-lock-key-file-updated") + shapeString, target, user);
_useDelay.TryResetDelay(ent);
},
IconEntity = GetNetEntity(ent),
Category = VerbCategory.CP14KeyFile,
Priority = -i,
Disabled = keyComp.LockShape[i] <= -DepthComplexity,
Text = Loc.GetString("cp14-lock-key-file-use-hint", ("num", i)),
CloseMenu = false,
};
args.Verbs.Add(verb);
}
}
private void GetLockpickVerbs(Entity<CP14LockpickComponent> lockPick, ref GetVerbsEvent<UtilityVerb> args)
{
if (!args.CanInteract || !args.CanAccess)
return;
if (!_lockQuery.TryComp(args.Target, out var lockComp) || !lockComp.Locked)
return;
if (!_cp14LockQuery.HasComp(args.Target))
return;
var target = args.Target;
var user = args.User;
for (var i = DepthComplexity; i >= -DepthComplexity; i--)
{
var height = i;
var verb = new UtilityVerb()
{
Act = () =>
{
_doAfter.TryStartDoAfter(new DoAfterArgs(EntityManager,
user,
lockPick.Comp.HackTime,
new LockPickHackDoAfterEvent(height),
target,
target,
lockPick)
{
BreakOnDamage = true,
BreakOnMove = true,
BreakOnDropItem = true,
BreakOnHandChange = true,
});
},
Text = Loc.GetString("cp14-lock-verb-lock-pick-use-text") + $" {height}",
Message = Loc.GetString("cp14-lock-verb-lock-pick-use-message"),
Category = VerbCategory.CP14LockPick,
Priority = height,
CloseMenu = false,
};
args.Verbs.Add(verb);
}
}
private void GetLockEditerVerbs(Entity<CP14LockEditerComponent> ent, ref GetVerbsEvent<UtilityVerb> args)
{
if (!args.CanInteract || !args.CanAccess)
return;
if (!_cp14LockQuery.TryComp(args.Target, out var lockComp) || !lockComp.CanEmbedded)
return;
if (lockComp.LockShape is null)
return;
var target = args.Target;
var user = args.User;
var lockShapeCount = lockComp.LockShape.Count;
for (var i = 0; i <= lockShapeCount - 1; i++)
{
var i1 = i;
var verb = new UtilityVerb
{
Act = () =>
{
if (!_timing.IsFirstTimePredicted)
return;
if (TryComp<UseDelayComponent>(ent, out var useDelayComp) &&
_useDelay.IsDelayed((ent, useDelayComp)))
return;
if (!_net.IsServer)
return;
lockComp.LockShape[i1]--;
if (lockComp.LockShape[i1] < -DepthComplexity)
lockComp.LockShape[i1] = DepthComplexity; //Cycle back to max
DirtyField(target, lockComp, nameof(CP14LockComponent.LockShape));
_audio.PlayPvs(ent.Comp.UseSound, Transform(target).Coordinates);
var shapeString = "[" + string.Join(", ", lockComp.LockShape) + "]";
_popup.PopupEntity(Loc.GetString("cp14-lock-editor-updated") + shapeString, target, user);
_useDelay.TryResetDelay(ent);
},
IconEntity = GetNetEntity(ent),
Category = VerbCategory.CP14EditLock,
Priority = -i,
Text = Loc.GetString("cp14-lock-editor-use-hint", ("num", i)),
CloseMenu = false,
};
args.Verbs.Add(verb);
}
}
private void TryUseKeyOnLock(EntityUid user, Entity<CP14LockComponent> target, Entity<CP14KeyComponent> key)
{
if (!TryComp<LockComponent>(target, out var lockComp))
@@ -237,24 +475,65 @@ public sealed class SharedCP14LockKeySystem : EntitySystem
if (keyShape == null || lockShape == null)
return;
if (keyShape == lockShape)
if (keyShape.SequenceEqual(lockShape))
{
if (lockComp.Locked)
{
if(_lock.TryUnlock(target, user))
_popup.PopupEntity(Loc.GetString("cp14-lock-unlock", ("lock", MetaData(target).EntityName)), target, user);
_lock.TryUnlock(target, user);
}
else
{
if (_lock.TryLock(target, user))
_popup.PopupEntity(Loc.GetString("cp14-lock-lock", ("lock", MetaData(target).EntityName)), target, user);
_lock.TryLock(target, user);
}
}
else
{
_popup.PopupEntity(Loc.GetString("cp14-lock-key-no-fit"), target, user);
_popup.PopupClient(Loc.GetString("cp14-lock-key-no-fit"), target, user);
}
}
private void OnKeyExamine(Entity<CP14KeyComponent> ent, ref ExaminedEvent args)
{
var parent = Transform(ent).ParentUid;
if (parent != args.Examiner)
return;
if (ent.Comp.LockShape == null)
return;
var sb = new StringBuilder(Loc.GetString("cp14-lock-examine-key", ("item", MetaData(ent).EntityName)));
sb.Append(" (");
foreach (var item in ent.Comp.LockShape)
{
sb.Append($"{item} ");
}
sb.Append(")");
args.PushMarkup(sb.ToString());
}
private void OnLockExamine(Entity<CP14LockComponent> ent, ref ExaminedEvent args)
{
if (!ent.Comp.CanEmbedded)
return;
var parent = Transform(ent).ParentUid;
if (parent != args.Examiner)
return;
if (ent.Comp.LockShape == null)
return;
var sb = new StringBuilder(Loc.GetString("cp14-lock-examine-key", ("item", MetaData(ent).EntityName)));
sb.Append(" (");
foreach (var item in ent.Comp.LockShape)
{
sb.Append($"{item} ");
}
sb.Append(")");
args.PushMarkup(sb.ToString());
}
}
[Serializable, NetSerializable]
@@ -270,3 +549,6 @@ public sealed partial class LockPickHackDoAfterEvent : DoAfterEvent
public override DoAfterEvent Clone() => this;
}
[Serializable, NetSerializable]
public sealed partial class LockInsertDoAfterEvent : SimpleDoAfterEvent;