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

Merge branch 'master' into replace-sounds-with-sound-specifier

Browse Source 
# Conflicts:
#	Content.Server/Actions/Actions/DisarmAction.cs
#	Content.Server/Actions/Actions/ScreamAction.cs
#	Content.Server/Arcade/Components/SpaceVillainArcadeComponent.cs
#	Content.Server/Damage/Components/DamageOnHighSpeedImpactComponent.cs
#	Content.Server/Explosion/Components/FlashExplosiveComponent.cs
#	Content.Server/Physics/Controllers/MoverController.cs
#	Content.Server/Portal/Components/PortalComponent.cs
#	Content.Server/Portal/Components/TeleporterComponent.cs
#	Content.Server/Projectiles/Components/ProjectileComponent.cs
#	Content.Server/Singularity/Components/EmitterComponent.cs
#	Content.Server/Sound/EmitSoundSystem.cs
#	Content.Server/Stunnable/Components/StunbatonComponent.cs
#	Content.Server/Tools/Components/MultitoolComponent.cs
#	Content.Server/Weapon/Ranged/Barrels/Components/ServerBatteryBarrelComponent.cs
#	Content.Shared/Gravity/GravityComponent.cs
#	Content.Shared/Light/Component/SharedExpendableLightComponent.cs
#	Content.Shared/Maps/ContentTileDefinition.cs
#	Content.Shared/Slippery/SlipperyComponent.cs
#	Content.Shared/Standing/StandingStateComponent.cs
#	Resources/Prototypes/Entities/Objects/Fun/bike_horn.yml
This commit is contained in:
Galactic Chimp
2021-07-25 14:12:00 +02:00
parent f3ef50c1d9 10af8efc0e
commit f531c65a0b
4171 changed files with 15603 additions and 14404 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
Content.Server/Singularity/Components/ContainmentFieldComponent.cs
View File

@@ -1,25 +1,11 @@
#nullable enable
using Robust.Shared.GameObjects;
using Robust.Shared.Physics.Collision;
using Robust.Shared.Physics.Dynamics;
namespace Content.Server.Singularity.Components
{
[RegisterComponent]
public class ContainmentFieldComponent : Component, IStartCollide
public class ContainmentFieldComponent : Component
{
public override string Name => "ContainmentField";
public ContainmentFieldConnection? Parent;
void IStartCollide.CollideWith(Fixture ourFixture, Fixture otherFixture, in Manifold manifold)
{
if (Parent == null)
{
Owner.QueueDelete();
return;
}
Parent.TryRepell(Owner, otherFixture.Body.Owner);
}
}
}

15
Content.Server/Singularity/Components/ContainmentFieldGeneratorComponent.cs
View File

