public sealed class ToggleDecalCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "toggledecals";
public string Description => "Toggles decaloverlay";
public string Help => $"{Command}";
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
- EntitySystem.Get<DecalSystem>().ToggleOverlay();
+ _e.System<DecalSystem>().ToggleOverlay();
}
}
public sealed partial class DecalPlacerWindow : DefaultWindow
{
[Dependency] private readonly IPrototypeManager _prototype = default!;
+ [Dependency] private readonly IEntityManager _e = default!;
private readonly DecalPlacementSystem _decalPlacementSystem;
RobustXamlLoader.Load(this);
IoCManager.InjectDependencies(this);
- _decalPlacementSystem = EntitySystem.Get<DecalPlacementSystem>();
+ _decalPlacementSystem = _e.System<DecalPlacementSystem>();
// This needs to be done in C# so we can have custom stuff passed in the constructor
// and thus have a proper step size
public sealed class ClearAllNetworkLinkOverlays : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "clearnetworklinkoverlays";
public string Description => "Clear all network link overlays.";
public string Help => Command;
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
- IoCManager.Resolve<IEntityManager>().System<NetworkConfiguratorSystem>().ClearAllOverlays();
+ _e.System<NetworkConfiguratorSystem>().ClearAllOverlays();
}
}
{
public sealed class NodeVisCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "nodevis";
public string Description => "Toggles node group visualization";
public string Help => "";
return;
}
- var sys = EntitySystem.Get<NodeGroupSystem>();
+ var sys = _e.System<NodeGroupSystem>();
sys.SetVisEnabled(!sys.VisEnabled);
}
}
public sealed class NodeVisFilterCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "nodevisfilter";
public string Description => "Toggles showing a specific group on nodevis";
public string Help => "Usage: nodevis [filter]\nOmit filter to list currently masked-off";
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
- var sys = EntitySystem.Get<NodeGroupSystem>();
+ var sys = _e.System<NodeGroupSystem>();
if (args.Length == 0)
{
using Content.Shared.CCVar;
using Robust.Shared.Configuration;
using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
using Robust.Shared.Timing;
namespace Content.IntegrationTests.Tests.Commands
tickBeforeRestart = entityManager.CurrentTick;
- var command = new RestartRoundNowCommand();
- command.Execute(null, string.Empty, Array.Empty<string>());
+ gameTicker.RestartRound();
if (lobbyEnabled)
{
[AdminCommand(AdminFlags.Admin)]
sealed class DSay : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "dsay";
public string Description => Loc.GetString("dsay-command-description");
if (string.IsNullOrEmpty(message))
return;
- var chat = EntitySystem.Get<ChatSystem>();
+ var chat = _e.System<ChatSystem>();
chat.TrySendInGameOOCMessage(entity, message, InGameOOCChatType.Dead, false, shell, player);
}
}
[AdminCommand(AdminFlags.Round)]
public sealed class ReadyAll : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "readyall";
public string Description => "Readies up all players in the lobby, except for observers.";
public string Help => $"{Command} | ̣{Command} <ready>";
ready = bool.Parse(args[0]);
}
- var gameTicker = EntitySystem.Get<GameTicker>();
+ var gameTicker = _e.System<GameTicker>();
if (gameTicker.RunLevel != GameRunLevel.PreRoundLobby)
[AdminCommand(AdminFlags.Round)]
public sealed class CallShuttleCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "callshuttle";
public string Description => Loc.GetString("call-shuttle-command-description");
public string Help => Loc.GetString("call-shuttle-command-help-text", ("command",Command));
// ReSharper disable once ConvertIfStatementToSwitchStatement
if (args.Length == 1 && TimeSpan.TryParseExact(args[0], ContentLocalizationManager.TimeSpanMinutesFormats, loc.DefaultCulture, out var timeSpan))
{
- EntitySystem.Get<RoundEndSystem>().RequestRoundEnd(timeSpan, shell.Player?.AttachedEntity, false);
+ _e.System<RoundEndSystem>().RequestRoundEnd(timeSpan, shell.Player?.AttachedEntity, false);
}
else if (args.Length == 1)
{
}
else
{
- EntitySystem.Get<RoundEndSystem>().RequestRoundEnd(shell.Player?.AttachedEntity, false);
+ _e.System<RoundEndSystem>().RequestRoundEnd(shell.Player?.AttachedEntity, false);
}
}
}
[AdminCommand(AdminFlags.Round)]
public sealed class RecallShuttleCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "recallshuttle";
public string Description => Loc.GetString("recall-shuttle-command-description");
public string Help => Loc.GetString("recall-shuttle-command-help-text", ("command",Command));
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
- EntitySystem.Get<RoundEndSystem>().CancelRoundEndCountdown(shell.Player?.AttachedEntity, false);
+ _e.System<RoundEndSystem>().CancelRoundEndCountdown(shell.Player?.AttachedEntity, false);
}
}
}
[AdminCommand(AdminFlags.VarEdit)]
public sealed class ThrowScoreboardCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "throwscoreboard";
public string Description => Loc.GetString("throw-scoreboard-command-description");
shell.WriteLine(Help);
return;
}
- EntitySystem.Get<GameTicker>().ShowRoundEndScoreboard();
+ _e.System<GameTicker>().ShowRoundEndScoreboard();
}
}
[Dependency] private readonly IAdminManager _adminManager = default!;
[Dependency] private readonly ILogManager _logManager = default!;
[Dependency] private readonly IConfigurationManager _configuration = default!;
+ [Dependency] private readonly IEntityManager _e = default!;
private readonly ISawmill _sawmill;
};
}
- private int CurrentRoundId => EntitySystem.Get<GameTicker>().RoundId;
+ private int CurrentRoundId => _e.System<GameTicker>().RoundId;
public override async void Opened()
{
if (request.TotalIntensity <= 0 || request.IntensitySlope <= 0)
return;
- var explosion = EntitySystem.Get<ExplosionSystem>().GenerateExplosionPreview(request);
+ var explosion = _explosionSystem.GenerateExplosionPreview(request);
if (explosion == null)
{
[AdminCommand(AdminFlags.Debug)]
public sealed class ClearAlert : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "clearalert";
public string Description => "Clears an alert for a player, defaulting to current player";
public string Help => "clearalert <alertType> <name or userID, omit for current player>";
if (!CommandUtils.TryGetAttachedEntityByUsernameOrId(shell, target, player, out attachedEntity)) return;
}
- if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(attachedEntity, out AlertsComponent? alertsComponent))
+ if (!_e.TryGetComponent(attachedEntity, out AlertsComponent? alertsComponent))
{
shell.WriteLine("user has no alerts component");
return;
}
var alertType = args[0];
- var alertsSystem =
EntitySystem.Get<AlertsSystem>();
+ var alertsSystem =
_e.System<AlertsSystem>();
if (!alertsSystem.TryGet(Enum.Parse<AlertType>(alertType), out var alert))
{
shell.WriteLine("unrecognized alertType " + alertType);
[AdminCommand(AdminFlags.Debug)]
public sealed class ShowAlert : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "showalert";
public string Description => "Shows an alert for a player, defaulting to current player";
public string Help => "showalert <alertType> <severity, -1 if no severity> <name or userID, omit for current player>";
if (!CommandUtils.TryGetAttachedEntityByUsernameOrId(shell, target, player, out attachedEntity)) return;
}
- if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(attachedEntity, out AlertsComponent? alertsComponent))
+ if (!_e.TryGetComponent(attachedEntity, out AlertsComponent? alertsComponent))
{
shell.WriteLine("user has no alerts component");
return;
var alertType = args[0];
var severity = args[1];
- var alertsSystem =
EntitySystem.Get<AlertsSystem>();
+ var alertsSystem =
_e.System<AlertsSystem>();
if (!alertsSystem.TryGet(Enum.Parse<AlertType>(alertType), out var alert))
{
shell.WriteLine("unrecognized alertType " + alertType);
[AdminCommand(AdminFlags.Debug)]
public sealed class ListGasesCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "listgases";
public string Description => "Prints a list of gases and their indices.";
public string Help => "listgases";
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
- var atmosSystem =
EntitySystem.Get<AtmosphereSystem>();
+ var atmosSystem =
_e.System<AtmosphereSystem>();
foreach (var gasPrototype in atmosSystem.Gases)
{
[AdminCommand(AdminFlags.Debug)]
public sealed class ShowAtmos : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "showatmos";
public string Description => "Toggles seeing atmos debug overlay.";
public string Help => $"Usage: {Command}";
return;
}
- var atmosDebug =
EntitySystem.Get<AtmosDebugOverlaySystem>();
+ var atmosDebug =
_e.System<AtmosDebugOverlaySystem>();
var enabled = atmosDebug.ToggleObserver(player);
shell.WriteLine(enabled
set
{
Type = value;
-
EntitySystem.Get<AtmosPlaqueSystem>().UpdateSign(Owner, this);
+
IoCManager.Resolve<IEntityManager>().System<AtmosPlaqueSystem>().UpdateSign(Owner, this);
}
}
}
{
IoCManager.InjectDependencies(this);
- DeviceNetworkSystem = EntitySystem.Get<DeviceNetworkSystem>();
- AirAlarmSystem = Entity
System.Get<AirAlarmSystem>();
+ DeviceNetworkSystem = EntityManager.System<DeviceNetworkSystem>();
+ AirAlarmSystem = Entity
Manager.System<AirAlarmSystem>();
}
}
public Color ColorVV
{
get => Color;
- set =>
EntitySystem.Get<AtmosPipeColorSystem>().SetColor(Owner, this, value);
+ set =>
IoCManager.Resolve<IEntityManager>().System<AtmosPipeColorSystem>().SetColor(Owner, this, value);
}
}
}
[AnyCommand]
internal sealed class LOOCCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "looc";
public string Description => "Send Local Out Of Character chat messages.";
public string Help => "looc <text>";
if (string.IsNullOrEmpty(message))
return;
- EntitySystem.Get<ChatSystem>().TrySendInGameOOCMessage(entity, message, InGameOOCChatType.Looc, false, shell, player);
+ _e.System<ChatSystem>().TrySendInGameOOCMessage(entity, message, InGameOOCChatType.Looc, false, shell, player);
}
}
}
[AnyCommand]
internal sealed class SuicideCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "suicide";
public string Description => Loc.GetString("suicide-command-description");
if (player.Status != SessionStatus.InGame || player.AttachedEntity == null)
return;
- var entityManager = IoCManager.Resolve<IEntityManager>();
- var minds = entityManager.System<SharedMindSystem>();
+ var minds = _e.System<SharedMindSystem>();
+
// This check also proves mind not-null for at the end when the mob is ghosted.
if (!minds.TryGetMind(player, out var mindId, out var mind) ||
mind.OwnedEntity is not { Valid: true } victim)
return;
}
- if (entityManager.HasComponent<AdminFrozenComponent>(victim))
+
+ var gameTicker = _e.System<GameTicker>();
+ var suicideSystem = _e.System<SuicideSystem>();
+
+ if (_e.HasComponent<AdminFrozenComponent>(victim))
{
var deniedMessage = Loc.GetString("suicide-command-denied");
shell.WriteLine(deniedMessage);
-
entityManager.System<PopupSystem>()
+
_e.System<PopupSystem>()
.PopupEntity(deniedMessage, victim, victim);
return;
}
- var gameTicker = entityManager.System<GameTicker>();
- var suicideSystem = entityManager.System<SuicideSystem>();
if (suicideSystem.Suicide(victim))
{
// Prevent the player from returning to the body.
var reagent = _protoManager.Index<ReagentPrototype>(reagentQuantity.Reagent.Prototype);
var reaction =
- reagent.ReactionTile(tile, (reagentQuantity.Quantity / vapor.TransferAmount) * 0.25f);
+ reagent.ReactionTile(tile, (reagentQuantity.Quantity / vapor.TransferAmount) * 0.25f, EntityManager);
if (reaction > reagentQuantity.Quantity)
{
{
var intensity = MathF.Min((float) args.Quantity * IntensityPerUnit, MaxTotalIntensity);
- EntitySystem.Get<ExplosionSystem>().QueueExplosion(
+ args.EntityManager.System<ExplosionSystem>()
+ .QueueExplosion(
args.SolutionEntity,
ExplosionType,
intensity,
public override bool Condition(ReagentEffectArgs args)
{
if (args.EntityManager.TryGetComponent<TagComponent>(args.SolutionEntity, out var tag))
- return EntitySystem.Get<TagSystem>().HasTag(tag, Tag) ^ Invert;
+ return args.EntityManager.System<TagSystem>().HasTag(tag, Tag) ^ Invert;
return false;
}
cleanseRate *= args.Scale;
- var bloodstreamSys = EntitySystem.Get<BloodstreamSystem>();
+ var bloodstreamSys = args.EntityManager.System<BloodstreamSystem>();
bloodstreamSys.FlushChemicals(args.SolutionEntity, args.Reagent.ID, cleanseRate);
}
}
{
if (!args.EntityManager.TryGetComponent(args.SolutionEntity, out FlammableComponent? flammable)) return;
- var flammableSystem = EntitySystem.Get<FlammableSystem>();
+ var flammableSystem = args.EntityManager.System<FlammableSystem>();
flammableSystem.Extinguish(args.SolutionEntity, flammable);
flammableSystem.AdjustFireStacks(args.SolutionEntity, -1.5f * (float) args.Quantity, flammable);
}
public override void Effect(ReagentEffectArgs args)
{
- var flamSys = EntitySystem.Get<FlammableSystem>();
+ var flamSys = args.EntityManager.System<FlammableSystem>();
flamSys.Ignite(args.SolutionEntity, args.OrganEntity ?? args.SolutionEntity);
}
}
{
if (args.EntityManager.TryGetComponent<BloodstreamComponent>(args.SolutionEntity, out var blood))
{
- var sys = EntitySystem.Get<BloodstreamSystem>();
+ var sys = args.EntityManager.System<BloodstreamSystem>();
var amt = Scaled ? Amount * args.Quantity.Float() : Amount;
amt *= args.Scale;
{
if (args.EntityManager.TryGetComponent<BloodstreamComponent>(args.SolutionEntity, out var blood))
{
- var sys = EntitySystem.Get<BloodstreamSystem>();
+ var sys = args.EntityManager.System<BloodstreamSystem>();
var amt = Scaled ? Amount * args.Quantity : Amount;
amt *= args.Scale;
IncreaseTimer(status, statusLifetime);
if (modified)
- EntitySystem.Get<MovementSpeedModifierSystem>().RefreshMovementSpeedModifiers(args.SolutionEntity);
+ args.EntityManager.System<MovementSpeedModifierSystem>().RefreshMovementSpeedModifiers(args.SolutionEntity);
}
public void IncreaseTimer(MovespeedModifierMetabolismComponent status, float time)
{
if (args.EntityManager.TryGetComponent<RespiratorComponent>(args.SolutionEntity, out var resp))
{
- var respSys = EntitySystem.Get<RespiratorSystem>();
+ var respSys = args.EntityManager.System<RespiratorSystem>();
respSys.UpdateSaturation(args.SolutionEntity, args.Quantity.Float() * Factor, resp);
}
}
var paralyzeTime = ParalyzeTime;
paralyzeTime *= args.Scale;
- EntitySystem.Get<StunSystem>().TryParalyze(args.SolutionEntity, TimeSpan.FromSeconds(paralyzeTime), Refresh);
+ args.EntityManager.System<StunSystem>().TryParalyze(args.SolutionEntity, TimeSpan.FromSeconds(paralyzeTime), Refresh);
}
}
{
var uid = args.SolutionEntity;
if (args.EntityManager.TryGetComponent(uid, out ThirstComponent? thirst))
- EntitySystem.Get<ThirstSystem>().ModifyThirst(uid, thirst, HydrationFactor);
+ args.EntityManager.System<ThirstSystem>().ModifyThirst(uid, thirst, HydrationFactor);
}
protected override string? ReagentEffectGuidebookText(IPrototypeManager prototype, IEntitySystemManager entSys)
{
if (!args.EntityManager.TryGetComponent(args.SolutionEntity, out CreamPiedComponent? creamPied)) return;
- EntitySystem.Get<CreamPieSystem>().SetCreamPied(args.SolutionEntity, creamPied, false);
+ args.EntityManager.System<CreamPieSystem>().SetCreamPied(args.SolutionEntity, creamPied, false);
}
}
}
[DataField]
public FixedPoint2 CleanCost { get; private set; } = FixedPoint2.New(0.25f);
- public FixedPoint2 TileReact(TileRef tile, ReagentPrototype reagent, FixedPoint2 reactVolume)
+ public FixedPoint2 TileReact(TileRef tile,
+ ReagentPrototype reagent,
+ FixedPoint2 reactVolume,
+ IEntityManager entityManager)
{
- var entMan = IoCManager.Resolve<IEntityManager>();
-
if (reactVolume <= CleanCost ||
- !entMan.TryGetComponent<MapGridComponent>(tile.GridUid, out var grid) ||
- !entMan.TryGetComponent<DecalGridComponent>(tile.GridUid, out var decalGrid))
+ !entityManager.TryGetComponent<MapGridComponent>(tile.GridUid, out var grid) ||
+ !entityManager.TryGetComponent<DecalGridComponent>(tile.GridUid, out var decalGrid))
{
return FixedPoint2.Zero;
}
- var lookupSystem = entMan.System<EntityLookupSystem>();
- var decalSystem = entMan.System<DecalSystem>();
+ var lookupSystem = entityManager.System<EntityLookupSystem>();
+ var decalSystem = entityManager.System<DecalSystem>();
// Very generous hitbox.
var decals = decalSystem
.GetDecalsIntersecting(tile.GridUid, lookupSystem.GetLocalBounds(tile, grid.TileSize).Enlarged(0.5f).Translated(new Vector2(-0.5f, -0.5f)));
[DataField("reagent", customTypeSerializer: typeof(PrototypeIdSerializer<ReagentPrototype>))]
public string ReplacementReagent = "Water";
- FixedPoint2 ITileReaction.TileReact(TileRef tile, ReagentPrototype reagent, FixedPoint2 reactVolume)
+ FixedPoint2 ITileReaction.TileReact(TileRef tile,
+ ReagentPrototype reagent,
+ FixedPoint2 reactVolume,
+ IEntityManager entityManager)
{
- var entMan = IoCManager.Resolve<IEntityManager>();
- var entities = entMan.System<EntityLookupSystem>().GetLocalEntitiesIntersecting(tile, 0f).ToArray();
- var puddleQuery = entMan.GetEntityQuery<PuddleComponent>();
- var solutionContainerSystem = entMan.System<SolutionContainerSystem>();
+ var entities = entityManager.System<EntityLookupSystem>().GetLocalEntitiesIntersecting(tile, 0f).ToArray();
+ var puddleQuery = entityManager.GetEntityQuery<PuddleComponent>();
+ var solutionContainerSystem = entityManager.System<SolutionContainerSystem>();
// Multiply as the amount we can actually purge is higher than the react amount.
var purgeAmount = reactVolume / CleanAmountMultiplier;
[DataField]
public float RandomOffsetMax = 0.0f;
- public FixedPoint2 TileReact(TileRef tile, ReagentPrototype reagent, FixedPoint2 reactVolume)
+ public FixedPoint2 TileReact(TileRef tile,
+ ReagentPrototype reagent,
+ FixedPoint2 reactVolume,
+ IEntityManager entityManager)
{
if (reactVolume >= Usage)
{
- // TODO probably pass this in args like reagenteffects do.
- var entMan = IoCManager.Resolve<IEntityManager>();
-
if (Whitelist != null)
{
int acc = 0;
var xoffs = random.NextFloat(-RandomOffsetMax, RandomOffsetMax);
var yoffs = random.NextFloat(-RandomOffsetMax, RandomOffsetMax);
- var center = entMan.System<TurfSystem>().GetTileCenter(tile);
+ var center = entityManager.System<TurfSystem>().GetTileCenter(tile);
var pos = center.Offset(new Vector2(xoffs, yoffs));
- entMan.SpawnEntity(Entity, pos);
+ entityManager.SpawnEntity(Entity, pos);
return Usage;
}
{
[DataField("coolingTemperature")] private float _coolingTemperature = 2f;
- public FixedPoint2 TileReact(TileRef tile, ReagentPrototype reagent, FixedPoint2 reactVolume)
+ public FixedPoint2 TileReact(TileRef tile,
+ ReagentPrototype reagent,
+ FixedPoint2 reactVolume,
+ IEntityManager entityManager)
{
if (reactVolume <= FixedPoint2.Zero || tile.Tile.IsEmpty)
return FixedPoint2.Zero;
- var atmosphereSystem =
EntitySystem.Get<AtmosphereSystem>();
+ var atmosphereSystem =
entityManager.System<AtmosphereSystem>();
var environment = atmosphereSystem.GetTileMixture(tile.GridUid, null, tile.GridIndices, true);
{
[DataField("temperatureMultiplier")] private float _temperatureMultiplier = 1.15f;
- public FixedPoint2 TileReact(TileRef tile, ReagentPrototype reagent, FixedPoint2 reactVolume)
+ public FixedPoint2 TileReact(TileRef tile,
+ ReagentPrototype reagent,
+ FixedPoint2 reactVolume,
+ IEntityManager entityManager)
{
if (reactVolume <= FixedPoint2.Zero || tile.Tile.IsEmpty)
return FixedPoint2.Zero;
- var atmosphereSystem =
EntitySystem.Get<AtmosphereSystem>();
+ var atmosphereSystem =
entityManager.System<AtmosphereSystem>();
var environment = atmosphereSystem.GetTileMixture(tile.GridUid, null, tile.GridIndices, true);
if (environment == null || !atmosphereSystem.IsHotspotActive(tile.GridUid, tile.GridIndices))
[DataDefinition]
public sealed partial class PryTileReaction : ITileReaction
{
- public FixedPoint2 TileReact(TileRef tile, ReagentPrototype reagent, FixedPoint2 reactVolume)
+ public FixedPoint2 TileReact(TileRef tile,
+ ReagentPrototype reagent,
+ FixedPoint2 reactVolume,
+ IEntityManager entityManager)
{
- var sys = IoCManager.Resolve<IEntityManager>().System<TileSystem>();
+ var sys = entityManager.System<TileSystem>();
sys.PryTile(tile);
return reactVolume;
}
[DataDefinition]
public sealed partial class SpillIfPuddlePresentTileReaction : ITileReaction
{
- public FixedPoint2 TileReact(TileRef tile, ReagentPrototype reagent, FixedPoint2 reactVolume)
+ public FixedPoint2 TileReact(TileRef tile,
+ ReagentPrototype reagent,
+ FixedPoint2 reactVolume,
+ IEntityManager entityManager)
{
- var spillSystem =
EntitySystem.Get<PuddleSystem>();
+ var spillSystem =
entityManager.System<PuddleSystem>();
if (reactVolume < 5 || !spillSystem.TryGetPuddle(tile, out _))
return FixedPoint2.Zero;
/// </summary>
[DataField("superSlippery")] private bool _superSlippery;
- public FixedPoint2 TileReact(TileRef tile, ReagentPrototype reagent, FixedPoint2 reactVolume)
+ public FixedPoint2 TileReact(TileRef tile,
+ ReagentPrototype reagent,
+ FixedPoint2 reactVolume,
+ IEntityManager entityManager)
{
if (reactVolume < 5)
return FixedPoint2.Zero;
- var entityManager = IoCManager.Resolve<IEntityManager>();
-
if (entityManager.EntitySysManager.GetEntitySystem<PuddleSystem>()
.TrySpillAt(tile, new Solution(reagent.ID, reactVolume), out var puddleUid, false, false))
{
!system.EntityManager.TryGetComponent<TransformComponent>(owner, out var xform))
return;
- var vendingMachineSystem = EntitySystem.Get<VendingMachineSystem>();
+ var vendingMachineSystem = system.EntityManager.System<VendingMachineSystem>();
var inventory = vendingMachineSystem.GetAvailableInventory(owner, vendingcomp);
if (inventory.Count <= 0)
return;
{
public void Execute(EntityUid uid, DestructibleSystem system, EntityUid? cause = null)
{
- var openable = EntitySystem.Get<OpenableSystem>();
+ var openable = system.EntityManager.System<OpenableSystem>();
openable.TryOpen(uid);
}
}
/// <param name="cause"></param>
public void Execute(EntityUid owner, DestructibleSystem system, EntityUid? cause = null)
{
- var solutionContainerSystem = EntitySystem.Get<SolutionContainerSystem>();
- var spillableSystem =
EntitySystem.Get<PuddleSystem>();
+ var solutionContainerSystem = system.EntityManager.System<SolutionContainerSystem>();
+ var spillableSystem =
system.EntityManager.System<PuddleSystem>();
var coordinates = system.EntityManager.GetComponent<TransformComponent>(owner).Coordinates;
{
var (reagent, quantity) = solution.Contents[i];
var proto = _prototypeManager.Index<ReagentPrototype>(reagent.Prototype);
- var removed = proto.ReactionTile(tileRef, quantity);
+ var removed = proto.ReactionTile(tileRef, quantity, EntityManager);
if (removed <= FixedPoint2.Zero)
continue;
continue;
var reagent = _prototype.Index<ReagentPrototype>(reagentQuantity.Reagent.Prototype);
- reagent.ReactionTile(tile, reagentQuantity.Quantity);
+ reagent.ReactionTile(tile, reagentQuantity.Quantity, EntityManager);
}
}
[AdminCommand(AdminFlags.Round)]
sealed class DelayStartCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "delaystart";
public string Description => "Delays the round start.";
public string Help => $"Usage: {Command} <seconds>\nPauses/Resumes the countdown if no argument is provided.";
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
- var ticker = EntitySystem.Get<GameTicker>();
+ var ticker = _e.System<GameTicker>();
if (ticker.RunLevel != GameRunLevel.PreRoundLobby)
{
shell.WriteLine("This can only be executed while the game is in the pre-round lobby.");
[AdminCommand(AdminFlags.Round)]
sealed class EndRoundCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "endround";
public string Description => "Ends the round and moves the server to PostRound.";
public string Help => String.Empty;
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
- var ticker = EntitySystem.Get<GameTicker>();
+ var ticker = _e.System<GameTicker>();
if (ticker.RunLevel != GameRunLevel.InRound)
{
[AdminCommand(AdminFlags.Round)]
sealed class ForcePresetCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "forcepreset";
public string Description => "Forces a specific game preset to start for the current lobby.";
public string Help => $"Usage: {Command} <preset>";
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
- var ticker = EntitySystem.Get<GameTicker>();
+ var ticker = _e.System<GameTicker>();
if (ticker.RunLevel != GameRunLevel.PreRoundLobby)
{
shell.WriteLine("This can only be executed while the game is in the pre-round lobby.");
[AdminCommand(AdminFlags.Round)]
public sealed class GoLobbyCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "golobby";
public string Description => "Enables the lobby and restarts the round.";
public string Help => $"Usage: {Command} / {Command} <preset>";
GamePresetPrototype? preset = null;
var presetName = string.Join(" ", args);
- var ticker = EntitySystem.Get<GameTicker>();
+ var ticker = _e.System<GameTicker>();
if (args.Length > 0)
{
[AnyCommand]
sealed class ObserveCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "observe";
public string Description => "";
public string Help => "";
return;
}
- var ticker = EntitySystem.Get<GameTicker>();
+ var ticker = _e.System<GameTicker>();
if (ticker.RunLevel == GameRunLevel.PreRoundLobby)
{
[AdminCommand(AdminFlags.Round)]
public sealed class RestartRoundCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "restartround";
public string Description => "Ends the current round and starts the countdown for the next lobby.";
public string Help => string.Empty;
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
- var ticker = EntitySystem.Get<GameTicker>();
+ var ticker = _e.System<GameTicker>();
if (ticker.RunLevel != GameRunLevel.InRound)
{
return;
}
- EntitySystem.Get<RoundEndSystem>().EndRound();
+ _e.System<RoundEndSystem>().EndRound();
}
}
[AdminCommand(AdminFlags.Round)]
public sealed class RestartRoundNowCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "restartroundnow";
public string Description => "Moves the server from PostRound to a new PreRoundLobby.";
public string Help => String.Empty;
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
- EntitySystem.Get<GameTicker>().RestartRound();
+ _e.System<GameTicker>().RestartRound();
}
}
}
[AdminCommand(AdminFlags.Round)]
sealed class StartRoundCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "startround";
public string Description => "Ends PreRoundLobby state and starts the round.";
public string Help => String.Empty;
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
- var ticker = EntitySystem.Get<GameTicker>();
+ var ticker = _e.System<GameTicker>();
if (ticker.RunLevel != GameRunLevel.PreRoundLobby)
{
[AnyCommand]
sealed class ToggleReadyCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "toggleready";
public string Description => "";
public string Help => "";
return;
}
- var ticker = EntitySystem.Get<GameTicker>();
+ var ticker = _e.System<GameTicker>();
ticker.ToggleReady(player, bool.Parse(args[0]));
}
}
set
{
_roleName = value;
- EntitySystem.Get<GhostRoleSystem>().UpdateAllEui();
+ IoCManager.Resolve<IEntityManager>().System<GhostRoleSystem>().UpdateAllEui();
}
}
set
{
_roleDescription = value;
- EntitySystem.Get<GhostRoleSystem>().UpdateAllEui();
+ IoCManager.Resolve<IEntityManager>().System<GhostRoleSystem>().UpdateAllEui();
}
}
set
{
_roleRules = value;
- EntitySystem.Get<GhostRoleSystem>().UpdateAllEui();
+ IoCManager.Resolve<IEntityManager>().System<GhostRoleSystem>().UpdateAllEui();
}
}
[AnyCommand]
public sealed class GhostRoles : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "ghostroles";
public string Description => "Opens the ghost role request window.";
public string Help => $"{Command}";
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (shell.Player != null)
- EntitySystem.Get<GhostRoleSystem>().OpenEui(shell.Player);
+ _e.System<GhostRoleSystem>().OpenEui(shell.Player);
else
shell.WriteLine("You can only open the ghost roles UI on a client.");
}
{
base.Closed();
- EntitySystem.Get<GhostRoleSystem>().CloseEui(Player);
+ _ghostRoleSystem.CloseEui(Player);
}
}
}
public override bool Check(GameMapPrototype map)
{
- var holidaySystem = EntitySystem.Get<HolidaySystem>();
+ var holidaySystem = IoCManager.Resolve<IEntityManager>().System<HolidaySystem>();
return Holidays.Any(holiday => holidaySystem.IsCurrentlyHoliday(holiday)) ^ Inverted;
}
_alwaysReachable.Add(pipeNode);
if (NodeGroup != null)
- EntitySystem.Get<NodeGroupSystem>().QueueRemakeGroup((BaseNodeGroup) NodeGroup);
+ IoCManager.Resolve<IEntityManager>().System<NodeGroupSystem>().QueueRemakeGroup((BaseNodeGroup) NodeGroup);
}
public void RemoveAlwaysReachable(PipeNode pipeNode)
_alwaysReachable.Remove(pipeNode);
if (NodeGroup != null)
- EntitySystem.Get<NodeGroupSystem>().QueueRemakeGroup((BaseNodeGroup) NodeGroup);
+ IoCManager.Resolve<IEntityManager>().System<NodeGroupSystem>().QueueRemakeGroup((BaseNodeGroup) NodeGroup);
}
/// <summary>
_connectionsEnabled = value;
if (NodeGroup != null)
- EntitySystem.Get<NodeGroupSystem>().QueueRemakeGroup((BaseNodeGroup) NodeGroup);
+ IoCManager.Resolve<IEntityManager>().System<NodeGroupSystem>().QueueRemakeGroup((BaseNodeGroup) NodeGroup);
}
}
[AdminCommand(AdminFlags.Debug)]
public sealed class PowerStatCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _e = default!;
+
public string Command => "powerstat";
public string Description => "Shows statistics for pow3r";
public string Help => "Usage: powerstat";
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
- var stats =
EntitySystem.Get<PowerNetSystem>().GetStatistics();
+ var stats =
_e.System<PowerNetSystem>().GetStatistics();
shell.WriteLine($"networks: {stats.CountNetworks}");
shell.WriteLine($"loads: {stats.CountLoads}");
{
base.Initialize();
- _electrocutionSystem = EntitySystem.Get<ElectrocutionSystem>();
+ _electrocutionSystem = EntityManager.System<ElectrocutionSystem>();
}
// This should add a wire into the entity's state, whether it be
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
- var sandboxManager = EntitySystem.Get<SandboxSystem>();
+ var sandboxManager = _entManager.System<SandboxSystem>();
var adminManager = IoCManager.Resolve<IAdminManager>();
if (shell.IsClient && (!sandboxManager.IsSandboxEnabled && !adminManager.HasAdminFlag(shell.Player!, AdminFlags.Mapping)))
{
{
public interface ITileReaction
{
- FixedPoint2 TileReact(TileRef tile, ReagentPrototype reagent, FixedPoint2 reactVolume);
+ FixedPoint2 TileReact(TileRef tile,
+ ReagentPrototype reagent,
+ FixedPoint2 reactVolume,
+ IEntityManager entityManager);
}
}
[DataField]
public SoundSpecifier FootstepSound = new SoundCollectionSpecifier("FootstepWater", AudioParams.Default.WithVolume(6));
- public FixedPoint2 ReactionTile(TileRef tile, FixedPoint2 reactVolume)
+ public FixedPoint2 ReactionTile(TileRef tile, FixedPoint2 reactVolume, IEntityManager entityManager)
{
var removed = FixedPoint2.Zero;
foreach (var reaction in TileReactions)
{
- removed += reaction.TileReact(tile, this, reactVolume - removed);
+ removed += reaction.TileReact(tile, this, reactVolume - removed, entityManager);
if (removed > reactVolume)
throw new Exception("Removed more than we have!");
var alertsComponent = new AlertsComponent();
alertsComponent = IoCManager.InjectDependencies(alertsComponent);
- Assert.That(
EntitySystem.Get<AlertsSystem>().TryGet(AlertType.LowPressure, out var lowpressure));
- Assert.That(
EntitySystem.Get<AlertsSystem>().TryGet(AlertType.HighPressure, out var highpressure));
+ Assert.That(
entManager.System<AlertsSystem>().TryGet(AlertType.LowPressure, out var lowpressure));
+ Assert.That(
entManager.System<AlertsSystem>().TryGet(AlertType.HighPressure, out var highpressure));
-
EntitySystem.Get<AlertsSystem>().ShowAlert(alertsComponent.Owner, AlertType.LowPressure, null, null);
+
entManager.System<AlertsSystem>().ShowAlert(alertsComponent.Owner, AlertType.LowPressure, null, null);
var getty = new ComponentGetState();
entManager.EventBus.RaiseComponentEvent(alertsComponent, getty);
Assert.That(alertState.Alerts.Count, Is.EqualTo(1));
Assert.That(alertState.Alerts.ContainsKey(lowpressure.AlertKey));
-
EntitySystem.Get<AlertsSystem>().ShowAlert(alertsComponent.Owner, AlertType.HighPressure, null, null);
+
entManager.System<AlertsSystem>().ShowAlert(alertsComponent.Owner, AlertType.HighPressure, null, null);
// Lazy
entManager.EventBus.RaiseComponentEvent(alertsComponent, getty);
Assert.That(alertState.Alerts.Count, Is.EqualTo(1));
Assert.That(alertState.Alerts.ContainsKey(highpressure.AlertKey));
-
EntitySystem.Get<AlertsSystem>().ClearAlertCategory(alertsComponent.Owner, AlertCategory.Pressure);
+
entManager.System<AlertsSystem>().ClearAlertCategory(alertsComponent.Owner, AlertCategory.Pressure);
entManager.EventBus.RaiseComponentEvent(alertsComponent, getty);
alertState = (AlertsComponent.AlertsComponent_AutoState) getty.State!;
projects / space-station-14.git / commitdiff