FueraDeEscala/Assets/Game Kit Controller/Scripts/Map/mapCreator.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class mapCreator : MonoBehaviour
{
	public List<buildingInfo> buildingList = new List<buildingInfo> ();

	public LayerMask layerToPlaceElements;
	public bool useRaycastToPlaceElements;
	public Vector3 mapPartEnabledTriggerScale;

	public Color enabledTriggerGizmoColor;

	public Material floorMaterial;

	public GameObject triggerToChangeBuildingPrefab;
	public GameObject triggerToChangeFloorPrefab;

	public GameObject triggerToChangeDynamicObjectPrefab;

	public string mapLayer;

	public bool showGizmo;
	public bool showMapPartsGizmo;
	public bool showMapPartsTextGizmo;
	public bool showMapPartEnabledTrigger;
	public bool useSameLineColor;
	public Color mapLinesColor;

	public bool showBuildingTriggersLine;
	public Color buildingTriggersLineColor;
	public bool showBuildingTriggers;
	public Color buildingTriggersColor;
	public bool showBuildingTriggersCubes;
	public Color buildingTriggersCubesColor;

	public bool showFloorTriggersLine;
	public Color floorTriggersLineColor;
	public bool showFloorTriggers;
	public Color floorTriggersColor;
	public bool showFloorTriggersCubes;
	public Color floorTriggersCubesColor;

	public Color gizmoLabelColor;
	public bool useHandleForVertex;
	public float handleRadius;
	public bool showVertexHandles;

	public bool generate3dMeshesActive;
	public bool generate3dMeshesShowGizmo;
	public bool generateFull3dMapMeshes;
	public Material mapPart3dMeshMaterial;

	public Color mapPart3dMaterialColor = Color.white;

	public Vector3 mapPart3dOffset;
	public float mapPart3dHeight = 1;

	public List<mapSystem> mapSystemList = new List<mapSystem> ();

	public List<mapSystemInfo> mapSystemInfoList = new List<mapSystemInfo> ();

	public List<mapIconType> mapIconTypes = new List<mapIconType> ();

	bool floorsConfiguredByTriggers;

	public bool generate3dMapPartMesh;

	int lastMapObjectInformationIDAssigned = 1;

	public bool updateAllMapTilesEveryFrame;

	buildingInfo currentBuildingInfoToUse;
	floorInfo currentFloorInfoToUse;

	GameObject currentPlayerDetected;

	GameObject currentCharacterToUse;

	public bool show3dSettings;

	public const string mainManagerName = "Map Creator";

	public static string getMainManagerName ()
	{
		return mainManagerName;
	}

	private static mapCreator _mapCreatorInstance;

	public static mapCreator Instance { get { return _mapCreatorInstance; } }

	bool instanceInitialized;


	public void getComponentInstance ()
	{
		if (instanceInitialized) {
			return;
		}

		if (_mapCreatorInstance != null && _mapCreatorInstance != this) {
			Destroy (this.gameObject);

			return;
		} 

		_mapCreatorInstance = this;

		instanceInitialized = true;
	}

	void Awake ()
	{
		getComponentInstance ();

		updateMainMapSystemList ();

		int mapSystemInfoListCount = mapSystemInfoList.Count;

		for (int i = mapSystemList.Count - 1; i >= 0; i--) {
			if (mapSystemList [i] == null) {
				mapSystemList.RemoveAt (i);

				print ("WARNING: the map system list configured in Map Creator inspector contains some missing element " +
				"related to a player map system, make sure it is properly configured");
			}
		}

		if (mapSystemInfoListCount == 0) {
			print ("The Map System and the Map Creator are not configured correctly. If both objects are in the scene, go to Map System inspector, " +
			"Map Floor And Icons, and press Search Floor List, to assign the created map floors to the map system");

			return;
		}
			
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			buildingInfo currentBuildingInfo = buildingList [i];

			int buildingFloorsListCount = currentBuildingInfo.buildingFloorsList.Count;

			for (int j = 0; j < buildingFloorsListCount; j++) {
				floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

				int mapTileBuilderListCount = currentFloorInfo.mapTileBuilderList.Count;

				if (!currentFloorInfo.floorEnabled) {
					for (int k = 0; k < mapTileBuilderListCount; k++) {
						currentFloorInfo.mapTileBuilderList [k].setMapPartEnabledState (false);
					}
				}
			}
		}
	}

	void Start ()
	{
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			buildingInfo currentBuildingInfo = buildingList [i];

			int buildingFloorsListCount = currentBuildingInfo.buildingFloorsList.Count;

			for (int j = 0; j < buildingFloorsListCount; j++) {

				floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

				int mapTileBuilderListCount = currentFloorInfo.mapTileBuilderList.Count;

				for (int k = 0; k < mapTileBuilderListCount; k++) {
					mapTileBuilder currentMapTileBuilder = currentFloorInfo.mapTileBuilderList [k];

					if (currentMapTileBuilder != null) {
						currentMapTileBuilder.createMapTileElement ();
					} else {
						print ("Warning: there is a map tile builder element in the list which is not assigned correctly with index " + k + ", use the button to get all floor parts");
					}
				}
			}
		}
	}

	public void updateMainMapSystemList ()
	{
		int mapSystemInfoListCount = mapSystemInfoList.Count;

		for (int i = 0; i < mapSystemInfoListCount; i++) {
			if (!mapSystemList.Contains (mapSystemInfoList [i].mainMapSystem)) {
				mapSystemList.Add (mapSystemInfoList [i].mainMapSystem);
			}
		}
	}

	//START OF INGAME FUNCTIONS
	//Operations on all the map system components
	public int getAndIncreaselastMapObjectInformationIDAssigned ()
	{
		lastMapObjectInformationIDAssigned++;

		return lastMapObjectInformationIDAssigned;
	}

	public void setlastMapObjectInformationIDAssignedValue (int newValue)
	{
		lastMapObjectInformationIDAssigned = newValue;
	}

	public void addMapObject (bool visibleInAllBuildings, bool visibleInAllFloors, bool calculateFloorAtStart, GameObject obj, string type, Vector3 offset, int ID, 
	                          int mapPartIndex, int buildingIndex, float extraIconSizeOnMap, bool followCameraRotation, bool followObjectRotation, 
	                          bool setCustomCompassSettings, bool useCompassIcon, GameObject compassIconPrefab, float verticalOffset)
	{
		int mapSystemListCount = mapSystemList.Count;
	
		for (int i = 0; i < mapSystemListCount; i++) {
			mapSystemList [i].addMapObject (visibleInAllBuildings, visibleInAllFloors, calculateFloorAtStart, obj, 
				type, offset, ID, mapPartIndex, buildingIndex, extraIconSizeOnMap, followCameraRotation, followObjectRotation, setCustomCompassSettings, useCompassIcon, compassIconPrefab, verticalOffset);
		}
	}

	public void removeMapObject (GameObject obj, bool isPathElement)
	{
		int mapSystemListCount = mapSystemList.Count;

		for (int i = 0; i < mapSystemListCount; i++) {
			mapSystemList [i].removeMapObject (obj, isPathElement);
		}
	}

	public void enableOrDisableSingleMapIconByID (int ID, bool value)
	{
		int mapSystemListCount = mapSystemList.Count;

		for (int i = 0; i < mapSystemListCount; i++) {
			mapSystemList [i].enableOrDisableSingleMapIconByID (ID, value);
		}
	}

	public void changeMapObjectIconFloor (GameObject objectToSearch, int newFloorIndex)
	{
		int mapSystemListCount = mapSystemList.Count;

		for (int i = 0; i < mapSystemListCount; i++) {
			mapSystemList [i].changeMapObjectIconFloor (objectToSearch, newFloorIndex);
		}
	}

	public void changeMapObjectIconFloorByPosition (GameObject objectToSearch)
	{
		int mapSystemListCount = mapSystemList.Count;

		for (int i = 0; i < mapSystemListCount; i++) {
			mapSystemList [i].changeMapObjectIconFloorByPosition (objectToSearch);
		}
	}

	public void setnewBuilingAndFloorIndexToMapObject (mapSystem.mapObjectInfo mapObjectInfoToModify, int newBuildingIndex, int newFloorIndex)
	{
		int mapSystemListCount = mapSystemList.Count;

		for (int i = 0; i < mapSystemListCount; i++) {
			mapSystemList [i].setnewBuilingAndFloorIndexToMapObject (mapObjectInfoToModify, newBuildingIndex, newFloorIndex);
		}
	}

	public int getBuldingIndexByName (string buildingName)
	{
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			if (buildingList [i].Name.Equals (buildingName)) {
				return i;
			}
		}

		return -1;
	}

	public void getAllBuildings ()
	{
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			int buildingFloorsListCount = buildingList [i].buildingFloorsList.Count;

			for (int j = 0; j < buildingFloorsListCount; j++) {
				GetAllFloorParts (i, j);
			}
		}
	}

	public void changeCurrentFloor (GameObject currentTriggerFloor)
	{
		int newFloorIndex = -1;

		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			buildingInfo currentBuildingInfo = buildingList [i];

			int buildingFloorsListCount = currentBuildingInfo.buildingFloorsList.Count;

			for (int j = 0; j < buildingFloorsListCount; j++) {
				floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

				if (currentFloorInfo.floor == currentTriggerFloor) {
//					print (buildingList [i].buildingFloorsList [j].Name);
					setCurrentFloorByFloorNumber (i, currentFloorInfo.floorNumber);

					newFloorIndex = j;
				}
			}
		}

		if (newFloorIndex != -1) {
			int mapSystemInfoListCount = mapSystemInfoList.Count;

			for (int i = 0; i < mapSystemInfoListCount; i++) {
				mapSystemInfo currentMapSystemInfo = mapSystemInfoList [i];

				if (currentMapSystemInfo.playerGameObject == currentPlayerDetected) {
					currentMapSystemInfo.mainMapSystem.setCurrentFloorIndex (newFloorIndex);

					currentMapSystemInfo.mainMapSystem.updateCurrentFloorNumber ();
				}
			}
		}
	}

	public void setCurrentFloorByFloorNumber (int buildingIndex, int floorNumber)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		int buildingFloorsListCount = currentBuildingInfo.buildingFloorsList.Count;

		for (int j = 0; j < buildingFloorsListCount; j++) {
			floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

			if (currentFloorInfo.floor != null) {
				if (currentFloorInfo.floorNumber == floorNumber) {
					//print (currentBuildingInfo.buildingFloorsList [j].Name);
					if (!currentFloorInfo.floor.activeSelf) {
						currentFloorInfo.floor.SetActive (true);
					}
				} else {
					if (currentFloorInfo.floor.activeSelf) {
						currentFloorInfo.floor.SetActive (false);
					}
				}
			}
		}
	}

	public void setCurrentFloorByFloorIndex (int buildingIndex, int floorIndex)
	{
		if (buildingIndex < 0 || floorIndex < 0) {
			return;
		}

		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		int buildingFloorsListCount = currentBuildingInfo.buildingFloorsList.Count;
		
		for (int j = 0; j < buildingFloorsListCount; j++) {
			floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

			if (currentFloorInfo.floor != null) {
				if (j == floorIndex) {
					//print (currentBuildingInfo.buildingFloorsList [j].Name);
					if (!currentFloorInfo.floor.activeSelf) {
						currentFloorInfo.floor.SetActive (true);
					}
				} else {
					if (currentFloorInfo.floor.activeSelf) {
						currentFloorInfo.floor.SetActive (false);
					}
				}
			}
		}
	}

	public void setFloorActiveState (int buildingIndex, int floorIndex, bool state)
	{
		if (buildingIndex < 0 || floorIndex < 0) {
			return;
		}

		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		if (currentFloorInfo.floor != null && currentFloorInfo.floor.activeSelf != state) {
			currentFloorInfo.floor.SetActive (state);
		}
	}

	public void enableOrDisableSingleMapIconByMapPartIndex (int mapPartBuildingIndex, int mapPartIndex, int mapPartFloorIndex, bool value)
	{
		int mapSystemListCount = mapSystemList.Count;

		for (int i = 0; i < mapSystemListCount; i++) {
			mapSystemList [i].enableOrDisableSingleMapIconByMapPartIndex (mapPartBuildingIndex, mapPartIndex, mapPartFloorIndex, value);
		}
	}

	public void enableOrDisabled2dMap (bool state, int buildingIndex)
	{
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			if (i == buildingIndex) {
				if (buildingList [i].buildingFloorsParent.gameObject.activeSelf != state) {
					buildingList [i].buildingFloorsParent.gameObject.SetActive (state);
				}
			}
		}
	}

	public void setCurrentObjectToChangeBuildingInfo (GameObject newCharacter)
	{
		currentCharacterToUse = newCharacter;
	}

	public void setCurrentMapPartIndex (int newValue)
	{
		int mapSystemInfoListCount = mapSystemInfoList.Count;

		for (int i = 0; i < mapSystemInfoListCount; i++) {
			mapSystemInfo currentMapSystemInfo = mapSystemInfoList [i];

			if (currentCharacterToUse == currentMapSystemInfo.playerGameObject) {
				if (currentMapSystemInfo.mainMapSystem != null) {
					currentMapSystemInfo.mainMapSystem.setCurrentMapPartIndex (newValue);
				}
			}
		}
	}

	public void getPlayerGameObject (GameObject newPlayerDetected)
	{
		currentPlayerDetected = newPlayerDetected;
	}

	public void changeCurrentBuilding (GameObject currentTriggerBuilding)
	{
//		print (currentTriggerBuilding.name);

		int buildingListCount = buildingList.Count;

		int mapSystemInfoListCount = mapSystemInfoList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			if (buildingList [i].buildingMapParent.gameObject == currentTriggerBuilding) {
				setCurrentBuildingByBuildingIndex (i);

				for (int j = 0; j < mapSystemInfoListCount; j++) {
					mapSystemInfo currentMapSystemInfo = mapSystemInfoList [j];

					if (currentMapSystemInfo.playerGameObject == currentPlayerDetected) {
						currentMapSystemInfo.mainMapSystem.updateCurrentBuilding (i);

						currentMapSystemInfo.mainMapSystem.updateCurrentFloorNumber ();
					}
				}
			}
		}
	}

	public void changeCurrentBuilding (int newCurrentBuildingIndex, GameObject newCharacter)
	{
		setCurrentBuildingByBuildingIndex (newCurrentBuildingIndex);

		int mapSystemInfoListCount = mapSystemInfoList.Count;

		for (int i = 0; i < mapSystemInfoListCount; i++) {
			mapSystemInfo currentMapSystemInfo = mapSystemInfoList [i];

			if (currentMapSystemInfo.playerGameObject == newCharacter) {
				currentMapSystemInfo.mainMapSystem.updateCurrentBuilding (newCurrentBuildingIndex);
				currentMapSystemInfo.mainMapSystem.updateCurrentFloorNumber ();
			}
		}
	}

	public void setCurrentBuildingByBuildingIndex (int buildingIndex)
	{
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			buildingInfo currentBuildingInfo = buildingList [i];

			if (i == buildingIndex) {
				if (!currentBuildingInfo.buildingFloorsParent.gameObject.activeSelf) {
					currentBuildingInfo.buildingFloorsParent.gameObject.SetActive (true);
				}
			} else {
				if (currentBuildingInfo.buildingFloorsParent.gameObject.activeSelf) {
					currentBuildingInfo.buildingFloorsParent.gameObject.SetActive (false);
				}
			}
		}
	}

	public void setBuildingAndFloorInfoToObject (GameObject objectToCheck, Transform buildingParent, Transform floorParent)
	{
		mapObjectInformation currentMapObjectInformation = objectToCheck.GetComponent<mapObjectInformation> ();

		if (currentMapObjectInformation != null) {

			int buildingListCount = buildingList.Count;

			for (int i = 0; i < buildingListCount; i++) {
				buildingInfo currentBuildingInfo = buildingList [i];

				if (currentBuildingInfo.buildingMapParent == buildingParent) {
					for (int j = 0; j < currentBuildingInfo.buildingFloorsList.Count; j++) {

						floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

						if (currentFloorInfo.floor != null && currentFloorInfo.floor.transform == floorParent) {
							currentMapObjectInformation.setNewBuildingAndFloorIndex (i, j);

							return;
						}
					}
				}
			}
		}
	}
	//END OF INGAME FUNCTIONS

	//START OF 3d MAP FUNCTIONS
	//3d map managemement
	public void addMapPart3dMeshToFloorParent (GameObject mapPart3dMesh, GameObject mapPartGameObject)
	{
		int mapBuildingIndex = -1;
		int mapFloorNumber = -1;
		int mapPartIndex = -1;

		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {

			buildingInfo currentBuildingInfo = buildingList [i];

			int buildingFloorsListCount = currentBuildingInfo.buildingFloorsList.Count;

			for (int j = 0; j < buildingFloorsListCount; j++) {
				floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

				if (currentFloorInfo.mapPartsList.Contains (mapPartGameObject) && mapFloorNumber == -1) {
					mapFloorNumber = j;

					mapPartIndex = currentFloorInfo.mapPartsList.IndexOf (mapPartGameObject);

					mapBuildingIndex = i;
				}
			}
		}

		if (mapFloorNumber != -1 && mapPartIndex != -1 && mapBuildingIndex != -1) {
			floorInfo currentFloorInfo = buildingList [mapBuildingIndex].buildingFloorsList [mapFloorNumber];

			if (currentFloorInfo.mapPart3dMeshesParent == null) {
				currentFloorInfo.mapPart3dMeshesParent = new GameObject ().transform;
				currentFloorInfo.mapPart3dMeshesParent.SetParent (buildingList [mapBuildingIndex].buildingMapParent);
				currentFloorInfo.mapPart3dMeshesParent.name = "Map Part3d Meshes Parent " + currentFloorInfo.Name;
			}

			if (currentFloorInfo.mapPart3dMeshesParent != null) {
				mapPart3dMesh.transform.SetParent (currentFloorInfo.mapPart3dMeshesParent);

				if (mapPartIndex == currentFloorInfo.mapPartsList.Count - 1) {
					if (currentFloorInfo.mapPart3dMeshesParent.gameObject.activeSelf) {
						currentFloorInfo.mapPart3dMeshesParent.gameObject.SetActive (false);
					}
				}
			}
		} else {
			print ("Map floor or map part " + mapPartGameObject.name + " not found");
		}
	}

	public void enableOrDisabled3dMap (bool state, int buildingIndex)
	{
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			if (i == buildingIndex) {
				buildingInfo currentBuildingInfo = buildingList [i];

				int buildingFloorsListCount = currentBuildingInfo.buildingFloorsList.Count;

				for (int j = 0; j < buildingFloorsListCount; j++) {
					floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

					if (currentFloorInfo.mapPart3dMeshesParent != null) {
						if (currentFloorInfo.mapPart3dMeshesParent.gameObject.activeSelf != state) {
							currentFloorInfo.mapPart3dMeshesParent.gameObject.SetActive (state);
						}
					}
				}
			}
		}
	}

	public void updateMapPart3dMeshPosition ()
	{
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			buildingInfo currentBuildingInfo = buildingList [i];

			int buildingFloorsListCount = currentBuildingInfo.buildingFloorsList.Count;

			for (int j = 0; j < buildingFloorsListCount; j++) {
				floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

				if (!currentFloorInfo.floorEnabled) {

					int mapTileBuilderListCount = currentFloorInfo.mapTileBuilderList.Count;
					
					for (int k = 0; k < mapTileBuilderListCount; k++) {
						currentFloorInfo.mapTileBuilderList [k].updateMapPart3dMeshPosition (mapPart3dOffset);
					}
				}
			}
		}
	}

	public void enableOrDisableMapPart3dMesh (bool state)
	{
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			buildingInfo currentBuildingInfo = buildingList [i];

			int buildingFloorsListCount = currentBuildingInfo.buildingFloorsList.Count;

			for (int j = 0; j < buildingFloorsListCount; j++) {
				floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

				if (!currentFloorInfo.floorEnabled) {
					int mapTileBuilderListCount = currentFloorInfo.mapTileBuilderList.Count;

					for (int k = 0; k < mapTileBuilderListCount; k++) {
						currentFloorInfo.mapTileBuilderList [k].enableOrDisableMapPart3dMesh (state);
					}
				}
			}
		}
	}

	public void set3dMapPartMeshColor (Color newColor, bool setOriginalColor, int currentBuildingIndex, int currentFloorIndex, int currentMapPartIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [currentBuildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [currentFloorIndex];

		if (setOriginalColor) {
			currentFloorInfo.mapTileBuilderList [currentMapPartIndex].setOriginal3dMapPartMaterialColor ();
		} else {
			currentFloorInfo.mapTileBuilderList [currentMapPartIndex].set3dMapPartMaterialColor (newColor);
		}
	}

	//3d MAP EDITOR FUNCTIONS
	public void removeMapPart3dMesh ()
	{
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			buildingInfo currentBuildingInfo = buildingList [i];

			int buildingFloorsListCount = currentBuildingInfo.buildingFloorsList.Count;

			for (int j = 0; j < buildingFloorsListCount; j++) {
				floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

				if (!currentFloorInfo.floorEnabled) {
					int mapTileBuilderListCount = currentFloorInfo.mapTileBuilderList.Count;

					for (int k = 0; k < mapTileBuilderListCount; k++) {
						currentFloorInfo.mapTileBuilderList [k].removeMapPart3dMesh ();
					}
				}
			}
		}
	}

	public void generateMapPart3dMesh ()
	{
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			buildingInfo currentBuildingInfo = buildingList [i];

			int buildingFloorsListCount = currentBuildingInfo.buildingFloorsList.Count;

			for (int j = 0; j < buildingFloorsListCount; j++) {
				floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

				if (!currentFloorInfo.floorEnabled) {
					int mapTileBuilderListCount = currentFloorInfo.mapTileBuilderList.Count;

					for (int k = 0; k < mapTileBuilderListCount; k++) {
						currentFloorInfo.mapTileBuilderList [k].generateMapPart3dMesh (mapPart3dHeight);
					}
				}
			}
		}
	}

	public void setGenerate3dMapPartMeshState ()
	{
		generate3dMapPartMesh = !generate3dMapPartMesh;

		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			for (int j = 0; j < buildingList [i].buildingFloorsList.Count; j++) {
				for (int k = 0; k < buildingList [i].buildingFloorsList [j].mapTileBuilderList.Count; k++) {
					buildingList [i].buildingFloorsList [j].mapTileBuilderList [k].setGenerate3dMapPartMeshState (generate3dMapPartMesh);
				}
			}
		}
	}

	public void setGenerate3dMapPartMeshStateFromEditor ()
	{
		generate3dMapPartMesh = !generate3dMapPartMesh;

		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			for (int j = 0; j < buildingList [i].buildingFloorsList.Count; j++) {
				for (int k = 0; k < buildingList [i].buildingFloorsList [j].mapTileBuilderList.Count; k++) {
					buildingList [i].buildingFloorsList [j].mapTileBuilderList [k].setGenerate3dMapPartMeshStateFromEditor (generate3dMapPartMesh);
				}
			}
		}
	}

	public void setGenerate3dMapPartMeshStateToFloor (bool value, int buildingIndex, int floorIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		for (int i = 0; i < currentFloorInfo.mapTileBuilderList.Count; i++) {
			currentFloorInfo.mapTileBuilderList [i].setGenerate3dMapPartMeshState (value);
		}
	}

	public void setGenerate3dMapPartMeshStateToFloorFromEditor (bool value, int buildingIndex, int floorIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		for (int i = 0; i < currentFloorInfo.mapTileBuilderList.Count; i++) {
			currentFloorInfo.mapTileBuilderList [i].setGenerate3dMapPartMeshStateFromEditor (value);
		}

		updateComponent ();
	}
	//END OF 3d MAP FUNCTIONS


	//START EDITOR FUNCTIONS
	//Floor map parts management
	public void addNewMapPart (Transform mapPartParent)
	{
		GameObject currentFloor = mapPartParent.gameObject;
		GameObject newMapPart = new GameObject ();
		newMapPart.transform.SetParent (currentFloor.transform);
		newMapPart.transform.localPosition = Vector3.zero;
		newMapPart.transform.localRotation = Quaternion.Euler (90, 0, 0);

		mapTileBuilder newMapTileBuilder = newMapPart.AddComponent<mapTileBuilder> ();
		newMapTileBuilder.setMapManager (this);
		newMapTileBuilder.setMapPartParent (mapPartParent);

		floorInfo currentFloorInfo = new floorInfo ();
		int buildingIndex = -1;
		int floorIndex = -1;

		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			for (int j = 0; j < buildingList [i].buildingFloorsList.Count; j++) {
				if (buildingList [i].buildingFloorsList [j].floor == currentFloor) {
					currentFloorInfo = buildingList [i].buildingFloorsList [j];
					buildingIndex = i;
					floorIndex = j;
				}
			}
		}

		newMapTileBuilder.setMapPartBuildingIndex (buildingIndex);
		newMapTileBuilder.setMapPartFlooorIndex (floorIndex);
		newMapTileBuilder.setMapPartIndex (currentFloorInfo.mapPartsList.Count);

		newMapPart.name = (currentFloorInfo.mapPartsList.Count + 1).ToString ("000");
		currentFloorInfo.mapPartsList.Add (newMapPart);

		currentFloorInfo.mapTileBuilderList.Add (newMapTileBuilder);

		updateComponent ();
	}

	public void addNewMapPartFromMapCreator (int buildingIndex, int floorIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		GameObject currentFloor = currentFloorInfo.floor;
		GameObject newMapPart = new GameObject ();

		newMapPart.transform.SetParent (currentFloor.transform);

		if ((floorIndex - 1) >= 0) {
			newMapPart.transform.localPosition = Vector3.zero;
			//currentBuildingInfo.buildingFloorsList [floorIndex - 1].floor.transform.localPosition;
		}

		newMapPart.transform.localRotation = Quaternion.Euler (90, 0, 0);

		mapTileBuilder newMapTileBuilder = newMapPart.AddComponent<mapTileBuilder> ();
		newMapTileBuilder.setMapManager (this);
		newMapTileBuilder.setMapPartParent (currentFloorInfo.floor.transform);

		newMapTileBuilder.setMapPartBuildingIndex (buildingIndex);
		newMapTileBuilder.setMapPartFlooorIndex (floorIndex);
		newMapTileBuilder.setMapPartIndex (currentFloorInfo.mapPartsList.Count);

		newMapPart.name = (currentFloorInfo.mapPartsList.Count + 1).ToString ("000");
		currentFloorInfo.mapPartsList.Add (newMapPart);

		currentFloorInfo.mapTileBuilderList.Add (newMapTileBuilder);

		updateComponent ();
	}

	public void removeMapPart (int buildingIndex, int floorIndex, int mapPartIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];
		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		GameObject currentMapPart = currentFloorInfo.mapPartsList [mapPartIndex];

		if (currentMapPart != null) {
			DestroyImmediate (currentMapPart);
		}

		currentFloorInfo.mapPartsList.RemoveAt (mapPartIndex);

		GetAllFloorParts (buildingIndex, floorIndex);

		updateComponent ();
	}

	public void removeMapPart (Transform mapPartParent, GameObject mapPartToDelete)
	{
		GameObject currentFloor = mapPartParent.gameObject;

		floorInfo currentFloorInfo = new floorInfo ();
		int buildingIndex = -1;
		int floorIndex = -1;

		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			for (int j = 0; j < buildingList [i].buildingFloorsList.Count; j++) {
				if (buildingList [i].buildingFloorsList [j].floor == currentFloor) {
					currentFloorInfo = buildingList [i].buildingFloorsList [j];
					buildingIndex = i;
					floorIndex = j;
				}
			}
		}

		currentFloorInfo.mapPartsList.Remove (mapPartToDelete);

		DestroyImmediate (mapPartToDelete);

		GetAllFloorParts (buildingIndex, floorIndex);

		updateComponent ();
	}

	public void removeAllMapParts (int buildingIndex, int floorIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		for (int i = 0; i < currentFloorInfo.mapPartsList.Count; i++) {
			if (currentFloorInfo.mapPartsList [i] != null) {
				DestroyImmediate (currentFloorInfo.mapPartsList [i]);
			}
		}

		currentFloorInfo.mapPartsList.Clear ();

		updateComponent ();
	}

	public void duplicateMapPart (Transform mapPartParent, GameObject mapPartToDuplicate)
	{
		GameObject currentFloor = mapPartParent.gameObject;

		GameObject newMapPart = (GameObject)Instantiate (mapPartToDuplicate, Vector3.zero, Quaternion.identity);

		newMapPart.transform.SetParent (currentFloor.transform);

		newMapPart.transform.localPosition = mapPartToDuplicate.transform.localPosition;
		newMapPart.transform.localRotation = mapPartToDuplicate.transform.localRotation;

		floorInfo currentFloorInfo = new floorInfo ();

		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			for (int j = 0; j < buildingList [i].buildingFloorsList.Count; j++) {
				if (buildingList [i].buildingFloorsList [j].floor == currentFloor) {
					currentFloorInfo = buildingList [i].buildingFloorsList [j];
				}
			}
		}

		newMapPart.name = (currentFloorInfo.mapPartsList.Count + 1).ToString ("000");
		currentFloorInfo.mapPartsList.Add (newMapPart);

		mapTileBuilder newMapTileBuilder = newMapPart.GetComponent<mapTileBuilder> ();
		newMapTileBuilder.setMapPartIndex (currentFloorInfo.mapTileBuilderList.Count);
		currentFloorInfo.mapTileBuilderList.Add (newMapTileBuilder);

		updateComponent ();
	}

	//Map floors management
	public void addNewFloor (int buildingIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo newFloorInfo = new floorInfo ();
		newFloorInfo.floorNumber = currentBuildingInfo.buildingFloorsList.Count;

		GameObject newFloor = new GameObject ();
		newFloor.transform.SetParent (currentBuildingInfo.buildingFloorsParent);
		newFloor.transform.localPosition = Vector3.zero;
		newFloor.transform.localRotation = Quaternion.identity;
		newFloor.name = "Floor-" + (newFloorInfo.floorNumber).ToString ("000");
		newFloorInfo.Name = newFloor.name;
		newFloorInfo.floor = newFloor;
		newFloorInfo.floorEnabled = true;

		currentBuildingInfo.buildingFloorsList.Add (newFloorInfo);

		GameObject newMapPart = new GameObject ();
		newMapPart.transform.SetParent (newFloor.transform);
		newMapPart.transform.localPosition = Vector3.zero;
		newMapPart.transform.localRotation = Quaternion.Euler (90, 0, 0);

		mapTileBuilder newMapTileBuilder = newMapPart.AddComponent<mapTileBuilder> ();
		newMapTileBuilder.setMapManager (this);
		newMapTileBuilder.setMapPartParent (newFloor.transform);

		newMapTileBuilder.setMapPartBuildingIndex (buildingIndex);
		newMapTileBuilder.setMapPartFlooorIndex (currentBuildingInfo.buildingFloorsList.IndexOf (newFloorInfo));
		newMapTileBuilder.setMapPartIndex (newFloorInfo.mapPartsList.Count);

		newMapPart.name = (newFloorInfo.mapPartsList.Count + 1).ToString ("000");
		newFloorInfo.mapPartsList.Add (newMapPart);

		newFloorInfo.mapTileBuilderList.Add (newMapTileBuilder);

		updateComponent ();
	}

	public void removeFloor (int buildingIndex, int floorIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		GameObject currentFloor = currentFloorInfo.floor;

		for (int i = 0; i < currentFloorInfo.mapPartsList.Count; i++) {
			removeMapPart (buildingIndex, floorIndex, i);
		}

		removeTriggerToChangeFloorList (buildingIndex, floorIndex);

		currentBuildingInfo.buildingFloorsList.RemoveAt (floorIndex);

		DestroyImmediate (currentFloor);

		for (int j = 0; j < currentBuildingInfo.buildingFloorsList.Count; j++) {
			GetAllFloorParts (buildingIndex, j);
		}

		updateComponent ();
	}

	public void removeAllFloors (int buildingIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		for (int i = 0; i < currentBuildingInfo.buildingFloorsList.Count; i++) {
			floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [i];

			GameObject currentFloor = currentFloorInfo.floor;

			for (int j = 0; j < currentFloorInfo.mapPartsList.Count; j++) {
				if (currentFloorInfo.mapPartsList [j] != null) {
					DestroyImmediate (currentFloorInfo.mapPartsList [j]);
				}
			}

			removeTriggerToChangeFloorList (buildingIndex, i);

			DestroyImmediate (currentFloor);
		}

		currentBuildingInfo.buildingFloorsList.Clear ();

		updateComponent ();
	}

	public void renameFloor (int buildingIndex, int floorIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		currentFloorInfo.floor.name = currentFloorInfo.Name;

		updateComponent ();
	}

	//Map floors triggers management
	public void addTriggerToChangeFloor (int buildingIndex, int floorIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		if (currentFloorInfo.currentFloorParent == null) {
			GameObject currentFloorParent = new GameObject ();
			currentFloorParent.name = "Trigger Parent Floor " + currentFloorInfo.floorNumber;
			currentFloorParent.transform.SetParent (currentBuildingInfo.buildingMapParent);
			currentFloorParent.transform.localPosition = Vector3.zero;
			currentFloorParent.transform.localRotation = Quaternion.identity;
			currentFloorInfo.currentFloorParent = currentFloorParent.transform;
		}

		GameObject newTriggerToChangeFloor = (GameObject)Instantiate (triggerToChangeFloorPrefab, Vector3.zero, Quaternion.identity);

		if (useRaycastToPlaceElements) {

			Camera currentCameraEditor = GKC_Utils.getCameraEditor ();

			if (currentCameraEditor != null) {
				Vector3 editorCameraPosition = currentCameraEditor.transform.position;
				Vector3 editorCameraForward = currentCameraEditor.transform.forward;

				RaycastHit hit;

				if (Physics.Raycast (editorCameraPosition, editorCameraForward, out hit, Mathf.Infinity, layerToPlaceElements)) {
					newTriggerToChangeFloor.transform.position = hit.point + Vector3.up * 0.1f;
				}
			}
		}

		newTriggerToChangeFloor.transform.localScale = mapPartEnabledTriggerScale;

		eventTriggerSystem currentEventTriggerSystem = newTriggerToChangeFloor.GetComponent<eventTriggerSystem> ();
		currentEventTriggerSystem.eventList [0].objectToCall = gameObject;
		currentEventTriggerSystem.eventList [0].objectToSend = currentFloorInfo.floor;

		newTriggerToChangeFloor.transform.SetParent (currentFloorInfo.currentFloorParent);
		newTriggerToChangeFloor.name = "Trigger To Change Floor " + (currentFloorInfo.floorNumber) + "-" + currentFloorInfo.triggerToChangeFloorList.Count;

		currentFloorInfo.triggerToChangeFloorList.Add (newTriggerToChangeFloor);

		updateComponent ();
	}

	public void removeTriggerToChangeFloor (int buildingIndex, int floorIndex, int triggerIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		GameObject currentChangeTrigger = currentFloorInfo.triggerToChangeFloorList [triggerIndex];

		if (currentChangeTrigger != null) {
			DestroyImmediate (currentChangeTrigger);
		}

		currentFloorInfo.triggerToChangeFloorList.RemoveAt (triggerIndex);

		if (currentFloorInfo.triggerToChangeFloorList.Count == 0) {
			if (currentFloorInfo.currentFloorParent != null) {
				DestroyImmediate (currentFloorInfo.currentFloorParent.gameObject);
			}
		}

		updateComponent ();
	}

	public void removeTriggerToChangeFloorList (int buildingIndex, int floorIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		for (int i = 0; i < currentFloorInfo.triggerToChangeFloorList.Count; i++) {
			GameObject currentChangeTrigger = currentFloorInfo.triggerToChangeFloorList [i];

			if (currentChangeTrigger != null) {
				DestroyImmediate (currentChangeTrigger);
			}
		}

		currentFloorInfo.triggerToChangeFloorList.Clear ();

		if (currentFloorInfo.currentFloorParent != null) {
			DestroyImmediate (currentFloorInfo.currentFloorParent.gameObject);
		}

		updateComponent ();
	}

	public void enableOrDisableAllFloorParts (bool state, int buildingIndex, int floorIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		for (int j = 0; j < currentFloorInfo.mapTileBuilderList.Count; j++) {
			currentFloorInfo.mapTileBuilderList [j].setMapPartEnabledStateFromEditor (state);
		}

		updateComponent ();
	}

	public void enableOrDisableFloorPart (bool state, int buildingIndex, int floorIndex, int mapPartIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		currentFloorInfo.mapTileBuilderList [mapPartIndex].setMapPartEnabledStateFromEditor (state);

		updateComponent ();
	}

	//Map building management
	public void renameBuilding (int index)
	{
		buildingInfo currentBuildingInfo = buildingList [index];

		currentBuildingInfo.buildingMapParent.name = currentBuildingInfo.Name;

		updateComponent ();
	}

	public void addNewBuilding ()
	{
		buildingInfo currentBuildingInfo = new buildingInfo ();

		GameObject newBuildingParent = new GameObject ();
		newBuildingParent.transform.SetParent (transform);
		newBuildingParent.transform.localPosition = Vector3.zero;
		newBuildingParent.transform.localRotation = Quaternion.identity;

		newBuildingParent.name = "Building-" + (buildingList.Count + 1).ToString ("000");
		currentBuildingInfo.Name = newBuildingParent.name;
		currentBuildingInfo.buildingMapParent = newBuildingParent.transform;
		currentBuildingInfo.buildingMapEnabled = true;

		GameObject newBuildingFloorsParent = new GameObject ();
		newBuildingFloorsParent.name = "Building Content";
		newBuildingFloorsParent.transform.SetParent (newBuildingParent.transform);
		newBuildingFloorsParent.transform.localPosition = Vector3.zero;
		newBuildingFloorsParent.transform.localRotation = Quaternion.identity;
		currentBuildingInfo.buildingFloorsParent = newBuildingFloorsParent.transform;

		buildingList.Add (currentBuildingInfo);

		addNewFloor (buildingList.Count - 1);

		updateComponent ();
	}

	public void removeBuilding (int buildingIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		GameObject currentBuilding = currentBuildingInfo.buildingMapParent.gameObject;

		for (int j = 0; j < currentBuildingInfo.buildingFloorsList.Count; j++) {
			floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

			for (int k = 0; k < currentFloorInfo.mapPartsList.Count; k++) {
				removeMapPart (buildingIndex, j, k);
			}
		}

		//removeTriggerToChangeFloorList (buildingIndex, floorIndex);

		buildingList.RemoveAt (buildingIndex);

		DestroyImmediate (currentBuilding);

		getAllBuildings ();

		updateComponent ();
	}

	public void removeAllBuildings ()
	{
		for (int i = 0; i < buildingList.Count; i++) {
			buildingInfo currentBuildingInfo = buildingList [i];

			for (int j = 0; j < currentBuildingInfo.buildingFloorsList.Count; j++) {

				floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];
				GameObject currentFloor = currentFloorInfo.floor;

				for (int k = 0; k < currentFloorInfo.mapPartsList.Count; k++) {
					if (currentFloorInfo.mapPartsList [k] != null) {
						DestroyImmediate (currentFloorInfo.mapPartsList [k]);
					}
				}

				removeTriggerToChangeFloorList (i, j);

				DestroyImmediate (currentFloor);
			}

			currentBuildingInfo.buildingFloorsList.Clear ();

			DestroyImmediate (currentBuildingInfo.buildingMapParent.gameObject);
		}

		buildingList.Clear ();

		updateComponent ();
	}


	public void enableOrDisableAllBuildings (bool state)
	{
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			enableOrDisableBuilding (state, i);
		}

		updateComponent ();
	}

	public void enableOrDisableBuilding (bool state, int buildingIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		for (int j = 0; j < currentBuildingInfo.buildingFloorsList.Count; j++) {
			floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [j];

			for (int k = 0; k < currentFloorInfo.mapTileBuilderList.Count; k++) {
				currentFloorInfo.mapTileBuilderList [k].setMapPartEnabledState (state);
			}
		}

		updateComponent ();
	}
		
	//Map building triggers management
	public void addTriggerToChangeBuilding (int buildingIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		if (currentBuildingInfo.triggerToChangeBuildingParent == null) {
			GameObject currentBuildingParent = new GameObject ();
			currentBuildingParent.name = "Trigger Parent Building " + currentBuildingInfo.Name;
			currentBuildingParent.transform.SetParent (currentBuildingInfo.buildingMapParent);
			currentBuildingParent.transform.localPosition = Vector3.zero;
			currentBuildingParent.transform.localRotation = Quaternion.identity;
			currentBuildingInfo.triggerToChangeBuildingParent = currentBuildingParent.transform;
		}

		GameObject newTriggerToChangeBuilding = (GameObject)Instantiate (triggerToChangeBuildingPrefab, Vector3.zero, Quaternion.identity);

		if (useRaycastToPlaceElements) {
			Camera currentCameraEditor = GKC_Utils.getCameraEditor ();

			if (currentCameraEditor != null) {
				Vector3 editorCameraPosition = currentCameraEditor.transform.position;
				Vector3 editorCameraForward = currentCameraEditor.transform.forward;

				RaycastHit hit;

				if (Physics.Raycast (editorCameraPosition, editorCameraForward, out hit, Mathf.Infinity, layerToPlaceElements)) {
					newTriggerToChangeBuilding.transform.position = hit.point + Vector3.up * 0.1f;
				}
			}
		}

		newTriggerToChangeBuilding.transform.localScale = mapPartEnabledTriggerScale;

		eventTriggerSystem currentEventTriggerSystem = newTriggerToChangeBuilding.GetComponent<eventTriggerSystem> ();
		currentEventTriggerSystem.eventList [0].objectToCall = gameObject;
		currentEventTriggerSystem.eventList [0].objectToSend = currentBuildingInfo.buildingMapParent.gameObject;

		newTriggerToChangeBuilding.transform.SetParent (currentBuildingInfo.triggerToChangeBuildingParent);
		newTriggerToChangeBuilding.name = "Trigger To Change Building-" + currentBuildingInfo.Name + "-" + currentBuildingInfo.triggerToChangeBuildingList.Count;

		currentBuildingInfo.triggerToChangeBuildingList.Add (newTriggerToChangeBuilding);

		updateComponent ();
	}

	public void removeTriggerToChangeBuilding (int buildingIndex, int triggerIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		GameObject currentChangeTrigger = currentBuildingInfo.triggerToChangeBuildingList [triggerIndex];

		if (currentChangeTrigger != null) {
			DestroyImmediate (currentChangeTrigger);
		}

		currentBuildingInfo.triggerToChangeBuildingList.RemoveAt (triggerIndex);

		if (currentBuildingInfo.triggerToChangeBuildingList.Count == 0) {
			if (currentBuildingInfo.triggerToChangeBuildingParent != null) {
				DestroyImmediate (currentBuildingInfo.triggerToChangeBuildingParent.gameObject);
			}
		}

		updateComponent ();
	}

	public void removeTriggerToChangeBuildingList (int buildingIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		for (int i = 0; i < currentBuildingInfo.triggerToChangeBuildingList.Count; i++) {
			GameObject currentChangeTrigger = currentBuildingInfo.triggerToChangeBuildingList [i];

			if (currentChangeTrigger != null) {
				DestroyImmediate (currentChangeTrigger);
			}
		}

		currentBuildingInfo.triggerToChangeBuildingList.Clear ();

		if (currentBuildingInfo.triggerToChangeBuildingParent != null) {
			DestroyImmediate (currentBuildingInfo.triggerToChangeBuildingParent.gameObject);
		}

		updateComponent ();
	}

	public void addTriggerToDynamicObject (int buildingIndex, int floorIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		if (currentBuildingInfo.triggerToChangeDynamicObjectsParent == null) {
			GameObject currentBuildingParent = new GameObject ();
			currentBuildingParent.name = "Trigger Dynamic Objects " + currentBuildingInfo.Name;
			currentBuildingParent.transform.SetParent (currentBuildingInfo.buildingMapParent);
			currentBuildingParent.transform.localPosition = Vector3.zero;
			currentBuildingParent.transform.localRotation = Quaternion.identity;
			currentBuildingInfo.triggerToChangeDynamicObjectsParent = currentBuildingParent.transform;
		}

		GameObject newTriggerToChangeDynamicObject = (GameObject)Instantiate (triggerToChangeDynamicObjectPrefab, Vector3.zero, Quaternion.identity);

		if (useRaycastToPlaceElements) {
			Camera currentCameraEditor = GKC_Utils.getCameraEditor ();

			if (currentCameraEditor != null) {
				Vector3 editorCameraPosition = currentCameraEditor.transform.position;
				Vector3 editorCameraForward = currentCameraEditor.transform.forward;

				RaycastHit hit;

				if (Physics.Raycast (editorCameraPosition, editorCameraForward, out hit, Mathf.Infinity, layerToPlaceElements)) {
					newTriggerToChangeDynamicObject.transform.position = hit.point + Vector3.up * 0.1f;
				}
			}
		}

		newTriggerToChangeDynamicObject.transform.localScale = mapPartEnabledTriggerScale;

		buildingAndFloorObjectInfoSystem currentBuildingAndFloorObjectInfoSystem = newTriggerToChangeDynamicObject.GetComponent<buildingAndFloorObjectInfoSystem> ();

		currentBuildingAndFloorObjectInfoSystem.setBuildingFloorInfo (currentBuildingInfo.buildingMapParent, currentBuildingInfo.buildingFloorsList [floorIndex].floor.transform, this);

		newTriggerToChangeDynamicObject.transform.SetParent (currentBuildingInfo.triggerToChangeDynamicObjectsParent);

		newTriggerToChangeDynamicObject.name = "Trigger Dynamic Object-" + currentBuildingInfo.Name + "-" + currentBuildingInfo.buildingFloorsList [floorIndex].Name + " " +
		(currentBuildingInfo.triggerForDynamicObjectsList.Count + 1);

		currentBuildingInfo.triggerForDynamicObjectsList.Add (newTriggerToChangeDynamicObject);

		updateComponent ();
	}

	public void removeTriggerToDynamicObject (int buildingIndex, int triggerIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		GameObject currentChangeTrigger = currentBuildingInfo.triggerForDynamicObjectsList [triggerIndex];

		if (currentChangeTrigger != null) {
			DestroyImmediate (currentChangeTrigger);
		}

		currentBuildingInfo.triggerForDynamicObjectsList.RemoveAt (triggerIndex);

		if (currentBuildingInfo.triggerForDynamicObjectsList.Count == 0) {
			if (currentBuildingInfo.triggerToChangeDynamicObjectsParent != null) {
				DestroyImmediate (currentBuildingInfo.triggerToChangeDynamicObjectsParent.gameObject);
			}
		}

		updateComponent ();
	}

	public void removeTriggerToDynamicObjectList (int buildingIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		for (int i = 0; i < currentBuildingInfo.triggerForDynamicObjectsList.Count; i++) {
			GameObject currentChangeTrigger = currentBuildingInfo.triggerForDynamicObjectsList [i];

			if (currentChangeTrigger != null) {
				DestroyImmediate (currentChangeTrigger);
			}
		}

		currentBuildingInfo.triggerForDynamicObjectsList.Clear ();

		if (currentBuildingInfo.triggerToChangeDynamicObjectsParent != null) {
			DestroyImmediate (currentBuildingInfo.triggerToChangeDynamicObjectsParent.gameObject);
		}

		updateComponent ();
	}

	public void GetAllFloorParts (int buildingIndex, int floorIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];

		floorInfo currentFloorInfo = currentBuildingInfo.buildingFloorsList [floorIndex];

		currentFloorInfo.mapPartsList.Clear ();
		currentFloorInfo.mapTileBuilderList.Clear ();
		List<GameObject> currentMapPartsList = currentFloorInfo.mapPartsList;
		int mapPartIndex = 0;

		print ("Updating info of building " + buildingIndex + " " + buildingList [buildingIndex].Name);

		foreach (Transform child in currentFloorInfo.floor.transform) {
			print ("Updating info of floor " + mapPartIndex + " " + currentFloorInfo.Name);

			mapPartIndex++;

			string newName = (mapPartIndex).ToString ("000");

			child.gameObject.name = newName;

			mapTileBuilder newMapTileBuilder = child.gameObject.GetComponent<mapTileBuilder> ();

			newMapTileBuilder.setMapManager (this);
			newMapTileBuilder.setInternalName (newName);
			newMapTileBuilder.setMapPartParent (currentFloorInfo.floor.transform);
			newMapTileBuilder.setMapPartBuildingIndex (buildingIndex);
			newMapTileBuilder.setMapPartFlooorIndex (floorIndex);
			newMapTileBuilder.setMapPartIndex (mapPartIndex - 1);

			currentMapPartsList.Add (child.gameObject);

			currentFloorInfo.mapTileBuilderList.Add (newMapTileBuilder);
		}

		updateComponent ();
	}

	public void calculateAllMapTileMesh ()
	{
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			currentBuildingInfoToUse = buildingList [i];

			for (int j = 0; j < currentBuildingInfoToUse.buildingFloorsList.Count; j++) {
				currentFloorInfoToUse = currentBuildingInfoToUse.buildingFloorsList [j];

				for (int k = 0; k < currentFloorInfoToUse.mapTileBuilderList.Count; k++) {
					currentFloorInfoToUse.mapTileBuilderList [k].calculateMapTileMesh ();

					GKC_Utils.updateComponent (currentFloorInfoToUse.mapTileBuilderList [k]);
				}
			}
		}
	}

	public void removeAllMapTileMesh ()
	{
		int buildingListCount = buildingList.Count;

		for (int i = 0; i < buildingListCount; i++) {
			currentBuildingInfoToUse = buildingList [i];

			for (int j = 0; j < currentBuildingInfoToUse.buildingFloorsList.Count; j++) {
				currentFloorInfoToUse = currentBuildingInfoToUse.buildingFloorsList [j];

				for (int k = 0; k < currentFloorInfoToUse.mapTileBuilderList.Count; k++) {
					currentFloorInfoToUse.mapTileBuilderList [k].removeMapTileRenderer ();

					GKC_Utils.updateComponent (currentFloorInfoToUse.mapTileBuilderList [k]);
				}
			}
		}
	}

	public void setMapObjectInformationID ()
	{
		lastMapObjectInformationIDAssigned = 1;

		mapObjectInformation[] mapObjectInformationList = FindObjectsOfType<mapObjectInformation> ();

		int mapObjectInformationListLength = mapObjectInformationList.Length;

		for (int j = 0; j < mapObjectInformationListLength; j++) {
			mapObjectInformation mapObjectInfo = mapObjectInformationList [j];

			print (mapObjectInfo.name + " with ID: " + lastMapObjectInformationIDAssigned);

			mapObjectInfo.assignID (lastMapObjectInformationIDAssigned);

			lastMapObjectInformationIDAssigned++;
		}

		setlastMapObjectInformationIDAssignedValue (lastMapObjectInformationIDAssigned);

		print ("\n Object ID assigned to every map object information component in the level");

		updateComponent ();
	}




	//EXTRA EDITOR FUNCTIONS
	public List<mapIconType> getMapIconTypes ()
	{
		return mapIconTypes;
	}

	public void setMapIconTypes (int mapSystemIndex)
	{
		mapIconTypes.Clear ();

		for (int i = 0; i < mapSystemInfoList [mapSystemIndex].mainMapSystem.mapIconTypes.Count; i++) {
			mapIconTypes.Add (mapSystemInfoList [mapSystemIndex].mainMapSystem.mapIconTypes [i]);
		}

		updateComponent ();
	}

	public void updateMapIconTypesOnMapSystem ()
	{
		for (int i = 0; i < mapSystemInfoList.Count; i++) {

			mapSystemInfoList [i].mainMapSystem.updateMapIconTypes (mapIconTypes);
		}

		updateComponent ();
	}

	public void addCameraPositionOnMapMenu (int buildingIndex)
	{
		buildingInfo currentBuildingInfo = buildingList [buildingIndex];
		GameObject newCameraPositionOnMapMenu = new GameObject ();

		newCameraPositionOnMapMenu.name = currentBuildingInfo.Name + "-Camera Position On Map Menu";
		newCameraPositionOnMapMenu.transform.SetParent (currentBuildingInfo.buildingMapParent);
		newCameraPositionOnMapMenu.transform.localPosition = Vector3.zero;
		newCameraPositionOnMapMenu.transform.eulerAngles = new Vector3 (90, 0, 0);

		currentBuildingInfo.cameraPositionOnMapMenu = newCameraPositionOnMapMenu.transform;

		if (useRaycastToPlaceElements) {
			Camera currentCameraEditor = GKC_Utils.getCameraEditor ();

			if (currentCameraEditor != null) {
				Vector3 editorCameraPosition = currentCameraEditor.transform.position;
				Vector3 editorCameraForward = currentCameraEditor.transform.forward;

				RaycastHit hit;

				if (Physics.Raycast (editorCameraPosition, editorCameraForward, out hit, Mathf.Infinity, layerToPlaceElements)) {
					newCameraPositionOnMapMenu.transform.position = hit.point + Vector3.up * 0.1f;
				} else {
					newCameraPositionOnMapMenu.transform.position = new Vector3 (editorCameraPosition.x, newCameraPositionOnMapMenu.transform.position.y, editorCameraPosition.z);
				}
			}
		}

		updateComponent ();
	}

	public void addNewPlayer (mapSystem newMapSystem, GameObject newPlayer, bool callingFunctionOnEditor)
	{
		for (int i = 0; i < mapSystemInfoList.Count; i++) {	
			if (mapSystemInfoList [i].playerGameObject == null) {
				mapSystemInfoList.RemoveAt (i);

				i--;
			}
		}

		bool playerFound = false;
		int playerIndex = 0;

		for (int i = 0; i < mapSystemInfoList.Count; i++) {	
			if (mapSystemInfoList [i].playerGameObject == newPlayer) {
				playerFound = true;
				playerIndex = i;
			}
		}

		if (playerFound) {
			mapSystemInfoList [playerIndex].playerGameObject = newPlayer;
			mapSystemInfoList [playerIndex].mainMapSystem = newMapSystem;
		} else {
			mapSystemInfo newMapSystemInfo = new mapSystemInfo ();
			newMapSystemInfo.Name = "Player " + (mapSystemInfoList.Count + 1);
			newMapSystemInfo.playerGameObject = newPlayer;
			newMapSystemInfo.mainMapSystem = newMapSystem;

			mapSystemInfoList.Add (newMapSystemInfo);
		}

		if (callingFunctionOnEditor) {
			updateComponent ();
		}
	}

	public void selectChangeBuildingTrigger (int buildingIndex, int triggerIndex)
	{
		GKC_Utils.setActiveGameObjectInEditor (buildingList [buildingIndex].triggerToChangeBuildingList [triggerIndex]);
	}

	public void selectDynamicObjectsTrigger (int buildingIndex, int triggerIndex)
	{
		GKC_Utils.setActiveGameObjectInEditor (buildingList [buildingIndex].triggerForDynamicObjectsList [triggerIndex]);
	}

	public void selectCurrentFloorTrigger (int buildingIndex, int floorIndex, int triggerIndex)
	{
		GKC_Utils.setActiveGameObjectInEditor (buildingList [buildingIndex].buildingFloorsList [floorIndex].triggerToChangeFloorList [triggerIndex].gameObject);
	}

	public void selectCurrentMapPart (int buildingIndex, int floorIndex, int mapPartIndex)
	{
		GKC_Utils.setActiveGameObjectInEditor (buildingList [buildingIndex].buildingFloorsList [floorIndex].mapPartsList [mapPartIndex]);
	}

	public void updateMapObjectInformationMapSystem ()
	{
		mapObjectInformation[] mapObjectInformationList = FindObjectsOfType<mapObjectInformation> ();

		foreach (mapObjectInformation mapObjectInfo in mapObjectInformationList) {
			mapObjectInfo.getCurrentMapManager ();
		}

		print ("\n Map Object Information components in the level updated");
	}
	//END OF EDITOR FUNCTIONS


	public void updateComponent ()
	{
		GKC_Utils.updateComponent (this);

		GKC_Utils.updateDirtyScene ("Update Map Creator", gameObject);
	}

