private void Awake()
    {
        triesLeft = transform.childCount;

        GameObject[] healthItems = new GameObject[triesLeft];

        for (int i = 0; i < triesLeft; ++i)
        {
            healthItems[i] = transform.GetChild(i).gameObject;
        }

        healthItemsOrdered = healthItems.OrderBy(item => item.transform.position.x).ToArray();
    }
	/* Take a gameobejct with children in parameters, and sort them by their name */
	public GameObject[] sortArrayFromName(GameObject childArrayToSort)
	{
		GameObject[] _arrayToSort = new GameObject[childArrayToSort.transform.childCount];
		GameObject o;

		for (int i = 0; i < childArrayToSort.transform.childCount; i++)
		{
			o = childArrayToSort.transform.GetChild(i).gameObject;
			_arrayToSort[i] = o;
		}

		_arrayToSort = _arrayToSort.OrderBy(go => go.name).ToArray();
		
		return _arrayToSort;
	}
    //Build Mid Sections
    void BuildPlatformMidSections(GameObject platformParent)
    {
        if (orientation == 1)
        {
            platformParent.transform.Rotate(0, 0, 90);
        }

        GameObject platformMidSections = new GameObject("Platform Mid Sections");

        platformMidSections.transform.SetParent(platformParent.transform);
        platformMidSections.transform.localPosition = new Vector3(0, 0, 0);

        // Create Ordered Array
        GameObject[] orderedObjects = new GameObject[0];
        int          objArrayPos    = 0;

        foreach (Transform child in platformParent.transform)
        {
            if (child.gameObject.tag == "Platform")
            {
                System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
                orderedObjects[objArrayPos] = child.gameObject;
                objArrayPos++;
            }
        }

        if (platformParent.transform.FindChild("Doors"))
        {
            foreach (Transform child in platformParent.transform.FindChild("Doors"))
            {
                if (child.gameObject.tag == "Door")
                {
                    System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
                    orderedObjects[objArrayPos] = child.gameObject;
                    objArrayPos++;
                }
            }
        }

        //Sort Array
        orderedObjects = orderedObjects.OrderBy(go => go.transform.position.x).ToArray();

        //Create platforms in between doors and ends
        for (int i = 0; i < orderedObjects.Length - 1; i++)
        {
            float objAPosX, objBPosX;

            if (orderedObjects[i].GetComponent <Collider2D>())
            {
                objAPosX = orderedObjects[i].GetComponent <Collider2D>().bounds.max.x;
            }

            else
            {
                objAPosX = orderedObjects[i].transform.position.x;
            }

            if (orderedObjects[i + 1].GetComponent <Collider2D>())
            {
                objBPosX = orderedObjects[i + 1].GetComponent <Collider2D>().bounds.min.x;
            }

            else
            {
                objBPosX = orderedObjects[i + 1].transform.position.x;
            }

            float distance = objBPosX - objAPosX;
            float midPoint = objAPosX + distance * 0.5f;

            //If there is space between doors or corners
            Object platformPrefab;

            if (distance > 0)
            {
                if (orientation == 0)
                {
                    platformPrefab = Resources.Load("PlatformH");
                }

                else
                {
                    platformPrefab = Resources.Load("PlatformV");
                }


                GameObject platform = (GameObject)PrefabUtility.InstantiatePrefab(platformPrefab);
                platform.name = "PlatformMid " + (i + 1);
                platform.transform.SetParent(platformMidSections.transform);
                platform.transform.position   = new Vector2(midPoint, orderedObjects[i].transform.position.y);
                platform.transform.localScale = new Vector3(distance, 1, 1);
            }
        }

        if (orientation == 1)
        {
            platformParent.transform.Rotate(0, 0, -90);
        }
    }
    void BuildPlatform(bool buildMidSections)
    {
        //Set Art
        switch (selectedPlatformArt)
        {
        case 0:
            platformEndSprite = Resources.Load <Sprite>("Blue Metal Platform_H_End");
            break;

        default:
            break;
        }

        //Create Parent Object
        GameObject platformParent = new GameObject();

        platformParent.name = "Platform";

        //Build Platform Ends
        GameObject endLeft = null, endRight = null, endTop = null, endBottom = null;

        //For horizontal platforms.
        if (orientation == 0)
        {
            Object platformHPrefab = Resources.Load("PlatformH");

            if (platformEndLeft)
            {
                endLeft      = (GameObject)PrefabUtility.InstantiatePrefab(platformHPrefab);
                endLeft.name = "Platform End Left";
                endLeft.transform.SetParent(platformParent.transform);
                endLeft.transform.localPosition = new Vector2((-platformWidth / 2) + 0.5f, 0);
                endLeft.transform.FindChild("Platform").GetComponent <SpriteRenderer>().sprite     = platformEndSprite;
                endLeft.transform.FindChild("Platform Lit").GetComponent <SpriteRenderer>().sprite = platformEndSprite;
                endLeft.transform.FindChild("Platform Lit").GetComponent <SpriteRenderer>().sprite = platformEndSprite;
            }

            else
            {
                endLeft      = new GameObject();
                endLeft.name = "Platform End Left";
                endLeft.tag  = "Platform";
                endLeft.transform.SetParent(platformParent.transform);
                endLeft.transform.localPosition = new Vector2((-platformWidth / 2), 0);
            }

            if (platformEndRight)
            {
                endRight      = (GameObject)PrefabUtility.InstantiatePrefab(platformHPrefab);
                endRight.name = "Platform End Right";
                endRight.transform.SetParent(platformParent.transform);
                endRight.transform.localPosition = new Vector2((platformWidth / 2) - 0.5f, 0);
                endRight.transform.localScale    = new Vector3(-1, 1, 1);
                endRight.transform.FindChild("Platform").GetComponent <SpriteRenderer>().sprite     = platformEndSprite;
                endRight.transform.FindChild("Platform Lit").GetComponent <SpriteRenderer>().sprite = platformEndSprite;
            }

            else
            {
                endRight      = new GameObject();
                endRight.name = "Platform End Right";
                endRight.tag  = "Platform";
                endRight.transform.SetParent(platformParent.transform);
                endRight.transform.localPosition = new Vector2((platformWidth / 2), 0);
            }
        }

        // For vertical platforms.
        else
        {
            endTop      = new GameObject();
            endTop.name = "Platform End Top";
            endTop.tag  = "Platform";
            endTop.transform.SetParent(platformParent.transform);
            endTop.transform.localPosition = new Vector2((-platformWidth / 2), 0);

            endBottom      = new GameObject();
            endBottom.name = "Platform End Bottom";
            endBottom.tag  = "Platform";
            endBottom.transform.SetParent(platformParent.transform);
            endBottom.transform.localPosition = new Vector2((platformWidth / 2), 0);
        }

        //Build Doors
        if (doorCount > 0)
        {
            // For horizontal doors.
            if (orientation == 0)
            {
                Object interiorDoorHPrefab = Resources.Load("InteriorDoorH");

                //Create Parent Object
                GameObject doorsParent = new GameObject("Doors");
                doorsParent.transform.SetParent(platformParent.transform);

                for (int i = 0; i < doorCount; i++)
                {
                    GameObject d = (GameObject)PrefabUtility.InstantiatePrefab(interiorDoorHPrefab);
                    d.name = "InteriorDoorH" + (i + 1);
                    d.transform.SetParent(doorsParent.transform);
                    d.transform.localPosition = new Vector3(0, 0, -1);
                }
            }

            // For vertical doors.
            else
            {
                Object interiorDoorVPrefab = Resources.Load("InteriorDoorV");

                //Create Parent Object
                GameObject doorsParent = new GameObject("Doors");
                doorsParent.transform.SetParent(platformParent.transform);

                for (int i = 0; i < doorCount; i++)
                {
                    GameObject d = (GameObject)PrefabUtility.InstantiatePrefab(interiorDoorVPrefab);
                    d.name = "InteriorDoorV" + (i + 1);
                    d.transform.SetParent(doorsParent.transform);
                    d.transform.localPosition = new Vector3(0, 0, -1);
                    d.transform.Rotate(0, 0, 90);
                }
            }
        }

        List <GameObject> doors = new List <GameObject>();

        if (platformParent.transform.FindChild("Doors"))
        {
            foreach (Transform child in platformParent.transform.FindChild("Doors"))
            {
                doors.Add(child.gameObject);
            }
        }

        // Order doors and platform ends
        GameObject[] orderedObjects = new GameObject[0];
        int          objArrayPos    = 0;

        //Add Platform Ends to ordered array

        if (orientation == 0)
        {
            System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
            orderedObjects[objArrayPos] = endLeft;
            objArrayPos++;

            System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
            orderedObjects[objArrayPos] = endRight;
            objArrayPos++;
        }

        else
        {
            System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
            orderedObjects[objArrayPos] = endTop;
            objArrayPos++;

            System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
            orderedObjects[objArrayPos] = endBottom;
            objArrayPos++;
        }

        //Add doors to ordered array
        if (doors.Count > 0)
        {
            foreach (GameObject door in doors)
            {
                System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
                orderedObjects[objArrayPos] = door;
                objArrayPos++;
            }
        }

        //Order array from left to right
        orderedObjects = orderedObjects.OrderBy(go => go.transform.position.x).ToArray();

        //Get leftmost and rightmost objects
        GameObject objectLeft  = orderedObjects[0];
        GameObject objectRight = orderedObjects[orderedObjects.Length - 1];

        float start, end;

        if (objectLeft.GetComponent <Collider2D>())
        {
            start = objectLeft.GetComponent <Collider2D>().bounds.max.x;
        }

        else
        {
            start = objectLeft.transform.position.x;
        }

        if (objectRight.GetComponent <Collider2D>())
        {
            end = objectRight.GetComponent <Collider2D>().bounds.min.x;
        }

        else
        {
            end = objectRight.transform.position.x;
        }

        float difference = end - start;

        //Remove End objects from array
        List <GameObject> o = orderedObjects.ToList();

        o.RemoveAt(0);
        o.RemoveAt(o.Count - 1);

        orderedObjects = o.ToArray();

        ////Position Doors and Ends
        foreach (GameObject orderedObject in orderedObjects)
        {
            float objectSizeX       = orderedObject.GetComponent <Collider2D>().bounds.size.x;
            float objectExtentsX    = orderedObject.GetComponent <Collider2D>().bounds.extents.x;
            float totalObjectLength = objectSizeX * orderedObjects.Length;
            float leftOverSpace     = difference - totalObjectLength;

            if (orientation == 0)
            {
                orderedObject.transform.position = new Vector3(start + objectExtentsX + (leftOverSpace / (orderedObjects.Length + 1)), orderedObject.transform.position.y, orderedObject.transform.position.z);
                start = orderedObject.GetComponent <Collider2D>().bounds.max.x;
            }

            else
            {
                orderedObject.transform.position = new Vector3(start + objectExtentsX + 0.15f + (leftOverSpace / (orderedObjects.Length + 1)), orderedObject.transform.position.y, orderedObject.transform.position.z);
                start = orderedObject.GetComponent <Collider2D>().bounds.max.x;
            }
        }

        if (orientation == 1)
        {
            platformParent.transform.Rotate(0, 0, -90);
        }

        if (buildMidSections)
        {
            BuildPlatformMidSections(platformParent);
        }

        //Parent to room
        if (selectedRoom)
        {
            platformParent.transform.SetParent(selectedRoom.transform);
            platformParent.transform.localPosition = new Vector3(0, 0, 0);
        }


        Selection.activeGameObject = platformParent;
    }
    private void Start()
    {
        /*ルートが設定されているなら、自動で設定する*/
        if (m_routeObjectParent != null)
        {
            GameObject[] routeObjectChirdren = new GameObject[m_routeObjectParent.transform.childCount];
            for (int i = 0; i < m_routeObjectParent.transform.childCount; i++)
            {
                routeObjectChirdren[i] = m_routeObjectParent.transform.GetChild(i).gameObject;
            }

            if (m_isOrderBy)
            {
                m_routeObjects = routeObjectChirdren.OrderBy(route => route.gameObject.name).ToArray();
            }
            else
            {
                m_routeObjects = routeObjectChirdren.OrderByDescending(route => route.gameObject.name).ToArray();
            }

            this.transform.position = m_routeObjects[0].transform.position;
        }

        if (m_lookAtPosParent)
        {
            m_yearDistance      = 0.1f;
            m_lookAtPosChirdlen = new GameObject[m_lookAtPosParent.transform.childCount];
            for (int i = 0; i < m_lookAtPosParent.transform.childCount; i++)
            {
                m_lookAtPosChirdlen[i] = m_lookAtPosParent.transform.GetChild(i).gameObject;
            }
            m_lookAtPosChirdlen.ToList().ForEach(pos => Debug.Log(pos.gameObject.name));
            RotateEnemy();
        }

        m_audioManager = GameObject.Find("AudioManager").GetComponent <AudioManager>();

        m_audio   = GetComponentInChildren <EnemyAudioManager>();
        m_elc     = GetComponentInChildren <EnemyLightController>();
        m_rb      = GetComponent <Rigidbody>();
        m_agent   = GetComponent <NavMeshAgent>();
        m_eStatus = EnemyStatus.Patrol;
        m_player  = GameObject.FindGameObjectWithTag("Player");
        if (!m_player)
        {
            Debug.LogError("プレイヤーが取得できていない");
        }
        else
        {
            Debug.Log($"プレイヤーを取得。{m_player.name}");
        }
        m_gm = FindObjectOfType <GameManager>();

        m_adc = FindObjectsOfType <AutomationDoorController>();
        if (m_adc != null)
        {
            Debug.Log($"{this.gameObject.name}::AutomationDoorControllerを取得::{m_adc.Length + 1}個");
        }
        else
        {
            Debug.LogError("AutomationDoorControllerを取得できていない");
        }

        m_ef  = GetComponentInChildren <EnemyEffects>();
        m_eef = GetComponentInChildren <EnemyEyeField>();
        BuildSequence();

        GoToNextPoint();
    }
    void CreateWalls(GameObject r)
	{
        Bounds roomBounds = r.GetComponent<Collider2D>().bounds;

        List<GameObject> doors = new List<GameObject>();

        if (r.transform.FindChild("Doors"))
        {
            foreach (Transform child in r.transform.FindChild("Doors"))
                doors.Add(child.gameObject);
        }

        GameObject wallsParent = new GameObject("Walls");
        wallsParent.transform.SetParent(r.transform);
        wallsParent.transform.localScale =  new Vector3(1 , 1 , 1);

        Object wallPrefab = Resources.Load ("Wall");
        Sprite wallSprite = Resources.Load<Sprite>("Blue Metal Wall");
		Sprite wallEndSprite = Resources.Load<Sprite>("Blue Metal Wall Corner");
		Sprite consoleCornerSprite = Resources.Load<Sprite>("CV Corner");

        //CREATE CORNERS
        //Corners are used for the placement and sizing of walls. 
        //Corners on walls that are not selected are deleted after walls are created 

        topLeftCorner = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
        topLeftCorner.GetComponent<SpriteRenderer>().sprite = wallEndSprite;
		topLeftCorner.transform.GetChild(0).GetComponent<SpriteRenderer>().sprite = consoleCornerSprite;
        topLeftCorner.name = "Wall Top-Left Corner";
        topLeftCorner.transform.SetParent(wallsParent.transform);
        topLeftCorner.transform.position = new Vector2(r.transform.position.x -roomBounds.extents.x - 0.5f, r.transform.position.y + roomBounds.extents.y + 0.5f);
        topLeftCorner.transform.localScale = new Vector3(1 / r.transform.localScale.x, 1 / r.transform.localScale.y, 1);
       
        topRightCorner = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
        topRightCorner.GetComponent<SpriteRenderer>().sprite = wallEndSprite;
		topRightCorner.transform.GetChild(0).GetComponent<SpriteRenderer>().sprite = consoleCornerSprite;
        topRightCorner.name = "Wall Top-Right Corner";
        topRightCorner.transform.SetParent(wallsParent.transform);
        topRightCorner.transform.position = new Vector2(r.transform.position.x + roomBounds.extents.x + 0.5f, r.transform.position.y + roomBounds.extents.y + 0.5f);
        topRightCorner.transform.localScale = new Vector3(-1 / r.transform.localScale.x, 1 / r.transform.localScale.y, 1);
       
        bottomLeftCorner = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
        bottomLeftCorner.GetComponent<SpriteRenderer>().sprite = wallEndSprite;
		bottomLeftCorner.transform.GetChild(0).GetComponent<SpriteRenderer>().sprite = consoleCornerSprite;
        bottomLeftCorner.name = "Wall Bottom-Left Corner";
        bottomLeftCorner.transform.SetParent(wallsParent.transform);
        bottomLeftCorner.transform.position = new Vector2(r.transform.position.x - roomBounds.extents.x - 0.5f, r.transform.position.y - roomBounds.extents.y - 0.5f);
        bottomLeftCorner.transform.localScale = new Vector3(1 / r.transform.localScale.x, -1 / r.transform.localScale.y, 1);
        
        bottomRightCorner = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
        bottomRightCorner.GetComponent<SpriteRenderer>().sprite = wallEndSprite;
		bottomRightCorner.transform.GetChild(0).GetComponent<SpriteRenderer>().sprite = consoleCornerSprite;
		bottomRightCorner.name = "Wall Bottom-Right Corner";
        bottomRightCorner.transform.SetParent(wallsParent.transform);
        bottomRightCorner.transform.position = new Vector2(r.transform.position.x + roomBounds.extents.x + 0.5f, r.transform.position.y - roomBounds.extents.y - 0.5f);
        bottomRightCorner.transform.localScale = new Vector3(-1 / r.transform.localScale.x, -1 / r.transform.localScale.y, 1);       

        //CREATE WALLS

        //Top Wall
        //Build wall if there is no aligned room selected or if room alignment is not bottom
        if (!roomToAlignTo ||  (roomToAlignTo && toolbarAlignToRoom !=1))
        {
            //Get walls on top and order by position
            GameObject[] orderedGameObjects = new GameObject[1];
            orderedGameObjects[0] = topLeftCorner;
            int objArrayPos = 1;

            if (doors.Count > 0)
            {
                //if door is on top wall add to array
                foreach (GameObject door in doors)
                {
                    if (door.transform.position.y > roomBounds.max.y)
                    {
                        System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
                        orderedGameObjects[objArrayPos] = door;
                        objArrayPos++;
                    }
                }
            }

            System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
            orderedGameObjects[objArrayPos] = topRightCorner;

            // Ordered from left to right
            orderedGameObjects = orderedGameObjects.OrderBy(go => go.transform.position.x).ToArray();

            if (debugWalls)
            {
                Debug.Log("Objects ordered from bottom to top");
                foreach (GameObject orderedObject in orderedGameObjects)
                    Debug.Log(orderedObject);
            }

            // Create walls in between doors and corners
            for (int i = 0; i < orderedGameObjects.Length - 1; i++)
            {
                float objAPosX = orderedGameObjects[i].GetComponent<Collider2D>().bounds.max.x;
                float objBPosX = orderedGameObjects[i + 1].GetComponent<Collider2D>().bounds.min.x;

                float difference = objBPosX - objAPosX;
                float midPoint = objAPosX + difference * 0.5f;

                if (debugWalls)
                {
                    Debug.Log("Distance between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + difference);
                    Debug.Log("Midpoint between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + midPoint);
                }

                // If there is space between doors or corners
                if (difference > 0)
                {
                    GameObject wall = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
                    wall.GetComponent<SpriteRenderer>().sprite = wallSprite;
                    wall.name = "Top Wall " + (i+1);
                    wall.transform.SetParent(wallsParent.transform);
                    wall.transform.position = new Vector2(midPoint, r.transform.position.y + roomBounds.extents.y + 0.5f);
                    wall.transform.localScale = new Vector3(difference / r.transform.localScale.x, 1 / r.transform.localScale.y, 1);
                }
            }
        }

        // Bottom Wall
        if (!roomToAlignTo || (roomToAlignTo && toolbarAlignToRoom != 0))
        {
            GameObject[] orderedGameObjects = new GameObject[1];
            orderedGameObjects[0] = bottomRightCorner;
            int objArrayPos = 1;

            foreach (GameObject door in doors)
            {
                if (door.transform.position.y < roomBounds.min.y)
                {
                    System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
                    orderedGameObjects[objArrayPos] = door;
                    objArrayPos++;
                }
            }

            System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
            orderedGameObjects[objArrayPos] = bottomLeftCorner;

            orderedGameObjects = orderedGameObjects.OrderBy(go => go.transform.position.x).ToArray();

            if (debugWalls)
            {
                Debug.Log("Objects ordered from bottom to top");
                foreach (GameObject orderedObject in orderedGameObjects)
                    Debug.Log(orderedObject);
            }

            // Create walls in between doors and corners
            for (int i = 0; i < orderedGameObjects.Length - 1; i++)
            {
                float objAPosX = orderedGameObjects[i].GetComponent<Collider2D>().bounds.max.x;
                float objBPosX = orderedGameObjects[i + 1].GetComponent<Collider2D>().bounds.min.x;

                float difference = objBPosX - objAPosX;
                float midPoint = objAPosX + difference * 0.5f;

                if (debugWalls)
                {
                    Debug.Log("Distance between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + difference);
                    Debug.Log("Midpoint between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + midPoint);
                }

                // If there is space between doors or corners
                if (difference > 0)
                {
                    GameObject wall = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
                    wall.GetComponent<SpriteRenderer>().sprite = wallSprite;
                    wall.name = "Bottom Wall " + (i + 1);
                    wall.transform.SetParent(wallsParent.transform);
                    wall.transform.position = new Vector2(midPoint, r.transform.position.y - roomBounds.extents.y - 0.5f);
                    wall.transform.localScale = new Vector3(difference / r.transform.localScale.x, -1 / r.transform.localScale.y, 1);
                }
            }
        }

        // Left Wall
        if (!roomToAlignTo || (roomToAlignTo && toolbarAlignToRoom != 3))
        {
            GameObject[] orderedGameObjects = new GameObject[1];
            orderedGameObjects[0] = topLeftCorner;

            int objArrayPos = 1;

            foreach (GameObject door in doors)
            {
                if (door.transform.position.x < roomBounds.min.x)
                {
                    System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
                    orderedGameObjects[objArrayPos] = door;
                    objArrayPos++;
                }
            }

            System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
            orderedGameObjects[objArrayPos] = bottomLeftCorner;
            
            // Ordered from bottom to top
            orderedGameObjects = orderedGameObjects.OrderBy(go => go.transform.position.y).ToArray();
            
            if (debugWalls)
            {
                Debug.Log("Objects ordered from bottom to top");
                foreach (GameObject orderedObject in orderedGameObjects)
                    Debug.Log(orderedObject);
            }

            // Create walls in between doors and corners
            for (int i = 0; i < orderedGameObjects.Length - 1; i++)
            {
                float objAPosY = orderedGameObjects[i].GetComponent<Collider2D>().bounds.max.y;
                float objBPosY = orderedGameObjects[i + 1].GetComponent<Collider2D>().bounds.min.y;

                float difference = objBPosY - objAPosY;
                float midPoint = objAPosY + difference * 0.5f;
                
                if (debugWalls)
                {
                    Debug.Log("Distance between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + difference);
                    Debug.Log("Midpoint between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + midPoint);
                }

                // If there is space between doors or corners
                if (difference > 0)
                {
                    GameObject wall = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
                    wall.GetComponent<SpriteRenderer>().sprite = wallSprite;
                    wall.name = "Left Wall " + (i + 1);
                    wall.transform.SetParent(wallsParent.transform);
                    wall.transform.Rotate(0, 0, -90);
                    wall.transform.position = new Vector2(r.transform.position.x - roomBounds.extents.x - 0.5f, midPoint);
                    wall.transform.localScale = new Vector3(difference / r.transform.localScale.x, 1 / r.transform.localScale.y, 1);
                }
            }
        }

        // Right Wall
        if (!roomToAlignTo || (roomToAlignTo && toolbarAlignToRoom != 2))
        {
            GameObject[] orderedGameObjects = new GameObject[1];
            orderedGameObjects[0] = topRightCorner;
            int objArrayPos = 1;

            foreach (GameObject door in doors)
            {
                if (door.transform.position.x > roomBounds.max.x)
                {
                    System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
                    orderedGameObjects[objArrayPos] = door;
                    objArrayPos++;
                }
            }

            System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
            orderedGameObjects[objArrayPos] = bottomRightCorner;

            // Ordered from top to bottom
            orderedGameObjects = orderedGameObjects.OrderBy(go => go.transform.position.y).ToArray();

            if (debugWalls)
            {
                Debug.Log("Objects ordered from bottom to top");
                foreach (GameObject orderedObject in orderedGameObjects)
                    Debug.Log(orderedObject);
            }

            // Create walls in between doors and corners
            for (int i = 0; i < orderedGameObjects.Length - 1; i++)
            {
                float objAPosY = orderedGameObjects[i].GetComponent<Collider2D>().bounds.max.y;
                float objBPosY = orderedGameObjects[i + 1].GetComponent<Collider2D>().bounds.min.y;

                float difference = objBPosY - objAPosY;
                float midPoint = objAPosY + difference * 0.5f;

                if (debugWalls)
                {
                    Debug.Log("Distance between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + difference);
                    Debug.Log("Midpoint between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + midPoint);
                }

                // If there is space between doors or corners
                if (difference > 0)
                {
                    GameObject wall = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
                    wall.GetComponent<SpriteRenderer>().sprite = wallSprite;
                    wall.name = "Right Wall " + (i + 1);
                    wall.transform.SetParent(wallsParent.transform);
                    wall.transform.Rotate(0, 0, 90);
                    wall.transform.localScale = new Vector3(difference / r.transform.localScale.x, 1 / r.transform.localScale.y, 1);
                    wall.transform.position = new Vector2(r.transform.position.x + roomBounds.extents.x + 0.5f, midPoint);
                }
            }
        }

        // Delete corners on walls that are not selected
        // Top Wall
        if (roomToAlignTo && toolbarAlignToRoom == 1)
        {
            GameObject.DestroyImmediate(topLeftCorner);
            GameObject.DestroyImmediate(topRightCorner);
        }

        // Bottom Wall
        if (roomToAlignTo && toolbarAlignToRoom == 0)
        {
            GameObject.DestroyImmediate(bottomLeftCorner);
            GameObject.DestroyImmediate(bottomRightCorner);
        }

        // Left Wall
        if (roomToAlignTo && toolbarAlignToRoom == 3)
        {
            GameObject.DestroyImmediate(topLeftCorner);
            GameObject.DestroyImmediate(bottomLeftCorner);
        }

        //Right Wall
        if (roomToAlignTo && toolbarAlignToRoom == 2)
        {
            GameObject.DestroyImmediate(topRightCorner);
            GameObject.DestroyImmediate(bottomRightCorner);
        }
    }
Exemple #7
0
        private IEnumerator SpawnHorizontalLightning()
        {
            GameObject[] lightOrd = new GameObject[2];
            int          rnd      = UnityEngine.Random.Range(0, 2);

            for (float y = 5.5f, i = 0; y < 10f; y += 3f, i++)
            {
                int index = (int)i;
                if (i == rnd)
                {
                    continue;
                }
                lightOrd[index] = Instantiate(Fennel.preloadedGO["lightHoriz"]);
                lightOrd[index].transform.SetPosition2D(88f, y);
            }
            _aud.PlayOneShot(ArenaFinder.audioClips["sndThunder1"]);
            GameObject[] lightnings = lightOrd.OrderBy(x => new System.Random().Next()).ToArray();
            foreach (GameObject parentL in lightnings)
            {
                if (parentL == null)
                {
                    continue;
                }
                foreach (SpriteRenderer childLSpr in parentL.GetComponentsInChildren <SpriteRenderer>(true).Where(x => x.name.Contains("light1")))
                {
                    childLSpr.enabled = true;
                }
                yield return(new WaitForSeconds(0.003f));
            }
            yield return(new WaitForSeconds(0.35f));

            foreach (GameObject parentL in lightnings)
            {
                if (parentL == null)
                {
                    continue;
                }
                foreach (SpriteRenderer childLSpr in parentL.GetComponentsInChildren <SpriteRenderer>(true).Where(x => x.name.Contains("light1")))
                {
                    childLSpr.enabled = false;
                }
                yield return(new WaitForSeconds(0.003f));
            }
            yield return(new WaitForSeconds(0.1f));

            _aud.PlayOneShot(ArenaFinder.audioClips["sndThunder2"]);
            GameCameras.instance.cameraShakeFSM.SendEvent("AverageShake");
            foreach (GameObject parentL in lightnings)
            {
                if (parentL == null)
                {
                    continue;
                }
                foreach (DamageHero childLDH in parentL.GetComponentsInChildren <DamageHero>(true))
                {
                    GameObject light2 = childLDH.gameObject;
                    light2.GetComponent <SpriteRenderer>().enabled = true;
                    light2.GetComponent <BoxCollider2D>().enabled  = true;
                }
                yield return(new WaitForSeconds(0.003f));
            }
            yield return(new WaitForSeconds(0.1f));

            foreach (GameObject parentL in lightnings)
            {
                if (parentL == null)
                {
                    continue;
                }
                Destroy(parentL);
                yield return(new WaitForSeconds(0.003f));
            }
        }
Exemple #8
0
        public IEnumerator SlamGround() //Make second wave spawn in phase 2 that is in alternate pos
        {
            fight.doNextAttack = false;
            float dir = FaceHero();

            float xStart  = gameObject.transform.position.x;
            float distBtw = 3.8f;

            GameObject[] lightningsOrdered = new GameObject[17];
            GameObject[] lightningsOrdOff  = new GameObject[17];
            int          maxL  = lightningsOrdered.Length;
            int          halfL = maxL / 2;

            for (float x = xStart, i = 0; i < halfL; i++, x += distBtw)
            {
                int index = (int)i;
                lightningsOrdered[index] = Instantiate(Fennel.preloadedGO["lightning"]);
                lightningsOrdered[index].transform.SetPosition2D(x, 13f);
                lightningsOrdOff[index] = Instantiate(Fennel.preloadedGO["lightning"]);
                lightningsOrdOff[index].transform.SetPosition2D(x + distBtw / 2f, 13f);
            }
            for (float x = xStart, i = halfL; i < maxL; i++, x -= distBtw)
            {
                int index = (int)i;
                lightningsOrdered[index] = Instantiate(Fennel.preloadedGO["lightning"]);
                lightningsOrdered[index].transform.SetPosition2D(x, 13f);
                lightningsOrdOff[index] = Instantiate(Fennel.preloadedGO["lightning"]);
                lightningsOrdOff[index].transform.SetPosition2D(x - distBtw / 2f, 13f);
            }

            _anim.PlayAt("slam", 0);
            SpawnOrb(gameObject.transform.position);
            yield return(new WaitForSeconds(0.01f));

            yield return(new WaitWhile(() => _anim.GetCurrentFrame() < 4));

            _aud.PlayOneShot(ArenaFinder.audioClips["sndThunder1"]);
            GameObject[] lightnings = lightningsOrdered.OrderBy(x => new System.Random().Next()).ToArray();
            foreach (GameObject parentL in lightnings)
            {
                GameObject light1 = parentL.transform.Find("light1").gameObject;
                light1.GetComponent <SpriteRenderer>().enabled = true;
                yield return(new WaitForSeconds(0.003f));
            }
            yield return(new WaitWhile(() => _anim.GetCurrentFrame() < 9));

            foreach (GameObject parentL in lightnings)
            {
                GameObject light1 = parentL.transform.Find("light1").gameObject;
                light1.GetComponent <SpriteRenderer>().enabled = false;
                yield return(new WaitForSeconds(0.003f));
            }
            yield return(new WaitWhile(() => _anim.GetCurrentFrame() < 13));

            _aud.PlayOneShot(ArenaFinder.audioClips["sndThunder2"]);
            GameCameras.instance.cameraShakeFSM.SendEvent("AverageShake");
            foreach (GameObject parentL in lightnings)
            {
                GameObject light2 = parentL.transform.Find("light2").gameObject;
                light2.GetComponent <SpriteRenderer>().enabled = true;
                light2.GetComponent <BoxCollider2D>().enabled  = true;
                StartCoroutine(SpawnRumbleParticle(new Vector2(parentL.transform.GetPositionX(), 4f)));
                yield return(new WaitForSeconds(0.003f));
            }
            yield return(new WaitWhile(() => _anim.GetCurrentFrame() < 15));

            foreach (GameObject parentL in lightnings)
            {
                Destroy(parentL);
                yield return(new WaitForSeconds(0.003f));
            }
            if (_hm.hp <= FennelFight.HP_PHASE2)
            {
                int rnd = UnityEngine.Random.Range(0, 2);
                if (rnd == 0)
                {
                    StartCoroutine(SpawnHorizontalLightning());
                }
                else
                {
                    StartCoroutine(SlamGroundV2(lightningsOrdOff));
                }
            }
            yield return(new WaitWhile(() => _anim.IsPlaying()));

            _anim.Play("idle");
            yield return(new WaitForSeconds(IDLE_TIME));

            if (_hm.hp <= FennelFight.HP_PHASE2)
            {
                yield return(new WaitForSeconds(0.6f));
            }
            fight.doNextAttack = true;
        }
    void CreateWalls(GameObject r)
    {
        Bounds roomBounds = r.GetComponent <Collider2D>().bounds;

        List <GameObject> doors = new List <GameObject>();

        if (r.transform.FindChild("Doors"))
        {
            foreach (Transform child in r.transform.FindChild("Doors"))
            {
                doors.Add(child.gameObject);
            }
        }

        GameObject wallsParent = new GameObject("Walls");

        wallsParent.transform.SetParent(r.transform);
        wallsParent.transform.localScale = new Vector3(1, 1, 1);

        Object wallPrefab          = Resources.Load("Wall");
        Sprite wallSprite          = Resources.Load <Sprite>("Blue Metal Wall");
        Sprite wallEndSprite       = Resources.Load <Sprite>("Blue Metal Wall Corner");
        Sprite consoleCornerSprite = Resources.Load <Sprite>("CV Corner");

        //CREATE CORNERS
        //Corners are used for the placement and sizing of walls.
        //Corners on walls that are not selected are deleted after walls are created

        topLeftCorner = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
        topLeftCorner.GetComponent <SpriteRenderer>().sprite = wallEndSprite;
        topLeftCorner.transform.GetChild(0).GetComponent <SpriteRenderer>().sprite = consoleCornerSprite;
        topLeftCorner.name = "Wall Top-Left Corner";
        topLeftCorner.transform.SetParent(wallsParent.transform);
        topLeftCorner.transform.position   = new Vector2(r.transform.position.x - roomBounds.extents.x - 0.5f, r.transform.position.y + roomBounds.extents.y + 0.5f);
        topLeftCorner.transform.localScale = new Vector3(1 / r.transform.localScale.x, 1 / r.transform.localScale.y, 1);

        topRightCorner = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
        topRightCorner.GetComponent <SpriteRenderer>().sprite = wallEndSprite;
        topRightCorner.transform.GetChild(0).GetComponent <SpriteRenderer>().sprite = consoleCornerSprite;
        topRightCorner.name = "Wall Top-Right Corner";
        topRightCorner.transform.SetParent(wallsParent.transform);
        topRightCorner.transform.position   = new Vector2(r.transform.position.x + roomBounds.extents.x + 0.5f, r.transform.position.y + roomBounds.extents.y + 0.5f);
        topRightCorner.transform.localScale = new Vector3(-1 / r.transform.localScale.x, 1 / r.transform.localScale.y, 1);

        bottomLeftCorner = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
        bottomLeftCorner.GetComponent <SpriteRenderer>().sprite = wallEndSprite;
        bottomLeftCorner.transform.GetChild(0).GetComponent <SpriteRenderer>().sprite = consoleCornerSprite;
        bottomLeftCorner.name = "Wall Bottom-Left Corner";
        bottomLeftCorner.transform.SetParent(wallsParent.transform);
        bottomLeftCorner.transform.position   = new Vector2(r.transform.position.x - roomBounds.extents.x - 0.5f, r.transform.position.y - roomBounds.extents.y - 0.5f);
        bottomLeftCorner.transform.localScale = new Vector3(1 / r.transform.localScale.x, -1 / r.transform.localScale.y, 1);

        bottomRightCorner = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
        bottomRightCorner.GetComponent <SpriteRenderer>().sprite = wallEndSprite;
        bottomRightCorner.transform.GetChild(0).GetComponent <SpriteRenderer>().sprite = consoleCornerSprite;
        bottomRightCorner.name = "Wall Bottom-Right Corner";
        bottomRightCorner.transform.SetParent(wallsParent.transform);
        bottomRightCorner.transform.position   = new Vector2(r.transform.position.x + roomBounds.extents.x + 0.5f, r.transform.position.y - roomBounds.extents.y - 0.5f);
        bottomRightCorner.transform.localScale = new Vector3(-1 / r.transform.localScale.x, -1 / r.transform.localScale.y, 1);

        //CREATE WALLS

        //Top Wall
        //Build wall if there is no aligned room selected or if room alignment is not bottom
        if (!roomToAlignTo || (roomToAlignTo && toolbarAlignToRoom != 1))
        {
            //Get walls on top and order by position
            GameObject[] orderedGameObjects = new GameObject[1];
            orderedGameObjects[0] = topLeftCorner;
            int objArrayPos = 1;

            if (doors.Count > 0)
            {
                //if door is on top wall add to array
                foreach (GameObject door in doors)
                {
                    if (door.transform.position.y > roomBounds.max.y)
                    {
                        System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
                        orderedGameObjects[objArrayPos] = door;
                        objArrayPos++;
                    }
                }
            }

            System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
            orderedGameObjects[objArrayPos] = topRightCorner;

            // Ordered from left to right
            orderedGameObjects = orderedGameObjects.OrderBy(go => go.transform.position.x).ToArray();

            if (debugWalls)
            {
                Debug.Log("Objects ordered from bottom to top");
                foreach (GameObject orderedObject in orderedGameObjects)
                {
                    Debug.Log(orderedObject);
                }
            }

            // Create walls in between doors and corners
            for (int i = 0; i < orderedGameObjects.Length - 1; i++)
            {
                float objAPosX = orderedGameObjects[i].GetComponent <Collider2D>().bounds.max.x;
                float objBPosX = orderedGameObjects[i + 1].GetComponent <Collider2D>().bounds.min.x;

                float difference = objBPosX - objAPosX;
                float midPoint   = objAPosX + difference * 0.5f;

                if (debugWalls)
                {
                    Debug.Log("Distance between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + difference);
                    Debug.Log("Midpoint between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + midPoint);
                }

                // If there is space between doors or corners
                if (difference > 0)
                {
                    GameObject wall = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
                    wall.GetComponent <SpriteRenderer>().sprite = wallSprite;
                    wall.name = "Top Wall " + (i + 1);
                    wall.transform.SetParent(wallsParent.transform);
                    wall.transform.position   = new Vector2(midPoint, r.transform.position.y + roomBounds.extents.y + 0.5f);
                    wall.transform.localScale = new Vector3(difference / r.transform.localScale.x, 1 / r.transform.localScale.y, 1);
                }
            }
        }

        // Bottom Wall
        if (!roomToAlignTo || (roomToAlignTo && toolbarAlignToRoom != 0))
        {
            GameObject[] orderedGameObjects = new GameObject[1];
            orderedGameObjects[0] = bottomRightCorner;
            int objArrayPos = 1;

            foreach (GameObject door in doors)
            {
                if (door.transform.position.y < roomBounds.min.y)
                {
                    System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
                    orderedGameObjects[objArrayPos] = door;
                    objArrayPos++;
                }
            }

            System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
            orderedGameObjects[objArrayPos] = bottomLeftCorner;

            orderedGameObjects = orderedGameObjects.OrderBy(go => go.transform.position.x).ToArray();

            if (debugWalls)
            {
                Debug.Log("Objects ordered from bottom to top");
                foreach (GameObject orderedObject in orderedGameObjects)
                {
                    Debug.Log(orderedObject);
                }
            }

            // Create walls in between doors and corners
            for (int i = 0; i < orderedGameObjects.Length - 1; i++)
            {
                float objAPosX = orderedGameObjects[i].GetComponent <Collider2D>().bounds.max.x;
                float objBPosX = orderedGameObjects[i + 1].GetComponent <Collider2D>().bounds.min.x;

                float difference = objBPosX - objAPosX;
                float midPoint   = objAPosX + difference * 0.5f;

                if (debugWalls)
                {
                    Debug.Log("Distance between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + difference);
                    Debug.Log("Midpoint between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + midPoint);
                }

                // If there is space between doors or corners
                if (difference > 0)
                {
                    GameObject wall = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
                    wall.GetComponent <SpriteRenderer>().sprite = wallSprite;
                    wall.name = "Bottom Wall " + (i + 1);
                    wall.transform.SetParent(wallsParent.transform);
                    wall.transform.position   = new Vector2(midPoint, r.transform.position.y - roomBounds.extents.y - 0.5f);
                    wall.transform.localScale = new Vector3(difference / r.transform.localScale.x, -1 / r.transform.localScale.y, 1);
                }
            }
        }

        // Left Wall
        if (!roomToAlignTo || (roomToAlignTo && toolbarAlignToRoom != 3))
        {
            GameObject[] orderedGameObjects = new GameObject[1];
            orderedGameObjects[0] = topLeftCorner;

            int objArrayPos = 1;

            foreach (GameObject door in doors)
            {
                if (door.transform.position.x < roomBounds.min.x)
                {
                    System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
                    orderedGameObjects[objArrayPos] = door;
                    objArrayPos++;
                }
            }

            System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
            orderedGameObjects[objArrayPos] = bottomLeftCorner;

            // Ordered from bottom to top
            orderedGameObjects = orderedGameObjects.OrderBy(go => go.transform.position.y).ToArray();

            if (debugWalls)
            {
                Debug.Log("Objects ordered from bottom to top");
                foreach (GameObject orderedObject in orderedGameObjects)
                {
                    Debug.Log(orderedObject);
                }
            }

            // Create walls in between doors and corners
            for (int i = 0; i < orderedGameObjects.Length - 1; i++)
            {
                float objAPosY = orderedGameObjects[i].GetComponent <Collider2D>().bounds.max.y;
                float objBPosY = orderedGameObjects[i + 1].GetComponent <Collider2D>().bounds.min.y;

                float difference = objBPosY - objAPosY;
                float midPoint   = objAPosY + difference * 0.5f;

                if (debugWalls)
                {
                    Debug.Log("Distance between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + difference);
                    Debug.Log("Midpoint between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + midPoint);
                }

                // If there is space between doors or corners
                if (difference > 0)
                {
                    GameObject wall = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
                    wall.GetComponent <SpriteRenderer>().sprite = wallSprite;
                    wall.name = "Left Wall " + (i + 1);
                    wall.transform.SetParent(wallsParent.transform);
                    wall.transform.Rotate(0, 0, -90);
                    wall.transform.position   = new Vector2(r.transform.position.x - roomBounds.extents.x - 0.5f, midPoint);
                    wall.transform.localScale = new Vector3(difference / r.transform.localScale.x, 1 / r.transform.localScale.y, 1);
                }
            }
        }

        // Right Wall
        if (!roomToAlignTo || (roomToAlignTo && toolbarAlignToRoom != 2))
        {
            GameObject[] orderedGameObjects = new GameObject[1];
            orderedGameObjects[0] = topRightCorner;
            int objArrayPos = 1;

            foreach (GameObject door in doors)
            {
                if (door.transform.position.x > roomBounds.max.x)
                {
                    System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
                    orderedGameObjects[objArrayPos] = door;
                    objArrayPos++;
                }
            }

            System.Array.Resize(ref orderedGameObjects, orderedGameObjects.Length + 1);
            orderedGameObjects[objArrayPos] = bottomRightCorner;

            // Ordered from top to bottom
            orderedGameObjects = orderedGameObjects.OrderBy(go => go.transform.position.y).ToArray();

            if (debugWalls)
            {
                Debug.Log("Objects ordered from bottom to top");
                foreach (GameObject orderedObject in orderedGameObjects)
                {
                    Debug.Log(orderedObject);
                }
            }

            // Create walls in between doors and corners
            for (int i = 0; i < orderedGameObjects.Length - 1; i++)
            {
                float objAPosY = orderedGameObjects[i].GetComponent <Collider2D>().bounds.max.y;
                float objBPosY = orderedGameObjects[i + 1].GetComponent <Collider2D>().bounds.min.y;

                float difference = objBPosY - objAPosY;
                float midPoint   = objAPosY + difference * 0.5f;

                if (debugWalls)
                {
                    Debug.Log("Distance between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + difference);
                    Debug.Log("Midpoint between " + orderedGameObjects[i] + " + " + orderedGameObjects[i + 1] + " = " + midPoint);
                }

                // If there is space between doors or corners
                if (difference > 0)
                {
                    GameObject wall = (GameObject)PrefabUtility.InstantiatePrefab(wallPrefab);
                    wall.GetComponent <SpriteRenderer>().sprite = wallSprite;
                    wall.name = "Right Wall " + (i + 1);
                    wall.transform.SetParent(wallsParent.transform);
                    wall.transform.Rotate(0, 0, 90);
                    wall.transform.localScale = new Vector3(difference / r.transform.localScale.x, 1 / r.transform.localScale.y, 1);
                    wall.transform.position   = new Vector2(r.transform.position.x + roomBounds.extents.x + 0.5f, midPoint);
                }
            }
        }

        // Delete corners on walls that are not selected
        // Top Wall
        if (roomToAlignTo && toolbarAlignToRoom == 1)
        {
            GameObject.DestroyImmediate(topLeftCorner);
            GameObject.DestroyImmediate(topRightCorner);
        }

        // Bottom Wall
        if (roomToAlignTo && toolbarAlignToRoom == 0)
        {
            GameObject.DestroyImmediate(bottomLeftCorner);
            GameObject.DestroyImmediate(bottomRightCorner);
        }

        // Left Wall
        if (roomToAlignTo && toolbarAlignToRoom == 3)
        {
            GameObject.DestroyImmediate(topLeftCorner);
            GameObject.DestroyImmediate(bottomLeftCorner);
        }

        //Right Wall
        if (roomToAlignTo && toolbarAlignToRoom == 2)
        {
            GameObject.DestroyImmediate(topRightCorner);
            GameObject.DestroyImmediate(bottomRightCorner);
        }
    }
    //Build Mid Sections
    void BuildPlatformMidSections(GameObject platformParent)
    {
        if (orientation == 1)
            platformParent.transform.Rotate(0, 0, 90);

        GameObject platformMidSections = new GameObject("Platform Mid Sections");
        platformMidSections.transform.SetParent(platformParent.transform);
        platformMidSections.transform.localPosition = new Vector3(0, 0, 0);

        // Create Ordered Array
        GameObject[] orderedObjects = new GameObject[0];
        int objArrayPos = 0;

        foreach(Transform child in platformParent.transform)
        {
            if (child.gameObject.tag == "Platform")
            {
                System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
                orderedObjects[objArrayPos] = child.gameObject;
                objArrayPos++;
            }
        }

        if (platformParent.transform.FindChild("Doors"))
        {
            foreach (Transform child in platformParent.transform.FindChild("Doors"))
            {
                if (child.gameObject.tag == "Door")
                {
                    System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
                    orderedObjects[objArrayPos] = child.gameObject;
                    objArrayPos++;
                }
            }
        }

        //Sort Array
        orderedObjects = orderedObjects.OrderBy(go => go.transform.position.x).ToArray();

        //Create platforms in between doors and ends
        for (int i = 0; i < orderedObjects.Length - 1; i++)
        {
            float objAPosX, objBPosX;

            if (orderedObjects[i].GetComponent<Collider2D>())
                objAPosX = orderedObjects[i].GetComponent<Collider2D>().bounds.max.x;

            else
                objAPosX = orderedObjects[i].transform.position.x;

            if (orderedObjects[i + 1].GetComponent<Collider2D>())
                objBPosX = orderedObjects[i + 1].GetComponent<Collider2D>().bounds.min.x;

            else
                objBPosX = orderedObjects[i + 1].transform.position.x;

            float distance = objBPosX - objAPosX;
            float midPoint = objAPosX + distance * 0.5f;

            //If there is space between doors or corners
            Object platformPrefab;

            if (distance > 0)
            {
                if(orientation == 0)
                    platformPrefab = Resources.Load("PlatformH");

                else
                    platformPrefab = Resources.Load("PlatformV");


                GameObject platform = (GameObject)PrefabUtility.InstantiatePrefab(platformPrefab);
                platform.name = "PlatformMid " + (i + 1);
                platform.transform.SetParent(platformMidSections.transform);
                platform.transform.position = new Vector2(midPoint, orderedObjects[i].transform.position.y);
                platform.transform.localScale = new Vector3(distance, 1, 1);
            }
        }

        if (orientation == 1)
            platformParent.transform.Rotate(0, 0, -90);
    }
    void BuildPlatform(bool buildMidSections)
    {
        //Set Art
        switch (selectedPlatformArt)
        {
            case 0:
            platformEndSprite = Resources.Load<Sprite>("Blue Metal Platform_H_End");
            break;
            default:
            break;
        }

        //Create Parent Object
        GameObject platformParent = new GameObject();
        platformParent.name = "Platform";

        //Build Platform Ends
        GameObject endLeft = null, endRight = null, endTop = null, endBottom = null;

		//For horizontal platforms.
        if (orientation == 0)
        {
            Object platformHPrefab = Resources.Load("PlatformH");

            if (platformEndLeft)
            {
                endLeft = (GameObject)PrefabUtility.InstantiatePrefab(platformHPrefab);
                endLeft.name = "Platform End Left";
                endLeft.transform.SetParent(platformParent.transform);
                endLeft.transform.localPosition = new Vector2((-platformWidth / 2) + 0.5f, 0);
                endLeft.transform.FindChild("Platform").GetComponent<SpriteRenderer>().sprite = platformEndSprite;
                endLeft.transform.FindChild("Platform Lit").GetComponent<SpriteRenderer>().sprite = platformEndSprite;
                endLeft.transform.FindChild("Platform Lit").GetComponent<SpriteRenderer>().sprite = platformEndSprite;
            }

            else
            {
                endLeft = new GameObject();
                endLeft.name = "Platform End Left";
                endLeft.tag = "Platform";
                endLeft.transform.SetParent(platformParent.transform);
                endLeft.transform.localPosition = new Vector2((-platformWidth / 2), 0);
            }

            if (platformEndRight)
            {
                endRight = (GameObject)PrefabUtility.InstantiatePrefab(platformHPrefab);
                endRight.name = "Platform End Right";
                endRight.transform.SetParent(platformParent.transform);
                endRight.transform.localPosition = new Vector2((platformWidth / 2) - 0.5f, 0);
                endRight.transform.localScale = new Vector3(-1, 1, 1);
                endRight.transform.FindChild("Platform").GetComponent<SpriteRenderer>().sprite = platformEndSprite;
                endRight.transform.FindChild("Platform Lit").GetComponent<SpriteRenderer>().sprite = platformEndSprite;
            }

            else
            {
                endRight = new GameObject();
                endRight.name = "Platform End Right";
                endRight.tag = "Platform";
                endRight.transform.SetParent(platformParent.transform);
                endRight.transform.localPosition = new Vector2((platformWidth / 2), 0);
            }
        }

        // For vertical platforms.
        else
        {
            endTop = new GameObject();
            endTop.name = "Platform End Top";
            endTop.tag = "Platform";
            endTop.transform.SetParent(platformParent.transform);
            endTop.transform.localPosition = new Vector2((-platformWidth / 2), 0);

            endBottom = new GameObject();
            endBottom.name = "Platform End Bottom";
            endBottom.tag = "Platform";
            endBottom.transform.SetParent(platformParent.transform);
            endBottom.transform.localPosition = new Vector2((platformWidth / 2), 0);
        }

        //Build Doors
        if (doorCount > 0)
        {
            // For horizontal doors.
            if (orientation == 0)
            {
                Object interiorDoorHPrefab = Resources.Load("InteriorDoorH");

                //Create Parent Object
                GameObject doorsParent = new GameObject("Doors");
                doorsParent.transform.SetParent(platformParent.transform);

                for (int i = 0; i < doorCount; i++)
                {
                    GameObject d = (GameObject)PrefabUtility.InstantiatePrefab(interiorDoorHPrefab);
                    d.name = "InteriorDoorH" + (i + 1);
                    d.transform.SetParent(doorsParent.transform);
                    d.transform.localPosition = new Vector3(0, 0, -1);
                }
            }

			// For vertical doors.
            else
            {
                Object interiorDoorVPrefab = Resources.Load("InteriorDoorV");

                //Create Parent Object
                GameObject doorsParent = new GameObject("Doors");
                doorsParent.transform.SetParent(platformParent.transform);

                for (int i = 0; i < doorCount; i++)
                {
                    GameObject d = (GameObject)PrefabUtility.InstantiatePrefab(interiorDoorVPrefab);
                    d.name = "InteriorDoorV" + (i + 1);
                    d.transform.SetParent(doorsParent.transform);
                    d.transform.localPosition = new Vector3(0, 0, -1);
                    d.transform.Rotate(0, 0, 90);
                }
            }
        }

        List<GameObject> doors = new List<GameObject>();

        if (platformParent.transform.FindChild("Doors"))
        {
            foreach (Transform child in platformParent.transform.FindChild("Doors"))
                doors.Add(child.gameObject);
        }

        // Order doors and platform ends
        GameObject[] orderedObjects = new GameObject[0];
        int objArrayPos = 0;

        //Add Platform Ends to ordered array

        if (orientation == 0)
        {
            System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
            orderedObjects[objArrayPos] = endLeft;
            objArrayPos++;

            System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
            orderedObjects[objArrayPos] = endRight;
            objArrayPos++;
        }

        else
        {
            System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
            orderedObjects[objArrayPos] = endTop;
            objArrayPos++;

            System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
            orderedObjects[objArrayPos] = endBottom;
            objArrayPos++;
        }

        //Add doors to ordered array
        if (doors.Count > 0)
        {
            foreach (GameObject door in doors)
            {
                System.Array.Resize(ref orderedObjects, orderedObjects.Length + 1);
                orderedObjects[objArrayPos] = door;
                objArrayPos++;
            }
        }

        //Order array from left to right
        orderedObjects = orderedObjects.OrderBy(go => go.transform.position.x).ToArray();

        //Get leftmost and rightmost objects
        GameObject objectLeft = orderedObjects[0];
        GameObject objectRight = orderedObjects[orderedObjects.Length - 1];

        float start, end;

        if (objectLeft.GetComponent<Collider2D>())
            start = objectLeft.GetComponent<Collider2D>().bounds.max.x;

        else
            start = objectLeft.transform.position.x;

        if (objectRight.GetComponent<Collider2D>())
            end = objectRight.GetComponent<Collider2D>().bounds.min.x;

        else
            end = objectRight.transform.position.x;

        float difference = end - start;

        //Remove End objects from array
        List<GameObject> o = orderedObjects.ToList();
        o.RemoveAt(0);
        o.RemoveAt(o.Count - 1);

        orderedObjects = o.ToArray();

        ////Position Doors and Ends
        foreach (GameObject orderedObject in orderedObjects)
        {
            float objectSizeX = orderedObject.GetComponent<Collider2D>().bounds.size.x;
            float objectExtentsX = orderedObject.GetComponent<Collider2D>().bounds.extents.x;
            float totalObjectLength = objectSizeX * orderedObjects.Length;
            float leftOverSpace = difference - totalObjectLength;

            if (orientation == 0)
            {
                orderedObject.transform.position = new Vector3(start + objectExtentsX + (leftOverSpace / (orderedObjects.Length + 1)), orderedObject.transform.position.y, orderedObject.transform.position.z);
                start = orderedObject.GetComponent<Collider2D>().bounds.max.x;
            }

            else
            {
                orderedObject.transform.position = new Vector3(start + objectExtentsX + 0.15f + (leftOverSpace / (orderedObjects.Length + 1)), orderedObject.transform.position.y, orderedObject.transform.position.z);
                start = orderedObject.GetComponent<Collider2D>().bounds.max.x;
            }
        }

        if (orientation == 1)
            platformParent.transform.Rotate(0, 0, -90);

        if (buildMidSections)
            BuildPlatformMidSections(platformParent);

        //Parent to room
        if (selectedRoom)
        {
            platformParent.transform.SetParent(selectedRoom.transform);
            platformParent.transform.localPosition = new Vector3(0, 0, 0);
        }


        Selection.activeGameObject = platformParent;
    }