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

Make portals use ICollideBehavior and set collidable.Hard to false (#2186)

Browse Source
This commit is contained in:
DrSmugleaf
2020-10-10 13:32:42 +02:00
committed by GitHub
parent 89f5ec31d2
commit fe39b5fb71
11 changed files with 107 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

205
Content.Server/GameObjects/Components/Movement/ServerPortalComponent.cs
View File

@@ -1,205 +0,0 @@
#nullable enable
using System;
using System.Collections.Generic;
using Content.Shared.GameObjects.Components.Movement;
using Robust.Server.GameObjects;
using Robust.Server.GameObjects.EntitySystems;
using Robust.Server.Interfaces.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.GameObjects.Components;
using Robust.Shared.GameObjects.Systems;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Serialization;
using Robust.Shared.Timers;
using Robust.Shared.ViewVariables;
namespace Content.Server.GameObjects.Components.Movement
{
[RegisterComponent]
public class ServerPortalComponent : SharedPortalComponent
{
[Dependency] private readonly IServerEntityManager _serverEntityManager = default!;
// Potential improvements: Different sounds,
// Add Gateways
// More efficient form of GetEntitiesIntersecting,
// Put portal above most other things layer-wise
// Add telefragging (get entities on connecting portal and force brute damage)
private IEntity? _connectingTeleporter;
private PortalState _state = PortalState.Pending;
[ViewVariables(VVAccess.ReadWrite)] private float _individualPortalCooldown;
[ViewVariables] private float _overallPortalCooldown;
[ViewVariables] private bool _onCooldown;
[ViewVariables] private string _departureSound = "";
[ViewVariables] private string _arrivalSound = "";
public readonly List<IEntity> ImmuneEntities = new List<IEntity>(); // K
[ViewVariables(VVAccess.ReadWrite)] private float _aliveTime;
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
// How long will the portal stay up: 0 is infinite
serializer.DataField(ref _aliveTime, "alive_time", 10.0f);
// How long before a specific person can go back into it
serializer.DataField(ref _individualPortalCooldown, "individual_cooldown", 2.1f);
// How long before anyone can go in it
serializer.DataField(ref _overallPortalCooldown, "overall_cooldown", 2.0f);
serializer.DataField(ref _departureSound, "departure_sound", "/Audio/Effects/teleport_departure.ogg");
serializer.DataField(ref _arrivalSound, "arrival_sound", "/Audio/Effects/teleport_arrival.ogg");
}
public override void OnAdd()
{
// This will blow up an entity it's attached to
base.OnAdd();
if (Owner.TryGetComponent<ICollidableComponent>(out var collide))
{
//collide.IsHardCollidable = false;
}
_state = PortalState.Pending;
if (_aliveTime > 0)
{
Timer.Spawn(TimeSpan.FromSeconds(_aliveTime), () => Owner.Delete());
}
}
public bool CanBeConnected()
{
if (_connectingTeleporter == null)
{
return true;
}
return false;
}
public void TryConnectPortal(IEntity otherPortal)
{
if (otherPortal.TryGetComponent<ServerPortalComponent>(out var connectedPortal) && connectedPortal.CanBeConnected())
{
_connectingTeleporter = otherPortal;
connectedPortal._connectingTeleporter = Owner;
TryChangeState(PortalState.Pending);
}
}
public void TryChangeState(PortalState targetState)
{
if (Owner == null || Deleted)
{
return;
}
_state = targetState;
if (Owner.TryGetComponent(out AppearanceComponent? appearance))
{
appearance.SetData(PortalVisuals.State, _state);
}
}
private void ReleaseCooldown(IEntity entity)
{
if (Owner == null || Deleted)
return;
if (ImmuneEntities.Contains(entity))
{
ImmuneEntities.Remove(entity);
}
if (_connectingTeleporter != null &&
_connectingTeleporter.TryGetComponent<ServerPortalComponent>(out var otherPortal))
{
otherPortal.ImmuneEntities.Remove(entity);
}
}
public IEnumerable<IEntity> GetPortableEntities()
{
foreach (var entity in _serverEntityManager.GetEntitiesIntersecting(Owner))
{
if (IsEntityPortable(entity))
{
yield return entity;
}
}
}
private bool IsEntityPortable(IEntity entity)
{
// TODO: Check if it's slotted etc. Otherwise the slot item itself gets ported.
if (!ImmuneEntities.Contains(entity) && entity.HasComponent<TeleportableComponent>())
{
return true;
}
return false;
}
// TODO: Fix portal updates for performance
public void OnUpdate()
{
if (_onCooldown == false)
{
foreach (var entity in GetPortableEntities())
{
TryPortalEntity(entity);
break;
}
}
}
public void StartCooldown()
{
if (_overallPortalCooldown > 0 && _onCooldown == false)
{
_onCooldown = true;
TryChangeState(PortalState.RecentlyTeleported);
if (_connectingTeleporter != null)
{
_connectingTeleporter.TryGetComponent<ServerPortalComponent>(out var otherPortal);
if (otherPortal != null)
{
otherPortal.TryChangeState(PortalState.RecentlyTeleported);
Timer.Spawn(TimeSpan.FromSeconds(_overallPortalCooldown), () =>
{
_onCooldown = false;
TryChangeState(PortalState.Pending);
otherPortal.TryChangeState(PortalState.Pending);
});
}
}
}
else
{
// Just in case?
_onCooldown = false;
}
}
public void TryPortalEntity(IEntity entity)
{
if (ImmuneEntities.Contains(entity) || _connectingTeleporter == null)
{
return;
}
var position = _connectingTeleporter.Transform.Coordinates;
var soundPlayer = EntitySystem.Get<AudioSystem>();
// Departure
// Do we need to rate-limit sounds to stop ear BLAST?
soundPlayer.PlayAtCoords(_departureSound, entity.Transform.Coordinates);
entity.Transform.Coordinates = position;
soundPlayer.PlayAtCoords(_arrivalSound, entity.Transform.Coordinates);
TryChangeState(PortalState.RecentlyTeleported);
// To stop spam teleporting. Could potentially look at adding a timer to flush this from the portal
ImmuneEntities.Add(entity);
_connectingTeleporter.GetComponent<ServerPortalComponent>().ImmuneEntities.Add(entity);
Timer.Spawn(TimeSpan.FromSeconds(_individualPortalCooldown), () => ReleaseCooldown(entity));
StartCooldown();
}
}
}