#if UNITY_EDITOR
    void OnDrawGizmos ()
	{
		if (!showGizmo) {
			return;
		}

		if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
			DrawGizmos ();
		}
	}

	void OnDrawGizmosSelected ()
	{
		DrawGizmos ();
	}

	void DrawGizmos ()
	{
		if (showGizmo && !Application.isPlaying) {
			int buildingListCount = buildingList.Count;

			for (int i = 0; i < buildingListCount; i++) {
				for (int j = 0; j < buildingList [i].buildingFloorsList.Count; j++) {
					if (buildingList [i].buildingFloorsList [j].floor != null) {
						Gizmos.color = Color.green;

						Gizmos.DrawWireSphere (buildingList [i].buildingFloorsList [j].floor.transform.position, 0.8f);

						if (j + 1 <= buildingList [i].buildingFloorsList.Count - 1) {
							if (buildingList [i].buildingFloorsList [j + 1].floor != null) {
								Gizmos.color = Color.white;

								Gizmos.DrawLine (buildingList [i].buildingFloorsList [j].floor.transform.position, buildingList [i].buildingFloorsList [j + 1].floor.transform.position);
							}
						}

						for (int k = 0; k < buildingList [i].buildingFloorsList [j].triggerToChangeFloorList.Count; k++) {
							if (showFloorTriggersLine) {
								Gizmos.color = floorTriggersLineColor;

								Gizmos.DrawLine (buildingList [i].buildingFloorsList [j].floor.transform.position, 
									buildingList [i].buildingFloorsList [j].triggerToChangeFloorList [k].transform.position);
							}

							if (showFloorTriggers) {
								Gizmos.color = floorTriggersColor;

								Gizmos.DrawSphere (buildingList [i].buildingFloorsList [j].triggerToChangeFloorList [k].transform.position, 0.8f);
							}

							if (showFloorTriggersCubes) {
								Gizmos.color = floorTriggersCubesColor;

								Gizmos.DrawCube (buildingList [i].buildingFloorsList [j].triggerToChangeFloorList [k].transform.position, 
									buildingList [i].buildingFloorsList [j].triggerToChangeFloorList [k].transform.localScale);
							}
						}
					}
				}

				for (int k = 0; k < buildingList [i].triggerToChangeBuildingList.Count; k++) {
					if (showBuildingTriggersLine) {
						Gizmos.color = buildingTriggersLineColor;

						Gizmos.DrawLine (buildingList [i].buildingMapParent.position, 
							buildingList [i].triggerToChangeBuildingList [k].transform.position);
					}

					if (showBuildingTriggers) {
						Gizmos.color = buildingTriggersColor;

						Gizmos.DrawSphere (buildingList [i].triggerToChangeBuildingList [k].transform.position, 0.8f);
					}

					if (showBuildingTriggersCubes) {
						Gizmos.color = buildingTriggersCubesColor;

						Gizmos.DrawCube (buildingList [i].triggerToChangeBuildingList [k].transform.position, 
							buildingList [i].triggerToChangeBuildingList [k].transform.localScale);
					}
				}
			}
		}
	}
