add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Devices/electronicDevice.cs

@@ -0,0 +1,504 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using UnityEngine.EventSystems;
+
+public class electronicDevice : MonoBehaviour
+{
+    public string playerTag = "Player";
+
+    public bool useOnlyForTrigger;
+    public string functionToSetPlayer;
+
+    public bool activateDeviceOnTriggerEnter;
+
+    public bool useFreeInteraction;
+    public bool useFreeInteractionEvent;
+    public UnityEvent freeInteractionEvent;
+
+    public bool useMoveCameraToDevice;
+    public bool disableDeviceWhenStopUsing;
+    public bool stopUsingDeviceWhenUnlock;
+    public bool disableAndRemoveDeviceWhenUnlock;
+    public UnityEvent functionToUseDevice = new UnityEvent ();
+    public bool usingDevice;
+    //public LayerMask layerForUsers;
+
+    public UnityEvent unlockFunctionCall = new UnityEvent ();
+    public UnityEvent lockFunctionCall = new UnityEvent ();
+    public GameObject currentPlayer;
+
+    public bool activateEventOnTriggerStay;
+    public UnityEvent triggerStayEvent = new UnityEvent ();
+    public float eventOnTriggerStayRate;
+    public bool activateEventOnTriggerEnter;
+    public UnityEvent triggerEnterEvent = new UnityEvent ();
+    public bool activateEventOnTriggerExit;
+    public UnityEvent triggerExitEvent = new UnityEvent ();
+
+    public bool sendPlayerOnTriggerEnter;
+    public eventParameters.eventToCallWithGameObject eventToSendPlayerOnTriggerEnter;
+    public bool sendPlayerOnTriggerExit;
+    public eventParameters.eventToCallWithGameObject eventToSendPlayerOnTriggerExit;
+
+    public bool activateEventIfUnableToUseDevice;
+    public UnityEvent unableToUseDeviceEvent = new UnityEvent ();
+
+    public bool sendCurrentPlayerOnEvent;
+    public eventParameters.eventToCallWithGameObject setCurrentPlayerEvent;
+
+    public bool useEventOnStartUsingDevice;
+    public bool useEventOnStopUsingDevice;
+    public UnityEvent eventOnStartUsingDevice;
+    public UnityEvent eventOnStopUsingDevice;
+
+    public bool deviceCanBeUsed = true;
+
+    public bool playerInside;
+
+    float lastTimeEventOnTriggerStay;
+
+    public moveCameraToDevice cameraMovementManager;
+    public moveDeviceToCamera deviceMovementManager;
+
+    public bool disableDeviceInteractionAfterUsingOnce;
+
+
+    public bool useConditionSystemToStartDevice;
+
+    public GKCConditionInfo mainGKCConditionInfoToStartDevice;
+
+    public bool useConditionSystemToStopDevice;
+
+    public GKCConditionInfo mainGKCConditionInfoToStopDevice;
+
+    public bool showDebugPrint;
+
+
+    List<GameObject> playerFoundList = new List<GameObject> ();
+
+
+    void Start ()
+    {
+        if (cameraMovementManager == null) {
+            cameraMovementManager = GetComponent<moveCameraToDevice> ();
+        }
+
+        if (deviceMovementManager == null) {
+            deviceMovementManager = GetComponent<moveDeviceToCamera> ();
+        }
+
+        //layerForUsers =  LayerMask.NameToLayer("player") << 0;
+    }
+
+    void Update ()
+    {
+        if (playerInside && activateEventOnTriggerStay) {
+            if (Time.time > lastTimeEventOnTriggerStay + eventOnTriggerStayRate) {
+                triggerStayEvent.Invoke ();
+                lastTimeEventOnTriggerStay = Time.time;
+            }
+        }
+    }
+
+    public void activateDevice ()
+    {
+        if (showDebugPrint) {
+            print ("checking to activateDevice");
+        }
+
+        if (!deviceCanBeUsed) {
+            if (activateEventIfUnableToUseDevice) {
+                if (unableToUseDeviceEvent.GetPersistentEventCount () > 0) {
+                    unableToUseDeviceEvent.Invoke ();
+                }
+            }
+
+            if (showDebugPrint) {
+                print ("cancel");
+            }
+
+            return;
+        }
+
+        if (useConditionSystemToStartDevice) {
+            if (!usingDevice) {
+                if (mainGKCConditionInfoToStartDevice != null) {
+                    if (!mainGKCConditionInfoToStartDevice.checkIfConditionCompleteAndReturnResult ()) {
+                        if (showDebugPrint) {
+                            print ("cancel");
+                        }
+
+                        return;
+                    }
+                }
+            }
+        }
+
+        if (useConditionSystemToStopDevice) {
+            if (usingDevice) {
+                if (mainGKCConditionInfoToStopDevice != null) {
+                    if (!mainGKCConditionInfoToStopDevice.checkIfConditionCompleteAndReturnResult ()) {
+                        if (showDebugPrint) {
+                            print ("cancel");
+                        }
+
+                        return;
+                    }
+                }
+            }
+        }
+
+        if (!useOnlyForTrigger) {
+            if (usingDevice && !useMoveCameraToDevice && !useFreeInteraction) {
+                if (showDebugPrint) {
+                    print ("cancel");
+                }
+
+                return;
+            }
+        }
+
+        if (useFreeInteraction && usingDevice) {
+            if (useFreeInteractionEvent) {
+                freeInteractionEvent.Invoke ();
+            }
+        } else {
+            setDeviceState (!usingDevice);
+        }
+
+        if (showDebugPrint) {
+            print ("calling to activate device state " + usingDevice);
+        }
+    }
+
+    public void setDeviceState (bool state)
+    {
+        usingDevice = state;
+
+        if (showDebugPrint) {
+            print ("setDeviceState " + usingDevice);
+        }
+
+        if (!useOnlyForTrigger) {
+            if (useMoveCameraToDevice) {
+                moveCamera (usingDevice);
+            }
+        }
+
+        functionToUseDevice.Invoke ();
+
+        if (usingDevice) {
+            if (useEventOnStartUsingDevice) {
+                eventOnStartUsingDevice.Invoke ();
+            }
+        } else {
+            if (useEventOnStopUsingDevice) {
+                eventOnStopUsingDevice.Invoke ();
+            }
+        }
+
+        if (!usingDevice) {
+            if (disableDeviceInteractionAfterUsingOnce) {
+                removeDeviceFromList ();
+            }
+        }
+    }
+
+    public void moveCamera (bool state)
+    {
+        if (cameraMovementManager != null) {
+            cameraMovementManager.moveCamera (usingDevice);
+        }
+
+        if (deviceMovementManager != null) {
+            deviceMovementManager.moveCamera (usingDevice);
+        }
+    }
+
+    public void setCurrentUser (GameObject newPlayer)
+    {
+        if (!usingDevice) {
+            currentPlayer = newPlayer;
+
+            if (cameraMovementManager != null) {
+                cameraMovementManager.setCurrentPlayer (currentPlayer);
+            }
+
+            if (deviceMovementManager != null) {
+                deviceMovementManager.setCurrentPlayer (currentPlayer);
+            }
+        }
+    }
+
+    public void setPlayerManually (GameObject newPlayer)
+    {
+        if (newPlayer != null) {
+            Collider newPlayerCollider = newPlayer.GetComponent<Collider> ();
+
+            if (newPlayerCollider != null) {
+                checkTriggerInfo (newPlayerCollider, true);
+            }
+        }
+    }
+
+    //check when the player enters or exits of the trigger in the device
+    void OnTriggerEnter (Collider col)
+    {
+        checkTriggerInfo (col, true);
+    }
+
+    void OnTriggerExit (Collider col)
+    {
+        checkTriggerInfo (col, false);
+    }
+
+    public void checkTriggerInfo (Collider col, bool isEnter)
+    {
+        //if ((1 << col.gameObject.layer & layerForUsers.value) == 1 << col.gameObject.layer) {
+        //}
+        //if the player is entering in the trigger
+        //print (isEnter + " " + col.name + " " + col.CompareTag (playerTag) + col.gameObject.name);
+
+        //if (currentPlayer != null) {
+        //    print ((currentPlayer == col.gameObject) + " " + (col.transform.IsChildOf (currentPlayer.transform)));
+        //}
+
+        if (isEnter) {
+            //if the device is already being used, return
+            if (usingDevice) {
+                return;
+            }
+
+            if (col.CompareTag (playerTag)) {
+
+                bool isNewPayerFound = false;
+
+                if (!playerFoundList.Contains (col.gameObject)) {
+                    playerFoundList.Add (col.gameObject);
+
+                    isNewPayerFound = true;
+                }
+
+                currentPlayer = col.gameObject;
+
+                if (useOnlyForTrigger || !useMoveCameraToDevice) {
+
+                    if (cameraMovementManager != null) {
+                        cameraMovementManager.setCurrentPlayer (currentPlayer);
+                    }
+
+                    if (deviceMovementManager != null) {
+                        deviceMovementManager.setCurrentPlayer (currentPlayer);
+                    }
+
+                    if (useOnlyForTrigger) {
+                        if (functionToSetPlayer != "") {
+                            SendMessage (functionToSetPlayer, currentPlayer, SendMessageOptions.DontRequireReceiver);
+                        }
+                    } else {
+                        if (!useMoveCameraToDevice) {
+                            setDeviceState (true);
+                        }
+                    }
+                }
+
+                if (sendCurrentPlayerOnEvent) {
+                    setCurrentPlayerEvent.Invoke (col.gameObject);
+                }
+
+                if (activateEventOnTriggerEnter) {
+                    triggerEnterEvent.Invoke ();
+                }
+
+                if (sendPlayerOnTriggerEnter) {
+                    eventToSendPlayerOnTriggerEnter.Invoke (col.gameObject);
+                }
+
+                playerInside = true;
+
+                if (activateDeviceOnTriggerEnter && isNewPayerFound) {
+                    usingDevicesSystem currentUsingDevicesSystem = col.gameObject.GetComponent<usingDevicesSystem> ();
+
+                    if (currentUsingDevicesSystem != null) {
+                        currentUsingDevicesSystem.useCurrentDevice (gameObject);
+                    }
+                }
+            }
+        } else {
+            if ((usingDevice && !useFreeInteraction) || (useFreeInteraction && currentPlayer != col.gameObject)) {
+                return;
+            }
+
+            //if the player is leaving the trigger
+            if (col.CompareTag (playerTag)) {
+                //if the player is the same that was using the device, the device can be used again
+                if (playerFoundList.Contains (col.gameObject)) {
+                    playerFoundList.Remove (col.gameObject);
+                }
+
+                if (playerFoundList.Count == 0) {
+                    currentPlayer = null;
+
+                    if (useOnlyForTrigger) {
+                        usingDevice = false;
+                    } else {
+                        if (!useMoveCameraToDevice || disableDeviceWhenStopUsing) {
+                            setDeviceState (false);
+                        }
+                    }
+
+                    if (activateEventOnTriggerExit) {
+                        triggerExitEvent.Invoke ();
+                    }
+
+                    if (sendPlayerOnTriggerExit) {
+                        eventToSendPlayerOnTriggerExit.Invoke (col.gameObject);
+                    }
+
+                    playerInside = false;
+
+                    lastTimeEventOnTriggerStay = 0;
+                }
+            }
+        }
+    }
+
+    public void setUsingDeviceState (bool state)
+    {
+        usingDevice = state;
+    }
+
+    public GameObject getCurrentPlayer ()
+    {
+        return currentPlayer;
+    }
+
+    public void unlockObject ()
+    {
+        if (unlockFunctionCall.GetPersistentEventCount () > 0) {
+            unlockFunctionCall.Invoke ();
+        }
+
+        if (disableAndRemoveDeviceWhenUnlock) {
+            removeDeviceFromList ();
+        }
+    }
+
+    public void lockObject ()
+    {
+        if (lockFunctionCall.GetPersistentEventCount () > 0) {
+            lockFunctionCall.Invoke ();
+        }
+    }
+
+    public void removeDeviceFromListWithoutDisablingDevice ()
+    {
+        if (playerFoundList.Count > 0) {
+            for (int i = 0; i < playerFoundList.Count; i++) {
+                playerFoundList [i].GetComponent<usingDevicesSystem> ().removeDeviceFromList (gameObject);
+            }
+
+            //playerFoundList.Clear ();
+
+        }
+    }
+
+    public void clearDeviceList ()
+    {
+        if (playerFoundList.Count > 0) {
+            for (int i = 0; i < playerFoundList.Count; i++) {
+                playerFoundList [i].GetComponent<usingDevicesSystem> ().clearDeviceList ();
+            }
+        }
+    }
+
+    public void addDeviceToList ()
+    {
+        if (playerFoundList.Count > 0) {
+            for (int i = 0; i < playerFoundList.Count; i++) {
+                playerFoundList [i].GetComponent<usingDevicesSystem> ().addDeviceToListIfNotAlreadyIncluded (gameObject);
+            }
+        }
+    }
+
+    public void removeDeviceFromList ()
+    {
+        if (playerFoundList.Count > 0) {
+            for (int i = 0; i < playerFoundList.Count; i++) {
+                playerFoundList [i].GetComponent<usingDevicesSystem> ().removeDeviceFromList (gameObject);
+            }
+
+            gameObject.tag = "Untagged";
+
+            //playerFoundList.Clear ();
+        }
+    }
+
+    public void removeDeviceFromListOnAllPlayersOnSceneWithoutDisablingDevice ()
+    {
+        GKC_Utils.removeDeviceFromListOnAllPlayersOnSceneWithoutDisablingDevice (gameObject);
+    }
+
+    public void removeDeviceFromListExternalCall ()
+    {
+        if (playerFoundList.Count > 0) {
+            for (int i = 0; i < playerFoundList.Count; i++) {
+                playerFoundList [i].GetComponent<usingDevicesSystem> ().removeDeviceFromListExternalCall (gameObject);
+            }
+
+            gameObject.tag = "Untagged";
+
+            //playerFoundList.Clear ();
+        }
+    }
+
+    public void stopUsindDevice ()
+    {
+        if (stopUsingDeviceWhenUnlock) {
+            setDeviceState (false);
+        }
+    }
+
+    public void stopUseDeviceToPlayer ()
+    {
+        if (currentPlayer != null) {
+            currentPlayer.GetComponent<usingDevicesSystem> ().useDevice ();
+        }
+    }
+
+    public void reloadDeviceStringActionOnPlayer ()
+    {
+        if (playerFoundList.Count > 0) {
+            for (int i = 0; i < playerFoundList.Count; i++) {
+                playerFoundList [i].GetComponent<usingDevicesSystem> ().reloadDeviceStringActionOnPlayer (gameObject);
+            }
+        }
+    }
+
+    public void setDeviceCanBeUsedState (bool state)
+    {
+        deviceCanBeUsed = state;
+    }
+
+    public void cancelUseElectronicDevice ()
+    {
+        if (usingDevice) {
+            activateDevice ();
+        }
+    }
+
+    public void useDeviceObjectExternally (GameObject currentPlayer)
+    {
+        GKC_Utils.useDeviceObjectExternally (currentPlayer, gameObject);
+    }
+
+    public void useDeviceObjectExternallyForCharacterInside ()
+    {
+        if (currentPlayer != null) {
+            GKC_Utils.useDeviceObjectExternally (currentPlayer, gameObject);
+        }
+    }
+}