changed: more robust environment observers, player graph changes

Assets/Player/Graphs/PlayerLocomotionFSM.asset

@@ -21,7 +21,7 @@ MonoBehaviour:
     _version: 3.31
     _category: 
     _comments: 
-    _translation: {x: 1, y: -175}
+    _translation: {x: 21, y: -46}
     _zoomFactor: 0.9967056
   _haltSerialization: 0
   _externalSerializationFile: {fileID: 0}

Assets/Scripts/Core/Graph Tasks/CheckEnvironmentObserver.cs

@@ -9,6 +9,7 @@ namespace NodeCanvas.Tasks.Conditions {
 		public BBParameter<string> observerLabel;
 		public BBParameter<RaycastHit> outputHitTo;
 		
+		
 		//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(){

Assets/Scripts/Player/PlayerEnvironmentManager.cs

@@ -9,9 +9,6 @@ using UnityEngine.Serialization;
 
 [Serializable]
 public class EnvironmentObserver{
-    // TODO: Clean this ugly shit up. Custom inspector with Odin plz.
-    public string label;
-
     enum LabelDrawingLocation{
         PlayerOffset,
         HitLocation,
@@ -26,10 +23,12 @@ public class EnvironmentObserver{
         SphereCast
     }
     
-    // [BoxGroup("Settings")]
+    [PropertySpace(0, 5), LabelWidth(60)]
-    [ShowInInspector, SerializeField] public CastType castType;
+    public string label;
+    [PropertySpace(0, 10), LabelWidth(60)]
+    public CastType castType;
 
-    [Button(ButtonSizes.Large), GUIColor("@GetObserverStatusColorStatic(active, hit)")]
+    [Button(ButtonSizes.Large), GUIColor("@GetObserverStatusColorStatic(active, hit)"), PropertyOrder(-1), PropertySpace(5, 5)]
     public void Active(){
         active = !active;
     }
@@ -38,45 +37,43 @@ public class EnvironmentObserver{
     public bool active;
 
     // Parameters for Cast cast types
-    [BoxGroup("Settings")]
+    [FoldoutGroup("Settings")] public float length;
-    public float length;
+    [FoldoutGroup("Settings")] public Vector3 direction;
-    [BoxGroup("Settings")]
+    [FoldoutGroup("Settings")] public Vector3 offset;
-    public Vector3 direction;
+    [PropertySpace(0, 5), FoldoutGroup("Settings")] public LayerMask ignoreLayers = ~0;
-    [BoxGroup("Settings")]
-    public Vector3 offset;
     
-    [ShowIfGroup("Settings/Casts3D", VisibleIf = "@castType == CastType.Ray || castType == CastType.BoxCast || castType == CastType.SphereCast")]
-    [BoxGroup("Settings/Casts3D")]
-    public float width;
 
+    [ShowIfGroup("Settings/CastsOnly", VisibleIf = "@castType == CastType.SphereCast || castType == CastType.SphereOverlap")]
+    [FoldoutGroup("Settings")] public float width;
 
     // Parameters for Overlap cast types
-    [BoxGroup("Settings/Overlaps")]
+    [ShowIfGroup("Settings/3DOnly", VisibleIf = "@castType == CastType.BoxCast && castType != CastType.BoxOverlap")]    [FoldoutGroup("Settings")]
     public Vector3 size;
     
-    [PropertyTooltip(
+    [ShowIfGroup("Settings/3DOnly")]
-        "Only use rotation when an observers direction alone can't (for whatever reason) fully be expressed without specifying a rotation.")]
-    [ShowIfGroup("Settings/Casts3D")]
-    [BoxGroup("Settings/Casts3D")]
     public Vector3 rotation;
 
-    [BoxGroup("Settings")]
+    [HideInInspector]
-    public LayerMask ignoreLayers = ~0;
-
     public RaycastHit hit;
 
-    [SerializeReference]
-    public List<EnvironmentObserver> children;
-
     [HideInInspector]
     public Collider[] overlapHits;
 
-    public bool drawLabel;
+    [FoldoutGroup("Text")]
-    public Vector3 labelLocationOffset;
+    [BoxGroup("Text/Label")] public bool drawLabel;
-    public Vector3 labelRotationOffset;
+    [ShowInInspector, SerializeField] [BoxGroup("Text/Label")] LabelDrawingLocation labelTextLocation;
+    [BoxGroup("Text/Label")] public float labelSize;
+    [BoxGroup("Text/Label")] public Vector3 labelLocationOffset;
+    [BoxGroup("Text/Label")] public Vector3 labelRotationOffset;
 
-    [ShowInInspector, SerializeField]
+    [BoxGroup("Text/Hit")] public bool drawHitName;
-    LabelDrawingLocation labelLocation;
+    [ShowInInspector, SerializeField] [BoxGroup("Text/Hit")] LabelDrawingLocation hitTextLocation;
+    [BoxGroup("Text/Hit")] public float hitTextSize;
+    [BoxGroup("Text/Hit")] public Vector3 hitLocationOffset;
+    [BoxGroup("Text/Hit")] public Vector3 hitRotationOffset;
+
+    [SerializeReference, PropertySpace(5, 5)]
+    public List<EnvironmentObserver> children;
 
     // NOTE: I had a ref for a RaycastHit here that would correspond to hit but idk if it's needed.
     public bool Evaluate(GameObject player){
@@ -86,7 +83,7 @@ public class EnvironmentObserver{
             
             // Set some of the variables used later during casting
             Vector3 relativeStart = player.transform.position + offset;
-            Vector3 relativeStartWithRotation = player.transform.position + player.transform.rotation * (offset) ;
+            Vector3 relativeStartWithRotation = player.transform.position + player.transform.rotation * offset ;
 
             switch (castType) {
                 case CastType.Ray:
@@ -105,11 +102,21 @@ public class EnvironmentObserver{
                     break;
                 case CastType.BoxCast:
                     // TODO: Make this not an if statement. Check that it works with NodeCanvas first
-                    if (Physics.BoxCast(relativeStartWithRotation, Vector3.one * (width / 2f), (player.transform.rotation * Quaternion.Euler(rotation) * direction), 
+                    if (Physics.BoxCast(relativeStartWithRotation, size / 2f,
-                            out hit, Quaternion.LookRotation(direction) * Quaternion.Euler(rotation), length, ignoreLayers)
+                            player.transform.rotation * Quaternion.Euler(rotation) * direction,
-                    );
+                            out hit, player.transform.rotation * Quaternion.Euler(rotation), length,
+                            ignoreLayers)
+                       ) {
+                    };
                     break;
                 case CastType.SphereCast:
+                    // TODO: Make this not an if statement. Check that it works with NodeCanvas first
+                    if (Physics.SphereCast(relativeStartWithRotation, width / 2f,
+                            player.transform.rotation * Quaternion.Euler(rotation) * direction,
+                            out hit, length,
+                            ignoreLayers)
+                       ) {
+                    };
                     break;
             }
 
@@ -124,27 +131,19 @@ public class EnvironmentObserver{
         Vector3 relativeStart = player.transform.position + offset;
         Vector3 relativeStartWithRotation = player.transform.position + player.transform.rotation * (offset);
         
+        // Setup the variables for boxcast, spherecast, etc
+        // Create an offset start point for the center of the wirebox, since gizmos are drawn with their pivot in the center.
+        Vector3 offsetWithRotationAndLength = (Quaternion.LookRotation(direction) * Quaternion.Euler(rotation)) * (Vector3.forward * (length / 2));
+        Vector3 offsetFromCenter = relativeStartWithRotation + player.transform.rotation * offsetWithRotationAndLength;
+            
+        // Also create a rotation for use with the gizmos. Mainly just to shorten the lines
+        Quaternion gizmosRotation = player.transform.rotation * Quaternion.LookRotation(direction) * Quaternion.Euler(rotation);
+        Vector3 firstBoxOffset = gizmosRotation * (Vector3.forward * size.z);
+
         Color gizmoColor = Evaluate(player) ? Color.green : Color.red;
         gizmoColor = active ? gizmoColor : Color.gray;
         
         using (Draw.ingame.WithColor(gizmoColor)){
-            Vector3 labelStartPos = Vector3.zero;
-            switch (labelLocation) {
-                case LabelDrawingLocation.PlayerOffset:
-                    labelStartPos = player.transform.position + labelLocationOffset;
-                    break;
-                case LabelDrawingLocation.IntersectingLength:
-                    labelStartPos = (relativeStart + (player.transform.rotation * direction * length) / 2f ) + labelLocationOffset;
-                    break;
-                case LabelDrawingLocation.HitLocation:{
-                    if (hit.transform != null) {
-                        labelStartPos = hit.point + labelLocationOffset;
-                    }
-
-                    break;
-                }
-            }
-
             switch (castType) {
                 case CastType.Ray:
                     Draw.ingame.Line(relativeStart, relativeStart + (player.transform.rotation * direction.normalized) * length);
@@ -152,35 +151,88 @@ public class EnvironmentObserver{
                 case CastType.BoxOverlap:
                     Draw.ingame.WireBox(relativeStartWithRotation, player.transform.rotation * Quaternion.Euler(rotation), size);
                     break;
-                case CastType.SphereOverlap:
+                case CastType.SphereCast:
+                    Draw.ingame.SolidCircle(relativeStartWithRotation, relativeStartWithRotation - Camera.main.transform.position, width * 1, gizmoColor.Alpha(.5f));
+                    Draw.ingame.WireCapsule(relativeStartWithRotation, relativeStartWithRotation + gizmosRotation * (Vector3.forward * (length - width / 2)), width);
                     break;
                 case CastType.BoxCast:
-                    // Create an offset start point for the center of the wirebox, since gizmos are drawn with their pivot in the center.
-                    Vector3 offsetWithRotationAndLength = (Quaternion.LookRotation(direction) * Quaternion.Euler(rotation)) * (Vector3.forward * length / 2f);
-                    Vector3 offsetFromCenter = relativeStartWithRotation + player.transform.rotation * offsetWithRotationAndLength;
-                    
-                    // Also create a rotation for use with the gizmos. Mainly just to shorten the lines
-                    Quaternion gizmosRotation = player.transform.rotation * Quaternion.LookRotation(direction) * Quaternion.Euler(rotation);
-                    
                     // Draw the gizmos for the boxcast
-                    Draw.ingame.WireBox(relativeStartWithRotation, gizmosRotation, Vector3.one * width);
+                    Draw.ingame.WireBox(offsetFromCenter, gizmosRotation, new float3(size.x, size.y, length));
-                    Draw.ingame.WireBox(offsetFromCenter, gizmosRotation, new float3(width, width, length + width));
+                    Draw.ingame.SolidBox(relativeStartWithRotation, gizmosRotation, size, gizmoColor.Alpha(.1f));
+                    
+                    Draw.ingame.WireBox(relativeStartWithRotation, gizmosRotation, size);
                     break;
                 default:
                     throw new ArgumentOutOfRangeException();
             }
             
+            Draw.ingame.SolidCircle(relativeStartWithRotation, relativeStartWithRotation - Camera.main.transform.position, .4f);
+            Draw.ingame.SolidCircle(hit.point, hit.point - Camera.main.transform.position, .4f);
+
+            // Set up variables for label (not hit name)
+            Vector3 labelStartPos = Vector3.zero;
+            switch (labelTextLocation) {
+                case LabelDrawingLocation.PlayerOffset:
+                    labelStartPos = player.transform.position;
+                    break;
+                case LabelDrawingLocation.IntersectingLength:
+                    labelStartPos = offsetFromCenter;
+                    break;
+                case LabelDrawingLocation.HitLocation:{
+                    if (hit.transform != null) {
+                        labelStartPos = hit.point;
+                    }
+
+                    break;
+                }
+            }
+            
+            // Draw label
+            if (drawLabel) {
                 Draw.ingame.Label3D(
-                labelStartPos, 
+                    labelStartPos + labelLocationOffset,
-                player.transform.rotation * Quaternion.Euler(labelRotationOffset), 
+                    gizmosRotation * Quaternion.Euler(labelRotationOffset),
-                hit.collider == null ? "" : hit.collider.name, 
+                    label,
-                .5f, 
+                    labelSize,
-                LabelAlignment.Center, 
+                    LabelAlignment.MiddleLeft,
-                Color.black
+                    gizmoColor
                 );
+            }
+          
+            // Set up variables for hit name
+            // Since the label is already drawn just use the previous startPos
+            switch (labelTextLocation) {
+                case LabelDrawingLocation.PlayerOffset:
+                    labelStartPos = player.transform.position;
+                    break;
+                case LabelDrawingLocation.IntersectingLength:
+                    labelStartPos = offsetFromCenter;
+                    break;
+                case LabelDrawingLocation.HitLocation:{
+                    if (hit.transform != null) {
+                        labelStartPos = hit.point;
+                    }
+
+                    break;
+                }
+            }
+            
+            // Draw hitname
+            if (drawLabel) {
+                Draw.ingame.Label3D(
+                    labelStartPos + labelLocationOffset,
+                    gizmosRotation * Quaternion.Euler(labelRotationOffset),
+                    label,
+                    hitTextSize,
+                    LabelAlignment.MiddleLeft,
+                    gizmoColor
+                );
+            }
             
             Sirenix.Utilities.Editor.GUIHelper.RequestRepaint();
         }
+
+
     }
     
     static Color GetObserverStatusColorStatic(bool active, RaycastHit hit){