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

Merge remote-tracking branch 'upstream/master' into ups

Browse Source
This commit is contained in:
Jabak
2024-07-20 18:45:46 +03:00
parent a5e3d2bfa1 b16052f0ab
commit 06405f8c62
186 changed files with 1524 additions and 331 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Content.Client/Gameplay/GameplayStateBase.cs
View File

@@ -2,6 +2,7 @@ using System.Linq;
using System.Numerics;
using Content.Client.Clickable;
using Content.Client.UserInterface;
using Content.Shared.Damage;
using Content.Shared.Input;
using Robust.Client.ComponentTrees;
using Robust.Client.GameObjects;
@@ -102,6 +103,13 @@ namespace Content.Client.Gameplay
return first.IsValid() ? first : null;
}
public EntityUid? GetDamageableClickedEntity(MapCoordinates coordinates) // WD
{
var first = GetClickableEntities(coordinates)
.FirstOrDefault(e => _entityManager.HasComponent<DamageableComponent>(e));
return first.IsValid() ? first : null;
}
public IEnumerable<EntityUid> GetClickableEntities(EntityCoordinates coordinates)
{
return GetClickableEntities(coordinates.ToMap(_entityManager, _entitySystemManager.GetEntitySystem<SharedTransformSystem>()));

4
Content.Client/Weapons/Melee/MeleeWeaponSystem.cs
View File

@@ -121,7 +121,7 @@ public sealed partial class MeleeWeaponSystem : SharedMeleeWeaponSystem
if (_stateManager.CurrentState is GameplayStateBase screen)
{
target = screen.GetClickedEntity(mousePos);
target = screen.GetDamageableClickedEntity(mousePos); // WD EDIT
}
EntityManager.RaisePredictiveEvent(new DisarmAttackEvent(GetNetEntity(target), GetNetCoordinates(coordinates)));
@@ -169,7 +169,7 @@ public sealed partial class MeleeWeaponSystem : SharedMeleeWeaponSystem
if (_stateManager.CurrentState is GameplayStateBase screen)
{
target = screen.GetClickedEntity(mousePos);
target = screen.GetDamageableClickedEntity(mousePos); // WD EDIT
}
// Don't light-attack if interaction will be handling this instead

2
Content.Client/Weapons/Ranged/Systems/GunSystem.cs
View File

@@ -190,7 +190,7 @@ public sealed partial class GunSystem : SharedGunSystem
EntityUid? shootingTarget = null;
if (_state.CurrentState is GameplayStateBase screen)
shootingTarget = screen.GetClickedEntity(mousePos);
shootingTarget = screen.GetDamageableClickedEntity(mousePos);
EntityManager.RaisePredictiveEvent(new RequestShootEvent
{

37
Content.Client/_White/Overlays/NightVisionOverlay.cs
View File

@@ -31,23 +31,28 @@ namespace Content.Client._White.Overlays
var handle = args.WorldHandle;
if (_playerManager.LocalEntity == null)
return;
var uid = _playerManager.LocalEntity.Value;
Color? color = null;
if (_entityManager.TryGetComponent<NightVisionComponent>(_playerManager.LocalSession?.AttachedEntity,
out var component) && component.IsActive)
if (_entityManager.TryGetComponent<NightVisionComponent>(uid, out var component) && component.IsActive)
{
_shader.SetParameter("tint", component.Tint);
_shader.SetParameter("luminance_threshold", component.Strength);
_shader.SetParameter("noise_amount", component.Noise);
color = component.Color;
color = SetParameters(component);
}
else if (_entityManager.TryGetComponent<TemporaryNightVisionComponent>(
_playerManager.LocalSession?.AttachedEntity, out var tempNvComp))
else if (_entityManager.TryGetComponent<ThermalVisionComponent>(uid, out var thermal) && thermal.IsActive)
{
_shader.SetParameter("tint", tempNvComp.Tint);
_shader.SetParameter("luminance_threshold", tempNvComp.Strength);
_shader.SetParameter("noise_amount", tempNvComp.Noise);
color = tempNvComp.Color;
color = SetParameters(thermal);
}
else if (_entityManager.TryGetComponent<TemporaryNightVisionComponent>(uid, out var tempNvComp))
{
color = SetParameters(tempNvComp);
}
else if (_entityManager.TryGetComponent<TemporaryThermalVisionComponent>(uid, out var tempThermal))
{
color = SetParameters(tempThermal);
}
if (color == null)
@@ -59,5 +64,13 @@ namespace Content.Client._White.Overlays
handle.DrawRect(args.WorldBounds, color.Value);
handle.UseShader(null);
}
private Color SetParameters(BaseNvOverlayComponent component)
{
_shader.SetParameter("tint", component.Tint);
_shader.SetParameter("luminance_threshold", component.Strength);
_shader.SetParameter("noise_amount", component.Noise);
return component.Color;
}
}
}

