488 lines
13 KiB
C#
488 lines
13 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using GameKitController.Audio;
|
|
using UnityEngine;
|
|
|
|
public class closetSystem : MonoBehaviour
|
|
{
|
|
public List<closetDoorInfo> closetDoorList = new List<closetDoorInfo> ();
|
|
|
|
public doorOpenType openType;
|
|
|
|
public enum doorOpenType
|
|
{
|
|
translate,
|
|
rotate
|
|
}
|
|
|
|
public bool useSounds;
|
|
|
|
public bool showGizmo;
|
|
public float gizmoRadius;
|
|
public float gizmoArrowLength = 1;
|
|
public float gizmoArrowLineLength = 2.5f;
|
|
public float gizmoArrowAngle = 20;
|
|
public Color gizmoArrowColor = Color.white;
|
|
public Color gizmoLabelColor = Color.black;
|
|
|
|
int numberOfDoors;
|
|
GameObject currentPlayer;
|
|
usingDevicesSystem currentUsingDevicesSystem;
|
|
|
|
GameObject objectToAddToCloset;
|
|
GameObject objectToRemoveFromCloset;
|
|
|
|
bool objectsToSpawnChecked;
|
|
|
|
void Start ()
|
|
{
|
|
for (int i = 0; i < closetDoorList.Count; i++) {
|
|
closetDoorList [i].originalPosition = closetDoorList [i].doorTransform.position;
|
|
closetDoorList [i].originalRotation = closetDoorList [i].doorTransform.rotation;
|
|
closetDoorList [i].deviceStringActionManager = closetDoorList [i].doorTransform.GetComponentInChildren<deviceStringAction> ();
|
|
|
|
if (useSounds) {
|
|
closetDoorList [i].InitializeAudioElements ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void changeDoorOpenCloseState (Transform currentDoor)
|
|
{
|
|
int doorIndex = -1;
|
|
|
|
for (int i = 0; i < closetDoorList.Count; i++) {
|
|
if (closetDoorList [i].doorTransform == currentDoor) {
|
|
doorIndex = i;
|
|
}
|
|
}
|
|
|
|
if (doorIndex > -1) {
|
|
closetDoorInfo currentDoorInfo = closetDoorList [doorIndex];
|
|
//stop the coroutine to translate the camera and call it again
|
|
if (currentDoorInfo.doorMovement != null) {
|
|
StopCoroutine (currentDoorInfo.doorMovement);
|
|
}
|
|
|
|
currentDoorInfo.doorMovement = StartCoroutine (openOrCloseDoorCoroutine (currentDoorInfo));
|
|
}
|
|
}
|
|
|
|
IEnumerator openOrCloseDoorCoroutine (closetDoorInfo currentDoorInfo)
|
|
{
|
|
Vector3 targetPosition = currentDoorInfo.originalPosition;
|
|
Quaternion targetRotation = currentDoorInfo.originalRotation;
|
|
|
|
if (currentDoorInfo.useCloseRotationTransform) {
|
|
targetRotation = currentDoorInfo.closeRotationTransform.rotation;
|
|
}
|
|
|
|
bool openingDoor = false;
|
|
|
|
if (!currentDoorInfo.opened) {
|
|
if (openType == doorOpenType.translate) {
|
|
targetPosition = currentDoorInfo.openedPosition.position;
|
|
}
|
|
|
|
if (openType == doorOpenType.rotate) {
|
|
targetRotation = currentDoorInfo.rotatedPosition.rotation;
|
|
}
|
|
|
|
openingDoor = true;
|
|
}
|
|
|
|
if (useSounds) {
|
|
GKC_Utils.checkAudioSourcePitch (currentDoorInfo.mainAudioSource);
|
|
|
|
if (openingDoor) {
|
|
AudioPlayer.PlayOneShot (currentDoorInfo.openAudioElement, gameObject);
|
|
} else {
|
|
AudioPlayer.PlayOneShot (currentDoorInfo.closeAudioElement, gameObject);
|
|
}
|
|
}
|
|
|
|
if (openingDoor) {
|
|
spawnObjectsOnPlace (currentDoorInfo);
|
|
|
|
for (int j = 0; j < currentDoorInfo.objectsInDoor.Count; j++) {
|
|
if (currentDoorInfo.objectsInDoor [j] != null) {
|
|
if (currentDoorInfo.objectsInDoor [j].activeSelf != true) {
|
|
currentDoorInfo.objectsInDoor [j].SetActive (true);
|
|
}
|
|
} else {
|
|
currentDoorInfo.objectsInDoor.RemoveAt (j);
|
|
|
|
j = 0;
|
|
}
|
|
}
|
|
|
|
if (!currentDoorInfo.onlyOneDoor) {
|
|
for (int i = 0; i < currentDoorInfo.othersDoors.Count; i++) {
|
|
for (int j = 0; j < closetDoorList.Count; j++) {
|
|
if (closetDoorList [j].doorTransform == currentDoorInfo.othersDoors [i]) {
|
|
|
|
spawnObjectsOnPlace (closetDoorList [j]);
|
|
|
|
for (int k = 0; k < closetDoorList [j].objectsInDoor.Count; k++) {
|
|
if (closetDoorList [j].objectsInDoor [k] != null) {
|
|
if (closetDoorList [j].objectsInDoor [k].activeSelf != true) {
|
|
closetDoorList [j].objectsInDoor [k].SetActive (true);
|
|
}
|
|
} else {
|
|
closetDoorList [j].objectsInDoor.RemoveAt (k);
|
|
|
|
k = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((currentDoorInfo.canBeOpened && openingDoor) || (currentDoorInfo.canBeClosed && !openingDoor)) {
|
|
if (currentDoorInfo.deviceStringActionManager != null) {
|
|
currentDoorInfo.deviceStringActionManager.changeActionName (openingDoor);
|
|
}
|
|
|
|
if (openType == doorOpenType.translate) {
|
|
float dist = GKC_Utils.distance (currentDoorInfo.doorTransform.position, targetPosition);
|
|
float duration = dist / currentDoorInfo.openSpeed;
|
|
float t = 0;
|
|
|
|
Vector3 currentDoorPosition = currentDoorInfo.doorTransform.position;
|
|
|
|
while (t < 1) {
|
|
t += Time.deltaTime / duration;
|
|
|
|
currentDoorInfo.doorTransform.position = Vector3.Slerp (currentDoorPosition, targetPosition, t);
|
|
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
if (openType == doorOpenType.rotate) {
|
|
float t = 0;
|
|
|
|
Quaternion currentDoorRotation = currentDoorInfo.doorTransform.rotation;
|
|
|
|
while (t < 1 && currentDoorInfo.doorTransform.rotation != targetRotation) {
|
|
t += Time.deltaTime * currentDoorInfo.openSpeed;
|
|
|
|
currentDoorInfo.doorTransform.rotation = Quaternion.Slerp (currentDoorRotation, targetRotation, t);
|
|
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
if (openingDoor) {
|
|
currentDoorInfo.opened = true;
|
|
currentDoorInfo.closed = false;
|
|
} else {
|
|
currentDoorInfo.opened = false;
|
|
currentDoorInfo.closed = true;
|
|
}
|
|
}
|
|
|
|
if (!openingDoor) {
|
|
bool totallyClosed = false;
|
|
|
|
if (currentDoorInfo.onlyOneDoor) {
|
|
totallyClosed = true;
|
|
} else {
|
|
numberOfDoors = 1;
|
|
|
|
for (int j = 0; j < currentDoorInfo.othersDoors.Count; j++) {
|
|
for (int i = 0; i < closetDoorList.Count; i++) {
|
|
if (closetDoorList [i].doorTransform == currentDoorInfo.othersDoors [j] && closetDoorList [i].closed) {
|
|
numberOfDoors++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (numberOfDoors == closetDoorList.Count) {
|
|
totallyClosed = true;
|
|
}
|
|
}
|
|
|
|
// print ("is closed: " + totallyClosed);
|
|
|
|
if (totallyClosed) {
|
|
//only disable these objects if they still inside the closet
|
|
//also, other objects placed inside must be disabled
|
|
if (currentDoorInfo.onlyOneDoor) {
|
|
for (int j = 0; j < currentDoorInfo.objectsInDoor.Count; j++) {
|
|
if (currentDoorInfo.objectsInDoor [j] != null) {
|
|
removeDeviceFromList (currentDoorInfo.objectsInDoor [j]);
|
|
|
|
if (currentDoorInfo.objectsInDoor [j].activeSelf != false) {
|
|
currentDoorInfo.objectsInDoor [j].SetActive (false);
|
|
}
|
|
} else {
|
|
currentDoorInfo.objectsInDoor.RemoveAt (j);
|
|
|
|
j = 0;
|
|
}
|
|
}
|
|
} else {
|
|
for (int i = 0; i < closetDoorList.Count; i++) {
|
|
for (int j = 0; j < closetDoorList [i].objectsInDoor.Count; j++) {
|
|
if (closetDoorList [i].objectsInDoor [j] != null) {
|
|
// print (closetDoorList [i].objectsInDoor [j].name);
|
|
|
|
removeDeviceFromList (closetDoorList [i].objectsInDoor [j]);
|
|
|
|
if (closetDoorList [i].objectsInDoor [j].activeSelf != false) {
|
|
closetDoorList [i].objectsInDoor [j].SetActive (false);
|
|
}
|
|
} else {
|
|
closetDoorList [i].objectsInDoor.RemoveAt (j);
|
|
|
|
j = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void spawnObjectsOnPlace (closetDoorInfo currentDoorInfo)
|
|
{
|
|
if (currentDoorInfo.spawnObjectsInsideAtStart && !currentDoorInfo.objectsInsideSpawned) {
|
|
for (int j = 0; j < currentDoorInfo.objectToSpawInfoList.Count; j++) {
|
|
GameObject newObject = (GameObject)Instantiate (currentDoorInfo.objectToSpawInfoList [j].objectToSpawn,
|
|
currentDoorInfo.objectToSpawInfoList [j].positionToSpawn.position,
|
|
currentDoorInfo.objectToSpawInfoList [j].positionToSpawn.rotation);
|
|
|
|
newObject.transform.SetParent (currentDoorInfo.objectToSpawInfoList [j].positionToSpawn);
|
|
|
|
currentDoorInfo.objectsInDoor.Add (newObject);
|
|
}
|
|
|
|
currentDoorInfo.objectsInsideSpawned = true;
|
|
}
|
|
}
|
|
|
|
public void setCurrentPlayer (GameObject player)
|
|
{
|
|
currentPlayer = player;
|
|
|
|
if (currentPlayer != null) {
|
|
currentUsingDevicesSystem = currentPlayer.GetComponent<usingDevicesSystem> ();
|
|
}
|
|
}
|
|
|
|
public void removeDeviceFromList (GameObject objecToRemove)
|
|
{
|
|
if (currentPlayer != null) {
|
|
currentUsingDevicesSystem.removeDeviceFromListUsingParent (objecToRemove);
|
|
}
|
|
}
|
|
|
|
public void setObjectToAddToCloset (GameObject objectToAdd)
|
|
{
|
|
objectToAddToCloset = objectToAdd;
|
|
}
|
|
|
|
public void setObjectToRemoveFromCloset (GameObject objectToRemove)
|
|
{
|
|
objectToRemoveFromCloset = objectToRemove;
|
|
}
|
|
|
|
|
|
public void addObjectToCloset (Transform doorToAdd)
|
|
{
|
|
simpleActionButton currentSimpleActionButton = objectToAddToCloset.GetComponent<simpleActionButton> ();
|
|
|
|
if (currentSimpleActionButton != null) {
|
|
|
|
GameObject currentObjectToAdd = currentSimpleActionButton.objectToActive;
|
|
|
|
for (int i = 0; i < closetDoorList.Count; i++) {
|
|
for (int j = 0; j < closetDoorList [i].objectsInDoor.Count; j++) {
|
|
if (closetDoorList [i].objectsInDoor.Contains (currentObjectToAdd)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < closetDoorList.Count; i++) {
|
|
if (closetDoorList [i].doorTransform == doorToAdd && closetDoorList [i].opened) {
|
|
if (!closetDoorList [i].objectsInDoor.Contains (currentObjectToAdd)) {
|
|
closetDoorList [i].objectsInDoor.Add (currentObjectToAdd);
|
|
|
|
if (openType == doorOpenType.translate) {
|
|
currentObjectToAdd.transform.SetParent (closetDoorList [i].doorTransform);
|
|
} else {
|
|
currentObjectToAdd.transform.SetParent (transform);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void removeObjectFromCloset (Transform doorToAdd)
|
|
{
|
|
GameObject currentObjectToAdd = objectToRemoveFromCloset.GetComponent<simpleActionButton> ().objectToActive;
|
|
|
|
for (int i = 0; i < closetDoorList.Count; i++) {
|
|
if (closetDoorList [i].doorTransform == doorToAdd) {
|
|
if (closetDoorList [i].objectsInDoor.Contains (currentObjectToAdd)) {
|
|
closetDoorList [i].objectsInDoor.Remove (currentObjectToAdd);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void addNewDoor ()
|
|
{
|
|
closetDoorInfo newClosetDoorInfo = new closetDoorInfo ();
|
|
|
|
newClosetDoorInfo.Name = "New Door";
|
|
|
|
closetDoorList.Add (newClosetDoorInfo);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
public void updateComponent ()
|
|
{
|
|
GKC_Utils.updateComponent (this);
|
|
}
|
|
|
|
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) {
|
|
for (int i = 0; i < closetDoorList.Count; i++) {
|
|
if (closetDoorList [i].doorTransform != null) {
|
|
Gizmos.color = Color.yellow;
|
|
Gizmos.DrawSphere (closetDoorList [i].doorTransform.position, gizmoRadius);
|
|
|
|
if (openType == doorOpenType.translate) {
|
|
if (closetDoorList [i].openedPosition != null) {
|
|
Gizmos.color = Color.green;
|
|
|
|
Gizmos.DrawSphere (closetDoorList [i].openedPosition.position, gizmoRadius);
|
|
|
|
Gizmos.color = Color.white;
|
|
|
|
Gizmos.DrawLine (closetDoorList [i].doorTransform.position, closetDoorList [i].openedPosition.position);
|
|
}
|
|
}
|
|
|
|
if (openType == doorOpenType.rotate) {
|
|
if (closetDoorList [i].rotatedPosition != null) {
|
|
Gizmos.color = Color.green;
|
|
|
|
GKC_Utils.drawGizmoArrow (closetDoorList [i].rotatedPosition.position, closetDoorList [i].rotatedPosition.right * gizmoArrowLineLength,
|
|
gizmoArrowColor, gizmoArrowLength, gizmoArrowAngle);
|
|
|
|
Gizmos.color = Color.white;
|
|
Gizmos.DrawLine (closetDoorList [i].doorTransform.position, closetDoorList [i].rotatedPosition.position);
|
|
}
|
|
|
|
if (closetDoorList [i].useCloseRotationTransform) {
|
|
Gizmos.color = Color.green;
|
|
|
|
GKC_Utils.drawGizmoArrow (closetDoorList [i].closeRotationTransform.position, closetDoorList [i].closeRotationTransform.right * gizmoArrowLineLength,
|
|
gizmoArrowColor, gizmoArrowLength, gizmoArrowAngle);
|
|
|
|
Gizmos.color = Color.white;
|
|
|
|
Gizmos.DrawLine (closetDoorList [i].doorTransform.position, closetDoorList [i].closeRotationTransform.position);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class closetDoorInfo
|
|
{
|
|
public string Name;
|
|
public float openSpeed;
|
|
public Transform doorTransform;
|
|
public Transform openedPosition;
|
|
public Transform rotatedPosition;
|
|
|
|
public bool canBeOpened = true;
|
|
public bool canBeClosed = true;
|
|
public bool opened;
|
|
public bool closed;
|
|
|
|
public List<GameObject> objectsInDoor = new List<GameObject> ();
|
|
|
|
public bool spawnObjectsInsideAtStart;
|
|
public List<objectToSpawInfo> objectToSpawInfoList = new List<objectToSpawInfo> ();
|
|
public bool objectsInsideSpawned;
|
|
|
|
public bool onlyOneDoor;
|
|
public List<Transform> othersDoors = new List<Transform> ();
|
|
|
|
public AudioClip openSound;
|
|
public AudioElement openAudioElement;
|
|
public AudioClip closeSound;
|
|
public AudioElement closeAudioElement;
|
|
|
|
public bool useCloseRotationTransform;
|
|
public Transform closeRotationTransform;
|
|
[HideInInspector] public AudioSource mainAudioSource;
|
|
|
|
[HideInInspector] public Vector3 originalPosition;
|
|
[HideInInspector] public Quaternion originalRotation;
|
|
|
|
[HideInInspector] public Coroutine doorMovement;
|
|
|
|
[HideInInspector] public deviceStringAction deviceStringActionManager;
|
|
|
|
public void InitializeAudioElements ()
|
|
{
|
|
mainAudioSource = doorTransform.GetComponent<AudioSource> ();
|
|
|
|
if (openSound != null) {
|
|
openAudioElement.clip = openSound;
|
|
}
|
|
|
|
if (closeSound != null) {
|
|
closeAudioElement.clip = closeSound;
|
|
}
|
|
|
|
if (mainAudioSource != null) {
|
|
openAudioElement.audioSource = mainAudioSource;
|
|
closeAudioElement.audioSource = mainAudioSource;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class objectToSpawInfo
|
|
{
|
|
public GameObject objectToSpawn;
|
|
public Transform positionToSpawn;
|
|
}
|
|
}
|