public Model(CitySettings settings)
{
this.nPatches = settings.patchNum != -1 ? settings.patchNum : 15;
plazaNeeded = settings.plaza;
citadelNeeded = true;
wallsNeeded = settings.wall;
var seed = settings.seed;
do
{
try
{
Random.InitState(++seed);
Debug.Log(seed);
build();
instance = this;
}
catch (Exception e)
{
Debug.Log(
e.StackTrace
);
instance = null;
}
finally
{
Random.State oldstate = Random.state;
Random.state = oldstate;
}
}while (instance == null);
}
/// <summary>
/// Found yourself a brand spankin' new city! Make sure to give it some settings
/// so it knows how to build itself.
/// </summary>
/// <param name="position"></param>
/// <param name="settings"></param>
/// <param name="name"></param>
/// <returns></returns>
public static City CreateCity(Vector3 position, CitySettings settings, string name = "City")
{
City temp = new GameObject(name).AddComponent <City>();
temp.Init(position, settings);
return(temp);
}
/// <summary>
/// Initialize this viewModel
/// </summary>
public void Initialize(DrawService drawService)
{
//initialize draw service
_drawService = drawService;
//_drawService.OnClick += OnClick;
//create empty voronoi Diagram
_points = new List <Point>();
_voronoiDiagram = new VoronoiDiagram();
_cityData = new CityData();
_citySettings = new CitySettings();
//seed for random generation
Seed = DateTime.Now.GetHashCode();
//store default settings
foreach (var districtType in _districtTypes)
{
DistrictSettings.Add(new DistrictSettings(districtType));
break;
}
RaisePropertyChanged("DistrictSettings");
//debug for math test and drawing
MathTesting();
}
public void Init(Vector3 position, CitySettings settings)
{
transform.position = position;
this.settings = settings;
metricConstraint = MetricFactory.Process(this.settings.metric, settings);
origin = CigenFactory.CreateOrMergeIntersection(RandomLocalPosition(), this);
}
/// <summary>
/// set required data for generating the terrain
/// </summary>
public void InitializeSettings(TerrainSettings terrainSettings, GenerationSettings voronoiSettings, GameObject parent, CitySettings citySettings)
{
//store settings
_terrainSettings = terrainSettings;
_voronoiSettings = voronoiSettings;
_citySettings = citySettings;
_parentGameObject = parent;
//initialize noise
//if no seed is specified generate a random one
if (!terrainSettings.UseSeed)
{
_terrainSettings.GroundSeed = Random.Range(int.MinValue, int.MaxValue);
_terrainSettings.MountainSeed = Random.Range(int.MinValue, int.MaxValue);
_terrainSettings.TreeSeed = Random.Range(int.MinValue, int.MaxValue);
_terrainSettings.DetailSeed = Random.Range(int.MinValue, int.MaxValue);
}
//create noise
_groundNoise = new PerlinNoise(_terrainSettings.GroundSeed);
_treeNoise = new PerlinNoise(_terrainSettings.TreeSeed);
_detailNoise = new PerlinNoise(_terrainSettings.DetailSeed);
//calculate total size of 1 terrain tile based on the city bounds
_terrainSize = (int)(_voronoiSettings.Width * 2f);
_grassLayers = 0;
_meshLayers = 0;
//create the prototypes used by the generator
CreatePrototypes();
}
/// <summary>
/// Initialize base settings
/// </summary>
public void Initialize()
{
//create a town generator object when it doesn't exist yet
if (_townGenerator != null)
{
return;
}
//Access towngenerator
_townGenerator = TownGenerator.GetInstance();
//Set default settings
_generationSettings = new GenerationSettings
{
VoronoiAlgorithm = VoronoiAlgorithm.Fortune,
PointAlgorithm = PointGenerationAlgorithm.CityLike
};
//City settings
_citySettings = new CitySettings();
_citySettings.DebugMode = false;
//Create a base district type
CreatePrefabSelection("Grass");
//Terrain settings editor
_terrainEditor = new TerrainEditor(new TerrainSettings(), this);
//Define a style for the foldout
_foldoutStyle = new GUIStyle(EditorStyles.foldout)
{
fontStyle = FontStyle.Bold,
};
var c = Color.black;
_foldoutStyle.onActive.textColor = c;
_foldoutStyle.normal.textColor = c;
_foldoutStyle.onNormal.textColor = c;
_foldoutStyle.hover.textColor = c;
_foldoutStyle.onHover.textColor = c;
_foldoutStyle.focused.textColor = c;
_foldoutStyle.onFocused.textColor = c;
_foldoutStyle.active.textColor = c;
_foldoutStyle.onActive.textColor = c;
}
/// <summary>
/// Convert an enum MetricSpace to it's corresponding MetricConstraint.
/// </summary>
/// <param name="metric"></param>
/// <param name="settings"></param>
/// <returns></returns>
public static MetricConstraint.MetricConstraint Process(MetricSpace metric, CitySettings settings)
{
MetricConstraint.MetricConstraint m = null;
switch (metric)
{
case MetricSpace.EUCLIDEAN:
m = new EuclideanConstraint(settings);
break;
case MetricSpace.MANHATTAN:
m = new ManhattanConstraint(settings);
break;
case MetricSpace.GRID:
m = new GridConstraint(settings);
break;
}
return(m);
}
/// Generates a voronoi diagram as a basic layout of the town
public void Generate(GenerationSettings generationSettings, CitySettings citySettings,
TerrainSettings terrainSettings)
{
//clean up previous generation and build
Clear();
//save settings
GenerationSettings = generationSettings;
CitySettings = citySettings;
//create a parent object at 0,0,0 if none is set
if (Parent == null)
{
Parent = new GameObject("Town");
Parent.transform.position = Vector3.zero;
}
//Generate the city
GenerateCity();
//set the terrain settings and build the terrain
TerrainTileGenerator.InitializeSettings(terrainSettings, GenerationSettings, Parent, CitySettings);
TerrainTileGenerator.BuildTerrain();
_bCanBuild = true;
if (!_bCanBuild)
{
Debug.LogWarning("CityGenerator: Unable to build city. \nPlease generate data first!");
return;
}
//Build the town
_townBuilder.Initialize(TerrainTileGenerator.CityTerrain, _cityData, TerrainTileGenerator.Settings, Parent,
PrefabsPerZone);
_townBuilder.Build();
}
public MetricConstraint(CitySettings settings)
{
this.settings = settings;
}
public GridConstraint(CitySettings settings) : base(settings)
{
}
public ManhattanConstraint(CitySettings settings) : base(settings)
{
}
public EuclideanConstraint(CitySettings settings) : base(settings)
{
}
private void OnEnable()
{
_settings = GeneratorAssets.Get().CitySettings;
}
