public override List <ILayout> Plan(List <Vector2> foundationPolygon, BuildingGenerator.Config config)
{
SetupConstructors(config.palette);
var layouts = new List <ILayout>();
for (int i = 0; i < foundationPolygon.Count; i++)
{
Vector2 a = foundationPolygon.GetLooped(i + 1);
Vector2 aNext = foundationPolygon.GetLooped(i + 2);
Vector2 b = foundationPolygon[i];
Vector2 bPrevious = foundationPolygon.GetLooped(i - 1);
float width = (b - a).magnitude;
bool leftIsConvex = Geometry.GetAngle(b, a, aNext) <= 180;
bool rightIsConvex = Geometry.GetAngle(bPrevious, b, a) <= 180;
if (i == 0)
{
layouts.Add(PlanEntranceFacade(width, config.floors, config.entranceInterval, config.hasAttic, leftIsConvex, rightIsConvex));
}
else
{
layouts.Add(PlanNormalFacade(width, config.floors, config.hasAttic, leftIsConvex, rightIsConvex));
}
}
return(layouts);
}
// TODO: I dont like the use of Instance, in the future maybe I will create a class called regions, and depending at which zone you are, it will load the info of the City instance
static City()
{
if (DefaultBuildConfig == null)
{
DefaultBuildConfig = new BuildingGenerator.Config(); // TODO: Random?
}
}
private static BuildingGenerator GenerateBuilding(int buildingIndex, BuildingGenerator.Config config, out Transform generatedBuild)
{
var builds = GameObject.Find("Builds");
if (builds == null)
{
builds = new GameObject("Builds");
}
var build = new GameObject("Build");
build.transform.parent = builds.transform;
var building = MapGenerator.CityModel.buildings.ElementAt(buildingIndex);
var height = BuildingPlanner.Instance.buildHeightCurve.GetBuildHeight(building.GetWeight());
if (config == City.DefaultBuildConfig)
{
City.DefaultBuildConfig.floors = (int)height;
}
var generator = new BuildingGenerator();
{
generator.SetFacadeConstructor(BuildingPlanner.Instance.proceduralFacadeConstructor);
generator.SetFacadePlanner(BuildingPlanner.Instance.proceduralFacadePlanner);
generator.SetRoofConstructor(BuildingPlanner.Instance.proceduralRoofConstructor);
generator.SetRoofPlanner(BuildingPlanner.Instance.proceduralRoofPlanner);
var foundationPoints = building.Pol.Edges.Select(x => CityGenerator.SConv.ConvertVector(x));
var orientation = Geometry.GetOrientation(foundationPoints.ToList());
if (orientation == Orientation.CounterClockwise)
{
foundationPoints = foundationPoints.Reverse();
}
var foundationList = foundationPoints.ToList();
generatedBuild = generator.Generate(foundationList, config,
build.transform);
var roof = generatedBuild.GetChild(0);
var facade = generatedBuild.GetChild(1);
var roofMesh = roof.gameObject.GetComponent <MeshFilter>().sharedMesh;
var facadeMesh = facade.gameObject.GetComponent <MeshFilter>().sharedMesh;
var roofCollider = roof.gameObject.AddComponent <MeshCollider>();
roofCollider.sharedMesh = roofMesh;
var facadeCollider = facade.gameObject.AddComponent <MeshCollider>();
facadeCollider.sharedMesh = facadeMesh;
}
build.transform.position = City.GetBuildingCenter(building);
return(generator);
}
public static void CreateBuildings(Chunk c, BuildingGenerator.Config config)
{
//foreach (var bIndex in c.listOfIndexBuildings)
// yield return CreateBuild(bIndex);
foreach (var bIndex in c.listOfIndexBuildings)
{
MapGenerator.CityModel.buildingGenerators.Add(GenerateBuilding(bIndex, config));
}
}
public override IConstructible <MeshDraft> Plan(List <Vector2> foundationPolygon, BuildingGenerator.Config config)
{
switch (config.roofConfig.type)
{
case RoofType.Flat:
return(new ProceduralFlatRoof(foundationPolygon, config.roofConfig, config.palette.roofColor));
case RoofType.Hipped:
return(new ProceduralHippedRoof(foundationPolygon, config.roofConfig, config.palette.roofColor));
case RoofType.Gabled:
return(new ProceduralGabledRoof(foundationPolygon, config.roofConfig, config.palette.roofColor));
default:
throw new ArgumentOutOfRangeException();
}
}
private static BuildingGenerator GenerateBuilding(int buildingIndex, BuildingGenerator.Config config)
{
return(GenerateBuilding(buildingIndex, config, out _));
}
