386 lines
15 KiB
C#
386 lines
15 KiB
C#
using System;
|
|
using Godot;
|
|
using RustyOptions;
|
|
|
|
namespace Movementtests.systems;
|
|
|
|
[GlobalClass, Icon("res://assets/ui/IconGodotNode/node_3D/icon_face.png")]
|
|
public partial class HeadSystem : Node3D
|
|
{
|
|
[Signal]
|
|
public delegate void HitboxActivatedEventHandler();
|
|
[Signal]
|
|
public delegate void HitboxDeactivatedEventHandler();
|
|
|
|
[Signal]
|
|
public delegate void ParryboxActivatedEventHandler();
|
|
[Signal]
|
|
public delegate void ParryboxDeactivatedEventHandler();
|
|
|
|
[Signal]
|
|
public delegate void HitTargetEventHandler();
|
|
[Signal]
|
|
public delegate void GotHitEventHandler();
|
|
[Signal]
|
|
public delegate void DeathAnimationFinishedEventHandler();
|
|
|
|
[Signal]
|
|
public delegate void StepFootEventHandler();
|
|
|
|
public record CameraParameters(
|
|
double Delta,
|
|
Vector2 LookDir,
|
|
Vector3 PlayerInput,
|
|
Vector3 PlayerVelocity,
|
|
Vector3 WallContactPoint,
|
|
float SensitivitMultiplier,
|
|
bool WithCameraJitter,
|
|
bool WithCameraBobbing,
|
|
float BobbingMultiplier,
|
|
float FovMultiplier);
|
|
|
|
internal Camera3D Camera = null!;
|
|
internal Node3D CameraAnchor = null!;
|
|
internal AnimationPlayer AnimationPlayer = null!;
|
|
internal AnimationTree AnimationTree = null!;
|
|
|
|
[Export(PropertyHint.Range, "0,1,0.01,or_greater")]
|
|
public float LookSensitivity { get; set; } = 1f;
|
|
|
|
[ExportGroup("Camera incline")]
|
|
[Export(PropertyHint.Range, "0.1,50,0.1,or_greater")]
|
|
public double CameraInclineAcceleration { get; set; } = 10f;
|
|
[Export(PropertyHint.Range, "0,10,0.1,or_greater")]
|
|
public float WallRunCameraIncline { get; set; } = 5f;
|
|
[Export(PropertyHint.Range, "0,10,0.1,or_greater")]
|
|
public float GroundedCameraIncline { get; set; } = 5f;
|
|
|
|
[ExportGroup("Sliding")]
|
|
[Export(PropertyHint.Range, "0,2,0.1,or_greater")]
|
|
public float SlidingCameraHeightOffset { get; set; } = 1.0f;
|
|
[Export(PropertyHint.Range, "0,1,0.01,or_greater")]
|
|
public float SlidingJitterFrequency { get; set; } = 0.01f;
|
|
[Export(PropertyHint.Range, "0,1,0.01,or_greater")]
|
|
public float SlidingJitterAmplitude { get; set; } = 0.1f;
|
|
|
|
internal FastNoiseLite _slidingNoise = new FastNoiseLite();
|
|
|
|
[ExportGroup("Bobbing")]
|
|
|
|
internal float _bobbingAccumulator; // Constantly increases when player moves in X or/and Z axis
|
|
[Export(PropertyHint.Range, "0,10,0.01,or_greater")]
|
|
public float BobbingFrequency { set; get; } = 2.4f;
|
|
[Export(PropertyHint.Range, "0,0.4,0.01,or_greater")]
|
|
public float BobbingAmplitude { set; get; } = 0.08f;
|
|
|
|
[ExportGroup("FOV")]
|
|
[Export(PropertyHint.Range, "0,180,0.1,degrees")]
|
|
public float BaseFov { get; set; } = 75.0f;
|
|
[Export(PropertyHint.Range, "0,10,0.01,or_greater")]
|
|
public float FovChangeFactor { get; set; } = 1.2f;
|
|
[Export(PropertyHint.Range, "0,10,0.01,or_greater")]
|
|
public float FovChangeSpeed { get; set; } = 6.25f;
|
|
[Export(PropertyHint.Range, "0,100,1,or_greater")]
|
|
public float FovMaxedOutSpeed { get; set; } = 20f;
|
|
|
|
[ExportGroup("First Person rig")]
|
|
internal Node3D FpRig = null!;
|
|
internal Node3D RightHandedWeapon = null!;
|
|
internal Vector3 RightHandedWeaponInitialRotation = Vector3.Zero;
|
|
internal Node3D LeftHandedWeapon = null!;
|
|
internal Vector3 LeftHandedWeaponInitialRotation = Vector3.Zero;
|
|
[Export(PropertyHint.Range, "0,20,1,or_greater")]
|
|
public float WeaponSway { get; set; } = 15f;
|
|
[Export(PropertyHint.Range, "0,200,1,or_greater")]
|
|
public float WeaponMoveRotation { get; set; } = 80f;
|
|
[Export(PropertyHint.Range, "0,20,1,or_greater")]
|
|
public float WeaponAdjustmentSpeed { get; set; } = 1f;
|
|
[Export(PropertyHint.Range, "0,2,0.01,or_greater")]
|
|
public float DisplacedWeaponSway { get; set; } = 0.8f;
|
|
[Export(PropertyHint.Range, "0,0.5,0.01,or_greater")]
|
|
public float DisplacedWeaponMoveRotation { get; set; } = 0.1f;
|
|
[Export(PropertyHint.Range, "0,20,1,or_greater")]
|
|
public float DisplacedWeaponAdjustmentSpeed { get; set; } = 12f;
|
|
|
|
public void Init()
|
|
{
|
|
IsPlayingForcingAnim = false;
|
|
|
|
Input.SetMouseMode(Input.MouseModeEnum.Captured);
|
|
Camera = GetNode<Camera3D>("CameraSmooth/Camera3D");
|
|
CameraAnchor = GetNode<Node3D>("CameraSmooth/CameraAnchor");
|
|
//_cameraAnchor = GetNode<Camera3D>("CameraSmooth/Camera3D");
|
|
AnimationPlayer = GetNode<AnimationPlayer>("AnimationPlayer");
|
|
AnimationTree = GetNode<AnimationTree>("AnimationTree");
|
|
|
|
FpRig = GetNode<Node3D>("FPRig");
|
|
RightHandedWeapon = GetNode<Node3D>("FPRig/Sword/SwordMesh");
|
|
RightHandedWeaponInitialRotation = RightHandedWeapon.Rotation;
|
|
LeftHandedWeapon = GetNode<Node3D>("FPRig/Parry/ParryMesh");
|
|
LeftHandedWeaponInitialRotation = LeftHandedWeapon.Rotation;
|
|
|
|
_slidingNoise.NoiseType = FastNoiseLite.NoiseTypeEnum.Perlin;
|
|
_slidingNoise.SetFrequency(SlidingJitterFrequency);
|
|
}
|
|
|
|
public void SetWeaponsVisible(bool swordVisible, bool parryVisible)
|
|
{
|
|
RightHandedWeapon.Visible = swordVisible;
|
|
LeftHandedWeapon.Visible = parryVisible;
|
|
}
|
|
|
|
public void OnMantle()
|
|
{
|
|
AnimationTree.Set("parameters/OnMantle/request", (int) AnimationNodeOneShot.OneShotRequest.Fire);
|
|
}
|
|
public void OnJumpStarted()
|
|
{
|
|
AnimationTree.Set("parameters/OnJumpStart/request", (int) AnimationNodeOneShot.OneShotRequest.Fire);
|
|
}
|
|
public void OnJumpEnded()
|
|
{
|
|
AnimationTree.Set("parameters/OnJumpEnd/request", (int) AnimationNodeOneShot.OneShotRequest.Fire);
|
|
}
|
|
public void OnHit()
|
|
{
|
|
AnimationTree.Set("parameters/OnHit/request", (int) AnimationNodeOneShot.OneShotRequest.Fire);
|
|
}
|
|
public void OnParry()
|
|
{
|
|
AnimationTree.Set("parameters/OnParry/request", (int) AnimationNodeOneShot.OneShotRequest.Fire);
|
|
}
|
|
public void OnStartDeathAnimation()
|
|
{
|
|
IsPlayingForcingAnim = true;
|
|
AnimationTree.Set("parameters/OnDie/request", (int) AnimationNodeOneShot.OneShotRequest.Fire);
|
|
}
|
|
|
|
public void OnDeathAnimationFinished()
|
|
{
|
|
EmitSignalDeathAnimationFinished();
|
|
}
|
|
|
|
public void OnHitTarget()
|
|
{
|
|
EmitSignalHitTarget();
|
|
}
|
|
public void OnGetHit()
|
|
{
|
|
EmitSignalGotHit();
|
|
}
|
|
|
|
public void OnHitboxActivated()
|
|
{
|
|
EmitSignalHitboxActivated();
|
|
}
|
|
public void OnHitboxDeactivated()
|
|
{
|
|
EmitSignalHitboxDeactivated();
|
|
}
|
|
|
|
public void OnParryboxActivated()
|
|
{
|
|
EmitSignalHitboxActivated();
|
|
}
|
|
public void OnParryboxDeactivated()
|
|
{
|
|
EmitSignalHitboxDeactivated();
|
|
}
|
|
|
|
internal bool FootstepEmitted;
|
|
internal bool IsPlayingForcingAnim;
|
|
|
|
public void ResetHeadBobbing()
|
|
{
|
|
_bobbingAccumulator = 0;
|
|
}
|
|
|
|
public void LookAround(CameraParameters inputs)
|
|
{
|
|
if (IsPlayingForcingAnim)
|
|
{
|
|
Camera.Position = Vector3.Zero;
|
|
Camera.Rotation = Vector3.Zero;
|
|
return;
|
|
}
|
|
|
|
var (delta,
|
|
lookDir,
|
|
playerInput,
|
|
playerVelocity,
|
|
wallContactPoint,
|
|
sensitivitMultiplier,
|
|
withCameraJitter,
|
|
withCameraBobbing,
|
|
bobbingMultiplier,
|
|
fovMultiplier) = inputs;
|
|
|
|
// Horizontal movement of head
|
|
float angleForHorizontalRotation = lookDir.X * LookSensitivity * sensitivitMultiplier;
|
|
RotateY(angleForHorizontalRotation);
|
|
|
|
// Vertical movement of head
|
|
Vector3 currentCameraRotation = CameraAnchor.Rotation;
|
|
currentCameraRotation.X += Convert.ToSingle(lookDir.Y * LookSensitivity * sensitivitMultiplier);
|
|
currentCameraRotation.X = Mathf.Clamp(currentCameraRotation.X, Mathf.DegToRad(-90f), Mathf.DegToRad(90f));
|
|
|
|
// Camera incline on Wall and more
|
|
var isWallRunning = wallContactPoint.Length() > Mathf.Epsilon;
|
|
float cameraIncline;
|
|
if (isWallRunning)
|
|
{
|
|
var directionToWall = (wallContactPoint - GlobalPosition).Normalized();
|
|
var cameraInclineFactor = ComputeCameraInclineFactor(directionToWall);
|
|
cameraIncline = Mathf.DegToRad(WallRunCameraIncline * cameraInclineFactor);
|
|
}
|
|
else
|
|
{
|
|
var cameraInclineFactor = ComputeCameraInclineFactor(playerInput);
|
|
cameraIncline = Mathf.DegToRad(GroundedCameraIncline * cameraInclineFactor * -1.0f);
|
|
}
|
|
currentCameraRotation.Z = (float) Mathf.Lerp(currentCameraRotation.Z, cameraIncline, delta * CameraInclineAcceleration);
|
|
CameraAnchor.Rotation = currentCameraRotation;
|
|
|
|
if (withCameraJitter)
|
|
{
|
|
CameraAnchor.Position = Vector3.Down*SlidingCameraHeightOffset;
|
|
float noise1D = _slidingNoise.GetNoise1D(Time.GetTicksMsec());
|
|
float noiseAmplitude = SlidingJitterAmplitude*Mathf.Clamp(playerVelocity.Length(), 0f, 1f);
|
|
CameraAnchor.Position += Vector3.Up*noise1D*noiseAmplitude;
|
|
}
|
|
else
|
|
{
|
|
CameraAnchor.Position = Vector3.Zero;
|
|
}
|
|
|
|
Vector3 newPositionForCamera = Vector3.Zero;
|
|
Vector3 newPositionForRig = Vector3.Zero;
|
|
if (withCameraBobbing)
|
|
{
|
|
_bobbingAccumulator += (float) delta * playerVelocity.Length();
|
|
|
|
// As the _bobbingAccumulator increases we're changing values for sin and cos functions.
|
|
// Because both of them are just waves, we will be slide up with y and then slide down with y
|
|
// creating bobbing effect. The same works for cos. As the _bobbingAccumulator increases the cos decreases and then increases
|
|
newPositionForCamera.Y = Mathf.Sin(_bobbingAccumulator * BobbingFrequency) * BobbingAmplitude * bobbingMultiplier;
|
|
newPositionForCamera.X = Mathf.Cos(_bobbingAccumulator * BobbingFrequency / 2.0f) * BobbingAmplitude * bobbingMultiplier;
|
|
|
|
if (newPositionForCamera.Y < -0.07 * bobbingMultiplier && !FootstepEmitted) Footstep();
|
|
if (newPositionForCamera.Y > 0) FootstepEmitted = false;
|
|
|
|
// Offset bobbing for weapon rig
|
|
newPositionForRig.Y = Mathf.Cos(_bobbingAccumulator * BobbingFrequency) * BobbingAmplitude * bobbingMultiplier * 0.2f;
|
|
newPositionForRig.X = Mathf.Sin(_bobbingAccumulator * BobbingFrequency / 2.0f) * BobbingAmplitude * bobbingMultiplier * 0.2f;
|
|
}
|
|
CameraAnchor.Position += newPositionForCamera;
|
|
Camera.GlobalTransform = CameraAnchor.GetGlobalTransformInterpolated();
|
|
|
|
// First person rig adjustments
|
|
FpRig.GlobalTransform = Camera.GlobalTransform;
|
|
// Apply bobbing
|
|
FpRig.Position += newPositionForRig;
|
|
|
|
// Rotate the whole rig based on movement input
|
|
var newRigRotation = FpRig.Rotation;
|
|
var camTilt = Mathf.Lerp(FpRig.Rotation.Z, CameraAnchor.Rotation.Z*WeaponMoveRotation, delta * WeaponAdjustmentSpeed);
|
|
newRigRotation.Z = (float) camTilt;
|
|
|
|
// Rotate the whole rig based on camera rotation input
|
|
newRigRotation.X = Mathf.Lerp(newRigRotation.X, -lookDir.Y*WeaponSway, (float) delta * WeaponAdjustmentSpeed);
|
|
newRigRotation.Y = Mathf.Lerp(newRigRotation.Y, -lookDir.X*WeaponSway, (float) delta * WeaponAdjustmentSpeed);
|
|
|
|
// Apply
|
|
FpRig.Rotation = newRigRotation;
|
|
|
|
// Compute sword meshes procedural adjustments
|
|
RightHandedWeapon.Rotation = ComputeRotationForFpMesh(RightHandedWeapon, RightHandedWeaponInitialRotation, playerInput, lookDir, (float) delta);
|
|
LeftHandedWeapon.Rotation = ComputeRotationForFpMesh(LeftHandedWeapon, LeftHandedWeaponInitialRotation, playerInput, lookDir, (float) delta);
|
|
|
|
// Camera adjustments
|
|
float velocityClamped = Mathf.Clamp(playerVelocity.Length(), 0.5f, FovMaxedOutSpeed);
|
|
float targetFov = BaseFov + FovChangeFactor * velocityClamped * fovMultiplier;
|
|
Camera.Fov = Mathf.Lerp(Camera.Fov, targetFov, (float) delta * FovChangeSpeed);
|
|
}
|
|
|
|
public Vector3 ComputeRotationForFpMesh(Node3D mesh, Vector3 initialRotation, Vector3 playerInput, Vector2 lookDir, float delta)
|
|
{
|
|
var newMeshRotation = mesh.Rotation;
|
|
var howMuchForward = ComputeHowMuchInputForward(playerInput);
|
|
var howMuchSideways = ComputeHowMuchInputSideways(playerInput);
|
|
var displacedCamTiltForward = Mathf.Lerp(newMeshRotation.Z,
|
|
initialRotation.Z + howMuchForward*DisplacedWeaponMoveRotation,
|
|
delta * DisplacedWeaponAdjustmentSpeed);
|
|
var displacedCamTiltSide = Mathf.Lerp(newMeshRotation.X,
|
|
initialRotation.X - howMuchSideways*DisplacedWeaponMoveRotation,
|
|
delta * DisplacedWeaponAdjustmentSpeed);
|
|
|
|
newMeshRotation.X = displacedCamTiltSide;
|
|
newMeshRotation.Z = displacedCamTiltForward;
|
|
|
|
var displacedSwayY = Mathf.Lerp(newMeshRotation.Y,
|
|
initialRotation.Y - lookDir.X*DisplacedWeaponSway,
|
|
delta * DisplacedWeaponAdjustmentSpeed);
|
|
newMeshRotation.Y = displacedSwayY;
|
|
|
|
return newMeshRotation;
|
|
}
|
|
|
|
public void Footstep()
|
|
{
|
|
FootstepEmitted = true;
|
|
EmitSignalStepFoot();
|
|
}
|
|
|
|
public void HideWeapon()
|
|
{
|
|
RightHandedWeapon.Visible = false;
|
|
}
|
|
public void ShowWeapon()
|
|
{
|
|
RightHandedWeapon.Visible = true;
|
|
}
|
|
|
|
public float ComputeCameraInclineFactor(Vector3 direction)
|
|
{
|
|
var forward = GetForwardHorizontalVector().Normalized();
|
|
var crossProduct = forward.Cross(direction);
|
|
return crossProduct.Length()*Mathf.Sign(crossProduct.Y);
|
|
}
|
|
|
|
public float ComputeHowMuchInputForward(Vector3 playerInput)
|
|
{
|
|
var forwardAngle = GetForwardHorizontalVector().AngleTo(playerInput);
|
|
var forwardRemapped = Mathf.Remap(forwardAngle, 0, Mathf.Pi, -1, 1);
|
|
return playerInput.Length() > 0 ? forwardRemapped : 0;
|
|
}
|
|
|
|
public float ComputeHowMuchInputSideways(Vector3 playerInput)
|
|
{
|
|
var rightAngle = GetForwardHorizontalVector().Cross(Vector3.Up).Normalized().AngleTo(playerInput);
|
|
var forwardRemapped = Mathf.Remap(rightAngle, 0, Mathf.Pi, -1, 1);
|
|
return playerInput.Length() > 0 ? forwardRemapped : 0;
|
|
}
|
|
|
|
public Vector3 GetForwardHorizontalVector()
|
|
{
|
|
return GetGlobalTransform().Basis.Z;
|
|
}
|
|
|
|
public Vector3 GetGlobalForwardVector()
|
|
{
|
|
return Camera.GlobalBasis.Z;
|
|
}
|
|
|
|
public Vector3 GetGlobalLookRotation()
|
|
{
|
|
return new Vector3(
|
|
Camera.Rotation.X,
|
|
Rotation.Y,
|
|
Camera.Rotation.Z);
|
|
}
|
|
|
|
public void SetHeight(float height)
|
|
{
|
|
Position = new Vector3(Position.X, height, Position.Z);
|
|
}
|
|
} |