332 lines
11 KiB
C#
332 lines
11 KiB
C#
using Unity.Netcode;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
|
|
public sealed class NetworkPhysicalLeverInteractable :
|
|
NetworkInteractable,
|
|
IPlayerInteractionSession
|
|
{
|
|
private const ulong NoController = ulong.MaxValue;
|
|
|
|
[Header("Lever visual")]
|
|
[SerializeField] private Transform leverVisual;
|
|
[SerializeField] private Vector3 neutralLocalEulerAngles;
|
|
[SerializeField] private Vector3 localRotationAxis = Vector3.right;
|
|
[SerializeField] private Vector3 localHandleDirection = Vector3.up;
|
|
[SerializeField, Range(-179f, 179f)] private float minimumAngle = -50f;
|
|
[SerializeField, Range(-179f, 179f)] private float maximumAngle = 50f;
|
|
[SerializeField, Min(1f)] private float movementSpeed = 180f;
|
|
|
|
[Header("Control")]
|
|
[SerializeField, Min(0.5f)] private float maximumControlDistance = 4f;
|
|
|
|
[Header("Two positions")]
|
|
[SerializeField, Range(0.05f, 0.95f)] private float switchThreshold = 0.5f;
|
|
[SerializeField] private bool initialPositionIsMaximum;
|
|
[SerializeField] private bool returnToInitialPositionAfterSwitch;
|
|
[SerializeField, Min(0f)] private float automaticReturnDelay = 0.25f;
|
|
[SerializeField] private UnityEvent<float> leverValueChanged;
|
|
[SerializeField] private UnityEvent<bool> leverStateChanged;
|
|
|
|
private readonly NetworkVariable<ulong> controllingClientId = new(
|
|
NoController,
|
|
NetworkVariableReadPermission.Everyone,
|
|
NetworkVariableWritePermission.Server);
|
|
|
|
private readonly NetworkVariable<float> synchronizedValue = new(
|
|
0f,
|
|
NetworkVariableReadPermission.Everyone,
|
|
NetworkVariableWritePermission.Server);
|
|
|
|
private readonly NetworkVariable<bool> isActivated = new(
|
|
false,
|
|
NetworkVariableReadPermission.Everyone,
|
|
NetworkVariableWritePermission.Server);
|
|
|
|
private bool hasSnapTarget;
|
|
private float snapTargetValue;
|
|
private float automaticReturnTime = -1f;
|
|
|
|
public float Value => synchronizedValue.Value;
|
|
public bool IsActivated => isActivated.Value;
|
|
public bool IsControlled => controllingClientId.Value != NoController;
|
|
public bool IsControlledByLocalPlayer =>
|
|
NetworkManager != null && IsControlledBy(NetworkManager.LocalClientId);
|
|
public string ReleasePrompt => "[Hold E] Pulling lever";
|
|
|
|
public override string InteractionPrompt => IsControlledByLocalPlayer
|
|
? ReleasePrompt
|
|
: IsControlled
|
|
? "Lever in use"
|
|
: InteractionLabel;
|
|
|
|
public override bool IsInteractionAvailable =>
|
|
base.IsInteractionAvailable && (!IsControlled || IsControlledByLocalPlayer);
|
|
|
|
private Quaternion NeutralLocalRotation => Quaternion.Euler(neutralLocalEulerAngles);
|
|
private Vector3 RotationAxis => localRotationAxis.sqrMagnitude > 0.0001f
|
|
? localRotationAxis.normalized
|
|
: Vector3.right;
|
|
private Vector3 HandleDirection => localHandleDirection.sqrMagnitude > 0.0001f
|
|
? localHandleDirection.normalized
|
|
: Vector3.up;
|
|
private float InitialPositionValue => initialPositionIsMaximum ? 1f : 0f;
|
|
|
|
private void Reset()
|
|
{
|
|
leverVisual = transform;
|
|
neutralLocalEulerAngles = leverVisual.localEulerAngles;
|
|
}
|
|
|
|
private void OnValidate()
|
|
{
|
|
if (maximumAngle < minimumAngle)
|
|
maximumAngle = minimumAngle;
|
|
}
|
|
|
|
public override void OnNetworkSpawn()
|
|
{
|
|
PlayerInteractionSessionRegistry.Register(this);
|
|
|
|
if (IsServer)
|
|
{
|
|
synchronizedValue.Value = InitialPositionValue;
|
|
isActivated.Value = initialPositionIsMaximum;
|
|
}
|
|
|
|
synchronizedValue.OnValueChanged += HandleValueChanged;
|
|
isActivated.OnValueChanged += HandleActivationChanged;
|
|
ApplyVisual(synchronizedValue.Value);
|
|
leverValueChanged?.Invoke(synchronizedValue.Value);
|
|
leverStateChanged?.Invoke(isActivated.Value);
|
|
}
|
|
|
|
public override void OnNetworkDespawn()
|
|
{
|
|
PlayerInteractionSessionRegistry.Unregister(this);
|
|
synchronizedValue.OnValueChanged -= HandleValueChanged;
|
|
isActivated.OnValueChanged -= HandleActivationChanged;
|
|
}
|
|
|
|
private void FixedUpdate()
|
|
{
|
|
if (!IsServer || !IsSpawned || leverVisual == null)
|
|
return;
|
|
|
|
if (IsControlled)
|
|
{
|
|
if (!TryGetPlayerObject(controllingClientId.Value, out NetworkObject playerObject) ||
|
|
!IsPlayerWithinControlDistance(playerObject))
|
|
{
|
|
EndControl();
|
|
return;
|
|
}
|
|
|
|
if (TryCalculateTargetValue(playerObject, out float targetValue))
|
|
{
|
|
MoveTowardsValue(targetValue);
|
|
UpdateActivationAtEndpoint();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (hasSnapTarget)
|
|
{
|
|
if (MoveTowardsValue(snapTargetValue))
|
|
CompleteSnap();
|
|
|
|
return;
|
|
}
|
|
|
|
if (automaticReturnTime >= 0f && Time.time >= automaticReturnTime)
|
|
BeginSnap(InitialPositionValue);
|
|
}
|
|
|
|
public bool IsControlledBy(ulong clientId) =>
|
|
controllingClientId.Value == clientId;
|
|
|
|
public void RequestRelease()
|
|
{
|
|
if (IsSpawned && IsControlledByLocalPlayer)
|
|
RequestReleaseServerRpc();
|
|
}
|
|
|
|
protected override bool CanInteractOnServer(ulong senderClientId) =>
|
|
!IsControlled || IsControlledBy(senderClientId);
|
|
|
|
protected override void InteractOnServer(
|
|
ulong senderClientId,
|
|
NetworkObject playerObject)
|
|
{
|
|
if (IsControlledBy(senderClientId))
|
|
EndControl();
|
|
else
|
|
BeginControl(senderClientId);
|
|
}
|
|
|
|
[Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Everyone)]
|
|
private void RequestReleaseServerRpc(RpcParams rpcParams = default)
|
|
{
|
|
if (IsControlledBy(rpcParams.Receive.SenderClientId))
|
|
EndControl();
|
|
}
|
|
|
|
private void BeginControl(ulong clientId)
|
|
{
|
|
hasSnapTarget = false;
|
|
automaticReturnTime = -1f;
|
|
controllingClientId.Value = clientId;
|
|
}
|
|
|
|
private void EndControl()
|
|
{
|
|
if (!IsControlled)
|
|
return;
|
|
|
|
controllingClientId.Value = NoController;
|
|
float targetPosition = synchronizedValue.Value >= switchThreshold ? 1f : 0f;
|
|
BeginSnap(targetPosition);
|
|
}
|
|
|
|
private void BeginSnap(float targetValue)
|
|
{
|
|
automaticReturnTime = -1f;
|
|
snapTargetValue = targetValue >= 0.5f ? 1f : 0f;
|
|
hasSnapTarget = true;
|
|
}
|
|
|
|
private void CompleteSnap()
|
|
{
|
|
hasSnapTarget = false;
|
|
bool snappedToMaximum = snapTargetValue >= 0.5f;
|
|
|
|
SetActivation(snappedToMaximum);
|
|
|
|
bool movedAwayFromInitialPosition =
|
|
!Mathf.Approximately(snapTargetValue, InitialPositionValue);
|
|
automaticReturnTime = returnToInitialPositionAfterSwitch &&
|
|
movedAwayFromInitialPosition
|
|
? Time.time + automaticReturnDelay
|
|
: -1f;
|
|
}
|
|
|
|
private void UpdateActivationAtEndpoint()
|
|
{
|
|
const float endpointTolerance = 0.001f;
|
|
|
|
if (synchronizedValue.Value >= 1f - endpointTolerance)
|
|
SetActivation(true);
|
|
else if (synchronizedValue.Value <= endpointTolerance)
|
|
SetActivation(false);
|
|
}
|
|
|
|
private void SetActivation(bool activated)
|
|
{
|
|
if (isActivated.Value != activated)
|
|
isActivated.Value = activated;
|
|
}
|
|
|
|
private bool IsPlayerWithinControlDistance(NetworkObject playerObject)
|
|
{
|
|
float maximumDistanceSquared = maximumControlDistance * maximumControlDistance;
|
|
return (playerObject.transform.position - leverVisual.position).sqrMagnitude <=
|
|
maximumDistanceSquared;
|
|
}
|
|
|
|
private bool TryCalculateTargetValue(
|
|
NetworkObject playerObject,
|
|
out float targetValue)
|
|
{
|
|
targetValue = synchronizedValue.Value;
|
|
|
|
FirstPersonCameraController cameraController =
|
|
playerObject.GetComponent<FirstPersonCameraController>();
|
|
Transform aimTransform = cameraController != null
|
|
? cameraController.AimTransform
|
|
: playerObject.transform;
|
|
|
|
Transform leverParent = leverVisual.parent;
|
|
Quaternion neutralRotation = NeutralLocalRotation;
|
|
Vector3 axisWorld = leverParent != null
|
|
? leverParent.TransformDirection(neutralRotation * RotationAxis)
|
|
: neutralRotation * RotationAxis;
|
|
Vector3 neutralDirectionWorld = leverParent != null
|
|
? leverParent.TransformDirection(neutralRotation * HandleDirection)
|
|
: neutralRotation * HandleDirection;
|
|
|
|
Ray aimRay = new(aimTransform.position, aimTransform.forward);
|
|
Plane movementPlane = new(axisWorld, leverVisual.position);
|
|
Vector3 targetPoint;
|
|
|
|
if (movementPlane.Raycast(aimRay, out float enter) && enter >= 0f)
|
|
{
|
|
targetPoint = aimRay.GetPoint(enter);
|
|
}
|
|
else
|
|
{
|
|
float distanceAlongRay = Mathf.Max(
|
|
0.25f,
|
|
Vector3.Dot(leverVisual.position - aimRay.origin, aimRay.direction));
|
|
targetPoint = aimRay.GetPoint(distanceAlongRay);
|
|
}
|
|
|
|
Vector3 desiredDirection = Vector3.ProjectOnPlane(
|
|
targetPoint - leverVisual.position,
|
|
axisWorld);
|
|
if (desiredDirection.sqrMagnitude < 0.0001f)
|
|
return false;
|
|
|
|
float desiredAngle = Vector3.SignedAngle(
|
|
neutralDirectionWorld,
|
|
desiredDirection.normalized,
|
|
axisWorld);
|
|
desiredAngle = Mathf.Clamp(desiredAngle, minimumAngle, maximumAngle);
|
|
targetValue = Mathf.InverseLerp(minimumAngle, maximumAngle, desiredAngle);
|
|
return true;
|
|
}
|
|
|
|
private bool MoveTowardsValue(float targetValue)
|
|
{
|
|
float angleRange = Mathf.Max(0.01f, maximumAngle - minimumAngle);
|
|
float valueStep = movementSpeed / angleRange * Time.fixedDeltaTime;
|
|
float nextValue = Mathf.MoveTowards(
|
|
synchronizedValue.Value,
|
|
Mathf.Clamp01(targetValue),
|
|
valueStep);
|
|
|
|
if (!Mathf.Approximately(nextValue, synchronizedValue.Value))
|
|
synchronizedValue.Value = nextValue;
|
|
|
|
return Mathf.Approximately(nextValue, targetValue);
|
|
}
|
|
|
|
private void HandleValueChanged(float _, float currentValue)
|
|
{
|
|
ApplyVisual(currentValue);
|
|
leverValueChanged?.Invoke(currentValue);
|
|
}
|
|
|
|
private void HandleActivationChanged(bool _, bool currentState) =>
|
|
leverStateChanged?.Invoke(currentState);
|
|
|
|
private void ApplyVisual(float value)
|
|
{
|
|
if (leverVisual == null)
|
|
return;
|
|
|
|
float angle = Mathf.Lerp(minimumAngle, maximumAngle, Mathf.Clamp01(value));
|
|
leverVisual.localRotation = NeutralLocalRotation *
|
|
Quaternion.AngleAxis(angle, RotationAxis);
|
|
}
|
|
|
|
[ContextMenu("Preview/Minimum")]
|
|
private void PreviewMinimum() => ApplyVisual(0f);
|
|
|
|
[ContextMenu("Preview/Initial Position")]
|
|
private void PreviewInitialPosition() => ApplyVisual(InitialPositionValue);
|
|
|
|
[ContextMenu("Preview/Maximum")]
|
|
private void PreviewMaximum() => ApplyVisual(1f);
|
|
}
|