tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Gun refactor (#8301)

Browse Source 
Co-authored-by: Kara <lunarautomaton6@gmail.com>
Co-authored-by: T-Stalker <le0nel_1van@hotmail.com>
Co-authored-by: T-Stalker <43253663+DogZeroX@users.noreply.github.com>
Co-authored-by: ElectroJr <leonsfriedrich@gmail.com>
Co-authored-by: metalgearsloth <metalgearsloth@gmail.com>
This commit is contained in:
metalgearsloth
2022-06-01 19:59:58 +10:00
committed by GitHub
parent 1ced3c5002
commit fb943a61dc
1051 changed files with 8230 additions and 99090 deletions
Download Patch File Download Diff File Expand all files Collapse all files

331
Content.Shared/Weapons/Ranged/Systems/SharedGunSystem.Revolver.cs Normal file
View File

@@ -0,0 +1,331 @@
using Content.Shared.Interaction;
using Content.Shared.Verbs;
using Content.Shared.Weapons.Ranged.Components;
using Content.Shared.Weapons.Ranged.Events;
using Robust.Shared.Containers;
using Robust.Shared.GameStates;
using Robust.Shared.Serialization;
using Robust.Shared.Utility;
namespace Content.Shared.Weapons.Ranged.Systems;
public partial class SharedGunSystem
{
protected const string RevolverContainer = "revolver-ammo";
protected virtual void InitializeRevolver()
{
SubscribeLocalEvent<RevolverAmmoProviderComponent, ComponentGetState>(OnRevolverGetState);
SubscribeLocalEvent<RevolverAmmoProviderComponent, ComponentHandleState>(OnRevolverHandleState);
SubscribeLocalEvent<RevolverAmmoProviderComponent, ComponentInit>(OnRevolverInit);
SubscribeLocalEvent<RevolverAmmoProviderComponent, TakeAmmoEvent>(OnRevolverTakeAmmo);
SubscribeLocalEvent<RevolverAmmoProviderComponent, GetVerbsEvent<Verb>>(OnRevolverVerbs);
SubscribeLocalEvent<RevolverAmmoProviderComponent, InteractUsingEvent>(OnRevolverInteractUsing);
SubscribeLocalEvent<RevolverAmmoProviderComponent, GetAmmoCountEvent>(OnRevolverGetAmmoCount);
}
private void OnRevolverGetAmmoCount(EntityUid uid, RevolverAmmoProviderComponent component, ref GetAmmoCountEvent args)
{
args.Count += GetRevolverCount(component);
args.Capacity += component.Capacity;
}
private void OnRevolverInteractUsing(EntityUid uid, RevolverAmmoProviderComponent component, InteractUsingEvent args)
{
if (args.Handled) return;
if (TryRevolverInsert(component, args.Used, args.User))
args.Handled = true;
}
private void OnRevolverGetState(EntityUid uid, RevolverAmmoProviderComponent component, ref ComponentGetState args)
{
args.State = new RevolverAmmoProviderComponentState
{
CurrentIndex = component.CurrentIndex,
AmmoSlots = component.AmmoSlots,
Chambers = component.Chambers,
};
}
private void OnRevolverHandleState(EntityUid uid, RevolverAmmoProviderComponent component, ref ComponentHandleState args)
{
if (args.Current is not RevolverAmmoProviderComponentState state) return;
var oldIndex = component.CurrentIndex;
component.CurrentIndex = state.CurrentIndex;
component.AmmoSlots = new EntityUid?[state.AmmoSlots.Length];
component.Chambers = new bool?[state.Chambers.Length];
DebugTools.Assert(component.AmmoSlots.Length == component.Chambers.Length);
// Need to copy across the state rather than the ref.
for (var i = 0; i < component.AmmoSlots.Length; i++)
{
component.AmmoSlots[i] = state.AmmoSlots[i];
component.Chambers[i] = state.Chambers[i];
}
// Handle spins
if (Timing.IsFirstTimePredicted)
{
if (oldIndex != state.CurrentIndex)
UpdateAmmoCount(uid);
}
}
public bool TryRevolverInsert(RevolverAmmoProviderComponent component, EntityUid uid, EntityUid? user)
{
if (component.Whitelist?.IsValid(uid, EntityManager) == false) return false;
for (var i = 0; i < component.Capacity; i++)
{
var index = (component.CurrentIndex + i) % component.Capacity;
if (component.AmmoSlots[index] != null ||
component.Chambers[index] != null) continue;
component.AmmoSlots[index] = uid;
component.AmmoContainer.Insert(uid);
PlaySound(component.Owner, component.SoundInsert?.GetSound(Random, ProtoManager), user);
Popup(Loc.GetString("gun-revolver-insert"), component.Owner, user);
UpdateRevolverAppearance(component);
UpdateAmmoCount(uid);
Dirty(component);
return true;
}
Popup(Loc.GetString("gun-revolver-full"), component.Owner, user);
return false;
}
private void OnRevolverVerbs(EntityUid uid, RevolverAmmoProviderComponent component, GetVerbsEvent<Verb> args)
{
if (!args.CanAccess || !args.CanInteract) return;
args.Verbs.Add(new Verb()
{
Text = Loc.GetString("gun-revolver-empty"),
Disabled = !AnyRevolverCartridges(component),
Act = () => EmptyRevolver(component, args.User)
});
args.Verbs.Add(new Verb()
{
Text = Loc.GetString("gun-revolver-spin"),
// Category = VerbCategory.G,
Act = () => SpinRevolver(component, args.User)
});
}
private bool AnyRevolverCartridges(RevolverAmmoProviderComponent component)
{
for (var i = 0; i < component.Capacity; i++)
{
if (component.Chambers[i] != null ||
component.AmmoSlots[i] != null) return true;
}
return false;
}
private int GetRevolverCount(RevolverAmmoProviderComponent component)
{
var count = 0;
for (var i = 0; i < component.Capacity; i++)
{
if (component.Chambers[i] != null ||
component.AmmoSlots[i] != null)
{
count++;
}
}
return count;
}
private int GetRevolverUnspentCount(RevolverAmmoProviderComponent component)
{
var count = 0;
for (var i = 0; i < component.Capacity; i++)
{
var chamber = component.Chambers[i];
if (chamber == true)
{
count++;
continue;
}
var ammo = component.AmmoSlots[i];
if (TryComp<CartridgeAmmoComponent>(ammo, out var cartridge) && !cartridge.Spent)
{
count++;
}
}
return count;
}
public void EmptyRevolver(RevolverAmmoProviderComponent component, EntityUid? user = null)
{
var xform = Transform(component.Owner);
var mapCoordinates = xform.MapPosition;
var anyEmpty = false;
for (var i = 0; i < component.Capacity; i++)
{
var chamber = component.Chambers[i];
var slot = component.AmmoSlots[i];
if (slot == null)
{
if (chamber == null) continue;
// Too lazy to make a new method don't sue me.
if (!_netManager.IsClient)
{
var uid = Spawn(component.FillPrototype, mapCoordinates);
if (TryComp<CartridgeAmmoComponent>(uid, out var cartridge))
SetCartridgeSpent(cartridge, !(bool) chamber);
EjectCartridge(uid);
}
component.Chambers[i] = null;
anyEmpty = true;
}
else
{
component.AmmoSlots[i] = null;
component.AmmoContainer.Remove(slot.Value);
if (!_netManager.IsClient)
EjectCartridge(slot.Value);
anyEmpty = true;
}
}
if (anyEmpty)
{
PlaySound(component.Owner, component.SoundEject?.GetSound(Random, ProtoManager), user);
UpdateAmmoCount(component.Owner);
UpdateRevolverAppearance(component);
Dirty(component);
}
}
private void UpdateRevolverAppearance(RevolverAmmoProviderComponent component)
{
if (!TryComp<AppearanceComponent>(component.Owner, out var appearance)) return;
appearance.SetData(AmmoVisuals.AmmoCount, GetRevolverCount(component));
appearance.SetData(AmmoVisuals.AmmoMax, component.Capacity);
}
protected virtual void SpinRevolver(RevolverAmmoProviderComponent component, EntityUid? user = null)
{
PlaySound(component.Owner, component.SoundSpin?.GetSound(Random, ProtoManager), user);
Popup(Loc.GetString("gun-revolver-spun"), component.Owner, user);
}
private void OnRevolverTakeAmmo(EntityUid uid, RevolverAmmoProviderComponent component, TakeAmmoEvent args)
{
var currentIndex = component.CurrentIndex;
Cycle(component, args.Shots);
// Revolvers provide the bullets themselves rather than the cartridges so they stay in the revolver.
for (var i = 0; i < args.Shots; i++)
{
var index = (currentIndex + i) % component.Capacity;
var chamber = component.Chambers[index];
// Get unspawned ent first if possible.
if (chamber != null)
{
if (chamber == true)
{
// TODO: This is kinda sussy boy
var ent = Spawn(component.FillPrototype, args.Coordinates);
if (TryComp<CartridgeAmmoComponent>(ent, out var cartridge))
{
component.Chambers[index] = false;
SetCartridgeSpent(cartridge, true);
args.Ammo.Add(EnsureComp<AmmoComponent>(Spawn(cartridge.Prototype, args.Coordinates)));
Del(ent);
continue;
}
component.Chambers[i] = null;
args.Ammo.Add(EnsureComp<AmmoComponent>(ent));
}
}
else if (component.AmmoSlots[index] != null)
{
var ent = component.AmmoSlots[index]!;
if (TryComp<CartridgeAmmoComponent>(ent, out var cartridge))
{
if (cartridge.Spent) continue;
SetCartridgeSpent(cartridge, true);
args.Ammo.Add(EnsureComp<AmmoComponent>(Spawn(cartridge.Prototype, args.Coordinates)));
continue;
}
component.AmmoContainer.Remove(ent.Value);
component.AmmoSlots[index] = null;
args.Ammo.Add(EnsureComp<AmmoComponent>(ent.Value));
Transform(ent.Value).Coordinates = args.Coordinates;
}
}
UpdateRevolverAppearance(component);
Dirty(component);
}
private void Cycle(RevolverAmmoProviderComponent component, int count = 1)
{
component.CurrentIndex = (component.CurrentIndex + count) % component.Capacity;
}
private void OnRevolverInit(EntityUid uid, RevolverAmmoProviderComponent component, ComponentInit args)
{
component.AmmoContainer = Containers.EnsureContainer<Container>(uid, RevolverContainer);
component.AmmoSlots = new EntityUid?[component.Capacity];
component.Chambers = new bool?[component.Capacity];
if (component.FillPrototype != null)
{
for (var i = 0; i < component.Capacity; i++)
{
if (component.AmmoSlots[i] != null)
{
component.Chambers[i] = null;
continue;
}
component.Chambers[i] = true;
}
}
}
[Serializable, NetSerializable]
protected sealed class RevolverAmmoProviderComponentState : ComponentState
{
public int CurrentIndex;
public EntityUid?[] AmmoSlots = default!;
public bool?[] Chambers = default!;
}
public sealed class RevolverSpinEvent : EntityEventArgs
{
}
}