257
Content.Server/GameObjects/Components/Movement/ServerTeleporterComponent.cs
View File

@@ -1,257 +0,0 @@
#nullable enable
using System;
using System.Linq;
using Content.Shared.GameObjects.Components.Movement;
using Content.Shared.Interfaces.GameObjects.Components;
using Content.Shared.Utility;
using Robust.Server.GameObjects;
using Robust.Server.GameObjects.EntitySystems;
using Robust.Server.Interfaces.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.GameObjects.Components;
using Robust.Shared.GameObjects.Systems;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.Interfaces.Map;
using Robust.Shared.Interfaces.Random;
using Robust.Shared.IoC;
using Robust.Shared.Map;
using Robust.Shared.Maths;
using Robust.Shared.Serialization;
using Robust.Shared.Timers;
using Robust.Shared.ViewVariables;
namespace Content.Server.GameObjects.Components.Movement
{
[RegisterComponent]
public class ServerTeleporterComponent : Component, IAfterInteract
{
[Dependency] private readonly IServerEntityManager _serverEntityManager = default!;
[Dependency] private readonly IRobustRandom _spreadRandom = default!;
// TODO: Look at MapManager.Map for Beacons to get all entities on grid
public ItemTeleporterState State => _state;
public override string Name => "ItemTeleporter";
[ViewVariables] private float _chargeTime;
[ViewVariables] private float _cooldown;
[ViewVariables] private int _range;
[ViewVariables] private ItemTeleporterState _state;
[ViewVariables] private TeleporterType _teleporterType;
[ViewVariables] private string _departureSound = "";
[ViewVariables] private string _arrivalSound = "";
[ViewVariables] private string? _cooldownSound;
// If the direct OR random teleport will try to avoid hitting collidables
[ViewVariables] private bool _avoidCollidable;
[ViewVariables] private float _portalAliveTime;
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(ref _teleporterType, "teleporter_type", TeleporterType.Random);
serializer.DataField(ref _range, "range", 15);
serializer.DataField(ref _chargeTime, "charge_time", 0.2f);
serializer.DataField(ref _cooldown, "cooldown", 2.0f);
serializer.DataField(ref _avoidCollidable, "avoid_walls", true);
serializer.DataField(ref _departureSound, "departure_sound", "/Audio/Effects/teleport_departure.ogg");
serializer.DataField(ref _arrivalSound, "arrival_sound", "/Audio/Effects/teleport_arrival.ogg");
serializer.DataField(ref _cooldownSound, "cooldown_sound", null);
serializer.DataField(ref _portalAliveTime, "portal_alive_time", 5.0f); // TODO: Change this to 0 before PR?
}
private void SetState(ItemTeleporterState newState)
{
if (!Owner.TryGetComponent(out AppearanceComponent? appearance))
{
return;
}
if (newState == ItemTeleporterState.Cooldown)
{
appearance.SetData(TeleporterVisuals.VisualState, TeleporterVisualState.Charging);
}
else
{
appearance.SetData(TeleporterVisuals.VisualState, TeleporterVisualState.Ready);
}
_state = newState;
}
void IAfterInteract.AfterInteract(AfterInteractEventArgs eventArgs)
{
if (_teleporterType == TeleporterType.Directed)
{
TryDirectedTeleport(eventArgs.User, eventArgs.ClickLocation.ToMap(Owner.EntityManager));
}
if (_teleporterType == TeleporterType.Random)
{
TryRandomTeleport(eventArgs.User);
}
}
public void TryDirectedTeleport(IEntity user, MapCoordinates mapCoords)
{
// Checks
if ((user.Transform.WorldPosition - mapCoords.Position).LengthSquared > _range * _range)
{
return;
}
if (_state == ItemTeleporterState.On)
{
return;
}
if (_avoidCollidable)
{
foreach (var entity in _serverEntityManager.GetEntitiesIntersecting(mapCoords))
{
// Added this component to avoid stacking portals and causing shenanigans
// TODO: Doesn't do a great job of stopping stacking portals for directed
if (entity.HasComponent<ICollidableComponent>() || entity.HasComponent<ServerTeleporterComponent>())
{
return;
}
}
}
// Start / Continue
if (_state == ItemTeleporterState.Off)
{
SetState(ItemTeleporterState.Charging);
// Play charging sound here if you want
}
if (_state != ItemTeleporterState.Charging)
{
return;
}
Timer.Spawn(TimeSpan.FromSeconds(_chargeTime), () => Teleport(user, mapCoords.Position));
StartCooldown();
}
public void StartCooldown()
{
SetState(ItemTeleporterState.Cooldown);
Timer.Spawn(TimeSpan.FromSeconds(_chargeTime + _cooldown), () => SetState(ItemTeleporterState.Off));
if (_cooldownSound != null)
{
var soundPlayer = EntitySystem.Get<AudioSystem>();
soundPlayer.PlayFromEntity(_cooldownSound, Owner);
}
}
public override void Initialize()
{
base.Initialize();
_state = ItemTeleporterState.Off;
}
private bool EmptySpace(IEntity user, Vector2 target)
{
// TODO: Check the user's spot? Upside is no stacking TPs but downside is they can't unstuck themselves from walls.
foreach (var entity in _serverEntityManager.GetEntitiesIntersecting(user.Transform.MapID, target))
{
if (entity.HasComponent<ICollidableComponent>() || entity.HasComponent<ServerPortalComponent>())
{
return false;
}
}
return true;
}
private Vector2 RandomEmptySpot(IEntity user, int range)
{
Vector2 targetVector = user.Transform.Coordinates.Position;
// Definitely a better way to do this
foreach (var i in Enumerable.Range(0, 5))
{
var randomRange = _spreadRandom.Next(0, range);
var angle = Angle.FromDegrees(_spreadRandom.Next(0, 359));
targetVector = user.Transform.Coordinates.Position + angle.ToVec() * randomRange;
if (EmptySpace(user, targetVector))
{
return targetVector;
}
if (i == 19)
{
return targetVector;
}
}
return targetVector;
}
public void TryRandomTeleport(IEntity user)
{
// Checks
if (_state == ItemTeleporterState.On)
{
return;
}
Vector2 targetVector;
if (_avoidCollidable)
{
targetVector = RandomEmptySpot(user, _range);
}
else
{
var randomRange = _spreadRandom.Next(0, _range);
var angle = Angle.FromDegrees(_spreadRandom.Next(0, 359));
targetVector = user.Transform.Coordinates.Position + angle.ToVec() * randomRange;
}
// Start / Continue
if (_state == ItemTeleporterState.Off)
{
SetState(ItemTeleporterState.Charging);
}
if (_state != ItemTeleporterState.Charging)
{
return;
}
// Seemed easier to just start the cd timer at the same time
Timer.Spawn(TimeSpan.FromSeconds(_chargeTime), () => Teleport(user, targetVector));
StartCooldown();
}
public void Teleport(IEntity user, Vector2 vector)
{
// Messy maybe?
var targetGrid = user.Transform.Coordinates.WithPosition(vector);
var soundPlayer = EntitySystem.Get<AudioSystem>();
// If portals use those, otherwise just move em over
if (_portalAliveTime > 0.0f)
{
// Call Delete here as the teleporter should have control over portal longevity
// Departure portal
var departurePortal = _serverEntityManager.SpawnEntity("Portal", user.Transform.Coordinates);
departurePortal.TryGetComponent<ServerPortalComponent>(out var departureComponent);
// Arrival portal
var arrivalPortal = _serverEntityManager.SpawnEntity("Portal", targetGrid);
if (arrivalPortal.TryGetComponent<ServerPortalComponent>(out var arrivalComponent))
{
// Connect. TODO: If the OnUpdate in ServerPortalComponent is changed this may need to change as well.
arrivalComponent.TryConnectPortal(departurePortal);
}
}
else
{
// Departure
soundPlayer.PlayAtCoords(_departureSound, user.Transform.Coordinates);
// Arrival
user.Transform.AttachToGridOrMap();
user.Transform.WorldPosition = vector;
soundPlayer.PlayAtCoords(_arrivalSound, user.Transform.Coordinates);
}
}
}
}

10
Content.Server/GameObjects/Components/Movement/TeleportableComponent.cs
View File

@@ -1,10 +0,0 @@
using Robust.Shared.GameObjects;
namespace Content.Server.GameObjects.Components.Movement
{
[RegisterComponent]
public class TeleportableComponent : Component
{
public override string Name => "Teleportable";
}
}