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);
}
}
// PUBLIC METHODS
public void Initialize(BlockSettings blockSettings)
{
m_Settings = blockSettings;
m_MeshFilter = GetComponent <MeshFilter>();
CreateMesh();
}
public void Initialize(BlockSettings settings)
{
base.Initialize();
this.settings = settings;
Audio = GetComponent <AudioSource>();
mat = GetComponent <Renderer>().material;
col = mat.color;
}
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;
}
}
// 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;
}
}
public DataflowBulkInserter(Func <IEnumerable <TMessage>, Task <IEnumerable <TResult> > > insertHandler, BlockSettings blockSettings = null, ILoggerFactory loggerFactory = null) =>
/**********************************************************************************/
// функция генерирует наполнитель для блока
// вызывается после генерации зданий и дорог, когда ограничители по пространству уже определены
//
/**********************************************************************************/
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;
}
}
}
/**********************************************************************************/
// функция выбиарет здание(ия) для генерации на карте.
//
/**********************************************************************************/
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);
}
/**********************************************************************************/
// функция генерирует внутренности блока
//
// порядок генерации объектов:
// - Здания
// - Дороги
// - Генерируемое окружение
/**********************************************************************************/
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);
}
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);
}
}
}
}
}
public void Deinitialize()
{
m_Mesh.Clear();
m_BlockData = null;
m_BlockSettings = null;
}