1000 lines
28 KiB
C#
1000 lines
28 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using BITFALL.Player.Equip;
|
|
using BITFALL.Player.Movement;
|
|
using BITKit;
|
|
using BITKit.Entities;
|
|
using BITKit.Selection;
|
|
using BITKit.StateMachine;
|
|
using Unity.Mathematics;
|
|
using UnityEngine;
|
|
using UnityEngine.AI;
|
|
using UnityEngine.InputSystem;
|
|
using UnityEngine.InputSystem.Interactions;
|
|
using UnityEngine.Splines;
|
|
using UnityEngine.UI;
|
|
|
|
namespace BITFALL.Entities.Player.Movement.States
|
|
{
|
|
[Serializable]
|
|
public class Vault : BasicMovement, IPlayerVaultState
|
|
{
|
|
private Collider _collider;
|
|
private bool _isHigher;
|
|
private Vector3 _targetPos;
|
|
private bool _inBounds;
|
|
private CapsuleCollider _playerCollider;
|
|
private bool _entered;
|
|
private bool _exited;
|
|
public override void OnStateEntry(IState old)
|
|
{
|
|
base.OnStateEntry(old);
|
|
|
|
_entered = _exited = _inBounds = false;
|
|
_playerCollider = self.GetComponent<CapsuleCollider>();
|
|
|
|
self.LimitViewAngle = 45;
|
|
|
|
actor.ForceNotGrounded();
|
|
|
|
_collider = self.vaultPoint.Collider;
|
|
actor.PhysicsComponent.IgnoreCollision(_collider.transform,true);
|
|
|
|
_targetPos = self.vaultPoint.CurrentPoint;
|
|
|
|
_isHigher = false;
|
|
|
|
actor.alwaysNotGrounded = true;
|
|
|
|
}
|
|
|
|
public override void OnStateExit(IState old, IState newState)
|
|
{
|
|
base.OnStateExit(old, newState);
|
|
|
|
//actor.RigidbodyComponent.IsKinematic = false;
|
|
|
|
self.LimitViewAngle = 0;
|
|
self.ExpectJump.Reset();
|
|
|
|
actor.alwaysNotGrounded = false;
|
|
|
|
actor.ForceNotGrounded();
|
|
|
|
actor.PhysicsComponent.IgnoreCollision(_collider.transform,false);
|
|
|
|
}
|
|
|
|
public override void OnStateUpdate(float deltaTime)
|
|
{
|
|
base.OnStateUpdate(deltaTime);
|
|
var samplePos = actor.Position;
|
|
var tempPos = samplePos;
|
|
tempPos.y = _collider.bounds.center.y;
|
|
_inBounds = _collider.bounds.Intersects(_playerCollider.bounds) || _collider.bounds.Contains(tempPos);
|
|
|
|
|
|
if (_inBounds)
|
|
{
|
|
actor.ForceNotGrounded();
|
|
|
|
if (actor.Position.y < _targetPos.y)
|
|
{
|
|
var pos = actor.Position;
|
|
pos.y = _targetPos.y - 1;
|
|
actor.Position = pos;
|
|
_isHigher = true;
|
|
}
|
|
|
|
_entered = true;
|
|
}
|
|
else
|
|
{
|
|
if (_entered && _exited is false)
|
|
{
|
|
_exited = true;
|
|
//Debug.Log("Exited");
|
|
}
|
|
if (samplePos.y > _targetPos.y)
|
|
{
|
|
_isHigher = true;
|
|
}
|
|
if (_isHigher is false)
|
|
{
|
|
actor.Position += actor.Up * (8 * deltaTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
|
|
{
|
|
if (_exited)
|
|
{
|
|
base.UpdateVelocity(ref currentVelocity, deltaTime);
|
|
currentVelocity.y = Mathf.Clamp(currentVelocity.y, -2, 8);
|
|
}
|
|
else
|
|
{
|
|
if (currentVelocity.GetLength() < 1)
|
|
{
|
|
currentVelocity = actor.Forward;
|
|
}
|
|
currentVelocity.y = 0;
|
|
}
|
|
}
|
|
|
|
public override void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
|
|
{
|
|
var targetRotation = currentRotation;
|
|
base.UpdateRotation(ref targetRotation, deltaTime);
|
|
currentRotation = Quaternion.Lerp(currentRotation, targetRotation, deltaTime);
|
|
}
|
|
|
|
public override void AfterUpdateMovement(float deltaTime)
|
|
{
|
|
//base.AfterUpdateMovement(deltaTime);
|
|
self.CurrentCameraPosition.shouldBe = self.FpvLocalPosition;
|
|
}
|
|
|
|
public bool ManualCancel()
|
|
{
|
|
if (Enabled is false) return false;
|
|
Exit();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class EdgeClimb : PlayerCharacterState, IPlayerEdgeClimbState
|
|
{
|
|
[SerializeField] private LayerMask layerMask;
|
|
|
|
public int Phase { get; set; }
|
|
public float3 CurrentPoint => climbPoint;
|
|
[Inject] private IEquipService _equipService;
|
|
private Collider _collider;
|
|
private Quaternion rotation;
|
|
private readonly List<Collider> _colliders = new List<Collider>();
|
|
private Animator _animator;
|
|
private Collider[] rangeColliders = new Collider[8];
|
|
private int rangeLength;
|
|
private Vector3 handPoint;
|
|
private Vector3 climbPoint;
|
|
private List<(Collider collider,Vector3 closePoint)> closePoints = new List<(Collider, Vector3)>();
|
|
private Collider[] tempColliders = new Collider[16];
|
|
public float3 NextPoint { get; set; }
|
|
|
|
public bool ManualCancel()
|
|
{
|
|
if (Enabled is false) return false;
|
|
Exit();
|
|
return true;
|
|
}
|
|
public float3[] ClosestPoint => closePointList.ValueArray;
|
|
private CacheList<float3> closePointList = new();
|
|
|
|
public override void OnStateEntry(IState old)
|
|
{
|
|
base.OnStateEntry(old);
|
|
|
|
_animator = self.GetComponent<Animator>();
|
|
|
|
_collider = self.edgeClimbPoint.Collider;
|
|
_colliders.Add(_collider);
|
|
|
|
climbPoint = self.edgeClimbPoint.CurrentPoint;
|
|
actor.PhysicsComponent.IgnoreCollision(_collider.transform,true);
|
|
|
|
var position = actor.Position+ actor.Forward * -1;
|
|
position.y = _collider.bounds.center.y;
|
|
var direction = _collider.bounds.center - position;
|
|
direction = Vector3.ProjectOnPlane(direction, Vector3.up);
|
|
var ray = new Ray(position, direction);
|
|
|
|
Debug.DrawRay(ray.origin,ray.direction * 8,Color.red,1f);
|
|
if (_collider.Raycast(ray, out var hit, 64))
|
|
{
|
|
rotation = Quaternion.LookRotation(hit.normal) * Quaternion.Euler(0, 180, 0);;
|
|
}
|
|
else
|
|
{
|
|
|
|
BIT4Log.Warning<IPlayerEdgeClimbState>(" Edge Climb Raycast Failed");
|
|
}
|
|
|
|
|
|
actor.alwaysNotGrounded = true;
|
|
actor.ColliderComponent.enabled = false;
|
|
actor.UseRootMotion = true;
|
|
|
|
self.LimitViewAngle = 90;
|
|
|
|
Phase = 0;
|
|
|
|
_equipService.AllowEquip.AddDisableElements(this);
|
|
|
|
self.inputActionGroup.RegisterCallback(self.JumpAction, OnJump);
|
|
self.inputActionGroup.RegisterCallback(self.MovementAction, OnMovement);
|
|
}
|
|
|
|
private void OnMovement(InputAction.CallbackContext obj)
|
|
{
|
|
// if (Phase is not (4 or 5 or 6)) return;
|
|
// var value = obj.ReadValue<Vector2>();
|
|
// if (value is { x: 0, y: 1 })
|
|
// {
|
|
// OnJump();
|
|
// }
|
|
}
|
|
private void OnJump(InputAction.CallbackContext obj)
|
|
{
|
|
if (obj is not {interaction:PressInteraction,performed:true}) return;
|
|
if(Phase is not (4 or 5 or 6))return;
|
|
OnJump();
|
|
}
|
|
private void OnJump()
|
|
{
|
|
|
|
var input = self.InputVector;
|
|
|
|
var startPos = climbPoint - actor.Forward * 0.1f;
|
|
var allowExit = Physics.Linecast(startPos, startPos + actor.Forward * 1f + actor.Up * 0.5f, out _,
|
|
layerMask) is false;
|
|
|
|
if (input.y is not -1)
|
|
{
|
|
if( (allowExit && input.x is 0) || closePoints.Count is 0)
|
|
{
|
|
|
|
var length = Physics.OverlapSphereNonAlloc(climbPoint, 1f, tempColliders,
|
|
layerMask);
|
|
for (var i = 0; i < length; i++)
|
|
{
|
|
var collider = tempColliders[i];
|
|
|
|
_colliders.Add(collider);
|
|
actor.PhysicsComponent.IgnoreCollision(collider.transform, true);
|
|
}
|
|
Phase = 8;
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
if (closePoints.Count is 0) return;
|
|
var direction = actor.Rotation * (Vector2)input;
|
|
var samplePoint = climbPoint + direction;
|
|
var close = closePoints.OrderBy(Close).First();
|
|
|
|
if(input.y is 1 && close.closePoint.y < climbPoint.y) return;
|
|
if(input.y is -1 && close.closePoint.y > climbPoint.y) return;
|
|
|
|
var offset = climbPoint-actor.Position;
|
|
|
|
actor.PhysicsComponent.IgnoreCollision(close.collider.transform,true);
|
|
|
|
_collider = close.collider; _colliders.Add(_collider);
|
|
|
|
NextPoint = close.closePoint - offset;
|
|
|
|
Phase = 1;
|
|
|
|
self.Stamina -= 10;
|
|
return;
|
|
float Close((Collider collider, Vector3 closePoint) arg)
|
|
{
|
|
var distance = Vector3.Distance(climbPoint, arg.closePoint);
|
|
|
|
var panel = new Plane(-actor.Forward,climbPoint);
|
|
var center = panel.ClosestPointOnPlane(climbPoint+direction);
|
|
var localPosition = panel.ClosestPointOnPlane(arg.closePoint)-center;
|
|
|
|
var pos = new Vector2
|
|
{
|
|
y = localPosition.y,
|
|
x = -localPosition.z
|
|
};
|
|
return Vector2.Distance(pos, default);
|
|
}
|
|
}
|
|
|
|
public override void OnStateExit(IState old, IState newState)
|
|
{
|
|
base.OnStateExit(old, newState);
|
|
|
|
actor.alwaysNotGrounded = false;
|
|
actor.ColliderComponent.enabled = true;
|
|
actor.UseRootMotion = false;
|
|
|
|
self.LimitViewAngle = 0;
|
|
|
|
_equipService.AllowEquip.RemoveDisableElements(this);
|
|
|
|
self.inputActionGroup.UnRegisterCallback(self.JumpAction, OnJump);
|
|
self.inputActionGroup.UnRegisterCallback(self.MovementAction, OnMovement);
|
|
|
|
foreach (var x in _colliders)
|
|
{
|
|
actor.PhysicsComponent.IgnoreCollision(x.transform,false);
|
|
}
|
|
_colliders.Clear();
|
|
}
|
|
|
|
public override void OnStateUpdate(float deltaTime)
|
|
{
|
|
base.OnStateUpdate(deltaTime);
|
|
switch (Phase)
|
|
{
|
|
case 0:
|
|
var targetPos = self.ExpectClimb.shouldBe - Vector3.up * 1.6f;
|
|
targetPos -= self.Rotation * Vector3.forward * 0.4f;
|
|
if (actor.Position.y >= targetPos.y)
|
|
Phase = 5;
|
|
if (Phase is 5)
|
|
actor.Position = targetPos;
|
|
return;
|
|
case 1:
|
|
if (Vector3.Distance(actor.Position, NextPoint) < 0.1f)
|
|
{
|
|
Phase = 5;
|
|
}
|
|
break;
|
|
case 4 or 5 or 6 or 7 or 9:
|
|
|
|
self.Stamina -= Phase switch
|
|
{
|
|
4 or 6=>5,
|
|
_=>1,
|
|
}* deltaTime;
|
|
|
|
if (self.Stamina <= 0)
|
|
{
|
|
Exit();
|
|
return;
|
|
}
|
|
|
|
handPoint = Vector3.Lerp(
|
|
_animator.GetBoneTransform(HumanBodyBones.LeftHand).position,
|
|
_animator.GetBoneTransform(HumanBodyBones.RightHand).position,
|
|
0.5f
|
|
);
|
|
|
|
climbPoint = _collider.ClosestPoint(actor.Position + Vector3.up * 10);
|
|
|
|
rangeLength =
|
|
Physics.OverlapSphereNonAlloc(climbPoint, 1.6f, rangeColliders, layerMask);
|
|
|
|
closePoints.Clear();
|
|
closePointList.Clear();
|
|
for (var i = 0; i < rangeLength; i++)
|
|
{
|
|
var collider = rangeColliders[i];
|
|
|
|
if (collider == _collider)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (collider is MeshCollider { convex: false })
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var closestPoint = collider.ClosestPoint(actor.Position + actor.Forward * -1);
|
|
closestPoint.y = collider.bounds.center.y + collider.bounds.extents.y;
|
|
|
|
if (Vector3.Distance(closestPoint, climbPoint) > 2)
|
|
{
|
|
continue;
|
|
}
|
|
var length = Physics.OverlapSphereNonAlloc(closestPoint, 0.01f, tempColliders, layerMask);
|
|
switch (length)
|
|
{
|
|
case <2:
|
|
break;
|
|
case 2:
|
|
if (_collider == tempColliders[0] || _collider==tempColliders[1])
|
|
{
|
|
break;
|
|
}
|
|
continue;
|
|
default:continue;
|
|
}
|
|
var direction = closestPoint - climbPoint;
|
|
direction = actor.transform.InverseTransformVector(direction);
|
|
|
|
closePoints.Add((collider, closestPoint));
|
|
closePointList.Add(closestPoint);
|
|
}
|
|
|
|
if (_collider.Raycast(new Ray(climbPoint + actor.Forward * -0.1f + actor.Up*-0.1f + actor.Right * (self.InputVector.x * 0.2f), actor.Forward), out _, 1f) is false)
|
|
{
|
|
try
|
|
{
|
|
foreach (var x in closePoints)
|
|
{
|
|
if (Vector3.Distance(x.closePoint, climbPoint) < 0.2f)
|
|
{
|
|
_collider = x.collider;
|
|
throw new InGameException();
|
|
}
|
|
}
|
|
Phase = 5;
|
|
}
|
|
catch (InGameException){}
|
|
|
|
}
|
|
else
|
|
Phase = Phase switch
|
|
{
|
|
5 when self.InputVector.x is not 0 => self.InputVector.x > 0 ? 4 : 6,
|
|
4 or 6 when self.InputVector.x is 0 => 5,
|
|
_ => Phase
|
|
};
|
|
|
|
var point = actor.Position;
|
|
point.y = _animator.GetBoneTransform(HumanBodyBones.RightHand).position.y;
|
|
point.y -= 0.2f;
|
|
break;
|
|
}
|
|
}
|
|
|
|
private float upVelocity;
|
|
public override void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
|
|
{
|
|
//base.UpdateVelocity(ref currentVelocity, deltaTime);
|
|
|
|
switch (Phase)
|
|
{
|
|
case 0:
|
|
var currentPosition = actor.Position;
|
|
currentPosition = Vector3.Lerp(
|
|
currentPosition,
|
|
self.ExpectClimb.shouldBe - Vector3.up * 1.6f + rotation * Vector3.forward * -0.5f,8*deltaTime);
|
|
currentPosition.y = actor.Position.y;
|
|
currentPosition.y+=(upVelocity+=deltaTime)*deltaTime;
|
|
|
|
if(_collider.Raycast(new Ray(currentPosition,Vector3.forward),out var fixHit,1.6f))
|
|
{
|
|
currentPosition.x = fixHit.point.x;
|
|
currentPosition.z = fixHit.point.y;
|
|
}
|
|
actor.Position = currentPosition;
|
|
break;
|
|
case 1:
|
|
actor.Position += ((Vector3)NextPoint - actor.Position).normalized * (6 * deltaTime);
|
|
break;
|
|
case 4 or 5 or 6:
|
|
var hand = _animator.GetBoneTransform(HumanBodyBones.LeftHand);
|
|
var closePoint = _collider.ClosestPoint(actor.Position+Vector3.up*8-actor.Forward);
|
|
var offset = closePoint.y - hand.position.y - 0.08f;
|
|
actor.Position+=actor.Up * (offset * 8 * deltaTime);
|
|
|
|
if (_collider.Raycast(new Ray(hand.position - actor.Forward * 0.4f, actor.Forward), out var hit, 1f))
|
|
{
|
|
var targetFootPosition = hit.point - actor.Forward * 0.05f;
|
|
|
|
rotation = Quaternion.LookRotation(hit.normal) * Quaternion.Euler(0, 180, 0);
|
|
|
|
if (Vector3.Distance(targetFootPosition, hand.position) > 0.01f)
|
|
{
|
|
Debug.DrawLine(hand.position, hit.point, Color.red, 1f);
|
|
actor.Position += (targetFootPosition - hand.position) * (deltaTime * 8);
|
|
}
|
|
else
|
|
{
|
|
Debug.DrawLine(hand.position, hit.point, Color.green, 1f);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
switch (Phase)
|
|
{
|
|
case 0:
|
|
currentVelocity = Vector3.up;
|
|
break;
|
|
}
|
|
}
|
|
public override void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
|
|
{
|
|
if (Phase is 0 or 4 or 5 or 6)
|
|
{
|
|
currentRotation = rotation;
|
|
}
|
|
}
|
|
public override void AfterUpdateMovement(float deltaTime)
|
|
{
|
|
self.CurrentCameraPosition.shouldBe = self.FpvLocalPosition;
|
|
}
|
|
|
|
public override void DrawGizmos()
|
|
{
|
|
Gizmos.DrawWireCube(climbPoint,Vector3.one*0.1f);
|
|
Gizmos.DrawCube(handPoint,Vector3.one*0.1f);
|
|
Gizmos.color=Color.green;
|
|
foreach (var x in closePoints)
|
|
{
|
|
Gizmos.DrawSphere(x.closePoint,0.1f);
|
|
}
|
|
}
|
|
}
|
|
[Serializable]
|
|
public class Climb : PlayerCharacterState,IPlayerClimbState
|
|
{
|
|
[SerializeField] protected float lerpDelta = 5;
|
|
private IntervalUpdate cancelInterval = new(0.16f);
|
|
private Transform ignore;
|
|
private bool needInit;
|
|
private float _startDistance;
|
|
private Vector3 _startPos;
|
|
|
|
public override void OnStateEntry(IState old)
|
|
{
|
|
ignore = self.climbClosePoint.Collider.transform;
|
|
actor.PhysicsComponent.IgnoreCollision(ignore,true);
|
|
base.OnStateEntry(old);
|
|
self.ExpectCrouch.Reset();
|
|
actor.alwaysNotGrounded = true;
|
|
actor.ForceNotGrounded();
|
|
actor.ColliderComponent.enabled = false;
|
|
cancelInterval.Reset();
|
|
needInit = true;
|
|
|
|
self.LimitViewAngle = 80;
|
|
|
|
_startDistance = Vector3.Distance(actor.Position, self.ExpectClimb);
|
|
|
|
_startPos = actor.Position;
|
|
}
|
|
public override void OnStateUpdate(float deltaTime)
|
|
{
|
|
if (cancelInterval.AllowUpdate && actor.Velocity.sqrMagnitude<=0.16f
|
|
|| Vector3.Distance(self.ExpectClimb,_startPos) > _startDistance && actor.Position.y > self.ExpectClimb.shouldBe.y
|
|
)
|
|
{
|
|
Exit();
|
|
return;
|
|
}
|
|
|
|
var direction = self.transform.InverseTransformPoint(self.ExpectClimb.shouldBe);
|
|
if (direction.z <= -0.3f)
|
|
{
|
|
Exit();
|
|
return;
|
|
}
|
|
|
|
// var pos = actor.Position;
|
|
// pos.y = self.ExpectClimb.shouldBe.y;
|
|
// if (self.Position.y >= self.ExpectClimb.shouldBe.y && Vector3.Distance(pos,self.ExpectClimb.shouldBe)<0.1f)
|
|
// {
|
|
// Exit();
|
|
// }
|
|
}
|
|
public override void OnStateExit(IState old, IState newState)
|
|
{
|
|
actor.PhysicsComponent.IgnoreCollision(ignore,false);
|
|
actor.alwaysNotGrounded = false;
|
|
actor.ColliderComponent.enabled = true;
|
|
self.ExpectJump.Reset();
|
|
actor.ForceGrounded();
|
|
|
|
self.LimitViewAngle = 0;
|
|
//
|
|
}
|
|
|
|
public override void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
|
|
{
|
|
if (needInit)
|
|
{
|
|
currentVelocity.y = 0;
|
|
needInit = false;
|
|
}
|
|
var velocity =(self.ExpectClimb.shouldBe - actor.Position)*lerpDelta;
|
|
|
|
velocity += self.Rotation * self.MovementInput.normalized * 1.0f;
|
|
currentVelocity = Vector3.Lerp(currentVelocity,velocity,lerpDelta*deltaTime);
|
|
}
|
|
|
|
public override void AfterUpdateMovement(float deltaTime)
|
|
{
|
|
self.CurrentCameraPosition.shouldBe = self.FpvLocalPosition;
|
|
}
|
|
public bool ManualCancel()
|
|
{
|
|
if (!Enabled) return false;
|
|
Exit();
|
|
return true;
|
|
}
|
|
}
|
|
[Serializable]
|
|
public sealed class Link:PlayerCharacterState,IPlayerLinkState
|
|
{
|
|
public int LinkArea { get; private set; }
|
|
private OffMeshLink _offMeshLink;
|
|
private ISplineContainer _splineContainer;
|
|
private float progress;
|
|
private float increment;
|
|
|
|
[Inject] private IEquipService _equipService;
|
|
[Inject] private InputActionGroup _inputActionGroup;
|
|
|
|
private readonly IntervalUpdate exitInterval = new(0.32f);
|
|
|
|
public override void OnStateEntry(IState old)
|
|
{
|
|
base.OnStateEntry(old);
|
|
|
|
self.ExpectCrouch.Reset();
|
|
|
|
self.ExpectJump.Reset();
|
|
|
|
actor.ForceNotGrounded();
|
|
|
|
actor.RigidbodyComponent.IsKinematic = true;
|
|
actor.ColliderComponent.enabled = false;
|
|
actor.UseRootMotion = true;
|
|
|
|
Init(self.OffMeshLink);
|
|
|
|
self.LimitViewAngle = 45;
|
|
|
|
_equipService.AllowEquip.AddDisableElements(this);
|
|
|
|
exitInterval.Reset();
|
|
|
|
_inputActionGroup.RegisterCallback(self.CrouchAction, OnCrouch);
|
|
_inputActionGroup.RegisterCallback(self.JumpAction, OnJump);
|
|
}
|
|
|
|
private void OnJump(InputAction.CallbackContext obj)
|
|
{
|
|
switch (obj)
|
|
{
|
|
case {interaction:PressInteraction,performed:true}:
|
|
Exit();
|
|
return;
|
|
}
|
|
}
|
|
private void OnCrouch(InputAction.CallbackContext obj)
|
|
{
|
|
switch (obj)
|
|
{
|
|
case { interaction: PressInteraction, performed: true }:
|
|
Exit();
|
|
return;
|
|
}
|
|
}
|
|
|
|
public override void OnStateExit(IState old, IState newState)
|
|
{
|
|
base.OnStateExit(old, newState);
|
|
actor.RigidbodyComponent.IsKinematic = false;
|
|
actor.ColliderComponent.enabled = true;
|
|
actor.UseRootMotion = false;
|
|
|
|
self.LimitViewAngle = 0;
|
|
|
|
_equipService.AllowEquip.RemoveDisableElements(this);
|
|
|
|
_inputActionGroup.UnRegisterCallback(self.CrouchAction, OnCrouch);
|
|
_inputActionGroup.UnRegisterCallback(self.JumpAction, OnJump);
|
|
}
|
|
|
|
private void Init(OffMeshLink offMeshLink)
|
|
{
|
|
var offsetTransform = offMeshLink.transform;
|
|
_offMeshLink = offMeshLink;
|
|
|
|
offMeshLink.TryGetComponent<ISplineContainer>(out _splineContainer);
|
|
|
|
LinkArea = offMeshLink.area;
|
|
|
|
if (_splineContainer is not null)
|
|
{
|
|
var isStart =
|
|
Vector3.Distance(
|
|
actor.Position,
|
|
offsetTransform.TransformPoint(_splineContainer.Splines[0].Knots.First().Position)
|
|
) <
|
|
Vector3.Distance(
|
|
actor.Position,
|
|
offsetTransform.TransformPoint(_splineContainer.Splines[0].Knots.Last().Position)
|
|
);
|
|
progress = isStart ? 0 : 1;
|
|
increment = isStart ? 1 : -1;
|
|
}
|
|
else
|
|
{
|
|
var offset = Mathf.Lerp(offMeshLink.startTransform.position.y,offMeshLink.endTransform.position.y,0.5f);
|
|
var offsetPos = actor.Position;
|
|
offsetPos.y = offset;
|
|
actor.ForceNotGrounded();
|
|
actor.Position = Vector3.MoveTowards(actor.Position, offsetPos, 0.64f);
|
|
progress = 0.5f;
|
|
}
|
|
}
|
|
|
|
public override void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
|
|
{
|
|
if (_splineContainer is null)
|
|
{
|
|
actor.Rotation = Quaternion.Lerp(
|
|
actor.Rotation,
|
|
_offMeshLink.transform.rotation * Quaternion.Euler(0,-180,0),
|
|
5 * deltaTime
|
|
);
|
|
}
|
|
}
|
|
|
|
public override void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
|
|
{
|
|
actor.ForceNotGrounded();
|
|
|
|
if (_offMeshLink is null) return;
|
|
switch (_splineContainer)
|
|
{
|
|
case null:
|
|
var positionA = _offMeshLink.startTransform.position;
|
|
var positionB = positionA;
|
|
positionB.y = _offMeshLink.endTransform.position.y;
|
|
var positionC = actor.Position + Vector3.up * (0 * deltaTime * 1.6f);
|
|
|
|
Vector3 vectorAC = positionC - positionA;
|
|
Vector3 vectorAB = positionB - positionA;
|
|
|
|
Vector3 closestPoint = positionA + Vector3.Project(vectorAC, vectorAB);
|
|
|
|
actor.Position = closestPoint;
|
|
//currentVelocity = Vector3.Lerp(currentVelocity , (closestPoint - actor.Position) , 5 * deltaTime);
|
|
|
|
self.UnityEntity.SetDirect(BITHash.Player.ActionSpeed,self.MovementInput.z);
|
|
|
|
break;
|
|
case not null:
|
|
var trans = _offMeshLink.transform;
|
|
var pos =trans.position + trans.rotation * _splineContainer.Splines[0].EvaluatePosition(progress +=increment * deltaTime);
|
|
|
|
actor.Position =Vector3.Lerp(actor.Position , pos , 8*deltaTime) ;
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public override void OnStateUpdate(float deltaTime)
|
|
{
|
|
|
|
if (exitInterval.AllowUpdateWithoutReset is false) return;
|
|
switch (_offMeshLink,_splineContainer)
|
|
{
|
|
case (null,null):
|
|
case (not null,_) when !_offMeshLink || _offMeshLink.gameObject.activeInHierarchy is false:
|
|
Exit();
|
|
return;
|
|
case (not null,not null):
|
|
if (progress is > 1.1f or < -0.1f)
|
|
{
|
|
Exit();
|
|
}
|
|
return;
|
|
case (not null,null):
|
|
if (actor.Position.y > _offMeshLink.endTransform.position.y - 1)
|
|
{
|
|
Exit();
|
|
actor.Position = _offMeshLink.endTransform.position;
|
|
return;
|
|
}
|
|
if (actor.Position.y < _offMeshLink.startTransform.position.y)
|
|
{
|
|
Exit();
|
|
actor.Position = _offMeshLink.startTransform.position;
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
public override void AfterUpdateMovement(float deltaTime)
|
|
{
|
|
self.CurrentCameraPosition.shouldBe = self.FpvLocalPosition;
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public sealed class Dodge : PlayerCharacterState,IPlayerDodgeState
|
|
{
|
|
[SerializeField] private int costStamina = 10;
|
|
[SerializeField] private AnimationCurve curve;
|
|
[SerializeField] private float duration = 0.32f;
|
|
[Inject] private IEquipService _equipService;
|
|
private int direction;
|
|
private float process;
|
|
|
|
[Inject] private IHealth _health;
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
_health.OnDamageFactory += OnDamageFactory;
|
|
|
|
}
|
|
|
|
public override void OnStateEntry(IState old)
|
|
{
|
|
base.OnStateEntry(old);
|
|
direction = self.MovementInput.x > 0 ? 1 : -1;
|
|
process = 0;
|
|
self.Stamina-= costStamina;
|
|
|
|
actor.UseRootMotion = true;
|
|
|
|
_equipService.AllowEquip.AddDisableElements(this);
|
|
|
|
}
|
|
|
|
public override void OnStateExit(IState old, IState newState)
|
|
{
|
|
base.OnStateExit(old, newState);
|
|
_equipService.AllowEquip.RemoveDisableElements(this);
|
|
actor.UseRootMotion = false;
|
|
}
|
|
|
|
public override void OnStateUpdate(float deltaTime)
|
|
{
|
|
base.OnStateUpdate(deltaTime);
|
|
process += deltaTime / duration;
|
|
}
|
|
|
|
// public override void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
|
|
// {
|
|
// currentVelocity = actor.transform.right * (direction * curve.Evaluate(process+=deltaTime / duration));
|
|
// }
|
|
|
|
public override void AfterUpdateMovement(float deltaTime)
|
|
{
|
|
if(process>=1)
|
|
Exit();
|
|
if(actor.IsGrounded is false)Exit();
|
|
}
|
|
|
|
private int OnDamageFactory(DamageMessage msg, int currentDamage)
|
|
{
|
|
if (self.CurrentState is not IPlayerDodgeState || msg.Initiator is not Entity initiator)
|
|
return currentDamage;
|
|
var _direction = self.Position - initiator.transform.position;
|
|
var verticalAngle = Vector3.Angle(initiator.transform.forward, _direction) - 90.0f;
|
|
//Debug.Log(verticalAngle);
|
|
return 0;
|
|
|
|
}
|
|
public bool ManualCancel()
|
|
{
|
|
if (!Enabled) return false;
|
|
Exit();
|
|
return true;
|
|
}
|
|
}
|
|
[Serializable]
|
|
public sealed class Fixed:PlayerCharacterState,IPlayerFixedState
|
|
{
|
|
public object FixedObject=>_fixedPlace;
|
|
public float3 FixedPosition=>_fixedPlace.FixedPosition;
|
|
public quaternion FixedRotation=>_fixedPlace.FixedRotation;
|
|
public float3 FixedLocalPosition => throw new NotImplementedException();
|
|
public quaternion FixedLocalRotation => throw new NotImplementedException();
|
|
private IPlayerFixedPlace _fixedPlace;
|
|
|
|
[Inject] private ISelector _selector;
|
|
|
|
[Inject] private IEquipService _equipService;
|
|
|
|
[Inject] private IKnockdown _knockdown;
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
_selector.OnActive+=OnSelectorActive;
|
|
}
|
|
|
|
public override void OnStateEntry(IState old)
|
|
{
|
|
base.OnStateEntry(old);
|
|
//actor.enabled = false;
|
|
//actor.RigidbodyComponent.IsKinematic = true;
|
|
actor.ColliderComponent.enabled = false;
|
|
actor.PhysicsComponent.enabled = false;
|
|
actor.alwaysNotGrounded = true;
|
|
actor.constraintRotation = false;
|
|
self.ExpectCrouch.Reset();
|
|
self.LimitViewAngle = 100;
|
|
|
|
_equipService.AllowEquip.AddDisableElements(this);
|
|
|
|
lastRotation = _fixedPlace.FixedRotation;
|
|
|
|
}
|
|
|
|
public override void OnStateExit(IState old, IState newState)
|
|
{
|
|
base.OnStateExit(old, newState);
|
|
//actor.RigidbodyComponent.IsKinematic = false;
|
|
actor.ColliderComponent.enabled = true;
|
|
actor.alwaysNotGrounded = false;
|
|
actor.PhysicsComponent.enabled = true;
|
|
actor.constraintRotation = true;
|
|
//actor.enabled = true;
|
|
self.LimitViewAngle = 0;
|
|
|
|
_equipService.AllowEquip.RemoveDisableElements(this);
|
|
}
|
|
public override void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
|
|
{
|
|
currentVelocity = default;
|
|
actor.Position = FixedPosition + _fixedPlace.Velocity * deltaTime;
|
|
;
|
|
}
|
|
public override void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
|
|
{
|
|
currentRotation = FixedRotation;
|
|
}
|
|
public override void AfterUpdateMovement(float deltaTime)
|
|
{
|
|
base.AfterUpdateMovement(deltaTime);
|
|
self.CurrentCameraPosition.shouldBe = self.FpvLocalPosition;
|
|
if (self.ExpectCrouch.shouldBe && _fixedPlace.Exit(self.Entity))
|
|
{
|
|
self.ExpectCrouch.Reset();
|
|
Exit();
|
|
}else if (_fixedPlace is null)
|
|
{
|
|
Exit();
|
|
}
|
|
}
|
|
private void OnSelectorActive(ISelectable obj)
|
|
{
|
|
if (obj is not MonoBehaviour monoBehaviour ||
|
|
monoBehaviour.TryGetComponent<IPlayerFixedPlace>(out var fixedPlace) is false) return;
|
|
if (_knockdown.IsKnockdown) return;
|
|
if (_fixedPlace?.Exit(self.Entity) is false)
|
|
{
|
|
return;
|
|
}
|
|
if (fixedPlace.Entry(self.Entity))
|
|
{
|
|
_fixedPlace = fixedPlace;
|
|
self.TransitionState<Fixed>();
|
|
return;
|
|
}
|
|
_fixedPlace = null;
|
|
}
|
|
|
|
private quaternion lastRotation;
|
|
public override void OnStateUpdate(float deltaTime)
|
|
{
|
|
base.OnStateUpdate(deltaTime);
|
|
var rotation = Quaternion.Inverse(_fixedPlace.FixedRotation) * lastRotation;
|
|
var euler =MathV.TransientRotationAxis(rotation.eulerAngles);
|
|
var add = new float2(euler.x, -euler.y);
|
|
self.AddViewEuler(add);
|
|
lastRotation = _fixedPlace.FixedRotation;
|
|
}
|
|
protected override void Exit()
|
|
{
|
|
base.Exit();
|
|
if (_fixedPlace is not null)
|
|
{
|
|
actor.Position = _fixedPlace.ExitPosition;
|
|
}
|
|
_fixedPlace = null;
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public sealed class ClimbBar
|
|
{
|
|
|
|
}
|
|
}
|
|
|