Cinka/OldThink
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Gateway destinations (#21040)

Browse Source 
* Gateway generation

* Gateway stuff

* gatewehs

* mercenaries

* play area

* Range fixes and tweaks

* weh

* Gateway UI polish

* Lots of fixes

* Knock some items off

* Fix dungeon spawning

Realistically we should probably be using a salvage job.

* wahwah

* wehvs

* expression

* weh

* eee

* a

* a

* WEH

* frfr

* Gatwey

* Fix gateway windows

* Fix gateway windows

* a

* a

* Better layer masking

* a

* a

* Noise fixes

* a

* Fix fractal calculations

* a

* More fixes

* Fixes

* Add layers back in

* Fixes

* namespaces and ftl

* Other TODO

* Fix distance

* Cleanup

* Fix test
This commit is contained in:
metalgearsloth
2023-11-15 13:23:40 +11:00
committed by GitHub
parent 67a3c3a6a3
commit 816ee2e1ab
51 changed files with 1562 additions and 959 deletions
Download Patch File Download Diff File Expand all files Collapse all files

220
Content.Server/Gateway/Systems/GatewaySystem.cs
View File

@@ -1,4 +1,6 @@
using Content.Server.Gateway.Components;
using Content.Server.Station.Systems;
using Content.Server.UserInterface;
using Content.Shared.Access.Systems;
using Content.Shared.Gateway;
using Content.Shared.Popups;
@@ -6,9 +8,8 @@ using Content.Shared.Teleportation.Components;
using Content.Shared.Teleportation.Systems;
using Content.Shared.Verbs;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.GameObjects;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
namespace Content.Server.Gateway.Systems;
@@ -19,6 +20,8 @@ public sealed class GatewaySystem : EntitySystem
[Dependency] private readonly LinkedEntitySystem _linkedEntity = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly MetaDataSystem _metadata = default!;
[Dependency] private readonly StationSystem _stations = default!;
[Dependency] private readonly SharedPopupSystem _popup = default!;
[Dependency] private readonly UserInterfaceSystem _ui = default!;
@@ -26,62 +29,109 @@ public sealed class GatewaySystem : EntitySystem
{
base.Initialize();
SubscribeLocalEvent<GatewayComponent, EntityUnpausedEvent>(OnGatewayUnpaused);
SubscribeLocalEvent<GatewayComponent, ComponentStartup>(OnStartup);
SubscribeLocalEvent<GatewayComponent, ActivatableUIOpenAttemptEvent>(OnGatewayOpenAttempt);
SubscribeLocalEvent<GatewayComponent, BoundUIOpenedEvent>(UpdateUserInterface);
SubscribeLocalEvent<GatewayComponent, GatewayOpenPortalMessage>(OnOpenPortal);
SubscribeLocalEvent<GatewayDestinationComponent, ComponentStartup>(OnDestinationStartup);
SubscribeLocalEvent<GatewayDestinationComponent, ComponentShutdown>(OnDestinationShutdown);
SubscribeLocalEvent<GatewayDestinationComponent, GetVerbsEvent<AlternativeVerb>>(OnDestinationGetVerbs);
}
public override void Update(float frameTime)
public void SetEnabled(EntityUid uid, bool value, GatewayComponent? component = null)
{
base.Update(frameTime);
if (!Resolve(uid, ref component) || component.Enabled == value)
return;
// close portals after theyve been open long enough
var query = EntityQueryEnumerator<GatewayComponent, PortalComponent>();
while (query.MoveNext(out var uid, out var comp, out var _))
{
if (_timing.CurTime < comp.NextClose)
continue;
component.Enabled = value;
UpdateAllGateways();
}
ClosePortal(uid, comp);
}
private void OnGatewayUnpaused(EntityUid uid, GatewayComponent component, ref EntityUnpausedEvent args)
{
component.NextReady += args.PausedTime;
}
private void OnStartup(EntityUid uid, GatewayComponent comp, ComponentStartup args)
{
// add existing destinations
var query = EntityQueryEnumerator<GatewayDestinationComponent>();
while (query.MoveNext(out var dest, out _))
{
comp.Destinations.Add(dest);
}
// no need to update ui since its just been created, just do portal
UpdateAppearance(uid);
}
private void OnGatewayOpenAttempt(EntityUid uid, GatewayComponent component, ref ActivatableUIOpenAttemptEvent args)
{
if (!component.Enabled || !component.Interactable)
args.Cancel();
}
private void UpdateUserInterface<T>(EntityUid uid, GatewayComponent comp, T args)
{
UpdateUserInterface(uid, comp);
}
private void UpdateUserInterface(EntityUid uid, GatewayComponent comp)
public void UpdateAllGateways()
{
var destinations = new List<(NetEntity, string, TimeSpan, bool)>();
foreach (var destUid in comp.Destinations)
var query = AllEntityQuery<GatewayComponent, TransformComponent>();
while (query.MoveNext(out var uid, out var comp, out var xform))
{
var dest = Comp<GatewayDestinationComponent>(destUid);
if (!dest.Enabled)
UpdateUserInterface(uid, comp, xform);
}
}
private void UpdateUserInterface(EntityUid uid, GatewayComponent comp, TransformComponent? xform = null)
{
if (!Resolve(uid, ref xform))
return;
var destinations = new List<GatewayDestinationData>();
var query = AllEntityQuery<GatewayComponent, TransformComponent>();
var nextUnlock = TimeSpan.Zero;
var unlockTime = TimeSpan.Zero;
// Next unlock is based off of:
// - Our station's unlock timer (if we have a station)
// - If our map is a generated destination then use the generator that made it
if (TryComp(_stations.GetOwningStation(uid), out GatewayGeneratorComponent? generatorComp) ||
(TryComp(xform.MapUid, out GatewayGeneratorDestinationComponent? generatorDestination) &&
TryComp(generatorDestination.Generator, out generatorComp)))
{
nextUnlock = generatorComp.NextUnlock;
unlockTime = generatorComp.UnlockCooldown;
}
while (query.MoveNext(out var destUid, out var dest, out var destXform))
{
if (!dest.Enabled || destUid == uid)
continue;
destinations.Add((GetNetEntity(destUid), dest.Name, dest.NextReady, HasComp<PortalComponent>(destUid)));
// Show destination if either no destination comp on the map or it's ours.
TryComp<GatewayGeneratorDestinationComponent>(destXform.MapUid, out var gatewayDestination);
destinations.Add(new GatewayDestinationData()
{
Entity = GetNetEntity(destUid),
// Fallback to grid's ID if applicable.
Name = dest.Name.IsEmpty && destXform.GridUid != null ? FormattedMessage.FromUnformatted(MetaData(destXform.GridUid.Value).EntityName) : dest.Name ,
Portal = HasComp<PortalComponent>(destUid),
// If NextUnlock < CurTime it's unlocked, however
// we'll always send the client if it's locked
// It can just infer unlock times locally and not have to worry about it here.
Locked = gatewayDestination != null && gatewayDestination.Locked
});
}
_linkedEntity.GetLink(uid, out var current);
var state = new GatewayBoundUserInterfaceState(destinations, GetNetEntity(current), comp.NextClose, comp.LastOpen);
var state = new GatewayBoundUserInterfaceState(
destinations,
GetNetEntity(current),
comp.NextReady,
comp.Cooldown,
nextUnlock,
unlockTime
);
_ui.TrySetUiState(uid, GatewayUiKey.Key, state);
}
@@ -92,38 +142,58 @@ public sealed class GatewaySystem : EntitySystem
private void OnOpenPortal(EntityUid uid, GatewayComponent comp, GatewayOpenPortalMessage args)
{
if (args.Session.AttachedEntity == null)
if (args.Session.AttachedEntity == null || GetNetEntity(uid) == args.Destination ||
!comp.Enabled || !comp.Interactable)
return;
// if the gateway has an access reader check it before allowing opening
var user = args.Session.AttachedEntity.Value;
if (CheckAccess(user, uid))
if (CheckAccess(user, uid, comp))
return;
// can't link if portal is already open on either side, the destination is invalid or on cooldown
var desto = GetEntity(args.Destination);
if (HasComp<PortalComponent>(uid) ||
HasComp<PortalComponent>(desto) ||
!TryComp<GatewayDestinationComponent>(desto, out var dest) ||
// If it's already open / not enabled / we're not ready DENY.
if (!TryComp<GatewayComponent>(desto, out var dest) ||
!dest.Enabled ||
_timing.CurTime < dest.NextReady)
_timing.CurTime < _metadata.GetPauseTime(uid) + comp.NextReady)
{
return;
}
// TODO: admin log???
ClosePortal(uid, comp, false);
OpenPortal(uid, comp, desto, dest);
}
private void OpenPortal(EntityUid uid, GatewayComponent comp, EntityUid dest, GatewayDestinationComponent destComp)
private void OpenPortal(EntityUid uid, GatewayComponent comp, EntityUid dest, GatewayComponent destComp, TransformComponent? destXform = null)
{
_linkedEntity.TryLink(uid, dest);
EnsureComp<PortalComponent>(uid).CanTeleportToOtherMaps = true;
EnsureComp<PortalComponent>(dest).CanTeleportToOtherMaps = true;
if (!Resolve(dest, ref destXform) || destXform.MapUid == null)
return;
var ev = new AttemptGatewayOpenEvent(destXform.MapUid.Value, dest);
RaiseLocalEvent(destXform.MapUid.Value, ref ev);
if (ev.Cancelled)
return;
_linkedEntity.OneWayLink(uid, dest);
var sourcePortal = EnsureComp<PortalComponent>(uid);
var targetPortal = EnsureComp<PortalComponent>(dest);
sourcePortal.CanTeleportToOtherMaps = true;
targetPortal.CanTeleportToOtherMaps = true;
sourcePortal.RandomTeleport = false;
targetPortal.RandomTeleport = false;
var openEv = new GatewayOpenEvent(destXform.MapUid.Value, dest);
RaiseLocalEvent(destXform.MapUid.Value, ref openEv);
// for ui
comp.LastOpen = _timing.CurTime;
// close automatically after time is up
comp.NextClose = comp.LastOpen + destComp.OpenTime;
comp.NextReady = _timing.CurTime + comp.Cooldown;
_audio.PlayPvs(comp.OpenSound, uid);
_audio.PlayPvs(comp.OpenSound, dest);
@@ -133,7 +203,7 @@ public sealed class GatewaySystem : EntitySystem
UpdateAppearance(dest);
}
private void ClosePortal(EntityUid uid, GatewayComponent? comp = null)
private void ClosePortal(EntityUid uid, GatewayComponent? comp = null, bool update = true)
{
if (!Resolve(uid, ref comp))
return;
@@ -142,7 +212,7 @@ public sealed class GatewaySystem : EntitySystem
if (!_linkedEntity.GetLink(uid, out var dest))
return;
if (TryComp<GatewayDestinationComponent>(dest, out var destComp))
if (TryComp<GatewayComponent>(dest, out var destComp))
{
// portals closed, put it on cooldown and let it eventually be opened again
destComp.NextReady = _timing.CurTime + destComp.Cooldown;
@@ -153,46 +223,35 @@ public sealed class GatewaySystem : EntitySystem
_linkedEntity.TryUnlink(uid, dest.Value);
RemComp<PortalComponent>(dest.Value);
UpdateUserInterface(uid, comp);
UpdateAppearance(uid);
UpdateAppearance(dest.Value);
if (update)
{
UpdateUserInterface(uid, comp);
UpdateAppearance(uid);
UpdateAppearance(dest.Value);
}
}
private void OnDestinationStartup(EntityUid uid, GatewayDestinationComponent comp, ComponentStartup args)
private void OnDestinationStartup(EntityUid uid, GatewayComponent comp, ComponentStartup args)
{
var query = EntityQueryEnumerator<GatewayComponent>();
var query = AllEntityQuery<GatewayComponent>();
while (query.MoveNext(out var gatewayUid, out var gateway))
{
gateway.Destinations.Add(uid);
UpdateUserInterface(gatewayUid, gateway);
}
UpdateAppearance(uid);
}
private void OnDestinationShutdown(EntityUid uid, GatewayDestinationComponent comp, ComponentShutdown args)
private void OnDestinationShutdown(EntityUid uid, GatewayComponent comp, ComponentShutdown args)
{
var query = EntityQueryEnumerator<GatewayComponent>();
var query = AllEntityQuery<GatewayComponent>();
while (query.MoveNext(out var gatewayUid, out var gateway))
{
gateway.Destinations.Remove(uid);
UpdateUserInterface(gatewayUid, gateway);
}
}
private void OnDestinationGetVerbs(EntityUid uid, GatewayDestinationComponent comp, GetVerbsEvent<AlternativeVerb> args)
{
if (!comp.Closeable || !args.CanInteract || !args.CanAccess)
return;
// a portal is open so add verb to close it
args.Verbs.Add(new AlternativeVerb()
{
Act = () => TryClose(uid, args.User),
Text = Loc.GetString("gateway-close-portal")
});
}
private void TryClose(EntityUid uid, EntityUid user)
{
// portal already closed so cant close it
@@ -222,4 +281,31 @@ public sealed class GatewaySystem : EntitySystem
_audio.PlayPvs(comp.AccessDeniedSound, uid);
return true;
}
public void SetDestinationName(EntityUid gatewayUid, FormattedMessage gatewayName, GatewayComponent? gatewayComp = null)
{
if (!Resolve(gatewayUid, ref gatewayComp))
return;
gatewayComp.Name = gatewayName;
Dirty(gatewayUid, gatewayComp);
}
}
/// <summary>
/// Raised directed on the target map when a GatewayDestination is attempted to be opened.
/// </summary>
[ByRefEvent]
public record struct AttemptGatewayOpenEvent(EntityUid MapUid, EntityUid GatewayDestinationUid)
{
public readonly EntityUid MapUid = MapUid;
public readonly EntityUid GatewayDestinationUid = GatewayDestinationUid;
public bool Cancelled = false;
}
/// <summary>
/// Raised directed on the target map when a gateway is opened.
/// </summary>
[ByRefEvent]
public readonly record struct GatewayOpenEvent(EntityUid MapUid, EntityUid GatewayDestinationUid);