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

Refactor Flammable to be ECS. (#4671)

Browse Source 
- Refactor IHotItem into IsHotEvent.
- Refactor IFireAct into TileFireEvent.
This commit is contained in:
Vera Aguilera Puerto
2021-09-22 11:05:33 +02:00
committed by GitHub
parent 9bde39c533
commit 6cea9cb973
21 changed files with 348 additions and 268 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
Content.Server/Atmos/Components/AtmosExposedComponent.cs
View File

@@ -5,12 +5,12 @@ using Robust.Shared.ViewVariables;
namespace Content.Server.Atmos.Components
{
// TODO: Kill this. With fire.
/// <summary>
/// Represents that entity can be exposed to Atmos
/// </summary>
[RegisterComponent]
public class AtmosExposedComponent
: Component
public class AtmosExposedComponent : Component
{
public override string Name => "AtmosExposed";
@@ -20,9 +20,6 @@ namespace Content.Server.Atmos.Components
[ViewVariables]
[ComponentDependency] private readonly BarotraumaComponent? _barotraumaComponent = null;
[ViewVariables]
[ComponentDependency] private readonly FlammableComponent? _flammableComponent = null;
public void Update(GasMixture air, float frameDelta, AtmosphereSystem atmosphereSystem)
{
if (_temperatureComponent != null)
@@ -35,8 +32,6 @@ namespace Content.Server.Atmos.Components
}
_barotraumaComponent?.Update(air.Pressure);
_flammableComponent?.Update(air);
}
}
}

157
Content.Server/Atmos/Components/FlammableComponent.cs
View File

@@ -1,32 +1,22 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Content.Server.Alert;
using Content.Server.Atmos.EntitySystems;
using Content.Server.Stunnable.Components;
using Content.Server.Temperature.Components;
using Content.Shared.ActionBlocker;
using Content.Shared.Alert;
using Content.Shared.Atmos;
using Content.Shared.Atmos.Components;
using Content.Shared.Damage;
using Content.Shared.Interaction;
using Content.Shared.Notification.Managers;
using Content.Shared.Temperature;
using Robust.Server.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.Localization;
using Robust.Shared.Physics;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.ViewVariables;
namespace Content.Server.Atmos.Components
{
[RegisterComponent]
public class FlammableComponent : SharedFlammableComponent, IFireAct, IInteractUsing
public class FlammableComponent : Component
{
private bool _resisting = false;
private readonly List<EntityUid> _collided = new();
public override string Name => "Flammable";
[ViewVariables]
public bool Resisting = false;
[ViewVariables]
public readonly List<EntityUid> Collided = new();
[ViewVariables(VVAccess.ReadWrite)]
public bool OnFire { get; set; }
@@ -45,136 +35,5 @@ namespace Content.Server.Atmos.Components
[DataField("damage", required: true)]
[ViewVariables(VVAccess.ReadWrite)]
public DamageSpecifier Damage = default!;
public void Extinguish()
{
if (!OnFire) return;
OnFire = false;
FireStacks = 0;
_collided.Clear();
UpdateAppearance();
}
public void AdjustFireStacks(float relativeFireStacks)
{
FireStacks = MathF.Min(MathF.Max(-10f, FireStacks + relativeFireStacks), 20f);
if (OnFire && FireStacks <= 0)
Extinguish();
UpdateAppearance();
}
public void Update(GasMixture air)
{
// Slowly dry ourselves off if wet.
if (FireStacks < 0)
{
FireStacks = MathF.Min(0, FireStacks + 1);
}
Owner.TryGetComponent(out ServerAlertsComponent? status);
if (!OnFire)
{
status?.ClearAlert(AlertType.Fire);
return;
}
status?.ShowAlert(AlertType.Fire);
if (FireStacks > 0)
{
if (Owner.TryGetComponent(out TemperatureComponent? temp))
{
temp.ReceiveHeat(200 * FireStacks);
}
// TODO ATMOS Fire resistance from armor
var damageScale = Math.Min((int) (FireStacks * 2.5f), 10);
EntitySystem.Get<DamageableSystem>().TryChangeDamage(Owner.Uid, Damage * damageScale);
AdjustFireStacks(-0.1f * (_resisting ? 10f : 1f));
}
else
{
Extinguish();
return;
}
// If we're in an oxygenless environment, put the fire out.
if (air.GetMoles(Gas.Oxygen) < 1f)
{
Extinguish();
return;
}
EntitySystem.Get<AtmosphereSystem>().HotspotExpose(Owner.Transform.Coordinates, 700f, 50f, true);
var physics = Owner.GetComponent<IPhysBody>();
foreach (var uid in _collided.ToArray())
{
if (!uid.IsValid() || !Owner.EntityManager.EntityExists(uid))
{
_collided.Remove(uid);
continue;
}
var entity = Owner.EntityManager.GetEntity(uid);
var otherPhysics = entity.GetComponent<IPhysBody>();
if (!physics.GetWorldAABB().Intersects(otherPhysics.GetWorldAABB()))
{
_collided.Remove(uid);
}
}
}
public void UpdateAppearance()
{
if (Owner.Deleted || !Owner.TryGetComponent(out AppearanceComponent? appearanceComponent)) return;
appearanceComponent.SetData(FireVisuals.OnFire, OnFire);
appearanceComponent.SetData(FireVisuals.FireStacks, FireStacks);
}
public void FireAct(float temperature, float volume)
{
AdjustFireStacks(3);
EntitySystem.Get<FlammableSystem>().Ignite(this);
}
// This needs some improvements...
public void Resist()
{
if (!OnFire || !EntitySystem.Get<ActionBlockerSystem>().CanInteract(Owner) || _resisting || !Owner.TryGetComponent(out StunnableComponent? stunnable)) return;
_resisting = true;
Owner.PopupMessage(Loc.GetString("flammable-component-resist-message"));
stunnable.Paralyze(2f);
Owner.SpawnTimer(2000, () =>
{
_resisting = false;
FireStacks -= 3f;
UpdateAppearance();
});
}
public async Task<bool> InteractUsing(InteractUsingEventArgs eventArgs)
{
foreach (var hotItem in eventArgs.Using.GetAllComponents<IHotItem>())
{
if (hotItem.IsCurrentlyHot())
{
EntitySystem.Get<FlammableSystem>().Ignite(this);
return true;
}
}
return false;
}
}
}

