Пример #1
0
    void DestroyBlocks()
    {
        if (blocks_to_destroy.Count > 0)
        {
            for (int i = 0; i < blocks_to_destroy.Count; i++)
            {
                if (BLOCK_RENEW)
                {
                    BlockSettings n_block = new BlockSettings();
                    n_block.GridPosition = Support.WorldToGrid(blocks_to_destroy[i].transform.position, BLOCK_SIZE, STARTING_POSITION);

                    //= new BlockSettings(to_destroy[i].transform.position.x, to_destroy[i].transform.position.y, to_destroy[i].transform.position.z);
                    new_blocks.Add(n_block);
                    //CreateBlock(blocks[i].transform.position.x, STARTING_POSITION.y + y_pos * BLOCK_SIZE, true)
                }

                GameObject.Destroy(blocks_to_destroy[i]);
                blocks.Remove(blocks_to_destroy[i]);
            }

            blocks_to_destroy.Clear();

            //ChangeState(GameState.PHYSIC);
        }
    }
Пример #2
0
    // PUBLIC METHODS

    public void Initialize(BlockSettings blockSettings)
    {
        m_Settings   = blockSettings;
        m_MeshFilter = GetComponent <MeshFilter>();

        CreateMesh();
    }
Пример #3
0
 public void Initialize(BlockSettings settings)
 {
     base.Initialize();
     this.settings = settings;
     Audio         = GetComponent <AudioSource>();
     mat           = GetComponent <Renderer>().material;
     col           = mat.color;
 }
Пример #4
0
        protected void InitializeBulkInserter(Func <IEnumerable <TMessage>, Task <IEnumerable <TResult> > > insertHandler, BlockSettings blockSettings, ILoggerFactory loggerFactory)
        {
            _insertHandler = insertHandler;

            _blockSettings = blockSettings ?? BlockSettings.Default;

            _mutexResult = new AsyncLock();

            _loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;

            _logger = loggerFactory.CreateLogger(nameof(DataflowBulkInserter <TMessage, TResult>));
        }
 private void Awake()
 {
     if (instance == null)
     {
         instance = this;
     }
     else
     {
         Destroy(this);
         return;
     }
 }
Пример #6
0
    // PUBLIC METHODS

    public void Initialize(int width, int height, float perlinScale, Vector2 perlinOffset, BlockSettings blockSettings, BlockData [,,] blockData = null)
    {
        m_Width         = width;
        m_Height        = height;
        m_PerlinScale   = perlinScale;
        m_PerlinOffset  = perlinOffset;
        m_BlockSettings = blockSettings;

        if (blockData == null)
        {
            m_BlockData = new BlockData[m_Width, m_Height, m_Width];
            Changed     = false;
        }
        else
        {
            m_BlockData = blockData;
            Changed     = true;
        }
    }
Пример #7
0
 public DataflowBulkInserter(Func <IEnumerable <TMessage>, Task <IEnumerable <TResult> > > insertHandler, BlockSettings blockSettings = null, ILoggerFactory loggerFactory = null) =>
