566 lines
15 KiB
C#
566 lines
15 KiB
C#
using UnityEngine;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine.Events;
|
|
|
|
public class waypointPlatform : MonoBehaviour
|
|
{
|
|
public bool platformActive = true;
|
|
public Transform platformTransform;
|
|
public List<Transform> wayPoints = new List<Transform> ();
|
|
public Transform waypointsParent;
|
|
public bool repeatWaypoints;
|
|
public bool moveInCircles;
|
|
public bool stopIfPlayerOutside;
|
|
public float waitTimeBetweenPoints;
|
|
public float movementSpeed;
|
|
public bool movingForward = true;
|
|
|
|
public string playerTag = "Player";
|
|
public string vehicleTag = "vehicle";
|
|
|
|
public bool useJustToMovePlatform;
|
|
|
|
public bool showGizmo;
|
|
public Color gizmoLabelColor = Color.black;
|
|
public float gizmoRadius;
|
|
public bool useHandleForVertex;
|
|
public float handleRadius;
|
|
public Color handleGizmoColor;
|
|
|
|
public bool showVertexHandles;
|
|
|
|
public List<string> tagToCheckToMove = new List<string> ();
|
|
|
|
public List<string> tagToCheckBelow = new List<string> ();
|
|
|
|
public List<GameObject> objectsDetectedBelowList = new List<GameObject> ();
|
|
|
|
public bool mirrorPlatformMovement;
|
|
public Vector3 mirrorMovementDirection = Vector3.one;
|
|
public waypointPlatform platformToMirror;
|
|
|
|
public bool useEventOnWaypointReached;
|
|
public List<eventOnWaypointInfo> eventOnWaypointReachedList = new List<eventOnWaypointInfo> ();
|
|
|
|
public List<passengersInfo> passengersInfoList = new List<passengersInfo> ();
|
|
|
|
public List<vehiclesInfo> vehiclesInfoList = new List<vehiclesInfo> ();
|
|
|
|
public deviceStringAction deviceStringActionManager;
|
|
|
|
List<Transform> forwardPath = new List<Transform> ();
|
|
List<Transform> inversePath = new List<Transform> ();
|
|
List<Transform> currentPath = new List<Transform> ();
|
|
Coroutine movement;
|
|
Transform currentWaypoint;
|
|
int currentPlatformIndex;
|
|
int i;
|
|
|
|
bool activateMovementForward;
|
|
|
|
Vector3 currentPlatformPosition;
|
|
bool mirroringPlatformActive;
|
|
|
|
bool settingPositionOnMirrorPlatflorm;
|
|
public float distanceToMirror;
|
|
|
|
|
|
void Start ()
|
|
{
|
|
if (platformTransform == null) {
|
|
platformTransform = transform;
|
|
}
|
|
|
|
forwardPath = new List<Transform> (wayPoints);
|
|
inversePath = new List<Transform> (wayPoints);
|
|
|
|
inversePath.Reverse ();
|
|
|
|
if (!stopIfPlayerOutside && !useJustToMovePlatform && platformActive) {
|
|
checkMovementCoroutine (true);
|
|
}
|
|
|
|
if (deviceStringActionManager == null) {
|
|
deviceStringActionManager = GetComponent<deviceStringAction> ();
|
|
}
|
|
}
|
|
|
|
void Update ()
|
|
{
|
|
if (mirroringPlatformActive) {
|
|
platformTransform.position = currentPlatformPosition +
|
|
new Vector3 (platformToMirror.distanceToMirror * mirrorMovementDirection.x,
|
|
platformToMirror.distanceToMirror * mirrorMovementDirection.y,
|
|
platformToMirror.distanceToMirror * mirrorMovementDirection.z);
|
|
}
|
|
|
|
if (settingPositionOnMirrorPlatflorm) {
|
|
distanceToMirror = GKC_Utils.distance (currentPlatformPosition, platformTransform.position);
|
|
}
|
|
}
|
|
|
|
public void setMirroringPlatformActiveState (bool state)
|
|
{
|
|
if (!mirrorPlatformMovement) {
|
|
return;
|
|
}
|
|
|
|
mirroringPlatformActive = state;
|
|
|
|
if (platformTransform != null) {
|
|
currentPlatformPosition = platformTransform.position;
|
|
}
|
|
}
|
|
|
|
void OnTriggerEnter (Collider col)
|
|
{
|
|
if (useJustToMovePlatform) {
|
|
return;
|
|
}
|
|
|
|
//if the player enters inside the platform trigger, then
|
|
if (col.gameObject.CompareTag (playerTag)) {
|
|
//store him
|
|
addPassenger (col.gameObject.transform);
|
|
|
|
//if he is not driving, then attach the player and the camera inside the platform
|
|
setPlayerParent (platformTransform, col.gameObject.transform);
|
|
|
|
//if the platform stops when the player exits from it, then restart its movement
|
|
if (stopIfPlayerOutside) {
|
|
checkMovementCoroutine (true);
|
|
}
|
|
|
|
} else if (col.gameObject.CompareTag (vehicleTag)) {
|
|
//store him
|
|
addVehicle (col.gameObject.transform);
|
|
|
|
//if he is not driving, then attach the player and the camera inside the platform
|
|
setVehicleParent (platformTransform, col.gameObject.transform);
|
|
|
|
} else if (tagToCheckToMove.Contains (col.gameObject.tag)) {
|
|
col.gameObject.transform.SetParent (platformTransform);
|
|
}
|
|
}
|
|
|
|
void OnTriggerExit (Collider col)
|
|
{
|
|
if (useJustToMovePlatform) {
|
|
return;
|
|
}
|
|
|
|
//if the player exits, then disattach the player
|
|
if (col.gameObject.CompareTag (playerTag)) {
|
|
setPlayerParent (null, col.gameObject.transform);
|
|
|
|
removePassenger (col.gameObject.transform);
|
|
|
|
//if the platform stops when the player exits from it, stop the platform
|
|
if (stopIfPlayerOutside) {
|
|
checkMovementCoroutine (false);
|
|
}
|
|
} else if (col.gameObject.CompareTag (vehicleTag)) {
|
|
setVehicleParent (null, col.gameObject.transform);
|
|
|
|
removeVehicle (col.gameObject.transform);
|
|
|
|
} else if (tagToCheckToMove.Contains (col.gameObject.tag)) {
|
|
col.gameObject.transform.SetParent (null);
|
|
}
|
|
}
|
|
|
|
//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);
|
|
}
|
|
}
|
|
}
|
|
|
|
void setVehicleParent (Transform father, Transform newVehicle)
|
|
{
|
|
bool vehicleFound = false;
|
|
|
|
vehiclesInfo newVehiclesInfo = new vehiclesInfo ();
|
|
|
|
for (i = 0; i < vehiclesInfoList.Count; i++) {
|
|
if (vehiclesInfoList [i].vehicleTransform == newVehicle && !vehicleFound) {
|
|
newVehiclesInfo = vehiclesInfoList [i];
|
|
vehicleFound = true;
|
|
}
|
|
}
|
|
|
|
if (vehicleFound) {
|
|
newVehiclesInfo.HUDManager.setVehicleAndCameraParent (father);
|
|
}
|
|
}
|
|
|
|
void setAllVehiclesParent (Transform father)
|
|
{
|
|
for (i = 0; i < vehiclesInfoList.Count; i++) {
|
|
vehiclesInfoList [i].HUDManager.setVehicleAndCameraParent (father);
|
|
}
|
|
}
|
|
|
|
public void addVehicle (Transform newVehicle)
|
|
{
|
|
bool vehicleFound = false;
|
|
for (i = 0; i < vehiclesInfoList.Count; i++) {
|
|
if (vehiclesInfoList [i].vehicleTransform == newVehicle && !vehicleFound) {
|
|
vehicleFound = true;
|
|
}
|
|
}
|
|
|
|
if (!vehicleFound) {
|
|
vehiclesInfo newVehiclesInfo = new vehiclesInfo ();
|
|
newVehiclesInfo.vehicleTransform = newVehicle;
|
|
|
|
newVehiclesInfo.HUDManager = newVehicle.GetComponent<vehicleHUDManager> ();
|
|
|
|
vehiclesInfoList.Add (newVehiclesInfo);
|
|
}
|
|
}
|
|
|
|
void removeVehicle (Transform newVehicle)
|
|
{
|
|
for (i = 0; i < vehiclesInfoList.Count; i++) {
|
|
if (vehiclesInfoList [i].vehicleTransform == newVehicle) {
|
|
vehiclesInfoList.RemoveAt (i);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void disablePlatform ()
|
|
{
|
|
stopPlatformMovement ();
|
|
|
|
platformActive = false;
|
|
|
|
setAllPlayersParent (null);
|
|
|
|
setAllVehiclesParent (null);
|
|
|
|
GetComponent<Collider> ().enabled = false;
|
|
|
|
this.enabled = false;
|
|
}
|
|
|
|
public void activatePlatformMovement ()
|
|
{
|
|
if (currentPath.Count == 0) {
|
|
for (i = currentPlatformIndex; i < forwardPath.Count; i++) {
|
|
currentPath.Add (forwardPath [i]);
|
|
}
|
|
}
|
|
|
|
checkMovementCoroutine (true);
|
|
}
|
|
|
|
public void deactivatePlatformMovement ()
|
|
{
|
|
checkMovementCoroutine (false);
|
|
}
|
|
|
|
//stop the platform coroutine movement and play again
|
|
public void checkMovementCoroutine (bool play)
|
|
{
|
|
stopPlatformMovement ();
|
|
|
|
if (!platformActive) {
|
|
return;
|
|
}
|
|
|
|
if (mirrorPlatformMovement) {
|
|
platformToMirror.setMirroringPlatformActiveState (play);
|
|
settingPositionOnMirrorPlatflorm = play;
|
|
currentPlatformPosition = transform.position;
|
|
}
|
|
|
|
if (play) {
|
|
movement = StartCoroutine (moveThroughWayPoints ());
|
|
}
|
|
}
|
|
|
|
public void stopPlatformMovement ()
|
|
{
|
|
if (movement != null) {
|
|
StopCoroutine (movement);
|
|
}
|
|
}
|
|
|
|
IEnumerator moveThroughWayPoints ()
|
|
{
|
|
if (!useJustToMovePlatform) {
|
|
currentPath.Clear ();
|
|
|
|
//if the platform moves from waypoint to waypoint and it starts again, then
|
|
if (moveInCircles) {
|
|
//from the current waypoint to the last of them, add these waypoints
|
|
for (i = currentPlatformIndex; i < forwardPath.Count; i++) {
|
|
currentPath.Add (forwardPath [i]);
|
|
}
|
|
} else {
|
|
//else, if only moves from the first waypoint to the last and then stop, then
|
|
//if the platform moves between waypoins in the order list
|
|
if (movingForward) {
|
|
//from the current waypoint to the last of them, add these waypoints
|
|
for (i = currentPlatformIndex; i < forwardPath.Count; i++) {
|
|
currentPath.Add (forwardPath [i]);
|
|
}
|
|
} else {
|
|
//from the current waypoint to the first of them, add these waypoints, making the reverse path
|
|
for (i = currentPlatformIndex; i < inversePath.Count; i++) {
|
|
currentPath.Add (inversePath [i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//if the current path to move has waypoints, then
|
|
if (currentPath.Count > 0) {
|
|
//move between every waypoint
|
|
foreach (Transform point in currentPath) {
|
|
//wait the amount of time configured
|
|
WaitForSeconds delay = new WaitForSeconds (waitTimeBetweenPoints);
|
|
|
|
yield return delay;
|
|
|
|
Vector3 pos = point.position;
|
|
Quaternion rot = point.rotation;
|
|
|
|
currentWaypoint = point;
|
|
|
|
//while the platform moves from the previous waypoint to the next, then displace it
|
|
while (GKC_Utils.distance (platformTransform.position, pos) > .01f) {
|
|
platformTransform.position = Vector3.MoveTowards (platformTransform.position, pos, Time.deltaTime * movementSpeed);
|
|
platformTransform.rotation = Quaternion.Slerp (platformTransform.rotation, rot, Time.deltaTime * movementSpeed);
|
|
|
|
yield return null;
|
|
}
|
|
|
|
//when the platform reaches the next waypoint
|
|
currentPlatformIndex++;
|
|
|
|
int currentIndex = currentPlatformIndex;
|
|
|
|
if (currentPlatformIndex > wayPoints.Count - 1) {
|
|
currentPlatformIndex = 0;
|
|
movingForward = !movingForward;
|
|
}
|
|
|
|
if (useEventOnWaypointReached) {
|
|
for (i = 0; i < eventOnWaypointReachedList.Count; i++) {
|
|
if (currentIndex == (eventOnWaypointReachedList [i].waypointToReach)) {
|
|
eventOnWaypointReachedList [i].eventOnWaypoint.Invoke ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//if the platform moves in every moment, then repeat the path
|
|
if (repeatWaypoints) {
|
|
checkMovementCoroutine (true);
|
|
}
|
|
} else {
|
|
//else, stop the movement
|
|
checkMovementCoroutine (false);
|
|
}
|
|
}
|
|
|
|
public void activetMovementByButton ()
|
|
{
|
|
activateMovementForward = !activateMovementForward;
|
|
|
|
currentPath.Clear ();
|
|
|
|
if (activateMovementForward) {
|
|
//from the current waypoint to the last of them, add these waypoints
|
|
for (i = currentPlatformIndex; i < forwardPath.Count; i++) {
|
|
currentPath.Add (forwardPath [i]);
|
|
}
|
|
} else {
|
|
//from the current waypoint to the first of them, add these waypoints, making the reverse path
|
|
for (i = currentPlatformIndex; i < inversePath.Count; i++) {
|
|
currentPath.Add (inversePath [i]);
|
|
}
|
|
}
|
|
|
|
setDeviceStringActionState (activateMovementForward);
|
|
|
|
checkMovementCoroutine (true);
|
|
}
|
|
|
|
public void setDeviceStringActionState (bool state)
|
|
{
|
|
if (deviceStringActionManager != null) {
|
|
deviceStringActionManager.changeActionName (state);
|
|
}
|
|
}
|
|
|
|
public void addObjectDetectedBelow (GameObject objectToCheck)
|
|
{
|
|
if (!objectsDetectedBelowList.Contains (objectToCheck)) {
|
|
if (tagToCheckBelow.Contains (objectToCheck.tag) || objectToCheck.GetComponent<Rigidbody> ()) {
|
|
|
|
objectsDetectedBelowList.Add (objectToCheck);
|
|
|
|
currentPlatformIndex = 0;
|
|
|
|
checkMovementCoroutine (true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void removeObjectDetectedBelow (GameObject objectToCheck)
|
|
{
|
|
if (objectsDetectedBelowList.Contains (objectToCheck)) {
|
|
objectsDetectedBelowList.Remove (objectToCheck);
|
|
}
|
|
}
|
|
|
|
//add a new waypoint
|
|
public void addNewWayPoint ()
|
|
{
|
|
Vector3 newPosition = Vector3.zero;
|
|
|
|
if (platformTransform == null) {
|
|
newPosition = transform.position;
|
|
} else {
|
|
newPosition = platformTransform.position;
|
|
}
|
|
|
|
if (wayPoints.Count > 0) {
|
|
newPosition = wayPoints [wayPoints.Count - 1].position + wayPoints [wayPoints.Count - 1].forward;
|
|
}
|
|
|
|
GameObject newWayPoint = new GameObject ();
|
|
newWayPoint.transform.SetParent (waypointsParent);
|
|
newWayPoint.transform.position = newPosition;
|
|
newWayPoint.name = (wayPoints.Count + 1).ToString ();
|
|
wayPoints.Add (newWayPoint.transform);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
void updateComponent ()
|
|
{
|
|
GKC_Utils.updateComponent (this);
|
|
|
|
GKC_Utils.updateDirtyScene ("Update Waypoint Platform " + gameObject.name, gameObject);
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
void OnDrawGizmos ()
|
|
{
|
|
if (!showGizmo) {
|
|
return;
|
|
}
|
|
|
|
if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
|
|
DrawGizmos ();
|
|
}
|
|
}
|
|
|
|
void OnDrawGizmosSelected ()
|
|
{
|
|
DrawGizmos ();
|
|
}
|
|
|
|
void DrawGizmos ()
|
|
{
|
|
if (showGizmo) {
|
|
for (i = 0; i < wayPoints.Count; i++) {
|
|
if (wayPoints [i] != null) {
|
|
Gizmos.color = Color.yellow;
|
|
Gizmos.DrawSphere (wayPoints [i].position, gizmoRadius);
|
|
|
|
if (i + 1 < wayPoints.Count) {
|
|
Gizmos.color = Color.white;
|
|
Gizmos.DrawLine (wayPoints [i].position, wayPoints [i + 1].position);
|
|
}
|
|
|
|
if (i == wayPoints.Count - 1 && moveInCircles) {
|
|
Gizmos.color = Color.white;
|
|
Gizmos.DrawLine (wayPoints [i].position, wayPoints [0].position);
|
|
}
|
|
|
|
if (currentWaypoint != null) {
|
|
Gizmos.color = Color.red;
|
|
Gizmos.DrawSphere (currentWaypoint.position, gizmoRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
[System.Serializable]
|
|
public class eventOnWaypointInfo
|
|
{
|
|
public string Name;
|
|
public int waypointToReach;
|
|
public UnityEvent eventOnWaypoint;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class passengersInfo
|
|
{
|
|
public Transform playerTransform;
|
|
public playerController playerControllerManager;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class vehiclesInfo
|
|
{
|
|
public Transform vehicleTransform;
|
|
public vehicleHUDManager HUDManager;
|
|
}
|
|
} |