Cinka/OldThink
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Rework climbing (#7706)

Browse Source
This commit is contained in:
Jacob Tong
2022-05-10 01:08:52 -07:00
committed by GitHub
parent 7198173ff4
commit 0e945b42b2
11 changed files with 516 additions and 634 deletions
Download Patch File Download Diff File Expand all files Collapse all files

283
Content.Server/Climbing/Components/ClimbableComponent.cs
View File

@@ -1,277 +1,14 @@
using Content.Server.DoAfter;
using Content.Server.Popups;
using Content.Shared.ActionBlocker;
using Content.Shared.Body.Components;
using Content.Shared.Body.Part;
using Content.Shared.Climbing;
using Content.Shared.DragDrop;
using Content.Shared.Interaction;
using Content.Shared.Interaction.Events;
using Content.Shared.Popups;
using Robust.Shared.Physics;
namespace Content.Server.Climbing.Components
namespace Content.Server.Climbing.Components;
[RegisterComponent]
public sealed class ClimbableComponent : SharedClimbableComponent
{
[RegisterComponent]
[ComponentReference(typeof(IClimbable))]
public sealed class ClimbableComponent : SharedClimbableComponent
{
[Dependency] private readonly IEntityManager _entities = default!;
/// <summary>
/// The time it takes to climb onto the entity.
/// </summary>
[ViewVariables]
[DataField("delay")]
private float _climbDelay = 0.8f;
protected override void Initialize()
{
base.Initialize();
if (!Owner.EnsureComponent(out PhysicsComponent _))
{
Logger.Warning($"Entity {_entities.GetComponent<MetaDataComponent>(Owner).EntityName} at {_entities.GetComponent<TransformComponent>(Owner).MapPosition} didn't have a {nameof(PhysicsComponent)}");
}
}
public override bool CanDragDropOn(DragDropEvent eventArgs)
{
if (!base.CanDragDropOn(eventArgs))
return false;
string reason;
bool canVault;
if (eventArgs.User == eventArgs.Dragged)
canVault = CanVault(eventArgs.User, eventArgs.Target, out reason);
else
canVault = CanVault(eventArgs.User, eventArgs.Dragged, eventArgs.Target, out reason);
if (!canVault)
eventArgs.User.PopupMessage(reason);
return canVault;
}
/// <summary>
/// Checks if the user can vault the target
/// </summary>
/// <param name="user">The entity that wants to vault</param>
/// <param name="target">The object that is being vaulted</param>
/// <param name="reason">The reason why it cant be dropped</param>
/// <returns></returns>
private bool CanVault(EntityUid user, EntityUid target, out string reason)
{
if (!EntitySystem.Get<ActionBlockerSystem>().CanInteract(user, target))
{
reason = Loc.GetString("comp-climbable-cant-interact");
return false;
}
if (!_entities.HasComponent<ClimbingComponent>(user) ||
!_entities.TryGetComponent(user, out SharedBodyComponent? body))
{
reason = Loc.GetString("comp-climbable-cant-climb");
return false;
}
if (!body.HasPartOfType(BodyPartType.Leg) ||
!body.HasPartOfType(BodyPartType.Foot))
{
reason = Loc.GetString("comp-climbable-cant-climb");
return false;
}
if (!EntitySystem.Get<SharedInteractionSystem>().InRangeUnobstructed(user, target, Range))
{
reason = Loc.GetString("comp-climbable-cant-reach");
return false;
}
reason = string.Empty;
return true;
}
/// <summary>
/// Checks if the user can vault the dragged entity onto the the target
/// </summary>
/// <param name="user">The user that wants to vault the entity</param>
/// <param name="dragged">The entity that is being vaulted</param>
/// <param name="target">The object that is being vaulted onto</param>
/// <param name="reason">The reason why it cant be dropped</param>
/// <returns></returns>
private bool CanVault(EntityUid user, EntityUid dragged, EntityUid target, out string reason)
{
if (!EntitySystem.Get<ActionBlockerSystem>().CanInteract(user, dragged))
{
reason = Loc.GetString("comp-climbable-cant-interact");
return false;
}
// CanInteract() doesn't support checking a second "target" entity.
// Doing so manually:
var ev = new GettingInteractedWithAttemptEvent(user, target);
_entities.EventBus.RaiseLocalEvent(target, ev);
if (ev.Cancelled)
{
reason = Loc.GetString("comp-climbable-cant-interact");
return false;
}
if (!_entities.HasComponent<ClimbingComponent>(dragged))
{
reason = Loc.GetString("comp-climbable-cant-climb");
return false;
}
bool Ignored(EntityUid entity) => entity == target || entity == user || entity == dragged;
var sys = EntitySystem.Get<SharedInteractionSystem>();
if (!sys.InRangeUnobstructed(user, target, Range, predicate: Ignored) ||
!sys.InRangeUnobstructed(user, dragged, Range, predicate: Ignored))
{
reason = Loc.GetString("comp-climbable-cant-reach");
return false;
}
reason = string.Empty;
return true;
}
public override bool DragDropOn(DragDropEvent eventArgs)
{
if (eventArgs.User == eventArgs.Dragged)
{
TryClimb(eventArgs.User, eventArgs.Target);
}
else
{
TryMoveEntity(eventArgs.User, eventArgs.Dragged, eventArgs.Target);
}
return true;
}
private async void TryMoveEntity(EntityUid user, EntityUid entityToMove, EntityUid climbable)
{
var doAfterEventArgs = new DoAfterEventArgs(user, _climbDelay, default, entityToMove)
{
BreakOnTargetMove = true,
BreakOnUserMove = true,
BreakOnDamage = true,
BreakOnStun = true
};
var result = await EntitySystem.Get<DoAfterSystem>().WaitDoAfter(doAfterEventArgs);
if (result != DoAfterStatus.Cancelled && _entities.TryGetComponent(entityToMove, out FixturesComponent? body) && body.FixtureCount >= 1)
{
var entityPos = _entities.GetComponent<TransformComponent>(entityToMove).WorldPosition;
var direction = (_entities.GetComponent<TransformComponent>(Owner).WorldPosition - entityPos).Normalized;
var endPoint = _entities.GetComponent<TransformComponent>(Owner).WorldPosition;
var climbMode = _entities.GetComponent<ClimbingComponent>(entityToMove);
climbMode.IsClimbing = true;
if (MathF.Abs(direction.X) < 0.6f) // user climbed mostly vertically so lets make it a clean straight line
{
endPoint = new Vector2(entityPos.X, endPoint.Y);
}
else if (MathF.Abs(direction.Y) < 0.6f) // user climbed mostly horizontally so lets make it a clean straight line
{
endPoint = new Vector2(endPoint.X, entityPos.Y);
}
climbMode.TryMoveTo(entityPos, endPoint);
// we may potentially need additional logic since we're forcing a player onto a climbable
// there's also the cases where the user might collide with the person they are forcing onto the climbable that i haven't accounted for
_entities.EventBus.RaiseLocalEvent(entityToMove, new StartClimbEvent(climbable), false);
_entities.EventBus.RaiseLocalEvent(climbable, new ClimbedOnEvent(entityToMove), false);
var othersMessage = Loc.GetString("comp-climbable-user-climbs-force-other",
("user", user), ("moved-user", entityToMove), ("climbable", Owner));
user.PopupMessageOtherClients(othersMessage);
var selfMessage = Loc.GetString("comp-climbable-user-climbs-force", ("moved-user", entityToMove), ("climbable", Owner));
user.PopupMessage(selfMessage);
}
}
public async void TryClimb(EntityUid user, EntityUid climbable)
{
if (!_entities.TryGetComponent(user, out ClimbingComponent? climbingComponent) || climbingComponent.IsClimbing)
return;
var doAfterEventArgs = new DoAfterEventArgs(user, _climbDelay, default, Owner)
{
BreakOnTargetMove = true,
BreakOnUserMove = true,
BreakOnDamage = true,
BreakOnStun = true
};
var result = await EntitySystem.Get<DoAfterSystem>().WaitDoAfter(doAfterEventArgs);
if (result != DoAfterStatus.Cancelled && _entities.TryGetComponent(user, out FixturesComponent? fixtureComp) && fixtureComp.Fixtures.Count >= 1)
{
// TODO: Remove the copy-paste code
var userPos = _entities.GetComponent<TransformComponent>(user).WorldPosition;
var direction = (_entities.GetComponent<TransformComponent>(Owner).WorldPosition - userPos).Normalized;
var endPoint = _entities.GetComponent<TransformComponent>(Owner).WorldPosition;
_entities.EventBus.RaiseLocalEvent(user, new StartClimbEvent(climbable), false);
_entities.EventBus.RaiseLocalEvent(climbable, new ClimbedOnEvent(user), false);
var climbMode = _entities.GetComponent<ClimbingComponent>(user);
climbMode.IsClimbing = true;
if (MathF.Abs(direction.X) < 0.6f) // user climbed mostly vertically so lets make it a clean straight line
{
endPoint = new Vector2(_entities.GetComponent<TransformComponent>(user).WorldPosition.X, endPoint.Y);
}
else if (MathF.Abs(direction.Y) < 0.6f) // user climbed mostly horizontally so lets make it a clean straight line
{
endPoint = new Vector2(endPoint.X, _entities.GetComponent<TransformComponent>(user).WorldPosition.Y);
}
climbMode.TryMoveTo(userPos, endPoint);
var othersMessage = Loc.GetString("comp-climbable-user-climbs-other", ("user", user), ("climbable", Owner));
user.PopupMessageOtherClients(othersMessage);
var selfMessage = Loc.GetString("comp-climbable-user-climbs", ("climbable", Owner));
user.PopupMessage(selfMessage);
}
}
}
}
/// <summary>
/// Raised on an entity when it is climbed on.
/// </summary>
public sealed class ClimbedOnEvent : EntityEventArgs
{
public EntityUid Climber;
public ClimbedOnEvent(EntityUid climber)
{
Climber = climber;
}
}
/// <summary>
/// Raised on an entity when it successfully climbs on something.
/// </summary>
public sealed class StartClimbEvent : EntityEventArgs
{
public EntityUid Climbable;
public StartClimbEvent(EntityUid climbable)
{
Climbable = climbable;
}
/// <summary>
/// The time it takes to climb onto the entity.
/// </summary>
[ViewVariables]
[DataField("delay")]
public float ClimbDelay = 0.8f;
}

110
Content.Server/Climbing/Components/ClimbingComponent.cs
View File

@@ -1,92 +1,34 @@
using System;
using Content.Shared.Buckle.Components;
using Content.Shared.Climbing;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Maths;
using Robust.Shared.Players;
using Robust.Shared.Timing;
namespace Content.Server.Climbing.Components
namespace Content.Server.Climbing.Components;
[RegisterComponent]
[ComponentReference(typeof(SharedClimbingComponent))]
public sealed class ClimbingComponent : SharedClimbingComponent
{
[RegisterComponent]
[ComponentReference(typeof(SharedClimbingComponent))]
public sealed class ClimbingComponent : SharedClimbingComponent
[ViewVariables(VVAccess.ReadWrite)]
public override bool IsClimbing
{
[Dependency] private readonly IGameTiming _gameTiming = default!;
[Dependency] private readonly IEntityManager _entityManager = default!;
public override bool IsClimbing
get => base.IsClimbing;
set
{
get => base.IsClimbing;
set
{
if (base.IsClimbing == value)
return;
base.IsClimbing = value;
if (value)
{
StartClimbTime = IoCManager.Resolve<IGameTiming>().CurTime;
EntitySystem.Get<ClimbSystem>().AddActiveClimber(this);
OwnerIsTransitioning = true;
}
else
{
EntitySystem.Get<ClimbSystem>().RemoveActiveClimber(this);
OwnerIsTransitioning = false;
}
Dirty();
}
}
public override bool OwnerIsTransitioning
{
get => base.OwnerIsTransitioning;
set
{
if (value == base.OwnerIsTransitioning) return;
base.OwnerIsTransitioning = value;
Dirty();
}
}
/// <summary>
/// Make the owner climb from one point to another
/// </summary>
public void TryMoveTo(Vector2 from, Vector2 to)
{
if (!_entityManager.TryGetComponent<PhysicsComponent>(Owner, out var physicsComponent)) return;
var velocity = (to - from).Length;
if (velocity <= 0.0f) return;
// Since there are bodies with different masses:
// mass * 5 seems enough to move entity
// instead of launching cats like rockets against the walls with constant impulse value.
physicsComponent.ApplyLinearImpulse((to - from).Normalized * velocity * physicsComponent.Mass * 5);
OwnerIsTransitioning = true;
EntitySystem.Get<ClimbSystem>().UnsetTransitionBoolAfterBufferTime(Owner, this);
}
public void Update()
{
if (!IsClimbing || _gameTiming.CurTime < TimeSpan.FromSeconds(BufferTime) + StartClimbTime)
{
return;
}
if (!IsOnClimbableThisFrame && IsClimbing)
IsClimbing = false;
}
public override ComponentState GetComponentState()
{
return new ClimbModeComponentState(base.IsClimbing, OwnerIsTransitioning);
if (base.IsClimbing == value) return;
base.IsClimbing = value;
Dirty();
}
}
public override bool OwnerIsTransitioning
{
get => base.OwnerIsTransitioning;
set
{
if (value == base.OwnerIsTransitioning) return;
base.OwnerIsTransitioning = value;
Dirty();
}
}
[ViewVariables]
public Dictionary<string, int> DisabledFixtureMasks { get; } = new();
}