433 lines
17 KiB
C#
433 lines
17 KiB
C#
using Content.Server.Body.Systems;
|
|
using Content.Server.DoAfter;
|
|
using Content.Server.Popups;
|
|
using Content.Shared.Actions;
|
|
using Content.Shared.Chemistry.Components;
|
|
using Content.Shared.MobState;
|
|
using Content.Shared.MobState.Components;
|
|
using Robust.Shared.Containers;
|
|
using Robust.Shared.Player;
|
|
using System.Threading;
|
|
using Content.Server.Chat.Systems;
|
|
using Content.Server.GameTicking;
|
|
using Content.Server.GameTicking.Rules;
|
|
using Content.Server.Humanoid;
|
|
using Content.Server.NPC;
|
|
using Content.Shared.Damage;
|
|
using Content.Shared.Dragon;
|
|
using Content.Shared.Examine;
|
|
using Content.Shared.Maps;
|
|
using Content.Shared.Movement.Systems;
|
|
using Robust.Shared.GameStates;
|
|
using Robust.Shared.Map;
|
|
using Robust.Shared.Random;
|
|
using Content.Server.NPC.Systems;
|
|
|
|
namespace Content.Server.Dragon
|
|
{
|
|
public sealed partial class DragonSystem : GameRuleSystem
|
|
{
|
|
[Dependency] private readonly IMapManager _mapManager = default!;
|
|
[Dependency] private readonly IRobustRandom _random = default!;
|
|
[Dependency] private readonly ITileDefinitionManager _tileDef = default!;
|
|
[Dependency] private readonly ChatSystem _chat = default!;
|
|
[Dependency] private readonly SharedActionsSystem _actionsSystem = default!;
|
|
[Dependency] private readonly DoAfterSystem _doAfterSystem = default!;
|
|
[Dependency] private readonly PopupSystem _popupSystem = default!;
|
|
[Dependency] private readonly BloodstreamSystem _bloodstreamSystem = default!;
|
|
[Dependency] private readonly MovementSpeedModifierSystem _movement = default!;
|
|
[Dependency] private readonly SharedContainerSystem _containerSystem = default!;
|
|
[Dependency] private readonly SharedAudioSystem _audioSystem = default!;
|
|
[Dependency] private readonly NPCSystem _npc = default!;
|
|
|
|
/// <summary>
|
|
/// Minimum distance between 2 rifts allowed.
|
|
/// </summary>
|
|
private const int RiftRange = 15;
|
|
|
|
/// <summary>
|
|
/// Radius of tiles
|
|
/// </summary>
|
|
private const int RiftTileRadius = 2;
|
|
|
|
private const int RiftsAllowed = 3;
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
|
|
SubscribeLocalEvent<DragonComponent, ComponentStartup>(OnStartup);
|
|
SubscribeLocalEvent<DragonComponent, ComponentShutdown>(OnShutdown);
|
|
SubscribeLocalEvent<DragonComponent, DragonDevourComplete>(OnDragonDevourComplete);
|
|
SubscribeLocalEvent<DragonComponent, DragonDevourActionEvent>(OnDevourAction);
|
|
SubscribeLocalEvent<DragonComponent, DragonSpawnRiftActionEvent>(OnDragonRift);
|
|
SubscribeLocalEvent<DragonComponent, RefreshMovementSpeedModifiersEvent>(OnDragonMove);
|
|
|
|
SubscribeLocalEvent<DragonComponent, DragonStructureDevourComplete>(OnDragonStructureDevourComplete);
|
|
SubscribeLocalEvent<DragonComponent, DragonDevourCancelledEvent>(OnDragonDevourCancelled);
|
|
SubscribeLocalEvent<DragonComponent, MobStateChangedEvent>(OnMobStateChanged);
|
|
|
|
SubscribeLocalEvent<DragonRiftComponent, ComponentShutdown>(OnRiftShutdown);
|
|
SubscribeLocalEvent<DragonRiftComponent, ComponentGetState>(OnRiftGetState);
|
|
SubscribeLocalEvent<DragonRiftComponent, AnchorStateChangedEvent>(OnAnchorChange);
|
|
SubscribeLocalEvent<DragonRiftComponent, ExaminedEvent>(OnRiftExamined);
|
|
|
|
SubscribeLocalEvent<RoundEndTextAppendEvent>(OnRiftRoundEnd);
|
|
}
|
|
|
|
public override void Update(float frameTime)
|
|
{
|
|
base.Update(frameTime);
|
|
|
|
foreach (var comp in EntityQuery<DragonComponent>())
|
|
{
|
|
if (comp.WeakenedAccumulator > 0f)
|
|
{
|
|
comp.WeakenedAccumulator -= frameTime;
|
|
|
|
// No longer weakened.
|
|
if (comp.WeakenedAccumulator < 0f)
|
|
{
|
|
comp.WeakenedAccumulator = 0f;
|
|
_movement.RefreshMovementSpeedModifiers(comp.Owner);
|
|
}
|
|
}
|
|
|
|
// At max rifts
|
|
if (comp.Rifts.Count >= RiftsAllowed)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// If there's an active rift don't accumulate.
|
|
if (comp.Rifts.Count > 0)
|
|
{
|
|
var lastRift = comp.Rifts[^1];
|
|
|
|
if (TryComp<DragonRiftComponent>(lastRift, out var rift) && rift.State != DragonRiftState.Finished)
|
|
{
|
|
comp.RiftAccumulator = 0f;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
comp.RiftAccumulator += frameTime;
|
|
|
|
// Delete it, naughty dragon!
|
|
if (comp.RiftAccumulator >= comp.RiftMaxAccumulator)
|
|
{
|
|
Roar(comp);
|
|
QueueDel(comp.Owner);
|
|
}
|
|
}
|
|
|
|
foreach (var comp in EntityQuery<DragonRiftComponent>())
|
|
{
|
|
if (comp.State != DragonRiftState.Finished && comp.Accumulator >= comp.MaxAccumulator)
|
|
{
|
|
// TODO: When we get autocall you can buff if the rift finishes / 3 rifts are up
|
|
// for now they just keep 3 rifts up.
|
|
|
|
comp.Accumulator = comp.MaxAccumulator;
|
|
RemComp<DamageableComponent>(comp.Owner);
|
|
comp.State = DragonRiftState.Finished;
|
|
Dirty(comp);
|
|
}
|
|
else if (comp.State != DragonRiftState.Finished)
|
|
{
|
|
comp.Accumulator += frameTime;
|
|
}
|
|
|
|
comp.SpawnAccumulator += frameTime;
|
|
|
|
if (comp.State < DragonRiftState.AlmostFinished && comp.Accumulator > comp.MaxAccumulator / 2f)
|
|
{
|
|
comp.State = DragonRiftState.AlmostFinished;
|
|
Dirty(comp);
|
|
var location = Transform(comp.Owner).LocalPosition;
|
|
|
|
_chat.DispatchGlobalAnnouncement(Loc.GetString("carp-rift-warning", ("location", location)), playSound: false, colorOverride: Color.Red);
|
|
_audioSystem.PlayGlobal("/Audio/Misc/notice1.ogg", Filter.Broadcast(), true);
|
|
}
|
|
|
|
if (comp.SpawnAccumulator > comp.SpawnCooldown)
|
|
{
|
|
comp.SpawnAccumulator -= comp.SpawnCooldown;
|
|
var ent = Spawn(comp.SpawnPrototype, Transform(comp.Owner).MapPosition);
|
|
_npc.SetBlackboard(ent, NPCBlackboard.FollowTarget, new EntityCoordinates(comp.Owner, Vector2.Zero));
|
|
}
|
|
}
|
|
}
|
|
|
|
#region Rift
|
|
|
|
private void OnRiftExamined(EntityUid uid, DragonRiftComponent component, ExaminedEvent args)
|
|
{
|
|
args.PushMarkup(Loc.GetString("carp-rift-examine", ("percentage", MathF.Round(component.Accumulator / component.MaxAccumulator * 100))));
|
|
}
|
|
|
|
private void OnAnchorChange(EntityUid uid, DragonRiftComponent component, ref AnchorStateChangedEvent args)
|
|
{
|
|
if (!args.Anchored && component.State == DragonRiftState.Charging)
|
|
{
|
|
QueueDel(uid);
|
|
}
|
|
}
|
|
|
|
private void OnRiftShutdown(EntityUid uid, DragonRiftComponent component, ComponentShutdown args)
|
|
{
|
|
if (TryComp<DragonComponent>(component.Dragon, out var dragon) && !dragon.Weakened)
|
|
{
|
|
foreach (var rift in dragon.Rifts)
|
|
{
|
|
QueueDel(rift);
|
|
}
|
|
|
|
dragon.Rifts.Clear();
|
|
|
|
// We can't predict the rift being destroyed anyway so no point adding weakened to shared.
|
|
dragon.WeakenedAccumulator = dragon.WeakenedDuration;
|
|
_movement.RefreshMovementSpeedModifiers(component.Dragon);
|
|
_popupSystem.PopupEntity(Loc.GetString("carp-rift-destroyed"), component.Dragon, Filter.Entities(component.Dragon));
|
|
}
|
|
}
|
|
|
|
private void OnRiftGetState(EntityUid uid, DragonRiftComponent component, ref ComponentGetState args)
|
|
{
|
|
args.State = new DragonRiftComponentState()
|
|
{
|
|
State = component.State
|
|
};
|
|
}
|
|
|
|
private void OnDragonMove(EntityUid uid, DragonComponent component, RefreshMovementSpeedModifiersEvent args)
|
|
{
|
|
if (component.Weakened)
|
|
{
|
|
args.ModifySpeed(0.5f, 0.5f);
|
|
}
|
|
}
|
|
|
|
private void OnDragonRift(EntityUid uid, DragonComponent component, DragonSpawnRiftActionEvent args)
|
|
{
|
|
if (component.Weakened)
|
|
{
|
|
_popupSystem.PopupEntity(Loc.GetString("carp-rift-weakened"), uid, Filter.Entities(uid));
|
|
return;
|
|
}
|
|
|
|
if (component.Rifts.Count >= RiftsAllowed)
|
|
{
|
|
_popupSystem.PopupEntity(Loc.GetString("carp-rift-max"), uid, Filter.Entities(uid));
|
|
return;
|
|
}
|
|
|
|
if (component.Rifts.Count > 0 && TryComp<DragonRiftComponent>(component.Rifts[^1], out var rift) && rift.State != DragonRiftState.Finished)
|
|
{
|
|
_popupSystem.PopupEntity(Loc.GetString("carp-rift-duplicate"), uid, Filter.Entities(uid));
|
|
return;
|
|
}
|
|
|
|
var xform = Transform(uid);
|
|
|
|
// Have to be on a grid fam
|
|
if (!_mapManager.TryGetGrid(xform.GridUid, out var grid))
|
|
{
|
|
_popupSystem.PopupEntity(Loc.GetString("carp-rift-anchor"), uid, Filter.Entities(uid));
|
|
return;
|
|
}
|
|
|
|
foreach (var (_, riftXform) in EntityQuery<DragonRiftComponent, TransformComponent>(true))
|
|
{
|
|
if (riftXform.Coordinates.InRange(EntityManager, xform.Coordinates, RiftRange))
|
|
{
|
|
_popupSystem.PopupEntity(Loc.GetString("carp-rift-proximity", ("proximity", RiftRange)), uid, Filter.Entities(uid));
|
|
return;
|
|
}
|
|
}
|
|
|
|
foreach (var tile in grid.GetTilesIntersecting(new Circle(xform.WorldPosition, RiftTileRadius), false))
|
|
{
|
|
if (!tile.IsSpace(_tileDef))
|
|
continue;
|
|
|
|
_popupSystem.PopupEntity(Loc.GetString("carp-rift-space-proximity", ("proximity", RiftTileRadius)), uid, Filter.Entities(uid));
|
|
return;
|
|
}
|
|
|
|
var carpUid = Spawn(component.RiftPrototype, xform.MapPosition);
|
|
component.Rifts.Add(carpUid);
|
|
Comp<DragonRiftComponent>(carpUid).Dragon = uid;
|
|
_audioSystem.PlayPvs("/Audio/Weapons/Guns/Gunshots/rocket_launcher.ogg", carpUid);
|
|
}
|
|
|
|
#endregion
|
|
|
|
private void OnShutdown(EntityUid uid, DragonComponent component, ComponentShutdown args)
|
|
{
|
|
foreach (var rift in component.Rifts)
|
|
{
|
|
QueueDel(rift);
|
|
}
|
|
}
|
|
|
|
private void OnMobStateChanged(EntityUid uid, DragonComponent component, MobStateChangedEvent args)
|
|
{
|
|
//Empties the stomach upon death
|
|
//TODO: Do this when the dragon gets butchered instead
|
|
if (args.CurrentMobState == DamageState.Dead)
|
|
{
|
|
if (component.SoundDeath != null)
|
|
_audioSystem.PlayPvs(component.SoundDeath, uid, component.SoundDeath.Params);
|
|
|
|
component.DragonStomach.EmptyContainer();
|
|
|
|
foreach (var rift in component.Rifts)
|
|
{
|
|
QueueDel(rift);
|
|
}
|
|
|
|
component.Rifts.Clear();
|
|
}
|
|
}
|
|
|
|
private void OnDragonDevourCancelled(EntityUid uid, DragonComponent component, DragonDevourCancelledEvent args)
|
|
{
|
|
component.CancelToken = null;
|
|
}
|
|
|
|
private void OnDragonDevourComplete(EntityUid uid, DragonComponent component, DragonDevourComplete args)
|
|
{
|
|
component.CancelToken = null;
|
|
var ichorInjection = new Solution(component.DevourChem, component.DevourHealRate);
|
|
|
|
//Humanoid devours allow dragon to get eggs, corpses included
|
|
if (!EntityManager.HasComponent<HumanoidComponent>(args.Target))
|
|
{
|
|
ichorInjection.ScaleSolution(0.5f);
|
|
}
|
|
|
|
_bloodstreamSystem.TryAddToChemicals(uid, ichorInjection);
|
|
component.DragonStomach.Insert(args.Target);
|
|
|
|
if (component.SoundDevour != null)
|
|
_audioSystem.PlayPvs(component.SoundDevour, uid, component.SoundDevour.Params);
|
|
}
|
|
|
|
private void OnDragonStructureDevourComplete(EntityUid uid, DragonComponent component, DragonStructureDevourComplete args)
|
|
{
|
|
component.CancelToken = null;
|
|
//TODO: Figure out a better way of removing structures via devour that still entails standing still and waiting for a DoAfter. Somehow.
|
|
EntityManager.QueueDeleteEntity(args.Target);
|
|
|
|
if (component.SoundDevour != null)
|
|
_audioSystem.PlayPvs(component.SoundDevour, uid, component.SoundDevour.Params);
|
|
}
|
|
|
|
private void Roar(DragonComponent component)
|
|
{
|
|
if (component.SoundRoar != null)
|
|
_audioSystem.Play(component.SoundRoar, Filter.Pvs(component.Owner, 4f, EntityManager), component.Owner, true, component.SoundRoar.Params);
|
|
}
|
|
|
|
private void OnStartup(EntityUid uid, DragonComponent component, ComponentStartup args)
|
|
{
|
|
//Dragon doesn't actually chew, since he sends targets right into his stomach.
|
|
//I did it mom, I added ERP content into upstream. Legally!
|
|
component.DragonStomach = _containerSystem.EnsureContainer<Container>(uid, "dragon_stomach");
|
|
|
|
if (component.DevourAction != null)
|
|
_actionsSystem.AddAction(uid, component.DevourAction, null);
|
|
|
|
if (component.SpawnRiftAction != null)
|
|
_actionsSystem.AddAction(uid, component.SpawnRiftAction, null);
|
|
|
|
Roar(component);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The devour action
|
|
/// </summary>
|
|
private void OnDevourAction(EntityUid uid, DragonComponent component, DragonDevourActionEvent args)
|
|
{
|
|
if (component.CancelToken != null ||
|
|
args.Handled ||
|
|
component.DevourWhitelist?.IsValid(args.Target, EntityManager) != true)
|
|
{
|
|
return;
|
|
}
|
|
|
|
args.Handled = true;
|
|
var target = args.Target;
|
|
|
|
// Structure and mob devours handled differently.
|
|
if (EntityManager.TryGetComponent(target, out MobStateComponent? targetState))
|
|
{
|
|
switch (targetState.CurrentState)
|
|
{
|
|
case DamageState.Critical:
|
|
case DamageState.Dead:
|
|
component.CancelToken = new CancellationTokenSource();
|
|
|
|
_doAfterSystem.DoAfter(new DoAfterEventArgs(uid, component.DevourTime, component.CancelToken.Token, target)
|
|
{
|
|
UserFinishedEvent = new DragonDevourComplete(uid, target),
|
|
UserCancelledEvent = new DragonDevourCancelledEvent(),
|
|
BreakOnTargetMove = true,
|
|
BreakOnUserMove = true,
|
|
BreakOnStun = true,
|
|
});
|
|
break;
|
|
default:
|
|
_popupSystem.PopupEntity(Loc.GetString("devour-action-popup-message-fail-target-alive"), uid, Filter.Entities(uid));
|
|
break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
_popupSystem.PopupEntity(Loc.GetString("devour-action-popup-message-structure"), uid, Filter.Entities(uid));
|
|
|
|
if (component.SoundStructureDevour != null)
|
|
_audioSystem.PlayPvs(component.SoundStructureDevour, uid, component.SoundStructureDevour.Params);
|
|
|
|
component.CancelToken = new CancellationTokenSource();
|
|
|
|
_doAfterSystem.DoAfter(new DoAfterEventArgs(uid, component.StructureDevourTime, component.CancelToken.Token, target)
|
|
{
|
|
UserFinishedEvent = new DragonStructureDevourComplete(uid, target),
|
|
UserCancelledEvent = new DragonDevourCancelledEvent(),
|
|
BreakOnTargetMove = true,
|
|
BreakOnUserMove = true,
|
|
BreakOnStun = true,
|
|
});
|
|
}
|
|
|
|
private sealed class DragonDevourComplete : EntityEventArgs
|
|
{
|
|
public EntityUid User { get; }
|
|
public EntityUid Target { get; }
|
|
|
|
public DragonDevourComplete(EntityUid user, EntityUid target)
|
|
{
|
|
User = user;
|
|
Target = target;
|
|
}
|
|
}
|
|
|
|
private sealed class DragonStructureDevourComplete : EntityEventArgs
|
|
{
|
|
public EntityUid User { get; }
|
|
public EntityUid Target { get; }
|
|
|
|
public DragonStructureDevourComplete(EntityUid user, EntityUid target)
|
|
{
|
|
User = user;
|
|
Target = target;
|
|
}
|
|
}
|
|
|
|
private sealed class DragonDevourCancelledEvent : EntityEventArgs {}
|
|
}
|
|
}
|