add ckg

plantilla base para movimiento básico

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

@@ -0,0 +1,653 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.Events;
+
+public class elevatorSystem : MonoBehaviour
+{
+    public bool elevatorSystemEnabled = true;
+
+    public List<floorInfo> floors = new List<floorInfo> ();
+    public int currentFloor;
+    public float elevatorSpeed = 20;
+
+    public List<string> tagToCheckToMove = new List<string> ();
+
+    public bool canUseElevatorButtonsWithoutPlayerInside;
+
+    public bool hasInsideElevatorDoor;
+    public GameObject insideElevatorDoor;
+    public GameObject elevatorSwitchPrefab;
+    public bool addSwitchInNewFloors;
+    public GameObject elevatorDoorPrefab;
+    public bool addDoorInNewFloors;
+    public bool moving;
+    public bool doorsClosed = true;
+
+    public float floorHeight = 5;
+
+    public bool changeIconFloorWhenMoving;
+
+    public bool showGizmo;
+    public Color gizmoLabelColor;
+
+    public bool useEventsOnMoveStartAndEnd;
+    public UnityEvent eventOnMoveStart;
+    public UnityEvent eventOnMoveEnd;
+
+    int currentDirectionToMove = 1;
+
+    bool anyPlayerInsideElevator;
+
+    int i;
+    bool lockedElevator;
+    bool closingDoors;
+    Coroutine elevatorMovement;
+    mapObjectInformation mapObjectInformationManager;
+
+    public List<passengersInfo> passengersInfoList = new List<passengersInfo> ();
+
+    List<GameObject> regularObjectsList = new List<GameObject> ();
+
+    int previousFloorIndex;
+
+    doorSystem insideElevatorDoorSystem;
+
+    bool allDoorsClosed;
+
+    floorInfo currentFloorInfo;
+
+    bool insideElevatorDoorLocated;
+
+    void Start ()
+    {
+        if (mapObjectInformationManager == null) {
+            mapObjectInformationManager = GetComponent<mapObjectInformation> ();
+        }
+
+        if (insideElevatorDoor != null) {
+            insideElevatorDoorSystem = insideElevatorDoor.GetComponent<doorSystem> ();
+
+            insideElevatorDoorLocated = insideElevatorDoorSystem != null;
+        }
+    }
+
+    void Update ()
+    {
+        //check if there is doors in the elevator to close them and start the elevator movement when they are closed
+        if (closingDoors) {
+            if (insideElevatorDoorLocated || floors [previousFloorIndex].outsideElevatorDoorLocated) {
+                allDoorsClosed = false;
+
+                //print (!insideElevatorDoorSystem + " " + insideElevatorDoorSystem.isDoorClosed ());
+
+                //				print (!floors [previousFloorIndex].outsideElevatorDoorSystem + " " + floors [previousFloorIndex].outsideElevatorDoorSystem.isDoorClosed ());
+
+                if ((!insideElevatorDoorLocated || insideElevatorDoorSystem.isDoorClosed ()) &&
+                    (!floors [previousFloorIndex].outsideElevatorDoorLocated || floors [previousFloorIndex].outsideElevatorDoorSystem.isDoorClosed ())) {
+                    allDoorsClosed = true;
+                }
+
+                if (allDoorsClosed) {
+                    closingDoors = false;
+
+                    checkElevatorMovement ();
+                }
+            } else {
+                closingDoors = false;
+
+                checkElevatorMovement ();
+            }
+        }
+    }
+
+    //the player has press the button move up, so increase the current floor count
+    public void nextFloor ()
+    {
+        if (!elevatorSystemEnabled) {
+            return;
+        }
+
+        getFloorNumberToMove (1);
+    }
+
+    //the player has press the button move down, so decrease the current floor count
+    public void previousFloor ()
+    {
+        if (!elevatorSystemEnabled) {
+            return;
+        }
+
+        getFloorNumberToMove (-1);
+    }
+
+    public void moveBetweenTwoPositions ()
+    {
+        if (!elevatorSystemEnabled) {
+            return;
+        }
+
+        getFloorNumberToMove (currentDirectionToMove);
+
+        currentDirectionToMove *= -1;
+    }
+
+    //move to the floor, according to the direction selected by the player
+    void getFloorNumberToMove (int direction)
+    {
+        //if the player is inside the elevator and it is not moving, then 
+        if ((anyPlayerInsideElevator || canUseElevatorButtonsWithoutPlayerInside) && !moving) {
+            //change the current floor to the next or the previous
+            int floorIndex = currentFloor + direction;
+
+            //check that the floor exists, and start to move the elevator to that floor position
+            if (floorIndex < floors.Count && floorIndex >= 0) {
+                openOrCloseElevatorDoors ();
+
+                previousFloorIndex = currentFloor;
+
+                currentFloor = floorIndex;
+
+                checkIfInsideElevatorDoorSystem ();
+
+                closingDoors = true;
+
+                setAllPlayersParent (transform);
+            }
+        }
+    }
+
+    public void checkIfInsideElevatorDoorSystem ()
+    {
+        if (floors [currentFloor].outsideElevatorDoor != null) {
+            if (!floors [currentFloor].outsideElevatorDoorLocated) {
+                floors [currentFloor].outsideElevatorDoorSystem = floors [currentFloor].outsideElevatorDoor.GetComponent<doorSystem> ();
+
+                floors [currentFloor].outsideElevatorDoorLocated = floors [currentFloor].outsideElevatorDoorSystem != null;
+            }
+        }
+    }
+
+    //move to the floor, according to the direction selected by the player
+    public bool goToNumberFloor (int floorNumber)
+    {
+        if (!elevatorSystemEnabled) {
+            return false;
+        }
+
+        bool canMoveToFloor = false;
+
+        //if the player is inside the elevator and it is not moving, then 
+        if ((anyPlayerInsideElevator || canUseElevatorButtonsWithoutPlayerInside) && !moving) {
+            //check that the floor exists, and start to move the elevator to that floor position
+            if (floorNumber < floors.Count && floorNumber >= 0 && floorNumber != currentFloor) {
+                openOrCloseElevatorDoors ();
+
+                previousFloorIndex = currentFloor;
+
+                currentFloor = floorNumber;
+
+                checkIfInsideElevatorDoorSystem ();
+
+                closingDoors = true;
+
+                setAllPlayersParent (transform);
+
+                canMoveToFloor = true;
+            }
+        }
+
+        return canMoveToFloor;
+    }
+
+    //when a elevator button is pressed, move the elevator to that floor
+    public void callElevator (GameObject button)
+    {
+        if (!elevatorSystemEnabled) {
+            return;
+        }
+
+        if (moving) {
+            return;
+        }
+
+        for (i = 0; i < floors.Count; i++) {
+            if (floors [i].floorButton == button) {
+
+                lockedElevator = false;
+
+                if (floors [currentFloor].outsideElevatorDoor != null) {
+                    checkIfInsideElevatorDoorSystem ();
+
+                    if (floors [currentFloor].outsideElevatorDoorSystem.locked) {
+                        lockedElevator = true;
+                    }
+                }
+
+                if (!lockedElevator) {
+                    if (currentFloor != i) {
+                        if (!doorsClosed) {
+                            openOrCloseElevatorDoors ();
+                        }
+
+                        previousFloorIndex = currentFloor;
+
+                        currentFloor = i;
+
+                        checkIfInsideElevatorDoorSystem ();
+
+                        closingDoors = true;
+                    } else {
+                        openOrCloseElevatorDoors ();
+                    }
+                }
+            }
+        }
+    }
+
+    //open or close the inside and outside doors of the elevator if the elevator has every of this doors
+    void openOrCloseElevatorDoors ()
+    {
+        if (insideElevatorDoor != null) {
+            if (insideElevatorDoorSystem.doorState == doorSystem.doorCurrentState.closed) {
+                doorsClosed = false;
+            } else {
+                doorsClosed = true;
+            }
+
+            insideElevatorDoorSystem.changeDoorsStateByButton ();
+        }
+
+        if (floors [currentFloor].outsideElevatorDoor != null) {
+            checkIfInsideElevatorDoorSystem ();
+
+            floors [currentFloor].outsideElevatorDoorSystem.openOrCloseElevatorDoor ();
+        }
+    }
+
+    //stop the current elevator movement and start it again
+    void checkElevatorMovement ()
+    {
+        if (elevatorMovement != null) {
+            StopCoroutine (elevatorMovement);
+        }
+
+        elevatorMovement = StartCoroutine (moveElevator ());
+    }
+
+    IEnumerator moveElevator ()
+    {
+        moving = true;
+
+        currentFloorInfo = floors [currentFloor];
+
+        //move the elevator from its position to the currentfloor
+        Vector3 currentElevatorPosition = transform.localPosition;
+
+        Vector3 targetPosition = currentFloorInfo.floorPosition.localPosition;
+        Quaternion targetRotation = currentFloorInfo.floorPosition.localRotation;
+
+        bool rotateElevator = false;
+
+        if (targetRotation != Quaternion.identity || transform.localRotation != Quaternion.identity) {
+            rotateElevator = true;
+        }
+
+        float dist = GKC_Utils.distance (transform.position, currentFloorInfo.floorPosition.position);
+
+        // calculate the movement duration
+        float duration = dist / elevatorSpeed;
+        float t = 0;
+
+        bool targetReached = false;
+
+        float angleDifference = 0;
+
+        float movementTimer = 0;
+
+        float distanceToTarget = 0;
+
+        checkEventsOnMove (true);
+
+        if (currentFloorInfo.useEventsOnMoveStartAndEnd) {
+            currentFloorInfo.eventOnMoveStart.Invoke ();
+        }
+
+        while (!targetReached) {
+            t += Time.deltaTime / duration;
+
+            transform.localPosition = Vector3.Lerp (currentElevatorPosition, targetPosition, t);
+
+            if (rotateElevator) {
+                transform.localRotation = Quaternion.Lerp (transform.localRotation, targetRotation, t);
+            }
+
+            angleDifference = Quaternion.Angle (transform.localRotation, targetRotation);
+
+            movementTimer += Time.deltaTime;
+
+            dist = GKC_Utils.distance (transform.localPosition, targetPosition);
+
+            distanceToTarget = GKC_Utils.distance (transform.localPosition, targetPosition);
+
+            if ((dist < 0.02f && angleDifference < 0.02f && distanceToTarget < 0.02f) || movementTimer > (duration + 0.5f)) {
+                targetReached = true;
+            }
+
+            yield return null;
+        }
+
+        //if the elevator reachs the correct floor, stop its movement, and deattach the player of its childs
+        moving = false;
+
+        setAllPlayersParent (null);
+
+        openOrCloseElevatorDoors ();
+
+        if (changeIconFloorWhenMoving) {
+            if (mapObjectInformationManager != null) {
+                mapObjectInformationManager.changeMapObjectIconFloorByPosition ();
+            }
+        }
+
+        checkEventsOnMove (false);
+
+        if (currentFloorInfo.useEventsOnMoveStartAndEnd) {
+            currentFloorInfo.eventOnMoveEnd.Invoke ();
+        }
+    }
+
+    void OnTriggerEnter (Collider col)
+    {
+        //the player has entered in the elevator trigger, stored it and set the evelator as his parent
+        if (col.CompareTag ("Player")) {
+            addPassenger (col.gameObject.transform);
+
+            if (passengersInfoList.Count > 0) {
+                anyPlayerInsideElevator = true;
+            }
+
+            setPlayerParent (transform, col.gameObject.transform);
+        } else if (tagToCheckToMove.Contains (col.gameObject.tag)) {
+            if (!regularObjectsList.Contains (col.gameObject)) {
+                col.gameObject.transform.SetParent (transform);
+
+                regularObjectsList.Add (col.gameObject);
+            }
+        }
+    }
+
+    void OnTriggerExit (Collider col)
+    {
+        //the player has gone of the elevator trigger, remove the parent from the player
+        if (col.CompareTag ("Player")) {
+
+            setPlayerParent (null, col.gameObject.transform);
+
+            removePassenger (col.gameObject.transform);
+
+            if (passengersInfoList.Count == 0) {
+                anyPlayerInsideElevator = false;
+            }
+
+            if (!doorsClosed) {
+                openOrCloseElevatorDoors ();
+            }
+        } else if (tagToCheckToMove.Contains (col.gameObject.tag)) {
+            if (regularObjectsList.Contains (col.gameObject)) {
+                col.gameObject.transform.SetParent (null);
+
+                regularObjectsList.Remove (col.gameObject);
+            }
+        }
+    }
+
+    //attach and disattch the player and the camera inside the elevator
+    void setPlayerParent (Transform father, Transform newPassenger)
+    {
+        bool passengerFound = false;
+
+        passengersInfo newPassengersInfo = new passengersInfo ();
+
+        for (i = 0; i < passengersInfoList.Count; i++) {
+            if (passengersInfoList [i].playerTransform == newPassenger && !passengerFound) {
+                newPassengersInfo = passengersInfoList [i];
+                passengerFound = true;
+            }
+        }
+
+        if (passengerFound) {
+            newPassengersInfo.playerControllerManager.setPlayerAndCameraAndFBAPivotTransformParent (father);
+
+            newPassengersInfo.playerControllerManager.setMovingOnPlatformActiveState (father != null);
+        }
+    }
+
+    void setAllPlayersParent (Transform father)
+    {
+        for (i = 0; i < passengersInfoList.Count; i++) {
+            passengersInfoList [i].playerControllerManager.setPlayerAndCameraAndFBAPivotTransformParent (father);
+
+            passengersInfoList [i].playerControllerManager.setMovingOnPlatformActiveState (father != null);
+        }
+    }
+
+    public void addPassenger (Transform newPassenger)
+    {
+        bool passengerFound = false;
+        for (i = 0; i < passengersInfoList.Count; i++) {
+            if (passengersInfoList [i].playerTransform == newPassenger && !passengerFound) {
+                passengerFound = true;
+            }
+        }
+
+        if (!passengerFound) {
+            passengersInfo newPassengersInfo = new passengersInfo ();
+
+            newPassengersInfo.playerTransform = newPassenger;
+
+            newPassengersInfo.playerControllerManager = newPassenger.GetComponent<playerController> ();
+
+            passengersInfoList.Add (newPassengersInfo);
+        }
+    }
+
+    void removePassenger (Transform newPassenger)
+    {
+        for (i = 0; i < passengersInfoList.Count; i++) {
+            if (passengersInfoList [i].playerTransform == newPassenger) {
+                passengersInfoList.RemoveAt (i);
+            }
+        }
+    }
+
+    public void setElevatorSystemEnabledState (bool state)
+    {
+        elevatorSystemEnabled = state;
+    }
+
+    //add a new floor, with a switch and a door, if they are enabled to add them
+    public void addNewFloor ()
+    {
+        floorInfo newFloorInfo = new floorInfo ();
+
+        GameObject newFloor = new GameObject ();
+
+        newFloor.transform.SetParent (transform.parent);
+        newFloor.transform.localRotation = Quaternion.identity;
+
+        Vector3 newFloorLocalposition = Vector3.zero;
+
+        if (floors.Count > 0) {
+            newFloorLocalposition = floors [floors.Count - 1].floorPosition.position + floors [floors.Count - 1].floorPosition.up * floorHeight;
+        }
+
+        newFloor.transform.position = newFloorLocalposition;
+        newFloor.name = "Floor " + floors.Count;
+
+        newFloorInfo.name = newFloor.name;
+        newFloorInfo.floorNumber = floors.Count;
+        newFloorInfo.floorPosition = newFloor.transform;
+
+        if (addSwitchInNewFloors) {
+            newFloorInfo.hasFloorButton = true;
+        }
+
+        if (addDoorInNewFloors) {
+            newFloorInfo.hasOutSideElevatorDoor = true;
+        }
+
+        //add a switch
+        if (addSwitchInNewFloors) {
+            GameObject newSwitch = (GameObject)Instantiate (elevatorSwitchPrefab, Vector3.zero, Quaternion.identity);
+            newSwitch.transform.SetParent (transform.parent);
+            newSwitch.transform.position = newFloorLocalposition + transform.forward * 6 - transform.right * 5;
+            newSwitch.name = "Elevator Switch " + floors.Count;
+
+            newFloorInfo.floorButton = newSwitch;
+            newSwitch.transform.SetParent (newFloor.transform);
+
+            simpleSwitch currentSimpleSwitch = newSwitch.GetComponent<simpleSwitch> ();
+            currentSimpleSwitch.objectToActive = gameObject;
+
+            GKC_Utils.updateComponent (currentSimpleSwitch);
+        }
+
+        //add a door
+        if (addDoorInNewFloors) {
+            GameObject newDoor = (GameObject)Instantiate (elevatorDoorPrefab, Vector3.zero, Quaternion.identity);
+            newDoor.transform.SetParent (transform.parent);
+            newDoor.transform.position = newFloorLocalposition + transform.forward * 5;
+
+            newDoor.name = "Elevator Door " + floors.Count;
+            newFloorInfo.outsideElevatorDoor = newDoor;
+            newDoor.transform.SetParent (newFloor.transform);
+        }
+
+        floors.Add (newFloorInfo);
+
+        updateComponent ();
+    }
+
+    public void removeFloor (int floorIndex)
+    {
+        if (floors [floorIndex].floorPosition != null) {
+            DestroyImmediate (floors [floorIndex].floorPosition.gameObject);
+        }
+
+        floors.RemoveAt (floorIndex);
+
+        updateComponent ();
+    }
+
+    public void removeAllFloors ()
+    {
+        for (i = 0; i < floors.Count; i++) {
+            DestroyImmediate (floors [i].floorPosition.gameObject);
+        }
+
+        floors.Clear ();
+
+        updateComponent ();
+    }
+
+    public void checkEventsOnMove (bool state)
+    {
+        if (useEventsOnMoveStartAndEnd) {
+            if (state) {
+                eventOnMoveStart.Invoke ();
+            } else {
+                eventOnMoveEnd.Invoke ();
+            }
+        }
+    }
+
+    public void updateComponent ()
+    {
+        GKC_Utils.updateComponent (this);
+    }
+
+    //draw every floor position and a line between floors
+#if UNITY_EDITOR
+    void OnDrawGizmos ()
+    {
+        if (!showGizmo) {
+            return;
+        }
+
+        if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
+            DrawGizmos ();
+        }
+    }
+
+    void OnDrawGizmosSelected ()
+    {
+        DrawGizmos ();
+    }
+
+    //draw the pivot and the final positions of every door
+    void DrawGizmos ()
+    {
+        if (showGizmo) {
+            if (!Application.isPlaying) {
+                for (i = 0; i < floors.Count; i++) {
+                    if (floors [i].floorPosition != null) {
+                        Gizmos.color = Color.yellow;
+
+                        if (floors [i].floorNumber == currentFloor) {
+                            Gizmos.color = Color.red;
+                        }
+
+                        Gizmos.DrawSphere (floors [i].floorPosition.position, 0.6f);
+
+                        if (i + 1 < floors.Count && floors [i + 1].floorPosition != null) {
+                            Gizmos.color = Color.yellow;
+                            Gizmos.DrawLine (floors [i].floorPosition.position, floors [i + 1].floorPosition.position);
+                        }
+
+                        if (floors [i].floorButton != null) {
+                            Gizmos.color = Color.blue;
+                            Gizmos.DrawLine (floors [i].floorButton.transform.position, floors [i].floorPosition.position);
+
+                            Gizmos.color = Color.green;
+                            Gizmos.DrawSphere (floors [i].floorButton.transform.position, 0.3f);
+
+                            if (floors [i].outsideElevatorDoor) {
+                                Gizmos.color = Color.white;
+                                Gizmos.DrawLine (floors [i].floorButton.transform.position, floors [i].outsideElevatorDoor.transform.position);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+#endif
+
+    [System.Serializable]
+    public class floorInfo
+    {
+        public string name;
+        public int floorNumber;
+        public Transform floorPosition;
+        public bool hasFloorButton;
+        public GameObject floorButton;
+        public bool hasOutSideElevatorDoor;
+        public GameObject outsideElevatorDoor;
+
+        public doorSystem outsideElevatorDoorSystem;
+
+        public bool outsideElevatorDoorLocated;
+
+        public bool useEventsOnMoveStartAndEnd;
+        public UnityEvent eventOnMoveStart;
+        public UnityEvent eventOnMoveEnd;
+    }
+
+    [System.Serializable]
+    public class passengersInfo
+    {
+        public Transform playerTransform;
+        public playerController playerControllerManager;
+    }
+}