Пример #8
0
    /**********************************************************************************/
    // функция генерирует наполнитель для блока
    // вызывается после генерации зданий и дорог, когда ограничители по пространству уже определены
    //
    /**********************************************************************************/
    void GenerateBlockEnviroment(GameObject block, BlockDescriptor descriptor, BlockSettings settings, int SizeOfBlocks)
    {
        int numberOfGeneratedObject         = settings.NumOfEnvElements;
        List <GameObject> applicableObjects = new List <GameObject>();

        foreach (GeneratedEnvironmentCtr.ENV_TYPE objType in settings.EnvTypes)
        {
            // формирование списка применимых для данного блока элементов
            foreach (GameObject generatedEnvObj in GeneratedEnvCollection)
            {
                // получаем контроллер и проверяем его тип
                GeneratedEnvironmentCtr ctr = generatedEnvObj.GetComponent <GeneratedEnvironmentCtr>();
                if (ctr == null)
                {
                    Debug.LogError("Wrong GeneratedEnvironmentCtr! is Null!");
                    return;
                }

                if (ctr.TYPE == objType)
                {
                    applicableObjects.Add(generatedEnvObj);
                }
            }
        }

        if (applicableObjects.Count == 0)
        {
            Debug.LogWarning("We have no enviroment items for: " + settings.EnvTypes.ToString() + ";  types");
            return;
        }

        // выбираем рандомные элементы из получившегося набора и используем их для заполнения блока
        // обновляем карту пространства
        for (int itemN = 0; itemN < numberOfGeneratedObject; itemN++)
        {
            GameObject envItemToInstance = applicableObjects[Random.Range(0, applicableObjects.Count)];

            bool generatingSuccess = false;
            bool weHaveFreeSpace   = true;
            while (!generatingSuccess && weHaveFreeSpace)
            {
                // состовляем коллекцию свободных точек
                List <Point> freeSpacePoints = new List <Point>();
                for (int x = 0; x < SizeOfBlocks; x++)
                {
                    for (int y = 0; y < SizeOfBlocks; y++)
                    {
                        if (descriptor.FreeSpaceMap[x, y] == true)
                        {
                            freeSpacePoints.Add(new Point(x, y));
                        }
                    }
                }

                // проверяем наличие свободного пространства
                if (freeSpacePoints.Count == 0)
                {
                    weHaveFreeSpace = false;
                    continue;
                }

                // выбираем случайную точку из свободных и устанавливаем туда элемент окружения
                Point randomFreePosition = freeSpacePoints[Random.Range(0, freeSpacePoints.Count)];
                int   xPos = randomFreePosition.x;
                int   yPos = randomFreePosition.y;


                // правильные координаты будут выставлены несколькими шагами дальше через localPosition
                GameObject instance = Instantiate(envItemToInstance, new Vector3(0.0f, 0.0f, 0.0f), Quaternion.identity) as GameObject;

                GeneratedEnvironmentCtr gec = instance.GetComponent <GeneratedEnvironmentCtr>();

                // устанавливаем в родителя ( TODO: без учёта размера генерируемого элемента)
                instance.transform.SetParent(block.transform);
                instance.transform.localPosition = new Vector3(((float)(xPos) + ((float)gec.SIZE) / 2) * SizeOfCell,
                                                               ((float)(yPos) + ((float)gec.SIZE) / 2) * SizeOfCell, 0.0f);

                // сохраняем локальные координаты
                gec.POSITION = new Point(xPos, yPos);

                // сохраняем ссылку на все сгенерированные элементы окружения
                descriptor.Enviroment.Add(instance);

                // обновляем карту свободных клеток в блоке
                descriptor.UpdateFreeSpaceMap(SizeOfBlocks);

                generatingSuccess = true;
            }
        }
    }