15
Content.Server/Atmos/EntitySystems/AtmosphereSystem.Hotspot.cs
View File

@@ -1,13 +1,15 @@
using Content.Server.Atmos.Components;
using Content.Server.Atmos.Reactions;
using Content.Server.Coordinates.Helpers;
using Content.Shared.Atmos;
using Content.Shared.Maps;
using Robust.Server.GameObjects;
using Robust.Shared.IoC;
namespace Content.Server.Atmos.EntitySystems
{
public partial class AtmosphereSystem
{
[Dependency] private readonly GridTileLookupSystem _gridtileLookupSystem = default!;
private void ProcessHotspot(GridAtmosphereComponent gridAtmosphere, TileAtmosphere tile)
{
if (!tile.Hotspot.Valid)
@@ -137,14 +139,11 @@ namespace Content.Server.Atmos.EntitySystems
Merge(tile.Air, affected);
}
var tileRef = tile.GridIndices.GetTileRef(tile.GridIndex, _mapManager);
var fireEvent = new TileFireEvent(tile.Hotspot.Temperature, tile.Hotspot.Volume);
foreach (var entity in tileRef.GetEntitiesInTileFast())
foreach (var entity in _gridtileLookupSystem.GetEntitiesIntersecting(tile.GridIndex, tile.GridIndices))
{
foreach (var fireAct in entity.GetAllComponents<IFireAct>())
{
fireAct.FireAct(tile.Hotspot.Temperature, tile.Hotspot.Volume);
}
RaiseLocalEvent(entity.Uid, fireEvent, false);
}
}
}

229
Content.Server/Atmos/EntitySystems/FlammableSystem.cs
View File

