add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Head Track/headTrackTarget.cs

@@ -0,0 +1,289 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class headTrackTarget : MonoBehaviour
+{
+	[Header ("Main Settings")]
+	[Space]
+
+	public bool targetEnabled = true;
+
+	public Vector3 positionOffset;
+	public float minDistanceToLook = 4;
+	public targetVisibilityTypes visibilityTypes;
+	public List<string> tagsToLocate = new List<string> ();
+
+	public bool useCustomLayer;
+	public LayerMask customLayer;
+
+	public bool storeHeadTrackFound;
+
+	[Space]
+	[Header ("Debug")]
+	[Space]
+
+	public List<headTrack> headTrackFoundList = new List<headTrack> ();
+
+	[Space]
+	[Header ("Gizmo Settings")]
+	[Space]
+
+	public bool showGizmo;
+	public Color gizmoColor = Color.yellow;
+
+	[Space]
+	[Header ("Components")]
+	[Space]
+
+	public Transform targetToLook;
+	public Collider mainCollider;
+
+	public enum targetVisibilityTypes
+	{
+		None,
+		Raycast
+	}
+
+	headTrack currentHeadTrack;
+
+	LayerMask currentLayerMask;
+	Vector3 positionToLook;
+	RaycastHit hit;
+
+	bool targetToLookLocated;
+
+	bool targetLoLookChecked;
+
+	public Vector3 getLookPositon ()
+	{
+		if (!targetLoLookChecked) {
+			if (targetToLook != null) {
+				targetToLookLocated = true;
+			}
+
+			targetLoLookChecked = true;
+		}
+
+		if (targetToLookLocated) {
+			return targetToLook.position + positionOffset;
+		} else {
+			return transform.TransformPoint (positionOffset);
+		}
+	}
+
+	public bool lookTargetVisible (Vector3 headPosition, LayerMask layer)
+	{
+		if (!targetEnabled) {
+			return false;
+		}
+
+		positionToLook = getLookPositon ();
+
+		if (visibilityTypes == targetVisibilityTypes.None) {
+			if (GKC_Utils.distance (headPosition, positionToLook) > minDistanceToLook) {
+				return false;
+			} else {
+				return true;
+			}
+		} else if (visibilityTypes == targetVisibilityTypes.Raycast) {
+			if (GKC_Utils.distance (headPosition, positionToLook) > minDistanceToLook) {
+				return false;
+			} else {
+				if (useCustomLayer) {
+					currentLayerMask = customLayer;
+				} else {
+					currentLayerMask = layer;
+				}
+
+				if (Physics.Linecast (headPosition, positionToLook, out hit, currentLayerMask)) {
+					if (hit.transform != transform) {
+						if (showGizmo) {
+							drawLine (headPosition, hit.point, Color.red);
+						}
+
+						return false;
+					} else {
+						if (showGizmo) {
+							drawLine (headPosition, hit.point, Color.green);
+						}
+
+						return true;
+					}
+				} else {
+					if (showGizmo) {
+						drawLine (headPosition, positionToLook, Color.green);
+					}
+
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	public void drawLine (Vector3 startPosition, Vector3 endPosition, Color color)
+	{
+		if (showGizmo) {
+			Debug.DrawLine (startPosition, endPosition, color);
+		}
+	}
+
+	void OnTriggerEnter (Collider other)
+	{
+		checkTriggerInfo (other.gameObject, true);
+	}
+
+	void OnTriggerExit (Collider other)
+	{
+		checkTriggerInfo (other.gameObject, false);
+	}
+
+	void checkTriggerInfo (GameObject objectToCheck, bool isEnter)
+	{
+		if (tagsToLocate.Contains (objectToCheck.tag)) {
+			currentHeadTrack = objectToCheck.GetComponent<headTrack> ();
+
+			if (currentHeadTrack != null) {
+				if (!currentHeadTrack.isHeadTrackEnabled ()) {
+					return;
+				}
+
+				if (isEnter) {
+
+					currentHeadTrack.checkHeadTrackTarget (this);
+
+					if (storeHeadTrackFound) {
+						if (!headTrackFoundList.Contains (currentHeadTrack)) {
+							headTrackFoundList.Add (currentHeadTrack);
+						}
+					}
+				} else {
+
+					currentHeadTrack.removeHeadTrackTarget (this);
+
+					if (storeHeadTrackFound) {
+						if (headTrackFoundList.Contains (currentHeadTrack)) {
+							headTrackFoundList.Remove (currentHeadTrack);
+						}
+					
+					}
+				}
+			}
+		}
+	}
+
+	public void setEnableState (bool state)
+	{
+		targetEnabled = state;
+	}
+
+	public void disableState ()
+	{
+		setEnableState (false);
+	}
+
+	public void addTagToLocate (string tagToAdd)
+	{
+		if (!tagsToLocate.Contains (tagToAdd)) {
+			tagsToLocate.Add (tagToAdd);
+
+			getMainCollider ();
+
+			if (mainCollider != null) {
+				mainCollider.enabled = false;
+
+				mainCollider.enabled = true;
+			}
+		}
+	}
+
+	public void removeTagToLocate (string tagToAdd)
+	{
+		if (tagsToLocate.Contains (tagToAdd)) {
+
+			if (storeHeadTrackFound) {
+
+				for (int i = headTrackFoundList.Count - 1; i >= 0; i--) {
+					if (headTrackFoundList [i].gameObject != null) {
+						if (headTrackFoundList [i].gameObject.CompareTag (tagToAdd)) {
+
+							headTrackFoundList [i].removeHeadTrackTarget (this);
+	
+							headTrackFoundList.RemoveAt (i);
+						}
+					} else {
+						headTrackFoundList.RemoveAt (i);
+					}
+				}
+			}
+
+			tagsToLocate.Remove (tagToAdd);
+		}
+	}
+
+	public void removeAllHeadTracksFoundAndDisableHeadTrack ()
+	{
+		for (int i = 0; i < headTrackFoundList.Count; i++) {
+
+			headTrackFoundList [i].removeHeadTrackTarget (this);
+		}
+
+		headTrackFoundList.Clear ();
+
+		getMainCollider ();
+
+		if (mainCollider != null) {
+			mainCollider.enabled = false;
+		}
+
+		targetEnabled = false;
+	}
+
+	public void enableHeadTrack ()
+	{
+		targetEnabled = true;
+
+		getMainCollider ();
+
+		if (mainCollider != null) {
+			mainCollider.enabled = true;
+		}
+	}
+
+	void getMainCollider ()
+	{
+		if (mainCollider == null) {
+			mainCollider = GetComponent<Collider> ();
+		}
+	}
+
+#if UNITY_EDITOR
+    void OnDrawGizmos ()
+	{
+		if (!showGizmo) {
+			return;
+		}
+
+		if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
+			DrawGizmos ();
+		}
+	}
+
+	void OnDrawGizmosSelected ()
+	{
+		DrawGizmos ();
+	}
+
+	void DrawGizmos ()
+	{
+		if (showGizmo && targetEnabled) {
+			Gizmos.color = gizmoColor;
+			Vector3 position = getLookPositon ();
+			Gizmos.DrawWireSphere (position, minDistanceToLook);
+			Gizmos.color = Color.red;
+			Gizmos.DrawSphere (position, 0.2f);
+		}
+	}
+#endif
+}