Пример #9
0
    /**********************************************************************************/
    // функция выбиарет здание(ия) для генерации на карте.
    //
    /**********************************************************************************/
    virtual protected List <GameObject> GetBuildingToInstance(BlockSettings settings)
    {
        /*****************/
        // определяем кол-во зданий, которые необходимо будет выбрать для генерации
        int numOfBuildings = 0;
        int maxGenWeight   = 0;

        foreach (var numVariant in settings.NumOfBuildings)
        {
            maxGenWeight += numVariant.y;
        }

        int randomWeight     = Random.Range(1, maxGenWeight + 1);
        int currentGenWeight = 0;

        for (int i = 0; i < settings.NumOfBuildings.Length; i++)
        {
            numOfBuildings    = settings.NumOfBuildings[i].x;   // количество зданий для генерации
            currentGenWeight += settings.NumOfBuildings[i].y;   // веса для данного варианта кол-ва зданий

            // если достигли или перешагнули значение случайного веса - выходим из цикла и используем последнее выбранное здание
            if (currentGenWeight >= randomWeight)
            {
                break;
            }
        }

        /*****************/
        // выбираем здания для генерации
        List <GameObject> toInstantiate = new List <GameObject>();

        // подсчитываем сумму всех весов в списке потенциальных зданий
        maxGenWeight = 0;
        foreach (var building in settings.Buildings)
        {
            maxGenWeight += building.Weight;
        }

        // собираем коллекцию префабов для дальнейшей генерации
        ObjectLibrary objLib = ObjectLibrary.GetInstance();

        for (; numOfBuildings > 0; numOfBuildings--)
        {
            randomWeight = Random.Range(1, maxGenWeight + 1);
            int          currentBuildingWeight = 0;
            Base.GO_TYPE buildingType          = Base.GO_TYPE.NONE_TYPE;


            for (int i = 0; i < settings.Buildings.Length; i++)
            {
                buildingType           = settings.Buildings[i].BuildingType;
                currentBuildingWeight += settings.Buildings[i].Weight;

                // если достигли или перешагнули значение случайного веса - выходим из цикла и используем последнее выбранное здание
                if (currentBuildingWeight >= randomWeight)
                {
                    break;
                }
            }

            GameObject prefab = objLib.GetPrefab(buildingType);
            toInstantiate.Add(prefab);
        }

        return(toInstantiate);
    }
Пример #10
0
    /**********************************************************************************/
    // функция генерирует внутренности блока
    //
    // порядок генерации объектов:
    // - Здания
    // - Дороги
    // - Генерируемое окружение
    /**********************************************************************************/
    void GenerateBlockContent(GameObject block, BlockDescriptor descriptor, int x, int y)
    {
        // определяемся с ограничениями на соединение дорог
        RoadManager.GetInstance().SetRoadRulesToBlock(descriptor, x, y);


        // обновляем карту занятых и свободных клеток
        descriptor.UpdateFreeSpaceMap(SizeOfBlocks);


        // определяем тип блока для генерации
        Base.BLOCK_TYPE blockToGenerate = GetBlockTypeToGenerate();

        // олучаем настройки для данного блока из библиотеки блоков
        BlockSettings settingsForGeneration = BlockLibrary.GetInstance().GetBlockSettings(blockToGenerate);

        // устанавливаем здания
        // для это выбираем его(их) из имеющейся коллекции
        List <GameObject> toInstantiateCollection = GetBuildingToInstance(settingsForGeneration);

        foreach (GameObject toInstantiate in toInstantiateCollection)
        {
            // получаем контроллер у объекта шаблона, он нам потребуется для определения размеров здания
            BuildingController bcOfPattern = toInstantiate.GetComponent <BuildingController>();

            // пробуем установить здание в блок
            bool success  = false;
            int  attempts = 10;
            while (!success && attempts > 0)
            {
                int xBuildingSize = bcOfPattern.XBuildingSize;
                int yBuildingSize = bcOfPattern.YBuildingSize;


                int xCorToPlace = Random.Range(0, (descriptor.xSize * SizeOfBlocks) - xBuildingSize + 1);
                int yCorToPlace = Random.Range(0, (descriptor.ySize * SizeOfBlocks) - yBuildingSize + 1);

                bool isPossible = true;

                // проверяем тушку здания
                for (int xCorToCheck = xCorToPlace; xCorToCheck < xCorToPlace + xBuildingSize; xCorToCheck++)
                {
                    for (int yCorToCheck = yCorToPlace; yCorToCheck < yCorToPlace + yBuildingSize; yCorToCheck++)
                    {
                        if (descriptor.FreeSpaceMap[xCorToCheck, yCorToCheck] != true)
                        {
                            isPossible = false;
                        }
                    }
                }

                // проверяем точку выхода из здания
                if (isPossible)
                {
                    Point roadPoint = new Point(xCorToPlace, yCorToPlace) + bcOfPattern.RoadPoint;
                    if (roadPoint.x < 0 || roadPoint.y < 0 || roadPoint.x >= SizeOfBlocks || roadPoint.y >= SizeOfBlocks)
                    {
                        isPossible = false;
                    }
                    else
                    {
                        if (descriptor.FreeSpaceMap[roadPoint.x, roadPoint.y] != true)
                        {
                            isPossible = false;
                        }
                    }
                }

                // если получилось подобрать координаты, устанавливаем новое здание в позицию и выходим из цикла
                if (isPossible)
                {
                    // правильные координаты будут выставлены несколькими шагами дальше через localPosition
                    GameObject instance = Instantiate(toInstantiate, new Vector3(0.0f, 0.0f, 0.0f), Quaternion.identity) as GameObject;

                    // устанавливаем в родителя
                    instance.transform.SetParent(block.transform);
                    instance.transform.localPosition = new Vector3((float)(xCorToPlace + xBuildingSize / 2) * SizeOfCell,
                                                                   (float)(yCorToPlace + yBuildingSize / 2) * SizeOfCell, 0.0f);

                    // сохраняем ссылку на все сгенерированные здания
                    descriptor.Buildings.Add(instance);

                    // обновляем карту свободных клеток в блоке
                    descriptor.UpdateFreeSpaceMap(SizeOfBlocks);

                    success = true;
                }

                // уменьшаем оставшееся кол-во попыток
                attempts--;
            }
        }


        // достраиваем дороги
        RoadManager.GetInstance().BuildRoadInBlock(descriptor, x, y, SizeOfBlocks);

        // генерируем прочие декоротивные и не только объекты
        GenerateBlockEnviroment(block, descriptor, settingsForGeneration, SizeOfBlocks);
    }
