コード例 #1
0
    void SetExtraRoomType(GameObject room, string roomType)
    {
        MapRoomController roomController = room.GetComponent <MapRoomController>();

        roomController.SetRoomType(roomType);
        roomController.SetCoreRoom(false);
    }
コード例 #2
0
    void SpawnStartRoom()
    {
        GameObject room = Instantiate(roomImage, transform.position, Quaternion.identity) as GameObject;

        room.name = "startRoom";
        room.transform.SetParent(transform);
        room.transform.localPosition = Vector3.zero;
        MapRoomController roomController = room.GetComponent <MapRoomController>();

        roomController.SetRoomType("Start");
        roomController.SetRoomIndex(0);
        roomController.SetCoreRoom(true);
        roomsPositions.Add(room.transform.position);
        roomsRemaining -= 1;
        rooms.Add(room);
    }
コード例 #3
0
    void SpawnMainRooms()
    {
        Vector3 lastRoomPosition = roomsPositions[0];

        Vector3   newRoomPosOffset = Vector3.zero;
        Direction lastDirection    = Direction.No;

        int repeats = 0;

        for (int i = roomsRemaining; i > 0; i--)
        {
            newDirection = new List <Direction>();

            switch (excludeDirecion)
            {
            case Direction.Left:
                newDirection.Add(Direction.Down);
                newDirection.Add(Direction.Right);
                newDirection.Add(Direction.Up);
                break;

            case Direction.Up:
                newDirection.Add(Direction.Down);
                newDirection.Add(Direction.Right);
                newDirection.Add(Direction.Left);
                break;

            case Direction.Right:
                newDirection.Add(Direction.Down);
                newDirection.Add(Direction.Left);
                newDirection.Add(Direction.Up);
                break;

            case Direction.Down:
                newDirection.Add(Direction.Left);
                newDirection.Add(Direction.Right);
                newDirection.Add(Direction.Up);
                break;
            }


            RaycastHit2D hitLeft = Physics2D.Raycast(lastRoomPosition, Vector2.left, 1.28f, 1 << 9);
            if (hitLeft.collider != null)
            {
                //                print(hitLeft.collider.name);
                if (hitLeft.collider.gameObject.tag == "MapRoom" && excludeDirecion != Direction.Left)
                {
                    newDirection.Remove(Direction.Left);
                }
            }

            RaycastHit2D hitUp = Physics2D.Raycast(lastRoomPosition, Vector2.up, 0.72f, 1 << 9);
            if (hitUp.collider != null)
            {
                //              print(hitUp.collider.name);
                if (hitUp.collider.gameObject.tag == "MapRoom" && excludeDirecion != Direction.Up)
                {
                    newDirection.Remove(Direction.Up);
                }
            }

            RaycastHit2D hitRight = Physics2D.Raycast(lastRoomPosition, Vector2.right, 1.28f, 1 << 9);
            if (hitRight.collider != null)
            {
                //               print(hitRight.collider.name);
                if (hitRight.collider.gameObject.tag == "MapRoom" && excludeDirecion != Direction.Right)
                {
                    newDirection.Remove(Direction.Right);
                }
            }

            RaycastHit2D hitDown = Physics2D.Raycast(lastRoomPosition, Vector2.down, 0.72f, 1 << 9);
            if (hitDown.collider != null)
            {
                //              print(hitDown.collider.name);
                if (hitDown.collider.gameObject.tag == "MapRoom" && excludeDirecion != Direction.Down)
                {
                    newDirection.Remove(Direction.Down);
                }
            }
            newDirection.Sort();
            //           print(newDirection.Count);

            int random = Random.Range(0, newDirection.Count);

            if (newDirection[random] == lastDirection)
            {
                if (repeats < maxRepeats)
                {
                    repeats += 1;
                }
                else
                {
                    switch (random)
                    {
                    case 0:
                        float localRandom0 = Random.value;
                        if (localRandom0 > 0.5f)
                        {
                            if (newDirection.Count > 1)
                            {
                                random = 1;
                            }
                        }
                        else if (newDirection.Count > 2)
                        {
                            random = 2;
                        }
                        break;

                    case 1:
                        float localRandom1 = Random.value;
                        if (localRandom1 > 0.5f)
                        {
                            random = 0;
                        }
                        else if (newDirection.Count > 2)
                        {
                            random = 2;
                        }
                        break;

                    case 2:
                        float localRandom2 = Random.value;
                        if (localRandom2 > 0.5f)
                        {
                            random = 0;
                        }
                        else if (newDirection.Count > 1)
                        {
                            random = 1;
                        }
                        break;
                    }
                    repeats = 0;
                }
            }
            else
            {
                repeats = 0;
            }

            switch (newDirection[random])
            {
            case Direction.Left:
                lastDirection    = Direction.Left;
                newRoomPosOffset = new Vector3(-1.28f, 0, 0);
                break;

            case Direction.Up:
                lastDirection    = Direction.Up;
                newRoomPosOffset = new Vector3(0, 0.72f, 0);
                break;

            case Direction.Right:
                lastDirection    = Direction.Right;
                newRoomPosOffset = new Vector3(1.28f, 0, 0);
                break;

            case Direction.Down:
                lastDirection    = Direction.Down;
                newRoomPosOffset = new Vector3(0, -0.72f, 0);
                break;
            }

            GameObject room = Instantiate(roomImage, lastRoomPosition, Quaternion.identity) as GameObject;

            if (i > 1)
            {
                room.name = "mainRoom_" + i;
                if (npcAmount < 2)
                {
                    float randomChance = Random.value; // NPC SPAWN CHANCE
                    if (randomChance > 0.75)
                    {
                        room.GetComponent <MapRoomController>().SetRoomType("Npc");
                        npcAmount += 1;
                    }
                    else
                    {
                        room.GetComponent <MapRoomController>().SetRoomType("Default");
                    }
                }
                else
                {
                    room.GetComponent <MapRoomController>().SetRoomType("Default");
                }
            }
            else
            {
                room.name = "mainRoom_1_bossRoom";
                room.GetComponent <MapRoomController>().SetRoomType("Boss");
            }
            room.transform.SetParent(transform);
            room.transform.localScale     = Vector3.one;
            room.transform.localPosition += newRoomPosOffset;
            MapRoomController roomController = room.GetComponent <MapRoomController>();
            roomController.SetRoomIndex(i);
            roomController.SetCoreRoom(true);
            roomsPositions.Add(room.transform.position);
            rooms.Add(room);


            lastRoomPosition = room.transform.position;
            roomsRemaining  -= 1;
        }
    }