354 lines
12 KiB
C#
354 lines
12 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.Spawners.Components;
|
|
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;
|
|
|
|
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!;
|
|
|
|
[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.LocalPlayer?.ControlledEntity;
|
|
|
|
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.CameraRecoilScalar);
|
|
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.SoundGunshot, gunUid, user);
|
|
Recoil(user, direction, gun.CameraRecoilScalar);
|
|
// 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.SoundGunshot, gunUid, user);
|
|
Recoil(user, direction, gun.CameraRecoilScalar);
|
|
if (IsClientSide(ent!.Value))
|
|
Del(ent.Value);
|
|
else
|
|
RemoveShootable(ent.Value);
|
|
break;
|
|
case HitscanPrototype:
|
|
Audio.PlayPredicted(gun.SoundGunshot, gunUid, user);
|
|
Recoil(user, direction, gun.CameraRecoilScalar);
|
|
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");
|
|
var light = EnsureComp<PointLightComponent>(uid);
|
|
light.NetSyncEnabled = false;
|
|
Lights.SetEnabled(uid, true, light);
|
|
Lights.SetRadius(uid, 2f, light);
|
|
light.Color = Color.FromHex("#cc8e2b");
|
|
light.Energy = 5f;
|
|
|
|
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.Enabled),
|
|
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");
|
|
}
|
|
}
|