Пример #11
0
    public static void IniciaLevel(Level map, TextAsset content, int Altura, int Largura)
    {
        // Read every line in the file.

        using (StringReader reader = new StringReader(content.text))
        {
            //Leitura---------------------------------------
            string line;
            int    y = 0;
            while ((line = reader.ReadLine()) != null)
            {
                // Do something with the line.
                string[] parts = line.Split(' ');
                for (int i = 0; i < parts.Length; i++)
                {
                    if ((parts[i] == "#R") || (parts[i] == "#r"))
                    {
                        map.isRandom = true;
                    }
                    if ((parts[i] == "I") || (parts[i] == "i"))
                    {
                        int aux = System.Convert.ToInt32(parts[i + 1]);
                        if (!map.tiposDeIngredientes.Contains(aux))
                        {
                            map.tiposDeIngredientes.Add(aux);
                        }
                    }
                    else if ((parts[i] == "P") || (parts[i] == "p"))
                    {
                        int aux = System.Convert.ToInt32(parts[i + 1]);
                        map.listaDePedidos.Add(aux);
                    }
                    else if (((parts[i] == "G") || (parts[i] == "g")) && (y < Altura) && (!map.isRandom))
                    {
                        for (int x = 0; x < Largura; x++)
                        {
                            int           aux   = System.Convert.ToInt32(parts[i + x + 1]);
                            BlockSettings block = new BlockSettings();
                            block.GridPosition = new Vector2(x, Altura - y);
                            block.id           = aux;
                            map.gridDeIngredientes.Add(block);
                        }
                        y++;
                    }
                }
            }

            if (map.isRandom)
            {
                map.gridDeIngredientes.Clear();
                for (int y_ = 0; y_ < Altura; y_++)
                {
                    for (int x = 0; x < Largura; x++)
                    {
                        BlockSettings block = new BlockSettings();
                        int           aux   = (map.tiposDeIngredientes[Random.Range(0, map.tiposDeIngredientes.Count)]);
                        block.GridPosition = new Vector2(x, y_);
                        block.id           = aux;
                        map.gridDeIngredientes.Add(block);
                    }
                }
            }
        }
    }
Пример #12
0
 public void Deinitialize()
 {
     m_Mesh.Clear();
     m_BlockData     = null;
     m_BlockSettings = null;
 }