--- /dev/null
+using System.Linq;
+using System.Numerics;
+using Content.Client.Parallax;
+using Content.Shared.Weather;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Client.Utility;
+using Robust.Shared.Enums;
+using Robust.Shared.Graphics.RSI;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+using Robust.Shared.Utility;
+
+namespace Content.Client.Weather;
+
+public sealed class WeatherOverlay : Overlay
+{
+ [Dependency] private readonly IClyde _clyde = default!;
+ [Dependency] private readonly IEntityManager _entManager = default!;
+ [Dependency] private readonly IGameTiming _timing = default!;
+ [Dependency] private readonly IMapManager _mapManager = default!;
+ [Dependency] private readonly IPrototypeManager _protoManager = default!;
+ [Dependency] private readonly IResourceCache _cache = default!;
+ private readonly SharedTransformSystem _transform;
+ private readonly SpriteSystem _sprite;
+ private readonly WeatherSystem _weather;
+
+ public override OverlaySpace Space => OverlaySpace.WorldSpaceBelowFOV;
+
+ private IRenderTexture? _blep;
+
+ public WeatherOverlay(SharedTransformSystem transform, SpriteSystem sprite, WeatherSystem weather)
+ {
+ ZIndex = ParallaxSystem.ParallaxZIndex + 1;
+ _transform = transform;
+ _weather = weather;
+ _sprite = sprite;
+ IoCManager.InjectDependencies(this);
+ }
+
+ protected override bool BeforeDraw(in OverlayDrawArgs args)
+ {
+ if (args.MapId == MapId.Nullspace)
+ return false;
+
+ if (!_entManager.TryGetComponent<WeatherComponent>(_mapManager.GetMapEntityId(args.MapId), out var weather) ||
+ weather.Weather.Count == 0)
+ {
+ return false;
+ }
+
+ return base.BeforeDraw(in args);
+ }
+
+ protected override void Draw(in OverlayDrawArgs args)
+ {
+ var mapUid = _mapManager.GetMapEntityId(args.MapId);
+
+ if (!_entManager.TryGetComponent<WeatherComponent>(mapUid, out var comp))
+ {
+ return;
+ }
+
+ foreach (var (proto, weather) in comp.Weather)
+ {
+ if (!_protoManager.TryIndex<WeatherPrototype>(proto, out var weatherProto))
+ continue;
+
+ var alpha = _weather.GetPercent(weather, mapUid);
+ DrawWorld(args, weatherProto, alpha);
+ }
+ }
+
+ private void DrawWorld(in OverlayDrawArgs args, WeatherPrototype weatherProto, float alpha)
+ {
+ var worldHandle = args.WorldHandle;
+ var mapId = args.MapId;
+ var worldAABB = args.WorldAABB;
+ var worldBounds = args.WorldBounds;
+ var invMatrix = args.Viewport.GetWorldToLocalMatrix();
+ var position = args.Viewport.Eye?.Position.Position ?? Vector2.Zero;
+
+ if (_blep?.Texture.Size != args.Viewport.Size)
+ {
+ _blep?.Dispose();
+ _blep = _clyde.CreateRenderTarget(args.Viewport.Size, new RenderTargetFormatParameters(RenderTargetColorFormat.Rgba8Srgb), name: "weather-stencil");
+ }
+
+ // Cut out the irrelevant bits via stencil
+ // This is why we don't just use parallax; we might want specific tiles to get drawn over
+ // particularly for planet maps or stations.
+ worldHandle.RenderInRenderTarget(_blep, () =>
+ {
+ var bodyQuery = _entManager.GetEntityQuery<PhysicsComponent>();
+ var xformQuery = _entManager.GetEntityQuery<TransformComponent>();
+ var weatherIgnoreQuery = _entManager.GetEntityQuery<IgnoreWeatherComponent>();
+
+ // idk if this is safe to cache in a field and clear sloth help
+ var grids = new List<Entity<MapGridComponent>>();
+ _mapManager.FindGridsIntersecting(mapId, worldAABB, ref grids);
+
+ foreach (var grid in grids)
+ {
+ var matrix = _transform.GetWorldMatrix(grid, xformQuery);
+ Matrix3.Multiply(in matrix, in invMatrix, out var matty);
+ worldHandle.SetTransform(matty);
+
+ foreach (var tile in grid.Comp.GetTilesIntersecting(worldAABB))
+ {
+ // Ignored tiles for stencil
+ if (_weather.CanWeatherAffect(grid, tile, weatherIgnoreQuery, bodyQuery))
+ {
+ continue;
+ }
+
+ var gridTile = new Box2(tile.GridIndices * grid.Comp.TileSize,
+ (tile.GridIndices + Vector2i.One) * grid.Comp.TileSize);
+
+ worldHandle.DrawRect(gridTile, Color.White);
+ }
+ }
+
+ }, Color.Transparent);
+
+ worldHandle.SetTransform(Matrix3.Identity);
+ worldHandle.UseShader(_protoManager.Index<ShaderPrototype>("StencilMask").Instance());
+ worldHandle.DrawTextureRect(_blep.Texture, worldBounds);
+ Texture? sprite = null;
+ var curTime = _timing.RealTime;
+
+ switch (weatherProto.Sprite)
+ {
+ case SpriteSpecifier.Rsi rsi:
+ var rsiActual = _cache.GetResource<RSIResource>(rsi.RsiPath).RSI;
+ rsiActual.TryGetState(rsi.RsiState, out var state);
+ var frames = state!.GetFrames(RsiDirection.South);
+ var delays = state.GetDelays();
+ var totalDelay = delays.Sum();
+ var time = curTime.TotalSeconds % totalDelay;
+ var delaySum = 0f;
+
+ for (var i = 0; i < delays.Length; i++)
+ {
+ var delay = delays[i];
+ delaySum += delay;
+
+ if (time > delaySum)
+ continue;
+
+ sprite = frames[i];
+ break;
+ }
+
+ sprite ??= _sprite.Frame0(weatherProto.Sprite);
+ break;
+ case SpriteSpecifier.Texture texture:
+ sprite = texture.GetTexture(_cache);
+ break;
+ default:
+ throw new NotImplementedException();
+ }
+
+ // Draw the rain
+ worldHandle.UseShader(_protoManager.Index<ShaderPrototype>("StencilDraw").Instance());
+
+ // TODO: This is very similar to parallax but we need stencil support but we can probably combine these somehow
+ // and not make it spaghetti, while getting the advantages of not-duped code?
+
+
+ // Okay I have spent like 5 hours on this at this point and afaict you have one of the following comprises:
+ // - No scrolling so the weather is always centered on the player
+ // - Crappy looking rotation but strafing looks okay and scrolls
+ // - Crappy looking strafing but rotation looks okay.
+ // - No rotation
+ // - Storing state across frames to do scrolling and just having it always do topdown.
+
+ // I have chosen no rotation.
+
+ const float scale = 1f;
+ const float slowness = 0f;
+ var scrolling = Vector2.Zero;
+
+ // Size of the texture in world units.
+ var size = (sprite.Size / (float) EyeManager.PixelsPerMeter) * scale;
+ var scrolled = scrolling * (float) curTime.TotalSeconds;
+
+ // Origin - start with the parallax shift itself.
+ var originBL = position * slowness + scrolled;
+
+ // Centre the image.
+ originBL -= size / 2;
+
+ // Remove offset so we can floor.
+ var flooredBL = args.WorldAABB.BottomLeft - originBL;
+
+ // Floor to background size.
+ flooredBL = (flooredBL / size).Floored() * size;
+
+ // Re-offset.
+ flooredBL += originBL;
+
+ for (var x = flooredBL.X; x < args.WorldAABB.Right; x += size.X)
+ {
+ for (var y = flooredBL.Y; y < args.WorldAABB.Top; y += size.Y)
+ {
+ var box = Box2.FromDimensions(new Vector2(x, y), size);
+ worldHandle.DrawTextureRect(sprite, box, (weatherProto.Color ?? Color.White).WithAlpha(alpha));
+ }
+ }
+
+ worldHandle.SetTransform(Matrix3.Identity);
+ worldHandle.UseShader(null);
+ }
+}
/// <summary>
/// Assert whether or not the target has the given component.
/// </summary>
- protected void AssertComp<T>(bool hasComp = true, NetEntity? target = null)
+ protected void AssertComp<T>(bool hasComp = true, NetEntity? target = null) where T : IComponent
{
target ??= Target;
if (target == null)
}
// An entity may also remove components on init -> check no components are missing.
- foreach (var (compType, comp) in prototype.Components)
+ foreach (var compType in prototype.Components.Keys)
{
Assert.That(compNames, Does.Contain(compType), $"Prototype {prototype.ID} removes component {compType} on spawn.");
}
Assert.Fail($"Uninitialized entities should not be saving entity Uids. Component: {WritingComponent}. Prototype: {Prototype.ID}");
}
- return new ValueDataNode(value.ToString());
+ return new ValueDataNode(value.Id.ToString());
}
EntityUid ITypeReader<EntityUid, ValueDataNode>.Read(ISerializationManager serializationManager,
SerializationHookContext hookCtx,
ISerializationContext? context, ISerializationManager.InstantiationDelegate<EntityUid>? instanceProvider)
{
- return EntityUid.Parse(node.Value);
+ return EntityUid.Parse(node.Value, "0");
}
}
}
return;
}
- var target = new EntityUid(targetId);
+ var targetNet = new NetEntity(targetId);
- if (!target.IsValid() || !_entities.EntityExists(target))
+ if (!_entities.TryGetEntity(targetNet, out var target))
{
shell.WriteLine(Loc.GetString("shell-invalid-entity-id"));
return;
}
- _entities.System<MindSystem>().ControlMob(player.UserId, target);
+ _entities.System<MindSystem>().ControlMob(player.UserId, target.Value);
}
}
}
[AdminCommand(AdminFlags.Fun)]
public sealed class OwoifyCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _entManager = default!;
+
public string Command => "owoify";
public string Description => "For when you need everything to be cat. Uses OwOAccent's formatting on the name and description of an entity.";
return;
}
- var entityManager = IoCManager.Resolve<IEntityManager>();
-
if (!int.TryParse(args[0], out var targetId))
{
shell.WriteLine(Loc.GetString("shell-argument-must-be-number"));
return;
}
- var eUid = new EntityUid(targetId);
+ var nent = new NetEntity(targetId);
+
+ if (!_entManager.TryGetEntity(nent, out var eUid))
+ {
+ return;
+ }
- var meta = entityManager.GetComponent<MetaDataComponent>(eUid);
+ var meta = _entManager.GetComponent<MetaDataComponent>(eUid.Value);
- var owoSys = entityManager.System<OwOAccentSystem>();
- var metaDataSys = entityManager.System<MetaDataSystem>();
+ var owoSys = _entManager.System<OwOAccentSystem>();
+ var metaDataSys = _entManager.System<MetaDataSystem>();
- metaDataSys.SetEntityName(eUid, owoSys.Accentuate(meta.EntityName), meta);
- metaDataSys.SetEntityDescription(eUid, owoSys.Accentuate(meta.EntityDescription), meta);
+ metaDataSys.SetEntityName(eUid.Value, owoSys.Accentuate(meta.EntityName), meta);
+ metaDataSys.SetEntityDescription(eUid.Value, owoSys.Accentuate(meta.EntityDescription), meta);
}
}
[AdminCommand(AdminFlags.Admin)]
sealed class SetMindCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _entManager = default!;
public string Command => "setmind";
return;
}
- if (!int.TryParse(args[0], out var entityUid))
+ if (!int.TryParse(args[0], out var entInt))
{
shell.WriteLine(Loc.GetString("shell-entity-uid-must-be-number"));
return;
ghostOverride = bool.Parse(args[2]);
}
- var entityManager = IoCManager.Resolve<IEntityManager>();
+ var nent = new NetEntity(entInt);
- var eUid = new EntityUid(entityUid);
-
- if (!eUid.IsValid() || !entityManager.EntityExists(eUid))
+ if (!_entManager.TryGetEntity(nent, out var eUid))
{
shell.WriteLine(Loc.GetString("shell-invalid-entity-id"));
return;
}
- if (!entityManager.HasComponent<MindContainerComponent>(eUid))
+ if (!_entManager.HasComponent<MindContainerComponent>(eUid))
{
shell.WriteLine(Loc.GetString("set-mind-command-target-has-no-mind-message"));
return;
return;
}
- var mindSystem = entityManager.System<SharedMindSystem>();
- var metadata = entityManager.GetComponent<MetaDataComponent>(eUid);
+ var mindSystem = _entManager.System<SharedMindSystem>();
+ var metadata = _entManager.GetComponent<MetaDataComponent>(eUid.Value);
var mind = playerCData.Mind ?? mindSystem.CreateMind(session.UserId, metadata.EntityName);
return;
}
- if (!int.TryParse(args[0], out var entityUid))
+ if (!int.TryParse(args[0], out var entInt))
{
shell.WriteLine(Loc.GetString("shell-entity-uid-must-be-number"));
return;
}
- var target = new EntityUid(entityUid);
+ var targetNet = new NetEntity(entInt);
- if (!target.IsValid() || !_entities.EntityExists(target))
+ if (!_entities.TryGetEntity(targetNet, out var target))
{
shell.WriteLine(Loc.GetString("shell-invalid-entity-id"));
return;
}
- if (!_entities.HasComponent<InventoryComponent?>(target))
+ if (!_entities.HasComponent<InventoryComponent>(target))
{
shell.WriteLine(Loc.GetString("shell-target-entity-does-not-have-message", ("missing", "inventory")));
return;
}
var eui = IoCManager.Resolve<EuiManager>();
- var ui = new SetOutfitEui(target);
+ var ui = new SetOutfitEui(targetNet);
eui.OpenEui(ui, player);
return;
}
- if (!SetOutfit(target, args[1], _entities))
+ if (!SetOutfit(target.Value, args[1], _entities))
shell.WriteLine(Loc.GetString("set-outfit-command-invalid-outfit-id-error"));
}
Text = Loc.GetString("set-outfit-verb-get-data-text"),
Category = VerbCategory.Debug,
Icon = new SpriteSpecifier.Texture(new ("/Textures/Interface/VerbIcons/outfit.svg.192dpi.png")),
- Act = () => _euiManager.OpenEui(new SetOutfitEui(args.Target), player),
+ Act = () => _euiManager.OpenEui(new SetOutfitEui(GetNetEntity(args.Target)), player),
Impact = LogImpact.Medium
};
args.Verbs.Add(verb);
public sealed class SetOutfitEui : BaseEui
{
[Dependency] private readonly IAdminManager _adminManager = default!;
- [Dependency] private readonly IEntityManager _entManager = default!;
- private readonly EntityUid _target;
+ private readonly NetEntity _target;
- public SetOutfitEui(EntityUid entity)
+ public SetOutfitEui(NetEntity entity)
{
_target = entity;
IoCManager.InjectDependencies(this);
{
return new SetOutfitEuiState
{
- TargetNetEntity = _entManager.GetNetEntity(_target)
+ TargetNetEntity = _target,
};
}
{
var comp = (Component) _serialization.CreateCopy(entry.Component, notNullableOverride: true);
comp.Owner = humanoid; // This .owner must survive for now.
- EntityManager.AddComponent(humanoid, comp, true);
+ EntityManager.AddComponent(humanoid, comp);
}
}
var temp = (object) component;
serializationManager.CopyTo(data.Component, ref temp);
- entityManager.AddComponent(mob, (Component) temp!, true);
+ entityManager.AddComponent(mob, (Component) temp!);
}
}
}
return;
}
- var entId = new EntityUid(int.Parse(args[0]));
+ var nent = new NetEntity(int.Parse(args[0]));
- if (!_entities.EntityExists(entId))
+ if (!_entities.TryGetEntity(nent, out var entId))
{
- shell.WriteError($"Unable to find entity with uid {entId}");
+ shell.WriteError($"Unable to find entity {nent}");
return;
}
return;
}
- var comp = _entities.AddComponent<HTNComponent>(entId);
+ var comp = _entities.AddComponent<HTNComponent>(entId.Value);
comp.RootTask = new HTNCompoundTask()
{
Task = args[1]
[AnyCommand]
public sealed class ColorNetworkCommand : IConsoleCommand
{
+ [Dependency] private readonly IAdminManager _adminManager = default!;
+ [Dependency] private readonly IEntityManager _entManager = default!;
+
public string Command => "colornetwork";
public string Description => Loc.GetString("color-network-command-description");
public string Help => Loc.GetString("color-network-command-help-text", ("command",Command));
return;
}
-
-
- var entityManager = IoCManager.Resolve<IEntityManager>();
-
if (!int.TryParse(args[0], out var targetId))
{
shell.WriteLine(Loc.GetString("shell-argument-must-be-number"));
return;
}
- var eUid = new EntityUid(targetId);
+ var nent = new NetEntity(targetId);
- if (!eUid.IsValid() || !entityManager.EntityExists(eUid))
+ if (!_entManager.TryGetEntity(nent, out var eUid))
{
shell.WriteLine(Loc.GetString("shell-invalid-entity-id"));
return;
}
- if (!entityManager.TryGetComponent(eUid, out NodeContainerComponent? nodeContainerComponent))
+ if (!_entManager.TryGetComponent(eUid, out NodeContainerComponent? nodeContainerComponent))
{
shell.WriteLine(Loc.GetString("shell-entity-is-not-node-container"));
return;
{
var group = nodeContainerComponent.Nodes[nodeGroupId.ToString().ToLower()].NodeGroup;
- if (group == null) return;
+ if (group == null)
+ return;
foreach (var x in group.Nodes)
{
- if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(x.Owner, out AtmosPipeColorComponent? atmosPipeColorComponent)) continue;
+ if (!_entManager.TryGetComponent(x.Owner, out AtmosPipeColorComponent? atmosPipeColorComponent))
+ continue;
-
EntitySystem.Get<AtmosPipeColorSystem>().SetColor(x.Owner, atmosPipeColorComponent, color);
+
_entManager.System<AtmosPipeColorSystem>().SetColor(x.Owner, atmosPipeColorComponent, color);
}
}
}
[AdminCommand(AdminFlags.Admin)]
public sealed class AddUplinkCommand : IConsoleCommand
{
+ [Dependency] private readonly IConfigurationManager _cfgManager = default!;
+ [Dependency] private readonly IEntityManager _entManager = default!;
+ [Dependency] private readonly IPlayerManager _playerManager = default!;
+
public string Command => "adduplink";
public string Description => Loc.GetString("add-uplink-command-description");
if (args.Length > 0)
{
// Get player entity
- if (!IoCManager.Resolve<IPlayerManager>().TryGetSessionByUsername(args[0], out session))
+ if (!_playerManager.TryGetSessionByUsername(args[0], out session))
{
shell.WriteLine(Loc.GetString("shell-target-player-does-not-exist"));
return;
// Get target item
EntityUid? uplinkEntity = null;
- var entityManager = IoCManager.Resolve<IEntityManager>();
if (args.Length >= 2)
{
if (!int.TryParse(args[1], out var itemID))
return;
}
- var eUid = new EntityUid(itemID);
- if (!eUid.IsValid() || !entityManager.EntityExists(eUid))
+ var eNet = new NetEntity(itemID);
+
+ if (!_entManager.TryGetEntity(eNet, out var eUid))
{
shell.WriteLine(Loc.GetString("shell-invalid-entity-id"));
return;
}
// Get TC count
- var configManager = IoCManager.Resolve<IConfigurationManager>();
- var tcCount = configManager.GetCVar(CCVars.TraitorStartingBalance);
- Logger.Debug(entityManager.ToPrettyString(user));
+ var tcCount = _cfgManager.GetCVar(CCVars.TraitorStartingBalance);
+ Logger.Debug(_entManager.ToPrettyString(user));
// Finally add uplink
- var uplinkSys = entityManager.EntitySysManager.GetEntitySystem<UplinkSystem>();
+ var uplinkSys = _entManager.System<UplinkSystem>();
if (!uplinkSys.AddUplink(user, FixedPoint2.New(tcCount), uplinkEntity: uplinkEntity))
{
shell.WriteLine(Loc.GetString("add-uplink-command-error-2"));
[AdminCommand(AdminFlags.Admin)]
public sealed class InvokeVerbCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _entManager = default!;
+
public string Command => "invokeverb";
public string Description => Loc.GetString("invoke-verb-command-description");
public string Help => Loc.GetString("invoke-verb-command-help");
return;
}
- var entityManager = IoCManager.Resolve<IEntityManager>();
- var verbSystem = entityManager.System<SharedVerbSystem>();
+ var verbSystem = _entManager.System<SharedVerbSystem>();
// get the 'player' entity (defaulting to command user, otherwise uses a uid)
EntityUid? playerEntity = null;
return;
}
}
- else
- {
- entityManager.EntityExists(new EntityUid(intPlayerUid));
- }
// gets the target entity
if (!int.TryParse(args[1], out var intUid))
return;
}
- var target = new EntityUid(intUid);
- if (!entityManager.EntityExists(target))
+ var targetNet = new NetEntity(intUid);
+
+ if (!_entManager.TryGetEntity(targetNet, out var target))
{
shell.WriteError(Loc.GetString("invoke-verb-command-invalid-target-entity"));
return;
}
var verbName = args[2].ToLowerInvariant();
- var verbs = verbSystem.GetLocalVerbs(target, playerEntity.Value, Verb.VerbTypes, true);
-
+ var verbs = verbSystem.GetLocalVerbs(target.Value, playerEntity.Value, Verb.VerbTypes, true);
// if the "verb name" is actually a verb-type, try run any verb of that type.
var verbType = Verb.VerbTypes.FirstOrDefault(x => x.Name == verbName);
var verb = verbs.FirstOrDefault(v => v.GetType() == verbType);
if (verb != null)
{
- verbSystem.ExecuteVerb(verb, playerEntity.Value, target, forced: true);
+ verbSystem.ExecuteVerb(verb, playerEntity.Value, target.Value, forced: true);
shell.WriteLine(Loc.GetString("invoke-verb-command-success", ("verb", verbName), ("target", target), ("player", playerEntity)));
return;
}
{
if (verb.Text.ToLowerInvariant() == verbName)
{
- verbSystem.ExecuteVerb(verb, playerEntity.Value, target, forced: true);
+ verbSystem.ExecuteVerb(verb, playerEntity.Value, target.Value, forced: true);
shell.WriteLine(Loc.GetString("invoke-verb-command-success", ("verb", verb.Text), ("target", target), ("player", playerEntity)));
return;
}
[AdminCommand(AdminFlags.Admin)]
public sealed class ListVerbsCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _entManager = default!;
+
public string Command => "listverbs";
public string Description => Loc.GetString("list-verbs-command-description");
public string Help => Loc.GetString("list-verbs-command-help");
return;
}
- var entityManager = IoCManager.Resolve<IEntityManager>();
- var verbSystem = EntitySystem.Get<SharedVerbSystem>();
+ var verbSystem = _entManager.System<SharedVerbSystem>();
// get the 'player' entity (defaulting to command user, otherwise uses a uid)
EntityUid? playerEntity = null;
+
if (!int.TryParse(args[0], out var intPlayerUid))
{
if (args[0] == "self" && shell.Player?.AttachedEntity != null)
return;
}
}
- else
- {
- entityManager.EntityExists(new EntityUid(intPlayerUid));
- }
// gets the target entity
if (!int.TryParse(args[1], out var intUid))
return;
}
- var target = new EntityUid(intUid);
- if (!entityManager.EntityExists(target))
+ var targetNet = new NetEntity(intUid);
+
+ if (!_entManager.TryGetEntity(targetNet, out var target))
{
shell.WriteError(Loc.GetString("list-verbs-command-invalid-target-entity"));
return;
}
- var verbs = verbSystem.GetLocalVerbs(target, playerEntity.Value, Verb.VerbTypes);
+ var verbs = verbSystem.GetLocalVerbs(target.Value, playerEntity.Value, Verb.VerbTypes);
foreach (var verb in verbs)
{
component.AnalyzerEntity = null;
}
- UpdateUserInterface(uid, component);
+ // TODO: Yeah this comp relies upon event ordering so we get this for now.
+ if (!TerminatingOrDeleted(uid))
+ UpdateUserInterface(uid, component);
}
private void UpdateUserInterface(EntityUid uid, AnalysisConsoleComponent? component = null)
var temp = (object) comp;
_serialization.CopyTo(entry.Component, ref temp);
- EntityManager.AddComponent(uid, (Component) temp!, true);
+ EntityManager.AddComponent(uid, (Component) temp!);
}
node.Discovered = true;
comp.Owner = uid;
var temp = (object) comp;
_serialization.CopyTo(entry, ref temp);
- EntityManager.AddComponent(uid, (Component) temp!, true);
+ EntityManager.AddComponent(uid, (Component) temp!);
continue;
}
var pulse = EnsureComp<AnomalyPulsingComponent>(uid);
pulse.EndTime = Timing.CurTime + pulse.PulseDuration;
Appearance.SetData(uid, AnomalyVisuals.IsPulsing, true);
-
+
var ev = new AnomalyPulseEvent(uid, component.Stability, component.Severity);
RaiseLocalEvent(uid, ref ev, true);
}
using Content.Shared.Damage;
-using Content.Shared.Damage.Prototypes;
using Robust.Shared.Audio;
using Robust.Shared.Containers;
using Content.Shared.ActionBlocker;
-using Content.Shared.Buckle.Components;
using Content.Shared.Movement.Events;
using Content.Shared.StepTrigger.Systems;
using Robust.Shared.Network;
-using Robust.Shared.Physics.Components;
using Robust.Shared.Timing;
namespace Content.Shared.Chasm;
-using System.Numerics;
using Content.Shared.ActionBlocker;
using Content.Shared.Body.Components;
using Content.Shared.Body.Part;
using Content.Shared.IdentityManagement;
using Content.Shared.Interaction;
using Content.Shared.Movement.Events;
-using Content.Shared.Movement.Systems;
using Content.Shared.Physics;
using Content.Shared.Popups;
using Content.Shared.Stunnable;
/// </summary>
public void RemoveItemSlot(EntityUid uid, ItemSlot slot, ItemSlotsComponent? itemSlots = null)
{
- if (Terminating(uid) || slot.ContainerSlot == null)
+ if (TerminatingOrDeleted(uid) || slot.ContainerSlot == null)
return;
slot.ContainerSlot.Shutdown();
using Content.Shared.Administration.Components;
using Content.Shared.Administration.Logs;
using Content.Shared.Alert;
-using Content.Shared.Atmos.Piping.Unary.Components;
using Content.Shared.Buckle.Components;
using Content.Shared.Cuffs.Components;
using Content.Shared.Damage;
using Robust.Shared.Containers;
using Robust.Shared.Network;
using Robust.Shared.Player;
-using Robust.Shared.Prototypes;
using Robust.Shared.Timing;
namespace Content.Shared.Inventory;
[Dependency] private readonly SharedPopupSystem _popup = default!;
[Dependency] private readonly MovementSpeedModifierSystem _movementSpeed = default!;
[Dependency] private readonly SharedInteractionSystem _interactionSystem = default!;
- [Dependency] private readonly SharedItemSystem _item = default!;
[Dependency] private readonly SharedContainerSystem _containerSystem = default!;
[Dependency] private readonly SharedHandsSystem _handsSystem = default!;
+ [Dependency] private readonly SharedItemSystem _item = default!;
[Dependency] private readonly IGameTiming _gameTiming = default!;
[Dependency] private readonly INetManager _netMan = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
lockComp.Locked = true;
_appearanceSystem.SetData(uid, StorageVisuals.Locked, true);
- Dirty(lockComp);
+ Dirty(uid, lockComp);
var ev = new LockToggledEvent(true);
RaiseLocalEvent(uid, ref ev, true);
lockComp.Locked = false;
_appearanceSystem.SetData(uid, StorageVisuals.Locked, false);
- Dirty(lockComp);
+ Dirty(uid, lockComp);
var ev = new LockToggledEvent(false);
RaiseLocalEvent(uid, ref ev, true);
-using Content.Shared.Mech;
using Content.Shared.Mech.Equipment.Components;
-using Content.Shared.Mech.Equipment.Systems;
using Content.Shared.Timing;
-using Robust.Shared.Audio;
using System.Linq;
namespace Content.Shared.Mech.Equipment.Systems;
using Content.Shared.RCD.Components;
using Content.Shared.Tag;
using Content.Shared.Tiles;
-using Robust.Shared.Audio;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Network;
using Content.Shared.Interaction;
using Content.Shared.Popups;
using Content.Shared.Radio.Components;
-using Content.Shared.Tools;
using Content.Shared.Tools.Components;
using Content.Shared.Wires;
using Robust.Shared.Containers;
using Robust.Shared.Map;
using Robust.Shared.Network;
using Robust.Shared.Physics;
-using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Systems;
-using Robust.Shared.Prototypes;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
using Content.Shared.ActionBlocker;
using Content.Shared.Administration.Logs;
-using Content.Shared.Audio;
-using Content.Shared.DragDrop;
using Content.Shared.Interaction;
using Content.Shared.Interaction.Events;
using Content.Shared.Inventory.Events;
using Content.Shared.Hands;
using Content.Shared.Mobs;
using Content.Shared.Mobs.Components;
-using Content.Shared.Mobs.Systems;
using Content.Shared.Movement.Events;
using Content.Shared.Movement.Systems;
using Content.Shared.Standing;
using Content.Shared.StatusEffect;
using Content.Shared.Throwing;
-using Robust.Shared.Audio;
-using Robust.Shared.GameStates;
-using Robust.Shared.Player;
namespace Content.Shared.Stunnable;
using Content.Shared.Examine;
using Content.Shared.Weapons.Ranged.Components;
using Robust.Shared.Network;
-using Robust.Shared.Player;
using Robust.Shared.Timing;
-using Robust.Shared.Utility;
namespace Content.Shared.Weapons.Ranged.Systems;
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Robust.Serialization.Generator", "RobustToolbox\Robust.Serialization.Generator\Robust.Serialization.Generator.csproj", "{6FBF108E-5CB5-47DE-8D7E-B496ABA9E3E2}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Content.PatreonParser", "Content.PatreonParser\Content.PatreonParser.csproj", "{D97D8258-D915-4D1D-B1E3-1A8D00CF9EB5}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Arch", "RobustToolbox\Arch\Arch.csproj", "{FCF7C99C-EC56-4DF4-A101-8C42E8EDB6EE}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Arch.SourceGen", "RobustToolbox\Arch\Arch\src\Arch.SourceGen\Arch.SourceGen.csproj", "{6EA70D29-EE1B-431B-A396-294CBD52D2D4}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
{D97D8258-D915-4D1D-B1E3-1A8D00CF9EB5}.DebugOpt|Any CPU.Build.0 = Debug|Any CPU
{D97D8258-D915-4D1D-B1E3-1A8D00CF9EB5}.Tools|Any CPU.ActiveCfg = Debug|Any CPU
{D97D8258-D915-4D1D-B1E3-1A8D00CF9EB5}.Tools|Any CPU.Build.0 = Debug|Any CPU
+ {FCF7C99C-EC56-4DF4-A101-8C42E8EDB6EE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {FCF7C99C-EC56-4DF4-A101-8C42E8EDB6EE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {FCF7C99C-EC56-4DF4-A101-8C42E8EDB6EE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {FCF7C99C-EC56-4DF4-A101-8C42E8EDB6EE}.Release|Any CPU.Build.0 = Release|Any CPU
+ {FCF7C99C-EC56-4DF4-A101-8C42E8EDB6EE}.DebugOpt|Any CPU.ActiveCfg = Debug|Any CPU
+ {FCF7C99C-EC56-4DF4-A101-8C42E8EDB6EE}.DebugOpt|Any CPU.Build.0 = Debug|Any CPU
+ {FCF7C99C-EC56-4DF4-A101-8C42E8EDB6EE}.Tools|Any CPU.ActiveCfg = Debug|Any CPU
+ {FCF7C99C-EC56-4DF4-A101-8C42E8EDB6EE}.Tools|Any CPU.Build.0 = Debug|Any CPU
+ {6EA70D29-EE1B-431B-A396-294CBD52D2D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {6EA70D29-EE1B-431B-A396-294CBD52D2D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {6EA70D29-EE1B-431B-A396-294CBD52D2D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {6EA70D29-EE1B-431B-A396-294CBD52D2D4}.Release|Any CPU.Build.0 = Release|Any CPU
+ {6EA70D29-EE1B-431B-A396-294CBD52D2D4}.DebugOpt|Any CPU.ActiveCfg = Debug|Any CPU
+ {6EA70D29-EE1B-431B-A396-294CBD52D2D4}.DebugOpt|Any CPU.Build.0 = Debug|Any CPU
+ {6EA70D29-EE1B-431B-A396-294CBD52D2D4}.Tools|Any CPU.ActiveCfg = Debug|Any CPU
+ {6EA70D29-EE1B-431B-A396-294CBD52D2D4}.Tools|Any CPU.Build.0 = Debug|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
{A965CB3B-FD31-44AF-8872-85ABA436098D} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
{07CA34A1-1D37-4771-A2E3-495A1044AE0B} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
{6FBF108E-5CB5-47DE-8D7E-B496ABA9E3E2} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
+ {FCF7C99C-EC56-4DF4-A101-8C42E8EDB6EE} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
+ {6EA70D29-EE1B-431B-A396-294CBD52D2D4} = {83B4CBBA-547A-42F0-A7CD-8A67D93196CE}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {AA37ED9F-F8D6-468E-A101-658AD605B09A}
projects / space-station-14.git / commitdiff