#endif

	[System.Serializable]
	public class floorInfo
	{
		public string Name;
		public int floorNumber;
		public GameObject floor;
		public bool floorEnabled;
		public Transform currentFloorParent;
		public Transform mapPart3dMeshesParent;

		public List<GameObject> triggerToChangeFloorList = new List<GameObject> ();

		public List<GameObject> mapPartsList = new List<GameObject> ();

		public List<mapTileBuilder> mapTileBuilderList = new List<mapTileBuilder> ();
	}

	[System.Serializable]
	public class buildingInfo
	{
		public string Name;
		public Transform buildingMapParent;
		public Transform buildingFloorsParent;
		public List<floorInfo> buildingFloorsList = new List<floorInfo> ();

		public List<GameObject> triggerToChangeBuildingList = new List<GameObject> ();
		public Transform triggerToChangeBuildingParent;

		public bool useCameraPositionOnMapMenu;
		public Transform cameraPositionOnMapMenu;
		public bool useCameraOffset = true;

		public bool isCurrentMap;
		public bool isInterior;
		public bool buildingMapEnabled;

		public List<GameObject> triggerForDynamicObjectsList = new List<GameObject> ();
		public Transform triggerToChangeDynamicObjectsParent;
	}

	[System.Serializable]
	public class mapSystemInfo
	{
		public string Name;
		public GameObject playerGameObject;
		public mapSystem mainMapSystem;
	}
}