public Grid(Setup_Render setup, Config_Map config, TerrainType[,] types)
{
gridUtils.InjectDependencies(this, setup.Mat_Terrain, setup.Mat_Border);
_mapConfig = config;
// GRID AND TILE INFORMATION
Size = config.GridSize;
TileHeight = config.TileSize;
TileThickness = config.TileThickness;
// for grid mesh
Hexagons = new Hexagon[Size, Size];
_terrainResource = new TerrainResource(setup);
if (types == null)
{
_terrainTypes = MapGeneration.GenerateTerrainTypes(config);
}
else
{
_terrainTypes = types;
}
// Init Hexagons with Border
InitHexagons();
InitVertexData();
}
private Grid InitGrid(Setup_Render renderSetup, Config_Map mapConfig, TerrainType[,] terrain = null)
{
Grid grid = new Grid(renderSetup, mapConfig, terrain);
transform.position = Vector3.zero;
grid.WMatrix = transform.localToWorldMatrix;
return(grid);
}
public static bool GenerateModels(Config_Map mapConfig, out List <List <Vector4> > models)
{
models = new List <List <Vector4> >();
foreach (Config_Model config in mapConfig.Models)
{
models.Add(GenerateModelPlacementPointsScattered(config, mapConfig.SpawnAmount).ToList());
}
return(models != null);
}
public void InitModelButtons(Config_Map mapConfig)
{
_terraintoolkit ??= FindObjectOfType <TerrainToolkit>();
// for each model, add 1 button to parent
for (int i = 0; i < mapConfig.Models.Count; i++)
{
var buttonID = i;
var button = Instantiate(_addModelButtonPrefab, _modelBar.transform);
button.GetComponent <UI_ModelView>().Init(mapConfig.Models[i].Thumbnail, mapConfig.Models[i].ThumbnailName);
button.onClick.AddListener(() => _terraintoolkit.OnClickAddSModel(buttonID));
}
}
public static TerrainType[,] GenerateTerrainTypes(Config_Map config)
{
TerrainType[,] tileTypes = CreateNewBlankTerrain(config);
if (config.AmountMountain > 0)
{
ComputeMountains(config, ref tileTypes);
}
if (config.AmountWater > 0)
{
ComputeWater(config, ref tileTypes);
}
return(tileTypes);
}
private void Awake()
{
_renderSetup = MAP_DATA.RENDER_SETUP;
_mapConfig = MAP_DATA.MAP_CONFIG;
if (MAP_DATA.MAPSAVE == null)
{
LaunchNewPlaythrough();
}
else
{
LaunchNewPlaythrough(
SerializationHandler.DeserializeTerrainData(),
SerializationHandler.DeserializeTerrainTypes(),
MAP_DATA.MAPSAVE.modelData
);
}
}
//todo: generation
private static void ComputeWater(Config_Map config, ref TerrainType[,] types)
{
for (int x = 0; x < types.GetLength(0); x++)
{
for (int y = 0; y < types.GetLength(1); y++)
{
float px = x / (float)config.GridSize;
float py = y / (float)config.GridSize;
float prob = Mathf.PerlinNoise(px, py) * config.AmountWater;
float r = Random.Range(0f, 1f);
if (r < prob)
{
types[x, y] = new TerrainType(config.WaterTerrain);
}
// else tileTypes[x, y] = TileType.blank;
// Debug.Log( $"X: {x}, Y: {y} : Mountain Prob is {prob}" );
}
}
}
private static TerrainType[,] CreateNewBlankTerrain(Config_Map config)
{
if (config.BlankTerrain == null)
{
#if UNITY_EDITOR
Debug.LogError($"At least 1 Blank Terrain Type needs to be added to any Map Config. Please add a Blank Terrain to {config.MapName}");
#endif
return(null);
}
TerrainType[,] types = new TerrainType[config.GridSize, config.GridSize];
for (int i = 0; i < types.GetLength(0); i++)
{
for (int j = 0; j < types.GetLength(1); j++)
{
types[i, j] = new TerrainType(config.BlankTerrain);
}
}
return(types);
}
public void LaunchNewBenchmark(bool initMeshUtils = false, Vector3[] updateHexagons = null, TerrainType[,] terrain = null, meshUtils.SerializedModelRegister[] modeldata = null)
{
_renderSetup = MAP_DATA.RENDER_SETUP;
_mapConfig = MAP_DATA.MAP_CONFIG;
SetGlobalParams();
// take config
_grid = InitGrid(_renderSetup, _mapConfig, terrain);
InitGridRenderer();
updateHexagons ??= GenerateNewActiveHexagons();
if (initMeshUtils)
{
InitModelPools(modeldata);
}
// load fearures
//_grid.InitFeatures();
UpdateGridFromSaveFile(updateHexagons);
}
private void InitModelPools(meshUtils.SerializedModelRegister[] modeldata)
{
// load models
Config_Map mapConfig = _mapConfig;
Setup_Render renderSetup = _renderSetup;
meshUtils.Init(mapConfig.Models.Count);
var meshinit = FindObjectOfType <Meshpooling.MeshInit>(); //Todo: Create ModelResource
var uihandler = FindObjectOfType <UIHandler>();
uihandler.InitModelButtons(mapConfig);
//TODO: Create Buttons per model
List <Config_Model> singlepool = new List <Config_Model>();
List <Config_Model> multipool = new List <Config_Model>();
int type = 0;
foreach (Config_Model model in mapConfig.Models)
{
model.MeshType = type;
if (model.PoolSingle)
{
singlepool.Add(model);
}
else
{
multipool.Add(model);
}
type++;
}
meshinit.Init(renderSetup.Compute_MeshPool, multipool);
meshinit.RunMeshes();
List <List <Vector4> > models;
if (modeldata != null)
{
models = meshUtils.DeserializeModelRegister(modeldata);
}
else
{
MapGeneration.GenerateModels(mapConfig, out models);
}
List <Vector3[]> poslist = new();
for (int i = 0; i < models.Count; i++)
{
Vector4[] positions = models[i].ToArray();
Vector3[] posdata = new Vector3[positions.Length];
for (int j = 0; j < positions.Length; j++)
{
posdata[j] = new Vector3(positions[j].x, positions[j].y, positions[j].z);
}
poslist.Add(posdata);
}
GenerateSinglePools(singlepool);
meshUtils.SpawnFromPool(poslist);
meshUtils.RegisterAllToHexagons();
}
