public void refershNoveltyMapsBatch()
    {
        int i = 0;

        TileObject[,] tmpStrAlias;
        Vector2Int startMainMap = ParameterManager.Instance.StartCell;

        GeneratorUIManager.Instance.deleteMapOnUI(AliasDragAreas[2].GetChild(0));
        AliasDragAreas[2].GetComponent <MapListManager>().dictionaryMap.Clear();

        if (SimilarMapsQueue.Count <= 0)
        {
            GenerateAndTestAliasMaps();
        }

        while (i < BatchAliasNumber)
        {
            tmpStrAlias = SimilarMapsQueue.Last();
            float dst = SimilarMapsQueue.GetPriority(tmpStrAlias);
            SimilarMapsQueue.Remove(tmpStrAlias);

            Utility.renderAliasOnUI(AliasDragAreas[2].GetChild(0).GetComponent <RectTransform>(), ParameterManager.Instance.GridType, new StructuredAlias(tmpStrAlias, startMainMap, ParameterManager.Instance.EndCell, dst), AliasPrefab, true);

            i++;
        }
    }
    public Dictionary <int, StructuredAlias> GenerateNRandomAliasFromRealMap(StructuredAlias realMap, int N)
    {
        mainMap  = realMap.AliasMap;
        gridType = ParameterManager.Instance.GridType;
        Vector2Int startMainMap = realMap.start;
        int        width        = realMap.AliasMap.GetLength(0);
        int        height       = realMap.AliasMap.GetLength(1);

        //Map initialization.
        int i = 0;

        Dictionary <int, StructuredAlias> AliasBatch = new Dictionary <int, StructuredAlias>();

        Vector2Int startAlias = realMap.start;
        Vector2Int endAlias   = realMap.end;
        SimplePriorityQueue <TileObject[, ]> tmpPQ = new SimplePriorityQueue <TileObject[, ]>();
        bool isAliasSameAsReal = true;

        while (i < N)
        {
            //define here the width, height, start and end  of the chosen map
            TileObject[,] aliasMap = new TileObject[width, height];

            genMan.connectedGenerator.setBaseGeneratorParameters(gridType, width, height, startAlias, endAlias, (i % 2 == 0?1:-1) * RNG_Alias.Next(), false);
            genMan.cellularAutomataGenerator.setBaseGeneratorParameters(gridType, width, height, startAlias, endAlias, (i % 2 == 0 ? 1 : -1) * RNG_Alias.Next(), false);
            genMan.primGenerator.setBaseGeneratorParameters(gridType, width, height, startAlias, endAlias, (i % 2 == 0 ? 1 : -1) * RNG_Alias.Next(), false);

            switch (i % 3)
            {
            case 0:
                aliasMap = genMan.connectedGenerator.generateMapGeneral(ParameterManager.Instance.IsTrapsOnMapBorder, (float)RNG_Alias.NextDouble());
                break;

            case 1:
                float prcObsCA = (float)RNG_Alias.NextDouble();
                aliasMap = genMan.cellularAutomataGenerator.generateMapGeneral(ParameterManager.Instance.IsTrapsOnMapBorder, prcObsCA, 1 + (prcObsCA <= .5f && !(i % 2 == 1)?0:RNG_Alias.Next(0, 6)), 5, i % 2 == 1, 0, 0);
                break;

            case 2:
                aliasMap = genMan.primGenerator.generateMapGeneral(ParameterManager.Instance.IsTrapsOnMapBorder, (float)RNG_Alias.NextDouble());
                break;

            default:
                ErrorManager.ManageError(ErrorManager.Error.HARD_ERROR, "AliasManager: no map generator found.");
                break;
            }

            foreach (var m in BaseAliasCollisionMask)
            {
                if (Utility.in_bounds_General(new Vector2Int(startMainMap.x + m.x, startMainMap.y + m.y), mainMap.GetLength(0), mainMap.GetLength(1)) &&
                    Utility.in_bounds_General(new Vector2Int(startAlias.x + m.x, startAlias.y + m.y), aliasMap.GetLength(0), aliasMap.GetLength(1)))
                {
                    aliasMap[startAlias.x + m.x, startAlias.y + m.y].type = realMap.AliasMap[startMainMap.x + m.x, startMainMap.y + m.y].type;
                }
            }

            for (int h = 0; h < width; h++)
            {
                for (int k = 0; k < height; k++)
                {
                    isAliasSameAsReal &= (aliasMap[h, k].type == realMap.AliasMap[h, k].type);

                    if (!isAliasSameAsReal)
                    {
                        break;
                    }
                }
                if (!isAliasSameAsReal)
                {
                    break;
                }
            }

            if (MapEvaluator.isEndReachable(aliasMap, gridType, startAlias, endAlias, ParameterManager.Instance.allowAutosolverForAlias).First() == endAlias && !isAliasSameAsReal)
            {
                //if the map has a path from start to end, add it
                float dst = MapEvaluator.BinaryMapSimilarity(mainMap, aliasMap, startMainMap, startAlias);
                tmpPQ.Enqueue(aliasMap, dst);


                i++;
            }
        }

        i = 0;
        TileObject[,] tmpStrAlias;
        while (i < N)
        {
            if (ParameterManager.Instance.considerSimilar)
            {
                float dst = tmpPQ.GetPriority(tmpPQ.First());
                tmpStrAlias = tmpPQ.Dequeue();

                AliasBatch.Add(Guid.NewGuid().GetHashCode(), new StructuredAlias(tmpStrAlias, startAlias, endAlias, dst));

                i++;
            }

            if (ParameterManager.Instance.considerNovelty && i < N)
            {
                tmpStrAlias = tmpPQ.Last();
                float dst = tmpPQ.GetPriority(tmpStrAlias);
                tmpPQ.Remove(tmpStrAlias);

                AliasBatch.Add(Guid.NewGuid().GetHashCode(), new StructuredAlias(tmpStrAlias, startAlias, endAlias, dst));

                i++;
            }
        }

        return(AliasBatch);
    }
    public void CollabGameGeneration()
    {
        mainMap          = ParameterManager.Instance.MapToPlay;
        gridType         = ParameterManager.Instance.GridType;
        SimilarMapsQueue = new SimplePriorityQueue <TileObject[, ]>();

        K_CollisionSet = MapEvaluator.BuildKCollisionVec(mainMap, gridType, ParameterManager.Instance.StartCell, Mathf.Max(ParameterManager.Instance.minStepsSolution, ParameterManager.Instance.maxStepsSolution));

        if (ParameterManager.Instance.isOptimizerOn)
        {
            List <TileObject[, ]> alises = new List <TileObject[, ]>();
            BaseAliasCollisionMask = getMainMapKMaxMinCells(mainMap, gridType, ParameterManager.Instance.minStepsSolution, ParameterManager.Instance.minStepsSolution, ParameterManager.Instance.StartCell, 0f);

            int experimentsNum = 1;
            while (experimentsNum > 0)
            {
                foreach (var a in AliasGeneratorManager.Instance.GetComponent <AliasGameEvaluator>().AliasGameOptimizerHandler())
                {
                    SimilarMapsQueue.Enqueue(a.Value.AliasMap, a.Value.similarityDistance);
                }
                experimentsNum--;
            }
        }
        else
        {
            GenerateAndTestAliasMaps();
        }


        int        i            = 0;
        Vector2Int startMainMap = ParameterManager.Instance.StartCell;

        TileObject[,] tmpStrAlias;
        while (i < ParameterManager.Instance.aliasNum)
        {
            if (ParameterManager.Instance.considerSimilar)
            {
                float dst = SimilarMapsQueue.GetPriority(SimilarMapsQueue.First());
                tmpStrAlias = SimilarMapsQueue.Dequeue();

                Utility.renderAliasOnUI(AliasDragAreas[0].GetChild(0).GetComponent <RectTransform>(), ParameterManager.Instance.GridType, new StructuredAlias(tmpStrAlias, startMainMap, ParameterManager.Instance.EndCell, dst), AliasPrefab, true);
                i++;
            }

            if (ParameterManager.Instance.considerNovelty && i < ParameterManager.Instance.aliasNum)
            {
                tmpStrAlias = SimilarMapsQueue.Last();
                float dst = SimilarMapsQueue.GetPriority(tmpStrAlias);
                SimilarMapsQueue.Remove(tmpStrAlias);

                Utility.renderAliasOnUI(AliasDragAreas[0].GetChild(0).GetComponent <RectTransform>(), ParameterManager.Instance.GridType, new StructuredAlias(tmpStrAlias, startMainMap, ParameterManager.Instance.EndCell, dst), AliasPrefab, true);
                i++;
            }
        }

        i = 0;
        while (SimilarMapsQueue.Count > 0 && i < BatchAliasNumber)
        {
            float dst = SimilarMapsQueue.GetPriority(SimilarMapsQueue.First());
            tmpStrAlias = SimilarMapsQueue.Dequeue();

            Utility.renderAliasOnUI(AliasDragAreas[1].GetChild(0).GetComponent <RectTransform>(), ParameterManager.Instance.GridType, new StructuredAlias(tmpStrAlias, startMainMap, ParameterManager.Instance.EndCell, dst), AliasPrefab, true);
            i++;
        }

        i = 0;
        while (SimilarMapsQueue.Count > 0 && i < BatchAliasNumber)
        {
            tmpStrAlias = SimilarMapsQueue.Last();
            float dst = SimilarMapsQueue.GetPriority(tmpStrAlias);
            SimilarMapsQueue.Remove(tmpStrAlias);

            Utility.renderAliasOnUI(AliasDragAreas[2].GetChild(0).GetComponent <RectTransform>(), ParameterManager.Instance.GridType, new StructuredAlias(tmpStrAlias, startMainMap, ParameterManager.Instance.EndCell, dst), AliasPrefab, true);

            i++;
        }

        //reset horizontal and vertical bars if exists
        ScrollRect sR = AliasDragAreas[0].GetComponent <ScrollRect>();

        if (sR != null)
        {
            Scrollbar hSb = sR.horizontalScrollbar;
            Scrollbar vSb = sR.verticalScrollbar;

            if (hSb != null)
            {
                hSb.value = .99f;
            }

            if (vSb != null)
            {
                vSb.value = .99f;
            }
        }

        gameObject.GetComponent <AliasGameEvaluator>().AliasGameEvaluatorHandler();
    }