@@ -1,23 +1,19 @@
#nullable enable
using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using Content.Shared.Physics;
using Content.Shared.Tag;
using Robust.Server.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.Log;
using Robust.Shared.Maths;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Broadphase;
using Robust.Shared.Physics.Collision;
using Robust.Shared.Physics.Dynamics;
using Robust.Shared.ViewVariables;
namespace Content.Server.Singularity.Components
{
[RegisterComponent]
public class ContainmentFieldGeneratorComponent : Component, IStartCollide
public class ContainmentFieldGeneratorComponent : Component
{
public override string Name => "ContainmentFieldGenerator";
@@ -101,7 +97,7 @@ namespace Content.Server.Singularity.Components
var dirVec = direction.ToVec();
var ray = new CollisionRay(Owner.Transform.WorldPosition, dirVec, (int) CollisionGroup.MobMask);
var rawRayCastResults = EntitySystem.Get<SharedBroadPhaseSystem>().IntersectRay(Owner.Transform.MapID, ray, 4.5f, Owner, false);
var rawRayCastResults = EntitySystem.Get<SharedBroadphaseSystem>().IntersectRay(Owner.Transform.MapID, ray, 4.5f, Owner, false);
var rayCastResults = rawRayCastResults as RayCastResults[] ?? rawRayCastResults.ToArray();
if(!rayCastResults.Any()) continue;
@@ -166,13 +162,6 @@ namespace Content.Server.Singularity.Components
}
}
void IStartCollide.CollideWith(Fixture ourFixture, Fixture otherFixture, in Manifold manifold)
{
if (otherFixture.Body.Owner.HasTag("EmitterBolt")) {
ReceivePower(6);
}
}
public void UpdateConnectionLights()
{
if (_pointLightComponent != null)

252
Content.Server/Singularity/Components/EmitterComponent.cs
View File

@@ -1,261 +1,47 @@
#nullable enable
using System;
using System.Threading;
using System.Threading.Tasks;
using Content.Server.Access.Components;
using Content.Server.Power.Components;
using Content.Server.Projectiles.Components;
using Content.Shared.Audio;
using Content.Shared.Interaction;
using Content.Shared.Notification;
using Content.Shared.Notification.Managers;
using Content.Shared.Singularity.Components;
using Content.Shared.Sound;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Log;
using Robust.Shared.Physics;
using Robust.Shared.Player;
using Robust.Shared.Random;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.Utility;
using Robust.Shared.ViewVariables;
using Timer = Robust.Shared.Timing.Timer;
#nullable enable
namespace Content.Server.Singularity.Components
{
[RegisterComponent]
[ComponentReference(typeof(IActivate))]
public class EmitterComponent : Component, IActivate, IInteractUsing
public class EmitterComponent : Component
{
[Dependency] private readonly IRobustRandom _robustRandom = default!;
[ComponentDependency] private readonly AppearanceComponent? _appearance = default;
[ComponentDependency] private readonly AccessReader? _accessReader = default;
[ComponentDependency] public readonly AppearanceComponent? Appearance = default;
[ComponentDependency] public readonly AccessReader? AccessReader = default;
[ComponentDependency] public readonly PowerConsumerComponent? PowerConsumer = default;
public override string Name => "Emitter";
private CancellationTokenSource? _timerCancel;
private PowerConsumerComponent _powerConsumer = default!;
public CancellationTokenSource? TimerCancel;
// whether the power switch is in "on"
[ViewVariables] public bool IsOn { get; private set; }
[ViewVariables] public bool IsOn;
// Whether the power switch is on AND the machine has enough power (so is actively firing)
[ViewVariables] private bool _isPowered;
[ViewVariables] private bool _isLocked;
[ViewVariables] public bool IsPowered;
[ViewVariables] public bool IsLocked;
// For the "emitter fired" sound
private const float Variation = 0.25f;
private const float Volume = 0.5f;
private const float Distance = 3f;
public const float Variation = 0.25f;
public const float Volume = 0.5f;
public const float Distance = 3f;
[ViewVariables(VVAccess.ReadWrite)] private int _fireShotCounter;
[ViewVariables] public int FireShotCounter;
[ViewVariables(VVAccess.ReadWrite)] [DataField("fireSound")] private SoundSpecifier _fireSound = new SoundPathSpecifier("/Audio/Weapons/emitter.ogg");
[ViewVariables(VVAccess.ReadWrite)] [DataField("boltType")] private string _boltType = "EmitterBolt";
[ViewVariables(VVAccess.ReadWrite)] [DataField("powerUseActive")] private int _powerUseActive = 500;
[ViewVariables(VVAccess.ReadWrite)] [DataField("fireBurstSize")] private int _fireBurstSize = 3;
[ViewVariables(VVAccess.ReadWrite)] [DataField("fireInterval")] private TimeSpan _fireInterval = TimeSpan.FromSeconds(2);
[ViewVariables(VVAccess.ReadWrite)] [DataField("fireBurstDelayMin")] private TimeSpan _fireBurstDelayMin = TimeSpan.FromSeconds(2);
[ViewVariables(VVAccess.ReadWrite)] [DataField("fireBurstDelayMax")] private TimeSpan _fireBurstDelayMax = TimeSpan.FromSeconds(10);
[ViewVariables] [DataField("fireSound")] public string FireSound = "/Audio/Weapons/emitter.ogg";
[ViewVariables] [DataField("boltType")] public string BoltType = "EmitterBolt";
[ViewVariables] [DataField("powerUseActive")] public int PowerUseActive = 500;
[ViewVariables] [DataField("fireBurstSize")] public int FireBurstSize = 3;
[ViewVariables] [DataField("fireInterval")] public TimeSpan FireInterval = TimeSpan.FromSeconds(2);
[ViewVariables] [DataField("fireBurstDelayMin")] public TimeSpan FireBurstDelayMin = TimeSpan.FromSeconds(2);
[ViewVariables] [DataField("fireBurstDelayMax")] public TimeSpan FireBurstDelayMax = TimeSpan.FromSeconds(10);
void IActivate.Activate(ActivateEventArgs eventArgs)
{
if (_isLocked)
{
Owner.PopupMessage(eventArgs.User, Loc.GetString("comp-emitter-access-locked", ("target", Owner)));
return;
}
if (Owner.TryGetComponent(out PhysicsComponent? phys) && phys.BodyType == BodyType.Static)
{
if (!IsOn)
{
SwitchOn();
Owner.PopupMessage(eventArgs.User, Loc.GetString("comp-emitter-turned-on", ("target", Owner)));
}
else
{
SwitchOff();
Owner.PopupMessage(eventArgs.User, Loc.GetString("comp-emitter-turned-off", ("target", Owner)));
}
}
else
{
Owner.PopupMessage(eventArgs.User, Loc.GetString("comp-emitter-not-anchored", ("target", Owner)));
}
}
Task<bool> IInteractUsing.InteractUsing(InteractUsingEventArgs eventArgs)
{
if (_accessReader == null || !eventArgs.Using.TryGetComponent(out IAccess? access))
{
return Task.FromResult(false);
}
if (_accessReader.IsAllowed(access))
{
_isLocked ^= true;
if (_isLocked)
{
Owner.PopupMessage(eventArgs.User, Loc.GetString("comp-emitter-lock", ("target", Owner)));
}
else
{
Owner.PopupMessage(eventArgs.User, Loc.GetString("comp-emitter-unlock", ("target", Owner)));
}
UpdateAppearance();
}
else
{
Owner.PopupMessage(eventArgs.User, Loc.GetString("comp-emitter-access-denied"));
}
return Task.FromResult(true);
}
public void SwitchOff()
{
IsOn = false;
_powerConsumer.DrawRate = 0;
PowerOff();
UpdateAppearance();
}
public void SwitchOn()
{
IsOn = true;
_powerConsumer.DrawRate = _powerUseActive;
// Do not directly PowerOn().
// OnReceivedPowerChanged will get fired due to DrawRate change which will turn it on.
UpdateAppearance();
}
public void PowerOff()
{
if (!_isPowered)
{
return;
}
_isPowered = false;
// Must be set while emitter powered.
DebugTools.AssertNotNull(_timerCancel);
_timerCancel!.Cancel();
UpdateAppearance();
}
public void PowerOn()
{
if (_isPowered)
{
return;
}
_isPowered = true;
_fireShotCounter = 0;
_timerCancel = new CancellationTokenSource();
Timer.Spawn(_fireBurstDelayMax, ShotTimerCallback, _timerCancel.Token);
UpdateAppearance();
}
private void ShotTimerCallback()
{
// Any power-off condition should result in the timer for this method being cancelled
// and thus not firing
DebugTools.Assert(_isPowered);
DebugTools.Assert(IsOn);
DebugTools.Assert(_powerConsumer.DrawRate <= _powerConsumer.ReceivedPower);
Fire();
TimeSpan delay;
if (_fireShotCounter < _fireBurstSize)
{
_fireShotCounter += 1;
delay = _fireInterval;
}
else
{
_fireShotCounter = 0;
var diff = _fireBurstDelayMax - _fireBurstDelayMin;
// TIL you can do TimeSpan * double.
delay = _fireBurstDelayMin + _robustRandom.NextFloat() * diff;
}
// Must be set while emitter powered.
DebugTools.AssertNotNull(_timerCancel);
Timer.Spawn(delay, ShotTimerCallback, _timerCancel!.Token);
}
private void Fire()
{
var projectile = Owner.EntityManager.SpawnEntity(_boltType, Owner.Transform.Coordinates);
if (!projectile.TryGetComponent<PhysicsComponent>(out var physicsComponent))
{
Logger.Error("Emitter tried firing a bolt, but it was spawned without a PhysicsComponent");
return;
}
physicsComponent.BodyStatus = BodyStatus.InAir;
if (!projectile.TryGetComponent<ProjectileComponent>(out var projectileComponent))
{
Logger.Error("Emitter tried firing a bolt, but it was spawned without a ProjectileComponent");
return;
}
projectileComponent.IgnoreEntity(Owner);
physicsComponent
.LinearVelocity = Owner.Transform.WorldRotation.ToWorldVec() * 20f;
projectile.Transform.WorldRotation = Owner.Transform.WorldRotation;
// TODO: Move to projectile's code.
Timer.Spawn(3000, () => projectile.Delete());
if(_fireSound.TryGetSound(out var fireSound))
SoundSystem.Play(Filter.Pvs(Owner), fireSound, Owner,
AudioHelpers.WithVariation(Variation).WithVolume(Volume).WithMaxDistance(Distance));
}
private void UpdateAppearance()
{
if (_appearance == null)
{
return;
}
EmitterVisualState state;
if (_isPowered)
{
state = EmitterVisualState.On;
}
else if (IsOn)
{
state = EmitterVisualState.Underpowered;
}
else
{
state = EmitterVisualState.Off;
}
_appearance.SetData(EmitterVisuals.VisualState, state);
_appearance.SetData(EmitterVisuals.Locked, _isLocked);
}
}
}

1
Content.Server/Singularity/Components/RadiationCollectorComponent.cs
View File

@@ -1,4 +1,3 @@
#nullable enable
using System;
using Content.Server.Power.Components;
using Content.Shared.Interaction;

43
Content.Server/Singularity/Components/ServerSingularityComponent.cs
View File

@@ -1,4 +1,3 @@
#nullable enable
using Content.Shared.Singularity;
using Content.Shared.Singularity.Components;
using Content.Shared.Sound;
@@ -17,7 +16,7 @@ namespace Content.Server.Singularity.Components
{
[RegisterComponent]
[ComponentReference(typeof(SharedSingularityComponent))]
public class ServerSingularityComponent : SharedSingularityComponent, IStartCollide
public class ServerSingularityComponent : SharedSingularityComponent
{
private SharedSingularitySystem _singularitySystem = default!;
@@ -102,46 +101,6 @@ namespace Content.Server.Singularity.Components
Energy -= EnergyDrain * seconds;
}
void IStartCollide.CollideWith(Fixture ourFixture, Fixture otherFixture, in Manifold manifold)
{
// If we're being deleted by another singularity, this call is probably for that singularity.
// Even if not, just don't bother.
if (BeingDeletedByAnotherSingularity)
return;
var otherEntity = otherFixture.Body.Owner;
if (otherEntity.TryGetComponent<IMapGridComponent>(out var mapGridComponent))
{
foreach (var tile in mapGridComponent.Grid.GetTilesIntersecting(ourFixture.Body.GetWorldAABB()))
{
mapGridComponent.Grid.SetTile(tile.GridIndices, Robust.Shared.Map.Tile.Empty);
Energy++;
}
return;
}
if (otherEntity.HasComponent<ContainmentFieldComponent>() ||
(otherEntity.TryGetComponent<ContainmentFieldGeneratorComponent>(out var component) && component.CanRepell(Owner)))
{
return;
}
if (otherEntity.IsInContainer())
return;
// Singularity priority management / etc.
if (otherEntity.TryGetComponent<ServerSingularityComponent>(out var otherSingulo))
otherSingulo.BeingDeletedByAnotherSingularity = true;
otherEntity.QueueDelete();
if (otherEntity.TryGetComponent<SinguloFoodComponent>(out var singuloFood))
Energy += singuloFood.Energy;
else
Energy++;
}
protected override void OnRemove()
{
_playingSound?.Stop();

45
Content.Server/Singularity/EntitySystems/ContainmentFieldGeneratorSystem.cs
View File

@@ -1,5 +1,9 @@
using Content.Server.Singularity.Components;
using Content.Server.ParticleAccelerator.Components;
using Content.Server.Singularity.Components;
using Content.Shared.Singularity.Components;
using Content.Shared.Tag;
using Robust.Shared.GameObjects;
using Robust.Shared.Physics.Dynamics;
namespace Content.Server.Singularity.EntitySystems
{
@@ -10,6 +14,45 @@ namespace Content.Server.Singularity.EntitySystems
base.Initialize();
SubscribeLocalEvent<ContainmentFieldGeneratorComponent, PhysicsBodyTypeChangedEvent>(BodyTypeChanged);
SubscribeLocalEvent<ContainmentFieldComponent, StartCollideEvent>(HandleFieldCollide);
SubscribeLocalEvent<ContainmentFieldGeneratorComponent, StartCollideEvent>(HandleGeneratorCollide);
SubscribeLocalEvent<ParticleProjectileComponent, StartCollideEvent>(HandleParticleCollide);
}
private void HandleParticleCollide(EntityUid uid, ParticleProjectileComponent component, StartCollideEvent args)
{
if (args.OtherFixture.Body.Owner.TryGetComponent<SingularityGeneratorComponent>(out var singularityGeneratorComponent))
{
singularityGeneratorComponent.Power += component.State switch
{
ParticleAcceleratorPowerState.Standby => 0,
ParticleAcceleratorPowerState.Level0 => 1,
ParticleAcceleratorPowerState.Level1 => 2,
ParticleAcceleratorPowerState.Level2 => 4,
ParticleAcceleratorPowerState.Level3 => 8,
_ => 0
};
EntityManager.QueueDeleteEntity(uid);
}
}
private void HandleGeneratorCollide(EntityUid uid, ContainmentFieldGeneratorComponent component, StartCollideEvent args)
{
if (args.OtherFixture.Body.Owner.HasTag("EmitterBolt")) {
component.ReceivePower(6);
}
}
private void HandleFieldCollide(EntityUid uid, ContainmentFieldComponent component, StartCollideEvent args)
{
if (component.Parent == null)
{
EntityManager.QueueDeleteEntity(uid);
return;
}
component.Parent.TryRepell(component.Owner, args.OtherFixture.Body.Owner);
}
private static void BodyTypeChanged(

224
Content.Server/Singularity/EntitySystems/EmitterSystem.cs
View File

@@ -1,21 +1,102 @@
using Content.Server.Power.EntitySystems;
using System;
using System.Threading;
using Content.Server.Access.Components;
using Content.Server.Power.EntitySystems;
using Content.Server.Projectiles.Components;
using Content.Server.Singularity.Components;
using Content.Shared.Audio;
using Content.Shared.Interaction;
using Content.Shared.Notification.Managers;
using Content.Shared.Singularity.Components;
using JetBrains.Annotations;
using Robust.Shared.Audio;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Log;
using Robust.Shared.Physics;
using Robust.Shared.Player;
using Robust.Shared.Random;
using Robust.Shared.Utility;
using Timer = Robust.Shared.Timing.Timer;
namespace Content.Server.Singularity.EntitySystems
{
[UsedImplicitly]
public class EmitterSystem : EntitySystem
{
[Dependency] private readonly IRobustRandom _random = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<EmitterComponent, PowerConsumerReceivedChanged>(ReceivedChanged);
SubscribeLocalEvent<EmitterComponent, InteractHandEvent>(OnInteractHand);
SubscribeLocalEvent<EmitterComponent, InteractUsingEvent>(OnInteractUsing);
}
private static void ReceivedChanged(
private void OnInteractUsing(EntityUid uid, EmitterComponent component, InteractUsingEvent args)
{
if(args.Handled) return;
if (component.AccessReader == null || !args.Used.TryGetComponent(out IAccess? access))
{
return;
}
if (component.AccessReader.IsAllowed(access))
{
component.IsLocked ^= true;
if (component.IsLocked)
{
component.Owner.PopupMessage(args.User, Loc.GetString("comp-emitter-lock", ("target", component.Owner)));
}
else
{
component.Owner.PopupMessage(args.User, Loc.GetString("comp-emitter-unlock", ("target", component.Owner)));
}
UpdateAppearance(component);
}
else
{
component.Owner.PopupMessage(args.User, Loc.GetString("comp-emitter-access-denied"));
}
args.Handled = true;
}
private void OnInteractHand(EntityUid uid, EmitterComponent component, InteractHandEvent args)
{
args.Handled = true;
if (component.IsLocked)
{
component.Owner.PopupMessage(args.User, Loc.GetString("comp-emitter-access-locked", ("target", component.Owner)));
return;
}
if (component.Owner.TryGetComponent(out PhysicsComponent? phys) && phys.BodyType == BodyType.Static)
{
if (!component.IsOn)
{
SwitchOn(component);
component.Owner.PopupMessage(args.User, Loc.GetString("comp-emitter-turned-on", ("target", component.Owner)));
}
else
{
SwitchOff(component);
component.Owner.PopupMessage(args.User, Loc.GetString("comp-emitter-turned-off", ("target", component.Owner)));
}
}
else
{
component.Owner.PopupMessage(args.User, Loc.GetString("comp-emitter-not-anchored", ("target", component.Owner)));
}
}
private void ReceivedChanged(
EntityUid uid,
EmitterComponent component,
PowerConsumerReceivedChanged args)
@@ -27,12 +108,147 @@ namespace Content.Server.Singularity.EntitySystems
if (args.ReceivedPower < args.DrawRate)
{
component.PowerOff();
PowerOff(component);
}
else
{
component.PowerOn();
PowerOn(component);
}
}
public void SwitchOff(EmitterComponent component)
{
component.IsOn = false;
if (component.PowerConsumer != null) component.PowerConsumer.DrawRate = 0;
PowerOff(component);
UpdateAppearance(component);
}
public void SwitchOn(EmitterComponent component)
{
component.IsOn = true;
if (component.PowerConsumer != null) component.PowerConsumer.DrawRate = component.PowerUseActive;
// Do not directly PowerOn().
// OnReceivedPowerChanged will get fired due to DrawRate change which will turn it on.
UpdateAppearance(component);
}
public void PowerOff(EmitterComponent component)
{
if (!component.IsPowered)
{
return;
}
component.IsPowered = false;
// Must be set while emitter powered.
DebugTools.AssertNotNull(component.TimerCancel);
component.TimerCancel?.Cancel();
UpdateAppearance(component);
}
public void PowerOn(EmitterComponent component)
{
if (component.IsPowered)
{
return;
}
component.IsPowered = true;
component.FireShotCounter = 0;
component.TimerCancel = new CancellationTokenSource();
Timer.Spawn(component.FireBurstDelayMax, () => ShotTimerCallback(component), component.TimerCancel.Token);
UpdateAppearance(component);
}
private void ShotTimerCallback(EmitterComponent component)
{
// Any power-off condition should result in the timer for this method being cancelled
// and thus not firing
DebugTools.Assert(component.IsPowered);
DebugTools.Assert(component.IsOn);
DebugTools.Assert(component.PowerConsumer != null && (component.PowerConsumer.DrawRate <= component.PowerConsumer.ReceivedPower));
Fire(component);
TimeSpan delay;
if (component.FireShotCounter < component.FireBurstSize)
{
component.FireShotCounter += 1;
delay = component.FireInterval;
}
else
{
component.FireShotCounter = 0;
var diff = component.FireBurstDelayMax - component.FireBurstDelayMin;
// TIL you can do TimeSpan * double.
delay = component.FireBurstDelayMin + _random.NextFloat() * diff;
}
// Must be set while emitter powered.
DebugTools.AssertNotNull(component.TimerCancel);
Timer.Spawn(delay, () => ShotTimerCallback(component), component.TimerCancel!.Token);
}
private void Fire(EmitterComponent component)
{
var projectile = component.Owner.EntityManager.SpawnEntity(component.BoltType, component.Owner.Transform.Coordinates);
if (!projectile.TryGetComponent<PhysicsComponent>(out var physicsComponent))
{
Logger.Error("Emitter tried firing a bolt, but it was spawned without a PhysicsComponent");
return;
}
physicsComponent.BodyStatus = BodyStatus.InAir;
if (!projectile.TryGetComponent<ProjectileComponent>(out var projectileComponent))
{
Logger.Error("Emitter tried firing a bolt, but it was spawned without a ProjectileComponent");
return;
}
projectileComponent.IgnoreEntity(component.Owner);
physicsComponent
.LinearVelocity = component.Owner.Transform.WorldRotation.ToWorldVec() * 20f;
projectile.Transform.WorldRotation = component.Owner.Transform.WorldRotation;
// TODO: Move to projectile's code.
Timer.Spawn(3000, () => projectile.Delete());
SoundSystem.Play(Filter.Pvs(component.Owner), component.FireSound, component.Owner,
AudioHelpers.WithVariation(EmitterComponent.Variation).WithVolume(EmitterComponent.Volume).WithMaxDistance(EmitterComponent.Distance));
}
private void UpdateAppearance(EmitterComponent component)
{
if (component.Appearance == null)
{
return;
}
EmitterVisualState state;
if (component.IsPowered)
{
state = EmitterVisualState.On;
}
else if (component.IsOn)
{
state = EmitterVisualState.Underpowered;
}
else
{
state = EmitterVisualState.Off;
}
component.Appearance.SetData(EmitterVisuals.VisualState, state);
component.Appearance.SetData(EmitterVisuals.Locked, component.IsLocked);
}
}
}

49
Content.Server/Singularity/EntitySystems/SingularitySystem.cs
View File

@@ -1,6 +1,9 @@
using Content.Server.Singularity.Components;
using Content.Shared.Singularity;
using JetBrains.Annotations;
using Robust.Shared.Containers;
using Robust.Shared.GameObjects;
using Robust.Shared.Physics.Dynamics;
namespace Content.Server.Singularity.EntitySystems
{
@@ -10,6 +13,52 @@ namespace Content.Server.Singularity.EntitySystems
private float _updateInterval = 1.0f;
private float _accumulator;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<ServerSingularityComponent, StartCollideEvent>(HandleCollide);
}
private void HandleCollide(EntityUid uid, ServerSingularityComponent component, StartCollideEvent args)
{
// If we're being deleted by another singularity, this call is probably for that singularity.
// Even if not, just don't bother.
if (component.BeingDeletedByAnotherSingularity)
return;
var otherEntity = args.OtherFixture.Body.Owner;
if (otherEntity.TryGetComponent<IMapGridComponent>(out var mapGridComponent))
{
foreach (var tile in mapGridComponent.Grid.GetTilesIntersecting(args.OurFixture.Body.GetWorldAABB()))
{
mapGridComponent.Grid.SetTile(tile.GridIndices, Robust.Shared.Map.Tile.Empty);
component.Energy++;
}
return;
}
if (otherEntity.HasComponent<ContainmentFieldComponent>() ||
(otherEntity.TryGetComponent<ContainmentFieldGeneratorComponent>(out var containmentField) && containmentField.CanRepell(component.Owner)))
{
return;
}
if (otherEntity.IsInContainer())
return;
// Singularity priority management / etc.
if (otherEntity.TryGetComponent<ServerSingularityComponent>(out var otherSingulo))
otherSingulo.BeingDeletedByAnotherSingularity = true;
otherEntity.QueueDelete();
if (otherEntity.TryGetComponent<SinguloFoodComponent>(out var singuloFood))
component.Energy += singuloFood.Energy;
else
component.Energy++;
}
public override void Update(float frameTime)
{
base.Update(frameTime);

4
Content.Server/Singularity/StartSingularityEngineCommand.cs
View File

@@ -1,7 +1,7 @@
#nullable enable
using Content.Server.Administration;
using Content.Server.ParticleAccelerator.Components;
using Content.Server.Singularity.Components;
using Content.Server.Singularity.EntitySystems;
using Content.Shared.Administration;
using Content.Shared.Singularity.Components;
using Robust.Shared.Console;
@@ -28,7 +28,7 @@ namespace Content.Server.Singularity
var entityManager = IoCManager.Resolve<IEntityManager>();
foreach (var comp in entityManager.ComponentManager.EntityQuery<EmitterComponent>())
{
comp.SwitchOn();
EntitySystem.Get<EmitterSystem>().SwitchOn(comp);
}
foreach (var comp in entityManager.ComponentManager.EntityQuery<RadiationCollectorComponent>())
{