protected new void Start()
    {
        base.Start();

        Hero.transform.position = new Vector3(Constants.PassageBackExitPosition.x, Hero.transform.position.y, 0);

        Passage = AdventureController.Instance.Map.Compartments[AdventureController.Instance.PlayerCompartmentNumber] as PassageClass;
        BackgroundObjects = new List<GameObject>();
        ActiveObjects = new List<GameObject>();

        FakeAltar exit = Instantiate(FT_AltarCollection.FakeAltar);
        exit.gameObject.name = "FakeBack";
        exit.AltarAction = FakeOnPreviousEvent;
        exit.Number = -1;
        exit.transform.position = Constants.PassageBackExitPosition;
        ActiveObjects.Add(exit.gameObject);
        BackgroundObjects.Add(CreateGameObjectBySprite(StartSprite));
        foreach (var tile in Passage.Tiles)
        {
            BackgroundObjects.Add(CreateGameObjectBySprite(tile.Background));
        }
        BackgroundObjects.Add(CreateGameObjectBySprite(EndSprite));

        exit = Instantiate(FT_AltarCollection.FakeAltar);
        exit.gameObject.name = "FakeNext";
        exit.Number = -1;
        exit.AltarAction = FakeOnNextEvent;
        exit.transform.position = Constants.PassageForwardExitPosition + new Vector3(BackgroundObjects[BackgroundObjects.Count - 1].transform.position.x - Constants.FT_PassageStartEndSpriteWidth / 2 / 100f, 0, 0);
        ActiveObjects.Add(exit.gameObject);

        for (int i = 0; i < Passage.Tiles.Length; i++)
        {
            for (int j = 0; j < Passage.Tiles[i].ActiveItems.Length; j++)
            {
                if (Passage.Tiles[i].ActiveItems[j] != null)
                {
                    GameObject newObject = Instantiate(Passage.Tiles[i].ActiveItems[j].gameObject);
                    (newObject.GetComponent<AbActiveItem>()).Number = i * Constants.FT_EventSlotsPerPassageTile + j;
                    float xPos = (Constants.FT_PassageStartEndSpriteWidth + i * Constants.FT_PassageTileSpriteWidth + j * Constants.FT_PassageTileSpriteWidth / Constants.FT_EventSlotsPerPassageTile) / 100;
                    newObject.transform.position = new Vector3(xPos, Constants.PassageAltarYpos, 0);
                    ActiveObjects.Add(newObject);
                }
                else
                {
                    if (Passage.Tiles[i].InactiveItems[j] != null)
                    {
                        GameObject newObject = Instantiate(Passage.Tiles[i].InactiveItems[j].gameObject);
                        (newObject.GetComponent<AbActiveItem>()).Number = i * Constants.FT_EventSlotsPerPassageTile + j;
                        (newObject.GetComponent<AbAltar>()).IsActive = false;
                        float xPos = (Constants.FT_PassageStartEndSpriteWidth + i * Constants.FT_PassageTileSpriteWidth + j * Constants.FT_PassageTileSpriteWidth / Constants.FT_EventSlotsPerPassageTile) / 100;
                        newObject.transform.position = new Vector3(xPos, Constants.PassageAltarYpos, 0);
                        ActiveObjects.Add(newObject);
                    }
                }
                if (Passage.Tiles[i].Enemies[j] != null)
                {
                    GameObject newObject = Instantiate(Passage.Tiles[i].Enemies[j].gameObject);
                    (newObject.GetComponent<AbEnemy>()).Number = i * Constants.FT_EventSlotsPerPassageTile + j;
                    float xPos = (Constants.FT_PassageStartEndSpriteWidth + i * Constants.FT_PassageTileSpriteWidth + j * Constants.FT_PassageTileSpriteWidth / Constants.FT_EventSlotsPerPassageTile) / 100f;
                    newObject.transform.position = new Vector3(xPos, Constants.PassageEnemyYpos, 0);
                    ActiveObjects.Add(newObject);
                }
            }
        }

        if (!AdventureController.Instance.isMovingNext)
        {
            //reverse positions
            Vector3 temp;
            for (int i = 0; i < BackgroundObjects.Count/2 + BackgroundObjects.Count%2; i++)
            {
                if (BackgroundObjects.Count % 2 == 1 && i == BackgroundObjects.Count / 2)
                {
                    (BackgroundObjects[i].GetComponent<SpriteRenderer>()).flipX = true;
                    break;
                }
                (BackgroundObjects[i].GetComponent<SpriteRenderer>()).flipX = true;
                (BackgroundObjects[BackgroundObjects.Count - i - 1].GetComponent<SpriteRenderer>()).flipX = true;
                temp = BackgroundObjects[BackgroundObjects.Count - i - 1].transform.position;
                BackgroundObjects[BackgroundObjects.Count - i - 1].transform.position = BackgroundObjects[i].transform.position;
                BackgroundObjects[i].transform.position = temp;
            }

            var newBackgroundArray = new List<GameObject>();
            for (int i = BackgroundObjects.Count - 1; i >= 0; i--)
            {
                newBackgroundArray.Add(BackgroundObjects[i]);
            }
            BackgroundObjects = newBackgroundArray;

            for (int i = 0; i < ActiveObjects.Count; i++)
            {
                (ActiveObjects[i].GetComponent<SpriteRenderer>()).flipX = true;
                temp = new Vector3(BackgroundObjects[0].transform.position.x + BackgroundObjects[BackgroundObjects.Count - 1].transform.position.x -
                        ActiveObjects[i].transform.position.x, ActiveObjects[i].transform.position.y, 0);
                ActiveObjects[i].transform.position = temp;
            }
        }

        isFighting = false;
        isExploring = true;
    }
    public void GenerateMap()
    {
        Map = new DungeonMap();
        int roomCount = Random.Range(Constants.FT_RoomCountMax, Constants.FT_RoomCountMin);
        for(int i=0; i < roomCount; i++)
        {
            RoomClass room = new RoomClass();
            room.Background = RoomSprites[Random.Range(0, RoomSprites.Length - 1)];
            room.Type = RoomTypes[Random.Range(0, RoomTypes.Length - 1)];
            room.Furniture = SetRoomFurniture(room);
            if (room.Type == FloodedTempleRoomType.Shop)
            {
                for(int j=0; j < Constants.FT_ItemsPerShop; j++)
                {
                    room.ActiveItems.Add(ItemCollection.GetRandomItem());
                }
            }
            else if (room.Type == FloodedTempleRoomType.Rest)
            {
                room.ActiveItems.Add(new FakeAltar());
            }
            else if (room.Type == FloodedTempleRoomType.Training)
            {
                room.Enemy = FT_EnemyCollection.GetRandomEnemy();
            }
            Map.Compartments.Add(room);

            if (i < roomCount - 1)
            {
                PassageClass passage = new PassageClass();
                passage.Tiles = new PassageTile[Random.Range(Constants.FT_PassageTileLengthMin, Constants.FT_PassageTileLengthMax)];
                AbActiveItem[] activeItems = new AbActiveItem[passage.Tiles.Length * 4];

                //#todo generate doors
                activeItems[1] = new FakeAltar();
                //activeItems[1].Action = previous;
                activeItems[activeItems.Length-2] = new FakeAltar();
                //activeItems[activeItems.Length-2].Action = next;

                for (int j = 3; j < activeItems.Length-2; j++)
                {
                    if (Random.Range(1, 100) <= Constants.FT_AltarChance)
                    {
                        activeItems[j] = FT_AltarCollection.GetRandomAltar();
                        j += Constants.FT_SameEventsMinDistance - 1;
                    }
                }
                AbEnemy[] enemies = new AbEnemy[passage.Tiles.Length * 4];
                for (int j = 2; j < enemies.Length; j++)
                {
                    if (Random.Range(1, 100) <= Constants.FT_AltarChance)
                    {
                        if (activeItems[j]!=null)
                        {
                            enemies[j-1] = FT_EnemyCollection.GetRandomEnemy();
                        }
                        else
                        {
                            enemies[j] = FT_EnemyCollection.GetRandomEnemy();
                        }
                        j += Constants.FT_SameEventsMinDistance - 1;
                    }
                }
                for (int j = 0; j < passage.Tiles.Length; j++)
                {
                    PassageTile passageTile = new PassageTile();
                    passageTile.Background = PassageSprites[Random.Range(0, PassageSprites.Length - 1)];

                    for(int k = 0; k < Constants.FT_EventSlotsPerPassageTile; k++)
                    {
                        passageTile.ActiveItems[k] = activeItems[j * 4 + k];
                    }
                    for (int k = 0; k < Constants.FT_EventSlotsPerPassageTile; k++)
                    {
                        passageTile.Enemies[k] = enemies[j * 4 + k];
                    }

                    passage.Tiles[j] = passageTile;
                }

                Map.Compartments.Add(passage);
            }
        }
    }
    public void GenerateMap()
    {
        Map = new DungeonMap();
        int roomCount = Random.Range(Constants.FT_RoomCountMax, Constants.FT_RoomCountMin);
        bool isRestExists = false;
        bool isTrainingExists = false;
        bool isShopExists = false;
        for (int i=0; i < roomCount; i++)
        {
            RoomClass room = new RoomClass();
            if (Map.Compartments.Count == 0)
            {
                room.Type = FloodedTempleRoomTypes.Start;
                room.Background = StartRoomSprite;
                room.Furniture = SetRoomFurniture(room);
                Map.Compartments.Add(room);
            }
            else if (Map.Compartments.Count == (roomCount - 1) * 2)
            {
                room.Type = FloodedTempleRoomTypes.Final;
                room.Background = FinalRoomSprite;
                room.Furniture = SetRoomFurniture(room);
                room.ActiveItems.Add(FT_AltarCollection.TheRivenMaskAltar);
                room.Enemy = FT_EnemyCollection.DDTheRock;
                Map.Compartments.Add(room);
            }
            else
            {
                do
                {
                    room.Type = MinorRoomTypes[Random.Range(0, MinorRoomTypes.Length)];
                } while (!(room.Type == FloodedTempleRoomTypes.Training && !isTrainingExists || room.Type == FloodedTempleRoomTypes.Shop && !isShopExists
                || room.Type == FloodedTempleRoomTypes.Rest && !isRestExists || isTrainingExists && isShopExists && isRestExists));
                if (room.Type == FloodedTempleRoomTypes.Training)
                {
                    isTrainingExists = true;
                }
                else if(room.Type == FloodedTempleRoomTypes.Shop)
                {
                    isShopExists = true;
                }
                else if (room.Type == FloodedTempleRoomTypes.Rest)
                {
                    isRestExists = true;
                }
                room.Background = MinorRoomSprites[(int)room.Type-1];
                room.Furniture = SetRoomFurniture(room);
                if (room.Type == FloodedTempleRoomTypes.Shop)
                {
                    for (int j = 0; j < Random.Range(1, Constants.FT_ItemsPerShop); j++)
                    {
                        room.ActiveItems.Add(ItemCollection.GetRandomItem());
                    }
                }
                else if (room.Type == FloodedTempleRoomTypes.Rest)
                {
                    room.ActiveItems.Add(FT_AltarCollection.RestRoomAltar);
                }
                else if (room.Type == FloodedTempleRoomTypes.Training)
                {
                    room.Enemy = FT_EnemyCollection.GetRandomMinorBoss();
                }
                Map.Compartments.Add(room);
            }
            if (i < roomCount - 1)
            {
                PassageClass passage = new PassageClass();
                passage.Tiles = new PassageTile[Random.Range(Constants.FT_PassageMinTileLength, Constants.FT_PassageMaxTileLength+1)];
                AbActiveItem[] activeItems = new AbActiveItem[passage.Tiles.Length * 4];

                for (int j = 3; j < activeItems.Length-2; j++)
                {
                    if ((j%Constants.FT_EventSlotsPerPassageTile==2 || j % Constants.FT_EventSlotsPerPassageTile == 3) && Random.Range(1, 100) <= Constants.FT_AltarChance)
                    {
                        activeItems[j] = FT_AltarCollection.GetRandomAltar();
                        j += Constants.FT_SameEventsMinDistance - 1;
                    }
                }
                AbEnemy[] enemies = new AbEnemy[passage.Tiles.Length * 4];

                if (i == 0)
                {
                    enemies[2] = FT_EnemyCollection.TutorialTurtle;
                }
                for (int j = 2; j < enemies.Length; j++)
                {
                    if (i == 0)
                    {
                        j += Constants.FT_SameEventsMinDistance - 1;
                    }
                    else
                    {
                        if (j % Constants.FT_EventSlotsPerPassageTile != 0 && Random.Range(1, 100) <= Constants.FT_EnemyChance)
                        {
                            if (activeItems[j] != null)
                            {
                                enemies[j - 1] = FT_EnemyCollection.GetRandomTrashEnemy();
                            }
                            else
                            {
                                enemies[j] = FT_EnemyCollection.GetRandomTrashEnemy();
                            }
                            j += Constants.FT_SameEventsMinDistance - 1;
                        }
                    }
                }
                for (int j = 0; j < passage.Tiles.Length; j++)
                {
                    PassageTile passageTile = new PassageTile();
                    passageTile.Background = PassageSprites[Random.Range(0, PassageSprites.Length)];

                    for(int k = 0; k < Constants.FT_EventSlotsPerPassageTile; k++)
                    {
                        passageTile.ActiveItems[k] = activeItems[j * 4 + k];
                    }
                    for (int k = 0; k < Constants.FT_EventSlotsPerPassageTile; k++)
                    {
                        passageTile.Enemies[k] = enemies[j * 4 + k];
                    }

                    passage.Tiles[j] = passageTile;
                }

                Map.Compartments.Add(passage);
            }
        }
    }