18
Content.Client/_White/Overlays/NightVisionSystem.cs
View File

@@ -72,6 +72,7 @@ public sealed class NightVisionSystem : SharedNightVisionSystem
if (_player.LocalSession != player)
return;
UpdateOverlay(active);
UpdateNightVision(active);
}
@@ -80,16 +81,31 @@ public sealed class NightVisionSystem : SharedNightVisionSystem
if (_player.LocalSession?.AttachedEntity != uid)
return;
UpdateOverlay(active);
UpdateNightVision(active);
}
private void UpdateNightVision(bool active)
public void UpdateOverlay(bool active)
{
if (_player.LocalEntity == null)
{
_overlayMan.RemoveOverlay(_overlay);
return;
}
var uid = _player.LocalEntity.Value;
active |= TryComp<NightVisionComponent>(uid, out var nv) && nv.IsActive ||
TryComp<ThermalVisionComponent>(uid, out var thermal) && thermal.IsActive ||
HasComp<TemporaryNightVisionComponent>(uid) ||
HasComp<TemporaryThermalVisionComponent>(uid);
if (active)
_overlayMan.AddOverlay(_overlay);
else
_overlayMan.RemoveOverlay(_overlay);
}
private void UpdateNightVision(bool active)
{
_lightManager.DrawLighting = !active;
}

103
Content.Client/_White/Overlays/ThermalVisionOverlay.cs Normal file
View File

@@ -0,0 +1,103 @@
using System.Linq;
using System.Numerics;
using Content.Shared._White.Overlays;
using Content.Shared.Body.Components;
using Robust.Client.GameObjects;
using Robust.Client.Graphics;
using Robust.Client.Player;
using Robust.Shared.Enums;
using Robust.Shared.Map;
namespace Content.Client._White.Overlays;
public sealed class ThermalVisionOverlay : Overlay
{
[Dependency] private readonly IEntityManager _entity = default!;
[Dependency] private readonly IPlayerManager _players = default!;
private readonly ContainerSystem _container;
private readonly TransformSystem _transform;
private readonly OccluderSystem _occluder;
public override OverlaySpace Space => OverlaySpace.WorldSpace;
private readonly List<NightVisionRenderEntry> _entries = new();
public ThermalVisionOverlay()
{
IoCManager.InjectDependencies(this);
_container = _entity.System<ContainerSystem>();
_transform = _entity.System<TransformSystem>();
_occluder = _entity.System<OccluderSystem>();
ZIndex = -1;
}
protected override void Draw(in OverlayDrawArgs args)
{
if (_players.LocalEntity == null)
return;
var ent = _players.LocalEntity.Value;
if ((!_entity.TryGetComponent(ent, out ThermalVisionComponent? component) || !component.IsActive) &&
!_entity.HasComponent<TemporaryThermalVisionComponent>(ent))
{
return;
}
if (HasOccluders(ent))
return;
var handle = args.WorldHandle;
var eye = args.Viewport.Eye;
var eyeRot = eye?.Rotation ?? default;
_entries.Clear();
var entities = _entity.EntityQueryEnumerator<BodyComponent, SpriteComponent, TransformComponent>();
while (entities.MoveNext(out var uid, out _, out var sprite, out var xform))
{
if (HasOccluders(uid))
continue;
_entries.Add(new NightVisionRenderEntry((uid, sprite, xform),
eye?.Position.MapId,
eyeRot));
}
foreach (var entry in _entries)
{
Render(entry.Ent, entry.Map, handle, entry.EyeRot);
}
handle.SetTransform(Matrix3.Identity);
}
private void Render(Entity<SpriteComponent, TransformComponent> ent,
MapId? map,
DrawingHandleWorld handle,
Angle eyeRot)
{
var (uid, sprite, xform) = ent;
if (xform.MapID != map || _container.IsEntityOrParentInContainer(uid))
return;
var position = _transform.GetWorldPosition(xform);
var rotation = _transform.GetWorldRotation(xform);
sprite.Render(handle, eyeRot, rotation, position: position);
}
private bool HasOccluders(EntityUid ent)
{
var mapCoordinates = _transform.GetMapCoordinates(ent);
var occluders = _occluder.QueryAabb(mapCoordinates.MapId,
Box2.CenteredAround(mapCoordinates.Position, new Vector2(0.4f, 0.4f)));
return occluders.Any(o => o.Component.Enabled);
}
}
public record struct NightVisionRenderEntry(
(EntityUid, SpriteComponent, TransformComponent) Ent,
MapId? Map,
Angle EyeRot);

