add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Health/destroyableObject.cs

@@ -0,0 +1,378 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using GameKitController.Audio;
+using UnityEngine.Events;
+
+public class destroyableObject : MonoBehaviour
+{
+	[Header ("Main Settings")]
+	[Space]
+
+	public bool explosionEnabled = true;
+	public GameObject destroyedParticles;
+	public AudioClip destroyedSound;
+	public AudioElement destroyedAudioElement;
+
+	[Space]
+	[Header ("Explosion Settings")]
+	[Space]
+
+	public bool useExplosionForceWhenDestroyed;
+	public float explosionRadius;
+	public float explosionForce;
+	public float explosionDamage;
+	public bool ignoreShield;
+
+	public int damageTypeID = -1;
+
+	public bool damageCanBeBlocked = true;
+
+	public bool killObjectsInRadius;
+	public ForceMode forceMode;
+
+	public bool applyExplosionForceToVehicles = true;
+	public float explosionForceToVehiclesMultiplier = 0.2f;
+
+	public bool pushCharactersOnExplosion = true;
+
+	public bool searchClosestWeakSpot;
+
+	[Space]
+	[Header ("Damage Over Time Settings")]
+	[Space]
+
+	public bool damageTargetOverTime;
+	public float damageOverTimeDelay;
+	public float damageOverTimeDuration;
+	public float damageOverTimeAmount;
+	public float damageOverTimeRate;
+	public bool damageOverTimeToDeath;
+	public bool removeDamageOverTimeState;
+
+	[Space]
+	[Header ("Detect Objects Settings")]
+	[Space]
+
+	public bool userLayerMask;
+	public LayerMask layer;
+
+	[Space]
+	[Header ("Remote Events Settings")]
+	[Space]
+
+	public bool useRemoteEventOnObjectsFound;
+	public string removeEventName;
+
+	[Space]
+	[Header ("Object Pieces Settings")]
+	[Space]
+
+	public bool fadePiecesEnabled = true;
+	public float timeToFadePieces;
+
+	public bool storeRendererParts = true;
+	public bool disableColliders = true;
+
+	public bool destroyObjectAfterFacePieces = true;
+	public Shader transparentShader;
+
+	public string defaultShaderName = "Legacy Shaders/Transparent/Diffuse";
+
+	[Space]
+	[Header ("Meshes Force Settings")]
+	[Space]
+
+	public float meshesExplosionForce = 500;
+	public float meshesExplosionRadius = 50;
+	public ForceMode meshesExplosionForceMode;
+
+	[Space]
+	[Header ("Extra Pieces Settings")]
+	[Space]
+
+	public bool useExtraParts;
+	public List<GameObject> extraParts = new List<GameObject> ();
+
+	[Space]
+	[Header ("Events Settings")]
+	[Space]
+
+	public bool useEventOnObjectDestroyed;
+	public UnityEvent eventOnObjectDestroyed;
+
+	public bool useEventOnObjectBeforeDestroyed;
+	public UnityEvent eventOnObjectBeforeDestroyed;
+
+	[Space]
+	[Header ("Debug")]
+	[Space]
+
+	public bool destroyed;
+
+	[Space]
+	[Header ("Gizmo Settings")]
+	[Space]
+
+	public bool showGizmo;
+
+	[Space]
+	[Header ("Components")]
+	[Space]
+
+	public Rigidbody mainRigidbody;
+	public mapObjectInformation mapInformationManager;
+	public AudioSource destroyedSource;
+
+	public Transform explosionCenter;
+
+
+	List<Material> rendererParts = new List<Material> ();
+
+	bool objectDisabled;
+
+
+	void Start ()
+	{
+		if (mainRigidbody == null) {
+			mainRigidbody = GetComponent<Rigidbody> ();
+		}
+
+		if (mapInformationManager == null) {
+			mapInformationManager = GetComponent<mapObjectInformation> ();
+		}
+
+		if (destroyedSource == null) {
+			destroyedSource = GetComponent<AudioSource> ();
+		}
+
+		if (destroyedSound != null) {
+			destroyedAudioElement.clip = destroyedSound;
+		}
+
+		if (destroyedSource != null) {
+			destroyedAudioElement.audioSource = destroyedSource;
+		}
+	}
+
+	void Update ()
+	{
+		if (destroyed && !objectDisabled) {
+			if (destroyObjectAfterFacePieces) {
+				if (timeToFadePieces > 0) {
+					timeToFadePieces -= Time.deltaTime;
+				}
+
+				if (storeRendererParts) {
+					if (timeToFadePieces <= 0) {
+						if (fadePiecesEnabled) {
+							int piecesAmountFade = 0;
+
+							for (int i = 0; i < rendererParts.Count; i++) {
+								Color alpha = rendererParts [i].color;
+
+								alpha.a -= Time.deltaTime / 5;
+
+								rendererParts [i].color = alpha;
+
+								if (alpha.a <= 0) {
+									piecesAmountFade++;
+								}
+							}
+
+							if (piecesAmountFade == rendererParts.Count) {
+								Destroy (gameObject);
+							}
+						} else {
+							Destroy (gameObject);
+						}
+					}
+				} else {
+					if (timeToFadePieces <= 0) {
+						Destroy (gameObject);
+					}
+				}
+			} else {
+				objectDisabled = true;
+			}
+		}
+	}
+
+	//Destroy the object
+	public void destroyObject ()
+	{
+		if (!explosionEnabled) {
+			return;
+		}
+
+		if (destroyed) {
+			return;
+		}
+
+		//instantiated an explosiotn particles
+		if (destroyedParticles != null) {
+			GameObject destroyedParticlesClone = (GameObject)Instantiate (destroyedParticles, transform.position, transform.rotation);
+			destroyedParticlesClone.transform.SetParent (transform);
+		}
+
+		if (destroyedAudioElement != null) {
+			AudioPlayer.PlayOneShot (destroyedAudioElement, gameObject);
+		}
+
+		//set the velocity of the object to zero
+		if (mainRigidbody != null) {
+			mainRigidbody.linearVelocity = Vector3.zero;
+			mainRigidbody.isKinematic = true;
+		}
+
+		//get every renderer component if the object
+		if (storeRendererParts) {
+
+			if (fadePiecesEnabled) {
+				if (transparentShader == null) {
+					transparentShader = Shader.Find (defaultShaderName);
+				}
+			}
+
+			Component[] components = GetComponentsInChildren (typeof(MeshRenderer));
+
+			List<Component> componentsList = new List<Component> (components);
+
+			if (useExtraParts) {
+				int extraPartsCount = extraParts.Count;
+
+				for (int j = 0; j < extraPartsCount; j++) {
+					
+					GameObject currentObject = extraParts [j];
+
+					if (currentObject != null) {
+						Component[] extraComponents = currentObject.GetComponentsInChildren (typeof(MeshRenderer));
+				
+						if (extraComponents.Length > 0) {
+							componentsList.AddRange (extraComponents);
+						}
+					}
+				}
+			}
+
+			int ignoreRaycastLayerIndex = LayerMask.NameToLayer ("Ignore Raycast");
+
+			int layerToIgnoreIndex = LayerMask.NameToLayer ("Scanner");
+
+			int componentsListCount = componentsList.Count;
+
+			for (int i = 0; i < componentsListCount; i++) {
+
+				MeshRenderer child = componentsList [i] as MeshRenderer;
+
+				if (child != null && child.gameObject.layer != layerToIgnoreIndex) {
+					if (child.enabled) {
+						if (fadePiecesEnabled) {
+							//for every renderer object, change every shader in it for a transparent shader 
+							for (int j = 0; j < child.materials.Length; j++) {
+								child.materials [j].shader = transparentShader;
+
+								rendererParts.Add (child.materials [j]);
+							}
+						}
+
+						//set the layer ignore raycast to them
+						child.gameObject.layer = ignoreRaycastLayerIndex;
+
+						//add rigidbody and box collider to them
+						Rigidbody currentRigidbody = child.gameObject.GetComponent<Rigidbody> ();
+
+						if (currentRigidbody == null) {
+							currentRigidbody = child.gameObject.AddComponent<Rigidbody> ();
+						} else {
+							currentRigidbody.isKinematic = false;
+							currentRigidbody.useGravity = true;
+						}
+
+						Collider currentCollider = child.gameObject.GetComponent<Collider> ();
+
+						if (currentCollider == null) {
+							currentCollider = child.gameObject.AddComponent<BoxCollider> ();
+						}
+
+						//apply explosion force
+						currentRigidbody.AddExplosionForce (meshesExplosionForce, transform.position, meshesExplosionRadius, 3, meshesExplosionForceMode);
+					}
+				} 
+			}
+		}
+
+		if (disableColliders) {
+			//any other object with a collider but with out renderer, is disabled
+			Component[] collidersInObject = GetComponentsInChildren (typeof(Collider));
+
+			int collidersInObjectLength = collidersInObject.Length;
+
+			for (int i = 0; i < collidersInObjectLength; i++) {
+				
+				Collider currentCollider = collidersInObject [i] as Collider;
+
+				if (currentCollider != null && !currentCollider.GetComponent<Renderer> ()) {
+					currentCollider.enabled = false;
+				}
+			}
+		}
+
+		if (mapInformationManager != null) {
+			mapInformationManager.removeMapObject ();
+		}
+
+		if (useEventOnObjectBeforeDestroyed) {
+			eventOnObjectBeforeDestroyed.Invoke ();
+		}
+
+		if (useExplosionForceWhenDestroyed) {
+			if (explosionCenter == null) {
+				explosionCenter = transform;
+			}
+
+			Vector3 currentPosition = explosionCenter.position;
+
+			applyDamage.setExplosion (currentPosition, explosionRadius, userLayerMask, layer, gameObject, false, gameObject, 
+				killObjectsInRadius, true, false, explosionDamage, pushCharactersOnExplosion, applyExplosionForceToVehicles, 
+				explosionForceToVehiclesMultiplier, explosionForce, forceMode, true, transform, ignoreShield, 
+				useRemoteEventOnObjectsFound, removeEventName, damageTypeID,
+				damageTargetOverTime, damageOverTimeDelay, damageOverTimeDuration, damageOverTimeAmount, 
+				damageOverTimeRate, damageOverTimeToDeath, removeDamageOverTimeState, damageCanBeBlocked, searchClosestWeakSpot);
+		}
+
+		if (useEventOnObjectDestroyed) {
+			eventOnObjectDestroyed.Invoke ();
+		}
+
+		destroyed = true;
+	}
+
+#if UNITY_EDITOR
+    void OnDrawGizmos ()
+	{
+		if (!showGizmo) {
+			return;
+		}
+
+		if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
+			DrawGizmos ();
+		}
+	}
+
+	void OnDrawGizmosSelected ()
+	{
+		DrawGizmos ();
+	}
+
+	void DrawGizmos ()
+	{
+		if (showGizmo) {
+			if (useExplosionForceWhenDestroyed) {
+				Gizmos.color = Color.red;
+				Gizmos.DrawWireSphere (transform.position, explosionRadius);
+			}
+		}
+	}
+#endif
+}