add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Grab Objects/putObjectSystem.cs

@@ -0,0 +1,694 @@
+using System.Collections;
+using System.Collections.Generic;
+using GameKitController.Audio;
+using UnityEngine;
+using UnityEngine.Events;
+
+public class putObjectSystem : MonoBehaviour
+{
+    public string objectName;
+
+    public bool putObjectSystemEnabled = true;
+
+    public bool ignoreTriggerEnterExitFunctionsEnabled;
+
+    public bool useCertainObjectToPlace;
+    public GameObject certainObjectToPlace;
+    public string objectNameToPlace;
+
+    public bool useObjectNameListToPlace;
+
+    public List<string> objectNameListToPlace = new List<string> ();
+
+    public Transform placeToPutObject;
+
+    public GameObject currentObjectPlaced;
+
+    public float placeObjectPositionSpeed;
+    public float placeObjectRotationSpeed;
+
+    public bool useRotationLimit;
+    public float maxUpRotationAngle = 30;
+    public float maxForwardRotationAngle = 30;
+
+    public bool usePositionLimit;
+    public float maxPositionDistance;
+
+    public bool needsOtherObjectPlacedBefore;
+    public int numberOfObjectsToPlaceBefore;
+
+    public bool disableObjectOnceIsPlaced;
+
+    public bool objectInsideTrigger;
+    public bool objectPlaced;
+
+    public bool waitToObjectPlacedToCallEvent;
+
+    public objectToPlaceSystem currentObjectToPlaceSystem;
+
+    public bool useLimitToCheckIfObjectRemoved;
+    public float minDistanceToRemoveObject;
+
+    public bool checkingIfObjectIsRemoved;
+
+    public float minWaitToPutSameObjectAgain = 0.7f;
+    public bool updateTriggerStateAfterWait;
+
+    public UnityEvent objectPlacedEvent;
+    public UnityEvent objectRemovedEvent;
+
+    public bool useSoundEffectOnObjectPlaced;
+    public AudioClip soundEffectOnObjectPlaced;
+    public AudioElement onObjectPlacedAudioElement;
+    public bool useSoundEffectOnObjectRemoved;
+    public AudioClip soundEffectOnObjectRemoved;
+    public AudioElement onObjectRemovedAudioElement;
+    public AudioSource mainAudioSource;
+
+    public Collider mainTrigger;
+
+    public bool destroyObjectOncePlaced;
+
+    public bool objectAdjustedToPlacePosition;
+
+
+    Coroutine placeObjectCoroutine;
+    int currentNumberObjectsPlaced;
+
+    bool objectInCorrectPosition;
+    bool objectInCorrectRotation;
+    bool movingObject;
+
+    float lastTimeObjectRemoved;
+    GameObject lastObjectPlaced;
+
+    Coroutine pauseCoroutine;
+
+    bool cancelPlaceObjectActive;
+
+
+    private void InitializeAudioElements ()
+    {
+        if (mainAudioSource != null) {
+            onObjectPlacedAudioElement.audioSource = mainAudioSource;
+            onObjectRemovedAudioElement.audioSource = mainAudioSource;
+        }
+
+        if (soundEffectOnObjectPlaced != null) {
+            onObjectPlacedAudioElement.clip = soundEffectOnObjectPlaced;
+        }
+
+        if (soundEffectOnObjectRemoved != null) {
+            onObjectRemovedAudioElement.clip = soundEffectOnObjectRemoved;
+        }
+    }
+
+    private void Start ()
+    {
+        InitializeAudioElements ();
+    }
+
+    void Update ()
+    {
+        if (objectInsideTrigger) {
+            if (!objectPlaced) {
+                if (useRotationLimit) {
+                    float forwardAngle = Vector3.SignedAngle (transform.forward, currentObjectPlaced.transform.forward, transform.up);
+                    float upAngle = Vector3.SignedAngle (transform.up, currentObjectPlaced.transform.up, transform.forward);
+
+                    if (Mathf.Abs (forwardAngle) > maxForwardRotationAngle || Mathf.Abs (upAngle) > maxUpRotationAngle) {
+                        objectInCorrectRotation = false;
+                    } else {
+                        objectInCorrectRotation = true;
+                    }
+                }
+
+                if (usePositionLimit) {
+                    float currentDistance = GKC_Utils.distance (currentObjectPlaced.transform.position, transform.position);
+
+                    if (currentDistance <= maxPositionDistance) {
+                        objectInCorrectPosition = true;
+                    } else {
+                        objectInCorrectPosition = false;
+                    }
+                }
+
+                if (useRotationLimit && !objectInCorrectRotation) {
+                    return;
+                }
+
+                if (usePositionLimit && !objectInCorrectPosition) {
+                    return;
+                }
+
+                checkIfCanBePlaced (false);
+            } else {
+                if (checkingIfObjectIsRemoved) {
+                    float currentDistance = GKC_Utils.distance (currentObjectPlaced.transform.position, placeToPutObject.position);
+
+                    if (currentDistance > minDistanceToRemoveObject) {
+                        removeObject ();
+                    } else {
+                        if (!currentObjectToPlaceSystem.isObjectInGrabbedState ()) {
+                            checkIfCanBePlaced (true);
+                        }
+                    }
+                }
+
+                if (destroyObjectOncePlaced) {
+                    if (objectAdjustedToPlacePosition) {
+                        GameObject objectToDestroy = currentObjectPlaced;
+
+                        removeObject ();
+
+                        if (objectToDestroy != null) {
+                            Destroy (objectToDestroy);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public void destroyCurrentObjectPlaced ()
+    {
+        if (objectAdjustedToPlacePosition) {
+            GameObject objectToDestroy = currentObjectPlaced;
+
+            removeObject ();
+
+            if (objectToDestroy != null) {
+                Destroy (objectToDestroy);
+            }
+        }
+    }
+
+    public void OnTriggerEnter (Collider col)
+    {
+        if (ignoreTriggerEnterExitFunctionsEnabled) {
+            return;
+        }
+
+        checkTriggerInfo (true, col.gameObject);
+    }
+
+    public void OnTriggerExit (Collider col)
+    {
+        if (ignoreTriggerEnterExitFunctionsEnabled) {
+            return;
+        }
+
+        checkTriggerInfo (false, col.gameObject);
+    }
+
+    public void checkTriggerInfo (bool isEnter, GameObject objectToCheck)
+    {
+        checkObjectToPlace (isEnter, objectToCheck);
+    }
+
+    public void placeObject (GameObject objectToCheck)
+    {
+        checkObjectToPlace (true, objectToCheck);
+    }
+
+    void checkObjectToPlace (bool isEnter, GameObject objectToCheck)
+    {
+        if (!putObjectSystemEnabled) {
+            return;
+        }
+
+        if (isEnter) {
+            if (!objectPlaced) {
+                objectToCheck = canBeDragged (objectToCheck);
+
+                if (objectToCheck != null) {
+                    if (objectToCheck == lastObjectPlaced && Time.time < lastTimeObjectRemoved + minWaitToPutSameObjectAgain) {
+                        if (updateTriggerStateAfterWait) {
+                            pausePutObject ();
+                        }
+
+                        //print ("same object to soon, pausing");
+
+                        return;
+                    }
+
+                    currentObjectPlaced = objectToCheck;
+
+                    if (!useRotationLimit && !usePositionLimit) {
+                        checkIfCanBePlaced (false);
+                    }
+
+                    objectInsideTrigger = true;
+
+                    lastObjectPlaced = currentObjectPlaced;
+
+                    if (cancelPlaceObjectActive) {
+                        resetPlacedObjectValues ();
+                    }
+
+                    cancelPlaceObjectActive = false;
+                }
+            }
+        } else {
+            if (!objectPlaced) {
+                objectToCheck = canBeDragged (objectToCheck);
+
+                if (objectToCheck != null) {
+                    currentObjectPlaced = null;
+                    objectInsideTrigger = false;
+
+                    lastTimeObjectRemoved = Time.time;
+
+                    //print ("updating last time");
+                }
+            }
+        }
+    }
+
+    public void checkIfCanBePlaced (bool objectPlacedPreviously)
+    {
+        bool objectCanBePlaced = true;
+
+        if (needsOtherObjectPlacedBefore) {
+            if (numberOfObjectsToPlaceBefore != currentNumberObjectsPlaced) {
+                objectCanBePlaced = false;
+            }
+        }
+
+        if (objectCanBePlaced) {
+            Rigidbody mainRigidbody = currentObjectPlaced.GetComponent<Rigidbody> ();
+
+            if (mainRigidbody != null) {
+                mainRigidbody.isKinematic = true;
+            }
+
+            moveObjectToPlace (objectPlacedPreviously);
+
+            objectPlaced = true;
+
+            checkingIfObjectIsRemoved = false;
+        }
+    }
+
+    public GameObject canBeDragged (GameObject objectToCheck)
+    {
+        if (useCertainObjectToPlace) {
+            if (objectToCheck == certainObjectToPlace || objectToCheck.transform.IsChildOf (certainObjectToPlace.transform)) {
+                return objectToCheck;
+            }
+        } else {
+            currentObjectToPlaceSystem = objectToCheck.GetComponent<objectToPlaceSystem> ();
+
+            if (currentObjectToPlaceSystem != null) {
+                if (useObjectNameListToPlace) {
+                    if (objectNameListToPlace.Contains (currentObjectToPlaceSystem.getObjectName ())) {
+                        return objectToCheck;
+                    }
+                } else {
+                    if (objectNameToPlace == currentObjectToPlaceSystem.getObjectName ()) {
+                        return objectToCheck;
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public void moveObjectToPlace (bool objectPlacedPreviously)
+    {
+        stopMoveObjectToPlaceCoroutine ();
+
+        stopPausePutObjectCoroutine ();
+
+        placeObjectCoroutine = StartCoroutine (placeObjectIntoPosition (objectPlacedPreviously));
+    }
+
+    public void stopMoveObjectToPlaceCoroutine ()
+    {
+        if (placeObjectCoroutine != null) {
+            StopCoroutine (placeObjectCoroutine);
+        }
+    }
+
+    IEnumerator placeObjectIntoPosition (bool objectPlacedPreviously)
+    {
+        objectAdjustedToPlacePosition = false;
+
+        grabbedObjectState currentGrabbedObject = currentObjectPlaced.GetComponent<grabbedObjectState> ();
+
+        bool objectCanBePlaced = true;
+
+        if (currentGrabbedObject != null) {
+            objectCanBePlaced = GKC_Utils.checkIfObjectCanBePlaced (currentGrabbedObject.getCurrentHolder (), currentObjectPlaced);
+
+            if (!objectCanBePlaced) {
+                cancelPlaceObjectActive = true;
+            }
+        }
+
+        currentObjectToPlaceSystem.setAdjustingObjectToPlaceInProcessState (true);
+
+        if (objectCanBePlaced) {
+            bool objectCanCallPlacedEvent = currentObjectToPlaceSystem.canObjectCanCallPlacedEvent ();
+
+            if (!objectPlacedPreviously) {
+                if (useSoundEffectOnObjectPlaced && objectCanCallPlacedEvent) {
+                    playSound (onObjectPlacedAudioElement);
+                }
+            }
+
+            if (currentGrabbedObject != null) {
+                GKC_Utils.dropObject (currentGrabbedObject.getCurrentHolder (), currentObjectPlaced);
+            }
+
+            Rigidbody mainRigidbody = currentObjectPlaced.GetComponent<Rigidbody> ();
+
+            if (mainRigidbody != null) {
+                mainRigidbody.isKinematic = true;
+            }
+
+            currentObjectToPlaceSystem.assignPutObjectSystem (this);
+
+            currentObjectToPlaceSystem.setObjectPlaceState (true);
+
+            currentObjectToPlaceSystem.checkEventOnObjectPlacedStateChanged (true);
+
+            if (disableObjectOnceIsPlaced) {
+                currentObjectToPlaceSystem.setObjectToPlacedEnabledState (false);
+
+                grabPhysicalObjectSystem currentGrabPhysicalObjectSystem = currentObjectPlaced.GetComponent<grabPhysicalObjectSystem> ();
+
+                if (currentGrabPhysicalObjectSystem != null) {
+                    currentGrabPhysicalObjectSystem.disableGrabPhysicalObject ();
+                }
+            }
+
+            if (!objectPlacedPreviously) {
+                if (!waitToObjectPlacedToCallEvent && objectCanCallPlacedEvent) {
+                    bool checkEventResult = false;
+
+                    if (currentObjectToPlaceSystem.isUseSecondaryObjectToPlaceConnectedEnabled ()) {
+                        //if (currentObjectToPlaceSystem.isSecondaryObjectToPlaceConnected ()) {
+                        //    checkEventResult = true;
+                        //}
+
+                        //if (currentObjectToPlaceSystem.isConnectedToOtherObjectToPlace () ||
+                        //    currentObjectToPlaceSystem.secondaryObjectToPlaceSystem.isConnectedToOtherObjectToPlace ()) {
+                        //    checkEventResult = true;
+                        //}
+
+                        bool extremeConnectedResult = false;
+
+                        currentObjectToPlaceSystem.checkIfExtremeConnected (ref extremeConnectedResult, true, null);
+
+                        //print ("check extremeConnectedResult on object placed " + extremeConnectedResult);
+
+                        bool checkNameOnPutObjectSystemToCallEventResult = false;
+
+                        currentObjectToPlaceSystem.checkNameOnPutObjectSystemToCallEventResult (ref checkNameOnPutObjectSystemToCallEventResult, null);
+
+                        //print ("checkNameOnPutObjectSystemToCallEventResult " + checkNameOnPutObjectSystemToCallEventResult);
+
+                        if (extremeConnectedResult && checkNameOnPutObjectSystemToCallEventResult) {
+                            checkEventResult = true;
+                        }
+                    } else {
+                        checkEventResult = true;
+                    }
+
+                    if (checkEventResult) {
+                        checkEventsOnObjectPlacedOrRemoved (true);
+                    }
+                }
+            }
+
+            currentObjectToPlaceSystem.checkStateOnExtremesOnObjectPlaced ();
+
+            Transform objectTransform = currentObjectPlaced.transform;
+
+            objectTransform.SetParent (placeToPutObject);
+
+            Vector3 targetPosition = Vector3.zero;
+            Quaternion targetRotation = Quaternion.identity;
+
+            if (currentObjectToPlaceSystem.isUseCustomPlaceToPutObjectTransformActive ()) {
+                Transform customPlaceToPutObjectTransform = currentObjectToPlaceSystem.getCustomPlaceToPutObjectTransform ();
+
+                targetPosition = customPlaceToPutObjectTransform.localPosition;
+                targetRotation = customPlaceToPutObjectTransform.localRotation;
+            }
+
+            float dist = GKC_Utils.distance (objectTransform.position, placeToPutObject.position);
+            float duration = dist / placeObjectPositionSpeed;
+            float t = 0;
+
+            float timePassed = 0;
+
+            float angleDifference = 0;
+
+            float positionDifference = 0;
+
+            bool targetReached = false;
+
+            while (!targetReached) {
+                t += Time.deltaTime / duration;
+
+                objectTransform.localPosition = Vector3.MoveTowards (objectTransform.localPosition, targetPosition, t);
+                objectTransform.localRotation = Quaternion.Lerp (objectTransform.localRotation, targetRotation, t);
+
+                timePassed += Time.deltaTime;
+
+                angleDifference = Quaternion.Angle (objectTransform.localRotation, targetRotation);
+
+                positionDifference = GKC_Utils.distance (objectTransform.localPosition, targetPosition);
+
+                if (timePassed > 3) {
+                    targetReached = true;
+                }
+
+                if (positionDifference < 0.01f && angleDifference < 0.2f) {
+                    targetReached = true;
+                }
+
+                yield return null;
+            }
+
+            if (!objectPlacedPreviously) {
+                if (waitToObjectPlacedToCallEvent && objectCanCallPlacedEvent) {
+                    checkEventsOnObjectPlacedOrRemoved (false);
+                }
+            }
+        } else {
+            stopMoveObjectToPlaceCoroutine ();
+
+            resetPlacedObjectValues ();
+        }
+
+        objectAdjustedToPlacePosition = true;
+
+        currentObjectToPlaceSystem.setAdjustingObjectToPlaceInProcessState (false);
+    }
+
+    void resetPlacedObjectValues ()
+    {
+        objectPlaced = false;
+
+        currentObjectToPlaceSystem = null;
+
+        currentObjectPlaced = null;
+
+        objectInsideTrigger = false;
+
+        checkingIfObjectIsRemoved = false;
+
+        objectAdjustedToPlacePosition = false;
+    }
+
+    public void removePlacedObject ()
+    {
+        if (useLimitToCheckIfObjectRemoved) {
+            checkingIfObjectIsRemoved = true;
+        } else {
+            removeObject ();
+        }
+    }
+
+    public void dropCurrentObjectPlaced (bool reactivateObjectToUseOnPlaceSystem)
+    {
+        if (!putObjectSystemEnabled) {
+            return;
+        }
+
+        if (currentObjectToPlaceSystem == null) {
+            return;
+        }
+
+        Rigidbody currentRigidbody = currentObjectPlaced.GetComponent<Rigidbody> ();
+
+
+        if (reactivateObjectToUseOnPlaceSystem) {
+            currentObjectToPlaceSystem.setObjectToPlacedEnabledState (true);
+
+            currentObjectToPlaceSystem.setObjectPlaceState (false);
+
+            currentObjectToPlaceSystem.checkEventOnObjectPlacedStateChanged (false);
+
+            currentObjectToPlaceSystem.setAdjustingObjectToPlaceInProcessState (false);
+        }
+
+
+        grabPhysicalObjectSystem currentGrabPhysicalObjectSystem = currentObjectPlaced.GetComponent<grabPhysicalObjectSystem> ();
+
+        if (currentGrabPhysicalObjectSystem != null) {
+            currentGrabPhysicalObjectSystem.setGrabObjectPhysicallyEnabledState (true);
+        }
+
+
+        removeObject ();
+
+        if (currentRigidbody != null) {
+            currentRigidbody.isKinematic = false;
+
+            currentRigidbody.AddForce (placeToPutObject.forward * 10, ForceMode.Impulse);
+        }
+    }
+
+    public void removeObject ()
+    {
+        if (!putObjectSystemEnabled) {
+            return;
+        }
+
+        if (currentObjectToPlaceSystem == null) {
+            return;
+        }
+
+        bool objectCanCallRemovedEvent = currentObjectToPlaceSystem.canObjectCanCallRemovedEvent ();
+
+        if (objectCanCallRemovedEvent && useSoundEffectOnObjectRemoved) {
+            playSound (onObjectRemovedAudioElement);
+        }
+
+        stopMoveObjectToPlaceCoroutine ();
+
+        objectPlaced = false;
+
+        if (objectCanCallRemovedEvent) {
+            objectRemovedEvent.Invoke ();
+        }
+
+        currentObjectToPlaceSystem = null;
+
+        currentObjectPlaced.transform.SetParent (null);
+
+        currentObjectPlaced = null;
+
+        objectInsideTrigger = false;
+
+        checkingIfObjectIsRemoved = false;
+
+        objectAdjustedToPlacePosition = false;
+    }
+
+    public void checkEventsOnObjectPlacedOrRemoved (bool state)
+    {
+        //print ("checkEventsOnObjectPlacedOrRemoved " + state);
+
+        if (state) {
+            objectPlacedEvent.Invoke ();
+        } else {
+            objectRemovedEvent.Invoke ();
+        }
+    }
+
+    public void disableObjectPlacedFromGrab ()
+    {
+        if (currentObjectPlaced != null) {
+            currentObjectPlaced.tag = "Untagged";
+        }
+    }
+
+    public void increaseNumberObjectsPlaced ()
+    {
+        currentNumberObjectsPlaced++;
+    }
+
+    public void decreaseNumberObjectsPlaced ()
+    {
+        currentNumberObjectsPlaced--;
+
+        if (currentNumberObjectsPlaced < 0) {
+            currentNumberObjectsPlaced = 0;
+        }
+    }
+
+    public void resetNumberObjectsPlaced ()
+    {
+        if (placeObjectCoroutine != null) {
+            StopCoroutine (placeObjectCoroutine);
+        }
+
+        currentNumberObjectsPlaced = 0;
+
+        objectPlaced = false;
+
+        objectInsideTrigger = false;
+
+        objectAdjustedToPlacePosition = false;
+    }
+
+    public void playSound (AudioElement soundToPlay)
+    {
+        if (soundToPlay != null) {
+            AudioPlayer.PlayOneShot (soundToPlay, gameObject);
+        }
+    }
+
+    public void pausePutObject ()
+    {
+        stopPausePutObjectCoroutine ();
+
+        pauseCoroutine = StartCoroutine (pausePutObjectCoroutine ());
+    }
+
+    public void stopPausePutObjectCoroutine ()
+    {
+        if (pauseCoroutine != null) {
+            StopCoroutine (pauseCoroutine);
+        }
+    }
+
+    IEnumerator pausePutObjectCoroutine ()
+    {
+        yield return new WaitForSeconds (minWaitToPutSameObjectAgain);
+
+        if (mainTrigger == null) {
+            mainTrigger = GetComponent<Collider> ();
+        }
+
+        if (mainTrigger != null) {
+            mainTrigger.enabled = false;
+            mainTrigger.enabled = true;
+        }
+    }
+
+    public bool isPutObjectSystemEnabled ()
+    {
+        return putObjectSystemEnabled;
+    }
+
+    public string getObjectName ()
+    {
+        return objectName;
+    }
+
+    public Vector3 getPlaceToPutObjectPosition ()
+    {
+        if (placeToPutObject != null) {
+            return placeToPutObject.position;
+        }
+
+        return transform.position;
+    }
+}