759 lines
20 KiB
C#
759 lines
20 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 : PlayerCharacterState, IPlayerVaultState
|
|
{
|
|
public float NormalizedTime
|
|
{
|
|
get => _normalizedTime;
|
|
set
|
|
{
|
|
_normalizedTime = value;
|
|
_manualUpdate=true;
|
|
}
|
|
}
|
|
public int Phase { get; set; }
|
|
|
|
[SerializeField] private AnimationCurve entryCurve;
|
|
|
|
private float _elapsedTime;
|
|
private float _normalizedTime;
|
|
private bool _manualUpdate;
|
|
private Vector3 _entryPosition;
|
|
|
|
private Vector3 entryVelocity;
|
|
public override void OnStateEntry(IState old)
|
|
{
|
|
base.OnStateEntry(old);
|
|
|
|
Phase = 0;
|
|
_elapsedTime = 0;
|
|
|
|
actor.alwaysNotGrounded = true;
|
|
//actor.ColliderComponent.enabled = false;
|
|
actor.IsKinematic = true;
|
|
actor.UseRootMotion = true;
|
|
|
|
_normalizedTime = 0;
|
|
_manualUpdate = false;
|
|
|
|
self.LimitViewAngle = 45;
|
|
|
|
actor.ForceNotGrounded();
|
|
|
|
_entryPosition = actor.Position;
|
|
|
|
entryVelocity = actor.Velocity;
|
|
}
|
|
|
|
public override void OnStateExit(IState old, IState newState)
|
|
{
|
|
base.OnStateExit(old, newState);
|
|
|
|
actor.alwaysNotGrounded = false;
|
|
//actor.ColliderComponent.enabled = true;
|
|
actor.IsKinematic = false;
|
|
actor.UseRootMotion = false;
|
|
|
|
if (self.vaultPoint is GetVaultPointFromCollider vaultPoint)
|
|
{
|
|
actor.Position = vaultPoint.EndPosition-Vector3.up*0.64f;
|
|
}
|
|
|
|
self.LimitViewAngle = 0;
|
|
//actor.Velocity = lastVelocity;
|
|
|
|
//actor.ForceGrounded();
|
|
|
|
self.ExpectJump.Reset();
|
|
self.RequestClimb = false;
|
|
|
|
_normalizedTime = 0;
|
|
_manualUpdate = false;
|
|
Phase = 0;
|
|
|
|
actor.ForceNotGrounded();
|
|
actor.Velocity = actor.Forward * 3 + actor.Up*-2;
|
|
}
|
|
|
|
public override void OnStateUpdate(float deltaTime)
|
|
{
|
|
_elapsedTime += deltaTime;
|
|
base.OnStateUpdate(deltaTime);
|
|
switch (Phase)
|
|
{
|
|
case 0 when _elapsedTime>0.16f:
|
|
// if(Vector3.Distance(
|
|
// characterController.ExpectClimb.shouldBe-Vector3.up*0.64f,
|
|
// actor.Position)
|
|
// <=0.16f)
|
|
// Phase = 1;
|
|
Phase = 1;
|
|
break;
|
|
case 1:
|
|
if(NormalizedTime>=1)
|
|
Exit();
|
|
if (_manualUpdate is false)
|
|
{
|
|
NormalizedTime+=deltaTime;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
public override void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
|
|
{
|
|
deltaTime =deltaTime<0.001f?0.001f:deltaTime;
|
|
base.UpdateVelocity(ref currentVelocity, deltaTime);
|
|
switch (Phase)
|
|
{
|
|
case 0:
|
|
// actor.Position =
|
|
// Vector3.MoveTowards(
|
|
// actor.Position,
|
|
// characterController.ExpectClimb.shouldBe - Vector3.up * 0.64f,
|
|
// 4f
|
|
// );
|
|
var endPos = self.ExpectClimb.shouldBe - Vector3.up * 0.64f;
|
|
var t = entryCurve.Evaluate(_elapsedTime);
|
|
actor.Position = Vector3.Lerp(_entryPosition, endPos, t);
|
|
break;
|
|
case 1 when self.vaultPoint is GetVaultPointFromCollider vaultPoint:
|
|
var newPos =
|
|
Vector3.Lerp(
|
|
vaultPoint.StartPosition,
|
|
vaultPoint.EndPosition,
|
|
NormalizedTime);
|
|
newPos.y = actor.Position.y;
|
|
|
|
actor.Position = newPos;
|
|
|
|
_entryPosition = (newPos - actor.Position)/ deltaTime;;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
public bool ManualCancel()
|
|
{
|
|
if (Enabled is false) return false;
|
|
Exit();
|
|
return true;
|
|
}
|
|
}
|
|
[Serializable]
|
|
public class EdgeClimb : PlayerCharacterState, IPlayerEdgeClimbState
|
|
{
|
|
public int Phase { get; set; }
|
|
|
|
[Inject] private IEquipService _equipService;
|
|
private Collider _collider;
|
|
private Quaternion rotation;
|
|
private Transform _chest;
|
|
public bool ManualCancel()
|
|
{
|
|
if (Enabled is false) return false;
|
|
Exit();
|
|
return true;
|
|
}
|
|
|
|
public override void OnStateEntry(IState old)
|
|
{
|
|
base.OnStateEntry(old);
|
|
|
|
_collider = self.edgeClimbPoint.Collider;
|
|
//Debug.DrawRay(actor.Position+Vector3.up,_collider.ClosestPoint(actor.Position)-(actor.Position+Vector3.up),Color.green,8f);
|
|
if(_collider.Raycast(new Ray(actor.Position, _collider.ClosestPoint(actor.Position)-actor.Position), out var hit, 8))
|
|
{
|
|
rotation =Quaternion.LookRotation(hit.normal) * Quaternion.Euler(0,180,0);
|
|
}
|
|
else
|
|
{
|
|
rotation = actor.Rotation;
|
|
}
|
|
_chest = self.GetComponent<Animator>().GetBoneTransform(HumanBodyBones.UpperChest);
|
|
|
|
|
|
actor.alwaysNotGrounded = true;
|
|
actor.ColliderComponent.enabled = false;
|
|
actor.UseRootMotion = true;
|
|
|
|
self.LimitViewAngle = 45;
|
|
|
|
Phase = 0;
|
|
|
|
_equipService.AllowEquip.AddDisableElements(this);
|
|
|
|
self.inputActionGroup.RegisterCallback(self.JumpAction, OnJump);
|
|
}
|
|
private void OnJump(InputAction.CallbackContext obj)
|
|
{
|
|
switch (obj)
|
|
{
|
|
case {interaction:PressInteraction,performed:true}:
|
|
Exit();
|
|
actor.Velocity += actor.Up * 8 + -actor.Forward*3;
|
|
self.RequestClimb = false;
|
|
return;
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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.35f;
|
|
if (actor.Position.y >= targetPos.y)
|
|
Phase = 5;
|
|
if (Phase is 5)
|
|
actor.Position = targetPos;
|
|
return;
|
|
case 5:
|
|
if (_collider.Raycast(new Ray(_chest.position, actor.Forward), out var _, 1))
|
|
{
|
|
if (self.InputVector.y > 0)
|
|
{
|
|
Phase = 8;
|
|
return;
|
|
}
|
|
if(self.InputVector.y<0)
|
|
{
|
|
Exit();
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Exit();
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
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,3.2f*deltaTime);
|
|
currentPosition.y = actor.Position.y;
|
|
currentPosition.y+=(upVelocity+=deltaTime)*deltaTime;
|
|
actor.Position = currentPosition;
|
|
break;
|
|
}
|
|
}
|
|
public override void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
|
|
{
|
|
if (Phase is 0)
|
|
{
|
|
currentRotation = rotation;
|
|
}
|
|
}
|
|
public override void AfterUpdateMovement(float deltaTime)
|
|
{
|
|
self.CurrentCameraPosition.shouldBe = self.FpvLocalPosition;
|
|
}
|
|
|
|
|
|
}
|
|
[Serializable]
|
|
public class Climb : PlayerCharacterState,IPlayerClimbState
|
|
{
|
|
[SerializeField] protected float lerpDelta = 5;
|
|
private IntervalUpdate cancelInterval = new(0.16f);
|
|
private Transform ignore;
|
|
private bool needInit;
|
|
|
|
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;
|
|
}
|
|
public override void OnStateUpdate(float deltaTime)
|
|
{
|
|
var distance = Vector3.Distance(self.ExpectClimb.shouldBe,
|
|
self.transform.position);
|
|
if (
|
|
distance<=0.1f
|
|
|| cancelInterval.AllowUpdate && actor.Velocity.sqrMagnitude<=0.16f
|
|
)
|
|
{
|
|
Exit();
|
|
}
|
|
|
|
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 - self.transform.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;
|
|
}
|
|
}
|
|
[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;
|
|
|
|
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;
|
|
|
|
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 * (self.MovementInput.z * 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)
|
|
{
|
|
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
|
|
{
|
|
|
|
}
|
|
}
|
|
|