68ce53ae17
* Use new Subs.CVar helper Removes manual config OnValueChanged calls, removes need to remember to manually unsubscribe. This both reduces boilerplate and fixes many issues where subscriptions weren't removed on entity system shutdown. * Fix a bunch of warnings * More warning fixes * Use new DateTime serializer to get rid of ISerializationHooks in changelog code. * Get rid of some more ISerializationHooks for enums * And a little more * Apply suggestions from code review Co-authored-by: 0x6273 <0x40@keemail.me> --------- Co-authored-by: 0x6273 <0x40@keemail.me>
361 lines
13 KiB
C#
361 lines
13 KiB
C#
using System.Numerics;
|
|
using Content.Client.Items;
|
|
using Content.Client.Weapons.Ranged.Components;
|
|
using Content.Shared.Camera;
|
|
using Content.Shared.CombatMode;
|
|
using Content.Shared.Weapons.Ranged;
|
|
using Content.Shared.Weapons.Ranged.Components;
|
|
using Content.Shared.Weapons.Ranged.Events;
|
|
using Content.Shared.Weapons.Ranged.Systems;
|
|
using Robust.Client.Animations;
|
|
using Robust.Client.GameObjects;
|
|
using Robust.Client.Graphics;
|
|
using Robust.Client.Input;
|
|
using Robust.Client.Player;
|
|
using Robust.Shared.Animations;
|
|
using Robust.Shared.Input;
|
|
using Robust.Shared.Map;
|
|
using Robust.Shared.Prototypes;
|
|
using Robust.Shared.Utility;
|
|
using SharedGunSystem = Content.Shared.Weapons.Ranged.Systems.SharedGunSystem;
|
|
using TimedDespawnComponent = Robust.Shared.Spawners.TimedDespawnComponent;
|
|
|
|
namespace Content.Client.Weapons.Ranged.Systems;
|
|
|
|
public sealed partial class GunSystem : SharedGunSystem
|
|
{
|
|
[Dependency] private readonly IEyeManager _eyeManager = default!;
|
|
[Dependency] private readonly IInputManager _inputManager = default!;
|
|
[Dependency] private readonly IPlayerManager _player = default!;
|
|
[Dependency] private readonly AnimationPlayerSystem _animPlayer = default!;
|
|
[Dependency] private readonly InputSystem _inputSystem = default!;
|
|
[Dependency] private readonly SharedCameraRecoilSystem _recoil = default!;
|
|
[Dependency] private readonly IComponentFactory _factory = default!;
|
|
|
|
[ValidatePrototypeId<EntityPrototype>]
|
|
public const string HitscanProto = "HitscanEffect";
|
|
|
|
public bool SpreadOverlay
|
|
{
|
|
get => _spreadOverlay;
|
|
set
|
|
{
|
|
if (_spreadOverlay == value)
|
|
return;
|
|
|
|
_spreadOverlay = value;
|
|
var overlayManager = IoCManager.Resolve<IOverlayManager>();
|
|
|
|
if (_spreadOverlay)
|
|
{
|
|
overlayManager.AddOverlay(new GunSpreadOverlay(
|
|
EntityManager,
|
|
_eyeManager,
|
|
Timing,
|
|
_inputManager,
|
|
_player,
|
|
this));
|
|
}
|
|
else
|
|
{
|
|
overlayManager.RemoveOverlay<GunSpreadOverlay>();
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _spreadOverlay;
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
UpdatesOutsidePrediction = true;
|
|
SubscribeLocalEvent<AmmoCounterComponent, ItemStatusCollectMessage>(OnAmmoCounterCollect);
|
|
SubscribeAllEvent<MuzzleFlashEvent>(OnMuzzleFlash);
|
|
|
|
// Plays animated effects on the client.
|
|
SubscribeNetworkEvent<HitscanEvent>(OnHitscan);
|
|
|
|
InitializeMagazineVisuals();
|
|
InitializeSpentAmmo();
|
|
}
|
|
|
|
private void OnMuzzleFlash(MuzzleFlashEvent args)
|
|
{
|
|
CreateEffect(GetEntity(args.Uid), args);
|
|
}
|
|
|
|
private void OnHitscan(HitscanEvent ev)
|
|
{
|
|
// ALL I WANT IS AN ANIMATED EFFECT
|
|
foreach (var a in ev.Sprites)
|
|
{
|
|
if (a.Sprite is not SpriteSpecifier.Rsi rsi)
|
|
continue;
|
|
|
|
var coords = GetCoordinates(a.coordinates);
|
|
|
|
if (Deleted(coords.EntityId))
|
|
continue;
|
|
|
|
var ent = Spawn(HitscanProto, coords);
|
|
var sprite = Comp<SpriteComponent>(ent);
|
|
var xform = Transform(ent);
|
|
xform.LocalRotation = a.angle;
|
|
sprite[EffectLayers.Unshaded].AutoAnimated = false;
|
|
sprite.LayerSetSprite(EffectLayers.Unshaded, rsi);
|
|
sprite.LayerSetState(EffectLayers.Unshaded, rsi.RsiState);
|
|
sprite.Scale = new Vector2(a.Distance, 1f);
|
|
sprite[EffectLayers.Unshaded].Visible = true;
|
|
|
|
var anim = new Animation()
|
|
{
|
|
Length = TimeSpan.FromSeconds(0.48f),
|
|
AnimationTracks =
|
|
{
|
|
new AnimationTrackSpriteFlick()
|
|
{
|
|
LayerKey = EffectLayers.Unshaded,
|
|
KeyFrames =
|
|
{
|
|
new AnimationTrackSpriteFlick.KeyFrame(rsi.RsiState, 0f),
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
_animPlayer.Play(ent, null, anim, "hitscan-effect");
|
|
}
|
|
}
|
|
|
|
public override void Update(float frameTime)
|
|
{
|
|
if (!Timing.IsFirstTimePredicted)
|
|
return;
|
|
|
|
var entityNull = _player.LocalEntity;
|
|
|
|
if (entityNull == null || !TryComp<CombatModeComponent>(entityNull, out var combat) || !combat.IsInCombatMode)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var entity = entityNull.Value;
|
|
|
|
if (!TryGetGun(entity, out var gunUid, out var gun))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var useKey = gun.UseKey ? EngineKeyFunctions.Use : EngineKeyFunctions.UseSecondary;
|
|
|
|
if (_inputSystem.CmdStates.GetState(useKey) != BoundKeyState.Down)
|
|
{
|
|
if (gun.ShotCounter != 0)
|
|
EntityManager.RaisePredictiveEvent(new RequestStopShootEvent { Gun = GetNetEntity(gunUid) });
|
|
return;
|
|
}
|
|
|
|
if (gun.NextFire > Timing.CurTime)
|
|
return;
|
|
|
|
var mousePos = _eyeManager.PixelToMap(_inputManager.MouseScreenPosition);
|
|
|
|
if (mousePos.MapId == MapId.Nullspace)
|
|
{
|
|
if (gun.ShotCounter != 0)
|
|
EntityManager.RaisePredictiveEvent(new RequestStopShootEvent { Gun = GetNetEntity(gunUid) });
|
|
|
|
return;
|
|
}
|
|
|
|
// Define target coordinates relative to gun entity, so that network latency on moving grids doesn't fuck up the target location.
|
|
var coordinates = EntityCoordinates.FromMap(entity, mousePos, TransformSystem, EntityManager);
|
|
|
|
Log.Debug($"Sending shoot request tick {Timing.CurTick} / {Timing.CurTime}");
|
|
|
|
EntityManager.RaisePredictiveEvent(new RequestShootEvent
|
|
{
|
|
Coordinates = GetNetCoordinates(coordinates),
|
|
Gun = GetNetEntity(gunUid),
|
|
});
|
|
}
|
|
|
|
public override void Shoot(EntityUid gunUid, GunComponent gun, List<(EntityUid? Entity, IShootable Shootable)> ammo,
|
|
EntityCoordinates fromCoordinates, EntityCoordinates toCoordinates, out bool userImpulse, EntityUid? user = null, bool throwItems = false)
|
|
{
|
|
userImpulse = true;
|
|
|
|
// Rather than splitting client / server for every ammo provider it's easier
|
|
// to just delete the spawned entities. This is for programmer sanity despite the wasted perf.
|
|
// This also means any ammo specific stuff can be grabbed as necessary.
|
|
var direction = fromCoordinates.ToMapPos(EntityManager, TransformSystem) - toCoordinates.ToMapPos(EntityManager, TransformSystem);
|
|
|
|
foreach (var (ent, shootable) in ammo)
|
|
{
|
|
if (throwItems)
|
|
{
|
|
Recoil(user, direction, gun.CameraRecoilScalarModified);
|
|
if (IsClientSide(ent!.Value))
|
|
Del(ent.Value);
|
|
else
|
|
RemoveShootable(ent.Value);
|
|
continue;
|
|
}
|
|
|
|
switch (shootable)
|
|
{
|
|
case CartridgeAmmoComponent cartridge:
|
|
if (!cartridge.Spent)
|
|
{
|
|
SetCartridgeSpent(ent!.Value, cartridge, true);
|
|
MuzzleFlash(gunUid, cartridge, user);
|
|
Audio.PlayPredicted(gun.SoundGunshotModified, gunUid, user);
|
|
Recoil(user, direction, gun.CameraRecoilScalarModified);
|
|
// TODO: Can't predict entity deletions.
|
|
//if (cartridge.DeleteOnSpawn)
|
|
// Del(cartridge.Owner);
|
|
}
|
|
else
|
|
{
|
|
userImpulse = false;
|
|
Audio.PlayPredicted(gun.SoundEmpty, gunUid, user);
|
|
}
|
|
|
|
if (IsClientSide(ent!.Value))
|
|
Del(ent.Value);
|
|
|
|
break;
|
|
case AmmoComponent newAmmo:
|
|
MuzzleFlash(gunUid, newAmmo, user);
|
|
Audio.PlayPredicted(gun.SoundGunshotModified, gunUid, user);
|
|
Recoil(user, direction, gun.CameraRecoilScalarModified);
|
|
if (IsClientSide(ent!.Value))
|
|
Del(ent.Value);
|
|
else
|
|
RemoveShootable(ent.Value);
|
|
break;
|
|
case HitscanPrototype:
|
|
Audio.PlayPredicted(gun.SoundGunshotModified, gunUid, user);
|
|
Recoil(user, direction, gun.CameraRecoilScalarModified);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Recoil(EntityUid? user, Vector2 recoil, float recoilScalar)
|
|
{
|
|
if (!Timing.IsFirstTimePredicted || user == null || recoil == Vector2.Zero || recoilScalar == 0)
|
|
return;
|
|
|
|
_recoil.KickCamera(user.Value, recoil.Normalized() * 0.5f * recoilScalar);
|
|
}
|
|
|
|
protected override void Popup(string message, EntityUid? uid, EntityUid? user)
|
|
{
|
|
if (uid == null || user == null || !Timing.IsFirstTimePredicted)
|
|
return;
|
|
|
|
PopupSystem.PopupEntity(message, uid.Value, user.Value);
|
|
}
|
|
|
|
protected override void CreateEffect(EntityUid uid, MuzzleFlashEvent message, EntityUid? user = null)
|
|
{
|
|
if (!Timing.IsFirstTimePredicted)
|
|
return;
|
|
|
|
EntityCoordinates coordinates;
|
|
|
|
if (message.MatchRotation)
|
|
coordinates = new EntityCoordinates(uid, Vector2.Zero);
|
|
else if (TryComp<TransformComponent>(uid, out var xform))
|
|
coordinates = xform.Coordinates;
|
|
else
|
|
return;
|
|
|
|
if (!coordinates.IsValid(EntityManager))
|
|
return;
|
|
|
|
var ent = Spawn(message.Prototype, coordinates);
|
|
|
|
var effectXform = Transform(ent);
|
|
TransformSystem.SetLocalPositionRotation(effectXform,
|
|
effectXform.LocalPosition + new Vector2(0f, -0.5f),
|
|
effectXform.LocalRotation - MathF.PI / 2);
|
|
|
|
var lifetime = 0.4f;
|
|
|
|
if (TryComp<TimedDespawnComponent>(uid, out var despawn))
|
|
{
|
|
lifetime = despawn.Lifetime;
|
|
}
|
|
|
|
var anim = new Animation()
|
|
{
|
|
Length = TimeSpan.FromSeconds(lifetime),
|
|
AnimationTracks =
|
|
{
|
|
new AnimationTrackComponentProperty
|
|
{
|
|
ComponentType = typeof(SpriteComponent),
|
|
Property = nameof(SpriteComponent.Color),
|
|
InterpolationMode = AnimationInterpolationMode.Linear,
|
|
KeyFrames =
|
|
{
|
|
new AnimationTrackProperty.KeyFrame(Color.White.WithAlpha(1f), 0),
|
|
new AnimationTrackProperty.KeyFrame(Color.White.WithAlpha(0f), lifetime)
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
_animPlayer.Play(ent, anim, "muzzle-flash");
|
|
if (!TryComp(uid, out PointLightComponent? light))
|
|
{
|
|
light = (PointLightComponent) _factory.GetComponent(typeof(PointLightComponent));
|
|
light.Owner = uid;
|
|
light.NetSyncEnabled = false;
|
|
AddComp(uid, light);
|
|
}
|
|
|
|
Lights.SetEnabled(uid, true, light);
|
|
Lights.SetRadius(uid, 2f, light);
|
|
Lights.SetColor(uid, Color.FromHex("#cc8e2b"), light);
|
|
Lights.SetEnergy(uid, 5f, light);
|
|
|
|
var animTwo = new Animation()
|
|
{
|
|
Length = TimeSpan.FromSeconds(lifetime),
|
|
AnimationTracks =
|
|
{
|
|
new AnimationTrackComponentProperty
|
|
{
|
|
ComponentType = typeof(PointLightComponent),
|
|
Property = nameof(PointLightComponent.Energy),
|
|
InterpolationMode = AnimationInterpolationMode.Linear,
|
|
KeyFrames =
|
|
{
|
|
new AnimationTrackProperty.KeyFrame(5f, 0),
|
|
new AnimationTrackProperty.KeyFrame(0f, lifetime)
|
|
}
|
|
},
|
|
new AnimationTrackComponentProperty
|
|
{
|
|
ComponentType = typeof(PointLightComponent),
|
|
Property = nameof(PointLightComponent.AnimatedEnable),
|
|
InterpolationMode = AnimationInterpolationMode.Linear,
|
|
KeyFrames =
|
|
{
|
|
new AnimationTrackProperty.KeyFrame(true, 0),
|
|
new AnimationTrackProperty.KeyFrame(false, lifetime)
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
var uidPlayer = EnsureComp<AnimationPlayerComponent>(uid);
|
|
|
|
_animPlayer.Stop(uid, uidPlayer, "muzzle-flash-light");
|
|
_animPlayer.Play(uid, uidPlayer, animTwo,"muzzle-flash-light");
|
|
}
|
|
}
|