namespace Content.Client.Explosion.EntitySystems;
-public sealed class ExplosionSystem : SharedExplosionSystem
-{
-
-}
+public sealed class ExplosionSystem : SharedExplosionSystem;
-using Content.Server.Explosion.Components;
+using Content.Shared.Explosion.Components;
using JetBrains.Annotations;
namespace Content.Server.Destructible.Thresholds.Behaviors
using Content.Shared.Explosion.EntitySystems;
using Content.Shared.FixedPoint;
using Robust.Shared.Map.Components;
+
namespace Content.Server.Explosion.EntitySystems;
-public sealed partial class ExplosionSystem : SharedExplosionSystem
+public sealed partial class ExplosionSystem
{
[Dependency] private readonly DestructibleSystem _destructibleSystem = default!;
using Content.Shared.CCVar;
-using Content.Shared.Explosion.EntitySystems;
+
namespace Content.Server.Explosion.EntitySystems;
-public sealed partial class ExplosionSystem : SharedExplosionSystem
+public sealed partial class ExplosionSystem
{
public int MaxIterations { get; private set; }
public int MaxArea { get; private set; }
// A good portion of it is focused around keeping track of what tile-indices on a grid correspond to tiles that border
// space. AFAIK no other system currently needs to track these "edge-tiles". If they do, this should probably be a
// property of the grid itself?
-public sealed partial class ExplosionSystem : SharedExplosionSystem
+public sealed partial class ExplosionSystem
{
/// <summary>
/// Set of tiles of each grid that are directly adjacent to space, along with the directions that face space.
using Robust.Shared.Timing;
using Robust.Shared.Utility;
using TimedDespawnComponent = Robust.Shared.Spawners.TimedDespawnComponent;
+
namespace Content.Server.Explosion.EntitySystems;
-public sealed partial class ExplosionSystem : SharedExplosionSystem
+public sealed partial class ExplosionSystem
{
[Dependency] private readonly FlammableSystem _flammableSystem = default!;
// get the entities on a tile. Note that we cannot process them directly, or we get
// enumerator-changed-while-enumerating errors.
List<(EntityUid, TransformComponent)> list = new();
- var state = (list, processed, _transformQuery);
+ var state = (list, processed, EntityManager.TransformQuery);
// get entities:
lookup.DynamicTree.QueryAabb(ref state, GridQueryCallback, gridBox, true);
var gridBox = Box2.FromDimensions(tile * DefaultTileSize, new Vector2(DefaultTileSize, DefaultTileSize));
var worldBox = spaceMatrix.TransformBox(gridBox);
var list = new List<(EntityUid, TransformComponent)>();
- var state = (list, processed, invSpaceMatrix, lookup.Owner, _transformQuery, gridBox, _transformSystem);
+ var state = (list, processed, invSpaceMatrix, lookup.Owner, EntityManager.TransformQuery, gridBox, _transformSystem);
// get entities:
lookup.DynamicTree.QueryAabb(ref state, SpaceQueryCallback, worldBox, true);
using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
using Robust.Shared.Timing;
-using Content.Shared.Explosion.EntitySystems;
+
namespace Content.Server.Explosion.EntitySystems;
// This partial part of the explosion system has all of the functions used to create the actual explosion map.
// I.e, to get the sets of tiles & intensity values that describe an explosion.
-public sealed partial class ExplosionSystem : SharedExplosionSystem
+public sealed partial class ExplosionSystem
{
/// <summary>
/// This is the main explosion generating function.
using Robust.Server.GameObjects;
using Robust.Shared.GameStates;
using Robust.Shared.Map;
+
namespace Content.Server.Explosion.EntitySystems;
// This part of the system handled send visual / overlay data to clients.
-public sealed partial class ExplosionSystem : SharedExplosionSystem
+public sealed partial class ExplosionSystem
{
public void InitVisuals()
{
using Content.Shared.Damage;
using Content.Shared.Database;
using Content.Shared.Explosion;
+using Content.Shared.Explosion.Components;
+using Content.Shared.Explosion.EntitySystems;
using Content.Shared.GameTicking;
using Content.Shared.Inventory;
using Content.Shared.Projectiles;
[Dependency] private readonly SharedTransformSystem _transformSystem = default!;
[Dependency] private readonly SharedMapSystem _map = default!;
- private EntityQuery<TransformComponent> _transformQuery;
private EntityQuery<FlammableComponent> _flammableQuery;
private EntityQuery<PhysicsComponent> _physicsQuery;
private EntityQuery<ProjectileComponent> _projectileQuery;
InitAirtightMap();
InitVisuals();
- _transformQuery = GetEntityQuery<TransformComponent>();
_flammableQuery = GetEntityQuery<FlammableComponent>();
_physicsQuery = GetEntityQuery<PhysicsComponent>();
_projectileQuery = GetEntityQuery<ProjectileComponent>();
args.DamageCoefficient *= modifier;
}
- /// <summary>
- /// Given an entity with an explosive component, spawn the appropriate explosion.
- /// </summary>
- /// <remarks>
- /// Also accepts radius or intensity arguments. This is useful for explosives where the intensity is not
- /// specified in the yaml / by the component, but determined dynamically (e.g., by the quantity of a
- /// solution in a reaction).
- /// </remarks>
- public void TriggerExplosive(EntityUid uid, ExplosiveComponent? explosive = null, bool delete = true, float? totalIntensity = null, float? radius = null, EntityUid? user = null)
+ /// <inheritdoc/>
+ public override void TriggerExplosive(EntityUid uid, ExplosiveComponent? explosive = null, bool delete = true, float? totalIntensity = null, float? radius = null, EntityUid? user = null)
{
// log missing: false, because some entities (e.g. liquid tanks) attempt to trigger explosions when damaged,
// but may not actually be explosive.
-using Content.Server.Explosion.EntitySystems;
-using Content.Shared.Explosion;
-using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
+using Content.Shared.Explosion.EntitySystems;
+using Robust.Shared.Prototypes;
-namespace Content.Server.Explosion.Components;
+namespace Content.Shared.Explosion.Components;
/// <summary>
/// Specifies an explosion that can be spawned by this entity. The explosion itself is spawned via <see
/// The total intensity may be overridden by whatever system actually calls TriggerExplosive(), but this
/// component still determines the explosion type and other properties.
/// </remarks>
-[RegisterComponent]
+[RegisterComponent, Access(typeof(SharedExplosionSystem))]
public sealed partial class ExplosiveComponent : Component
{
-
/// <summary>
/// The explosion prototype. This determines the damage types, the tile-break chance, and some visual
/// information (e.g., the light that the explosion gives off).
/// </summary>
- [ViewVariables(VVAccess.ReadWrite)]
- [DataField("explosionType", required: true, customTypeSerializer: typeof(PrototypeIdSerializer<ExplosionPrototype>))]
- public string ExplosionType = default!;
+ [DataField(required: true)]
+ public ProtoId<ExplosionPrototype> ExplosionType = default!;
/// <summary>
/// The maximum intensity the explosion can have on a single tile. This limits the maximum damage and tile
/// break chance the explosion can achieve at any given location.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite)]
- [DataField("maxIntensity")]
+ [DataField]
public float MaxIntensity = 4;
/// <summary>
/// How quickly the intensity drops off as you move away from the epicenter.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite)]
- [DataField("intensitySlope")]
+ [DataField]
public float IntensitySlope = 1;
/// <summary>
/// This number can be overridden by passing optional argument to <see
/// cref="ExplosionSystem.TriggerExplosive"/>.
/// </remarks>
- [ViewVariables(VVAccess.ReadWrite)]
- [DataField("totalIntensity")]
+ [DataField]
public float TotalIntensity = 10;
/// <summary>
/// Factor used to scale the explosion intensity when calculating tile break chances. Allows for stronger
/// explosives that don't space tiles, without having to create a new explosion-type prototype.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite)]
- [DataField("tileBreakScale")]
+ [DataField]
public float TileBreakScale = 1f;
/// <summary>
/// Maximum number of times that an explosive can break a tile. Currently, for normal space stations breaking a
/// tile twice will generally result in a vacuum.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite)]
- [DataField("maxTileBreak")]
+ [DataField]
public int MaxTileBreak = int.MaxValue;
/// <summary>
/// Whether this explosive should be able to create a vacuum by breaking tiles.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite)]
- [DataField("canCreateVacuum")]
+ [DataField]
public bool CanCreateVacuum = true;
/// <summary>
/// An override for whether or not the entity should be deleted after it explodes.
/// If null, the system calling the explode method handles it.
/// </summary>
- [DataField("deleteAfterExplosion")]
+ [DataField]
public bool? DeleteAfterExplosion;
/// <summary>
-using Content.Shared.Explosion.Components;
using Content.Shared.Armor;
+using Content.Shared.Explosion.Components;
namespace Content.Shared.Explosion.EntitySystems;
+/// <summary>
+/// Lets code in shared trigger explosions and handles explosion resistance examining.
+/// All processing is still done clientside.
+/// </summary>
public abstract class SharedExplosionSystem : EntitySystem
{
-
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<ExplosionResistanceComponent, ArmorExamineEvent>(OnArmorExamine);
}
- private void OnArmorExamine(EntityUid uid, ExplosionResistanceComponent component, ref ArmorExamineEvent args)
+ private void OnArmorExamine(Entity<ExplosionResistanceComponent> ent, ref ArmorExamineEvent args)
{
- var value = MathF.Round((1f - component.DamageCoefficient) * 100, 1);
+ var value = MathF.Round((1f - ent.Comp.DamageCoefficient) * 100, 1);
if (value == 0)
return;
args.Msg.PushNewline();
- args.Msg.AddMarkupOrThrow(Loc.GetString(component.Examine, ("value", value)));
+ args.Msg.AddMarkupOrThrow(Loc.GetString(ent.Comp.Examine, ("value", value)));
+ }
+
+ /// <summary>
+ /// Given an entity with an explosive component, spawn the appropriate explosion.
+ /// </summary>
+ /// <remarks>
+ /// Also accepts radius or intensity arguments. This is useful for explosives where the intensity is not
+ /// specified in the yaml / by the component, but determined dynamically (e.g., by the quantity of a
+ /// solution in a reaction).
+ /// </remarks>
+ public virtual void TriggerExplosive(EntityUid uid, ExplosiveComponent? explosive = null, bool delete = true, float? totalIntensity = null, float? radius = null, EntityUid? user = null)
+ {
}
}
projects / space-station-14.git / commitdiff