@@ -1,56 +1,251 @@
using System;
using Content.Server.Alert;
using Content.Server.Atmos.Components;
using Content.Server.Stunnable.Components;
using Content.Server.Temperature.Components;
using Content.Shared.ActionBlocker;
using Content.Shared.Alert;
using Content.Shared.Atmos;
using Content.Shared.Damage;
using Content.Shared.Interaction;
using Content.Shared.Notification.Managers;
using Content.Shared.Temperature;
using Robust.Server.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Dynamics;
namespace Content.Server.Atmos.EntitySystems
{
internal sealed class FlammableSystem : EntitySystem
{
[Dependency] private readonly ActionBlockerSystem _actionBlockerSystem = default!;
[Dependency] private readonly DamageableSystem _damageableSystem = default!;
[Dependency] private readonly AtmosphereSystem _atmosphereSystem = default!;
private const float MinimumFireStacks = -10f;
private const float MaximumFireStacks = 20f;
private const float UpdateTime = 1f;
private float _timer = 0f;
// TODO: Port the rest of Flammable.
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<FlammableComponent, StartCollideEvent>(HandleCollide);
SubscribeLocalEvent<FlammableComponent, InteractUsingEvent>(OnInteractUsingEvent);
SubscribeLocalEvent<FlammableComponent, StartCollideEvent>(OnCollideEvent);
SubscribeLocalEvent<FlammableComponent, IsHotEvent>(OnIsHotEvent);
SubscribeLocalEvent<FlammableComponent, TileFireEvent>(OnTileFireEvent);
}
private void HandleCollide(EntityUid uid, FlammableComponent component, StartCollideEvent args)
private void OnInteractUsingEvent(EntityUid uid, FlammableComponent flammable, InteractUsingEvent args)
{
if (!args.OtherFixture.Body.Owner.TryGetComponent(out FlammableComponent? otherFlammable))
if (args.Handled)
return;
if (!component.FireSpread || !otherFlammable.FireSpread)
var isHotEvent = new IsHotEvent();
RaiseLocalEvent(args.Used.Uid, isHotEvent, false);
if (!isHotEvent.IsHot)
return;
if (component.OnFire)
Ignite(uid, flammable);
args.Handled = true;
}
private void OnCollideEvent(EntityUid uid, FlammableComponent flammable, StartCollideEvent args)
{
var otherUid = args.OtherFixture.Body.Owner.Uid;
if (!ComponentManager.TryGetComponent(otherUid, out FlammableComponent? otherFlammable))
return;
if (!flammable.FireSpread || !otherFlammable.FireSpread)
return;
if (flammable.OnFire)
{
if (otherFlammable.OnFire)
{
var fireSplit = (component.FireStacks + otherFlammable.FireStacks) / 2;
component.FireStacks = fireSplit;
var fireSplit = (flammable.FireStacks + otherFlammable.FireStacks) / 2;
flammable.FireStacks = fireSplit;
otherFlammable.FireStacks = fireSplit;
}
else
{
component.FireStacks /= 2;
otherFlammable.FireStacks += component.FireStacks;
Ignite(otherFlammable);
flammable.FireStacks /= 2;
otherFlammable.FireStacks += flammable.FireStacks;
Ignite(otherUid, otherFlammable);
}
} else if (otherFlammable.OnFire)
{
otherFlammable.FireStacks /= 2;
component.FireStacks += otherFlammable.FireStacks;
Ignite(component);
flammable.FireStacks += otherFlammable.FireStacks;
Ignite(uid, flammable);
}
}
internal void Ignite(FlammableComponent component)
private void OnIsHotEvent(EntityUid uid, FlammableComponent flammable, IsHotEvent args)
{
if (component.FireStacks > 0 && !component.OnFire)
args.IsHot = flammable.OnFire;
}
private void OnTileFireEvent(EntityUid uid, FlammableComponent flammable, TileFireEvent args)
{
AdjustFireStacks(uid, 3, flammable);
Ignite(uid, flammable);
}
public void UpdateAppearance(EntityUid uid, FlammableComponent? flammable = null, AppearanceComponent? appearance = null)
{
if (!Resolve(uid, ref flammable, ref appearance))
return;
appearance.SetData(FireVisuals.OnFire, flammable.OnFire);
appearance.SetData(FireVisuals.FireStacks, flammable.FireStacks);
}
public void AdjustFireStacks(EntityUid uid, float relativeFireStacks, FlammableComponent? flammable = null)
{
if (!Resolve(uid, ref flammable))
return;
flammable.FireStacks = MathF.Min(MathF.Max(MinimumFireStacks, flammable.FireStacks + relativeFireStacks), MaximumFireStacks);
if (flammable.OnFire && flammable.FireStacks <= 0)
Extinguish(uid, flammable);
UpdateAppearance(uid, flammable);
}
public void Extinguish(EntityUid uid, FlammableComponent? flammable = null)
{
if (!Resolve(uid, ref flammable))
return;
if (!flammable.OnFire)
return;
flammable.OnFire = false;
flammable.FireStacks = 0;
flammable.Collided.Clear();
UpdateAppearance(uid, flammable);
}
public void Ignite(EntityUid uid, FlammableComponent? flammable = null)
{
if (!Resolve(uid, ref flammable))
return;
if (flammable.FireStacks > 0 && !flammable.OnFire)
{
component.OnFire = true;
flammable.OnFire = true;
}
component.UpdateAppearance();
UpdateAppearance(uid, flammable);
}
public void Resist(EntityUid uid, FlammableComponent? flammable = null, StunnableComponent? stunnable = null)
{
if (!Resolve(uid, ref flammable, ref stunnable))
return;
if (!flammable.OnFire || !_actionBlockerSystem.CanInteract(flammable.Owner) || flammable.Resisting)
return;
flammable.Resisting = true;
flammable.Owner.PopupMessage(Loc.GetString("flammable-component-resist-message"));
stunnable.Paralyze(2f);
flammable.Owner.SpawnTimer(2000, () =>
{
flammable.Resisting = false;
flammable.FireStacks -= 3f;
UpdateAppearance(uid, flammable);
});
}
public override void Update(float frameTime)
{
_timer += frameTime;
if (_timer < UpdateTime)
return;
_timer -= UpdateTime;
// TODO: This needs cleanup to take off the crust from TemperatureComponent and shit.
foreach (var (flammable, physics, transform) in ComponentManager.EntityQuery<FlammableComponent, PhysicsComponent, ITransformComponent>())
{
var uid = flammable.Owner.Uid;
// Slowly dry ourselves off if wet.
if (flammable.FireStacks < 0)
{
flammable.FireStacks = MathF.Min(0, flammable.FireStacks + 1);
}
flammable.Owner.TryGetComponent(out ServerAlertsComponent? status);
if (!flammable.OnFire)
{
status?.ClearAlert(AlertType.Fire);
return;
}
status?.ShowAlert(AlertType.Fire);
if (flammable.FireStacks > 0)
{
if (flammable.Owner.TryGetComponent(out TemperatureComponent? temp))
{
temp.ReceiveHeat(200 * flammable.FireStacks);
}
// TODO ATMOS Fire resistance from armor
var damageScale = Math.Min((int) (flammable.FireStacks * 2.5f), 10);
_damageableSystem.TryChangeDamage(flammable.Owner.Uid, flammable.Damage * damageScale);
AdjustFireStacks(uid, -0.1f * (flammable.Resisting ? 10f : 1f), flammable);
}
else
{
Extinguish(uid, flammable);
return;
}
var air = _atmosphereSystem.GetTileMixture(transform.Coordinates);
// If we're in an oxygenless environment, put the fire out.
if (air == null || air.GetMoles(Gas.Oxygen) < 1f)
{
Extinguish(uid, flammable);
return;
}
_atmosphereSystem.HotspotExpose(transform.Coordinates, 700f, 50f, true);
foreach (var otherUid in flammable.Collided.ToArray())
{
if (!otherUid.IsValid() || !EntityManager.EntityExists(otherUid))
{
flammable.Collided.Remove(otherUid);
continue;
}
var otherPhysics = ComponentManager.GetComponent<IPhysBody>(uid);
// TODO: Sloth, please save our souls!
if (!physics.GetWorldAABB().Intersects(otherPhysics.GetWorldAABB()))
{
flammable.Collided.Remove(otherUid);
}
}
}
}
}
}

7
Content.Server/Atmos/FireEvent.cs
View File

@@ -1,7 +0,0 @@
namespace Content.Server.Atmos
{
public interface IFireAct
{
void FireAct(float temperature, float volume);
}
}

19
Content.Server/Atmos/TileFireEvent.cs Normal file
View File

@@ -0,0 +1,19 @@
using Robust.Shared.GameObjects;
namespace Content.Server.Atmos
{
/// <summary>
/// Event raised directed to an entity when it is standing on a tile that's on fire.
/// </summary>
public class TileFireEvent : EntityEventArgs
{
public float Temperature { get; }
public float Volume { get; }
public TileFireEvent(float temperature, float volume)
{
Temperature = temperature;
Volume = volume;
}
}
}