{
[Dependency] private readonly AnimationPlayerSystem _animations = default!;
[Dependency] private readonly MetaDataSystem _metaData = default!;
+ [Dependency] private readonly SpriteSystem _sprite = default!;
[Dependency] private readonly TransformSystem _transform = default!;
public override void Initialize()
}
var sprite = Comp<SpriteComponent>(animatableClone);
- sprite.CopyFrom(sprite0);
- sprite.Visible = true;
+ _sprite.CopySprite((uid, sprite0), (animatableClone, sprite));
+ _sprite.SetVisible((animatableClone, sprite), true);
var animations = Comp<AnimationPlayerComponent>(animatableClone);
public sealed class PillSystem : EntitySystem
{
+ [Dependency] private readonly SpriteSystem _sprite = default!;
+
public override void Initialize()
{
base.Initialize();
if (!TryComp(uid, out SpriteComponent? sprite))
return;
- if (!sprite.TryGetLayer(0, out var layer))
+ if (!_sprite.TryGetLayer((uid, sprite), 0, out var layer, false))
return;
- layer.SetState($"pill{component.PillType + 1}");
+ _sprite.LayerSetRsiState(layer, $"pill{component.PillType + 1}");
}
}
{
if (args.Sprite == null)
return;
- if(!AppearanceSystem.TryGetData<Color>(uid, SmokeVisuals.Color, out var color))
+ if (!AppearanceSystem.TryGetData<Color>(uid, SmokeVisuals.Color, out var color))
return;
- args.Sprite.Color = color;
+ SpriteSystem.SetColor((uid, args.Sprite), color);
}
}
{
if (AppearanceSystem.TryGetData<Color>(uid, VaporVisuals.Color, out var color, args.Component) && args.Sprite != null)
{
- args.Sprite.Color = color;
+ SpriteSystem.SetColor((uid, args.Sprite), color);
}
}
}
drawDepth = sprite.DrawDepth;
renderOrder = sprite.RenderOrder;
var (spritePos, spriteRot) = _transforms.GetWorldPositionRotation(transform);
- var spriteBB = sprite.CalculateRotatedBoundingBox(spritePos, spriteRot, eye.Rotation);
+ var spriteBB = _sprites.CalculateBounds((entity.Owner, sprite), spritePos, spriteRot, eye.Rotation);
bottom = Matrix3Helpers.CreateRotation(eye.Rotation).TransformBox(spriteBB).Bottom;
- Matrix3x2.Invert(sprite.GetLocalMatrix(), out var invSpriteMatrix);
+ Matrix3x2.Invert(sprite.LocalMatrix, out var invSpriteMatrix);
// This should have been the rotation of the sprite relative to the screen, but this is not the case with no-rot or directional sprites.
var relativeRotation = (spriteRot + eye.Rotation).Reduced().FlipPositive();
if (layer.Texture != null)
{
// Convert to image coordinates
- var imagePos = (Vector2i) (localPos * EyeManager.PixelsPerMeter * new Vector2(1, -1) + layer.Texture.Size / 2f);
+ var imagePos = (Vector2i)(localPos * EyeManager.PixelsPerMeter * new Vector2(1, -1) + layer.Texture.Size / 2f);
if (_clickMapManager.IsOccluding(layer.Texture, imagePos))
return true;
var layerLocal = Vector2.Transform(localPos, inverseMatrix);
// Convert to image coordinates
- var layerImagePos = (Vector2i) (layerLocal * EyeManager.PixelsPerMeter * new Vector2(1, -1) + rsiState.Size / 2f);
+ var layerImagePos = (Vector2i)(layerLocal * EyeManager.PixelsPerMeter * new Vector2(1, -1) + rsiState.Size / 2f);
// Next, to get the right click map we need the "direction" of this layer that is actually being used to draw the sprite on the screen.
// This **can** differ from the dir defined before, but can also just be the same.
public override void Execute(IConsoleShell shell, string argStr, string[] args)
{
var containerSys = _entityManager.System<SharedContainerSystem>();
- var query = _entityManager.AllEntityQueryEnumerator<OrganComponent>();
+ var spriteSys = _entityManager.System<SpriteSystem>();
+ var query = _entityManager.AllEntityQueryEnumerator<OrganComponent, SpriteComponent>();
- while (query.MoveNext(out var uid, out _))
+ while (query.MoveNext(out var uid, out _, out var sprite))
{
- if (!_entityManager.TryGetComponent(uid, out SpriteComponent? sprite))
- {
- continue;
- }
-
- sprite.ContainerOccluded = false;
+ spriteSys.SetContainerOccluded((uid, sprite), false);
var tempParent = uid;
while (containerSys.TryGetContainingContainer((tempParent, null, null), out var container))
{
if (!container.ShowContents)
{
- sprite.ContainerOccluded = true;
+ spriteSys.SetContainerOccluded((uid, sprite), true);
break;
}
public override void Execute(IConsoleShell shell, string argStr, string[] args)
{
+ var spriteSys = _entManager.System<SpriteSystem>();
var query = _entManager.AllEntityQueryEnumerator<OrganComponent, SpriteComponent>();
- while (query.MoveNext(out _, out var sprite))
+ while (query.MoveNext(out var uid, out _, out var sprite))
{
- sprite.ContainerOccluded = false;
+ spriteSys.SetContainerOccluded((uid, sprite), false);
}
}
}
public sealed class DiceSystem : SharedDiceSystem
{
+ [Dependency] private readonly SpriteSystem _sprite = default!;
+
public override void Initialize()
{
base.Initialize();
return;
// TODO maybe just move each die to its own RSI?
- var state = sprite.LayerGetState(0).Name;
+ var state = _sprite.LayerGetRsiState((entity.Owner, sprite), 0).Name;
if (state == null)
return;
var prefix = state.Substring(0, state.IndexOf('_'));
- sprite.LayerSetState(0, $"{prefix}_{entity.Comp.CurrentValue}");
+ _sprite.LayerSetRsiState((entity.Owner, sprite), 0, $"{prefix}_{entity.Comp.CurrentValue}");
}
}
private readonly MetaDataSystem _meta;
private readonly ProgressColorSystem _progressColor;
private readonly SharedContainerSystem _container;
+ private readonly SpriteSystem _sprite;
private readonly Texture _barTexture;
private readonly ShaderInstance _unshadedShader;
_meta = _entManager.EntitySysManager.GetEntitySystem<MetaDataSystem>();
_container = _entManager.EntitySysManager.GetEntitySystem<SharedContainerSystem>();
_progressColor = _entManager.System<ProgressColorSystem>();
+ _sprite = _entManager.System<SpriteSystem>();
var sprite = new SpriteSpecifier.Rsi(new("/Textures/Interface/Misc/progress_bar.rsi"), "icon");
_barTexture = _entManager.EntitySysManager.GetEntitySystem<SpriteSystem>().Frame0(sprite);
// Use the sprite itself if we know its bounds. This means short or tall sprites don't get overlapped
// by the bar.
- float yOffset = sprite.Bounds.Height / 2f + 0.05f;
+ var yOffset = _sprite.GetLocalBounds((uid, sprite)).Height / 2f + 0.05f;
// Position above the entity (we've already applied the matrix transform to the entity itself)
// Offset by the texture size for every do_after we have.
if (doAfter.CancelledTime != null)
{
var elapsed = doAfter.CancelledTime.Value - doAfter.StartTime;
- elapsedRatio = (float) Math.Min(1, elapsed.TotalSeconds / doAfter.Args.Delay.TotalSeconds);
+ elapsedRatio = (float)Math.Min(1, elapsed.TotalSeconds / doAfter.Args.Delay.TotalSeconds);
var cancelElapsed = (time - doAfter.CancelledTime.Value).TotalSeconds;
var flash = Math.Floor(cancelElapsed / FlashTime) % 2 == 0;
color = GetProgressColor(0, flash ? alpha : 0);
else
{
var elapsed = time - doAfter.StartTime;
- elapsedRatio = (float) Math.Min(1, elapsed.TotalSeconds / doAfter.Args.Delay.TotalSeconds);
+ elapsedRatio = (float)Math.Min(1, elapsed.TotalSeconds / doAfter.Args.Delay.TotalSeconds);
color = GetProgressColor(elapsedRatio, alpha);
}
{
[Dependency] private readonly IGameTiming _timing = default!;
[Dependency] private readonly AnimationPlayerSystem _animation = default!;
+ [Dependency] private readonly SpriteSystem _sprite = default!;
/// <summary>
/// It's a little on the long side but given we use multiple colours denoting what happened it makes it easier to register.
if (TryComp<SpriteComponent>(uid, out var sprite))
{
- sprite.Color = component.Color;
+ _sprite.SetColor((uid, sprite), component.Color);
}
}
{
[Dependency] private readonly IResourceCache _rescache = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+ [Dependency] private readonly SpriteSystem _sprite = default!;
/// <inheritdoc/>
public override void Initialize()
var path = SpriteSpecifierSerializer.TextureRoot / rsistring;
if (_rescache.TryGetResource(path, out RSIResource? rsi))
- args.Sprite.BaseRSI = rsi.RSI;
+ _sprite.SetBaseRsi((ent.Owner, args.Sprite), rsi.RSI);
}
}
private readonly MobStateSystem _mobStateSystem;
private readonly MobThresholdSystem _mobThresholdSystem;
private readonly StatusIconSystem _statusIconSystem;
+ private readonly SpriteSystem _spriteSystem;
private readonly ProgressColorSystem _progressColor;
_mobStateSystem = _entManager.System<MobStateSystem>();
_mobThresholdSystem = _entManager.System<MobThresholdSystem>();
_statusIconSystem = _entManager.System<StatusIconSystem>();
+ _spriteSystem = _entManager.System<SpriteSystem>();
_progressColor = _entManager.System<ProgressColorSystem>();
}
continue;
// we use the status icon component bounds if specified otherwise use sprite
- var bounds = _entManager.GetComponentOrNull<StatusIconComponent>(uid)?.Bounds ?? spriteComponent.Bounds;
+ var bounds = _entManager.GetComponentOrNull<StatusIconComponent>(uid)?.Bounds ?? _spriteSystem.GetLocalBounds((uid, spriteComponent));
var worldPos = _transform.GetWorldPosition(xform, xformQuery);
if (!bounds.Translated(worldPos).Intersects(args.WorldAABB))
!_mobThresholdSystem.TryGetThresholdForState(uid, MobState.Dead, out threshold, thresholds))
return (1, false);
- var ratio = 1 - ((FixedPoint2) (dmg.TotalDamage / threshold)).Float();
+ var ratio = 1 - ((FixedPoint2)(dmg.TotalDamage / threshold)).Float();
return (ratio, false);
}
public sealed partial class PointingSystem : SharedPointingSystem
{
+ [Dependency] private readonly SpriteSystem _sprite = default!;
+
public override void Initialize()
{
base.Initialize();
Verb verb = new()
{
Text = Loc.GetString("pointing-verb-get-data-text"),
- Icon = new SpriteSpecifier.Texture(new ("/Textures/Interface/VerbIcons/point.svg.192dpi.png")),
+ Icon = new SpriteSpecifier.Texture(new("/Textures/Interface/VerbIcons/point.svg.192dpi.png")),
ClientExclusive = true,
Act = () => RaiseNetworkEvent(new PointingAttemptEvent(GetNetEntity(args.Target)))
};
private void OnArrowStartup(EntityUid uid, PointingArrowComponent component, ComponentStartup args)
{
if (TryComp<SpriteComponent>(uid, out var sprite))
- sprite.DrawDepth = (int) DrawDepth.Overlays;
+ _sprite.SetDrawDepth((uid, sprite), (int)DrawDepth.Overlays);
BeginPointAnimation(uid, component.StartPosition, component.Offset, component.AnimationKey);
}
{
if (TryComp<SpriteComponent>(uid, out var sprite))
{
- sprite.DrawDepth = (int) DrawDepth.Overlays;
+ _sprite.SetDrawDepth((uid, sprite), (int)DrawDepth.Overlays);
sprite.NoRotation = false;
}
}
using Content.Shared.Projectiles;
-using Robust.Shared.Spawners;
using Content.Shared.Weapons.Ranged.Systems;
using Robust.Client.Animations;
using Robust.Client.GameObjects;
-using Robust.Shared.GameStates;
using TimedDespawnComponent = Robust.Shared.Spawners.TimedDespawnComponent;
namespace Content.Client.Projectiles;
public sealed class ProjectileSystem : SharedProjectileSystem
{
[Dependency] private readonly AnimationPlayerSystem _player = default!;
+ [Dependency] private readonly SpriteSystem _sprite = default!;
public override void Initialize()
{
if (TryComp<SpriteComponent>(ent, out var sprite))
{
sprite[EffectLayers.Unshaded].AutoAnimated = false;
- sprite.LayerMapTryGet(EffectLayers.Unshaded, out var layer);
- var state = sprite.LayerGetState(layer);
+ _sprite.LayerMapTryGet((ent, sprite), EffectLayers.Unshaded, out var layer, false);
+ var state = _sprite.LayerGetRsiState((ent, sprite), layer);
var lifetime = 0.5f;
if (TryComp<TimedDespawnComponent>(ent, out var despawn))
using System.Numerics;
using Content.Shared.Salvage.Fulton;
-using Robust.Shared.Spawners;
using JetBrains.Annotations;
using Robust.Client.Animations;
using Robust.Client.GameObjects;
using Robust.Client.Graphics;
-using Robust.Shared.Animations;
using Robust.Shared.Serialization.Manager;
using Robust.Shared.Utility;
using TimedDespawnComponent = Robust.Shared.Spawners.TimedDespawnComponent;
{
[Dependency] private readonly ISerializationManager _serManager = default!;
[Dependency] private readonly AnimationPlayerSystem _player = default!;
+ [Dependency] private readonly SpriteSystem _sprite = default!;
private static readonly TimeSpan AnimationDuration = TimeSpan.FromSeconds(0.4);
}
sprite.NoRotation = true;
- var effectLayer = sprite.AddLayer(new SpriteSpecifier.Rsi(new ResPath("Objects/Tools/fulton_balloon.rsi"), "fulton_balloon"));
- sprite.LayerSetOffset(effectLayer, EffectOffset + new Vector2(0f, 0.5f));
+ var effectLayer = _sprite.AddLayer((animationEnt, sprite), new SpriteSpecifier.Rsi(new ResPath("Objects/Tools/fulton_balloon.rsi"), "fulton_balloon"));
+ _sprite.LayerSetOffset((animationEnt, sprite), effectLayer, EffectOffset + new Vector2(0f, 0.5f));
var despawn = AddComp<TimedDespawnComponent>(animationEnt);
despawn.Lifetime = 1.5f;
{
[Dependency] private readonly IPrototypeManager _protoMan = default!;
[Dependency] private readonly SharedTransformSystem _transformSystem = default!;
+ [Dependency] private readonly SpriteSystem _sprite = default!;
private ShaderInstance _shader = default!;
if (!Resolve(uid, ref component, ref sprite, false))
return;
- sprite.Color = Color.White;
+ _sprite.SetColor((uid, sprite), Color.White);
sprite.PostShader = enabled ? _shader : null;
sprite.GetScreenTexture = enabled;
sprite.RaiseShaderEvent = enabled;
_shader.SetParameter("visibility", visibility);
visibility = MathF.Max(0, visibility);
- args.Sprite.Color = new Color(visibility, visibility, 1, 1);
+ _sprite.SetColor((uid, args.Sprite), new Color(visibility, visibility, 1, 1));
}
}
return;
var drawDepth = isStuck ? comp.StuckDrawDepth : comp.OriginalDrawDepth;
- args.Sprite.DrawDepth = drawDepth;
+ SpriteSystem.SetDrawDepth((uid, args.Sprite), drawDepth);
}
}
using Robust.Client.Animations;
using Robust.Client.GameObjects;
using Robust.Client.Player;
-using Robust.Shared.Map;
using Robust.Shared.Timing;
namespace Content.Client.SubFloor;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
[Dependency] private readonly SharedHandsSystem _hands = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
+ [Dependency] private readonly SpriteSystem _sprite = default!;
[Dependency] private readonly TrayScanRevealSystem _trayScanReveal = default!;
private const string TRayAnimationKey = "trays";
if ((!_appearance.TryGetData(uid, SubFloorVisuals.ScannerRevealed, out bool value) || !value) &&
sprite.Color.A > SubfloorRevealAlpha)
{
- sprite.Color = sprite.Color.WithAlpha(0f);
+ _sprite.SetColor((uid, sprite), sprite.Color.WithAlpha(0f));
}
SetRevealed(uid, true);
{
SetRevealed(uid, false);
RemCompDeferred<TrayRevealedComponent>(uid);
- sprite.Color = sprite.Color.WithAlpha(1f);
+ _sprite.SetColor((uid, sprite), sprite.Color.WithAlpha(1f));
continue;
}
[Dependency] private readonly IGameTiming _gameTiming = default!;
[Dependency] private readonly AppearanceSystem _appearance = default!;
[Dependency] private readonly SharedTransformSystem _transformSystem = default!;
+ [Dependency] private readonly SpriteSystem _sprite = default!;
// Time in seconds to wait until sending the location of a dragged entity to the server again
private const float Delay = 1f / 10; // 10 Hz
// the appearance handle the rest
if (_appearance.TryGetData<Vector2>(uid, TabletopItemVisuals.Scale, out var scale, args.Component))
{
- args.Sprite.Scale = scale;
+ _sprite.SetScale((uid, args.Sprite), scale);
}
if (_appearance.TryGetData<int>(uid, TabletopItemVisuals.DrawDepth, out var drawDepth, args.Component))
{
- args.Sprite.DrawDepth = drawDepth;
+ _sprite.SetDrawDepth((uid, args.Sprite), drawDepth);
}
}
if (eye == null)
return MapCoordinates.Nullspace;
- var size = (Vector2) viewport.ViewportSize / EyeManager.PixelsPerMeter; // Convert to tiles instead of pixels
+ var size = (Vector2)viewport.ViewportSize / EyeManager.PixelsPerMeter; // Convert to tiles instead of pixels
var eyePosition = eye.Position.Position;
var eyeRotation = eye.Rotation;
var eyeScale = eye.Scale;
using Robust.Shared.Input;
using Robust.Shared.Input.Binding;
using Robust.Shared.Map;
-using Robust.Shared.Player;
using Robust.Shared.Utility;
using static Content.Client.Inventory.ClientInventorySystem;
[UISystemDependency] private readonly ClientInventorySystem _inventorySystem = default!;
[UISystemDependency] private readonly HandsSystem _handsSystem = default!;
[UISystemDependency] private readonly ContainerSystem _container = default!;
+ [UISystemDependency] private readonly SpriteSystem _sprite = default!;
private EntityUid? _playerUid;
private InventorySlotsComponent? _playerInventory;
}
}
- hoverSprite.CopyFrom(sprite);
- hoverSprite.Color = fits ? new Color(0, 255, 0, 127) : new Color(255, 0, 0, 127);
+ _sprite.CopySprite((held, sprite), (hoverEntity, hoverSprite));
+ _sprite.SetColor((hoverEntity, hoverSprite), fits ? new Color(0, 255, 0, 127) : new Color(255, 0, 0, 127));
control.HoverSpriteView.SetEntity(hoverEntity);
}
projects / space-station-14.git / commitdiff