109
Content.Client/_White/Overlays/ThermalVisionSystem.cs Normal file
View File

@@ -0,0 +1,109 @@
using Content.Shared._Miracle.Systems;
using Content.Shared.GameTicking;
using Content.Shared._White.Overlays;
using Robust.Client.Graphics;
using Robust.Client.Player;
using Robust.Shared.Player;
namespace Content.Client._White.Overlays;
public sealed class ThermalVisionSystem : SharedThermalVisionSystem
{
[Dependency] private readonly IPlayerManager _player = default!;
[Dependency] private readonly IOverlayManager _overlayMan = default!;
[Dependency] private readonly NightVisionSystem _nv = default!;
private ThermalVisionOverlay _overlay = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<ThermalVisionComponent, PlayerAttachedEvent>(OnPlayerAttached);
SubscribeLocalEvent<ThermalVisionComponent, PlayerDetachedEvent>(OnPlayerDetached);
SubscribeLocalEvent<RoundRestartCleanupEvent>(OnRestart);
SubscribeLocalEvent<TemporaryThermalVisionComponent, ComponentInit>(OnTempInit);
SubscribeLocalEvent<TemporaryThermalVisionComponent, ComponentRemove>(OnTempRemove);
SubscribeLocalEvent<TemporaryThermalVisionComponent, PlayerAttachedEvent>(OnTempPlayerAttached);
SubscribeLocalEvent<TemporaryThermalVisionComponent, PlayerDetachedEvent>(OnTempPlayerDetached);
_overlay = new ThermalVisionOverlay();
}
private void OnTempPlayerAttached(Entity<TemporaryThermalVisionComponent> ent, ref PlayerAttachedEvent args)
{
UpdateThermalVision(args.Player, true);
}
private void OnTempPlayerDetached(Entity<TemporaryThermalVisionComponent> ent, ref PlayerDetachedEvent args)
{
UpdateThermalVision(args.Player, false);
}
private void OnTempRemove(Entity<TemporaryThermalVisionComponent> ent, ref ComponentRemove args)
{
if (TryComp(ent, out ThermalVisionComponent? thermalVision) && thermalVision.IsActive)
return;
UpdateThermalVision(ent, false);
}
private void OnTempInit(Entity<TemporaryThermalVisionComponent> ent, ref ComponentInit args)
{
UpdateThermalVision(ent, true);
}
private void OnPlayerAttached(EntityUid uid, ThermalVisionComponent component, PlayerAttachedEvent args)
{
if (!component.IsActive && HasComp<TemporaryThermalVisionComponent>(args.Entity))
return;
UpdateThermalVision(args.Player, component.IsActive);
}
private void OnPlayerDetached(EntityUid uid, ThermalVisionComponent component, PlayerDetachedEvent args)
{
UpdateThermalVision(args.Player, false);
}
private void UpdateThermalVision(ICommonSession player, bool active)
{
if (_player.LocalSession != player)
return;
_nv.UpdateOverlay(active);
UpdateThermalVision(active);
}
protected override void UpdateThermalVision(EntityUid uid, bool active)
{
if (_player.LocalSession?.AttachedEntity != uid)
return;
_nv.UpdateOverlay(active);
UpdateThermalVision(active);
}
public void UpdateThermalVision(bool active)
{
if (_player.LocalEntity == null)
{
_overlayMan.RemoveOverlay(_overlay);
return;
}
var uid = _player.LocalEntity.Value;
active |= TryComp<ThermalVisionComponent>(uid, out var thermal) && thermal.IsActive ||
HasComp<TemporaryThermalVisionComponent>(uid);
if (active)
_overlayMan.AddOverlay(_overlay);
else
_overlayMan.RemoveOverlay(_overlay);
}
private void OnRestart(RoundRestartCleanupEvent ev)
{
_overlayMan.RemoveOverlay(_overlay);
}
}