return;
// (☞ﾟヮﾟ)☞
- var maxSpread = gun.MaxAngle;
- var minSpread = gun.MinAngle;
+ var maxSpread = gun.MaxAngleModified;
+ var minSpread = gun.MinAngleModified;
var timeSinceLastFire = (_timing.CurTime - gun.NextFire).TotalSeconds;
- var currentAngle = new Angle(MathHelper.Clamp(gun.CurrentAngle.Theta - gun.AngleDecay.Theta * timeSinceLastFire,
- gun.MinAngle.Theta, gun.MaxAngle.Theta));
+ var currentAngle = new Angle(MathHelper.Clamp(gun.CurrentAngle.Theta - gun.AngleDecayModified.Theta * timeSinceLastFire,
+ gun.MinAngleModified.Theta, gun.MaxAngleModified.Theta));
var direction = (mousePos.Position - mapPos.Position);
worldHandle.DrawLine(mapPos.Position, mousePos.Position + direction, Color.Orange);
using Content.Client.Weapons.Ranged.Components;
using Content.Shared.Camera;
using Content.Shared.CombatMode;
-using Robust.Shared.Spawners;
using Content.Shared.Weapons.Ranged;
using Content.Shared.Weapons.Ranged.Components;
using Content.Shared.Weapons.Ranged.Events;
{
if (throwItems)
{
- Recoil(user, direction, gun.CameraRecoilScalar);
+ Recoil(user, direction, gun.CameraRecoilScalarModified);
if (IsClientSide(ent!.Value))
Del(ent.Value);
else
{
SetCartridgeSpent(ent!.Value, cartridge, true);
MuzzleFlash(gunUid, cartridge, user);
- Audio.PlayPredicted(gun.SoundGunshot, gunUid, user);
- Recoil(user, direction, gun.CameraRecoilScalar);
+ Audio.PlayPredicted(gun.SoundGunshotModified, gunUid, user);
+ Recoil(user, direction, gun.CameraRecoilScalarModified);
// TODO: Can't predict entity deletions.
//if (cartridge.DeleteOnSpawn)
// Del(cartridge.Owner);
break;
case AmmoComponent newAmmo:
MuzzleFlash(gunUid, newAmmo, user);
- Audio.PlayPredicted(gun.SoundGunshot, gunUid, user);
- Recoil(user, direction, gun.CameraRecoilScalar);
+ 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.SoundGunshot, gunUid, user);
- Recoil(user, direction, gun.CameraRecoilScalar);
+ Audio.PlayPredicted(gun.SoundGunshotModified, gunUid, user);
+ Recoil(user, direction, gun.CameraRecoilScalarModified);
break;
}
}
--- /dev/null
+namespace Content.Server.Administration.Components;
+
+[RegisterComponent]
+public sealed partial class AdminMinigunComponent : Component
+{
+
+}
--- /dev/null
+using Content.Server.Administration.Components;
+using Content.Shared.Weapons.Ranged.Events;
+
+namespace Content.Server.Administration.Systems;
+
+public sealed class AdminGunSystem : EntitySystem
+{
+ public override void Initialize()
+ {
+ SubscribeLocalEvent<AdminMinigunComponent, GunRefreshModifiersEvent>(OnGunRefreshModifiers);
+ }
+
+ private void OnGunRefreshModifiers(Entity<AdminMinigunComponent> ent, ref GunRefreshModifiersEvent args)
+ {
+ args.FireRate = 15;
+ }
+}
using Content.Server.Stack;
using Content.Server.Station.Components;
using Content.Server.Station.Systems;
+using Content.Server.Weapons.Ranged.Systems;
using Content.Shared.Access;
using Content.Shared.Access.Components;
using Content.Shared.Access.Systems;
[Dependency] private readonly BatterySystem _batterySystem = default!;
[Dependency] private readonly SharedTransformSystem _xformSystem = default!;
[Dependency] private readonly MetaDataSystem _metaSystem = default!;
+ [Dependency] private readonly GunSystem _gun = default!;
private void AddTricksVerbs(GetVerbsEvent<Verb> args)
{
Icon = new SpriteSpecifier.Rsi(new("/Textures/Objects/Weapons/Guns/HMGs/minigun.rsi"), "icon"),
Act = () =>
{
- gun.FireRate = 15;
+ EnsureComp<AdminMinigunComponent>(args.Target);
+ _gun.RefreshModifiers((args.Target, gun));
},
Impact = LogImpact.Medium,
Message = Loc.GetString("admin-trick-minigun-fire-description"),
using Content.Server.Atmos.EntitySystems;
using Content.Server.Storage.EntitySystems;
using Content.Server.Stunnable;
+using Content.Server.Weapons.Ranged.Systems;
using Content.Shared.Containers.ItemSlots;
using Content.Shared.Interaction;
using Content.Shared.PneumaticCannon;
using Content.Shared.StatusEffect;
using Content.Shared.Tools.Components;
using Content.Shared.Weapons.Ranged.Components;
+using Content.Shared.Weapons.Ranged.Events;
using Content.Shared.Weapons.Ranged.Systems;
using Robust.Shared.Containers;
{
[Dependency] private readonly AtmosphereSystem _atmos = default!;
[Dependency] private readonly GasTankSystem _gasTank = default!;
+ [Dependency] private readonly GunSystem _gun = default!;
[Dependency] private readonly StunSystem _stun = default!;
[Dependency] private readonly ItemSlotsSystem _slots = default!;
SubscribeLocalEvent<PneumaticCannonComponent, InteractUsingEvent>(OnInteractUsing, before: new []{ typeof(StorageSystem) });
SubscribeLocalEvent<PneumaticCannonComponent, GunShotEvent>(OnShoot);
SubscribeLocalEvent<PneumaticCannonComponent, ContainerIsInsertingAttemptEvent>(OnContainerInserting);
+ SubscribeLocalEvent<PneumaticCannonComponent, GunRefreshModifiersEvent>(OnGunRefreshModifiers);
}
private void OnInteractUsing(EntityUid uid, PneumaticCannonComponent component, InteractUsingEvent args)
Popup.PopupEntity(Loc.GetString("pneumatic-cannon-component-change-power",
("power", component.Power.ToString())), uid, args.User);
+ component.ProjectileSpeed = GetProjectileSpeedFromPower(component);
if (TryComp<GunComponent>(uid, out var gun))
- {
- gun.ProjectileSpeed = GetProjectileSpeedFromPower(component);
- }
+ _gun.RefreshModifiers((uid, gun));
args.Handled = true;
}
_slots.TryEject(uid, PneumaticCannonComponent.TankSlotId, args.User, out _);
}
+ private void OnGunRefreshModifiers(Entity<PneumaticCannonComponent> ent, ref GunRefreshModifiersEvent args)
+ {
+ if (ent.Comp.ProjectileSpeed is { } speed)
+ args.ProjectileSpeed = speed;
+ }
+
/// <summary>
/// Returns whether the pneumatic cannon has enough gas to shoot an item, as well as the tank itself.
/// </summary>
using Content.Shared.Damage.Systems;
using Content.Shared.Database;
using Content.Shared.Effects;
-using Content.Shared.FixedPoint;
using Content.Shared.Interaction.Components;
using Content.Shared.Projectiles;
using Content.Shared.Weapons.Melee;
using Content.Shared.Weapons.Ranged.Events;
using Content.Shared.Weapons.Ranged.Systems;
using Content.Shared.Weapons.Reflect;
-using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.Map;
using Robust.Shared.Physics;
-using Robust.Shared.Physics.Components;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Utility;
}
if (cartridge.Count > 1)
{
- var angles = LinearSpread(mapAngle - cartridge.Spread / 2,
- mapAngle + cartridge.Spread / 2, cartridge.Count);
+ var ev = new GunGetAmmoSpreadEvent(cartridge.Spread);
+ RaiseLocalEvent(gunUid, ref ev);
+
+ var angles = LinearSpread(mapAngle - ev.Spread / 2,
+ mapAngle + ev.Spread / 2, cartridge.Count);
for (var i = 0; i < cartridge.Count; i++)
{
SetCartridgeSpent(ent.Value, cartridge, true);
MuzzleFlash(gunUid, cartridge, user);
- Audio.PlayPredicted(gun.SoundGunshot, gunUid, user);
+ Audio.PlayPredicted(gun.SoundGunshotModified, gunUid, user);
if (cartridge.DeleteOnSpawn)
Del(ent.Value);
case AmmoComponent newAmmo:
shotProjectiles.Add(ent!.Value);
MuzzleFlash(gunUid, newAmmo, user);
- Audio.PlayPredicted(gun.SoundGunshot, gunUid, user);
+ Audio.PlayPredicted(gun.SoundGunshotModified, gunUid, user);
ShootOrThrow(ent.Value, mapDirection, gunVelocity, gun, gunUid, user);
break;
case HitscanPrototype hitscan:
FireEffects(fromEffect, hitscan.MaxLength, dir.ToAngle(), hitscan);
}
- Audio.PlayPredicted(gun.SoundGunshot, gunUid, user);
+ Audio.PlayPredicted(gun.SoundGunshotModified, gunUid, user);
break;
default:
throw new ArgumentOutOfRangeException();
{
RemoveShootable(uid);
// TODO: Someone can probably yeet this a billion miles so need to pre-validate input somewhere up the call stack.
- ThrowingSystem.TryThrow(uid, mapDirection, gun.ProjectileSpeed, user);
+ ThrowingSystem.TryThrow(uid, mapDirection, gun.ProjectileSpeedModified, user);
return;
}
- ShootProjectile(uid, mapDirection, gunVelocity, gunUid, user, gun.ProjectileSpeed);
+ ShootProjectile(uid, mapDirection, gunVelocity, gunUid, user, gun.ProjectileSpeedModified);
}
/// <summary>
private Angle GetRecoilAngle(TimeSpan curTime, GunComponent component, Angle direction)
{
var timeSinceLastFire = (curTime - component.LastFire).TotalSeconds;
- var newTheta = MathHelper.Clamp(component.CurrentAngle.Theta + component.AngleIncrease.Theta - component.AngleDecay.Theta * timeSinceLastFire, component.MinAngle.Theta, component.MaxAngle.Theta);
+ var newTheta = MathHelper.Clamp(component.CurrentAngle.Theta + component.AngleIncreaseModified.Theta - component.AngleDecayModified.Theta * timeSinceLastFire, component.MinAngleModified.Theta, component.MaxAngleModified.Theta);
component.CurrentAngle = new Angle(newTheta);
component.LastFire = component.NextFire;
var random = Random.NextFloat(-0.5f, 0.5f);
var spread = component.CurrentAngle.Theta * random;
var angle = new Angle(direction.Theta + component.CurrentAngle.Theta * random);
- DebugTools.Assert(spread <= component.MaxAngle.Theta);
+ DebugTools.Assert(spread <= component.MaxAngleModified.Theta);
return angle;
}
[DataField("baseProjectileSpeed")]
public float BaseProjectileSpeed = 20f;
+ /// <summary>
+ /// The current projectile speed setting.
+ /// </summary>
+ [DataField]
+ public float? ProjectileSpeed;
+
/// <summary>
/// If true, will throw ammo rather than shoot it.
/// </summary>
using Content.Shared.Damage;
using Content.Shared.Tag;
+using Content.Shared.Weapons.Ranged.Events;
+using Content.Shared.Weapons.Ranged.Systems;
using Robust.Shared.Audio;
using Robust.Shared.GameStates;
using Robust.Shared.Map;
namespace Content.Shared.Weapons.Ranged.Components;
-[RegisterComponent, NetworkedComponent, Virtual]
-[AutoGenerateComponentState]
-public partial class GunComponent : Component
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+[Access(typeof(SharedGunSystem))]
+public sealed partial class GunComponent : Component
{
#region Sound
- [ViewVariables(VVAccess.ReadWrite), DataField("soundGunshot")]
+ /// <summary>
+ /// The base sound to use when the gun is fired.
+ /// </summary>
+ [DataField]
public SoundSpecifier? SoundGunshot = new SoundPathSpecifier("/Audio/Weapons/Guns/Gunshots/smg.ogg");
- [ViewVariables(VVAccess.ReadWrite), DataField("soundEmpty")]
+ /// <summary>
+ /// The sound to use when the gun is fired.
+ /// <seealso cref="GunRefreshModifiersEvent"/>
+ /// </summary>
+ [AutoNetworkedField, ViewVariables(VVAccess.ReadWrite)]
+ public SoundSpecifier? SoundGunshotModified;
+
+ [DataField]
public SoundSpecifier? SoundEmpty = new SoundPathSpecifier("/Audio/Weapons/Guns/Empty/empty.ogg");
/// <summary>
/// Sound played when toggling the <see cref="SelectedMode"/> for this gun.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField("soundMode")]
- public SoundSpecifier? SoundModeToggle = new SoundPathSpecifier("/Audio/Weapons/Guns/Misc/selector.ogg");
+ [DataField]
+ public SoundSpecifier? SoundMode = new SoundPathSpecifier("/Audio/Weapons/Guns/Misc/selector.ogg");
#endregion
// These values are very small for now until we get a debug overlay and fine tune it
+ /// <summary>
+ /// The base scalar value applied to the vector governing camera recoil.
+ /// </summary>
+ [DataField, AutoNetworkedField]
+ public float CameraRecoilScalar = 1f;
+
/// <summary>
/// A scalar value applied to the vector governing camera recoil.
/// If 0, there will be no camera recoil.
+ /// <seealso cref="GunRefreshModifiersEvent"/>
/// </summary>
- [DataField("cameraRecoilScalar"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
- public float CameraRecoilScalar = 1f;
+ [AutoNetworkedField, ViewVariables(VVAccess.ReadWrite)]
+ public float CameraRecoilScalarModified = 1f;
/// <summary>
/// Last time the gun fired.
/// Used for recoil purposes.
/// </summary>
- [DataField("lastFire")]
+ [DataField]
public TimeSpan LastFire = TimeSpan.Zero;
/// <summary>
/// What the current spread is for shooting. This gets changed every time the gun fires.
/// </summary>
- [DataField("currentAngle")]
+ [DataField]
[AutoNetworkedField]
public Angle CurrentAngle;
/// <summary>
- /// How much the spread increases every time the gun fires.
+ /// The base value for how much the spread increases every time the gun fires.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField("angleIncrease")]
+ [DataField]
public Angle AngleIncrease = Angle.FromDegrees(0.5);
/// <summary>
- /// How much the <see cref="CurrentAngle"/> decreases per second.
+ /// How much the spread increases every time the gun fires.
+ /// <seealso cref="GunRefreshModifiersEvent"/>
+ /// </summary>
+ [AutoNetworkedField, ViewVariables(VVAccess.ReadWrite)]
+ public Angle AngleIncreaseModified;
+
+ /// <summary>
+ /// The base value for how much the <see cref="CurrentAngle"/> decreases per second.
/// </summary>
- [DataField("angleDecay")]
+ [DataField]
public Angle AngleDecay = Angle.FromDegrees(4);
/// <summary>
- /// The maximum angle allowed for <see cref="CurrentAngle"/>
+ /// How much the <see cref="CurrentAngle"/> decreases per second.
+ /// <seealso cref="GunRefreshModifiersEvent"/>
/// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField("maxAngle")]
+ [AutoNetworkedField, ViewVariables(VVAccess.ReadWrite)]
+ public Angle AngleDecayModified;
+
+ /// <summary>
+ /// The base value for the maximum angle allowed for <see cref="CurrentAngle"/>
+ /// </summary>
+ [DataField]
[AutoNetworkedField]
public Angle MaxAngle = Angle.FromDegrees(2);
/// <summary>
- /// The minimum angle allowed for <see cref="CurrentAngle"/>
+ /// The maximum angle allowed for <see cref="CurrentAngle"/>
+ /// <seealso cref="GunRefreshModifiersEvent"/>
+ /// </summary>
+ [AutoNetworkedField, ViewVariables(VVAccess.ReadWrite)]
+ public Angle MaxAngleModified;
+
+ /// <summary>
+ /// The base value for the minimum angle allowed for <see cref="CurrentAngle"/>
/// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField("minAngle")]
+ [DataField]
[AutoNetworkedField]
public Angle MinAngle = Angle.FromDegrees(1);
+ /// <summary>
+ /// The minimum angle allowed for <see cref="CurrentAngle"/>.
+ /// <seealso cref="GunRefreshModifiersEvent"/>
+ /// </summary>
+ [AutoNetworkedField, ViewVariables(VVAccess.ReadWrite)]
+ public Angle MinAngleModified;
+
#endregion
/// <summary>
/// Whether this gun is shot via the use key or the alt-use key.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField("useKey"), AutoNetworkedField]
+ [DataField, AutoNetworkedField]
public bool UseKey = true;
/// <summary>
[ViewVariables]
public EntityCoordinates? ShootCoordinates = null;
+ /// <summary>
+ /// The base value for how many shots to fire per burst.
+ /// </summary>
+ [DataField, AutoNetworkedField]
+ public int ShotsPerBurst = 3;
+
+ /// <summary>
+ /// How many shots to fire per burst.
+ /// <seealso cref="GunRefreshModifiersEvent"/>
+ /// </summary>
+ [AutoNetworkedField, ViewVariables(VVAccess.ReadWrite)]
+ public int ShotsPerBurstModified = 3;
+
/// <summary>
/// Used for tracking semi-auto / burst
/// </summary>
public int ShotCounter = 0;
/// <summary>
- /// How many times it shoots per second.
+ /// The base value for how many times it shoots per second.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField("fireRate")]
+ [DataField]
[AutoNetworkedField]
public float FireRate = 8f;
+ /// <summary>
+ /// How many times it shoots per second.
+ /// <seealso cref="GunRefreshModifiersEvent"/>
+ /// </summary>
+ [AutoNetworkedField, ViewVariables(VVAccess.ReadWrite)]
+ public float FireRateModified;
+
/// <summary>
/// Starts fire cooldown when equipped if true.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField("resetOnHandSelected")]
+ [DataField]
public bool ResetOnHandSelected = true;
/// <summary>
/// Type of ammo the gun can work with
/// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField("compatibleAmmo")]
+ [DataField]
public List<ProtoId<TagPrototype>>? CompatibleAmmo;
/// <summary>
/// Damage the gun deals when used with wrong ammo
/// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField("damageOnWrongAmmo")]
+ [DataField]
public DamageSpecifier? DamageOnWrongAmmo = null;
/// <summary>
- /// How fast the projectile moves.
+ /// The base value for how fast the projectile moves.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField("projectileSpeed")]
+ [DataField]
public float ProjectileSpeed = 25f;
+ /// <summary>
+ /// How fast the projectile moves.
+ /// <seealso cref="GunRefreshModifiersEvent"/>
+ /// </summary>
+ [AutoNetworkedField, ViewVariables(VVAccess.ReadWrite)]
+ public float ProjectileSpeedModified;
+
/// <summary>
/// When the gun is next available to be shot.
/// Can be set multiple times in a single tick due to guns firing faster than a single tick time.
/// </summary>
- [DataField("nextFire", customTypeSerializer:typeof(TimeOffsetSerializer))]
+ [DataField(customTypeSerializer:typeof(TimeOffsetSerializer))]
[AutoNetworkedField]
public TimeSpan NextFire = TimeSpan.Zero;
/// <summary>
/// What firemodes can be selected.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField("availableModes")]
+ [DataField]
[AutoNetworkedField]
public SelectiveFire AvailableModes = SelectiveFire.SemiAuto;
/// <summary>
/// What firemode is currently selected.
/// </summary>
- [ViewVariables(VVAccess.ReadWrite), DataField("selectedMode")]
+ [DataField]
[AutoNetworkedField]
public SelectiveFire SelectedMode = SelectiveFire.SemiAuto;
/// Whether or not information about
/// the gun will be shown on examine.
/// </summary>
- [DataField("showExamineText")]
+ [DataField]
public bool ShowExamineText = true;
/// <summary>
/// Whether or not someone with the
/// clumsy trait can shoot this
/// </summary>
- [DataField("clumsyProof"), ViewVariables(VVAccess.ReadWrite)]
+ [DataField]
public bool ClumsyProof = false;
}
--- /dev/null
+namespace Content.Shared.Weapons.Ranged.Events;
+
+/// <summary>
+/// Raised directed on the gun entity when ammo is shot to calculate its spread.
+/// </summary>
+/// <param name="Spread">The spread of the ammo, can be changed by handlers.</param>
+[ByRefEvent]
+public record struct GunGetAmmoSpreadEvent(Angle Spread);
--- /dev/null
+namespace Content.Shared.Weapons.Ranged.Events;
+
+/// <summary>
+/// Raised directed on the gun entity when a muzzle flash is about to happen.
+/// </summary>
+/// <param name="Cancelled">If set to true, the muzzle flash will not be shown.</param>
+[ByRefEvent]
+public record struct GunMuzzleFlashAttemptEvent(bool Cancelled);
--- /dev/null
+using Content.Shared.Weapons.Ranged.Components;
+using Content.Shared.Weapons.Ranged.Systems;
+using Robust.Shared.Audio;
+
+namespace Content.Shared.Weapons.Ranged.Events;
+
+/// <summary>
+/// Raised directed on the gun entity when <see cref="SharedGunSystem.RefreshModifiers"/>
+/// is called, to update the values of <see cref="GunComponent"/> from other systems.
+/// </summary>
+[ByRefEvent]
+public record struct GunRefreshModifiersEvent(
+ Entity<GunComponent> Gun,
+ SoundSpecifier? SoundGunshot,
+ float CameraRecoilScalar,
+ Angle AngleIncrease,
+ Angle AngleDecay,
+ Angle MaxAngle,
+ Angle MinAngle,
+ int ShotsPerBurst,
+ float FireRate,
+ float ProjectileSpeed
+);
// Reset shotting for cycling
if (Resolve(uid, ref gunComp, false) &&
- gunComp is { FireRate: > 0f } &&
+ gunComp is { FireRateModified: > 0f } &&
!Paused(uid))
{
- gunComp.NextFire = Timing.CurTime + TimeSpan.FromSeconds(1 / gunComp.FireRate);
+ gunComp.NextFire = Timing.CurTime + TimeSpan.FromSeconds(1 / gunComp.FireRateModified);
}
Dirty(uid, component);
args.PushMarkup(Loc.GetString("gun-selected-mode-examine", ("color", ModeExamineColor),
("mode", GetLocSelector(component.SelectedMode))));
args.PushMarkup(Loc.GetString("gun-fire-rate-examine", ("color", FireRateExamineColor),
- ("fireRate", $"{component.FireRate:0.0}")));
+ ("fireRate", $"{component.FireRateModified:0.0}")));
}
}
component.NextFire += cooldown;
}
- Audio.PlayPredicted(component.SoundModeToggle, uid, user);
+ Audio.PlayPredicted(component.SoundMode, uid, user);
Popup(Loc.GetString("gun-selected-mode", ("mode", GetLocSelector(fire))), uid, user);
Dirty(uid, component);
}
private void OnGunSelected(EntityUid uid, GunComponent component, HandSelectedEvent args)
{
- var fireDelay = 1f / component.FireRate;
+ var fireDelay = 1f / component.FireRateModified;
if (fireDelay.Equals(0f))
return;
SubscribeLocalEvent<GunComponent, CycleModeEvent>(OnCycleMode);
SubscribeLocalEvent<GunComponent, HandSelectedEvent>(OnGunSelected);
SubscribeLocalEvent<GunComponent, EntityUnpausedEvent>(OnGunUnpaused);
-
-#if DEBUG
SubscribeLocalEvent<GunComponent, MapInitEvent>(OnMapInit);
}
- private void OnMapInit(EntityUid uid, GunComponent component, MapInitEvent args)
+ private void OnMapInit(Entity<GunComponent> gun, ref MapInitEvent args)
{
- if (component.NextFire > Timing.CurTime)
- Log.Warning($"Initializing a map that contains an entity that is on cooldown. Entity: {ToPrettyString(uid)}");
+#if DEBUG
+ if (gun.Comp.NextFire > Timing.CurTime)
+ Log.Warning($"Initializing a map that contains an entity that is on cooldown. Entity: {ToPrettyString(gun)}");
- DebugTools.Assert((component.AvailableModes & component.SelectedMode) != 0x0);
+ DebugTools.Assert((gun.Comp.AvailableModes & gun.Comp.SelectedMode) != 0x0);
#endif
+
+ RefreshModifiers((gun, gun));
}
private void OnGunMelee(EntityUid uid, GunComponent component, MeleeHitEvent args)
private void AttemptShoot(EntityUid user, EntityUid gunUid, GunComponent gun)
{
- if (gun.FireRate <= 0f ||
+ if (gun.FireRateModified <= 0f ||
!_actionBlockerSystem.CanAttack(user))
return;
if (gun.NextFire > curTime)
return;
- var fireRate = TimeSpan.FromSeconds(1f / gun.FireRate);
+ var fireRate = TimeSpan.FromSeconds(1f / gun.FireRateModified);
// First shot
// Previously we checked shotcounter but in some cases all the bullets got dumped at once
shots = Math.Min(shots, 1 - gun.ShotCounter);
break;
case SelectiveFire.Burst:
- shots = Math.Min(shots, 3 - gun.ShotCounter);
+ shots = Math.Min(shots, gun.ShotsPerBurstModified - gun.ShotCounter);
break;
case SelectiveFire.FullAuto:
break;
protected void MuzzleFlash(EntityUid gun, AmmoComponent component, EntityUid? user = null)
{
+ var attemptEv = new GunMuzzleFlashAttemptEvent();
+ RaiseLocalEvent(gun, ref attemptEv);
+ if (attemptEv.Cancelled)
+ return;
+
var sprite = component.MuzzleFlash;
if (sprite == null)
var impulseVector = shotDirection * impulseStrength;
Physics.ApplyLinearImpulse(user, -impulseVector, body: userPhysics);
}
+
+ public void RefreshModifiers(Entity<GunComponent?> gun)
+ {
+ if (!Resolve(gun, ref gun.Comp))
+ return;
+
+ var comp = gun.Comp;
+ var ev = new GunRefreshModifiersEvent(
+ (gun, comp),
+ comp.SoundGunshot,
+ comp.CameraRecoilScalar,
+ comp.AngleIncrease,
+ comp.AngleDecay,
+ comp.MaxAngle,
+ comp.MinAngle,
+ comp.ShotsPerBurst,
+ comp.FireRate,
+ comp.ProjectileSpeed
+ );
+
+ RaiseLocalEvent(gun, ref ev);
+
+ comp.SoundGunshotModified = ev.SoundGunshot;
+ comp.CameraRecoilScalarModified = ev.CameraRecoilScalar;
+ comp.AngleIncreaseModified = ev.AngleIncrease;
+ comp.AngleDecayModified = ev.AngleDecay;
+ comp.MaxAngleModified = ev.MaxAngle;
+ comp.MinAngleModified = ev.MinAngle;
+ comp.ShotsPerBurstModified = ev.ShotsPerBurst;
+ comp.FireRateModified = ev.FireRate;
+ comp.ProjectileSpeedModified = ev.ProjectileSpeed;
+
+ Dirty(gun);
+ }
+
protected abstract void CreateEffect(EntityUid uid, MuzzleFlashEvent message, EntityUid? user = null);
/// <summary>
using Content.Shared.Weapons.Melee.Components;
using Content.Shared.Weapons.Melee.Events;
using Content.Shared.Weapons.Ranged.Components;
+using Content.Shared.Weapons.Ranged.Events;
using Content.Shared.Weapons.Ranged.Systems;
using Content.Shared.Wieldable.Components;
using Robust.Shared.Audio.Systems;
[Dependency] private readonly SharedAudioSystem _audioSystem = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
[Dependency] private readonly UseDelaySystem _delay = default!;
+ [Dependency] private readonly SharedGunSystem _gun = default!;
public override void Initialize()
{
SubscribeLocalEvent<GunRequiresWieldComponent, AttemptShootEvent>(OnShootAttempt);
SubscribeLocalEvent<GunWieldBonusComponent, ItemWieldedEvent>(OnGunWielded);
SubscribeLocalEvent<GunWieldBonusComponent, ItemUnwieldedEvent>(OnGunUnwielded);
+ SubscribeLocalEvent<GunWieldBonusComponent, GunRefreshModifiersEvent>(OnGunRefreshModifiers);
SubscribeLocalEvent<IncreaseDamageOnWieldComponent, GetMeleeDamageEvent>(OnGetMeleeDamage);
}
private void OnGunUnwielded(EntityUid uid, GunWieldBonusComponent component, ItemUnwieldedEvent args)
{
- if (!TryComp<GunComponent>(uid, out var gun))
- return;
-
- gun.MinAngle -= component.MinAngle;
- gun.MaxAngle -= component.MaxAngle;
- Dirty(uid, gun);
+ _gun.RefreshModifiers(uid);
}
private void OnGunWielded(EntityUid uid, GunWieldBonusComponent component, ref ItemWieldedEvent args)
{
- if (!TryComp<GunComponent>(uid, out var gun))
- return;
+ _gun.RefreshModifiers(uid);
+ }
- gun.MinAngle += component.MinAngle;
- gun.MaxAngle += component.MaxAngle;
- Dirty(uid, gun);
+ private void OnGunRefreshModifiers(Entity<GunWieldBonusComponent> bonus, ref GunRefreshModifiersEvent args)
+ {
+ if (TryComp(bonus, out WieldableComponent? wield) &&
+ wield.Wielded)
+ {
+ args.MinAngle += bonus.Comp.MinAngle;
+ args.MaxAngle += bonus.Comp.MaxAngle;
+ }
}
private void AddToggleWieldVerb(EntityUid uid, WieldableComponent component, GetVerbsEvent<InteractionVerb> args)
if (ev.Cancelled)
return false;
+ component.Wielded = false;
var targEv = new ItemUnwieldedEvent(user);
RaiseLocalEvent(used, targEv);
if (args.User == null)
return;
- if (!component.Wielded)
- return;
-
if (TryComp<ItemComponent>(uid, out var item))
{
_itemSystem.SetHeldPrefix(uid, component.OldInhandPrefix, component: item);
}
- component.Wielded = false;
-
if (!args.Force) // don't play sound/popup if this was a forced unwield
{
if (component.UnwieldSound != null)
projects / space-station-14.git / commitdiff