697 lines
23 KiB
C#
697 lines
23 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using GameKitController.Audio;
|
|
using UnityEngine;
|
|
|
|
public class plasmaCutterProjectile : projectileSystem
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public Material defaultSliceMaterial;
|
|
|
|
public float forceToApplyToCutPart;
|
|
public ForceMode forceMode;
|
|
public float forceRadius;
|
|
|
|
public bool cutMultipleTimesActive;
|
|
|
|
public bool useCutLimit;
|
|
public int cutLimit;
|
|
|
|
public bool activateRigidbodiesOnNewObjects = true;
|
|
|
|
[Space]
|
|
[Header ("Shatter Object Settings")]
|
|
[Space]
|
|
|
|
public bool shatterObjectActive;
|
|
public int shatterAmount;
|
|
|
|
public bool applyForceOnShatter;
|
|
|
|
public bool addSliceComponentToPieces = true;
|
|
|
|
[Space]
|
|
[Header ("Damage Settings")]
|
|
[Space]
|
|
|
|
public bool activateDamageOnSlice;
|
|
public float damageAmountToApplyOnSlice;
|
|
public bool ignoreShieldOnDamage = true;
|
|
public bool canActivateReactionSystemTemporally;
|
|
public int damageReactionID = -1;
|
|
|
|
public int damageTypeID = -1;
|
|
|
|
[Space]
|
|
[Header ("Physics Settings")]
|
|
[Space]
|
|
|
|
public bool updateLastObjectSpeed;
|
|
|
|
public bool applyForcesOnObjectsDetected;
|
|
public float addForceMultiplier;
|
|
public bool applyImpactForceToVehicles;
|
|
public float impactForceToVehiclesMultiplier;
|
|
|
|
public bool checkObjectLayerAndTagToApplyForces;
|
|
|
|
public LayerMask targetToApplyForceLayer;
|
|
public List<string> tagetToApplyForceTagList = new List<string> ();
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public float minDelayToSliceSameObject = 0.01f;
|
|
|
|
public Transform cutPositionTransform;
|
|
|
|
public Vector3 cutOverlapBoxSize = new Vector3 (5, 0.1f, 5);
|
|
|
|
public bool addRigidbodyToBothSlicedObjects;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
|
|
public List<GameObject> objectsDetected = new List<GameObject> ();
|
|
|
|
[Space]
|
|
[Header ("Gizmo Settings")]
|
|
[Space]
|
|
|
|
public bool showGizmo;
|
|
public Color gizmoColor = Color.red;
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public Transform cutDirectionTransform;
|
|
public Transform planeDefiner1;
|
|
public Transform planeDefiner2;
|
|
public Transform planeDefiner3;
|
|
|
|
surfaceToSlice currentSurfaceToSlice;
|
|
|
|
int currentNumberOfCuts;
|
|
|
|
List<GameObject> objectsToShatter;
|
|
bool objectShattered = false;
|
|
|
|
public void checkObjectDetected (Collider col)
|
|
{
|
|
if (canActivateEffect (col)) {
|
|
|
|
objectShattered = false;
|
|
|
|
if (currentProjectileInfo.impactAudioElement != null) {
|
|
currentProjectileInfo.impactAudioElement.audioSource = GetComponent<AudioSource> ();
|
|
AudioPlayer.PlayOneShot (currentProjectileInfo.impactAudioElement, gameObject);
|
|
}
|
|
|
|
Collider objectCollider = col.GetComponent<Collider> ();
|
|
|
|
objectToDamage = objectCollider.gameObject;
|
|
|
|
processObject (objectToDamage, objectCollider, cutPositionTransform.position);
|
|
|
|
if (!cutMultipleTimesActive || currentNumberOfCuts >= cutLimit) {
|
|
setProjectileUsedState (true);
|
|
|
|
mainRigidbody.isKinematic = true;
|
|
|
|
projectilePaused = true;
|
|
|
|
destroyProjectile ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void processObject (GameObject objectToCheck, Collider objectCollider, Vector3 slicePosition)
|
|
{
|
|
if (cutMultipleTimesActive) {
|
|
if (objectsDetected.Contains (objectToCheck)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
currentSurfaceToSlice = objectToCheck.GetComponent<surfaceToSlice> ();
|
|
|
|
if (currentSurfaceToSlice == null) {
|
|
currentSurfaceToSlice = sliceSystemUtils.getSurfaceToSlice (objectToCheck);
|
|
}
|
|
|
|
bool isVehicle = applyDamage.isVehicle (objectToCheck);
|
|
|
|
if (isVehicle) {
|
|
GameObject currentVehicle = applyDamage.getVehicle (objectToCheck);
|
|
|
|
if (currentVehicle != null) {
|
|
currentSurfaceToSlice = currentVehicle.GetComponent<surfaceToSlice> ();
|
|
|
|
if (currentSurfaceToSlice != null) {
|
|
objectToCheck = currentVehicle;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool objectIsSliceSurfaceDisabled = false;
|
|
|
|
bool objectCanBeSliced = false;
|
|
|
|
if (showDebugPrint) {
|
|
print ("processing object " + objectToCheck.name);
|
|
}
|
|
|
|
bool ignoreRegularDamageIfCutSurfaceNotEnabled = false;
|
|
|
|
bool isIgnoreDamageIfSliceNotActivatedActive = false;
|
|
|
|
if (currentSurfaceToSlice != null) {
|
|
bool isCutSurfaceEnabled = currentSurfaceToSlice.isCutSurfaceEnabled ();
|
|
|
|
bool sliceCanBeActivated = currentSurfaceToSlice.sliceCanBeActivated (minDelayToSliceSameObject);
|
|
|
|
bool checkSliceDirectionResult = currentSurfaceToSlice.checkSliceDirectionResult (cutPositionTransform.right, cutPositionTransform.up);
|
|
|
|
isIgnoreDamageIfSliceNotActivatedActive = currentSurfaceToSlice.isIgnoreDamageIfSliceNotActivatedActive ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("Surface cut enabled state " + isCutSurfaceEnabled +
|
|
" can activate slice " + sliceCanBeActivated);
|
|
}
|
|
|
|
if (isCutSurfaceEnabled && sliceCanBeActivated && checkSliceDirectionResult) {
|
|
Material crossSectionMaterial = currentSurfaceToSlice.getCrossSectionMaterial ();
|
|
|
|
if (crossSectionMaterial == null) {
|
|
crossSectionMaterial = defaultSliceMaterial;
|
|
}
|
|
|
|
sliceCurrentObject (objectToCheck, objectCollider, crossSectionMaterial, slicePosition);
|
|
|
|
objectCanBeSliced = true;
|
|
} else {
|
|
if (isVehicle && isCutSurfaceEnabled) {
|
|
objectCanBeSliced = true;
|
|
}
|
|
}
|
|
|
|
if (!isCutSurfaceEnabled) {
|
|
objectIsSliceSurfaceDisabled = true;
|
|
|
|
ignoreRegularDamageIfCutSurfaceNotEnabled = currentSurfaceToSlice.isIgnoreRegularDamageIfCutSurfaceNotEnabled ();
|
|
}
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("Surface to slice not found on " + objectToCheck.name);
|
|
}
|
|
}
|
|
|
|
if (!objectCanBeSliced && !ignoreRegularDamageIfCutSurfaceNotEnabled) {
|
|
if (activateDamageOnSlice && !isIgnoreDamageIfSliceNotActivatedActive) {
|
|
Vector3 damagePosition = cutPositionTransform.position;
|
|
|
|
if (applyDamage.checkIfDead (objectToCheck)) {
|
|
damagePosition = objectToCheck.transform.position;
|
|
}
|
|
|
|
applyDamage.checkCanBeDamaged (gameObject, objectToCheck, damageAmountToApplyOnSlice, -cutPositionTransform.forward, damagePosition,
|
|
currentProjectileInfo.owner, true, true, ignoreShieldOnDamage, false, true, canActivateReactionSystemTemporally,
|
|
damageReactionID, damageTypeID);
|
|
}
|
|
|
|
if (applyForcesOnObjectsDetected && !objectIsSliceSurfaceDisabled) {
|
|
if (!checkObjectLayerAndTagToApplyForces ||
|
|
((1 << objectToCheck.layer & targetToApplyForceLayer.value) == 1 << objectToCheck.layer && tagetToApplyForceTagList.Contains (objectToCheck.tag))) {
|
|
checkForceToApplyOnObject (objectToCheck);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void sliceCurrentObject (GameObject objectToCheck, Collider objectCollider, Material crossSectionMaterial, Vector3 slicePosition)
|
|
{
|
|
if (useCutLimit) {
|
|
currentNumberOfCuts++;
|
|
}
|
|
|
|
// slice the provided object using the transforms of this object
|
|
if (currentSurfaceToSlice.isObjectCharacter ()) {
|
|
// print ("character found " + objectToCheck.name + " is dead " + applyDamage.checkIfDead (objectToCheck));
|
|
|
|
if (applyDamage.getCharacterOrVehicle (objectToCheck) != null && !applyDamage.checkIfDead (objectToCheck)) {
|
|
processCharacter (objectToCheck);
|
|
|
|
return;
|
|
}
|
|
|
|
Rigidbody mainObject = objectToCheck.GetComponent<Rigidbody> ();
|
|
|
|
bool mainObjectHasRigidbody = mainObject != null;
|
|
|
|
Vector3 lastSpeed = Vector3.zero;
|
|
|
|
if (mainObjectHasRigidbody) {
|
|
lastSpeed = mainObject.linearVelocity;
|
|
}
|
|
|
|
currentSurfaceToSlice.checkEventBeforeSlice ();
|
|
|
|
currentSurfaceToSlice.getMainSimpleSliceSystem ().activateSlice (objectCollider, positionInWorldSpace,
|
|
normalInWorldSpace, slicePosition, updateLastObjectSpeed, lastSpeed);
|
|
|
|
currentSurfaceToSlice.checkEventOnCut ();
|
|
|
|
currentSurfaceToSlice.checkTimeBulletOnCut ();
|
|
} else {
|
|
if (shatterObjectActive) {
|
|
shatterObject (objectToCheck, crossSectionMaterial);
|
|
|
|
return;
|
|
}
|
|
|
|
// slice the provided object using the transforms of this object
|
|
bool objectSliced = false;
|
|
|
|
GameObject object1 = null;
|
|
GameObject object2 = null;
|
|
|
|
currentSurfaceToSlice.checkEventBeforeSlice ();
|
|
|
|
objectToCheck = currentSurfaceToSlice.getMainSurfaceToSlice ();
|
|
|
|
// slice the provided objectToCheck ect using the transforms of this object
|
|
sliceSystemUtils.sliceObject (transform.position, objectToCheck, cutDirectionTransform.up, crossSectionMaterial, ref objectSliced, ref object1, ref object2);
|
|
|
|
Vector3 objectPosition = objectToCheck.transform.position;
|
|
Quaternion objectRotation = objectToCheck.transform.rotation;
|
|
|
|
Transform objectParent = objectToCheck.transform.parent;
|
|
|
|
if (objectSliced) {
|
|
if (currentSurfaceToSlice.useParticlesOnSlice) {
|
|
Quaternion particlesRotation = Quaternion.LookRotation (positionInWorldSpace);
|
|
|
|
Instantiate (currentSurfaceToSlice.particlesOnSlicePrefab, slicePosition, particlesRotation);
|
|
}
|
|
|
|
currentSurfaceToSlice.checkEventOnCut ();
|
|
|
|
currentSurfaceToSlice.checkTimeBulletOnCut ();
|
|
|
|
Rigidbody mainObject = objectToCheck.GetComponent<Rigidbody> ();
|
|
bool mainObjectHasRigidbody = mainObject != null;
|
|
|
|
object1.transform.position = objectPosition;
|
|
object1.transform.rotation = objectRotation;
|
|
|
|
object2.transform.position = objectPosition;
|
|
object2.transform.rotation = objectRotation;
|
|
|
|
if (objectParent != null) {
|
|
object1.transform.SetParent (objectParent);
|
|
object2.transform.SetParent (objectParent);
|
|
}
|
|
|
|
surfaceToSlice newSurfaceToSlice1 = object1.AddComponent<surfaceToSlice> ();
|
|
surfaceToSlice newSurfaceToSlice2 = object2.AddComponent<surfaceToSlice> ();
|
|
|
|
currentSurfaceToSlice.copySurfaceInfo (newSurfaceToSlice1);
|
|
currentSurfaceToSlice.copySurfaceInfo (newSurfaceToSlice2);
|
|
|
|
newSurfaceToSlice1.checkDestroySlicedPartsAfterDelay ();
|
|
newSurfaceToSlice2.checkDestroySlicedPartsAfterDelay ();
|
|
|
|
float currentForceToApply = forceToApplyToCutPart;
|
|
|
|
ForceMode currentForceMode = forceMode;
|
|
|
|
if (currentSurfaceToSlice.useCustomForceMode) {
|
|
currentForceMode = currentSurfaceToSlice.customForceMode;
|
|
}
|
|
|
|
if (mainObjectHasRigidbody || activateRigidbodiesOnNewObjects) {
|
|
|
|
if (currentSurfaceToSlice.useCustomForceAmount) {
|
|
currentForceToApply = currentSurfaceToSlice.customForceAmount;
|
|
}
|
|
|
|
Rigidbody object1Rigidbody = object1.AddComponent<Rigidbody> ();
|
|
|
|
Rigidbody object2Rigidbody = object2.AddComponent<Rigidbody> ();
|
|
|
|
object2Rigidbody.AddExplosionForce (currentForceToApply, transform.position, 10, 1, currentForceMode);
|
|
|
|
object1Rigidbody.AddExplosionForce (currentForceToApply, transform.position, 10, 1, currentForceMode);
|
|
} else {
|
|
if (currentSurfaceToSlice.useCustomForceAmount) {
|
|
currentForceToApply = currentSurfaceToSlice.customForceAmount;
|
|
}
|
|
|
|
bool addRigidbodyToObject1 = false;
|
|
bool addRigidbodyToObject2 = false;
|
|
|
|
if (addRigidbodyToBothSlicedObjects) {
|
|
addRigidbodyToObject1 = true;
|
|
addRigidbodyToObject2 = true;
|
|
} else {
|
|
float distance1 = GKC_Utils.distance (objectToCheck.transform.position, object1.transform.position);
|
|
float distance2 = GKC_Utils.distance (objectToCheck.transform.position, object2.transform.position);
|
|
|
|
if (distance1 < distance2) {
|
|
addRigidbodyToObject1 = true;
|
|
} else {
|
|
addRigidbodyToObject2 = true;
|
|
}
|
|
}
|
|
|
|
if (addRigidbodyToObject1) {
|
|
Rigidbody object2Rigidbody = object2.AddComponent<Rigidbody> ();
|
|
|
|
object2Rigidbody.AddExplosionForce (currentForceToApply, transform.position, 10, 1, currentForceMode);
|
|
}
|
|
|
|
if (addRigidbodyToObject2) {
|
|
Rigidbody object1Rigidbody = object1.AddComponent<Rigidbody> ();
|
|
|
|
object1Rigidbody.AddExplosionForce (currentForceToApply, transform.position, 10, 1, currentForceMode);
|
|
}
|
|
}
|
|
|
|
if (currentSurfaceToSlice.useBoxCollider) {
|
|
object1.AddComponent<BoxCollider> ();
|
|
object2.AddComponent<BoxCollider> ();
|
|
} else {
|
|
MeshCollider object1Collider = object1.AddComponent<MeshCollider> ();
|
|
MeshCollider object2Collider = object2.AddComponent<MeshCollider> ();
|
|
|
|
object1Collider.convex = true;
|
|
object2Collider.convex = true;
|
|
}
|
|
|
|
if (currentSurfaceToSlice.setNewLayerOnCut) {
|
|
object1.layer = LayerMask.NameToLayer (currentSurfaceToSlice.newLayerOnCut);
|
|
object2.layer = LayerMask.NameToLayer (currentSurfaceToSlice.newLayerOnCut);
|
|
}
|
|
|
|
if (currentSurfaceToSlice.setNewTagOnCut) {
|
|
object1.tag = currentSurfaceToSlice.newTagOnCut;
|
|
object2.tag = currentSurfaceToSlice.newTagOnCut;
|
|
}
|
|
|
|
if (cutMultipleTimesActive) {
|
|
if (!objectsDetected.Contains (object1)) {
|
|
objectsDetected.Add (object1);
|
|
}
|
|
|
|
if (!objectsDetected.Contains (object2)) {
|
|
objectsDetected.Add (object2);
|
|
}
|
|
}
|
|
|
|
objectToCheck.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void processCharacter (GameObject currentCharacter)
|
|
{
|
|
StartCoroutine (processCharacterCoroutine (currentCharacter));
|
|
}
|
|
|
|
List<Collider> colliders = new List<Collider> ();
|
|
|
|
IEnumerator processCharacterCoroutine (GameObject currentCharacter)
|
|
{
|
|
applyDamage.pushCharacterWithoutForceAndPauseGetUp (currentCharacter);
|
|
|
|
Vector3 slicePosition = cutPositionTransform.position;
|
|
|
|
Collider [] temporalHits = Physics.OverlapBox (slicePosition, cutOverlapBoxSize, cutDirectionTransform.rotation, currentProjectileInfo.targetToDamageLayer);
|
|
|
|
bool bodyPartFound = false;
|
|
|
|
if (temporalHits.Length > 0) {
|
|
bool ragdollCollidersFoundOnCharacter = false;
|
|
|
|
colliders = null;
|
|
|
|
ragdollActivator currentRagdollActivator = currentCharacter.GetComponent<ragdollActivator> ();
|
|
|
|
if (currentRagdollActivator != null) {
|
|
colliders = currentRagdollActivator.getBodyColliderList ();
|
|
|
|
if (colliders != null && colliders.Count > 0) {
|
|
ragdollCollidersFoundOnCharacter = true;
|
|
}
|
|
}
|
|
|
|
Collider colliderToCheck = null;
|
|
|
|
float minDistance = 1000;
|
|
|
|
for (int i = 0; i < temporalHits.Length; i++) {
|
|
Collider currentCollider = temporalHits [i];
|
|
|
|
bool canActivateSliceResult = false;
|
|
|
|
if (ragdollCollidersFoundOnCharacter) {
|
|
if (showDebugPrint) {
|
|
print ("ragoll detected");
|
|
}
|
|
|
|
if (colliders.Contains (currentCollider)) {
|
|
canActivateSliceResult = true;
|
|
|
|
if (showDebugPrint) {
|
|
print ("ragdoll part found");
|
|
}
|
|
}
|
|
} else {
|
|
canActivateSliceResult = true;
|
|
}
|
|
|
|
if (canActivateSliceResult) {
|
|
|
|
if (applyDamage.isCharacter (currentCollider.gameObject)) {
|
|
bodyPartFound = true;
|
|
|
|
float currentDistance = GKC_Utils.distance (slicePosition, currentCollider.transform.position);
|
|
|
|
if (currentDistance < minDistance) {
|
|
minDistance = currentDistance;
|
|
|
|
colliderToCheck = currentCollider;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bodyPartFound) {
|
|
if (currentCharacter != null) {
|
|
applyDamage.killCharacter (currentCharacter);
|
|
}
|
|
|
|
processObject (colliderToCheck.gameObject, colliderToCheck, slicePosition);
|
|
}
|
|
}
|
|
|
|
yield return null;
|
|
}
|
|
|
|
private Vector3 positionInWorldSpace
|
|
{
|
|
get
|
|
{
|
|
return (planeDefiner1.position + planeDefiner2.position + planeDefiner3.position) / 3f;
|
|
}
|
|
}
|
|
|
|
private Vector3 normalInWorldSpace
|
|
{
|
|
get
|
|
{
|
|
Vector3 t0 = planeDefiner1.position;
|
|
Vector3 t1 = planeDefiner2.position;
|
|
Vector3 t2 = planeDefiner3.position;
|
|
|
|
Vector3 vectorValue;
|
|
|
|
vectorValue.x = t0.y * (t1.z - t2.z) + t1.y * (t2.z - t0.z) + t2.y * (t0.z - t1.z);
|
|
vectorValue.y = t0.z * (t1.x - t2.x) + t1.z * (t2.x - t0.x) + t2.z * (t0.x - t1.x);
|
|
vectorValue.z = t0.x * (t1.y - t2.y) + t1.x * (t2.y - t0.y) + t2.x * (t0.y - t1.y);
|
|
|
|
return vectorValue;
|
|
}
|
|
}
|
|
|
|
public void checkForceToApplyOnObject (GameObject objectToDamage)
|
|
{
|
|
Rigidbody objectToDamageRigidbody = objectToDamage.GetComponent<Rigidbody> ();
|
|
|
|
Vector3 forceDirection = cutDirectionTransform.forward;
|
|
|
|
float forceAmount = addForceMultiplier;
|
|
|
|
float forceToVehiclesMultiplier = impactForceToVehiclesMultiplier;
|
|
|
|
if (applyImpactForceToVehicles) {
|
|
Rigidbody objectToDamageMainRigidbody = applyDamage.applyForce (objectToDamage);
|
|
|
|
if (objectToDamageMainRigidbody != null) {
|
|
Vector3 force = forceAmount * forceDirection;
|
|
|
|
bool isVehicle = applyDamage.isVehicle (objectToDamage);
|
|
|
|
if (isVehicle) {
|
|
force *= forceToVehiclesMultiplier;
|
|
}
|
|
|
|
objectToDamageMainRigidbody.AddForce (objectToDamageMainRigidbody.mass * force, forceMode);
|
|
}
|
|
} else {
|
|
if (applyDamage.canApplyForce (objectToDamage)) {
|
|
//print (objectToDamage.name);
|
|
Vector3 force = forceAmount * forceDirection;
|
|
|
|
if (objectToDamageRigidbody == null) {
|
|
objectToDamageRigidbody = objectToDamage.GetComponent<Rigidbody> ();
|
|
}
|
|
|
|
objectToDamageRigidbody.AddForce (objectToDamageRigidbody.mass * force, forceMode);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void setProjectileSpecialActionActiveState (bool state)
|
|
{
|
|
setShatterObjectActiveState (state);
|
|
}
|
|
|
|
//SHATTER FUNCTIONS
|
|
public void setShatterObjectActiveState (bool state)
|
|
{
|
|
shatterObjectActive = state;
|
|
}
|
|
|
|
public void shatterObject (GameObject objectToCheck, Material crossSectionMaterial)
|
|
{
|
|
if (objectShattered) {
|
|
return;
|
|
}
|
|
|
|
objectsToShatter = new List<GameObject> ();
|
|
|
|
if (objectToCheck.transform.parent != null) {
|
|
objectToCheck.transform.SetParent (null);
|
|
}
|
|
|
|
objectsToShatter.Add (objectToCheck);
|
|
|
|
for (int i = 0; i < shatterAmount; i++) {
|
|
randomShatter (crossSectionMaterial);
|
|
}
|
|
|
|
objectShattered = true;
|
|
}
|
|
|
|
public void randomShatter (Material crossSectionMaterial)
|
|
{
|
|
List<GameObject> adders = new List<GameObject> ();
|
|
List<GameObject> removals = new List<GameObject> ();
|
|
|
|
foreach (GameObject objectToShatter in objectsToShatter) {
|
|
GameObject [] shatters = randomShatterSingle (objectToShatter, crossSectionMaterial);
|
|
|
|
if (shatters != null) {
|
|
foreach (GameObject add in shatters) {
|
|
adders.Add (add);
|
|
}
|
|
|
|
removals.Add (objectToShatter);
|
|
}
|
|
}
|
|
|
|
foreach (GameObject rem in removals) {
|
|
objectsToShatter.Remove (rem);
|
|
}
|
|
|
|
foreach (GameObject add in adders) {
|
|
objectsToShatter.Add (add);
|
|
}
|
|
}
|
|
|
|
public GameObject [] randomShatterSingle (GameObject objectToShatter, Material crossSectionMaterial)
|
|
{
|
|
Vector3 shatterPosition = objectToShatter.transform.position;
|
|
|
|
GameObject [] shatters = sliceSystemUtils.shatterObject (objectToShatter, shatterPosition, crossSectionMaterial);
|
|
|
|
if (shatters != null && shatters.Length > 0) {
|
|
objectToShatter.SetActive (false);
|
|
|
|
Vector3 cutPosition = objectToShatter.transform.position;
|
|
|
|
// add rigidbodies and colliders
|
|
foreach (GameObject shatteredObject in shatters) {
|
|
shatteredObject.AddComponent<MeshCollider> ().convex = true;
|
|
|
|
if (applyForceOnShatter) {
|
|
Rigidbody currentObjectRigidbody = shatteredObject.AddComponent<Rigidbody> ();
|
|
|
|
currentObjectRigidbody.AddExplosionForce (forceToApplyToCutPart, cutPosition, 10, 1, forceMode);
|
|
} else {
|
|
shatteredObject.AddComponent<Rigidbody> ();
|
|
}
|
|
|
|
if (addSliceComponentToPieces) {
|
|
surfaceToSlice newSurfaceToSlice = shatteredObject.AddComponent<surfaceToSlice> ();
|
|
|
|
newSurfaceToSlice.setCrossSectionMaterial (crossSectionMaterial);
|
|
}
|
|
}
|
|
}
|
|
|
|
return shatters;
|
|
}
|
|
|
|
public override void resetProjectile ()
|
|
{
|
|
base.resetProjectile ();
|
|
|
|
currentNumberOfCuts = 0;
|
|
|
|
objectsDetected.Clear ();
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
void OnDrawGizmos ()
|
|
{
|
|
if (!showGizmo) {
|
|
return;
|
|
}
|
|
|
|
if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
|
|
DrawGizmos ();
|
|
}
|
|
}
|
|
|
|
void OnDrawGizmosSelected ()
|
|
{
|
|
DrawGizmos ();
|
|
}
|
|
|
|
void DrawGizmos ()
|
|
{
|
|
if (showGizmo) {
|
|
GKC_Utils.drawRectangleGizmo (cutPositionTransform.position, cutPositionTransform.rotation, Vector3.zero, cutOverlapBoxSize, gizmoColor);
|
|
}
|
|
}
|
|
#endif
|
|
} |