diff --git a/Content.Client/SpaceArtillery/SpaceArtillerySystem.cs b/Content.Client/SpaceArtillery/SpaceArtillerySystem.cs new file mode 100644 index 00000000000..f82c3b7d93b --- /dev/null +++ b/Content.Client/SpaceArtillery/SpaceArtillerySystem.cs @@ -0,0 +1,7 @@ +using Content.Shared.SpaceArtillery; + +namespace Content.Shared.SpaceArtillery; + +public sealed class SpaceArtillerySystem : EntitySystem +{ +} diff --git a/Content.Server/Projectiles/ProjectileSystem.cs b/Content.Server/Projectiles/ProjectileSystem.cs index 0061b16e47c..551f30fd28f 100644 --- a/Content.Server/Projectiles/ProjectileSystem.cs +++ b/Content.Server/Projectiles/ProjectileSystem.cs @@ -7,6 +7,7 @@ using Content.Shared.Projectiles; using Robust.Shared.Physics.Events; using Robust.Shared.Player; +using Content.Shared.SpaceArtillery; //Frontier Modification namespace Content.Server.Projectiles; @@ -30,6 +31,23 @@ private void OnStartCollide(EntityUid uid, ProjectileComponent component, ref St if (args.OurFixtureId != ProjectileFixture || !args.OtherFixture.Hard || component.DamagedEntity || component is { Weapon: null, OnlyCollideWhenShot: true }) return; + + //Frontier code + // Makes sure that armament projectile doesnt damage the safezone + if(TryComp(args.OtherEntity, out var transformComponent)) + { + var _gridUid = transformComponent.GridUid; + + if(_gridUid is {Valid :true} gridUid) + { + if(HasComp(uid) && HasComp(gridUid)) + { + QueueDel(uid); + return; + } + } + } + //Frontier code ends here var target = args.OtherEntity; // it's here so this check is only done once before possible hit diff --git a/Content.Server/Shuttles/Components/IFFConsoleComponent.cs b/Content.Server/Shuttles/Components/IFFConsoleComponent.cs index 562bec51c26..35cea9c660c 100644 --- a/Content.Server/Shuttles/Components/IFFConsoleComponent.cs +++ b/Content.Server/Shuttles/Components/IFFConsoleComponent.cs @@ -1,9 +1,10 @@ using Content.Server.Shuttles.Systems; using Content.Shared.Shuttles.Components; +using Content.Shared.SpaceArtillery; //Frontier code modification namespace Content.Server.Shuttles.Components; -[RegisterComponent, Access(typeof(ShuttleSystem))] +[RegisterComponent, Access(typeof(ShuttleSystem),typeof(SpaceArtillerySystem))] //Frontier modification, added acces to SpaceArtillerySystem public sealed partial class IFFConsoleComponent : Component { /// @@ -11,4 +12,18 @@ public sealed partial class IFFConsoleComponent : Component /// [ViewVariables(VVAccess.ReadWrite), DataField("allowedFlags")] public IFFFlags AllowedFlags = IFFFlags.HideLabel; + +//Frontier Code - allows temporarily disabling IFF console + /// + /// Whether the console should be treated as temporarily disabled + /// + [ViewVariables(VVAccess.ReadWrite)] public bool IsDisabled = false; + + /// + /// Flags into which console will be forced into + /// Switches with main flags when armaments are active + /// + [ViewVariables(VVAccess.ReadWrite)] + public IFFFlags AccessableAllowedFlags = IFFFlags.None; +//Frontier Code ends here } diff --git a/Content.Server/_NF/SpaceArtillery/Components/BlockSpaceArtilleryProjectileGridComponent.cs b/Content.Server/_NF/SpaceArtillery/Components/BlockSpaceArtilleryProjectileGridComponent.cs new file mode 100644 index 00000000000..dd9a6de1979 --- /dev/null +++ b/Content.Server/_NF/SpaceArtillery/Components/BlockSpaceArtilleryProjectileGridComponent.cs @@ -0,0 +1,12 @@ +namespace Content.Shared.SpaceArtillery; +using Content.Shared.Construction.Prototypes; +using Robust.Shared.Prototypes; +using Robust.Shared.Serialization; +using Robust.Shared.Utility; + + +[RegisterComponent] +public sealed partial class BlockSpaceArtilleryProjectileGridComponent : Component +{ + +} \ No newline at end of file diff --git a/Content.Server/_NF/SpaceArtillery/Components/SpaceArtilleryComponent.cs b/Content.Server/_NF/SpaceArtillery/Components/SpaceArtilleryComponent.cs new file mode 100644 index 00000000000..0b495568d2b --- /dev/null +++ b/Content.Server/_NF/SpaceArtillery/Components/SpaceArtilleryComponent.cs @@ -0,0 +1,206 @@ +namespace Content.Shared.SpaceArtillery; +using Content.Shared.Construction.Prototypes; +using Content.Shared.DeviceLinking; +using Robust.Shared.Prototypes; +using Robust.Shared.Serialization; +using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype; +using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.List; +using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.Dictionary; +using Content.Shared.Actions; +using Robust.Shared.Utility; +using Content.Shared.Containers.ItemSlots; +using Content.Shared.Stacks; + +[RegisterComponent] +public sealed partial class SpaceArtilleryComponent : Component +{ + [ViewVariables(VVAccess.ReadWrite), DataField("coolantType", customTypeSerializer:typeof(PrototypeIdSerializer))] + public string CoolantType = "Coolant"; + + public static string CoolantSlotSlotId = "SpaceArtillery-CoolantSlot"; + + [DataField("SpaceArtillery-CoolantSlot")] + public ItemSlot CoolantSlot = new(); + + /// + /// Whether the space artillery need coolant to fire on top of ammunition or power + /// + [DataField("isCoolantRequiredToFire"),ViewVariables(VVAccess.ReadWrite)] public bool IsCoolantRequiredToFire = false; + + /// + /// Stored amount of coolant + /// + [DataField("coolantStored"), ViewVariables(VVAccess.ReadWrite)] + public int CoolantStored = 0; + + /// + /// Maximum amount of coolant that can fit + /// + [DataField("maxCoolantStored"), ViewVariables(VVAccess.ReadWrite)] + public int MaxCoolantStored = 90; + + /// + /// Amount of coolant consumed upon artillery firing + /// + [DataField("coolantConsumed"), ViewVariables(VVAccess.ReadWrite)] + public int CoolantConsumed = 1; + + /// + /// Whether the space artillery's safety is enabled or not + /// + [DataField("isArmed"),ViewVariables(VVAccess.ReadWrite)] public bool IsArmed = false; + + /// + /// Whether the space artillery has enough power + /// + [ViewVariables(VVAccess.ReadWrite)] public bool IsPowered = false; + + /// + /// Whether the space artillery's battery is being charged + /// + [ViewVariables(VVAccess.ReadWrite)] public bool IsCharging = false; + + /// + /// Rate of charging the battery + /// + [DataField("powerChargeRate"), ViewVariables(VVAccess.ReadWrite)] + public int PowerChargeRate = 3000; + + /// + /// Whether the space artillery requires whole vessel to activate its armaments, + /// Use these for any armaments with high destructive capability + /// + [DataField("isDestructive"),ViewVariables(VVAccess.ReadWrite)] public bool IsDestructive = true; + + /// + /// Whether the space artillery can send signals at all + /// + [DataField("isCapableOfSendingSignal"),ViewVariables(VVAccess.ReadWrite)] public bool IsCapableOfSendingSignal = true; + + /// + /// Whether the space artillery need power to operate remotely from signal + /// + [DataField("isPowerRequiredForSignal"),ViewVariables(VVAccess.ReadWrite)] public bool IsPowerRequiredForSignal = true; + + /// + /// Whether the space artillery need power to operate manually when mounted/buckled to + /// + [DataField("isPowerRequiredForMount"),ViewVariables(VVAccess.ReadWrite)] public bool IsPowerRequiredForMount = false; + + /// + /// Amount of power being used when operating + /// + [DataField("powerUsePassive"), ViewVariables(VVAccess.ReadWrite)] + public int PowerUsePassive = 600; + + /// + /// Whether the space artillery needs power to fire a shot + /// + [DataField("isPowerRequiredToFire"),ViewVariables(VVAccess.ReadWrite)] public bool IsPowerRequiredToFire = false; + + /// + /// Amount of power used when firing + /// + [DataField("powerUseActive"), ViewVariables(VVAccess.ReadWrite)] + public int PowerUseActive = 6000; + + + /// + /// Maximum velocity which grid can reach from recoil impulse, at moment there is high variance, will go above it by 10 + /// + [DataField("velocityLimitRecoilGrid"), ViewVariables(VVAccess.ReadWrite)] + public float VelocityLimitRecoilGrid = 30; + + /// + /// Amount of power used when firing + /// + [DataField("linearRecoilGrid"), ViewVariables(VVAccess.ReadWrite)] + public float LinearRecoilGrid = 30; + + /// + /// Amount of power used when firing + /// + [DataField("angularInstabilityGrid"), ViewVariables(VVAccess.ReadWrite)] + public float AngularInstabilityGrid = 10; + + + /// + /// Maximum velocity which unanchored weapon can reach from recoil impulse + /// + [DataField("velocityLimitRecoilWeapon"), ViewVariables(VVAccess.ReadWrite)] + public float VelocityLimitRecoilWeapon = 30; + + /// + /// Amount of power used when firing + /// + [DataField("linearRecoilWeapon"), ViewVariables(VVAccess.ReadWrite)] + public float LinearRecoilWeapon = 60; + + /// + /// Amount of power used when firing + /// + [DataField("angularInstabilityWeapon"), ViewVariables(VVAccess.ReadWrite)] + public float AngularInstabilityWeapon = 30; + + +///Sink Ports + /// + /// Signal port that makes space artillery fire. + /// + [DataField("spaceArtilleryFirePort", customTypeSerializer: typeof(PrototypeIdSerializer))] + public string SpaceArtilleryFirePort = "SpaceArtilleryFire"; + + /// + /// Signal port that toggles artillery's safety, which is the combat mode + /// + [DataField("spaceArtilleryToggleSafetyPort", customTypeSerializer: typeof(PrototypeIdSerializer))] + public string SpaceArtilleryToggleSafetyPort = "SpaceArtilleryToggleSafety"; + + /// + /// Signal port that sets artillery's safety to "SAFE" + /// + [DataField("spaceArtilleryOnSafetyPort", customTypeSerializer: typeof(PrototypeIdSerializer))] + public string SpaceArtilleryOnSafetyPort = "SpaceArtilleryOnSafety"; + + /// + /// Signal port that sets artillery's safety to "ARMED" + /// + [DataField("spaceArtilleryOffSafetyPort", customTypeSerializer: typeof(PrototypeIdSerializer))] + public string SpaceArtilleryOffSafetyPort = "SpaceArtilleryOffSafety"; + +///Source Ports + /// + /// The port that gets set to high while the alarm is in the danger state, and low when not. + /// + [DataField("spaceArtilleryDetectedFiringPort", customTypeSerializer: typeof(PrototypeIdSerializer))] + public string SpaceArtilleryDetectedFiringPort = "SpaceArtilleryDetectedFiring"; + + /// + /// The port that gets set to high while the alarm is in the danger state, and low when not. + /// + [DataField("spaceArtilleryDetectedMalfunctionPort", customTypeSerializer: typeof(PrototypeIdSerializer))] + public string SpaceArtilleryDetectedMalfunctionPort = "SpaceArtilleryDetectedMalfunction"; + + /// + /// The port that gets set to high while the alarm is in the danger state, and low when not. + /// + [DataField("spaceArtilleryDetectedSafetyChangePort", customTypeSerializer: typeof(PrototypeIdSerializer))] + public string SpaceArtilleryDetectedSafetyChangePort = "SpaceArtilleryDetectedSafetyChange"; + + +///Actions + /// + /// The action for firing the artillery when mounted + /// + + [DataField("fireAction", customTypeSerializer: typeof(PrototypeIdSerializer))] + public string? FireAction = "ActionSpaceArtilleryFire"; + + /// + /// The action for the weapon (if any) + /// + [DataField("fireActionEntity")] + [ViewVariables(VVAccess.ReadWrite)] + public EntityUid? FireActionEntity; + +} \ No newline at end of file diff --git a/Content.Server/_NF/SpaceArtillery/Components/SpaceArtilleryGridComponent.cs b/Content.Server/_NF/SpaceArtillery/Components/SpaceArtilleryGridComponent.cs new file mode 100644 index 00000000000..b1c13819f6e --- /dev/null +++ b/Content.Server/_NF/SpaceArtillery/Components/SpaceArtilleryGridComponent.cs @@ -0,0 +1,72 @@ +namespace Content.Shared.SpaceArtillery; +using Content.Shared.Construction.Prototypes; +using Content.Shared.DeviceLinking; +using Robust.Shared.Prototypes; +using Robust.Shared.Serialization; +using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype; +using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.List; +using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.Dictionary; +using Content.Shared.Actions; +using Robust.Shared.Utility; +using Content.Shared.Containers.ItemSlots; +using Content.Shared.Stacks; +using Content.Shared.Shuttles.Components; + + + +/// +/// Component dictates if grid is allowed to utilise space artillery armaments at all +/// +[RegisterComponent] +public sealed partial class SpaceArtilleryGridComponent : Component +{ + /// + /// Whether the grid has fully activated the armaments + /// + [ViewVariables(VVAccess.ReadWrite)] public bool IsActive = false; + + /// + /// Whether the grid started activating the armaments, safety delay + /// + [ViewVariables(VVAccess.ReadWrite)] public bool IsCharging = false; + + [ViewVariables] + public TimeSpan LastActivationTime; + + [ViewVariables] + public TimeSpan ChargeUpDuration = TimeSpan.FromSeconds(30); + + [ViewVariables] + public TimeSpan ChargeUpEndTime; + + [ViewVariables] + public TimeSpan CooldownDuration = TimeSpan.FromSeconds(120); + + [ViewVariables] + public TimeSpan CooldownEndTime; + + /// + /// Default color to use for IFF if no component is found. + /// + public static readonly Color IFFColor = Color.Aquamarine; + + /// + /// Default color to use for activated armament IFF if no component is found. + /// + public static readonly Color IFFArmedColor = Color.Red; + + [ViewVariables(VVAccess.ReadWrite), DataField] + public IFFFlags Flags = IFFFlags.None; + + /// + /// Color for this to show up on IFF. + /// + [ViewVariables(VVAccess.ReadWrite), DataField] + public Color Color = IFFColor; + + /// + /// Color for armed vessel to show up on IFF. + /// + [ViewVariables(VVAccess.ReadWrite), DataField] + public Color ArmedColor = IFFArmedColor; +} \ No newline at end of file diff --git a/Content.Server/_NF/SpaceArtillery/Components/SpaceArtilleryProjectileComponent.cs b/Content.Server/_NF/SpaceArtillery/Components/SpaceArtilleryProjectileComponent.cs new file mode 100644 index 00000000000..c92ed093b57 --- /dev/null +++ b/Content.Server/_NF/SpaceArtillery/Components/SpaceArtilleryProjectileComponent.cs @@ -0,0 +1,12 @@ +namespace Content.Shared.SpaceArtillery; +using Content.Shared.Construction.Prototypes; +using Robust.Shared.Prototypes; +using Robust.Shared.Serialization; +using Robust.Shared.Utility; + + +[RegisterComponent] +public sealed partial class SpaceArtilleryProjectileComponent : Component +{ + +} \ No newline at end of file diff --git a/Content.Server/_NF/SpaceArtillery/SpaceArtilleryGridActivationEvents.cs b/Content.Server/_NF/SpaceArtillery/SpaceArtilleryGridActivationEvents.cs new file mode 100644 index 00000000000..ccd6a151a4b --- /dev/null +++ b/Content.Server/_NF/SpaceArtillery/SpaceArtilleryGridActivationEvents.cs @@ -0,0 +1,10 @@ + +namespace Content.Shared.SpaceArtillery; + + +[ByRefEvent] +public readonly record struct SpaceArtilleryGridActivationEvent; + + +[ByRefEvent] +public readonly record struct SpaceArtilleryGridDeactivationEvent; \ No newline at end of file diff --git a/Content.Server/_NF/SpaceArtillery/SpaceArtillerySystem.cs b/Content.Server/_NF/SpaceArtillery/SpaceArtillerySystem.cs new file mode 100644 index 00000000000..adcdee1f13b --- /dev/null +++ b/Content.Server/_NF/SpaceArtillery/SpaceArtillerySystem.cs @@ -0,0 +1,683 @@ +using Content.Shared.SpaceArtillery; +using Content.Server.DeviceLinking.Events; +using Content.Server.Projectiles; +using Content.Server.Weapons.Ranged.Systems; +using Content.Shared.Weapons.Ranged.Systems; +using Content.Server.Weapons.Ranged.Components; +using Content.Shared.Weapons.Ranged.Components; +using Content.Shared.Weapons.Ranged.Events; +using Content.Shared.Interaction.Events; +using System.Numerics; +using Content.Shared.CombatMode; +using Content.Shared.Interaction; +using Content.Shared.Examine; +using Robust.Shared.Map; +using Robust.Shared.Physics.Components; +using Robust.Shared.Physics; +using Robust.Shared.Physics.Systems; +using Content.Shared.Actions; +using Content.Shared.Buckle; +using Content.Shared.Buckle.Components; +using Content.Server.Power.Components; +using Content.Server.Power.EntitySystems; +using Content.Shared.Power; +using Content.Shared.Rounding; +using Robust.Shared.Containers; +using Content.Shared.Stacks; +using Content.Server.Stack; +using Robust.Shared.Prototypes; +using Content.Shared.Containers.ItemSlots; +using Robust.Shared.Random; +using Content.Server.DeviceLinking.Components; +using Content.Server.DeviceLinking.Systems; +using Content.Server.DeviceNetwork; +using Robust.Shared.Timing; +using Content.Shared.Shuttles.Systems; +using Content.Shared.Shuttles.Components; +using Content.Server.Shuttles.Components; + +namespace Content.Shared.SpaceArtillery; + +public sealed partial class SpaceArtillerySystem : EntitySystem +{ + [Dependency] private readonly IPrototypeManager _prototypeManager = default!; + [Dependency] private readonly ProjectileSystem _projectile = default!; + [Dependency] private readonly GunSystem _gun = default!; + [Dependency] private readonly SharedCombatModeSystem _combat = default!; + //[Dependency] private readonly RotateToFaceSystem _rotate = default!; + [Dependency] private readonly SharedActionsSystem _actionsSystem = default!; + [Dependency] private readonly SharedBuckleSystem _buckle = default!; + [Dependency] private readonly SharedContainerSystem _containerSystem = default!; + [Dependency] private readonly ItemSlotsSystem _itemSlotsSystem = default!; + [Dependency] private readonly SharedPhysicsSystem _physicsSystem = default!; + [Dependency] private readonly IRobustRandom _random = default!; + [Dependency] private readonly DeviceLinkSystem _deviceLink = default!; + [Dependency] private readonly IGameTiming _gameTiming = default!; //var variable = _gameTiming.CurTime; - to set with current time + [Dependency] private readonly SharedShuttleSystem _shuttleSystem = default!; + + private const float ShootSpeed = 30f; + private const float distance = 100; + private const float rotOffset = 3.14159265f; //Without it the artillery would be shooting backwards.The rotation is in radians and equals to 180 degrees + //private readonly TransformSystem _transform; + + protected ISawmill Sawmill = default!; + + public override void Initialize() + { + base.Initialize(); + Sawmill = Logger.GetSawmill("SpaceArtillery"); + SubscribeLocalEvent(OnSignalReceived); + SubscribeLocalEvent(OnBuckleChange); + SubscribeLocalEvent(OnFireAction); + SubscribeLocalEvent(OnShotEvent); + SubscribeLocalEvent(OnEmptyShotEvent); + SubscribeLocalEvent(OnApcChanged); + SubscribeLocalEvent(OnBatteryChargeChanged); + SubscribeLocalEvent(OnCoolantSlotChanged); + SubscribeLocalEvent(OnCoolantSlotChanged); + SubscribeLocalEvent(OnExamine); + SubscribeLocalEvent(OnComponentInit); + SubscribeLocalEvent(OnComponentRemove); + + ///TODO Integrate vessel armament deactivation event + SubscribeLocalEvent(OnMapInit); + SubscribeLocalEvent(OnActivationEvent); + + //This is to ensure proper operation of armed vessel + SubscribeLocalEvent(OnIFFInit); + } + + private void OnMapInit(EntityUid uid, SpaceArtilleryGridComponent componentGrid, MapInitEvent args) + { + componentGrid.LastActivationTime = _gameTiming.CurTime; + componentGrid.CooldownEndTime = componentGrid.LastActivationTime + componentGrid.CooldownDuration; + } + + + private void OnComponentInit(EntityUid uid, SpaceArtilleryComponent component, ComponentInit args) + { + if(component.IsCoolantRequiredToFire == true) + _itemSlotsSystem.AddItemSlot(uid, SpaceArtilleryComponent.CoolantSlotSlotId, component.CoolantSlot); + } + + private void OnComponentRemove(EntityUid uid, SpaceArtilleryComponent component, ComponentRemove args) + { + _itemSlotsSystem.RemoveItemSlot(uid, component.CoolantSlot); + } + + private void OnExamine(EntityUid uid, SpaceArtilleryComponent component, ExaminedEvent args) + { + if (!args.IsInDetailsRange) + return; + + + if(component.IsArmed == true) + { + args.PushMarkup(Loc.GetString("space-artillery-on-examine-safe")); + } + else + { + args.PushMarkup(Loc.GetString("space-artillery-on-examine-armed")); + } + + if(component.IsCoolantRequiredToFire == true) + { + args.PushMarkup(Loc.GetString("space-artillery-on-examine-coolant-consumed", + ("consumed_coolant", component.CoolantConsumed))); + + args.PushMarkup(Loc.GetString("space-artillery-on-examine-coolant-count", + ("current_coolant", component.CoolantStored), ("max_coolant", component.MaxCoolantStored))); + } + + } + + private void OnSignalReceived(EntityUid uid, SpaceArtilleryComponent component, ref SignalReceivedEvent args) + { + if(component.IsPowered == true || component.IsPowerRequiredForSignal == false) + { + //Sawmill.Info($"Space Artillery has been pinged. Entity: {ToPrettyString(uid)}"); + if (args.Port == component.SpaceArtilleryFirePort && component.IsArmed == true) + { + if(TryComp(uid, out var battery)) + { + if((component.IsPowered == true && battery.Charge >= component.PowerUseActive) || component.IsPowerRequiredToFire == false) + { + if((component.IsCoolantRequiredToFire == true && component.CoolantStored >= component.CoolantConsumed) || component.IsCoolantRequiredToFire == false) + { + TryFireArtillery(uid, component, battery); + } else + OnMalfunction(uid,component); + } else + OnMalfunction(uid,component); + } + } + if (args.Port == component.SpaceArtilleryToggleSafetyPort) + { + ///WIP TEST DEBUG----------------------------------------------------------------------------------- + if(TryComp(uid, out var transformComponent)) + { + var _gridUid = transformComponent.GridUid; + + if(_gridUid is {Valid :true} gridUid) + { + var activationEvent = new SpaceArtilleryGridActivationEvent(); + RaiseLocalEvent(gridUid, ref activationEvent); + } + } + + ///TEST DEBUG-------------------------------------------------------------------------------- + + if (TryComp(uid, out var combat)) + { + if(combat.IsInCombatMode == false && combat.IsInCombatMode != null) + { + _combat.SetInCombatMode(uid, true, combat); + component.IsArmed = true; + + if(component.IsCapableOfSendingSignal == true) + _deviceLink.SendSignal(uid, component.SpaceArtilleryDetectedSafetyChangePort, true); + } + else + { + _combat.SetInCombatMode(uid, false, combat); + component.IsArmed = false; + + if(component.IsCapableOfSendingSignal == true) + _deviceLink.SendSignal(uid, component.SpaceArtilleryDetectedSafetyChangePort, true); + } + } + } + if (args.Port == component.SpaceArtilleryOnSafetyPort) + { + if (TryComp(uid, out var combat) && combat.IsInCombatMode != null) + { + if(combat.IsInCombatMode == true && component.IsCapableOfSendingSignal == true) + _deviceLink.SendSignal(uid, component.SpaceArtilleryDetectedSafetyChangePort, true); + + _combat.SetInCombatMode(uid, false, combat); + component.IsArmed = false; + + } + } + if (args.Port == component.SpaceArtilleryOffSafetyPort) + { + if (TryComp(uid, out var combat) && combat.IsInCombatMode != null) + { + if(combat.IsInCombatMode == false && component.IsCapableOfSendingSignal == true) + _deviceLink.SendSignal(uid, component.SpaceArtilleryDetectedSafetyChangePort, true); + + _combat.SetInCombatMode(uid, true, combat); + component.IsArmed = true; + } + } + } else + OnMalfunction(uid,component); + } + + private void OnBuckleChange(EntityUid uid, SpaceArtilleryComponent component, ref BuckleChangeEvent args) + { + // Once Gunner buckles + if (args.Buckling) + { + + // Update actions + + if (TryComp(args.BuckledEntity, out var actions)) + { + _actionsSystem.AddAction(args.BuckledEntity, ref component.FireActionEntity, component.FireAction, uid, actions); + } + return; + } + + // Once gunner unbuckles + // Clean up actions + _actionsSystem.RemoveProvidedActions(args.BuckledEntity, uid); + + } + + /// + /// This fires when the gunner presses the fire action + /// + + private void OnFireAction(EntityUid uid, SpaceArtilleryComponent component, FireActionEvent args) + { + if((component.IsPowered == true || component.IsPowerRequiredForMount == false) && component.IsArmed == true) + { + if(TryComp(uid, out var battery)) + { + if((component.IsPowered == true && battery.Charge >= component.PowerUseActive) || component.IsPowerRequiredToFire == false) + { + if((component.IsCoolantRequiredToFire == true && component.CoolantStored >= component.CoolantConsumed) || component.IsCoolantRequiredToFire == false) + { + if (args.Handled) + return; + + TryFireArtillery(uid, component, battery); + + args.Handled = true; + } else + OnMalfunction(uid,component); + } else + OnMalfunction(uid,component); + } + } else + OnMalfunction(uid,component); + } + + + private void OnApcChanged(EntityUid uid, SpaceArtilleryComponent component, ref PowerChangedEvent args){ + + if(TryComp(uid, out var batteryCharger)){ + + if (args.Powered) + { + component.IsCharging = true; + batteryCharger.AutoRecharge = true; + batteryCharger.AutoRechargeRate = component.PowerChargeRate; + } + else + { + component.IsCharging = false; + batteryCharger.AutoRecharge = true; + batteryCharger.AutoRechargeRate = component.PowerUsePassive * -1; + + if(TryComp(uid, out var battery)) + battery.CurrentCharge -= component.PowerUsePassive; //It is done so that BatterySelfRecharger will get start operating instead of being blocked by fully charged battery + } + } + } + + + private void OnBatteryChargeChanged(EntityUid uid, SpaceArtilleryComponent component, ref ChargeChangedEvent args){ + + if(args.Charge > 0) + { + component.IsPowered = true; + } + else + { + component.IsPowered = false; + } + + if(TryComp(uid, out var apcPowerReceiver) && TryComp(uid, out var battery)) + { + if(battery.IsFullyCharged == false) + { + apcPowerReceiver.Load = component.PowerUsePassive + component.PowerChargeRate; + } + else + { + apcPowerReceiver.Load = component.PowerUsePassive; + } + } + } + + private void OnCoolantSlotChanged(EntityUid uid, SpaceArtilleryComponent component, ContainerModifiedMessage args) + { + GetInsertedCoolantAmount(component, out var storage); + + // validating the coolant slot was setup correctly in the yaml + if (component.CoolantSlot.ContainerSlot is not BaseContainer coolantSlot) + { + return; + } + + // validate stack prototypes + if (!TryComp(component.CoolantSlot.ContainerSlot.ContainedEntity, out var stackComponent) || + stackComponent.StackTypeId == null) + { + return; + } + + // and then check them against the Armament's CoolantType + if (_prototypeManager.Index(component.CoolantType) != _prototypeManager.Index(stackComponent.StackTypeId)) + { + return; + } + + var currentCoolant = component.CoolantStored; + var maxCoolant = component.MaxCoolantStored; + var totalCoolantPresent = currentCoolant + storage; + if(totalCoolantPresent > maxCoolant) + { + var remainingCoolant = totalCoolantPresent - maxCoolant; + stackComponent.Count = remainingCoolant; + stackComponent.UiUpdateNeeded = true; + component.CoolantStored = maxCoolant; + } + else + { + component.CoolantStored = totalCoolantPresent; + _containerSystem.CleanContainer(coolantSlot); + } + } + + private void TryFireArtillery(EntityUid uid, SpaceArtilleryComponent component, BatteryComponent battery) + { + var xform = Transform(uid); + + if (!_gun.TryGetGun(uid, out var gunUid, out var gun)) + { + OnMalfunction(uid,component); + return; + } + + if(TryComp(uid, out var transformComponent)){ + + var worldPosX = transformComponent.WorldPosition.X; + var worldPosY = transformComponent.WorldPosition.Y; + var worldRot = transformComponent.WorldRotation+rotOffset; + var targetSpot = new Vector2(worldPosX - distance * (float) Math.Sin(worldRot), worldPosY + distance * (float) Math.Cos(worldRot)); + + var _gridUid = transformComponent.GridUid; + + EntityCoordinates targetCordinates; + targetCordinates = new EntityCoordinates(xform.MapUid!.Value, targetSpot); + + ///Checks if armaments on grid are activated, or its a harmless armament + if(TryComp(_gridUid, out var componentGrid)) + { + if(componentGrid.IsActive == true || component.IsDestructive == false) + { + ///Fires the armament, sending signal to gun system + _gun.AttemptShoot(uid, gunUid, gun, targetCordinates); + } + else + { + OnMalfunction(uid,component); + } + } + else if(component.IsDestructive == false) + { + ///Fires the armament, sending signal to gun system + _gun.AttemptShoot(uid, gunUid, gun, targetCordinates); + } + + } + } + + private void GetInsertedCoolantAmount(SpaceArtilleryComponent component, out int amount) + { + amount = 0; + var coolantEntity = component.CoolantSlot.ContainerSlot?.ContainedEntity; + + if (!TryComp(coolantEntity, out var coolantStack) || + coolantStack.StackTypeId != component.CoolantType) + { + return; + } + + amount = coolantStack.Count; + return; + } + + ///TODO Fix empty cartridge allowing recoil to be activated + ///TOD add check for args.FiredProjectiles + private void OnShotEvent(EntityUid uid, SpaceArtilleryComponent component, AmmoShotEvent args) + { + if(args.FiredProjectiles.Count == 0) + { + OnMalfunction(uid,component); + return; + } + + if(TryComp(uid, out var transformComponent) && TryComp(uid, out var battery)){ + var worldPosX = transformComponent.WorldPosition.X; + var worldPosY = transformComponent.WorldPosition.Y; + var worldRot = transformComponent.WorldRotation+rotOffset; + var targetSpot = new Vector2(worldPosX - distance * (float) Math.Sin(worldRot), worldPosY + distance * (float) Math.Cos(worldRot)); + + var _gridUid = transformComponent.GridUid; + + if(component.IsCapableOfSendingSignal == true) + _deviceLink.SendSignal(uid, component.SpaceArtilleryDetectedFiringPort, true); + + if(component.IsPowerRequiredToFire == true) + { + battery.CurrentCharge -= component.PowerUseActive; + } + if(component.IsCoolantRequiredToFire == true) + { + component.CoolantStored -= component.CoolantConsumed; + } + + ///Space Recoil is handled here + if(transformComponent.Anchored == true) + { + if(TryComp(_gridUid, out var gridPhysicsComponent) && _gridUid is {Valid :true} gridUid) + { + var gridMass = gridPhysicsComponent.FixturesMass; + var linearVelocityLimitGrid = component.VelocityLimitRecoilGrid; + var oldLinearVelocity = gridPhysicsComponent.LinearVelocity; + var oldAngularVelocity = gridPhysicsComponent.AngularVelocity; + + var oldLinearRelativeVelocity = (float) Math.Sqrt((oldLinearVelocity.X * oldLinearVelocity.X) + (oldLinearVelocity.Y * oldLinearVelocity.Y)); + + //Check if grid isn't flying faster already than the velocity limit + if(oldLinearRelativeVelocity >= linearVelocityLimitGrid) + return; + + var targetSpotRecoil = new Vector2(worldPosX - component.LinearRecoilGrid * (float) Math.Sin(worldRot), worldPosY + component.LinearRecoilGrid * (float) Math.Cos(worldRot)); + var recoilX = (worldPosX - targetSpotRecoil.X); + var recoilY = (worldPosY - targetSpotRecoil.Y); + + var newLinearVelocity = new Vector2(oldLinearVelocity.X + (recoilX/gridMass), oldLinearVelocity.Y + (recoilY/gridMass)); + + + var newLinearRelativeVelocity = (float) Math.Sqrt((newLinearVelocity.X * newLinearVelocity.X) + (newLinearVelocity.Y * newLinearVelocity.Y)); + + //Check if new velocity isn't faster than the limit + if(newLinearRelativeVelocity > linearVelocityLimitGrid) + { + //Decrease X and Y velocity so that relative velocity matches the limit + newLinearVelocity.X = newLinearVelocity.X * linearVelocityLimitGrid / newLinearRelativeVelocity; + newLinearVelocity.Y = newLinearVelocity.Y * linearVelocityLimitGrid / newLinearRelativeVelocity; + } + + var randomAngularInstability = _random.Next((int) -component.AngularInstabilityGrid, (int) component.AngularInstabilityGrid); + var newAngularVelocity = oldAngularVelocity + (randomAngularInstability/gridMass); + + + _physicsSystem.SetLinearVelocity(gridUid, newLinearVelocity); + _physicsSystem.SetAngularVelocity(gridUid, newAngularVelocity); + + Sawmill.Info($"Space Artillery recoil. RecoilX: {recoilX} RecoilY: {recoilY} Instability: {randomAngularInstability}"); + Sawmill.Info($"Space Artillery recoil. LinearVelocityX: {newLinearVelocity.X}/{oldLinearVelocity.X} LinearVelocityY: {newLinearVelocity.Y}/{oldLinearVelocity.Y} AngularInstability: {newAngularVelocity}/{oldAngularVelocity}"); + + //(float) Math.Sqrt(GetSeverityModifier()); + } + } + else + { + if(TryComp(uid, out var weaponPhysicsComponent) && uid is {Valid :true} weaponUid) + { + var weaponMass = weaponPhysicsComponent.FixturesMass; + var linearVelocityLimitWeapon = component.VelocityLimitRecoilWeapon; + var oldLinearVelocity = weaponPhysicsComponent.LinearVelocity; + var oldAngularVelocity = weaponPhysicsComponent.AngularVelocity; + + var oldLinearRelativeVelocity = (float) Math.Sqrt((oldLinearVelocity.X * oldLinearVelocity.X) + (oldLinearVelocity.Y * oldLinearVelocity.Y)); + + //Check if weapon isn't flying faster already than the velocity limit + if(oldLinearRelativeVelocity >= linearVelocityLimitWeapon) + return; + + var targetSpotRecoil = new Vector2(worldPosX - component.LinearRecoilWeapon * (float) Math.Sin(worldRot), worldPosY + component.LinearRecoilWeapon * (float) Math.Cos(worldRot)); + var recoilX = (worldPosX - targetSpotRecoil.X); + var recoilY = (worldPosY - targetSpotRecoil.Y); + + var newLinearVelocity = new Vector2(oldLinearVelocity.X + (recoilX/weaponMass), oldLinearVelocity.Y + (recoilY/weaponMass)); + + + var newLinearRelativeVelocity = (float) Math.Sqrt((newLinearVelocity.X * newLinearVelocity.X) + (newLinearVelocity.Y * newLinearVelocity.Y)); + + //Check if new velocity isn't faster than the limit + if(newLinearRelativeVelocity > linearVelocityLimitWeapon) + { + //Decrease X and Y velocity so that relative velocity matches the limit + newLinearVelocity.X = newLinearVelocity.X * linearVelocityLimitWeapon / newLinearRelativeVelocity; + newLinearVelocity.Y = newLinearVelocity.Y * linearVelocityLimitWeapon / newLinearRelativeVelocity; + } + + var randomAngularInstability = _random.Next((int) -component.AngularInstabilityWeapon, (int) component.AngularInstabilityWeapon); + var newAngularVelocity = oldAngularVelocity + (randomAngularInstability/weaponMass); + + + _physicsSystem.SetLinearVelocity(uid, newLinearVelocity); + _physicsSystem.SetAngularVelocity(uid, newAngularVelocity); + + //(float) Math.Sqrt(GetSeverityModifier()); + } + } + } + } + + private void OnEmptyShotEvent(EntityUid uid, SpaceArtilleryComponent component, OnEmptyGunShotEvent args) + { + OnMalfunction(uid,component); + } + + private void OnMalfunction(EntityUid uid, SpaceArtilleryComponent component) + { + if(component.IsCapableOfSendingSignal == true) + _deviceLink.SendSignal(uid, component.SpaceArtilleryDetectedMalfunctionPort, true); + } + + + +///Armed vessels handling +//TODO Code it much much better + + ///Prevents built IFF console from being capable of changing armed vessel's IFF settings + private void OnIFFInit(EntityUid uid, IFFConsoleComponent iffComponent, ComponentInit args) + { + if(TryComp(uid, out var transformComponent)) + { + var _gridUid = transformComponent.GridUid; + + if(_gridUid is {Valid :true} gridUid) + { + if(TryComp(gridUid, out var SpaceArtilleryGridComponent)) + { + if(SpaceArtilleryGridComponent.IsActive == true || SpaceArtilleryGridComponent.IsCharging == true) + { + var _oldFlags = iffComponent.AllowedFlags; + var _newFlags = iffComponent.AccessableAllowedFlags; + + iffComponent.AllowedFlags = _newFlags; + iffComponent.AccessableAllowedFlags = _oldFlags; + + iffComponent.IsDisabled = true; + + var ev = new AnchorStateChangedEvent(transformComponent); + RaiseLocalEvent(uid, ref ev, false); + } + } + } + } + } + + + private void OnActivationEvent(EntityUid GridUid, SpaceArtilleryGridComponent componentGrid, ref SpaceArtilleryGridActivationEvent args) + { + + if(componentGrid.IsActive == true) + { + if(_gameTiming.CurTime >= componentGrid.CooldownEndTime) + { + componentGrid.IsActive = false; + + if(TryComp(GridUid, out var IffComponent)) + { + //IffComponent.Color = componentGrid.Color; + _shuttleSystem.SetIFFColor(GridUid, componentGrid.Color, IffComponent); + //_shuttleSystem.AddIFFFlag(GridUid, IFFFlags.Hide); + //_shuttleSystem.AddIFFFlag(GridUid, IFFFlags.HideLabel); + + var query = EntityQueryEnumerator(); + while (query.MoveNext(out var uid, out var comp)) + { + if(TryComp(uid, out var transformComponent)) + { + var _gridUid = transformComponent.GridUid; + + if(_gridUid is {Valid :true} gridUid && gridUid == GridUid && comp.IsDisabled == true) + { + var _oldFlags = comp.AllowedFlags; + var _newFlags = comp.AccessableAllowedFlags; + + comp.AllowedFlags = _newFlags; + comp.AccessableAllowedFlags = _oldFlags; + + comp.IsDisabled = false; + + var ev = new AnchorStateChangedEvent(transformComponent); + RaiseLocalEvent(uid, ref ev, false); + } + } + } + } + } + } + else if(componentGrid.IsCharging == true) + { + if(_gameTiming.CurTime >= componentGrid.ChargeUpEndTime) + { + componentGrid.IsCharging = false; + componentGrid.IsActive = true; + } + } + else + { + componentGrid.IsCharging = true; + + componentGrid.LastActivationTime = _gameTiming.CurTime; + componentGrid.ChargeUpEndTime = componentGrid.LastActivationTime + componentGrid.ChargeUpDuration; + componentGrid.CooldownEndTime = componentGrid.LastActivationTime + componentGrid.CooldownDuration; + + if(TryComp(GridUid, out var IffComponent)) + { + //IffComponent.Color = componentGrid.ArmedColor; + //IffComponent.Flags = componentGrid.Flags; + ///TODO have it affect IFF consoles and disable their ability + _shuttleSystem.SetIFFColor(GridUid, componentGrid.ArmedColor, IffComponent); + _shuttleSystem.RemoveIFFFlag(GridUid, IFFFlags.Hide); + _shuttleSystem.RemoveIFFFlag(GridUid, IFFFlags.HideLabel); + + var query = EntityQueryEnumerator(); + while (query.MoveNext(out var uid, out var comp)) + { + if(TryComp(uid, out var transformComponent)) + { + var _gridUid = transformComponent.GridUid; + + if(_gridUid is {Valid :true} gridUid && gridUid == GridUid && comp.IsDisabled == false) + { + var _oldFlags = comp.AllowedFlags; + var _newFlags = comp.AccessableAllowedFlags; + + comp.AllowedFlags = _newFlags; + comp.AccessableAllowedFlags = _oldFlags; + + comp.IsDisabled = true; + + var ev = new AnchorStateChangedEvent(transformComponent); + RaiseLocalEvent(uid, ref ev, false); + } + } + } + } + } + } +} + + + + +// Raise event to activate armaments for the grid + /* var activationEvent = new SpaceArtilleryGridActivationEvent(true, uid, GridUid); + RaiseLocalEvent(GridUid, activationEvent); + + if (activationEvent.Handled) + return; + */ \ No newline at end of file diff --git a/Content.Shared/SpaceArtillery/SharedSpaceArtillerySystem.cs b/Content.Shared/SpaceArtillery/SharedSpaceArtillerySystem.cs new file mode 100644 index 00000000000..934efd2b20d --- /dev/null +++ b/Content.Shared/SpaceArtillery/SharedSpaceArtillerySystem.cs @@ -0,0 +1,13 @@ +using Content.Shared.Actions; + +namespace Content.Shared.SpaceArtillery; + +public sealed class SharedSpaceArtillerySystem : EntitySystem +{ +} +/// +/// Raised when someone fires the artillery +/// +public sealed partial class FireActionEvent : InstantActionEvent +{ +} \ No newline at end of file diff --git a/Resources/Locale/en-US/_NF/space_artillery/examine.ftl b/Resources/Locale/en-US/_NF/space_artillery/examine.ftl new file mode 100644 index 00000000000..40c8f6796f1 --- /dev/null +++ b/Resources/Locale/en-US/_NF/space_artillery/examine.ftl @@ -0,0 +1,9 @@ +space-artillery-on-examine-armed = Armament mode: [bold][color=green]SAFE[/color][/bold] + +space-artillery-on-examine-safe = Armament mode: [bold][color=red]ARMED[/color][/bold] + + + +space-artillery-on-examine-coolant-consumed = Consumed coolant: [bold][color=cyan]{$consumed_coolant}[/color][/bold] + +space-artillery-on-examine-coolant-count = Remaining coolant: [bold][color=cyan]{$current_coolant} / {$max_coolant}[/color][/bold] diff --git a/Resources/Locale/en-US/_NF/space_artillery/receiver_ports.ftl b/Resources/Locale/en-US/_NF/space_artillery/receiver_ports.ftl new file mode 100644 index 00000000000..a3dd754a553 --- /dev/null +++ b/Resources/Locale/en-US/_NF/space_artillery/receiver_ports.ftl @@ -0,0 +1,11 @@ +signal-port-name-space-artillery-fire = Fire Armament +signal-port-description-space-artillery-fire = Controls Space Artillery's firing mechanism. + +signal-port-name-space-artillery-toggle-safety = Toggle Safety +signal-port-description-space-artillery-toggle-safety = Toggles Space Artillery's safety mechanism. + +signal-port-name-space-artillery-on-safety = On Safety +signal-port-description-space-artillery-on-safety = Enables Space Artillery's safety mechanism, preventing it from firing. + +signal-port-name-space-artillery-off-safety = Off Safety +signal-port-description-space-artillery-off-safety = Disables Space Artillery's safety mechanism, readying it for firing. \ No newline at end of file diff --git a/Resources/Locale/en-US/_NF/space_artillery/transmitter_ports.ftl b/Resources/Locale/en-US/_NF/space_artillery/transmitter_ports.ftl new file mode 100644 index 00000000000..de1a4248bad --- /dev/null +++ b/Resources/Locale/en-US/_NF/space_artillery/transmitter_ports.ftl @@ -0,0 +1,8 @@ +signal-port-name-space-artillery-detected-firing = Firing detected +signal-port-description-space-artillery-detected-firing = Sends signal when it detects Space Artillery succesfully firing a shot. + +signal-port-name-space-artillery-detected-malfunction = Malfunction detected +signal-port-description-space-artillery-detected-malfunction = Sends signal when it detects Space Artillery failing to fire or detecting an issue. + +signal-port-name-space-artillery-detected-safety-change = Safety Change detected +signal-port-description-space-artillery-detected-safety-change = Sends signal when it detects Space Artillery succesfully changing safety mode. \ No newline at end of file diff --git a/Resources/Prototypes/DeviceLinking/sink_ports.yml b/Resources/Prototypes/DeviceLinking/sink_ports.yml index 56b10ec4fcc..b4a462dce11 100644 --- a/Resources/Prototypes/DeviceLinking/sink_ports.yml +++ b/Resources/Prototypes/DeviceLinking/sink_ports.yml @@ -111,4 +111,4 @@ - type: sinkPort id: SetParticleSigma name: signal-port-name-set-particle-sigma - description: signal-port-description-set-particle-sigma + description: signal-port-description-set-particle-sigma \ No newline at end of file diff --git a/Resources/Prototypes/_NF/SpaceArtillery/actions.yml b/Resources/Prototypes/_NF/SpaceArtillery/actions.yml new file mode 100644 index 00000000000..faf426b069f --- /dev/null +++ b/Resources/Prototypes/_NF/SpaceArtillery/actions.yml @@ -0,0 +1,10 @@ +- type: entity + id: ActionSpaceArtilleryFire + name: Fire + description: Sends lead downrange + noSpawn: true + components: + - type: InstantAction + useDelay: 0.1 + icon: Objects/Fun/bikehorn.rsi/icon.png #To be changed + event: !type:FireActionEvent \ No newline at end of file diff --git a/Resources/Prototypes/_NF/SpaceArtillery/armaments.yml b/Resources/Prototypes/_NF/SpaceArtillery/armaments.yml new file mode 100644 index 00000000000..1690d754aec --- /dev/null +++ b/Resources/Prototypes/_NF/SpaceArtillery/armaments.yml @@ -0,0 +1,1226 @@ + +# Actual Space weapons +- type: entity + id: Artillery_Gun_630 + name: artillery gun 630cal + parent: ConstructibleMachine + description: It's like from 20th century second planet wars! Fires 630 caliber shells. Old and reliable. + placement: + mode: SnapgridCenter + components: + - type: Clickable + - type: InteractionOutline + - type: Physics + bodyType: Static + - type: Fixtures + fixtures: + fix1: + shape: + !type:PhysShapeAabb + bounds: "-0.25,-0.25,0.25,0.25" + density: 600 + mask: + - MachineMask + layer: + - MachineLayer + - type: Transform + anchored: true + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/space_artillery.rsi + layers: + - state: space_artillery + - type: Anchorable + - type: Pullable + - type: Rotatable + rotateWhilePulling: false + rotateWhileAnchored: true + increment: 45 + - type: Appearance + - type: AmmoCounter + - type: Battery + maxCharge: 1000000 + startingCharge: 1000000 + - type: ExaminableBattery + - type: BallisticAmmoProvider + autoCycle: true + capacity: 1 + proto: CartridgeShellArmorPiercing + whitelist: + tags: + - CartridgeShell + - type: ContainerContainer + containers: + ballistic-ammo: !type:Container + ents: [] + - type: DeviceNetwork + deviceNetId: Wireless + receiveFrequencyId: BasicDevice + - type: WirelessNetworkConnection + range: 200 + - type: DeviceLinkSink + ports: + - SpaceArtilleryFire + - SpaceArtilleryToggleSafety + - SpaceArtilleryOnSafety + - SpaceArtilleryOffSafety + - type: DeviceLinkSource + ports: + - SpaceArtilleryDetectedFiring + - SpaceArtilleryDetectedMalfunction + - SpaceArtilleryDetectedSafetyChange + - type: Gun + fireRate: 1 + projectileSpeed: 70 + soundGunshot: + path: /Audio/Effects/thunk.ogg + soundEmpty: + path: /Audio/Items/hiss.ogg + - type: SpaceArtillery + isArmed: true + powerChargeRate: 2000 + powerUsePassive: 3000 + isPowerRequiredForSignal: true + isPowerRequiredToFire: false + - type: Actions + - type: CombatMode + IsInCombatMode: true + - type: ApcPowerReceiver + powerLoad: 3000 + - type: ExtensionCableReceiver + - type: BatterySelfRecharger + + +- type: entity + id: Artillery_Gun_630_WallMounted + name: artillery gun 630cal wallmounted + parent: ConstructibleMachine + description: It's like from 20th century second planet wars! Fires 630 caliber shells. Old and reliable. + placement: + mode: SnapgridCenter + components: + - type: Clickable + - type: InteractionOutline + - type: Physics + bodyType: Static + - type: Tag + tags: + - Wall + - type: Airtight + - type: Occluder + boundingBox: "-0.1,-0.5,0.5,0.5" + - type: Fixtures + fixtures: + fix1: + shape: + !type:PhysShapeAabb + bounds: "-0.5,-0.5,0.5,0.5" + density: 600 + mask: + - FullTileMask + layer: + - WallLayer + - type: Transform + anchored: true + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/space_artillery_wallmount.rsi + layers: + - state: space_artillery + - type: Anchorable + - type: Pullable + - type: Rotatable + rotateWhilePulling: false + rotateWhileAnchored: true + increment: 45 + - type: Appearance + - type: AmmoCounter + - type: Battery + maxCharge: 1000000 + startingCharge: 1000000 + - type: ExaminableBattery + - type: BallisticAmmoProvider + autoCycle: true + capacity: 1 + proto: CartridgeShellArmorPiercing + whitelist: + tags: + - CartridgeShell + - type: ContainerContainer + containers: + ballistic-ammo: !type:Container + ents: [] + - type: DeviceNetwork + deviceNetId: Wireless + receiveFrequencyId: BasicDevice + - type: WirelessNetworkConnection + range: 200 + - type: DeviceLinkSink + ports: + - SpaceArtilleryFire + - SpaceArtilleryToggleSafety + - SpaceArtilleryOnSafety + - SpaceArtilleryOffSafety + - type: DeviceLinkSource + ports: + - SpaceArtilleryDetectedFiring + - SpaceArtilleryDetectedMalfunction + - SpaceArtilleryDetectedSafetyChange + - type: Gun + fireRate: 1 + projectileSpeed: 70 + soundGunshot: + path: /Audio/Effects/thunk.ogg + soundEmpty: + path: /Audio/Items/hiss.ogg + - type: SpaceArtillery + isArmed: true + powerChargeRate: 2000 + powerUsePassive: 3000 + isPowerRequiredForSignal: true + isPowerRequiredToFire: false + linearRecoilGrid: 300 + - type: Actions + - type: CombatMode + IsInCombatMode: true + - type: ApcPowerReceiver + powerLoad: 3000 + - type: ExtensionCableReceiver + - type: BatterySelfRecharger + - type: RadiationBlocker + resistance: 8 + + +- type: entity + id: Mounted_Machine_Gun_50 + name: mounted machine gun 50 + parent: ConstructibleMachine + description: It's like from 20th century second planet wars! Puts down suppressive fire. With enough shots turns hull into swiss cheese. Old and reliable. + placement: + mode: SnapgridCenter + components: + - type: Clickable + - type: InteractionOutline + - type: Physics + bodyType: Static + - type: Fixtures + fixtures: + fix1: + shape: + !type:PhysShapeAabb + bounds: "-0.25,-0.25,0.25,0.25" + density: 600 + mask: + - MachineMask + layer: + - MachineLayer + - type: Transform + anchored: true + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/space_artillery.rsi + layers: + - state: space_artillery + - type: Anchorable + - type: Pullable + - type: Rotatable + rotateWhilePulling: false + rotateWhileAnchored: true + increment: 45 + - type: Battery + maxCharge: 0 + startingCharge: 0 + - type: Appearance + - type: BallisticAmmoProvider + autoCycle: true + capacity: 60 + proto: CartridgeMachineGunArmorPiercing + whitelist: + tags: + - CartridgeMachineGun + - type: ContainerContainer + containers: + ballistic-ammo: !type:Container + ents: [] + - type: Gun + fireRate: 5 + projectileSpeed: 70 + soundGunshot: + path: /Audio/Effects/thunk.ogg + soundEmpty: + path: /Audio/Items/hiss.ogg + - type: SpaceArtillery + isArmed: true + powerChargeRate: 0 + powerUsePassive: 0 + isPowerRequiredForMount: false + isPowerRequiredToFire: false + isPowerRequiredForSignal: false + - type: BatterySelfRecharger + - type: Actions + - type: CombatMode + IsInCombatMode: true + - type: Strap + position: Stand + buckleOffset: "0,0.8" + maxBuckleDistance: 1 + - type: UserInterface #internal radar idea will probably get scrapped + interfaces: + - key: enum.RadarConsoleUiKey.Key + type: RadarConsoleBoundUserInterface + - type: IntrinsicUI + uis: + - key: enum.RadarConsoleUiKey.Key + toggleAction: ActionSpaceArtilleryShowRadar + - type: RadarConsole + +- type: entity + id: Mounted_Machine_Gun_50_WallMounted + name: mounted machine gun 50 wallmounted + parent: ConstructibleMachine + description: It's like from 20th century second planet wars! Puts down suppressive fire. With enough shots turns hull into swiss cheese. Old and reliable. + placement: + mode: SnapgridCenter + components: + - type: Clickable + - type: InteractionOutline + - type: Physics + bodyType: Static + - type: Fixtures + fixtures: + fix1: + shape: + !type:PhysShapeAabb + bounds: "-0.25,-0.25,0.25,0.25" + density: 600 + mask: + - MachineMask + layer: + - MachineLayer + - type: Transform + anchored: true + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/space_artillery_wallmount.rsi + layers: + - state: space_artillery + - type: Anchorable + - type: Pullable + - type: Rotatable + rotateWhilePulling: false + rotateWhileAnchored: true + increment: 90 + - type: Battery + maxCharge: 200000 + startingCharge: 200000 + - type: ExaminableBattery + - type: Appearance + - type: DeviceNetwork + deviceNetId: Wireless + receiveFrequencyId: BasicDevice + - type: WirelessNetworkConnection + range: 200 + - type: DeviceLinkSink + ports: + - SpaceArtilleryFire + - SpaceArtilleryToggleSafety + - SpaceArtilleryOnSafety + - SpaceArtilleryOffSafety + - type: DeviceLinkSource + ports: + - SpaceArtilleryDetectedFiring + - SpaceArtilleryDetectedMalfunction + - SpaceArtilleryDetectedSafetyChange + - type: BallisticAmmoProvider + autoCycle: true + capacity: 120 + proto: CartridgeMachineGunArmorPiercing + whitelist: + tags: + - CartridgeMachineGun + - type: ContainerContainer + containers: + ballistic-ammo: !type:Container + ents: [] + - type: Gun + fireRate: 5 + projectileSpeed: 70 + soundGunshot: + path: /Audio/Effects/thunk.ogg + soundEmpty: + path: /Audio/Items/hiss.ogg + - type: SpaceArtillery + isArmed: true + powerChargeRate: 1500 + powerUsePassive: 500 + isPowerRequiredForMount: false + isPowerRequiredToFire: false + isPowerRequiredForSignal: true + - type: BatterySelfRecharger + - type: Actions + - type: CombatMode + IsInCombatMode: true + - type: Tag + tags: + - Wall + - type: Airtight + - type: Occluder + boundingBox: "-0.1,-0.5,0.5,0.5" + - type: RadiationBlocker + resistance: 8 + - type: ApcPowerReceiver + powerLoad: 3000 + - type: ExtensionCableReceiver + +- type: entity + id: Railgun_WallMounted + name: railgun 1000 cal wallmounted + parent: ConstructibleMachine + description: A rather new invention. Fires 1000 caliber solid rails. Wrecks through hull. You don't want to be on the receiving end. + placement: + mode: SnapgridCenter + components: + - type: Clickable + - type: InteractionOutline + - type: Physics + bodyType: Static + - type: Tag + tags: + - Wall + - type: Airtight + - type: Occluder + boundingBox: "-0.1,-0.5,0.5,0.5" + - type: Fixtures + fixtures: + fix1: + shape: + !type:PhysShapeAabb + bounds: "-0.5,-0.5,0.5,0.5" + density: 600 + mask: + - FullTileMask + layer: + - WallLayer + - type: Transform + anchored: true + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/space_artillery_wallmount.rsi + layers: + - state: space_artillery + - type: Anchorable + - type: Pullable + - type: Rotatable + rotateWhilePulling: false + rotateWhileAnchored: true + increment: 45 + - type: Appearance + - type: AmmoCounter + - type: Battery + maxCharge: 1000000 + startingCharge: 1000000 + - type: ExaminableBattery + - type: BallisticAmmoProvider + autoCycle: true + capacity: 1 + proto: CartridgeRailArmorPiercing + whitelist: + tags: + - CartridgeRail + - type: ContainerContainer + containers: + ballistic-ammo: !type:Container + ents: [] + SpaceArtillery-CoolantSlot: !type:ContainerSlot {} + - type: DeviceNetwork + deviceNetId: Wireless + receiveFrequencyId: BasicDevice + - type: WirelessNetworkConnection + range: 200 + - type: DeviceLinkSink + ports: + - SpaceArtilleryFire + - SpaceArtilleryToggleSafety + - SpaceArtilleryOnSafety + - SpaceArtilleryOffSafety + - type: DeviceLinkSource + ports: + - SpaceArtilleryDetectedFiring + - SpaceArtilleryDetectedMalfunction + - SpaceArtilleryDetectedSafetyChange + - type: Gun + fireRate: 1 + projectileSpeed: 70 + soundGunshot: + path: /Audio/Effects/thunk.ogg + soundEmpty: + path: /Audio/Items/hiss.ogg + - type: SpaceArtillery + isArmed: true + powerChargeRate: 14000 + powerUsePassive: 6000 + powerUseActive: 500000 + isPowerRequiredForSignal: true + isPowerRequiredToFire: true + isCoolantRequiredToFire: true + coolantConsumed: 30 + maxCoolantStored: 120 + linearRecoilGrid: 900 + angularInstabilityGrid: 30 + SpaceArtillery-CoolantSlot: + name: SpaceArtillery-CoolantSlot + insertSound: /Audio/Machines/scanning.ogg + ejectSound: /Audio/Machines/tray_eject.ogg + ejectOnBreak: true + swap: false + whitelist: + components: + - Stack + - type: Actions + - type: CombatMode + IsInCombatMode: true + - type: ApcPowerReceiver + powerLoad: 6000 + - type: ExtensionCableReceiver + - type: BatterySelfRecharger + - type: RadiationBlocker + resistance: 8 + +- type: entity + id: Military_Laser + name: military laser + parent: ConstructibleMachine + description: Highly focused laser beam designed to melt through hull. + placement: + mode: SnapgridCenter + components: + - type: Clickable + - type: InteractionOutline + - type: Physics + bodyType: Static + - type: Fixtures + fixtures: + fix1: + shape: + !type:PhysShapeAabb + bounds: "-0.25,-0.25,0.25,0.25" + density: 600 + mask: + - MachineMask + layer: + - MachineLayer + - type: Transform + anchored: true + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/space_artillery.rsi + layers: + - state: space_artillery + - type: Anchorable + delay: 9999 + - type: Pullable + - type: Rotatable + rotateWhilePulling: false + rotateWhileAnchored: true + increment: 45 + - type: Appearance + - type: AmmoCounter + - type: Battery + maxCharge: 100000 + startingCharge: 100000 + - type: ExaminableBattery + - type: HitscanBatteryAmmoProvider + proto: Focused_Pulse + fireCost: 25000 + - type: ItemSlots + - type: ContainerContainer + containers: + SpaceArtillery-CoolantSlot: !type:ContainerSlot {} + - type: DeviceNetwork + deviceNetId: Wireless + receiveFrequencyId: BasicDevice + - type: WirelessNetworkConnection + range: 200 + - type: DeviceLinkSink + ports: + - SpaceArtilleryFire + - SpaceArtilleryToggleSafety + - SpaceArtilleryOnSafety + - SpaceArtilleryOffSafety + - type: DeviceLinkSource + ports: + - SpaceArtilleryDetectedFiring + - SpaceArtilleryDetectedMalfunction + - SpaceArtilleryDetectedSafetyChange + - type: Gun + fireRate: 3 + projectileSpeed: 70 + selectedMode: FullAuto + availableModes: + - SemiAuto + - FullAuto + soundGunshot: + path: /Audio/Effects/thunk.ogg + soundEmpty: + path: /Audio/Items/hiss.ogg + - type: SpaceArtillery + isArmed: true + isCoolantRequiredToFire: true + coolantConsumed: 10 + isPowerRequiredToFire: true + SpaceArtillery-CoolantSlot: + name: SpaceArtillery-CoolantSlot + insertSound: /Audio/Machines/scanning.ogg + ejectSound: /Audio/Machines/tray_eject.ogg + ejectOnBreak: true + swap: false + whitelist: + components: + - Stack + - type: Actions + - type: CombatMode + IsInCombatMode: true + - type: Strap + position: Stand + buckleOffset: "0,0.8" + maxBuckleDistance: 1 + - type: ApcPowerReceiver + powerLoad: 1000 + - type: ExtensionCableReceiver + - type: BatterySelfRecharger + +- type: entity + id: Mining_Laser + name: mining laser + parent: ConstructibleMachine + description: Laser Beam utilising crystaline plasma to melt rock down into usable chunks with uncanny precision. Requires coolant to function. + placement: + mode: SnapgridCenter + components: + - type: Clickable + - type: InteractionOutline + - type: Physics + bodyType: Static + - type: Fixtures + fixtures: + fix1: + shape: + !type:PhysShapeAabb + bounds: "-0.25,-0.25,0.25,0.25" + density: 600 + mask: + - MachineMask + layer: + - MachineLayer + - type: Transform + anchored: true + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/mining_laser.rsi + granularLayersRendering: true + layers: + - state: capacitor + renderingStrategy: SnapToCardinals + - state: chair + renderingStrategy: SnapToCardinals + - state: turret + renderingStrategy: Default + - type: Anchorable + delay: 9999 + - type: Pullable + - type: Rotatable + rotateWhilePulling: false + rotateWhileAnchored: true + increment: 45 + - type: Appearance + - type: AmmoCounter + - type: Battery + maxCharge: 100000 + startingCharge: 100000 + - type: ExaminableBattery + - type: HitscanBatteryAmmoProvider + proto: Mining + fireCost: 5000 + - type: ItemSlots + - type: ContainerContainer + containers: + SpaceArtillery-CoolantSlot: !type:ContainerSlot {} + - type: DeviceNetwork + deviceNetId: Wireless + receiveFrequencyId: BasicDevice + - type: WirelessNetworkConnection + range: 200 + - type: DeviceLinkSink + ports: + - SpaceArtilleryFire + - SpaceArtilleryToggleSafety + - SpaceArtilleryOnSafety + - SpaceArtilleryOffSafety + - type: DeviceLinkSource + ports: + - SpaceArtilleryDetectedFiring + - SpaceArtilleryDetectedMalfunction + - SpaceArtilleryDetectedSafetyChange + - type: Gun + fireRate: 3 + projectileSpeed: 70 + selectedMode: FullAuto + availableModes: + - SemiAuto + - FullAuto + soundGunshot: + path: /Audio/Effects/thunk.ogg + soundEmpty: + path: /Audio/Items/hiss.ogg + - type: SpaceArtillery + isArmed: true + isCoolantRequiredToFire: true + coolantStored: 90 + isPowerRequiredToFire: true + SpaceArtillery-CoolantSlot: + name: SpaceArtillery-CoolantSlot + insertSound: /Audio/Machines/scanning.ogg + ejectSound: /Audio/Machines/tray_eject.ogg + ejectOnBreak: true + swap: false + whitelist: + components: + - Stack + - type: Actions + - type: CombatMode + IsInCombatMode: true + - type: Strap + position: Stand + buckleOffset: "0,0.8" + maxBuckleDistance: 1 + - type: ApcPowerReceiver + powerLoad: 1000 + - type: ExtensionCableReceiver + - type: BatterySelfRecharger + +#Need to resolve issue which allows launcher to fire ANY bullet +- type: entity + id: Pneumatic_Launcher + name: pneumatic launcher + parent: ConstructibleMachine + description: Utilises internal piston and pressure mechanisms to launch small and medium items forward at large speeds. + placement: + mode: SnapgridCenter + components: + - type: Clickable + - type: InteractionOutline + - type: Physics + bodyType: Static + - type: Fixtures + fixtures: + fix1: + shape: + !type:PhysShapeAabb + bounds: "-0.25,-0.25,0.25,0.25" + density: 600 + mask: + - MachineMask + layer: + - MachineLayer + - type: Transform + anchored: true + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/space_artillery.rsi + layers: + - state: space_artillery + - type: Anchorable + - type: Pullable + - type: Rotatable + rotateWhilePulling: false + rotateWhileAnchored: true + increment: 45 + - type: Appearance + - type: Storage + capacity: 120 + - type: UserInterface + interfaces: + - key: enum.StorageUiKey.Key + type: StorageBoundUserInterface + - type: ContainerContainer + containers: + storagebase: !type:Container + ents: [] + - type: ContainerAmmoProvider + container: storagebase + - type: PneumaticCannon + gasUsage: 0 + baseProjectileSpeed: 70 + toolModifyPower: Screwing + - type: DeviceNetwork + deviceNetId: Wireless + receiveFrequencyId: BasicDevice + - type: WirelessNetworkConnection + range: 200 + - type: DeviceLinkSink + ports: + - SpaceArtilleryFire + - SpaceArtilleryToggleSafety + - SpaceArtilleryOnSafety + - SpaceArtilleryOffSafety + - type: DeviceLinkSource + ports: + - SpaceArtilleryDetectedFiring + - SpaceArtilleryDetectedMalfunction + - SpaceArtilleryDetectedSafetyChange + - type: Gun + fireRate: 3 + projectileSpeed: 70 + selectedMode: FullAuto + availableModes: + - SemiAuto + - FullAuto + soundGunshot: + path: /Audio/Effects/thunk.ogg + soundEmpty: + path: /Audio/Items/hiss.ogg + - type: SpaceArtillery + isArmed: true + powerChargeRate: 2000 + powerUsePassive: 1000 + powerUseActive: 10000 + isPowerRequiredForSignal: true + isPowerRequiredToFire: true + - type: Actions + - type: CombatMode + IsInCombatMode: true + - type: Strap + position: Stand + buckleOffset: "0,1.2" + maxBuckleDistance: 1.5 + - type: ApcPowerReceiver + powerLoad: 1000 + - type: ExtensionCableReceiver + - type: Battery + maxCharge: 300000 + startingCharge: 300000 + - type: ExaminableBattery + - type: BatterySelfRecharger + +#Boosters category +- type: entity + id: Booster_Basic + name: Basic Booster + parent: ConstructibleMachine + description: Standard construction booster utilising compresed ion wave to rappidly propel vessel in space with power. Requires quick cooling using coolant. + placement: + mode: SnapgridCenter + components: + - type: Clickable + - type: InteractionOutline + - type: Physics + bodyType: Static + - type: Fixtures + fixtures: + fix1: + shape: + !type:PhysShapeAabb + bounds: "-0.25,-0.25,0.25,0.25" + density: 600 + mask: + - MachineMask + layer: + - MachineLayer + - type: Transform + anchored: true + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/space_artillery.rsi + layers: + - state: space_artillery + - type: Anchorable + delay: 10 + - type: Pullable + - type: Rotatable + rotateWhilePulling: false + rotateWhileAnchored: true + increment: 45 + - type: Appearance + - type: Battery + maxCharge: 100000 + startingCharge: 100000 + - type: ExaminableBattery + - type: ProjectileBatteryAmmoProvider + proto: BulletBoosterWave + fireCost: 20000 + - type: ItemSlots + - type: ContainerContainer + containers: + SpaceArtillery-CoolantSlot: !type:ContainerSlot {} + - type: DeviceNetwork + deviceNetId: Wireless + receiveFrequencyId: BasicDevice + - type: WirelessNetworkConnection + range: 200 + - type: DeviceLinkSink + ports: + - SpaceArtilleryFire + - SpaceArtilleryToggleSafety + - SpaceArtilleryOnSafety + - SpaceArtilleryOffSafety + - type: DeviceLinkSource + ports: + - SpaceArtilleryDetectedFiring + - SpaceArtilleryDetectedMalfunction + - SpaceArtilleryDetectedSafetyChange + - type: Gun + fireRate: 3 + projectileSpeed: 35 + selectedMode: FullAuto + availableModes: + - SemiAuto + - FullAuto + soundGunshot: + path: /Audio/Effects/thunk.ogg + soundEmpty: + path: /Audio/Items/hiss.ogg + - type: SpaceArtillery + isArmed: true + isDestructive: false + isCoolantRequiredToFire: true + coolantConsumed: 1 + coolantStored: 90 + isPowerRequiredToFire: true + powerUseActive: 5000 + powerUsePassive: 500 + SpaceArtillery-CoolantSlot: + name: SpaceArtillery-CoolantSlot + insertSound: /Audio/Machines/scanning.ogg + ejectSound: /Audio/Machines/tray_eject.ogg + ejectOnBreak: true + swap: false + whitelist: + components: + - Stack + linearRecoilGrid: 300 + - type: Actions + - type: CombatMode + IsInCombatMode: true + - type: Strap + position: Stand + buckleOffset: "0,0.8" + maxBuckleDistance: 1 + - type: ApcPowerReceiver + powerLoad: 1000 + - type: ExtensionCableReceiver + - type: BatterySelfRecharger + +- type: entity + id: Booster_Security + name: Security Booster + parent: ConstructibleMachine + description: Security model of the basic booster. Has increased efficiency and impulse force. Requires quick cooling using coolant. + placement: + mode: SnapgridCenter + components: + - type: Clickable + - type: InteractionOutline + - type: Physics + bodyType: Static + - type: Fixtures + fixtures: + fix1: + shape: + !type:PhysShapeAabb + bounds: "-0.25,-0.25,0.25,0.25" + density: 600 + mask: + - MachineMask + layer: + - MachineLayer + - type: Transform + anchored: true + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/space_artillery.rsi + layers: + - state: space_artillery + - type: Anchorable + delay: 10 + - type: Pullable + - type: Rotatable + rotateWhilePulling: false + rotateWhileAnchored: true + increment: 45 + - type: Appearance + - type: Battery + maxCharge: 100000 + startingCharge: 100000 + - type: ExaminableBattery + - type: ProjectileBatteryAmmoProvider + proto: BulletBoosterWave + fireCost: 10000 + - type: ItemSlots + - type: ContainerContainer + containers: + SpaceArtillery-CoolantSlot: !type:ContainerSlot {} + - type: DeviceNetwork + deviceNetId: Wireless + receiveFrequencyId: BasicDevice + - type: WirelessNetworkConnection + range: 200 + - type: DeviceLinkSink + ports: + - SpaceArtilleryFire + - SpaceArtilleryToggleSafety + - SpaceArtilleryOnSafety + - SpaceArtilleryOffSafety + - type: DeviceLinkSource + ports: + - SpaceArtilleryDetectedFiring + - SpaceArtilleryDetectedMalfunction + - SpaceArtilleryDetectedSafetyChange + - type: Gun + fireRate: 3 + projectileSpeed: 35 + selectedMode: FullAuto + availableModes: + - SemiAuto + - FullAuto + soundGunshot: + path: /Audio/Effects/thunk.ogg + soundEmpty: + path: /Audio/Items/hiss.ogg + - type: SpaceArtillery + isArmed: true + isDestructive: false + isCoolantRequiredToFire: true + coolantConsumed: 1 + coolantStored: 90 + isPowerRequiredToFire: true + powerUseActive: 2500 + powerUsePassive: 500 + SpaceArtillery-CoolantSlot: + name: SpaceArtillery-CoolantSlot + insertSound: /Audio/Machines/scanning.ogg + ejectSound: /Audio/Machines/tray_eject.ogg + ejectOnBreak: true + swap: false + whitelist: + components: + - Stack + linearRecoilGrid: 600 + velocityLimitRecoilGrid: 40 + - type: Actions + - type: CombatMode + IsInCombatMode: true + - type: Strap + position: Stand + buckleOffset: "0,0.8" + maxBuckleDistance: 1 + - type: ApcPowerReceiver + powerLoad: 1000 + - type: ExtensionCableReceiver + - type: BatterySelfRecharger + +- type: entity + id: Booster_Security_Chase + name: Security Chase Booster + parent: ConstructibleMachine + description: Massive security booster. Perfect at drifting in space and rappidly burning NFSD's budget. Due to strong impulse it's more unstable than smaller cousin. Requires quick cooling using coolant. + placement: + mode: SnapgridCenter + components: + - type: Clickable + - type: InteractionOutline + - type: Physics + bodyType: Static + - type: Fixtures + fixtures: + fix1: + shape: + !type:PhysShapeAabb + bounds: "-0.25,-0.25,0.25,0.25" + density: 600 + mask: + - MachineMask + layer: + - MachineLayer + - type: Transform + anchored: true + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/space_artillery.rsi + layers: + - state: space_artillery + - type: Anchorable + delay: 10 + - type: Pullable + - type: Rotatable + rotateWhilePulling: false + rotateWhileAnchored: true + increment: 45 + - type: Appearance + - type: Battery + maxCharge: 100000 + startingCharge: 100000 + - type: ExaminableBattery + - type: ProjectileBatteryAmmoProvider + proto: BulletBoosterWave + fireCost: 10000 + - type: ItemSlots + - type: ContainerContainer + containers: + SpaceArtillery-CoolantSlot: !type:ContainerSlot {} + - type: DeviceNetwork + deviceNetId: Wireless + receiveFrequencyId: BasicDevice + - type: WirelessNetworkConnection + range: 200 + - type: DeviceLinkSink + ports: + - SpaceArtilleryFire + - SpaceArtilleryToggleSafety + - SpaceArtilleryOnSafety + - SpaceArtilleryOffSafety + - type: DeviceLinkSource + ports: + - SpaceArtilleryDetectedFiring + - SpaceArtilleryDetectedMalfunction + - SpaceArtilleryDetectedSafetyChange + - type: Gun + fireRate: 3 + projectileSpeed: 35 + selectedMode: FullAuto + availableModes: + - SemiAuto + - FullAuto + soundGunshot: + path: /Audio/Effects/thunk.ogg + soundEmpty: + path: /Audio/Items/hiss.ogg + - type: SpaceArtillery + isArmed: true + isDestructive: false + isCoolantRequiredToFire: true + coolantConsumed: 3 + coolantStored: 90 + isPowerRequiredToFire: true + powerUseActive: 2500 + powerUsePassive: 500 + SpaceArtillery-CoolantSlot: + name: SpaceArtillery-CoolantSlot + insertSound: /Audio/Machines/scanning.ogg + ejectSound: /Audio/Machines/tray_eject.ogg + ejectOnBreak: true + swap: false + whitelist: + components: + - Stack + linearRecoilGrid: 2400 + velocityLimitRecoilGrid: 60 + angularInstabilityGrid: 30 + - type: Actions + - type: CombatMode + IsInCombatMode: true + - type: Strap + position: Stand + buckleOffset: "0,0.8" + maxBuckleDistance: 1 + - type: ApcPowerReceiver + powerLoad: 1000 + - type: ExtensionCableReceiver + - type: BatterySelfRecharger + +#Deployable weaponry +#WARNING CURRENTLY VERY BUGGED. NEED TO RESOLVE THE ISSUE OF ACTING LIKE ITEM +- type: entity + name: General Purpose Machine Gun .35 cal + parent: BaseItem + id: WeaponGPMG + description: Designed for tearing through armored cover of vessels. Utilises .35 caliber ammunition with explosive tip. + components: + - type: Sprite + sprite: Objects/Weapons/Guns/LMGs/l6.rsi + layers: + - state: base + map: ["enum.GunVisualLayers.Base"] + - state: mag-3 + map: ["enum.GunVisualLayers.Mag"] + - type: Item + size: 60 + - type: Clothing + sprite: Objects/Weapons/Guns/LMGs/l6.rsi + quickEquip: false + slots: + - Back + - type: MagazineVisuals + magState: mag + steps: 4 + zeroVisible: true + - type: Appearance + - type: Gun + minAngle: 24 + maxAngle: 45 + angleIncrease: 4 + angleDecay: 16 + fireRate: 8 + projectileSpeed: 70 + selectedMode: FullAuto + availableModes: + - FullAuto + soundGunshot: + path: /Audio/Weapons/Guns/Gunshots/lmg.ogg + soundEmpty: + path: /Audio/Weapons/Guns/Empty/lmg_empty.ogg + - type: ChamberMagazineAmmoProvider + soundRack: + path: /Audio/Weapons/Guns/Cock/lmg_cock.ogg + - type: AmmoCounter + - type: MultiHandedItem + - type: ItemSlots + slots: + gun_magazine: + name: Magazine + startingItem: MagazineLightRifleBox + insertSound: /Audio/Weapons/Guns/MagIn/batrifle_magin.ogg + ejectSound: /Audio/Weapons/Guns/MagOut/batrifle_magout.ogg + priority: 2 + whitelist: + tags: + - MagazineLightRifleBox + gun_chamber: + name: Chamber + startingItem: CartridgeLightRifle + priority: 1 + whitelist: + tags: + - CartridgeLightRifle + - type: ContainerContainer + containers: + gun_magazine: !type:ContainerSlot + gun_chamber: !type:ContainerSlot + - type: StaticPrice + price: 500 + - type: UseDelay + delay: 1 + - type: SpaceArtillery + isArmed: true + isPowerRequiredForMount: false + isPowerRequiredToFire: false + - type: Strap + position: Stand + buckleOffset: "0,0.8" + maxBuckleDistance: 1 + - type: ApcPowerReceiver + powerLoad: 0 + - type: ExtensionCableReceiver + - type: Battery + maxCharge: 0 + startingCharge: 0 + - type: BatterySelfRecharger + - type: Anchorable + - type: Pullable + - type: Rotatable + rotateWhilePulling: false + rotateWhileAnchored: true + increment: 45 + + +# Old code attempt at internal mass scanner +- type: entity + id: ActionSpaceArtilleryShowRadar + name: Mass Scanner Interface + description: View a mass scanner interface. + noSpawn: true + components: + - type: InstantAction + icon: { sprite: Structures/Machines/parts.rsi, state: box_0 } + iconOn: Structures/Machines/parts.rsi/box_2.png + keywords: [ "AI", "console", "interface" ] + priority: -10 + event: !type:ToggleIntrinsicUIEvent { key: enum.RadarConsoleUiKey.Key } \ No newline at end of file diff --git a/Resources/Prototypes/_NF/SpaceArtillery/laser.yml b/Resources/Prototypes/_NF/SpaceArtillery/laser.yml new file mode 100644 index 00000000000..5548ed219f4 --- /dev/null +++ b/Resources/Prototypes/_NF/SpaceArtillery/laser.yml @@ -0,0 +1,33 @@ +- type: hitscan + id: Mining + damage: + types: + Heat: 5 + Structural: 100 + muzzleFlash: + sprite: _NF/Objects/SpaceArtillery/lasers.rsi + state: muzzle_mining + travelFlash: + sprite: _NF/Objects/SpaceArtillery/lasers.rsi + state: beam_mining + impactFlash: + sprite: _NF/Objects/SpaceArtillery/lasers.rsi + state: impact_mining + maxLength: 40 + +- type: hitscan + id: Focused_Pulse + damage: + types: + Heat: 30 + Structural: 800 + muzzleFlash: + sprite: _NF/Objects/SpaceArtillery/lasers.rsi + state: muzzle_focused_pulse + travelFlash: + sprite: _NF/Objects/SpaceArtillery/lasers.rsi + state: beam_focused_pulse + impactFlash: + sprite: _NF/Objects/SpaceArtillery/lasers.rsi + state: impact_focused_pulse + maxLength: 40 \ No newline at end of file diff --git a/Resources/Prototypes/_NF/SpaceArtillery/shells.yml b/Resources/Prototypes/_NF/SpaceArtillery/shells.yml new file mode 100644 index 00000000000..c267d1c32de --- /dev/null +++ b/Resources/Prototypes/_NF/SpaceArtillery/shells.yml @@ -0,0 +1,722 @@ +# Space Artillery projectiles + + +#EMP shell +- type: entity + id: BulletShellEmp + name: shell + parent: BaseBulletTrigger + noSpawn: true + components: + - type: Projectile + damage: + types: + Structural: 100 + Blunt: 20 + - type: TimedDespawn + lifetime: 20 + #roughly 600m range + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi + layers: + - state: base-projectile + - type: EmpOnTrigger + range: 8 + energyConsumption: 50000 + disableDuration: 20 + - type: SpaceArtilleryProjectile + +- type: entity + id: CartridgeShellEmp + name: 630 EMP shell + parent: BaseItem + description: A 1.5 emp warhead designed for the RPG-7 launcher. Has tubular shape. + components: + - type: Tag + tags: + - CartridgeShell + - type: Item + size: 60 + - type: CartridgeAmmo + proto: BulletShellEmp + deleteOnSpawn: false + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi + layers: + - state: base + map: ["enum.AmmoVisualLayers.Base"] + - type: Appearance + - type: SpentAmmoVisuals + - type: SpaceGarbage + + +#Solid Shell +- type: entity + id: BulletShellArmorPiercing + name: shell + parent: BaseBulletTrigger + noSpawn: true + components: + - type: Projectile + damage: + types: + Structural: 1000 + #currently explosion deals roughly 60 damage + - type: TimedDespawn + lifetime: 20 + #roughly 600m range + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi + layers: + - state: base-projectile + - type: ExplodeOnTrigger + - type: Explosive + explosionType: Default + maxIntensity: 4 + intensitySlope: 3 + totalIntensity: 10 + maxTileBreak: 1 + - type: PointLight + radius: 3.5 + color: orange + energy: 0.5 + - type: SpaceArtilleryProjectile + +- type: entity + id: CartridgeShellArmorPiercing + name: 630 Armor-Piercing shell + parent: BaseItem + description: A 1.5 emp warhead designed for the RPG-7 launcher. Has tubular shape. + components: + - type: Tag + tags: + - CartridgeShell + - Cartridge + - type: Item + size: 60 + - type: CartridgeAmmo + proto: BulletShellArmorPiercing + deleteOnSpawn: false + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi + layers: + - state: base + map: ["enum.AmmoVisualLayers.Base"] + - type: Appearance + - type: SpentAmmoVisuals + - type: SpaceGarbage + +#High Explosive Shell +- type: entity + id: BulletShellHighExplosive + name: shell + parent: BaseBulletTrigger + noSpawn: true + components: + - type: Projectile + damage: + types: + Structural: 100 + #currently explosion deals roughly 30 damage per tile in large AoE + - type: TimedDespawn + lifetime: 20 + #roughly 600m range + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi + layers: + - state: base-projectile + - type: ExplodeOnTrigger + - type: Explosive + explosionType: Default + maxIntensity: 2 + intensitySlope: 2 + totalIntensity: 100 + maxTileBreak: 2 + - type: PointLight + radius: 3.5 + color: orange + energy: 0.5 + - type: SpaceArtilleryProjectile + +- type: entity + id: CartridgeShellHighExplosive + name: 630 High-Explosive shell + parent: BaseItem + description: A 1.5 emp warhead designed for the RPG-7 launcher. Has tubular shape. + components: + - type: Tag + tags: + - CartridgeShell + - Cartridge + - type: Item + size: 60 + - type: CartridgeAmmo + proto: BulletShellHighExplosive + deleteOnSpawn: false + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi + layers: + - state: base + map: ["enum.AmmoVisualLayers.Base"] + - type: Appearance + - type: SpentAmmoVisuals + - type: SpaceGarbage + +#Practice Shell +- type: entity + id: BulletShellPractice + name: shell + parent: BaseBulletTrigger + noSpawn: true + components: + - type: Projectile + damage: + types: + Structural: 1 + #currently explosion deals roughly 30 damage per tile in large AoE + - type: TimedDespawn + lifetime: 20 + #roughly 600m range + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi + layers: + - state: base-projectile + - type: ExplodeOnTrigger + - type: Explosive + explosionType: Default + maxIntensity: 0.1 + intensitySlope: 1 + totalIntensity: 2 + maxTileBreak: 2 + - type: PointLight + radius: 3.5 + color: orange + energy: 0.5 + - type: SpaceArtilleryProjectile + +- type: entity + id: CartridgeShellPractice + name: 630 Practice shell + parent: BaseItem + description: A 1.5 emp warhead designed for the RPG-7 launcher. Has tubular shape. + components: + - type: Tag + tags: + - CartridgeShell + - Cartridge + - type: Item + size: 60 + - type: CartridgeAmmo + proto: BulletShellPractice + deleteOnSpawn: false + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi + layers: + - state: base + map: ["enum.AmmoVisualLayers.Base"] + - type: Appearance + - type: SpentAmmoVisuals + - type: SpaceGarbage + +#.50 call EMP for machine gun +- type: entity + id: BulletMachineGunEMP + name: 50 Machine Gun EMP bullet + parent: BaseBulletTrigger + noSpawn: true + components: + - type: Projectile + damage: + types: + Structural: 35 + Blunt: 10 + - type: TimedDespawn + lifetime: 20 + #roughly 600m range + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi + layers: + - state: base-projectile + - type: EmpOnTrigger + range: 3 + energyConsumption: 2000 + disableDuration: 3 + - type: PointLight + radius: 3.5 + color: orange + energy: 0.5 + - type: SpaceArtilleryProjectile + +- type: entity + id: CartridgeMachineGunEMP + name: 50 Machine Gun EMP cartridge + parent: BaseItem + description: A 1.5 emp warhead designed for the RPG-7 launcher. Has tubular shape. + components: + - type: Tag + tags: + - CartridgeMachineGun + - Cartridge + - type: Item + size: 2 + - type: CartridgeAmmo + proto: BulletMachineGunEMP + deleteOnSpawn: false + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi + layers: + - state: base + map: ["enum.AmmoVisualLayers.Base"] + - type: Appearance + - type: SpentAmmoVisuals + - type: SpaceGarbage + +#.50 call AP for machine gun +- type: entity + id: BulletMachineGunArmorPiercing + name: 50 Machine Gun Armor-Piercing bullet + parent: BaseBulletTrigger + noSpawn: true + components: + - type: Projectile + damage: + types: + Structural: 35 + #currently explosion deals 30 damage + - type: TimedDespawn + lifetime: 20 + #roughly 600m range + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi + layers: + - state: base-projectile + - type: ExplodeOnTrigger + - type: Explosive + explosionType: Default + maxIntensity: 2 + intensitySlope: 1 + totalIntensity: 5 + maxTileBreak: 0 + - type: PointLight + radius: 3.5 + color: orange + energy: 0.5 + - type: SpaceArtilleryProjectile + +- type: entity + id: CartridgeMachineGunArmorPiercing + name: 50 Machine Gun Armor-Piercing cartridge + parent: BaseItem + description: A 1.5 emp warhead designed for the RPG-7 launcher. Has tubular shape. + components: + - type: Tag + tags: + - CartridgeMachineGun + - Cartridge + - type: Item + size: 2 + - type: CartridgeAmmo + proto: BulletMachineGunArmorPiercing + deleteOnSpawn: false + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi + layers: + - state: base + map: ["enum.AmmoVisualLayers.Base"] + - type: Appearance + - type: SpentAmmoVisuals + - type: SpaceGarbage + +#.50 call HE for machine gun +- type: entity + id: BulletMachineGunHighExplosive + name: 50 Machine Gun High-Explosive bullet + parent: BaseBulletTrigger + noSpawn: true + components: + - type: Projectile + damage: + types: + Structural: 24 + #currently explosion deals 21 damage per tile in large AoE + - type: TimedDespawn + lifetime: 20 + #roughly 600m range + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi + layers: + - state: base-projectile + - type: ExplodeOnTrigger + - type: Explosive + explosionType: Default + maxIntensity: 1.4 + intensitySlope: 0.8 + totalIntensity: 16 + maxTileBreak: 0 + - type: PointLight + radius: 3.5 + color: orange + energy: 0.5 + - type: SpaceArtilleryProjectile + +- type: entity + id: CartridgeMachineGunHighExplosive + name: 50 Machine Gun High-Explosive cartridge + parent: BaseItem + description: A 1.5 emp warhead designed for the RPG-7 launcher. Has tubular shape. + components: + - type: Tag + tags: + - CartridgeMachineGun + - Cartridge + - type: Item + size: 2 + - type: CartridgeAmmo + proto: BulletMachineGunHighExplosive + deleteOnSpawn: false + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi + layers: + - state: base + map: ["enum.AmmoVisualLayers.Base"] + - type: Appearance + - type: SpentAmmoVisuals + - type: SpaceGarbage + +#.50 call Practice for machine gun +- type: entity + id: BulletMachineGunPractice + name: 50 Machine Gun Practice bullet + parent: BaseBulletTrigger + noSpawn: true + components: + - type: Projectile + damage: + types: + Structural: 5 + #currently explosion deals 30 damage + - type: TimedDespawn + lifetime: 20 + #roughly 600m range + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi + layers: + - state: base-projectile + - type: ExplodeOnTrigger + - type: Explosive + explosionType: Default + maxIntensity: 0.1 + intensitySlope: 1 + totalIntensity: 0.6 + maxTileBreak: 0 + - type: PointLight + radius: 3.5 + color: orange + energy: 0.5 + - type: SpaceArtilleryProjectile + +- type: entity + id: CartridgeMachineGunPractice + name: 50 Machine Gun Practice cartridge + parent: BaseItem + description: A 1.5 emp warhead designed for the RPG-7 launcher. Has tubular shape. + components: + - type: Tag + tags: + - CartridgeMachineGun + - Cartridge + - type: Item + size: 2 + - type: CartridgeAmmo + proto: BulletMachineGunPractice + deleteOnSpawn: false + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi + layers: + - state: base + map: ["enum.AmmoVisualLayers.Base"] + - type: Appearance + - type: SpentAmmoVisuals + - type: SpaceGarbage + + +#1000 cal Railgun EMP Rail + +- type: entity + id: BulletRailEMP + name: rail + parent: BaseBulletTrigger + noSpawn: true + components: + - type: Projectile + damage: + types: + Structural: 500 + Blunt: 50 + - type: TimedDespawn + lifetime: 34 + #roughly 1000m range + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi + layers: + - state: base-projectile + - type: EmpOnTrigger + range: 12 + energyConsumption: 1000000 + disableDuration: 120 + - type: PointLight + radius: 3.5 + color: orange + energy: 0.5 + - type: SpaceArtilleryProjectile + +- type: entity + id: CartridgeRailEMP + name: 1000 EMP rail + parent: BaseItem + description: A 1000 caliber rail designed for the Railgun. Is made out of solid plasma infused tungsten rod. Punches through hull like butter. + components: + - type: Tag + tags: + - CartridgeRail + - Cartridge + - type: Item + size: 120 + - type: MultiHandedItem + - type: CartridgeAmmo + proto: BulletRailEMP + deleteOnSpawn: false + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi + layers: + - state: base + map: ["enum.AmmoVisualLayers.Base"] + - type: Appearance + - type: SpentAmmoVisuals + - type: SpaceGarbage + +#1000 cal Railgun AP Rail + +- type: entity + id: BulletRailArmorPiercing + name: rail + parent: BaseBulletTrigger + noSpawn: true + components: + - type: Projectile + damage: + types: + Structural: 10000 + #currently explosion deals 720 damage, gibs in 3 direct rail hits + - type: TimedDespawn + lifetime: 34 + #roughly 1000m range + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi + layers: + - state: base-projectile + - type: ExplodeOnTrigger + - type: Explosive + explosionType: Default + maxIntensity: 64 + intensitySlope: 32 + totalIntensity: 96 + maxTileBreak: 2 + - type: PointLight + radius: 3.5 + color: orange + energy: 0.5 + - type: SpaceArtilleryProjectile + +- type: entity + id: CartridgeRailArmorPiercing + name: 1000 Armor-Piercing rail + parent: BaseItem + description: A 1000 caliber rail designed for the Railgun. Is made out of solid plasma infused tungsten rod. Punches through hull like butter. + components: + - type: Tag + tags: + - CartridgeRail + - Cartridge + - type: Item + size: 120 + - type: MultiHandedItem + - type: CartridgeAmmo + proto: BulletRailArmorPiercing + deleteOnSpawn: false + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi + layers: + - state: base + map: ["enum.AmmoVisualLayers.Base"] + - type: Appearance + - type: SpentAmmoVisuals + - type: SpaceGarbage + +#1000 cal Railgun HE Rail + +- type: entity + id: BulletRailHighExplosive + name: rail + parent: BaseBulletTrigger + noSpawn: true + components: + - type: Projectile + damage: + types: + Structural: 1000 + #currently explosion deals 156 damage per tile in large AoE + - type: TimedDespawn + lifetime: 34 + #roughly 1000m range + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi + layers: + - state: base-projectile + - type: ExplodeOnTrigger + - type: Explosive + explosionType: Default + maxIntensity: 10 + intensitySlope: 10 + totalIntensity: 500 + maxTileBreak: 50 + - type: PointLight + radius: 3.5 + color: orange + energy: 0.5 + - type: SpaceArtilleryProjectile + +- type: entity + id: CartridgeRailHighExplosive + name: 1000 High-Explosive rail + parent: BaseItem + description: A 1000 caliber rail designed for the Railgun. Is made out of solid plasma infused tungsten rod. Punches through hull like butter. + components: + - type: Tag + tags: + - CartridgeRail + - Cartridge + - type: Item + size: 120 + - type: MultiHandedItem + - type: CartridgeAmmo + proto: BulletRailHighExplosive + deleteOnSpawn: false + - type: Sprite + sprite: _NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi + layers: + - state: base + map: ["enum.AmmoVisualLayers.Base"] + - type: Appearance + - type: SpentAmmoVisuals + - type: SpaceGarbage + +#Booster energy projectile which they spew out. +#NEEDS CHECKUP TO ENSURE THAT ITS FIXED AND WONT CAUSE ISSUES LATER +- type: entity + name: booster wave + id: BulletBoosterWave + parent: BaseBullet + noSpawn: true + components: + - type: Sprite + sprite: Objects/Weapons/Guns/Projectiles/projectiles_tg.rsi + layers: + - state: omnilaser_greyscale + shader: unshaded + color: red + - type: Projectile + impactEffect: BulletImpactEffectRedDisabler + damage: + types: + Radiation: 5 + Structural: 30 # Slightly more damage than the 17heat from the Captain's Hitscan lasgun + soundHit: + collection: MeatLaserImpact + soundForce: true + - type: SpaceArtilleryProjectile + + +# Coolant object +- type: entity + parent: BaseItem + id: CoolantCartridge + name: coolant cartridge + description: A rather dense package. Utilises reaction of Frezon and Nitrogen to rappidly cool whatever machine it's in. Most often used in Space Armaments or Mining Lasers. + components: + - type: Material + - type: PhysicalComposition + materialComposition: + Coolant: 1 + - type: StaticPrice + price: 0 + - type: Stack + stackType: Coolant + count: 1 + baseLayer: base + layerStates: + - cash + - cash_10 + - cash_100 + - cash_500 + - cash_1000 + - cash_1000000 + - type: Sprite + sprite: Objects/Economy/cash.rsi + state: cash + layers: + - state: cash + map: ["base"] + - type: Physics + bodyType: Dynamic + - type: Fixtures + fixtures: + fix1: + density: 30 + shape: + !type:PhysShapeAabb + bounds: "-0.35,-0.2,0.25,0.1" + mask: + - ItemMask + - type: Appearance + +- type: material + id: Coolant + name: coolant + unit: materials-unit-bill + stackEntity: CoolantCartridge + icon: { sprite: /Textures/Objects/Economy/cash.rsi, state: cash } + price: 500 + +- type: stack + id: Coolant + name: coolant + icon: { sprite: /Textures/Objects/Economy/cash.rsi, state: cash } + spawn: CoolantCartridge + maxCount: 30 + itemSize: 4 + + +- type: entity + parent: CoolantCartridge + id: CoolantCartridge10 + suffix: 10 + components: + - type: Icon + sprite: Objects/Economy/cash.rsi + state: cash_10 + - type: Stack + count: 10 + +- type: entity + parent: CoolantCartridge + id: CoolantCartridge30 + suffix: 30 + components: + - type: Icon + sprite: Objects/Economy/cash.rsi + state: cash_100 + - type: Stack + count: 30 + + diff --git a/Resources/Prototypes/_NF/SpaceArtillery/sink_ports.yml b/Resources/Prototypes/_NF/SpaceArtillery/sink_ports.yml new file mode 100644 index 00000000000..9fcd4478639 --- /dev/null +++ b/Resources/Prototypes/_NF/SpaceArtillery/sink_ports.yml @@ -0,0 +1,19 @@ +- type: sinkPort + id: SpaceArtilleryFire + name: signal-port-name-space-artillery-fire + description: signal-port-description-space-artillery-fire + +- type: sinkPort + id: SpaceArtilleryToggleSafety + name: signal-port-name-space-artillery-toggle-safety + description: signal-port-description-space-artillery-toggle-safety + +- type: sinkPort + id: SpaceArtilleryOnSafety + name: signal-port-name-space-artillery-on-safety + description: signal-port-description-space-artillery-on-safety + +- type: sinkPort + id: SpaceArtilleryOffSafety + name: signal-port-name-space-artillery-off-safety + description: signal-port-description-space-artillery-off-safety \ No newline at end of file diff --git a/Resources/Prototypes/_NF/SpaceArtillery/source_ports.yml b/Resources/Prototypes/_NF/SpaceArtillery/source_ports.yml new file mode 100644 index 00000000000..b18ec6108a2 --- /dev/null +++ b/Resources/Prototypes/_NF/SpaceArtillery/source_ports.yml @@ -0,0 +1,14 @@ +- type: sourcePort + id: SpaceArtilleryDetectedFiring + name: signal-port-name-space-artillery-detected-firing + description: signal-port-description-space-artillery-detected-firing + +- type: sourcePort + id: SpaceArtilleryDetectedMalfunction + name: signal-port-name-space-artillery-detected-malfunction + description: signal-port-description-space-artillery-detected-malfunction + +- type: sourcePort + id: SpaceArtilleryDetectedSafetyChange + name: signal-port-name-space-artillery-detected-safety-change + description: signal-port-description-space-artillery-detected-safety-change \ No newline at end of file diff --git a/Resources/Prototypes/tags.yml b/Resources/Prototypes/tags.yml index c3dbf0bf09f..532a11e7585 100644 --- a/Resources/Prototypes/tags.yml +++ b/Resources/Prototypes/tags.yml @@ -1341,5 +1341,36 @@ - type: Tag # Frontier id: BloodFood # Frontier +- type: Tag # Frontier Space Artillery + id: CartridgeCoolant # Frontier Space Artillery + +- type: Tag # Frontier Space Artillery + id: CartridgeGPMG # Frontier Space Artillery + +- type: Tag # Frontier Space Artillery + id: CartridgeMachineGun # Frontier Space Artillery + +- type: Tag # Frontier Space Artillery + id: CartridgeNitroExpress # Frontier Space Artillery + +- type: Tag # Frontier Space Artillery + id: CartridgeRailgun # Frontier Space Artillery + +- type: Tag # Frontier Space Artillery + id: CartridgeShell # Frontier Space Artillery + - type: Tag # Frontier id: MothFood #Frontier + +- type: Tag # Frontier + id: WeaponRanged # Frontier + +- type: Tag # Frontier + id: WeaponLongarms # Frontier + +- type: Tag # Frontier + id: WeaponShortArms # Frontier + +- type: Tag # Frontier + id: WeaponMelee # Frontier + diff --git a/Resources/Textures/Structures/space_artillery.rsi/meta.json b/Resources/Textures/Structures/space_artillery.rsi/meta.json new file mode 100644 index 00000000000..798889e4759 --- /dev/null +++ b/Resources/Textures/Structures/space_artillery.rsi/meta.json @@ -0,0 +1,15 @@ +{ + "version": 1, + "license": "CC-BY-SA-3.0", + "copyright": "Taken from tgstation at https://github.com/tgstation/tgstation/commit/da354ba4e28fcaf73002d25cab0da4815808be60", + "size": { + "x": 32, + "y": 32 + }, + "states": [ + { + "name": "space_artillery", + "directions": 4 + } + ] +} diff --git a/Resources/Textures/Structures/space_artillery.rsi/space_artillery.png b/Resources/Textures/Structures/space_artillery.rsi/space_artillery.png new file mode 100644 index 00000000000..a33b77621ee Binary files /dev/null and b/Resources/Textures/Structures/space_artillery.rsi/space_artillery.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi/base-projectile.png b/Resources/Textures/_NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi/base-projectile.png new file mode 100644 index 00000000000..405f3593c8d Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi/base-projectile.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi/base-spent.png b/Resources/Textures/_NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi/base-spent.png new file mode 100644 index 00000000000..32c38257a3d Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi/base-spent.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi/base.png b/Resources/Textures/_NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi/base.png new file mode 100644 index 00000000000..6b6db59ce0c Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi/base.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi/meta.json b/Resources/Textures/_NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi/meta.json new file mode 100644 index 00000000000..7267dbcad7e --- /dev/null +++ b/Resources/Textures/_NF/Objects/SpaceArtillery/1000_armorpiercing_rail_casing.rsi/meta.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "size": { + "x": 64, + "y": 64 + }, + "license": "CC-BY-SA-3.0", + "copyright": "https://github.com/discordia-space/CEV-Eris/raw/8a848cde3e8610455f77704e861e5a06315a3b0e/icons/obj/ammo.dmi", + "states": [ + { + "name": "base" + }, + { + "name": "base-spent" + }, + { + "name": "base-projectile" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi/base-projectile.png b/Resources/Textures/_NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi/base-projectile.png new file mode 100644 index 00000000000..7459fe0a8d9 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi/base-projectile.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi/base-spent.png b/Resources/Textures/_NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi/base-spent.png new file mode 100644 index 00000000000..5fc0a28554d Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi/base-spent.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi/base.png b/Resources/Textures/_NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi/base.png new file mode 100644 index 00000000000..b744056269d Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi/base.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi/meta.json b/Resources/Textures/_NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi/meta.json new file mode 100644 index 00000000000..16745049c94 --- /dev/null +++ b/Resources/Textures/_NF/Objects/SpaceArtillery/50_armorpiercing_machinegun_casing.rsi/meta.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "size": { + "x": 32, + "y": 32 + }, + "license": "CC-BY-SA-3.0", + "copyright": "https://github.com/discordia-space/CEV-Eris/raw/8a848cde3e8610455f77704e861e5a06315a3b0e/icons/obj/ammo.dmi", + "states": [ + { + "name": "base" + }, + { + "name": "base-spent" + }, + { + "name": "base-projectile" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi/base-projectile.png b/Resources/Textures/_NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi/base-projectile.png new file mode 100644 index 00000000000..c16f964e83d Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi/base-projectile.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi/base-spent.png b/Resources/Textures/_NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi/base-spent.png new file mode 100644 index 00000000000..5fc0a28554d Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi/base-spent.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi/base.png b/Resources/Textures/_NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi/base.png new file mode 100644 index 00000000000..12d1ea52681 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi/base.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi/meta.json b/Resources/Textures/_NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi/meta.json new file mode 100644 index 00000000000..16745049c94 --- /dev/null +++ b/Resources/Textures/_NF/Objects/SpaceArtillery/50_emp_machinegun_casing.rsi/meta.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "size": { + "x": 32, + "y": 32 + }, + "license": "CC-BY-SA-3.0", + "copyright": "https://github.com/discordia-space/CEV-Eris/raw/8a848cde3e8610455f77704e861e5a06315a3b0e/icons/obj/ammo.dmi", + "states": [ + { + "name": "base" + }, + { + "name": "base-spent" + }, + { + "name": "base-projectile" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi/base-projectile.png b/Resources/Textures/_NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi/base-projectile.png new file mode 100644 index 00000000000..294b071dc08 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi/base-projectile.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi/base-spent.png b/Resources/Textures/_NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi/base-spent.png new file mode 100644 index 00000000000..5fc0a28554d Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi/base-spent.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi/base.png b/Resources/Textures/_NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi/base.png new file mode 100644 index 00000000000..1d1cd76cf00 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi/base.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi/meta.json b/Resources/Textures/_NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi/meta.json new file mode 100644 index 00000000000..16745049c94 --- /dev/null +++ b/Resources/Textures/_NF/Objects/SpaceArtillery/50_highexplosive_machinegun_casing.rsi/meta.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "size": { + "x": 32, + "y": 32 + }, + "license": "CC-BY-SA-3.0", + "copyright": "https://github.com/discordia-space/CEV-Eris/raw/8a848cde3e8610455f77704e861e5a06315a3b0e/icons/obj/ammo.dmi", + "states": [ + { + "name": "base" + }, + { + "name": "base-spent" + }, + { + "name": "base-projectile" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi/base-projectile.png b/Resources/Textures/_NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi/base-projectile.png new file mode 100644 index 00000000000..1f6a0f6c0b2 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi/base-projectile.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi/base-spent.png b/Resources/Textures/_NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi/base-spent.png new file mode 100644 index 00000000000..5fc0a28554d Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi/base-spent.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi/base.png b/Resources/Textures/_NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi/base.png new file mode 100644 index 00000000000..316b0643162 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi/base.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi/meta.json b/Resources/Textures/_NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi/meta.json new file mode 100644 index 00000000000..16745049c94 --- /dev/null +++ b/Resources/Textures/_NF/Objects/SpaceArtillery/50_practice_machinegun_casing.rsi/meta.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "size": { + "x": 32, + "y": 32 + }, + "license": "CC-BY-SA-3.0", + "copyright": "https://github.com/discordia-space/CEV-Eris/raw/8a848cde3e8610455f77704e861e5a06315a3b0e/icons/obj/ammo.dmi", + "states": [ + { + "name": "base" + }, + { + "name": "base-spent" + }, + { + "name": "base-projectile" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi/base-projectile.png b/Resources/Textures/_NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi/base-projectile.png new file mode 100644 index 00000000000..ef0a8f9d8b6 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi/base-projectile.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi/base-spent.png b/Resources/Textures/_NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi/base-spent.png new file mode 100644 index 00000000000..2b362cf78e0 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi/base-spent.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi/base.png b/Resources/Textures/_NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi/base.png new file mode 100644 index 00000000000..77877920951 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi/base.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi/meta.json b/Resources/Textures/_NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi/meta.json new file mode 100644 index 00000000000..16745049c94 --- /dev/null +++ b/Resources/Textures/_NF/Objects/SpaceArtillery/630_armorpiercing_shell_casing.rsi/meta.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "size": { + "x": 32, + "y": 32 + }, + "license": "CC-BY-SA-3.0", + "copyright": "https://github.com/discordia-space/CEV-Eris/raw/8a848cde3e8610455f77704e861e5a06315a3b0e/icons/obj/ammo.dmi", + "states": [ + { + "name": "base" + }, + { + "name": "base-spent" + }, + { + "name": "base-projectile" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi/base-projectile.png b/Resources/Textures/_NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi/base-projectile.png new file mode 100644 index 00000000000..152c1b4d230 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi/base-projectile.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi/base-spent.png b/Resources/Textures/_NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi/base-spent.png new file mode 100644 index 00000000000..dafcd09c6b4 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi/base-spent.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi/base.png b/Resources/Textures/_NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi/base.png new file mode 100644 index 00000000000..f9cb2d669d4 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi/base.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi/meta.json b/Resources/Textures/_NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi/meta.json new file mode 100644 index 00000000000..16745049c94 --- /dev/null +++ b/Resources/Textures/_NF/Objects/SpaceArtillery/630_emp_shell_casing.rsi/meta.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "size": { + "x": 32, + "y": 32 + }, + "license": "CC-BY-SA-3.0", + "copyright": "https://github.com/discordia-space/CEV-Eris/raw/8a848cde3e8610455f77704e861e5a06315a3b0e/icons/obj/ammo.dmi", + "states": [ + { + "name": "base" + }, + { + "name": "base-spent" + }, + { + "name": "base-projectile" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi/base-projectile.png b/Resources/Textures/_NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi/base-projectile.png new file mode 100644 index 00000000000..5ea4cb3312c Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi/base-projectile.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi/base-spent.png b/Resources/Textures/_NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi/base-spent.png new file mode 100644 index 00000000000..0ebd237c9dd Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi/base-spent.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi/base.png b/Resources/Textures/_NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi/base.png new file mode 100644 index 00000000000..4e65cadea71 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi/base.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi/meta.json b/Resources/Textures/_NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi/meta.json new file mode 100644 index 00000000000..16745049c94 --- /dev/null +++ b/Resources/Textures/_NF/Objects/SpaceArtillery/630_highexplosive_shell_casing.rsi/meta.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "size": { + "x": 32, + "y": 32 + }, + "license": "CC-BY-SA-3.0", + "copyright": "https://github.com/discordia-space/CEV-Eris/raw/8a848cde3e8610455f77704e861e5a06315a3b0e/icons/obj/ammo.dmi", + "states": [ + { + "name": "base" + }, + { + "name": "base-spent" + }, + { + "name": "base-projectile" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi/base-projectile.png b/Resources/Textures/_NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi/base-projectile.png new file mode 100644 index 00000000000..600183cc822 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi/base-projectile.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi/base-spent.png b/Resources/Textures/_NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi/base-spent.png new file mode 100644 index 00000000000..a8054e10412 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi/base-spent.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi/base.png b/Resources/Textures/_NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi/base.png new file mode 100644 index 00000000000..2dd19dceeea Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi/base.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi/meta.json b/Resources/Textures/_NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi/meta.json new file mode 100644 index 00000000000..16745049c94 --- /dev/null +++ b/Resources/Textures/_NF/Objects/SpaceArtillery/630_practice_shell_casing.rsi/meta.json @@ -0,0 +1,20 @@ +{ + "version": 1, + "size": { + "x": 32, + "y": 32 + }, + "license": "CC-BY-SA-3.0", + "copyright": "https://github.com/discordia-space/CEV-Eris/raw/8a848cde3e8610455f77704e861e5a06315a3b0e/icons/obj/ammo.dmi", + "states": [ + { + "name": "base" + }, + { + "name": "base-spent" + }, + { + "name": "base-projectile" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/beam_focused_pulse.png b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/beam_focused_pulse.png new file mode 100644 index 00000000000..41eee0c6656 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/beam_focused_pulse.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/beam_mining.png b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/beam_mining.png new file mode 100644 index 00000000000..ed86e6404d8 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/beam_mining.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/impact_focused_pulse.png b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/impact_focused_pulse.png new file mode 100644 index 00000000000..2913054d630 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/impact_focused_pulse.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/impact_mining.png b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/impact_mining.png new file mode 100644 index 00000000000..16d5c7e84ec Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/impact_mining.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/meta.json b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/meta.json new file mode 100644 index 00000000000..72c584444f2 --- /dev/null +++ b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/meta.json @@ -0,0 +1,101 @@ +{ + "version": 1, + "license": "CC-BY-SA-3.0", + "copyright": "Made by [DATA_REDACTED] .discord: #data_redacted", + "size": { + "x": 32, + "y": 32 + }, + "states": [ + { + "name": "muzzle_mining", + "delays": [ + [ + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002 + ] + ] + }, + { + "name": "beam_mining", + "delays": [ + [ + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002 + ] + ] + }, + { + "name": "impact_mining", + "delays": [ + [ + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002 + ] + ] + }, + { + "name": "muzzle_focused_pulse", + "delays": [ + [ + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002 + ] + ] + }, + { + "name": "beam_focused_pulse", + "delays": [ + [ + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002 + ] + ] + }, + { + "name": "impact_focused_pulse", + "delays": [ + [ + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002, + 0.060000002 + ] + ] + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/muzzle_focused_pulse.png b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/muzzle_focused_pulse.png new file mode 100644 index 00000000000..f07a55b1731 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/muzzle_focused_pulse.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/muzzle_mining.png b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/muzzle_mining.png new file mode 100644 index 00000000000..982e35a033b Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/lasers.rsi/muzzle_mining.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/mining_laser.rsi/capacitor.png b/Resources/Textures/_NF/Objects/SpaceArtillery/mining_laser.rsi/capacitor.png new file mode 100644 index 00000000000..d3a92a929f1 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/mining_laser.rsi/capacitor.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/mining_laser.rsi/chair.png b/Resources/Textures/_NF/Objects/SpaceArtillery/mining_laser.rsi/chair.png new file mode 100644 index 00000000000..575db5b1871 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/mining_laser.rsi/chair.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/mining_laser.rsi/meta.json b/Resources/Textures/_NF/Objects/SpaceArtillery/mining_laser.rsi/meta.json new file mode 100644 index 00000000000..cfbc27f97f8 --- /dev/null +++ b/Resources/Textures/_NF/Objects/SpaceArtillery/mining_laser.rsi/meta.json @@ -0,0 +1,23 @@ +{ + "version": 1, + "license": "CC-BY-SA-3.0", + "copyright": "Taken from tgstation at https://github.com/tgstation/tgstation/commit/da354ba4e28fcaf73002d25cab0da4815808be60", + "size": { + "x": 32, + "y": 32 + }, + "states": [ + { + "name": "turret", + "directions": 4 + }, + { + "name": "chair", + "directions": 4 + }, + { + "name": "capacitor", + "directions": 4 + } + ] +} diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/mining_laser.rsi/turret.png b/Resources/Textures/_NF/Objects/SpaceArtillery/mining_laser.rsi/turret.png new file mode 100644 index 00000000000..8ca32e73569 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/mining_laser.rsi/turret.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/space_artillery.rsi/meta.json b/Resources/Textures/_NF/Objects/SpaceArtillery/space_artillery.rsi/meta.json new file mode 100644 index 00000000000..798889e4759 --- /dev/null +++ b/Resources/Textures/_NF/Objects/SpaceArtillery/space_artillery.rsi/meta.json @@ -0,0 +1,15 @@ +{ + "version": 1, + "license": "CC-BY-SA-3.0", + "copyright": "Taken from tgstation at https://github.com/tgstation/tgstation/commit/da354ba4e28fcaf73002d25cab0da4815808be60", + "size": { + "x": 32, + "y": 32 + }, + "states": [ + { + "name": "space_artillery", + "directions": 4 + } + ] +} diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/space_artillery.rsi/space_artillery.png b/Resources/Textures/_NF/Objects/SpaceArtillery/space_artillery.rsi/space_artillery.png new file mode 100644 index 00000000000..a33b77621ee Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/space_artillery.rsi/space_artillery.png differ diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/space_artillery_wallmount.rsi/meta.json b/Resources/Textures/_NF/Objects/SpaceArtillery/space_artillery_wallmount.rsi/meta.json new file mode 100644 index 00000000000..c47ed9a9656 --- /dev/null +++ b/Resources/Textures/_NF/Objects/SpaceArtillery/space_artillery_wallmount.rsi/meta.json @@ -0,0 +1,15 @@ +{ + "version": 1, + "license": "CC-BY-SA-3.0", + "copyright": "Taken from tgstation at https://github.com/tgstation/tgstation/commit/da354ba4e28fcaf73002d25cab0da4815808be60", + "size": { + "x": 64, + "y": 64 + }, + "states": [ + { + "name": "space_artillery", + "directions": 4 + } + ] +} diff --git a/Resources/Textures/_NF/Objects/SpaceArtillery/space_artillery_wallmount.rsi/space_artillery.png b/Resources/Textures/_NF/Objects/SpaceArtillery/space_artillery_wallmount.rsi/space_artillery.png new file mode 100644 index 00000000000..294fe23e449 Binary files /dev/null and b/Resources/Textures/_NF/Objects/SpaceArtillery/space_artillery_wallmount.rsi/space_artillery.png differ