thunderstargames/project-reset
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

change: fixing of many issues in handler, deprecation/deletion of variables, cleanup of UnitMovementHandler, cleaning up of inspector

Browse Source
This commit is contained in:
Chris
2025-09-23 14:14:47 -04:00
parent b21adf93e2
commit bd2903a0b2
10 changed files with 445 additions and 838 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Assets/Scripts/Core/Graph Tasks/Movement Settings Changes/ChangeGravitySettings.cs
View File

@@ -33,7 +33,7 @@ namespace Reset.Units {
// ValueGroup.ChangeSmoothingEasing(jumpPower, ref agent.data.jumpPower.currentSmoothing,
// ref agent.data.jumpPower.easing, ref agent.defaultData.jumpPower.smoothing, ref agent.defaultData.jumpPower.easing);
FloatValueGroup.UpdateValue(jumpPowerDecay, agent.data.jumpPowerDecay);
// FloatValueGroup.UpdateValue(jumpPowerDecay, agent.data.jumpPowerDecay);
// Deprecated by SetNewGravity
// FloatValueGroup.UpdateValue(gravityPower, ref agent.data.gravityPower.value, ref agent.defaultData.gravityPower.value);

35
Assets/Scripts/Core/MathExtensions.cs
View File

@@ -13,10 +13,45 @@ public static class MathExtensions{
return (to - origin).normalized;
}
public static Vector3 ToVector3(this Vector2 vector2){
return new Vector3(vector2.x, 0f, vector2.y);
}
public static Vector2 ToVector2(this Vector3 vector3){
return new Vector2(vector3.x, vector3.z);
}
public static Color Alpha(this Color input, float newAlpha){
return new Color(input.r, input.g, input.b, newAlpha);
}
public static Quaternion SmoothDamp(Quaternion rot, Quaternion target, ref Quaternion deriv, float time) {
if (Time.deltaTime < Mathf.Epsilon) return rot;
// account for double-cover
var Dot = Quaternion.Dot(rot, target);
var Multi = Dot > 0f ? 1f : -1f;
target.x *= Multi;
target.y *= Multi;
target.z *= Multi;
target.w *= Multi;
// smooth damp (nlerp approx)
var Result = new Vector4(
Mathf.SmoothDamp(rot.x, target.x, ref deriv.x, time),
Mathf.SmoothDamp(rot.y, target.y, ref deriv.y, time),
Mathf.SmoothDamp(rot.z, target.z, ref deriv.z, time),
Mathf.SmoothDamp(rot.w, target.w, ref deriv.w, time)
).normalized;
// ensure deriv is tangent
var derivError = Vector4.Project(new Vector4(deriv.x, deriv.y, deriv.z, deriv.w), Result);
deriv.x -= derivError.x;
deriv.y -= derivError.y;
deriv.z -= derivError.z;
deriv.w -= derivError.w;
return new Quaternion(Result.x, Result.y, Result.z, Result.w);
}
public static Vector2 Rotate(this Vector2 v, float delta) {
return new Vector2(
v.x * Mathf.Cos(delta) - v.y * Mathf.Sin(delta),

57
Assets/Scripts/Player/CameraSettingData.cs Normal file
View File

@@ -0,0 +1,57 @@
using System;
using System.Collections.Generic;
using UnityEngine;
public struct CameraSettingData : ICloneable{
public SettingValue<float> mainFieldOfView;
public SettingValue<Vector3> orbitPositionDamping;
public SettingValue<Vector3> orbitTargetOffset;
public SettingValue<bool> axisLookEnabledX;
public SettingValue<bool> axisLookEnabledY;
public SettingValue<float> axisLookGainX;
public SettingValue<float> axisLookGainY;
public SettingValue<float> orbitFollowTopHeight;
public SettingValue<float> orbitFollowTopRadius;
public SettingValue<float> orbitFollowCenterHeight;
public SettingValue<float> orbitFollowCenterRadius;
public SettingValue<float> orbitFollowBottomHeight;
public SettingValue<float> orbitFollowBottomRadius;
public SettingValue<Vector2> rotationComposerScreenPos;
public SettingValue<Vector3> cameraOffsetOffset;
public object Clone(){
return MemberwiseClone();
}
public List<IResettableSettingValue> GetAllSettings(){
var outputList = new List<IResettableSettingValue>();
IResettableSettingValue[] settings = new[]{
mainFieldOfView as IResettableSettingValue,
orbitPositionDamping,
orbitTargetOffset,
axisLookEnabledX,
axisLookEnabledY,
axisLookGainX,
axisLookGainY,
orbitFollowTopHeight,
orbitFollowTopRadius,
orbitFollowCenterHeight,
orbitFollowCenterRadius,
orbitFollowBottomHeight,
orbitFollowBottomRadius,
rotationComposerScreenPos,
cameraOffsetOffset,
};
outputList.AddRange(settings);
return outputList;
}
}

3
Assets/Scripts/Player/CameraSettingData.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 14393bffe6324344b5f972412e37a339
timeCreated: 1758568723

40
Assets/Scripts/Player/CameraSettingsProcessor.cs
View File

@@ -1,37 +1,8 @@
using System;
using Reset.Core;
using Sirenix.OdinInspector;
using Unity.Cinemachine;
using UnityEngine;
public struct CameraSettingData : ICloneable{
public SettingValue<float> mainFieldOfView;
public SettingValue<Vector3> orbitPositionDamping;
public SettingValue<Vector3> orbitTargetOffset;
public SettingValue<bool> axisLookEnabledX;
public SettingValue<bool> axisLookEnabledY;
public SettingValue<float> axisLookGainX;
public SettingValue<float> axisLookGainY;
public SettingValue<float> orbitFollowTopHeight;
public SettingValue<float> orbitFollowTopRadius;
public SettingValue<float> orbitFollowCenterHeight;
public SettingValue<float> orbitFollowCenterRadius;
public SettingValue<float> orbitFollowBottomHeight;
public SettingValue<float> orbitFollowBottomRadius;
public SettingValue<Vector2> rotationComposerScreenPos;
public SettingValue<Vector3> cameraOffsetOffset;
public object Clone(){
return MemberwiseClone();
}
}
public class CameraSettingsProcessor : MonoBehaviour{
public static CameraSettingsProcessor Instance{ get; private set; }
@@ -89,7 +60,7 @@ public class CameraSettingsProcessor : MonoBehaviour{
data.rotationComposerScreenPos.targetValue = rotComp.Composition.ScreenPosition;
data.cameraOffsetOffset.targetValue = offset.Offset;
// And copy to the original
original = (CameraSettingData)data.Clone();
}
@@ -142,4 +113,13 @@ public class CameraSettingsProcessor : MonoBehaviour{
offset.Offset = data.cameraOffsetOffset.Value;
}
[Button]
void InitializeAllSettings(){
var allSettings = data.GetAllSettings();
for (int i = 0; i < allSettings.Count; i++) {
allSettings[i].Initialize();
allSettings[i].Verify();
}
}
}

44
Assets/Scripts/Player/ResolvedMovement.cs
View File

@@ -1,4 +1,5 @@
using Sirenix.OdinInspector;
using Reset.Core.Tools;
using Sirenix.OdinInspector;
using UnityEngine;
namespace Reset.Units{
@@ -6,25 +7,50 @@ namespace Reset.Units{
public struct MoveDirection{
private Transform owner;
private Vector2 _moveDir; // Always local
private Vector2 _moveRaw;
private Vector2 _moveDir; // Always world??
[ShowInInspector]
public Vector2 World{
get => owner.TransformDirection(_moveDir);
set{
_moveDir = owner.InverseTransformDirection(value);
get{
DebugOverlayDrawer.ChangeValue("Movement", "_moveDir", _moveDir);
// return owner.TransformDirection(_moveDir.ToVector3()).ToVector2();
return _moveDir;
}
set{
_moveDir = value;
}
}
[ShowInInspector]
public Vector2 Local{
get => _moveDir;
set {
_moveDir = value;
get => owner.InverseTransformDirection(_moveDir.ToVector3()).ToVector2();
private set {
// _moveDir = value;
}
}
public Vector2 RawWorld{
get{
DebugOverlayDrawer.ChangeValue("Movement", "_moveRaw", _moveRaw);
// return owner.TransformDirection(_moveDir.ToVector3()).ToVector2();
return _moveRaw;
}
set{
_moveRaw = value;
}
}
public Vector2 RawLocal{
get => owner.InverseTransformDirection(_moveRaw.ToVector3()).ToVector2();
}
public MoveDirection(Transform ownerTransform){
owner = ownerTransform;
_moveDir = Vector2.zero;
_moveRaw = Vector2.zero;
}
}

61
Assets/Scripts/Player/SettingValue.cs
View File

@@ -1,39 +1,53 @@
using System;
using Sirenix.OdinInspector;
using UnityEngine;
using UnityEngine.Serialization;
public interface IResettableSettingValue{
public abstract void SmoothAndEase();
public void Verify();
public void SmoothAndEase();
public void Initialize();
}
[Serializable]
public struct SettingValue<T> : IResettableSettingValue{
public T targetValue;
public T currentValue;
public T refVel;
public float targetSmoothing; // Smoothing changes how fast the value is changed.
public float targetEasing; // Easing changes how fast smoothing is changed, when given a new value.
public class SettingValue<T> : IResettableSettingValue{
[HorizontalGroup("Settings", width: .3f), VerticalGroup("Settings/Value"), BoxGroup("Settings/Value/Value"), LabelText("Target")]
public T targetValue;
[HorizontalGroup("Settings"), VerticalGroup("Settings/Value"), BoxGroup("Settings/Value/Value"), LabelText("Current")]
public T currentValue;
[HorizontalGroup("Settings"), VerticalGroup("Settings/Smoothing"), BoxGroup("Settings/Smoothing/Smoothing"), LabelText("Target"), ShowIf("@IsSmoothable()")]
public float targetSmoothing; // Smoothing changes how fast the value is changed.
[HorizontalGroup("Settings"), VerticalGroup("Settings/Easing"), BoxGroup("Settings/Easing/Easing"), LabelText("Target"), ShowIf("@IsSmoothable()")]
public float targetEasing; // Easing changes how fast smoothing is changed, when given a new value.
public T Value{
get => currentValue;
set => targetValue = value;
}
[HorizontalGroup("Settings"), VerticalGroup("Settings/Smoothing"), BoxGroup("Settings/Smoothing/Smoothing"), LabelText("Current"), ShowIf("@IsSmoothable()")]
private float currentSmoothing;
[HorizontalGroup("Settings"), VerticalGroup("Settings/Value"), BoxGroup("Settings/Value/Value"), LabelText("Default")]
public T defaultValue;
[HorizontalGroup("Settings"), VerticalGroup("Settings/Smoothing"), BoxGroup("Settings/Smoothing/Smoothing"), LabelText("Default"), ShowIf("@IsSmoothable()")]
public float defaultSmoothing;
[HorizontalGroup("Settings"), VerticalGroup("Settings/Easing"), BoxGroup("Settings/Easing/Easing"), LabelText("Default"), ShowIf("@IsSmoothable()")]
public float defaultEasing;
private float refVelFloat; // For use with SmoothDamp
private Vector3 refVelV3; // For use with SmoothDamp
private Vector2 refVelV2; // For use with SmoothDamp
private bool verified;
bool IsSmoothable(){
return (typeof(T) == typeof(float) || typeof(T) == typeof(Vector2) || typeof(T) == typeof(Vector3) || typeof(T) == typeof(Vector4) || typeof(T) == typeof(Quaternion) );
}
public SettingValue(T initValue, float defaultEasing = 2f, float defaultSmoothing = 1f){
targetValue = initValue;
defaultValue = initValue;
this.defaultSmoothing = defaultSmoothing;
this.defaultEasing = defaultEasing;
@@ -46,14 +60,20 @@ public struct SettingValue<T> : IResettableSettingValue{
refVelFloat = 0;
refVelV3 = default;
refVelV2 = default;
refVel = default;
defaultValue = initValue;
}
public void Verify(){
if (targetValue.Equals(currentValue) == false) {
Debug.LogWarning($"A SettingValue ({this}) doesn't have its current and target value matching. This should have been set!");
}
verified = true;
}
public void SmoothAndEase(){
Debug.Log("Worked!");
return;
if (!verified) {
Debug.LogWarning($"A SettingValue ({this}) wasn't verified before being smoothed and eased. What's up with that?");
}
currentSmoothing = Mathf.MoveTowards(currentSmoothing, targetSmoothing, targetEasing * 1f * Time.deltaTime);
@@ -77,4 +97,9 @@ public struct SettingValue<T> : IResettableSettingValue{
currentValue = (T)(object)new Vector4(v3value.x, v3value.y, v3value.z, v4value);
}
}
public void Initialize(){
currentValue = targetValue;
Debug.Log(Value);
}
}

50
Assets/Scripts/Player/UnitMovementData.cs
View File

@@ -8,31 +8,31 @@ namespace Reset.Units{
[Serializable]
public class UnitMovementData : ICloneable{
// Movement Direction
public SettingValue<Vector2> moveSmoothing = new SettingValue<Vector2>(new Vector2(.5f, .5f));
public SettingValue<float> acceleration = new SettingValue<float>(5f);
public SettingValue<float> deacceleration = new SettingValue<float>(5f);
[Title("Move Smoothing"), HideLabel, InlineProperty] public SettingValue<Vector2> moveSmoothing = new SettingValue<Vector2>(new Vector2(.5f, .5f));
[Title("Acceleration"), HideLabel, InlineProperty] public SettingValue<float> acceleration = new SettingValue<float>(5f);
[Title("Deacceleration"), HideLabel, InlineProperty] public SettingValue<float> deacceleration = new SettingValue<float>(5f);
[SliderField(0,1)]
public SettingValue<float> airDirectionDecay = new SettingValue<float>(1f); // TODO: Check default value
[Title("Air Direction Decay"), HideLabel, InlineProperty] public SettingValue<float> airDirectionDecay = new SettingValue<float>(1f); // TODO: Check default value
// Move Speed
public SettingValue<float> softening = new SettingValue<float>(1f, defaultSmoothing: 1f);
public SettingValue<float> moveSpeed = new SettingValue<float>(15f, defaultSmoothing: 10f);
[Title("Softening"), HideLabel, InlineProperty] public SettingValue<float> softening = new SettingValue<float>(1f, defaultSmoothing: 1f);
[Title("Move Speed"), HideLabel, InlineProperty] public SettingValue<float> moveSpeed = new SettingValue<float>(15f, defaultSmoothing: 10f);
// Jumping
[ShowInInspector] public SettingValue<float> jumpPower = new SettingValue<float>(0f);
public SettingValue<float> jumpPowerDecay = new SettingValue<float>(3f); // TODO: Check default value
// [Title("Jump Power"), HideLabel, InlineProperty] [ShowInInspector] public SettingValue<float> jumpPower = new SettingValue<float>(0f);
// [Title("Move Smoothing"), HideLabel, InlineProperty] public SettingValue<float> jumpPowerDecay = new SettingValue<float>(3f); // TODO: Check default value
// Gravity
[ShowInInspector] public SettingValue<float> gravityPower = new SettingValue<float>(1f);
public SettingValue<float> gravityMax = new SettingValue<float>(8f);
public SettingValue<float> gravityAcceleration = new SettingValue<float>(1f);
public SettingValue<float> gravityScale = new SettingValue<float>(1f);
[Title("Gravity Power"), HideLabel, InlineProperty] [ShowInInspector] public SettingValue<float> gravityPower = new SettingValue<float>(1f);
[Title("Gravity Max"), HideLabel, InlineProperty] public SettingValue<float> gravityMax = new SettingValue<float>(8f);
[Title("Gravity Acceleration"), HideLabel, InlineProperty] public SettingValue<float> gravityAcceleration = new SettingValue<float>(1f);
[Title("Gravity Scale"), HideLabel, InlineProperty] public SettingValue<float> gravityScale = new SettingValue<float>(1f);
// Rotation
[ShowInInspector, SerializeReference] public Enum rotateFacing;
public SettingValue<float> rotationSpeed = new SettingValue<float>(5f);
public SettingValue<float> rotationInputBlending = new SettingValue<float>(.3f);
[Title("Rotate Facing"), HideLabel, InlineProperty] public SettingValue<PlayerFacingDirection> rotateFacing = new SettingValue<PlayerFacingDirection>(initValue: PlayerFacingDirection.Momentum);
[Title("Rotation Speed"), HideLabel, InlineProperty] public SettingValue<float> rotationSpeed = new SettingValue<float>(5f);
[Title("Rotation Input Blending"), HideLabel, InlineProperty] public SettingValue<float> rotationInputBlending = new SettingValue<float>(.3f);
public object Clone(){
return MemberwiseClone();
@@ -41,13 +41,25 @@ namespace Reset.Units{
public List<IResettableSettingValue> GetAllSettings(){
var outputList = new List<IResettableSettingValue>();
IResettableSettingValue[] test = new[]{
IResettableSettingValue[] settings = new[]{
moveSmoothing as IResettableSettingValue,
acceleration,
deacceleration,
airDirectionDecay,
softening,
moveSpeed,
// jumpPower,
// jumpPowerDecay,
gravityPower,
gravityMax,
gravityAcceleration,
gravityScale,
rotateFacing,
rotationSpeed,
rotationInputBlending,
};
test[0].SmoothAndEase();
outputList.AddRange(test);
outputList.AddRange(settings);
return outputList;
}

303
Assets/Scripts/Player/UnitMovementHandler.cs
View File

@@ -1,19 +1,20 @@
using System.Collections.Generic;
using UnityEngine;
using Reset.Core.Tools;
using Sirenix.OdinInspector;
namespace Reset.Units{
public class UnitMovementHandler : MonoBehaviour{
[ShowInInspector]
[ShowInInspector, InlineProperty, HideLabel, FoldoutGroup("Resolved Movement", expanded: true)]
public ResolvedMovement resolvedMovement;
[FoldoutGroup("Final Values"), ShowInInspector, ReadOnly] private float outputSpeed;
[FoldoutGroup("Final Values"), ShowInInspector, ReadOnly] private float additionalSpeed;
[FoldoutGroup("Final Values"), ShowInInspector, ReadOnly] public Vector3 outputMoveDirection;
[FoldoutGroup("Final Values"), ShowInInspector, ReadOnly] public Vector3 additionalMoveDirection;
[FoldoutGroup("Final Values"), ShowInInspector, ReadOnly] private Quaternion outputRotation;
[FoldoutGroup("Final Values"), ShowInInspector, ReadOnly] private Quaternion specifiedRotation;
[FoldoutGroup("Final Values"), ShowInInspector, ReadOnly] private float outputRotationSpeed;
[HideInInspector] public Vector3 outputMoveDirection;
[HideInInspector] public Vector3 additionalMoveDirection;
// SmoothDamp Velocities
private Quaternion refVelocityRotationSpeed;
private float refVelocityAcceleration;
private float refVelocityDeacceleration;
// Smoothing Values
private float directionChangeDotLerp;
@@ -26,112 +27,69 @@ namespace Reset.Units{
private LockOnManager lockOnManager;
// Movement Data
[ShowInInspector, PropertyOrder(2)] public UnitMovementData data = new();
[ShowInInspector, PropertyOrder(2), FoldoutGroup("Movement Data", expanded: true), InlineProperty, HideLabel] public UnitMovementData data = new();
void Awake(){
controller = GetComponent<CharacterController>();
controls = GetComponent<PlayerControls>();
lockOnManager = GetComponent<LockOnManager>();
InitAllSettings();
}
void Start(){
resolvedMovement = new ResolvedMovement();
resolvedMovement.moveDirection = new ResolvedMovement.MoveDirection(transform);
resolvedMovement = new ResolvedMovement{
moveDirection = new ResolvedMovement.MoveDirection(transform)
};
}
void Update(){
SmoothAllSettings();
UpdateCurrentDirection();
UpdateCurrentGravity();
UpdateCurrentSpeed();
// UpdateCurrentRotation();
UpdateCurrentRotation();
DoMovement();
}
// Add directly to the direction
public void AddToCurrentDirection(Vector3 inputDirection, float power){ // Old
additionalMoveDirection += inputDirection.normalized;
additionalSpeed = power;
}
public void SmoothToSpeed(float desiredSpeed, float smoothing){ // Old
additionalSpeed = Mathf.Lerp(additionalSpeed, desiredSpeed, smoothing * Time.deltaTime);
}
public void SetNewDirection(Vector3 inputDirection){ // NOTE: If smoothing desired add a default bool for smoothing maybe? // Old
additionalMoveDirection = inputDirection.Flatten(null, 0f, null);
}
public void SetNewGravity(float value){
additionalMoveDirection.y = value;
}
// Hold a new rotation to be moved to during PlayerFacingDirection.SpecifiedRotation
public void SetSpecifiedRotation(Quaternion inputRotation){ // Old
specifiedRotation = inputRotation;
}
// Blend between the current direction and an input direction, based on the current controller input
public void OverwriteDirectionFromInput(Vector2 value, float priority, float speed = Mathf.Infinity){ // Old
// Create a new direction that is the current controller input * the amount of power they should have
Vector3 dirToAdd = new Vector3(controls.rawMoveInput.x * value.x, 0f, controls.rawMoveInput.y * value.y);
// Multiply it by the current magnitude (why? i forgor)
dirToAdd *= controls.rawMoveInput.magnitude;
// Blend the existing direction into it
dirToAdd = Vector3.Lerp(outputMoveDirection, dirToAdd, priority * controls.rawMoveInput.magnitude);
// Set the new direction
outputMoveDirection = new Vector3(dirToAdd.x, outputMoveDirection.y, dirToAdd.z);
// Everthing under here is for the speed now. If it's not set do...nothing. Otherwise set it to the max value between move speed and the new speed
if (float.IsPositiveInfinity(speed)) {
return;
}
outputSpeed = Mathf.Lerp(outputSpeed, Mathf.Max(data.moveSpeed.Value, speed), priority);
}
// Setting absolute to true will cause the current gravity to snap to the new gravity value.
// Keeping it false will make it apply additively to the current gravity. Both options use relativty for linear interpolation.
public void SetNewGravity(float value, float relativity, bool absolute){ // new
if (absolute){
resolvedMovement.gravity = Mathf.Lerp(resolvedMovement.gravity, value, relativity);
} else {
resolvedMovement.gravity = Mathf.Lerp(resolvedMovement.gravity, resolvedMovement.gravity + value, relativity);
}
DebugOverlayDrawer.ChangeValue("Movement", "Move Direction (Local)", resolvedMovement.moveDirection.Local);
DebugOverlayDrawer.ChangeValue("Movement", "Move Direction (World)", resolvedMovement.moveDirection.World);
}
// Update the direction, called every frame
private void UpdateCurrentDirection(){
// Get input value
Vector2 targetDirection = new Vector2(controls.rawMoveInput.x, controls.rawMoveInput.y);
targetDirection = (Camera.main.transform.rotation * targetDirection.ToVector3()).ToVector2();
// Deadzone
if (targetDirection.magnitude < .05f) {
if (targetDirection.magnitude < .08f) {
targetDirection = Vector2.zero;
}
// Set Raw Direciton
resolvedMovement.moveDirection.RawWorld = targetDirection;
// Get current direction
Vector2 currentDirection = resolvedMovement.moveDirection.Local;
Vector2 currentDirection = resolvedMovement.moveDirection.World;
// Also need to find the dot value of the current input versus the current move direction
Vector3 slerpedValue;
Vector2 lerpedValue;
Vector2 newDirection;
float switchedDirection = Vector3.Dot(targetDirection, currentDirection);
float switchedDirectionRemapped = Mathf.Lerp(0, 1, switchedDirection);
directionChangeDotLerp = Mathf.Lerp(switchedDirection, switchedDirectionRemapped, 5f * Time.deltaTime) ; // turn that .5f into a variable
DebugOverlayDrawer.ChangeValue("Movement", "Direction Change Dot", directionChangeDotLerp);
DebugOverlayDrawer.ChangeValue("Movement", "Direction Change Dot", directionChangeDotLerp);
// Smooth movement. Use deaccel smoothing if the input magnitude is lower, and accel smoothing if it's higher
// Also checks when grounded to only use Slerp on the ground
// Also checks when grounded to only use Slerp on the ground
Vector3 slerpedValue;
Vector2 lerpedValue;
Vector2 newDirection;
if (controller.isGrounded){
slerpedValue = Vector3.Slerp(currentDirection, targetDirection, data.softening.Value * Time.deltaTime); // This used to be a slerp. If rotational movement broke this is why
slerpedValue = Vector3.Slerp(currentDirection, targetDirection, data.softening.Value * Time.deltaTime);
lerpedValue = Vector2.Lerp(currentDirection, targetDirection, data.softening.Value * Time.deltaTime);
newDirection = Vector2.Lerp(slerpedValue, lerpedValue, directionChangeDotLerp);
@@ -139,29 +97,23 @@ namespace Reset.Units{
newDirection = Vector2.Lerp(currentDirection, targetDirection, data.softening.Value * data.airDirectionDecay.Value * Time.deltaTime);
}
// newDirection = Vector2.MoveTowards(currentDirection, targetDirection.Rotate(-Vector2.Angle(currentDirection, targetDirection)), 2f * Time.deltaTime);
// Commit move direction
// resolvedMovement.moveDirection.Local = Vector2.SmoothDamp(
// resolvedMovement.moveDirection.Local,
// newDirection,
// ref smoothing.moveSmoothing.refVel,
// smoothing.moveSmoothing.smoothing *Time.deltaTime); // TODO: Check this smoothing
resolvedMovement.moveDirection.Local = newDirection;
// Commit the new direction
resolvedMovement.moveDirection.World = newDirection;
}
// Update the speed, called every frame
private void UpdateCurrentSpeed(){
float speed;
// ""Smooth"" the speed
float smoothedSpeed;
if (resolvedMovement.moveDirection.Local.magnitude < controls.rawMoveInput.magnitude) {
speed = data.moveSpeed.Value * Time.deltaTime * data.acceleration.Value;
smoothedSpeed = Mathf.MoveTowards(resolvedMovement.moveSpeed, data.moveSpeed.Value, data.acceleration.Value * Time.deltaTime);
} else {
speed = data.moveSpeed.Value * Time.deltaTime * data.deacceleration.Value;
smoothedSpeed = Mathf.MoveTowards(resolvedMovement.moveSpeed, 0f, data.deacceleration.Value * Time.deltaTime);
}
resolvedMovement.moveSpeed = speed;
// Commit the speed
resolvedMovement.moveSpeed = smoothedSpeed;
DebugOverlayDrawer.ChangeValue("Movement", "Resolved Speed", resolvedMovement.moveSpeed);
}
@@ -173,75 +125,61 @@ namespace Reset.Units{
resolvedMovement.gravity -= data.gravityAcceleration.Value * Time.deltaTime;
}
// resolvedMovement.gravity = Mathf.Clamp(resolvedMovement.gravity, Mathf.NegativeInfinity, data.gravityMax.value);
// Apply a constant gravity if the player is grounded
if (controller.isGrounded) {
// resolvedMovement.gravity = -.3f;
}
// Create the final gravity value
float gravityMoveDirection = data.jumpPower.Value + (Physics.gravity.y * resolvedMovement.gravity);
// resolvedMovement.gravity = data.jumpPower.value + (Physics.gravity.y * data.gravityPower.currentValue);
// Commit gravity to move direction, ignoring XZ since those are done in UpdateMovementDirection
outputMoveDirection.y = Mathf.SmoothDamp(outputMoveDirection.y, gravityMoveDirection, ref gravitySmoothVelocityRef, .1f * Time.deltaTime);
float gravityMoveDirection = Physics.gravity.y * resolvedMovement.gravity;
}
// Update the rotation, called every frame
private void UpdateCurrentRotation(){
// Get input value
Vector3 inputMovement = new Vector3(controls.rawMoveInput.x, 0f, controls.rawMoveInput.y);
Quaternion targetRotation = Quaternion.identity;
// Switch the desired rotation based on current movement setting
switch (data.rotateFacing) {
switch (data.rotateFacing.Value) { // TODO: Check that this isn't broken
// Just look at target
case PlayerFacingDirection.TowardsTarget:
// Look directly at the target
outputRotation = Quaternion.LookRotation(transform.position.DirectionTo(lockOnManager.mainTarget.gameObject.transform.position));
targetRotation = Quaternion.LookRotation(transform.position.DirectionTo(lockOnManager.mainTarget.gameObject.transform.position));
break;
case PlayerFacingDirection.Momentum:
// Look towards the current direction the agent is moving
if (inputMovement.magnitude > .05f){
outputRotation = Camera.main.transform.rotation * Quaternion.LookRotation(outputMoveDirection);
targetRotation = Quaternion.LookRotation(resolvedMovement.moveDirection.RawWorld.ToVector3(), Vector3.up);
}
break;
case PlayerFacingDirection.MatchForward:
// Look towards the input direction....why??? I guess cause move direction is PlayerFacingDirection.Momentum.
if (controls.rawMoveInput.magnitude < 0.05f) { break; }
outputRotation = Camera.main.transform.rotation * Quaternion.LookRotation(inputMovement);
targetRotation = Camera.main.transform.rotation * Quaternion.LookRotation(inputMovement);
break;
case PlayerFacingDirection.MatchCamera:
// Look the same direction as the camera
outputRotation = Quaternion.Euler(Camera.main.transform.rotation.eulerAngles.Flatten(0, null, 0));
targetRotation = Quaternion.Euler(Camera.main.transform.rotation.eulerAngles.Flatten(0, null, 0));
break;
case PlayerFacingDirection.Static:
// Don't change
outputRotation = transform.rotation;
break;
case PlayerFacingDirection.SpecifiedDirection:
// Look at an inputed rotation
outputRotation = specifiedRotation;
targetRotation = transform.rotation;
break;
}
DebugOverlayDrawer.ChangeValue("Rotation", "Target Rotation", targetRotation.eulerAngles);
// Add the current input into the created rotation
if (inputMovement.magnitude > .05){
outputRotation = Quaternion.Lerp(outputRotation, Camera.main.transform.rotation * Quaternion.LookRotation(inputMovement), data.rotationInputBlending.Value);
if (inputMovement.magnitude > .05) {
// Quaternion inputRot = Camera.main.transform.rotation * Quaternion.LookRotation(inputMovement);
// resolvedMovement.rotation = Quaternion.RotateTowards(resolvedMovement.rotation, targetRotation, 10f);
resolvedMovement.rotation = targetRotation;
}
// Calculate rotation speed, as in how fast the fella rotates. This value has it's own smoothing to allow for gradual increasing/decreasing of the speed till it reaches the target
outputRotationSpeed = Mathf.Lerp(outputRotationSpeed, data.rotationSpeed.Value, data.softening.Value * Time.deltaTime);
// Set final rotation
transform.rotation = Quaternion.Slerp(transform.rotation, outputRotation, outputRotationSpeed * Time.deltaTime).Flatten(0, null, 0);
transform.rotation = Quaternion.Slerp(transform.rotation, resolvedMovement.rotation, data.rotationSpeed.Value * Time.deltaTime).Flatten(0, null, 0);
}
// Move with default settings
public void DoMovement(){
DoMovement(resolvedMovement.moveDirection.Local, resolvedMovement.moveSpeed, data.gravityScale.Value); // TODO: Gets multiplied a second time in DoMovement by gravity scale????
DoMovement(resolvedMovement.moveDirection.World, resolvedMovement.moveSpeed, data.gravityScale.Value); // TODO: Gets multiplied a second time in DoMovement by gravity scale????
}
// Custom move from input
@@ -249,63 +187,100 @@ namespace Reset.Units{
// Debug.Log($"moveDir: {moveDir}, agent velocity: {transform.InverseTransformDirection(controller.velocity.normalized)}");
// Seperate the different move directions. Additonal becomes it's own because it needs to be added independently of the other two
Vector2 moveXZDir = new Vector3(moveDir.x, moveDir.y);
Vector2 moveXZDir = moveDir;
float moveYDir = resolvedMovement.gravity;
Vector3 addDir = additionalMoveDirection;
// Add their related speeds
moveXZDir *= speed * Time.deltaTime;
moveYDir *= data.gravityScale.Value * Time.deltaTime;
addDir *= additionalSpeed * Time.deltaTime;
// Construct the direction and move
Vector3 finalDir = new Vector3(moveXZDir.x, moveYDir,moveXZDir.y) ;
controller.Move((Camera.main.transform.rotation.Flatten(0, null, 0) * finalDir) + addDir);
}
void LateUpdate(){
UpdateGravityLate();
DecayAdditionalDirection();
}
void DecayAdditionalDirection(){
// Get input value
Vector3 inputMovement = new Vector3(controls.rawMoveInput.x, 0f, controls.rawMoveInput.y);
// Ignore values under deadzone
if (inputMovement.magnitude < .1f) {
inputMovement = Vector3.zero;
}
// Remove Y from variables
Vector3 currentNoY = new Vector3(additionalMoveDirection.x, 0f, additionalMoveDirection.z);
// Decay the direction
if (inputMovement.magnitude < currentNoY.magnitude) {
additionalMoveDirection = Vector3.Slerp(additionalMoveDirection, Vector3.zero,data.acceleration.Value * Time.deltaTime);
} else {
// float deaccelValue = data.deaccelerationCurve.Evaluate(inputMovement.magnitude);
additionalMoveDirection = Vector3.Lerp(additionalMoveDirection, Vector3.zero, data.deacceleration.Value * Time.deltaTime);
}
// Decay the gravity
additionalMoveDirection.y -= data.gravityPower.Value;
additionalMoveDirection.y = Mathf.Max(0f, additionalMoveDirection.y);
Vector3 finalDir = new Vector3(moveXZDir.x, moveYDir, moveXZDir.y);
controller.Move(finalDir);
}
private void UpdateGravityLate(){
// Decay jump power
data.jumpPower.Value -= data.jumpPowerDecay.Value * Time.deltaTime;
data.jumpPower.Value = Mathf.Max(0f, data.jumpPower.Value);
// Setting absolute to true will cause the current gravity to snap to the new gravity value.
// Keeping it false will make it apply additively to the current gravity. Both options use relativty for linear interpolation.
public void SetNewGravity(float value, float relativity, bool absolute){ // new
if (absolute){
resolvedMovement.gravity = Mathf.Lerp(resolvedMovement.gravity, value, relativity);
} else {
resolvedMovement.gravity = Mathf.Lerp(resolvedMovement.gravity, resolvedMovement.gravity + value, relativity);
}
}
[Button("Initialize Settings")]
public void SetNewDirection(Vector2 value, float relativity, bool absolute){ // new
if (absolute){
resolvedMovement.moveDirection.World = Vector2.Lerp(resolvedMovement.moveDirection.World, value, relativity);
} else {
resolvedMovement.moveDirection.World = Vector2.Lerp(resolvedMovement.moveDirection.World, resolvedMovement.moveDirection.World + value, relativity);
}
}
public void SetNewRawDirection(Vector2 value, float relativity, bool absolute){ // new
if (absolute){
resolvedMovement.moveDirection.RawWorld = Vector2.Lerp(resolvedMovement.moveDirection.RawWorld, value, relativity);
} else {
resolvedMovement.moveDirection.RawWorld = Vector2.Lerp(resolvedMovement.moveDirection.RawWorld, resolvedMovement.moveDirection.RawWorld + value, relativity);
}
}
public void SetNewSpeed(float value, float relativity, bool absolute){ // new
if (absolute){
resolvedMovement.moveSpeed = Mathf.Lerp(resolvedMovement.moveSpeed, value, relativity);
} else {
resolvedMovement.moveSpeed = Mathf.Lerp(resolvedMovement.moveSpeed, resolvedMovement.moveSpeed + value, relativity);
}
}
public void SetNewRotation(Quaternion value, float relativity, bool absolute){ // new
if (absolute){
resolvedMovement.rotation = Quaternion.Lerp(resolvedMovement.rotation, value, relativity);
} else {
resolvedMovement.rotation = Quaternion.Lerp(resolvedMovement.rotation, resolvedMovement.rotation * value, relativity);
}
}
[Button("Initialize Settings", ButtonHeight = 30), PropertySpace(10,5 )]
void InitAllSettings(){
var newthing = data.GetAllSettings();
var settingsList = data.GetAllSettings();
foreach (IResettableSettingValue value in settingsList) {
value.Initialize();
value.Verify();
}
}
void SmoothAllSettings(){
var settingsList = data.GetAllSettings();
foreach (IResettableSettingValue value in settingsList) {
value.SmoothAndEase();
}
}
public void AddToCurrentDirection(Vector3 inputDirection, float power){ // Old
Debug.LogError("Using an old movement command! Switch to one of the new alternatives!");
}
public void SmoothToSpeed(float desiredSpeed, float smoothing){ // Old
Debug.LogError("Using an old movement command! Switch to one of the new alternatives!");
}
public void SetNewDirection(Vector3 inputDirection){ // NOTE: If smoothing desired add a default bool for smoothing maybe? // Old
Debug.LogError("Using an old movement command! Switch to one of the new alternatives!");
}
public void SetNewGravity(float value){
Debug.LogError("Using an old movement command! Switch to one of the new alternatives!");
}
public void SetSpecifiedRotation(Quaternion inputRotation){ // Old
Debug.LogError("Using an old movement command! Switch to one of the new alternatives!");
}
public void OverwriteDirectionFromInput(Vector2 value, float priority, float speed = Mathf.Infinity){ // Old
Debug.LogError("Using an old movement command! Switch to one of the new alternatives!");
}
}
}