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

change: all movement separated into invidividual tasks, a lot of shuffling value groups and related stuff around

Browse Source
This commit is contained in:
Chris
2025-09-16 17:07:20 -04:00
parent 7a0499f36a
commit aad8b78c22
17 changed files with 1507 additions and 1036 deletions
Download Patch File Download Diff File Expand all files Collapse all files

113
Assets/Scripts/Core/Graph Tasks/ChangeCameraSettings.cs
View File

@@ -42,118 +42,29 @@ namespace NodeCanvas.Tasks.Actions {
//Call EndAction() to mark the action as finished, either in success or failure.
//EndAction can be called from anywhere.
protected override void OnExecute(){
UpdateOrbitFollowValue(orbitFollowTop, ref CameraSettingsProcessor.values.orbitFollowTopHeight, ref CameraSettingsProcessor.values.orbitFollowTopRadius);
UpdateOrbitFollowValue(orbitFollowCenter, ref CameraSettingsProcessor.values.orbitFollowCenterHeight, ref CameraSettingsProcessor.values.orbitFollowCenterRadius);
UpdateOrbitFollowValue(orbitFollowBottom, ref CameraSettingsProcessor.values.orbitFollowBottomHeight, ref CameraSettingsProcessor.values.orbitFollowBottomRadius);
OrbitalFollowValueGroup.UpdateValue(orbitFollowTop, ref CameraSettingsProcessor.data.orbitFollowTopHeight.value, ref CameraSettingsProcessor.original.orbitFollowTopRadius.value);
OrbitalFollowValueGroup.UpdateValue(orbitFollowCenter, ref CameraSettingsProcessor.data.orbitFollowCenterHeight.value, ref CameraSettingsProcessor.original.orbitFollowCenterRadius.value);
OrbitalFollowValueGroup.UpdateValue(orbitFollowBottom, ref CameraSettingsProcessor.data.orbitFollowBottomHeight.value, ref CameraSettingsProcessor.original.orbitFollowBottomRadius.value);
UpdateVector3Value(cameraOffset, ref CameraSettingsProcessor.values.cameraOffsetOffset);
Vector3ValueGroup.UpdateValue(cameraOffset, ref CameraSettingsProcessor.data.cameraOffsetOffset.value, ref CameraSettingsProcessor.original.cameraOffsetOffset.value);
UpdateVector3Value(orbitPositionDamping, ref CameraSettingsProcessor.values.orbitPositionDamping);
UpdateVector3Value(orbitTargetOffset, ref CameraSettingsProcessor.values.orbitTargetOffset);
Vector3ValueGroup.UpdateValue(orbitPositionDamping, ref CameraSettingsProcessor.data.orbitPositionDamping.value, ref CameraSettingsProcessor.original.cameraOffsetOffset.value);
Vector3ValueGroup.UpdateValue(orbitTargetOffset, ref CameraSettingsProcessor.data.orbitTargetOffset.value, ref CameraSettingsProcessor.original.cameraOffsetOffset.value);
UpdateVector2Value(screenPosition, ref CameraSettingsProcessor.values.rotationComposerScreenPos);
UpdateFloatValue(fieldOfView, ref CameraSettingsProcessor.values.mainFieldOfView);
Vector2ValueGroup.UpdateValue(screenPosition, ref CameraSettingsProcessor.data.rotationComposerScreenPos.value, ref CameraSettingsProcessor.original.rotationComposerScreenPos.value);
FloatValueGroup.UpdateValue(fieldOfView, ref CameraSettingsProcessor.data.mainFieldOfView.value, ref CameraSettingsProcessor.original.mainFieldOfView.value);
UpdateFloatValue(axisLookXGain, ref CameraSettingsProcessor.values.axisLookGainX);
UpdateFloatValue(axisLookYGain, ref CameraSettingsProcessor.values.axisLookGainY);
FloatValueGroup.UpdateValue(axisLookXGain, ref CameraSettingsProcessor.data.axisLookGainX.value, ref CameraSettingsProcessor.original.axisLookGainX.value);
FloatValueGroup.UpdateValue(axisLookYGain, ref CameraSettingsProcessor.data.axisLookGainY.value, ref CameraSettingsProcessor.original.axisLookGainY.value);
UpdateBoolValue(enableXAxis, ref CameraSettingsProcessor.values.axisLookEnabledX);
UpdateBoolValue(enableYAxis, ref CameraSettingsProcessor.values.axisLookEnabledY);
BoolValueGroup.UpdateValue(enableXAxis, ref CameraSettingsProcessor.data.axisLookEnabledX.value, ref CameraSettingsProcessor.original.axisLookEnabledX.value);
BoolValueGroup.UpdateValue(enableYAxis, ref CameraSettingsProcessor.data.axisLookEnabledY.value, ref CameraSettingsProcessor.original.axisLookEnabledY.value);
EndAction(true);
}
public void UpdateVector3Value(Vector3ValueGroup valueGroup, ref CameraSettingSingleValue<Vector3> targetProperty){
switch (valueGroup.changeX) {
case ValueChangeAction.NewValue:
targetProperty.targetValue.x = valueGroup.newValue.x;
break;
case ValueChangeAction.ResetValue:
targetProperty.targetValue.x = targetProperty.originalValue.x;
break;
}
switch (valueGroup.changeY) {
case ValueChangeAction.NewValue:
targetProperty.targetValue.y = valueGroup.newValue.y;
break;
case ValueChangeAction.ResetValue:
targetProperty.targetValue.y = targetProperty.originalValue.y;
break;
}
switch (valueGroup.changeZ) {
case ValueChangeAction.NewValue:
targetProperty.targetValue.z = valueGroup.newValue.z;
break;
case ValueChangeAction.ResetValue:
targetProperty.targetValue.z = targetProperty.originalValue.z;
break;
}
}
public void UpdateVector2Value(Vector2ValueGroup valueGroup, ref CameraSettingSingleValue<Vector2> targetProperty){
switch (valueGroup.changeX) {
case ValueChangeAction.NewValue:
targetProperty.targetValue.x = valueGroup.newValue.x;
break;
case ValueChangeAction.ResetValue:
targetProperty.targetValue.x = targetProperty.originalValue.x;
break;
}
switch (valueGroup.changeY) {
case ValueChangeAction.NewValue:
targetProperty.targetValue.y = valueGroup.newValue.y;
break;
case ValueChangeAction.ResetValue:
targetProperty.targetValue.y = targetProperty.originalValue.y;
break;
}
}
public void UpdateOrbitFollowValue(OrbitalFollowValueGroup valueGroup, ref CameraSettingSingleValue<float> targetHeight, ref CameraSettingSingleValue<float> targetRadius){
switch (valueGroup.changeHeight) {
case ValueChangeAction.NewValue:
targetHeight.targetValue = valueGroup.height;
break;
case ValueChangeAction.ResetValue:
targetHeight.targetValue = targetHeight.originalValue;
break;
}
switch (valueGroup.changeRadius) {
case ValueChangeAction.NewValue:
targetRadius.targetValue = valueGroup.radius;
break;
case ValueChangeAction.ResetValue:
targetRadius.targetValue = targetRadius.originalValue;
break;
}
}
public void UpdateBoolValue(BoolValueGroup valueGroup, ref CameraSettingSingleValue<bool> targetProperty){
switch (valueGroup.changeValue) {
case ValueChangeAction.NewValue:
targetProperty.targetValue = valueGroup.value;
break;
case ValueChangeAction.ResetValue:
targetProperty.targetValue = targetProperty.originalValue;
break;
}
}
public void UpdateFloatValue(FloatValueGroup valueGroup, ref CameraSettingSingleValue<float> targetProperty){
switch (valueGroup.changeValue) {
case ValueChangeAction.NewValue:
targetProperty.targetValue = valueGroup.value.value;
break;
case ValueChangeAction.ResetValue:
targetProperty.targetValue = targetProperty.originalValue;
break;
}
}
//Called once per frame while the action is active.
protected override void OnUpdate() {

189
Assets/Scripts/Core/Graph Tasks/ChangeMovementSettings.cs
View File

@@ -2,13 +2,15 @@ using System;
using NodeCanvas.Framework;
using ParadoxNotion.Design;
using Reset.Units;
using Sirenix.OdinInspector.Editor;
using UnityEngine;
namespace Reset.Core {
[Category("Reset")]
[Description("Commits movement unit changes to the handler.")]
public class ChangeMovementSettings : ActionTask<UnitMovementHandler> {
// Move Speed
[ParadoxNotion.Design.Header("Speed")]
public FloatValueGroup moveSpeed = new (newLabel: "Move Speed");
public FloatValueGroup moveSpeedSoothing = new (newLabel: "Move Speed Smoothing");
@@ -19,15 +21,7 @@ namespace Reset.Core {
public FloatValueGroup deaccelerationSmoothing = new (newLabel: "Deacceleration Smoothing");
// public CurveValueGroup deaccelerationCurve = new (newLabel: "Deacceleration Curve"); // Currently unused, may return
// Direction
[Space(5)]
public Vector3ValueGroup feedNewDirection = new Vector3ValueGroup("Feed New Direction");
public float newDirectionStrength;
[Space(5)]
public Vector2 addDirectionFromInput;
public float addInputStrength;
[SliderField(0,1)]
public float addInputPriorty;
// Jumping
[ParadoxNotion.Design.Header("Jumping")]
@@ -63,48 +57,41 @@ namespace Reset.Core {
//Call EndAction() to mark the action as finished, either in success or failure.
//EndAction can be called from anywhere.
protected override void OnExecute() {
// Direction
UpdateFloatValue(airDirectionDecay, ref agent.data.airDirectionDecay, ref agent.data.airDirectionDecay);
UpdateFloatValue(accelerationSmoothing, ref agent.data.accelerationSmoothing, ref agent.defaultData.accelerationSmoothing);
UpdateFloatValue(deaccelerationSmoothing, ref agent.data.deaccelerationSmoothing, ref agent.defaultData.deaccelerationSmoothing);
// UpdateCurveProperty(deaccelerationCurve, ref agent.data.deaccelerationCurve, ref agent.defaultData.deaccelerationCurve); // Currently unused, may return
// Direction from value
// Check that feedDir is not changed
UpdateVector3Value(feedNewDirection, ref feedDir, ref feedDir);
// If there's a direciton add it to the player for a frame
if (feedDir != Vector3.zero) {
agent.AddToCurrentDirection(agent.transform.rotation * feedDir.normalized, newDirectionStrength);
// Reset the fed direction after it's added so future runs don't have
feedDir = Vector3.zero;
}
// Direction from controller input
if (addDirectionFromInput != Vector2.zero){
agent.OverwriteDirectionFromInput(new Vector3(addDirectionFromInput.x, addDirectionFromInput.y), addInputPriorty, addInputStrength);
}
// Move Speed
UpdateFloatValue(moveSpeed, ref agent.data.moveSpeed, ref agent.defaultData.moveSpeed);
UpdateFloatValue(moveSpeedSoothing, ref agent.data.moveSpeedSoothing, ref agent.defaultData.moveSpeedSoothing);
// Jump
UpdateFloatValue(jumpPower, ref agent.data.jumpPower, ref agent.defaultData.jumpPower);
UpdateFloatValue(jumpPowerDecay, ref agent.data.jumpPowerDecay, ref agent.defaultData.jumpPowerDecay);
// Gravity
UpdateFloatValue(gravityPower, ref agent.data.gravityPower, ref agent.defaultData.gravityPower);
UpdateFloatValue(gravityMax, ref agent.data.gravityMax, ref agent.defaultData.gravityMax);
UpdateFloatValue(gravityAcceleration, ref agent.data.gravityAcceleration, ref agent.defaultData.gravityAcceleration);
UpdateFloatValue(gravityScale, ref agent.data.gravityScale, ref agent.defaultData.gravityScale);
UpdateFloatValue(settingsChangeSmoothing, ref agent.data.settingsChangeSmoothing, ref agent.defaultData.settingsChangeSmoothing);
// Rotation
UpdateEnumValue(rotateFacing, ref agent.data.rotateFacing, ref agent.defaultData.rotateFacing);
UpdateFloatValue(rotationSpeed, ref agent.data.rotationSpeed, ref agent.defaultData.rotationSpeed);
UpdateFloatValue(rotationSmoothing, ref agent.data.rotationSmoothing, ref agent.defaultData.rotationSmoothing);
UpdateFloatValue(rotationInputBlending, ref agent.data.rotationInputBlending, ref agent.defaultData.rotationInputBlending);
// // Direction
// FloatValueGroup.UpdateValue(airDirectionDecay, ref agent.data.airDirectionDecay, ref agent.defaultData.airDirectionDecay);
// FloatValueGroup.ChangeSmoothingEasing(airDirectionDecay,
// ref agent.smoothing.airDirectionDecay,
// ref agent.easing.airDirectionDecay,
// ref agent.defaultSmoothing.airDirectionDecay,
// ref agent.defaultEasing.airDirectionDecay
// );
//
// UpdateFloatValue(accelerationSmoothing, ref agent.data.accelerationSmoothing, ref agent.defaultData.accelerationSmoothing);
// UpdateFloatValue(deaccelerationSmoothing, ref agent.data.deaccelerationSmoothing, ref agent.defaultData.deaccelerationSmoothing);
// // UpdateCurveProperty(deaccelerationCurve, ref agent.data.deaccelerationCurve, ref agent.defaultData.deaccelerationCurve); // Currently unused, may return
//
//
//
// // Move Speed
// UpdateFloatValue(moveSpeed, ref agent.data.moveSpeed, ref agent.defaultData.moveSpeed);
// UpdateFloatValue(moveSpeedSoothing, ref agent.data.moveSpeedSoothing, ref agent.defaultData.moveSpeedSoothing);
//
// // Jump
// UpdateFloatValue(jumpPower, ref agent.data.jumpPower, ref agent.defaultData.jumpPower);
// UpdateFloatValue(jumpPowerDecay, ref agent.data.jumpPowerDecay, ref agent.defaultData.jumpPowerDecay);
//
// // Gravity
// UpdateFloatValue(gravityPower, ref agent.data.gravityPower, ref agent.defaultData.gravityPower);
// UpdateFloatValue(gravityMax, ref agent.data.gravityMax, ref agent.defaultData.gravityMax);
// UpdateFloatValue(gravityAcceleration, ref agent.data.gravityAcceleration, ref agent.defaultData.gravityAcceleration);
// UpdateFloatValue(gravityScale, ref agent.data.gravityScale, ref agent.defaultData.gravityScale);
// UpdateFloatValue(settingsChangeSmoothing, ref agent.data.settingsChangeSmoothing, ref agent.defaultData.settingsChangeSmoothing);
//
// // Rotation
// UpdateEnumValue(rotateFacing, ref agent.data.rotateFacing, ref agent.defaultData.rotateFacing);
// UpdateFloatValue(rotationSpeed, ref agent.data.rotationSpeed, ref agent.defaultData.rotationSpeed);
// UpdateFloatValue(rotationSmoothing, ref agent.data.rotationSmoothing, ref agent.defaultData.rotationSmoothing);
// UpdateFloatValue(rotationInputBlending, ref agent.data.rotationInputBlending, ref agent.defaultData.rotationInputBlending);
// Rotation from value
if (feedNewRotation.value != Vector3.zero) {
@@ -133,103 +120,5 @@ namespace Reset.Core {
protected override void OnPause() {
}
public void UpdateCurveProperty(CurveValueGroup valueGroup, ref AnimationCurve targetProperty, ref AnimationCurve defaultProperty){
switch (valueGroup.changeValue) {
case ValueChangeAction.NoChange:
break;
case ValueChangeAction.NewValue:
targetProperty = valueGroup.newValue;
break;
case ValueChangeAction.ResetValue:
targetProperty = defaultProperty;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public void UpdateVector3Value(Vector3ValueGroup valueGroup, ref Vector3 targetProperty, ref Vector3 defaultProperty){
switch (valueGroup.changeX) {
case ValueChangeAction.NewValue:
targetProperty.x = valueGroup.newValue.x;
break;
case ValueChangeAction.ResetValue:
targetProperty.x = defaultProperty.x;
break;
}
switch (valueGroup.changeY) {
case ValueChangeAction.NewValue:
targetProperty.y = valueGroup.newValue.y;
break;
case ValueChangeAction.ResetValue:
targetProperty.y = defaultProperty.y;
break;
}
switch (valueGroup.changeZ) {
case ValueChangeAction.NewValue:
targetProperty.z = valueGroup.newValue.z;
break;
case ValueChangeAction.ResetValue:
targetProperty.z = defaultProperty.z;
break;
}
}
public void UpdateVector2Value(Vector2ValueGroup valueGroup, ref Vector2 targetProperty, ref Vector2 defaultProperty){
switch (valueGroup.changeX) {
case ValueChangeAction.NewValue:
targetProperty.x = valueGroup.newValue.x;
break;
case ValueChangeAction.ResetValue:
targetProperty.x = defaultProperty.x;
break;
}
switch (valueGroup.changeY) {
case ValueChangeAction.NewValue:
targetProperty.y = valueGroup.newValue.y;
break;
case ValueChangeAction.ResetValue:
targetProperty.y = defaultProperty.y;
break;
}
}
public void UpdateBoolValue(BoolValueGroup valueGroup, ref bool targetProperty, ref bool defaultProperty){
switch (valueGroup.changeValue) {
case ValueChangeAction.NewValue:
targetProperty = valueGroup.value;
break;
case ValueChangeAction.ResetValue:
targetProperty = defaultProperty;
break;
}
}
public void UpdateEnumValue(EnumValueGroup valueGroup, ref Enum targetProperty, ref Enum defaultProperty){
switch (valueGroup.changeValue) {
case ValueChangeAction.NewValue:
targetProperty = valueGroup.newValue;
break;
case ValueChangeAction.ResetValue:
targetProperty = defaultProperty;
break;
}
}
public void UpdateFloatValue(FloatValueGroup valueGroup, ref float targetProperty, ref float defaultProperty){
switch (valueGroup.changeValue) {
case ValueChangeAction.NewValue:
targetProperty = valueGroup.value.value;
break;
case ValueChangeAction.ResetValue:
targetProperty = defaultProperty;
break;
}
}
}
}

8
Assets/Scripts/Core/Graph Tasks/Movement Settings Changes.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 7879b20d5bcdf974c823d1919491e026
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

67
Assets/Scripts/Core/Graph Tasks/Movement Settings Changes/ChangeDirectionSettings.cs Normal file
View File

@@ -0,0 +1,67 @@
using NodeCanvas.Framework;
using ParadoxNotion.Design;
using Reset.Core;
using UnityEngine;
namespace Reset.Units {
[Category("Reset/Movement")]
public class ChangeDirectionSettings : ActionTask<UnitMovementHandler> {
// Direction
[Space(5)]
public Vector3ValueGroup feedNewDirection = new Vector3ValueGroup("Feed New Direction");
public float newDirectionStrength;
[Space(5)]
public Vector2 addDirectionFromInput;
public float addInputStrength;
[SliderField(0,1)]
public float addInputPriorty;
//Use for initialization. This is called only once in the lifetime of the task.
//Return null if init was successfull. Return an error string otherwise
protected override string OnInit() {
return null;
}
//This is called once each time the task is enabled.
//Call EndAction() to mark the action as finished, either in success or failure.
//EndAction can be called from anywhere.
protected override void OnExecute() {
// Direction from value
// Check that feedDir is not changed
// UpdateVector3Value(feedNewDirection, ref feedDir, ref feedDir);
//
// Vector3ValueGroup.ResolvedValue(feedNewDirection, ref feedDir, ref feedDir);
//
// // If there's a direciton add it to the player for a frame
// if (feedDir != Vector3.zero) {
// agent.AddToCurrentDirection(agent.transform.rotation * feedDir.normalized, newDirectionStrength);
// // Reset the fed direction after it's added so future runs don't have
// feedDir = Vector3.zero;
// }
// Direction from controller input
if (addDirectionFromInput != Vector2.zero){
agent.OverwriteDirectionFromInput(new Vector3(addDirectionFromInput.x, addDirectionFromInput.y), addInputPriorty, addInputStrength);
}
EndAction(true);
}
//Called once per frame while the action is active.
protected override void OnUpdate() {
}
//Called when the task is disabled.
protected override void OnStop() {
}
//Called when the task is paused.
protected override void OnPause() {
}
}
}

2
Assets/Scripts/Core/Graph Tasks/Movement Settings Changes/ChangeDirectionSettings.cs.meta Normal file
View File

@@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: e97f34b81238a9548b0bf4f5b68c8f17

54
Assets/Scripts/Core/Graph Tasks/Movement Settings Changes/ChangeGravitySettings.cs Normal file
View File

@@ -0,0 +1,54 @@
using NodeCanvas.Framework;
using ParadoxNotion.Design;
using Reset.Core;
namespace Reset.Units {
[Category("Reset/Movement")]
public class ChangeGravitySettings : ActionTask<UnitMovementHandler>{
public FloatValueGroup jumpPower = new FloatValueGroup("Jump Power");
public FloatValueGroup jumpPowerDecay = new FloatValueGroup("Jump Power Decay");
public FloatValueGroup gravityPower = new FloatValueGroup("Jump Power");
public FloatValueGroup gravityMax = new FloatValueGroup("Jump Power");
public FloatValueGroup gravityAcceleration = new FloatValueGroup("Jump Power");
public FloatValueGroup gravityScale = new FloatValueGroup("Jump Power");
//Use for initialization. This is called only once in the lifetime of the task.
//Return null if init was successfull. Return an error string otherwise
protected override string OnInit() {
return null;
}
//This is called once each time the task is enabled.
//Call EndAction() to mark the action as finished, either in success or failure.
//EndAction can be called from anywhere.
protected override void OnExecute() {
// Jump
FloatValueGroup.UpdateValue(jumpPower, ref agent.data.jumpPower, ref agent.defaultData.jumpPower);
FloatValueGroup.UpdateValue(jumpPowerDecay, ref agent.data.jumpPowerDecay, ref agent.defaultData.jumpPowerDecay);
// Gravity
FloatValueGroup.UpdateValue(gravityPower, ref agent.data.gravityPower, ref agent.defaultData.gravityPower);
FloatValueGroup.UpdateValue(gravityMax, ref agent.data.gravityMax, ref agent.defaultData.gravityMax);
FloatValueGroup.UpdateValue(gravityAcceleration, ref agent.data.gravityAcceleration, ref agent.defaultData.gravityAcceleration);
FloatValueGroup.UpdateValue(gravityScale, ref agent.data.gravityScale, ref agent.defaultData.gravityScale);
}
//Called once per frame while the action is active.
protected override void OnUpdate() {
}
//Called when the task is disabled.
protected override void OnStop() {
}
//Called when the task is paused.
protected override void OnPause() {
}
}
}

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

@@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: 67c9324e429e09f4da157ab85dadacff

38
Assets/Scripts/Core/Graph Tasks/Movement Settings Changes/ChangeMoveSpeedSettings.cs Normal file
View File

@@ -0,0 +1,38 @@
using NodeCanvas.Framework;
using ParadoxNotion.Design;
namespace Reset.Units {
[Category("Reset/Movement")]
public class ChangeMoveSpeedSettings : ActionTask<UnitMovementHandler> {
//Use for initialization. This is called only once in the lifetime of the task.
//Return null if init was successfull. Return an error string otherwise
protected override string OnInit() {
return null;
}
//This is called once each time the task is enabled.
//Call EndAction() to mark the action as finished, either in success or failure.
//EndAction can be called from anywhere.
protected override void OnExecute() {
EndAction(true);
}
//Called once per frame while the action is active.
protected override void OnUpdate() {
}
//Called when the task is disabled.
protected override void OnStop() {
}
//Called when the task is paused.
protected override void OnPause() {
}
}
}

2
Assets/Scripts/Core/Graph Tasks/Movement Settings Changes/ChangeMoveSpeedSettings.cs.meta Normal file
View File

@@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: c1f858e8bdedb4f46ac3e10c0dccde29

38
Assets/Scripts/Core/Graph Tasks/Movement Settings Changes/ChangeRotationSettings.cs Normal file
View File

@@ -0,0 +1,38 @@
using NodeCanvas.Framework;
using ParadoxNotion.Design;
namespace Reset.Units {
[Category("Reset/Movement")]
public class ChangeRotationSettings : ActionTask<UnitMovementHandler> {
//Use for initialization. This is called only once in the lifetime of the task.
//Return null if init was successfull. Return an error string otherwise
protected override string OnInit() {
return null;
}
//This is called once each time the task is enabled.
//Call EndAction() to mark the action as finished, either in success or failure.
//EndAction can be called from anywhere.
protected override void OnExecute() {
EndAction(true);
}
//Called once per frame while the action is active.
protected override void OnUpdate() {
}
//Called when the task is disabled.
protected override void OnStop() {
}
//Called when the task is paused.
protected override void OnPause() {
}
}
}

2
Assets/Scripts/Core/Graph Tasks/Movement Settings Changes/ChangeRotationSettings.cs.meta Normal file
View File

@@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: 2af547219746e194f97217fe24cfb8cd

653
Assets/Scripts/Core/ValueGroup.cs
View File

@@ -1,496 +1,311 @@
using System;
#if UNITY_EDITOR
using NodeCanvas.Editor;
#endif
using NodeCanvas.Framework;
using ParadoxNotion.Design;
using UnityEditor;
using UnityEngine;
namespace Reset.Core{
// Individual bool setting for each ring. Three of these will be used.
public struct OrbitalFollowValueGroup{
public string label;
public ValueChangeAction changeHeight;
public float height;
public ValueChangeAction changeRadius;
public float radius;
public abstract class ValueGroup{
public interface ISmoothable{
public BBParameter<ValueChangeAction> changeEasing{ get; set; }
public BBParameter<ValueChangeAction> changeSmoothing{ get; set; }
public OrbitalFollowValueGroup(string newLabel){
label = newLabel;
changeHeight = ValueChangeAction.NoChange;
height = 0f;
changeRadius = ValueChangeAction.NoChange;
radius = 0f;
public BBParameter<float> smoothing { get; set; }
public BBParameter<float> easing{ get; set; }
}
public static void ChangeSmoothingEasing(ISmoothable valueGroup, ref float targetSmoothing,
ref float targetEasing, ref float defaultSmoothing, ref float defaultEasing){
switch (valueGroup.changeSmoothing.value) {
case ValueChangeAction.NewValue:
targetSmoothing = valueGroup.smoothing.value;
break;
case ValueChangeAction.ResetValue:
targetSmoothing = defaultSmoothing;
break;
}
switch (valueGroup.changeEasing.value) {
case ValueChangeAction.NewValue:
targetEasing = valueGroup.easing.value;
break;
case ValueChangeAction.ResetValue:
targetEasing = defaultEasing;
break;
}
}
}
// Enum options for individual camera settings
// Enum options for individual settings
public enum ValueChangeAction{
NoChange,
NewValue,
ResetValue,
RelativeValue, // Placeholder for using as altering existing value
}
public struct CurveValueGroup{
// Individual bool setting for each ring. Three of these will be used.
public struct OrbitalFollowValueGroup : ValueGroup.ISmoothable{
public string label;
public AnimationCurve newValue;
public ValueChangeAction changeValue;
public BBParameter<ValueChangeAction> changeHeight;
public BBParameter<float> height;
public BBParameter<ValueChangeAction> changeRadius;
public BBParameter<float> radius;
public BBParameter<ValueChangeAction> changeEasing{ get; set; }
public BBParameter<ValueChangeAction> changeSmoothing{ get; set; }
public BBParameter<float> smoothing{ get; set; }
public BBParameter<float> easing{ get; set; }
public OrbitalFollowValueGroup(string newLabel){
label = newLabel;
changeHeight = ValueChangeAction.NoChange;
height = 0f;
changeRadius = ValueChangeAction.NoChange;
radius = 0f;
changeSmoothing = ValueChangeAction.NoChange;
smoothing = .1f;
changeEasing = ValueChangeAction.NoChange;
easing = 1f;
}
public static void UpdateValue(OrbitalFollowValueGroup valueGroup, ref float targetProperty, ref float defaultProperty){
switch (valueGroup.changeHeight.value) {
case ValueChangeAction.NewValue:
targetProperty = valueGroup.height.value;
break;
case ValueChangeAction.ResetValue:
targetProperty = defaultProperty;
break;
}
switch (valueGroup.changeRadius.value) {
case ValueChangeAction.NewValue:
targetProperty = valueGroup.radius.value;
break;
case ValueChangeAction.ResetValue:
targetProperty = defaultProperty;
break;
}
}
}
public struct CurveValueGroup{ // Done
public string label;
public BBParameter<AnimationCurve> value;
public BBParameter<ValueChangeAction> changeValue;
public CurveValueGroup(string newLabel){
changeValue = ValueChangeAction.NoChange;
newValue = new AnimationCurve();
value = new AnimationCurve();
label = newLabel;
}
public static void UpdateValue(CurveValueGroup valueGroup, ref AnimationCurve targetProperty, ref AnimationCurve defaultProperty){
switch (valueGroup.changeValue.value) {
case ValueChangeAction.NewValue:
targetProperty = valueGroup.value.value;
break;
case ValueChangeAction.ResetValue:
targetProperty = defaultProperty;
break;
}
}
}
public struct EnumValueGroup{
public struct EnumValueGroup{ // Done
public string label;
public Enum newValue;
public BBParameter<Enum> value;
public ValueChangeAction changeValue;
public BBParameter<ValueChangeAction> changeValue;
public EnumValueGroup(string newLabel, Enum enumType){
changeValue = ValueChangeAction.NoChange;
newValue = enumType;
value = enumType;
label = newLabel;
}
public static void UpdateValue(EnumValueGroup valueGroup, ref Enum targetProperty, ref Enum defaultProperty){
switch (valueGroup.changeValue.value) {
case ValueChangeAction.NewValue:
targetProperty = valueGroup.value.value;
break;
case ValueChangeAction.ResetValue:
targetProperty = defaultProperty;
break;
}
}
}
public struct Vector3ValueGroup{
public struct Vector3ValueGroup{ // Done
public string label;
public Vector3 newValue;
public ValueChangeAction changeX;
public ValueChangeAction changeY;
public ValueChangeAction changeZ;
public BBParameter<Vector3> value;
public BBParameter<ValueChangeAction> changeX;
public BBParameter<ValueChangeAction> changeY;
public BBParameter<ValueChangeAction> changeZ;
public Vector3ValueGroup(string newLabel){
changeX = ValueChangeAction.NoChange;
changeY = ValueChangeAction.NoChange;
changeZ = ValueChangeAction.NoChange;
newValue = Vector3.zero;
value = new BBParameter<Vector3>{
value = Vector3.zero
};
label = newLabel;
}
public static void UpdateValue(Vector3ValueGroup valueGroup, ref Vector3 targetProperty, ref Vector3 defaultProperty){
switch (valueGroup.changeX.value) {
case ValueChangeAction.NewValue:
targetProperty.x = valueGroup.value.value.x;
break;
case ValueChangeAction.ResetValue:
targetProperty.x = defaultProperty.x;
break;
}
switch (valueGroup.changeY.value) {
case ValueChangeAction.NewValue:
targetProperty.y = valueGroup.value.value.y;
break;
case ValueChangeAction.ResetValue:
targetProperty.y = defaultProperty.y;
break;
}
switch (valueGroup.changeZ.value) {
case ValueChangeAction.NewValue:
targetProperty.z = valueGroup.value.value.z;
break;
case ValueChangeAction.ResetValue:
targetProperty.z = defaultProperty.z;
break;
}
}
}
public struct Vector2ValueGroup{
public struct Vector2ValueGroup : ValueGroup.ISmoothable{ // Done
public string label;
public Vector2 newValue;
public BBParameter<Vector2> value;
public ValueChangeAction changeX;
public ValueChangeAction changeY;
public BBParameter<ValueChangeAction> changeEasing{ get; set; }
public BBParameter<ValueChangeAction> changeSmoothing{ get; set; }
public BBParameter<float> smoothing{ get; set; }
public BBParameter<float> easing{ get; set; }
public BBParameter<ValueChangeAction> changeX;
public BBParameter<ValueChangeAction> changeY;
public Vector2ValueGroup(string newLabel){
changeX = ValueChangeAction.NoChange;
changeY = ValueChangeAction.NoChange;
newValue = Vector2.zero;
value = new BBParameter<Vector2>{
value = Vector2.zero
};
label = newLabel;
changeEasing = ValueChangeAction.NoChange;
changeSmoothing = ValueChangeAction.NoChange;
smoothing = 0;
easing = 0;
}
public static void UpdateValue(Vector2ValueGroup valueGroup, ref Vector2 targetProperty, ref Vector2 defaultProperty){
switch (valueGroup.changeX.value) {
case ValueChangeAction.NewValue:
targetProperty.x = valueGroup.value.value.x;
break;
case ValueChangeAction.ResetValue:
targetProperty.x = defaultProperty.x;
break;
}
switch (valueGroup.changeY.value) {
case ValueChangeAction.NewValue:
targetProperty.y = valueGroup.value.value.y;
break;
case ValueChangeAction.ResetValue:
targetProperty.y = defaultProperty.y;
break;
}
}
}
public struct FloatValueGroup{
public string label;
// public float value;
public BBParameter<float> value;
public ValueChangeAction changeValue;
public class FloatValueGroup : ValueGroup.ISmoothable{ // Done
public string label;
public BBParameter<ValueChangeAction> changeValue;
public BBParameter<float> value;
public BBParameter<ValueChangeAction> changeEasing{ get; set; }
public BBParameter<ValueChangeAction> changeSmoothing{ get; set; }
public BBParameter<float> smoothing { get; set; }
public BBParameter<float> easing{ get; set; }
public FloatValueGroup(string newLabel){
label = newLabel;
value = new BBParameter<float>().value = 0f;
changeValue = ValueChangeAction.NoChange;
changeSmoothing = ValueChangeAction.NoChange;
smoothing = 0f;
changeEasing = ValueChangeAction.NoChange;
easing = 0f;
}
public static void UpdateValue(FloatValueGroup valueGroup, ref float targetProperty, ref float defaultProperty){
switch (valueGroup.changeValue.value) {
case ValueChangeAction.NewValue:
targetProperty = valueGroup.value.value;
break;
case ValueChangeAction.ResetValue:
targetProperty = defaultProperty;
break;
}
}
}
public struct BoolValueGroup{
public string label;
public bool value;
public BBParameter<bool> value;
public ValueChangeAction changeValue;
public BBParameter<ValueChangeAction> changeValue;
public BoolValueGroup(string newLabel){
label = newLabel;
value = true;
changeValue = ValueChangeAction.NoChange;
}
}
#if UNITY_EDITOR
public class BoolValueGroupDrawer : ObjectDrawer<BoolValueGroup> {
public override BoolValueGroup OnGUI(GUIContent _content, BoolValueGroup _instance){
// Remove label for floats
EditorGUIUtility.labelWidth = 50;
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(80.0f),
GUILayout.MinWidth(20.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(200.0f),
};
// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
GUILayout.BeginVertical();
GUILayout.Label(_instance.label, labelOptions);
GUILayout.BeginHorizontal();
// Create the x settings enum
_instance.changeValue = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeValue);
// Create the value/disabled information field
if (_instance.changeValue == ValueChangeAction.NewValue){
_instance.value = EditorGUILayout.Toggle(_instance.value, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeValue == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close this line up
GUILayout.EndHorizontal();
GUILayout.EndVertical();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
public class CurveVlueGroupDrawer : ObjectDrawer<CurveValueGroup> {
public override CurveValueGroup OnGUI(GUIContent _content, CurveValueGroup _instance){
// Remove label for floats
EditorGUIUtility.labelWidth = 50;
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(80.0f),
GUILayout.MinWidth(20.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(200.0f),
};
// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
GUILayout.BeginVertical();
GUILayout.Label(_instance.label, labelOptions);
GUILayout.BeginHorizontal();
// Create the x settings enum
_instance.changeValue = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeValue);
// Create the value/disabled information field
if (_instance.changeValue == ValueChangeAction.NewValue){
_instance.newValue = EditorGUILayout.CurveField(_instance.newValue, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeValue == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close this line up
GUILayout.EndHorizontal();
GUILayout.EndVertical();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
public class EnumValueGroupDrawer : ObjectDrawer<EnumValueGroup>{
public override EnumValueGroup OnGUI(GUIContent _content, EnumValueGroup _instance){
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(200.0f),
GUILayout.MinWidth(100.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(200.0f),
};
// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
GUILayout.BeginVertical();
GUILayout.Label(_instance.label, labelOptions);
GUILayout.BeginHorizontal();
// Create the x settings enum
_instance.changeValue = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeValue);
// Create the value/disabled information field
if (_instance.changeValue == ValueChangeAction.NewValue){
_instance.newValue = EditorGUILayout.EnumPopup("", instance.newValue, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeValue == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close this line up
GUILayout.EndHorizontal();
GUILayout.EndVertical();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
public class FloatValueGroupDrawer : ObjectDrawer<FloatValueGroup> {
public override FloatValueGroup OnGUI(GUIContent _content, FloatValueGroup _instance){
// Remove label for floats
EditorGUIUtility.labelWidth = 50;
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(80.0f),
GUILayout.MinWidth(20.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(200.0f),
};
// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
GUILayout.BeginVertical();
GUILayout.Label(_instance.label, labelOptions);
GUILayout.BeginHorizontal();
// Create the x settings enum
_instance.changeValue = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeValue);
// Create the value/disabled information field
if (_instance.changeValue == ValueChangeAction.NewValue){
// _instance.value = EditorGUILayout.FloatField(_instance.value, floatOptions);
BBParameterEditor.ParameterField("", _instance.value);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeValue == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
public static void UpdateValue(BoolValueGroup valueGroup, ref bool targetProperty, ref bool defaultProperty){
switch (valueGroup.changeValue.value) {
case ValueChangeAction.NewValue:
targetProperty = valueGroup.value.value;
break;
case ValueChangeAction.ResetValue:
targetProperty = defaultProperty;
break;
}
// Close this line up
GUILayout.EndHorizontal();
GUILayout.EndVertical();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
public class Vector3ValueGroupDrawer : ObjectDrawer<Vector3ValueGroup> {
public override Vector3ValueGroup OnGUI(GUIContent _content, Vector3ValueGroup _instance){
// Remove label for floats
EditorGUIUtility.labelWidth = 20;
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(300.0f),
GUILayout.MinWidth(20.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(200.0f),
};
// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
GUILayout.BeginVertical();
GUILayout.Label(_instance.label, labelOptions);
GUILayout.BeginHorizontal();
// Create the x settings enum
_instance.changeX = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeX);
// Create the value/disabled information field
if (_instance.changeX == ValueChangeAction.NewValue){
_instance.newValue.x = EditorGUILayout.FloatField(_instance.newValue.x, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeX == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// It do what it do.
GUILayout.Space(5);
// Create the y settings enum
_instance.changeY = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeY);
// Create the value/disabled information field
if (_instance.changeY == ValueChangeAction.NewValue){
_instance.newValue.y = EditorGUILayout.FloatField(_instance.newValue.y, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeY == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// It do what it do.
GUILayout.Space(5);
// Create the y settings enum
_instance.changeZ = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeZ);
// Create the value/disabled information field
if (_instance.changeZ == ValueChangeAction.NewValue){
_instance.newValue.z = EditorGUILayout.FloatField(_instance.newValue.z, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeZ == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close this line up
GUILayout.EndHorizontal();
GUILayout.EndVertical();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
public class Vector2ValueGroupDrawer : ObjectDrawer<Vector2ValueGroup> {
public override Vector2ValueGroup OnGUI(GUIContent _content, Vector2ValueGroup _instance){
// Remove label for floats
EditorGUIUtility.labelWidth = 50;
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(300.0f),
GUILayout.MinWidth(20.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(200.0f),
};
// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
GUILayout.BeginVertical();
GUILayout.Label(_instance.label, labelOptions);
GUILayout.BeginHorizontal();
// Create the x settings enum
_instance.changeX = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeX);
// Create the value/disabled information field
if (_instance.changeX == ValueChangeAction.NewValue){
_instance.newValue.x = EditorGUILayout.FloatField(_instance.newValue.x, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeX == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// It do what it do.
GUILayout.Space(5);
// Create the y settings enum
_instance.changeY = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeY);
// Create the value/disabled information field
if (_instance.changeY == ValueChangeAction.NewValue){
_instance.newValue.y = EditorGUILayout.FloatField(_instance.newValue.y, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeY == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close this line up
GUILayout.EndHorizontal();
GUILayout.EndVertical();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
// Custom editor for each orbital follow ring setting
public class OrbitalFollowValueGroupDrawer : ObjectDrawer<OrbitalFollowValueGroup>{
public override OrbitalFollowValueGroup OnGUI(GUIContent _content, OrbitalFollowValueGroup _instance){
// Remove label for floats
EditorGUIUtility.labelWidth = 1;
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(300.0f),
GUILayout.MinWidth(20.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(60.0f),
};
// Start a Horiztonal Section
GUILayout.BeginHorizontal();
// Add the left side label
GUILayout.Label(_instance.label, labelOptions);
// Create the height settings enum
_instance.changeHeight = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeHeight);
// Create the value/disabled information field
if (_instance.changeHeight == ValueChangeAction.NewValue){
_instance.height = EditorGUILayout.FloatField(_instance.height, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeHeight == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// It do what it do.
GUILayout.Space(5);
// Create the radius settings enum
_instance.changeRadius = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeRadius);
// Create the value/disabled information field
if (_instance.changeRadius == ValueChangeAction.NewValue){
_instance.radius = EditorGUILayout.FloatField(_instance.radius, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeRadius == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close this line up
GUILayout.EndHorizontal();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
#endif
}

454
Assets/Scripts/Core/ValueGroupEditors.cs Normal file
View File

@@ -0,0 +1,454 @@
using NodeCanvas.Editor;
using ParadoxNotion.Design;
using Reset.Core;
using UnityEditor;
using UnityEngine;
#if UNITY_EDITOR
public class BoolValueGroupDrawer : ObjectDrawer<BoolValueGroup> {
public override BoolValueGroup OnGUI(GUIContent _content, BoolValueGroup _instance){
// Remove label for floats
EditorGUIUtility.labelWidth = 50;
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(80.0f),
GUILayout.MinWidth(20.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(200.0f),
};
// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
GUILayout.BeginVertical();
GUILayout.Label(_instance.label, labelOptions);
GUILayout.BeginHorizontal();
// Create the x settings enum
_instance.changeValue = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeValue.value);
// Create the value/disabled information field
if (_instance.changeValue.value == ValueChangeAction.NewValue){
_instance.value = EditorGUILayout.Toggle(_instance.value.value, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeValue.value == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close this line up
GUILayout.EndHorizontal();
GUILayout.EndVertical();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
public class CurveValueGroupDrawer : ObjectDrawer<CurveValueGroup> {
public override CurveValueGroup OnGUI(GUIContent _content, CurveValueGroup _instance){
// Remove label for floats
EditorGUIUtility.labelWidth = 50;
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(80.0f),
GUILayout.MinWidth(20.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(200.0f),
};
// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
GUILayout.BeginVertical();
GUILayout.Label(_instance.label, labelOptions);
GUILayout.BeginHorizontal();
// Create the x settings enum
_instance.changeValue.value = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeValue.value);
// Create the value/disabled information field
if (_instance.changeValue.value == ValueChangeAction.NewValue){
BBParameterEditor.ParameterField("", _instance.value);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeValue.value == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close this line up
GUILayout.EndHorizontal();
GUILayout.EndVertical();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
public class EnumValueGroupDrawer : ObjectDrawer<EnumValueGroup>{
public override EnumValueGroup OnGUI(GUIContent _content, EnumValueGroup _instance){
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(200.0f),
GUILayout.MinWidth(100.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(200.0f),
};
// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
GUILayout.BeginVertical();
GUILayout.Label(_instance.label, labelOptions);
GUILayout.BeginHorizontal();
// Create the x settings enum
_instance.changeValue.value = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeValue.value);
// Create the value/disabled information field
if (_instance.changeValue.value == ValueChangeAction.NewValue){
_instance.value.value = EditorGUILayout.EnumPopup("", instance.value.value, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField((ValueChangeAction)_instance.value.value == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close this line up
GUILayout.EndHorizontal();
GUILayout.EndVertical();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
public class FloatValueGroupDrawer : ObjectDrawer<FloatValueGroup> {
public override FloatValueGroup OnGUI(GUIContent _content, FloatValueGroup _instance){
// Remove label for floats
EditorGUIUtility.labelWidth = 50;
// Start the label
GUILayout.BeginHorizontal();
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(80.0f),
GUILayout.MinWidth(20.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(200.0f),
};
GUIStyle titleText = new GUIStyle{
fontSize = 12,
fontStyle = FontStyle.Bold,
padding = new RectOffset(8, 0, 3,0),
normal ={
textColor = Color.white
}
};
// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
GUILayout.Label(_instance.label, titleText);
// End the label
GUILayout.EndHorizontal();
// Start the variables
GUILayout.BeginHorizontal();
// Create the x settings enum
// _instance.changeValue.value = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeValue.value);
BBParameterEditor.ParameterField("", _instance.changeValue);
// Create the value/disabled information field
if (_instance.changeValue.value == ValueChangeAction.NewValue){
// _instance.value = EditorGUILayout.FloatField(_instance.value, floatOptions);
BBParameterEditor.ParameterField("", _instance.value);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeValue.value == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close this line up with the variables
GUILayout.EndHorizontal();
// Start the smoothing and easing section
GUILayout.BeginHorizontal();
GUIStyle smallText= new GUIStyle{
fontSize = 10,
padding = new RectOffset(8, 0, 0,0),
normal ={
textColor = Color.gray
}
};
// Start the left side for easing
GUILayout.BeginVertical();
// Draw the label
GUILayout.BeginHorizontal();
GUILayout.Label("Easing", smallText);
GUILayout.EndHorizontal();
// Easing
_instance.changeEasing.value = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeEasing.value);
if (_instance.changeEasing.value == ValueChangeAction.NewValue){
// _instance.value = EditorGUILayout.FloatField(_instance.value, floatOptions);
BBParameterEditor.ParameterField("", _instance.easing);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeEasing.value == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close easing
GUILayout.EndVertical();
// Start the right for smoothing
GUILayout.BeginVertical();
// Draw the label
GUILayout.BeginHorizontal();
GUILayout.Label("Smoothing", smallText);
GUILayout.EndHorizontal();
// Easing
_instance.changeSmoothing.value = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeSmoothing.value);
if (_instance.changeSmoothing.value == ValueChangeAction.NewValue){
// _instance.value = EditorGUILayout.FloatField(_instance.value, floatOptions);
BBParameterEditor.ParameterField("", _instance.smoothing);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeSmoothing.value == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close easing
GUILayout.EndVertical();
GUILayout.Space(8);
GUILayout.EndHorizontal();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
public class Vector3ValueGroupDrawer : ObjectDrawer<Vector3ValueGroup> {
public override Vector3ValueGroup OnGUI(GUIContent _content, Vector3ValueGroup _instance){
// Remove label for floats
EditorGUIUtility.labelWidth = 20;
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(300.0f),
GUILayout.MinWidth(20.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(200.0f),
};
// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
GUILayout.BeginVertical();
GUILayout.Label(_instance.label, labelOptions);
GUILayout.BeginHorizontal();
// Create the x settings enum
_instance.changeX.value = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeX.value);
// Create the value/disabled information field
if (_instance.changeX.value== ValueChangeAction.NewValue) {
var value = _instance.value.value;
value.x = EditorGUILayout.FloatField(_instance.value.value.x, floatOptions);
_instance.value.value = value;
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeX.value == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// It do what it do.
GUILayout.Space(5);
// Create the y settings enum
_instance.changeY.value = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeY.value);
// Create the value/disabled information field
if (_instance.changeY.value == ValueChangeAction.NewValue) {
var value = _instance.value.value;
value.y = EditorGUILayout.FloatField(_instance.value.value.y, floatOptions);
_instance.value.value = value;
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeY.value == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// It do what it do.
GUILayout.Space(5);
// Create the y settings enum
_instance.changeZ.value = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeZ.value);
// Create the value/disabled information field
if (_instance.changeZ.value == ValueChangeAction.NewValue) {
var value = _instance.value.value;
value.z = EditorGUILayout.FloatField(_instance.value.value.z, floatOptions);
_instance.value.value = value;
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeZ.value == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close this line up
GUILayout.EndHorizontal();
GUILayout.EndVertical();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
public class Vector2ValueGroupDrawer : ObjectDrawer<Vector2ValueGroup> {
public override Vector2ValueGroup OnGUI(GUIContent _content, Vector2ValueGroup _instance){
// Remove label for floats
EditorGUIUtility.labelWidth = 50;
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(300.0f),
GUILayout.MinWidth(20.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(200.0f),
};
// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
GUILayout.BeginVertical();
GUILayout.Label(_instance.label, labelOptions);
GUILayout.BeginHorizontal();
// Create the x settings enum
_instance.changeX.value = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeX.value);
// Create the value/disabled information field
if (_instance.changeX.value == ValueChangeAction.NewValue) {
var value = _instance.value.value;
value.x = EditorGUILayout.FloatField(_instance.value.value.x, floatOptions);
_instance.value.value = value;
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeX.value == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// It do what it do.
GUILayout.Space(5);
// Create the y settings enum
_instance.changeY.value = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeY.value);
// Create the value/disabled information field
if (_instance.changeY.value == ValueChangeAction.NewValue) {
var value = _instance.value.value;
value.y = EditorGUILayout.FloatField(_instance.value.value.y, floatOptions);
_instance.value.value = value;
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeY.value == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close this line up
GUILayout.EndHorizontal();
GUILayout.EndVertical();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
// Custom editor for each orbital follow ring setting
public class OrbitalFollowValueGroupDrawer : ObjectDrawer<OrbitalFollowValueGroup>{
public override OrbitalFollowValueGroup OnGUI(GUIContent _content, OrbitalFollowValueGroup _instance){
// Remove label for floats
EditorGUIUtility.labelWidth = 1;
// Set layout options for the label and the float fields
GUILayoutOption[] floatOptions = new GUILayoutOption[] {
GUILayout.Width(300.0f),
GUILayout.MinWidth(20.0f),
GUILayout.ExpandWidth(true),
};
GUILayoutOption[] labelOptions = new GUILayoutOption[]{
GUILayout.Width(60.0f),
};
// Start a Horiztonal Section
GUILayout.BeginHorizontal();
// Add the left side label
GUILayout.Label(_instance.label, labelOptions);
// Create the height settings enum
_instance.changeHeight.value = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeHeight.value);
// Create the value/disabled information field
if (_instance.changeHeight.value == ValueChangeAction.NewValue){
_instance.height.value = EditorGUILayout.FloatField(_instance.height.value, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeHeight.value == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// It do what it do.
GUILayout.Space(5);
// Create the radius settings enum
_instance.changeRadius.value = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeRadius.value);
// Create the value/disabled information field
if (_instance.changeRadius.value == ValueChangeAction.NewValue){
_instance.radius = EditorGUILayout.FloatField(_instance.radius.value, floatOptions);
} else {
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField(_instance.changeRadius.value == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
EditorGUI.EndDisabledGroup();
}
// Close this line up
GUILayout.EndHorizontal();
// Reset to default so the rest of things don't get messed up
EditorGUIUtility.labelWidth = 0;
return _instance;
}
}
#endif

3
Assets/Scripts/Core/ValueGroupEditors.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: e327ef0e278a437486396775f36450dd
timeCreated: 1758039991

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

@@ -1,82 +1,68 @@
using System;
using Reset.Core;
using Sirenix.OdinInspector;
using Unity.Cinemachine;
using UnityEngine;
public struct CameraSettingSingleValue<T>{
// NOTE: Could add a locked variable here if needed??
public T originalValue;
public T targetValue;
public float smoothing;
public struct SettingValue<T>{
public T value;
public float smoothing; // Smoothing changes how fast value is changed.
public float easing; // Easing changes how fast smoothing is changed, when given a new value.
public float currentSmoothing; // Actively eased and accessed value
public float currentValue; // Actively smoothed and accessed value
public T refVel; // For use with SmoothDamp
public float velocityRef;
public Vector2 velocityRefV2;
public Vector3 velocityRefV3;
public CameraSettingSingleValue(float defaultSmoothing = .2f, T original = default(T)){
originalValue = original;
targetValue = original;
public SettingValue(float defaultEasing = 2f, float defaultSmoothing = 1f){
easing = defaultEasing;
value = default;
smoothing = defaultSmoothing;
velocityRef = 0;
velocityRefV2 = default;
velocityRefV3 = default;
}
public void Reset(){
targetValue = originalValue;
currentSmoothing = 0;
currentValue = 0;
refVel = default;
}
}
public struct CameraSettingValues{
public CameraSettingSingleValue<float> mainFieldOfView;
public struct CameraSettingData : ICloneable{
public SettingValue<float> mainFieldOfView;
public CameraSettingSingleValue<Vector3> orbitPositionDamping;
public CameraSettingSingleValue<Vector3> orbitTargetOffset;
public SettingValue<Vector3> orbitPositionDamping;
public SettingValue<Vector3> orbitTargetOffset;
public CameraSettingSingleValue<bool> axisLookEnabledX;
public CameraSettingSingleValue<bool> axisLookEnabledY;
public SettingValue<bool> axisLookEnabledX;
public SettingValue<bool> axisLookEnabledY;
public CameraSettingSingleValue<float> axisLookGainX;
public CameraSettingSingleValue<float> axisLookGainY;
public SettingValue<float> axisLookGainX;
public SettingValue<float> axisLookGainY;
public CameraSettingSingleValue<float> orbitFollowTopHeight;
public CameraSettingSingleValue<float> orbitFollowTopRadius;
public CameraSettingSingleValue<float> orbitFollowCenterHeight;
public CameraSettingSingleValue<float> orbitFollowCenterRadius;
public CameraSettingSingleValue<float> orbitFollowBottomHeight;
public CameraSettingSingleValue<float> orbitFollowBottomRadius;
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 CameraSettingSingleValue<Vector2> rotationComposerScreenPos;
public SettingValue<Vector2> rotationComposerScreenPos;
public CameraSettingSingleValue<Vector3> cameraOffsetOffset;
public CameraSettingValues(float defaultSmoothing){
mainFieldOfView = new CameraSettingSingleValue<float>(defaultSmoothing);
orbitPositionDamping = new CameraSettingSingleValue<Vector3>(defaultSmoothing);
orbitTargetOffset = new CameraSettingSingleValue<Vector3>(defaultSmoothing);
axisLookEnabledX = new CameraSettingSingleValue<bool>();
axisLookEnabledY = new CameraSettingSingleValue<bool>();
axisLookGainX = new CameraSettingSingleValue<float>(defaultSmoothing);
axisLookGainY = new CameraSettingSingleValue<float>(defaultSmoothing);
orbitFollowTopHeight = new CameraSettingSingleValue<float>(defaultSmoothing);
orbitFollowTopRadius = new CameraSettingSingleValue<float>(defaultSmoothing);
orbitFollowCenterHeight = new CameraSettingSingleValue<float>(defaultSmoothing);
orbitFollowCenterRadius = new CameraSettingSingleValue<float>(defaultSmoothing);
orbitFollowBottomHeight = new CameraSettingSingleValue<float>(defaultSmoothing);
orbitFollowBottomRadius = new CameraSettingSingleValue<float>(defaultSmoothing);
rotationComposerScreenPos = new CameraSettingSingleValue<Vector2>(defaultSmoothing);
cameraOffsetOffset = new CameraSettingSingleValue<Vector3>(defaultSmoothing);
public SettingValue<Vector3> cameraOffsetOffset;
public object Clone(){
return MemberwiseClone();
}
}
public class CameraSettingsProcessor : MonoBehaviour{
public static CameraSettingsProcessor Instance{ get; private set; }
public static CameraSettingValues values = new(defaultSmoothing: .2f);
[HideInInspector] public static CameraSettingData data;
[HideInInspector] public static CameraSettingData original;
[ShowInInspector] public static CameraSettingData smoothing;
[ShowInInspector] public static CameraSettingData easing;
[HideInInspector] public static CameraSettingData currentSmoothing;
[HideInInspector] public static CameraSettingData currentValue;
public static GameObject mainCamera;
@@ -102,87 +88,112 @@ public class CameraSettingsProcessor : MonoBehaviour{
offset = mainCamera.GetComponent<CinemachineCameraOffset>();
axisCont = mainCamera.GetComponent<CinemachineInputAxisController>();
// Initialize camera settings values
values = new CameraSettingValues{
cameraOffsetOffset = new CameraSettingSingleValue<Vector3>(defaultSmoothing: .2f, offset.Offset),
mainFieldOfView = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, main.Lens.FieldOfView),
axisLookEnabledX = new CameraSettingSingleValue<bool>(0, axisCont.Controllers[0].Enabled),
axisLookEnabledY = new CameraSettingSingleValue<bool>(0, axisCont.Controllers[1].Enabled),
axisLookGainX = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, axisCont.Controllers[0].Input.Gain),
axisLookGainY = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, axisCont.Controllers[1].Input.Gain),
orbitPositionDamping = new CameraSettingSingleValue<Vector3>(defaultSmoothing: .2f, orbit.TrackerSettings.PositionDamping),
orbitTargetOffset = new CameraSettingSingleValue<Vector3>(defaultSmoothing: .1f, orbit.TargetOffset),
orbitFollowTopHeight = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, orbit.Orbits.Top.Height),
orbitFollowTopRadius = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, orbit.Orbits.Top.Radius),
orbitFollowCenterHeight = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, orbit.Orbits.Center.Height),
orbitFollowCenterRadius = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, orbit.Orbits.Center.Radius),
orbitFollowBottomHeight = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, orbit.Orbits.Bottom.Height),
orbitFollowBottomRadius = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, orbit.Orbits.Bottom.Radius),
rotationComposerScreenPos = new CameraSettingSingleValue<Vector2>(defaultSmoothing: .2f, rotComp.Composition.ScreenPosition),
};
}
void ProcessCameraValues(){
main.Lens.FieldOfView = Mathf.SmoothDamp(main.Lens.FieldOfView,
values.mainFieldOfView.targetValue, ref values.mainFieldOfView.velocityRef,
values.mainFieldOfView.smoothing);
// Initialize camera settings values from current values
data.mainFieldOfView.value = main.Lens.FieldOfView;
data.orbitPositionDamping.value = orbit.TrackerSettings.PositionDamping;
data.orbitTargetOffset.value = orbit.TargetOffset;
axisCont.Controllers[0].Enabled = values.axisLookEnabledX.targetValue;
data.axisLookEnabledX.value = axisCont.Controllers[0].Enabled;
data.axisLookEnabledY.value = axisCont.Controllers[1].Enabled;
axisCont.Controllers[1].Enabled = values.axisLookEnabledY.targetValue;
data.axisLookGainX.value = axisCont.Controllers[0].Input.Gain;
data.axisLookGainY.value = axisCont.Controllers[1].Input.Gain;
axisCont.Controllers[0].Input.Gain = Mathf.SmoothDamp(axisCont.Controllers[0].Input.Gain,
values.axisLookGainX.targetValue, ref values.axisLookGainX.velocityRef,
values.axisLookGainX.smoothing);
axisCont.Controllers[1].Input.Gain = Mathf.SmoothDamp(axisCont.Controllers[1].Input.Gain,
values.axisLookGainY.targetValue, ref values.axisLookGainY.velocityRef,
values.axisLookGainY.smoothing);
orbit.TargetOffset = Vector3.SmoothDamp(orbit.TargetOffset,
values.orbitTargetOffset.targetValue, ref values.orbitTargetOffset.velocityRefV3,
values.orbitTargetOffset.smoothing);
orbit.TrackerSettings.PositionDamping = Vector3.SmoothDamp(orbit.TrackerSettings.PositionDamping,
values.orbitPositionDamping.targetValue, ref values.orbitPositionDamping.velocityRefV3,
values.orbitPositionDamping.smoothing);
orbit.Orbits.Top.Height = Mathf.SmoothDamp(orbit.Orbits.Top.Height,
values.orbitFollowTopHeight.targetValue, ref values.orbitFollowTopHeight.velocityRef,
values.orbitFollowTopHeight.smoothing);
orbit.Orbits.Top.Radius = Mathf.SmoothDamp(orbit.Orbits.Top.Radius,
values.orbitFollowTopRadius.targetValue, ref values.orbitFollowTopRadius.velocityRef,
values.orbitFollowTopRadius.smoothing);
orbit.Orbits.Center.Height = Mathf.SmoothDamp(orbit.Orbits.Center.Height,
values.orbitFollowCenterHeight.targetValue, ref values.orbitFollowCenterHeight.velocityRef,
values.orbitFollowCenterHeight.smoothing);
orbit.Orbits.Center.Radius = Mathf.SmoothDamp(orbit.Orbits.Center.Radius,
values.orbitFollowCenterRadius.targetValue, ref values.orbitFollowCenterRadius.velocityRef,
values.orbitFollowCenterRadius.smoothing);
orbit.Orbits.Bottom.Height = Mathf.SmoothDamp(orbit.Orbits.Bottom.Height,
values.orbitFollowBottomHeight.targetValue, ref values.orbitFollowBottomHeight.velocityRef,
values.orbitFollowBottomHeight.smoothing);
orbit.Orbits.Bottom.Radius = Mathf.SmoothDamp(orbit.Orbits.Bottom.Radius,
values.orbitFollowBottomRadius.targetValue, ref values.orbitFollowBottomRadius.velocityRef,
values.orbitFollowBottomRadius.smoothing);
data.orbitFollowTopHeight.value = orbit.Orbits.Top.Height;
data.orbitFollowTopRadius.value = orbit.Orbits.Top.Radius;
data.orbitFollowCenterHeight.value = orbit.Orbits.Center.Height;
data.orbitFollowCenterRadius.value = orbit.Orbits.Center.Radius;
data.orbitFollowBottomHeight.value = orbit.Orbits.Bottom.Height;
data.orbitFollowBottomRadius.value = orbit.Orbits.Bottom.Radius;
rotComp.Composition.ScreenPosition = Vector2.SmoothDamp(rotComp.Composition.ScreenPosition,
values.rotationComposerScreenPos.targetValue, ref values.rotationComposerScreenPos.velocityRefV2,
values.rotationComposerScreenPos.smoothing);
offset.Offset = Vector3.SmoothDamp(offset.Offset,
values.cameraOffsetOffset.targetValue, ref values.cameraOffsetOffset.velocityRefV3,
values.cameraOffsetOffset.smoothing);
data.rotationComposerScreenPos.value = rotComp.Composition.ScreenPosition;
data.cameraOffsetOffset.value = offset.Offset;
// And copy to the original
original = (CameraSettingData)data.Clone();
}
void Update(){
EaseToNewSmoothingValues();
ProcessCameraValues();
}
void EaseToNewSmoothingValues(){
data.mainFieldOfView.currentSmoothing = Mathf.MoveTowards(data.mainFieldOfView.currentSmoothing, data.mainFieldOfView.smoothing, data.mainFieldOfView.easing * Time.deltaTime);
data.orbitPositionDamping.currentSmoothing = Mathf.MoveTowards(data.orbitPositionDamping.currentSmoothing, data.orbitPositionDamping.smoothing, easing.orbitPositionDamping.easing * Time.deltaTime);
data.orbitTargetOffset.currentSmoothing = Mathf.MoveTowards(data.mainFieldOfView.currentSmoothing, data.mainFieldOfView.smoothing, easing.mainFieldOfView.easing * Time.deltaTime);
data.axisLookGainX.currentSmoothing = Mathf.MoveTowards(data.mainFieldOfView.currentSmoothing, data.mainFieldOfView.smoothing, easing.mainFieldOfView.easing * Time.deltaTime);
data.axisLookGainY.currentSmoothing = Mathf.MoveTowards(data.mainFieldOfView.currentSmoothing, data.mainFieldOfView.smoothing, easing.mainFieldOfView.easing * Time.deltaTime);
data.orbitFollowTopHeight.currentSmoothing = Mathf.MoveTowards(data.mainFieldOfView.currentSmoothing, data.mainFieldOfView.smoothing, easing.mainFieldOfView.easing * Time.deltaTime);
data.orbitFollowTopRadius.currentSmoothing = Mathf.MoveTowards(data.mainFieldOfView.currentSmoothing, data.mainFieldOfView.smoothing, easing.mainFieldOfView.easing * Time.deltaTime);
data.orbitFollowCenterHeight.currentSmoothing = Mathf.MoveTowards(data.mainFieldOfView.currentSmoothing, data.mainFieldOfView.smoothing, easing.mainFieldOfView.easing * Time.deltaTime);
data.orbitFollowCenterRadius.currentSmoothing = Mathf.MoveTowards(data.mainFieldOfView.currentSmoothing, data.mainFieldOfView.smoothing, easing.mainFieldOfView.easing * Time.deltaTime);
data.orbitFollowBottomHeight.currentSmoothing = Mathf.MoveTowards(data.mainFieldOfView.currentSmoothing, data.mainFieldOfView.smoothing, easing.mainFieldOfView.easing * Time.deltaTime);
data.orbitFollowBottomRadius.currentSmoothing = Mathf.MoveTowards(data.mainFieldOfView.currentSmoothing, data.mainFieldOfView.smoothing, easing.mainFieldOfView.easing * Time.deltaTime);
data.rotationComposerScreenPos.currentSmoothing = Mathf.MoveTowards(data.mainFieldOfView.currentSmoothing, data.mainFieldOfView.smoothing, easing.mainFieldOfView.easing * Time.deltaTime);
data.cameraOffsetOffset.currentSmoothing = Mathf.MoveTowards(data.mainFieldOfView.currentSmoothing, data.mainFieldOfView.smoothing, easing.mainFieldOfView.easing * Time.deltaTime);
}
void ProcessCameraValues(){
main.Lens.FieldOfView = Mathf.SmoothDamp(main.Lens.FieldOfView,
data.mainFieldOfView.value, ref data.mainFieldOfView.refVel,
data.mainFieldOfView.smoothing);
axisCont.Controllers[0].Enabled = data.axisLookEnabledX.value;
axisCont.Controllers[1].Enabled = data.axisLookEnabledY.value;
axisCont.Controllers[0].Input.Gain = Mathf.SmoothDamp(axisCont.Controllers[0].Input.Gain,
data.axisLookGainX.value, ref data.axisLookGainX.refVel,
data.axisLookGainX.smoothing);
axisCont.Controllers[1].Input.Gain = Mathf.SmoothDamp(axisCont.Controllers[1].Input.Gain,
data.axisLookGainY.value, ref data.axisLookGainY.refVel,
data.axisLookGainY.smoothing);
orbit.TargetOffset = Vector3.SmoothDamp(orbit.TargetOffset,
data.orbitTargetOffset.value, ref data.orbitTargetOffset.refVel,
data.orbitTargetOffset.smoothing);
orbit.TrackerSettings.PositionDamping = Vector3.SmoothDamp(orbit.TrackerSettings.PositionDamping,
data.orbitPositionDamping.value, ref data.orbitPositionDamping.refVel,
data.orbitPositionDamping.smoothing);
orbit.Orbits.Top.Height = Mathf.SmoothDamp(orbit.Orbits.Top.Height,
data.orbitFollowTopHeight.value, ref data.orbitFollowTopHeight.refVel,
data.orbitFollowTopHeight.smoothing);
orbit.Orbits.Top.Radius = Mathf.SmoothDamp(orbit.Orbits.Top.Radius,
data.orbitFollowTopRadius.value, ref data.orbitFollowTopRadius.refVel,
data.orbitFollowTopRadius.smoothing);
orbit.Orbits.Center.Height = Mathf.SmoothDamp(orbit.Orbits.Center.Height,
data.orbitFollowCenterHeight.value, ref data.orbitFollowCenterHeight.refVel,
data.orbitFollowCenterHeight.smoothing);
orbit.Orbits.Center.Radius = Mathf.SmoothDamp(orbit.Orbits.Center.Radius,
data.orbitFollowCenterRadius.value, ref data.orbitFollowCenterRadius.refVel,
data.orbitFollowCenterRadius.smoothing);
orbit.Orbits.Bottom.Height = Mathf.SmoothDamp(orbit.Orbits.Bottom.Height,
data.orbitFollowBottomHeight.value, ref data.orbitFollowBottomHeight.refVel,
data.orbitFollowBottomHeight.smoothing);
orbit.Orbits.Bottom.Radius = Mathf.SmoothDamp(orbit.Orbits.Bottom.Radius,
data.orbitFollowBottomRadius.value, ref data.orbitFollowBottomRadius.refVel,
data.orbitFollowBottomRadius.smoothing);
rotComp.Composition.ScreenPosition = Vector2.SmoothDamp(rotComp.Composition.ScreenPosition,
data.rotationComposerScreenPos.value, ref data.rotationComposerScreenPos.refVel,
data.rotationComposerScreenPos.smoothing);
offset.Offset = Vector3.SmoothDamp(offset.Offset,
data.cameraOffsetOffset.value, ref data.cameraOffsetOffset.refVel,
data.cameraOffsetOffset.smoothing);
}
}

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

@@ -1,10 +1,8 @@
using System;
using NUnit.Framework.Internal;
using UnityEngine;
using ParadoxNotion.Design;
using PlasticPipe.PlasticProtocol.Messages;
using Sirenix.OdinInspector;
using UnityEngine.Serialization;
using Quaternion = UnityEngine.Quaternion;
public enum PlayerFacingDirection{
TowardsTarget = 0,
@@ -26,8 +24,7 @@ namespace Reset.Units{
// Movement Direction
public float accelerationSmoothing = 5f;
public float deaccelerationSmoothing = 5f;
// public AnimationCurve deaccelerationCurve; // Currently unused, may return
[SliderField(0,1)]
public float airDirectionDecay;
@@ -47,9 +44,8 @@ namespace Reset.Units{
public float settingsChangeSmoothing = 6f;
// Rotation
[ShowInInspector, SerializeReference]
public Enum rotateFacing;
[FormerlySerializedAs("rotationSpeedTarget")] public float rotationSpeed = 5f;
[ShowInInspector, SerializeReference] public Enum rotateFacing;
public float rotationSpeed = 5f;
public float rotationSmoothing = 1f;
public float rotationInputBlending = .3f;
@@ -57,8 +53,38 @@ namespace Reset.Units{
return MemberwiseClone();
}
}
public class ResolvedMovement{
public UnitMovementHandler.MoveDirection moveDirection;
public float moveSpeed;
public Quaternion rotation;
public float rotationSpeed;
public float gravity;
}
public class UnitMovementHandler : MonoBehaviour{
public struct MoveDirection{
private Transform owner;
private Vector2 moveDir; // Always local
public Vector2 World{
get => owner.TransformDirection(Local);
set{
moveDir = owner.InverseTransformDirection(value);
Local = moveDir;
}
}
public Vector2 Local{
get => owner.InverseTransformDirection(World);
set {
moveDir = value;
World = owner.TransformDirection(value);
}
}
}
// class MovementFloatModifier{
// // IBuffSource source
// public float value;
@@ -79,25 +105,24 @@ namespace Reset.Units{
[FoldoutGroup("Smoothed Values"), ShowInInspector, ReadOnly] private float smoothedGravityScale;
[FoldoutGroup("Smoothed Values"), ShowInInspector, ReadOnly] private float settingsChangeRotationSpeed;
private float directionChangeDot;
private bool moveCallDisabledNextFrame;
private bool movedThisFrame;
// Lerps
private float directionChangeDotLerp;
private Vector3 moveSmoothVelocityRef;
private float gravitySmoothVelocityRef;
// References
private CharacterController controller;
private PlayerControls controls;
private LockOnManager lockOnManager;
private Vector3 moveSmooth;
public float gravitySmooth;
private bool relativeToCamera;
// Movement Data
[ShowInInspector, PropertyOrder(2)] public UnitMovementData data = new();
[ShowInInspector, PropertyOrder(2)] public UnitMovementData smoothing = new();
[ShowInInspector, PropertyOrder(2)] public UnitMovementData easing = new();
[ShowInInspector, PropertyOrder(2)]
public UnitMovementData data = new();
[HideInInspector]
public UnitMovementData defaultData;
[HideInInspector] public UnitMovementData defaultData;
[HideInInspector] public UnitMovementData defaultSmoothing;
[HideInInspector] public UnitMovementData defaultEasing;
void Awake(){
controller = GetComponent<CharacterController>();
@@ -105,15 +130,16 @@ namespace Reset.Units{
lockOnManager = GetComponent<LockOnManager>();
}
private void Start(){
void Start(){
defaultData = (UnitMovementData)data.Clone();
defaultSmoothing = (UnitMovementData)smoothing.Clone();
defaultEasing = (UnitMovementData)easing.Clone();
}
void Update(){
UpdateCurrentDirection();
UpdateCurrentGravity();
UpdateCurrentSpeed();
UpdateCurrentRotation();
DoMovement();
@@ -188,7 +214,7 @@ namespace Reset.Units{
float switchedDirection = Vector3.Dot(inputMovement, outputMoveDirection);
float switchedDirectionRemapped = Mathf.Lerp(0, 1, switchedDirection);
directionChangeDot = Mathf.Lerp(switchedDirection, switchedDirectionRemapped, 5f * Time.deltaTime) ; // turn that .5f into a variable
directionChangeDotLerp = Mathf.Lerp(switchedDirection, switchedDirectionRemapped, 5f * Time.deltaTime) ; // turn that .5f into a variable
// 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
@@ -197,7 +223,7 @@ namespace Reset.Units{
slerpedValue = Vector3.Slerp(currentNoY, targetNoY, data.accelerationSmoothing * Time.deltaTime);
lerpedValue = Vector3.Lerp(currentNoY, targetNoY, data.accelerationSmoothing * Time.deltaTime);
currentNoY = Vector3.Lerp(lerpedValue, slerpedValue, directionChangeDot);
currentNoY = Vector3.Lerp(lerpedValue, slerpedValue, directionChangeDotLerp);
} else {
currentNoY = Vector3.Lerp(currentNoY, targetNoY, data.accelerationSmoothing * Time.deltaTime);
}
@@ -206,14 +232,14 @@ namespace Reset.Units{
slerpedValue = Vector3.Slerp(currentNoY, targetNoY, data.deaccelerationSmoothing * Time.deltaTime);
lerpedValue = Vector3.Lerp(currentNoY, targetNoY, data.deaccelerationSmoothing * Time.deltaTime);
currentNoY = Vector3.Lerp(lerpedValue, slerpedValue, directionChangeDot);
currentNoY = Vector3.Lerp(lerpedValue, slerpedValue, directionChangeDotLerp);
} else {
currentNoY = Vector3.Lerp(currentNoY, targetNoY, data.deaccelerationSmoothing * data.airDirectionDecay * Time.deltaTime);
}
}
// Commit move direction
outputMoveDirection = Vector3.SmoothDamp(outputMoveDirection, new Vector3(currentNoY.x, outputMoveDirection.y, currentNoY.z),ref moveSmooth , .5f *Time.deltaTime);
outputMoveDirection = Vector3.SmoothDamp(outputMoveDirection, new Vector3(currentNoY.x, outputMoveDirection.y, currentNoY.z),ref moveSmoothVelocityRef , .5f *Time.deltaTime);
}
// Update the speed, called every frame
@@ -237,7 +263,7 @@ namespace Reset.Units{
float gravityMoveDirection = data.jumpPower + (Physics.gravity.y * data.gravityPower);
// Commit gravity to move direction, ignoring XZ since those are done in UpdateMovementDirection
outputMoveDirection.y = Mathf.SmoothDamp(outputMoveDirection.y, gravityMoveDirection, ref gravitySmooth, .1f * Time.deltaTime);
outputMoveDirection.y = Mathf.SmoothDamp(outputMoveDirection.y, gravityMoveDirection, ref gravitySmoothVelocityRef, .1f * Time.deltaTime);
}
// Update the rotation, called every frame
@@ -294,10 +320,6 @@ namespace Reset.Units{
public void DoMovement(){
DoMovement(outputMoveDirection, outputSpeed, data.gravityScale);
}
public void DisableNextMoveCall(){
moveCallDisabledNextFrame = true;
}
// Custom move from input
public void DoMovement(Vector3 moveDir, float speed, float gravityScale){