public static House GenerateShack(House house) { BuildingGenerator.GenerateWallsFloorAndEntrance(house.Width, house.Height, house.BuildingObjects, house.BuildingTiles, 0, BuildingStyle.wood); //BuildingGenerator.AddObject(house.BuildingObjects, WorldObject.BED, 2, 1); return(house); }
public void Generate(Vector3[] surroundingPoints) //Should this take in a reference to the surrounding blocks? { if (generationDone == false && pointsSet == true) { //Do generation stuff Vector3[] origins; Vector3 bottomLeftCorner = new Vector3(-blockSize, 0f, -blockSize); Vector3 topRightCorner = new Vector3(blockSize * 2, 0f, blockSize * 2); Mesh[] buildingBases = VoroniMeshGenerator.GenerateVoroniIslands(pointList, surroundingPoints, bottomLeftCorner, topRightCorner, blockSize, blockSize, roadWidth, out origins); for (int i = 0; i < buildingCount; i++) { //Create 3 new buildings, one for the base layer, one for bottom side of top layer and one for top side of top layer BuildingGenerator newBuilding = Instantiate(buildingGeneratorPrefab); newBuilding.transform.SetParent(transform); newBuilding.SetBaseMesh(buildingBases[i], origins[i]); newBuilding.Generate(); Vector3 elevatedOrigin = origins[i] + (Vector3.up * topLayerElevation); //Reposition origin of mesh to be on the upper layer plane newBuilding = Instantiate(buildingGeneratorPrefab); newBuilding.transform.SetParent(transform); newBuilding.SetBaseMesh(buildingBases[i], elevatedOrigin); newBuilding.Generate(true); newBuilding = Instantiate(buildingGeneratorPrefab); newBuilding.transform.SetParent(transform); newBuilding.SetBaseMesh(buildingBases[i], elevatedOrigin); newBuilding.Generate(); } } generationDone = true; }
public static Barracks GenerateBarracks(GenerationRandom genRan, Barracks barr, out BuildingVoxels vox, BuildingGenerationPlan plan) { vox = new BuildingVoxels(barr.Width, World.ChunkHeight, barr.Height); ChooseWallBounds(genRan, barr); BuildingGenerator.ConnectBoundingWall(vox, barr.BoundingWall, Voxel.stone); Tile[,] tileMap = new Tile[barr.Width, barr.Height]; BuildingGenerator.ChooseEntrancePoint(genRan, vox, barr, plan); BuildingGenerator.SetTiles(tileMap, 0, 0, barr.Width / 2, barr.Height - 1, Tile.STONE_FLOOR); BuildingGenerator.SetTiles(tileMap, barr.Width / 2, 0, barr.Width / 2 - 1, barr.Height - 1, Tile.DIRT); List <NPCJob> jobs = new List <NPCJob>(); for (int x = 2; x < barr.Height; x += 3) { Vector3 pos = new Vector3(barr.Width - 2, 0, x); float rotation = Vec2i.Angle(Vec2i.Forward, BuildingGenerator.GetWallPointDirection(barr, new Vec2i(barr.Width - 2, x))); TrainingDummy obj = new TrainingDummy().SetPosition(pos).SetRotation(rotation) as TrainingDummy; if (BuildingGenerator.AddObject(barr, vox, obj)) { jobs.Add(new NPCJobSoldier(barr)); } } WorkBuildingData wbd = new WorkBuildingData(jobs.ToArray()); barr.SetWorkBuildingData(wbd); barr.SetBuilding(tileMap); return(barr); }
public void LoadBuilding(GameObject spawnPoint, BuildingSettings settings) { Building b = BuildingGenerator.Generate(settings); GetComponent <BuildingRenderer>().Render(b, spawnPoint); //Debug.Log(b.ToString()); }
public static Blacksmith GenerateBlacksmith(GenerationRandom genRan, Blacksmith smith, out BuildingVoxels vox, BuildingGenerationPlan plan) { vox = new BuildingVoxels(smith.Width, World.ChunkHeight, smith.Height); ChooseWallBounds(genRan, smith); BuildingGenerator.ConnectBoundingWall(vox, smith.BoundingWall, Voxel.stone); Tile[,] tileMap = new Tile[smith.Width, smith.Height]; //Make the whole floor stone BuildingGenerator.SetTiles(tileMap, 0, 0, smith.Width - 1, smith.Height - 1, Tile.STONE_FLOOR); Vec2i outSideMin = null; Vec2i outSideMax = null; //Find the outdoor part and make the floor dirt for (int i = 0; i < smith.BoundingWall.Length; i++) { Vec2i p = smith.BoundingWall[i]; //If this boundry point does not lie on any of the edges, then it is indented into the //building. This means this point defines the outside region of the building. if ((p.x != 0 && p.x != smith.Width - 1) && (p.z != 0 && p.z != smith.Height - 1)) { //We get the 2 neigboring wall points, as these define the outside region Vec2i nm1 = smith.BoundingWall[(i - 1 + smith.BoundingWall.Length) % smith.BoundingWall.Length]; Vec2i np1 = smith.BoundingWall[(i + 1) % smith.BoundingWall.Length]; int minX = Mathf.Min(p.x, nm1.x, np1.x); int minZ = Mathf.Min(p.z, nm1.z, np1.z); int maxX = Mathf.Max(p.x, nm1.x, np1.x); int maxZ = Mathf.Max(p.z, nm1.z, np1.z); BuildingGenerator.SetTiles(tileMap, minX, minZ, maxX - minX, maxZ - minZ, Tile.DIRT); outSideMin = new Vec2i(minX, minZ); outSideMax = new Vec2i(maxX, maxZ); break; } } smith.SetBuilding(tileMap); PlaceOutsideObjects(genRan, smith, vox, outSideMin, outSideMax); BuildingGenerator.ChooseEntrancePoint(genRan, vox, smith, plan); BuildingGenerator.AddWindow(genRan, vox, smith); BuildingGenerator.AddWindow(genRan, vox, smith); BuildingGenerator.AddWindow(genRan, vox, smith, autoReattempt: false); BuildingGenerator.AddWindow(genRan, vox, smith, autoReattempt: false); BuildingGenerator.PlaceObjectAgainstWall(genRan, new Chest(), 0, vox, smith, .1f, attemptsCount: 20, distToEntr: 4); BuildingGenerator.PlaceObjectAgainstWall(genRan, new WeaponStand(), 0, vox, smith, 0.1f, distToEntr: 4); BuildingGenerator.PlaceObjectAgainstWall(genRan, new ArmourStand(), 0, vox, smith, .1f, distToEntr: 4); WorkBuildingData wbd = new WorkBuildingData(new NPCJob[] { new NPCJobMerchant(smith), new NPCJobBlackSmith(smith), new NPCJobBlackSmith(smith) }); smith.SetWorkBuildingData(wbd); for (int i = 0; i < 10; i++) { smith.Inventory.AddItem(new Shirt(new ItemMetaData().SetColor(Color.blue))); } return(smith); }
public override void OnInspectorGUI() { BuildingGenerator buildingGenerator = (BuildingGenerator)target; EditorGUILayout.LabelField("Cubes Collected:", buildingGenerator.cubeHouses.Length.ToString()); EditorGUILayout.LabelField("Cubes Stored:", buildingGenerator.storedCubes.Length.ToString()); EditorGUILayout.LabelField("Homes Stored:", buildingGenerator.storedHomes.Length.ToString()); GUILayout.BeginHorizontal(); if (GUILayout.Button("Collect CubeHouses", GUILayout.Width(130f))) { buildingGenerator.CollectAllCubes(); } if (GUILayout.Button("Clear Selection", GUILayout.Width(130f))) { buildingGenerator.ClearSelectedCubes(); } GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(); if (GUILayout.Button("Generate Houses", GUILayout.Width(130f))) { buildingGenerator.ConvertToBuilding(); } if (GUILayout.Button("Destroy Homes", GUILayout.Width(130f))) { buildingGenerator.DeleteGeneratedHouses(); } GUILayout.EndHorizontal(); if (GUILayout.Button("Finalize Construction *PERMANENT*", GUILayout.Width(265f))) { buildingGenerator.FinalizeConstruction(); } base.OnInspectorGUI(); }
// Start is called before the first frame update void Start() { Building building = BuildingGenerator.Generate(); GetComponent <BuildingRenderer>().Render(building); Debug.Log(building.ToString()); }
private void Start() { coordGen = gameObject.GetComponent <CoordinateGenerator>(); roadGen = gameObject.GetComponent <RoadGenerator>(); buildingGen = gameObject.GetComponent <BuildingGenerator>(); GenerateRoads(); }
void Awake() { buildingGenerator = FindObjectOfType <BuildingGenerator>(); Instantiate(audioSetPrefab); fireAudioSource = GameObject.Find("Fire Sound").GetComponent <AudioSource>(); waterAudioSource = GameObject.Find("Water Sound").GetComponent <AudioSource>(); cockroachAudioSource = GameObject.Find("Cockroach Sound").GetComponent <AudioSource>(); }
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 override void OnInspectorGUI() { DrawDefaultInspector(); BuildingGenerator buildingGenerator = (BuildingGenerator)target; if (GUILayout.Button("Generate a house")) { buildingGenerator.GeneratePreviewHouse(); } }
public Transform Generate() { var generator = new BuildingGenerator(); generator.SetFacadePlanner(facadePlanner); generator.SetFacadeConstructor(facadeConstructor); generator.SetRoofPlanner(roofPlanner); generator.SetRoofConstructor(roofConstructor); return(generator.Generate(foundationPolygon.vertices, config)); }
private void Awake() { var generator = new BuildingGenerator(); generator.SetFacadePlanner(facadePlanner); generator.SetFacadeConstructor(facadeConstructor); generator.SetRoofPlanner(roofPlanner); generator.SetRoofConstructor(roofConstructor); generator.Generate(foundationPolygon.vertices, config, transform); }
void Start() { this.mapWidth = WorldBuilder.CHUNK_SIZE + 1; this.mapHeight = WorldBuilder.CHUNK_SIZE + 1; terrainGenerator = GameObject.Find("Level").GetComponent <TerrainGenerator>(); buildingGenerator = GameObject.Find("Buildings").GetComponent <BuildingGenerator>(); parentObject = GameObject.Find("CityPoints"); }
// Start is called before the first frame update void Start() { randomNumber = Random.Range(1, 5); buildingGenerator = GetComponentInParent <BuildingGenerator>(); for (int i = 10; i < buildingGenerator.instantiatedBlocks.Count; i++) { if (this.gameObject == buildingGenerator.instantiatedBlocks[i]) { InstantiateFractal(); } } }
public void LoadBuilding() { settings = settingsArray[Random.Range(0, settingsArray.Length)]; SetSize(new Vector2Int(width, depth)); SetHeight(height); Building b = BuildingGenerator.Generate(settings); GetComponent <BuildingRenderer>().Render(b, spawnPoint); explosionSystem.Play(); currentCoroutine = LoadAnimation(); StartCoroutine(currentCoroutine); //Debug.Log(b.ToString()); }
public void Initialise(BuildingGenerator bg) { gridGenerator = bg.gridGenerator; edgelength = gridGenerator.cellSize; generationAllowed = true; //Temporary cellCollider = gridGenerator.getCellCollider(); mainCam = Camera.main; camTransform = mainCam.gameObject.transform; groundCursor = GlobalInformation.groundCursor.transform; viewDistance = GlobalInformation.viewDistance; buildingGenerator = bg; localSeed = GlobalInformation.hash((int)transform.position.x ^ GlobalInformation.hash(GlobalInformation.worldSeed ^ (int)transform.position.z)); initialised = true; }
public static Farm GenerateVegFarm(GenerationRandom genRan, Farm farm, out BuildingVoxels vox, BuildingGenerationPlan plan) { vox = new BuildingVoxels(farm.Width, World.ChunkHeight, farm.Height); Tile[,] tiles = new Tile[farm.Width, farm.Height]; BuildingGenerator.SetTiles(tiles, 0, 0, farm.Width - 1, farm.Height - 1, Tile.TEST_MAGENTA); farm.SetBuilding(tiles); BuildingGenerator.BuildBoundingWallRect(vox, farm.Width, farm.Height, 2, Voxel.stone); BuildingGenerator.ChooseEntrancePoint(genRan, vox, farm, plan, false); return(farm); }
/// <summary> /// Attempts to place generate a building based on <paramref name="bp"/> in the plot specified /// </summary> /// <param name="bp"></param> /// <param name="plot"></param> private bool GenBuildingInPlot(BuildingPlan bp, Plot plot) { Vec2i entrance = GenerationRandom.RandomFromArray(plot.EntranceSides); BuildingGenerationPlan bpPlan = new BuildingGenerationPlan() { BuildingPlan = bp, EntranceSide = entrance, MaxHeight = plot.Bounds.Height, MaxWidth = plot.Bounds.Width }; if (bp.MinSize > plot.Bounds.Width || bp.MinSize > plot.Bounds.Height) { return(false); } Building b = BuildingGenerator.CreateBuilding(GenerationRandom, out BuildingVoxels vox, bpPlan); Vec2i pos = new Vec2i(plot.Bounds.X, plot.Bounds.Y); if (entrance.x == -1) { pos = new Vec2i(plot.Bounds.X, plot.Bounds.Y + GenerationRandom.RandomIntFromSet(0, plot.Bounds.Height - b.Height)); } else if (entrance.x == 1) { pos = new Vec2i(plot.Bounds.X + (plot.Bounds.Width - b.Width), plot.Bounds.Y + GenerationRandom.RandomIntFromSet(0, plot.Bounds.Height - b.Height)); } else if (entrance.z == -1) { pos = new Vec2i(plot.Bounds.X + GenerationRandom.RandomIntFromSet(0, plot.Bounds.Width - b.Width), plot.Bounds.Y); } else if (entrance.z == 1) { pos = new Vec2i(plot.Bounds.X + GenerationRandom.RandomIntFromSet(0, plot.Bounds.Width - b.Width), plot.Bounds.Y + (plot.Bounds.Height - b.Height)); } Recti r = AddBuilding(b, vox, pos); if (r != null) { BuildingPlots.Add(r); return(true); } return(false); }
public FrmMain() { InitializeComponent(); GlobalVariables.Interface_Size = graphicInterface.Size; graphicInterface.Size = GlobalVariables.Interface_Size; timer.Tick += new EventHandler(graphicInterface.OnTick); timer.Interval = GlobalVariables.TIMER_INTERVAL; TimeManager.Init(); buildingGenerator = new BuildingGenerator(); dummyVehicle = GenerateDummyVehicle(1000); dummyPersons = GenerateDummyPersons(1000); busLineGenerator = new BusLineGenerator(buildingGenerator.CenterZoneTopLeft, buildingGenerator.CenterZoneBottomRight, buildingGenerator.PerimeterZoneTopLeft, buildingGenerator.PerimeterZoneBottomRight); dummyBus = busLineGenerator.Buses; graphicInterface.Generate(dummyPersons, buildingGenerator.Buildings, dummyVehicle, dummyBus); SetClockTime(); // ⚠️ dummyDataChart = new List <LineSeries>(); dummyDataChart.Add(new LineSeries { Title = "Infecté(s)", Values = new ChartValues <double>() { 0, 1, 2, 4, 2, 1, 0 } }); crtChart.SetData(dummyDataChart); List <PieSeries> dummyDataPie = new List <PieSeries>(); dummyDataPie.Add(new PieSeries { Title = "Sain(s)", Values = new ChartValues <double>() { 30 } }); dummyDataPie.Add(new PieSeries { Title = "Infecté(s)", Values = new ChartValues <double>() { 1 } }); pieChart.SetData(dummyDataPie); // ⚠️ }
public override void OnInspectorGUI() { BuildingGenerator building = target as BuildingGenerator; if (DrawDefaultInspector()) { building.GenerateBuilding(); } if (GUILayout.Button("Generate building")) { building.GenerateBuilding(); } if (GUILayout.Button("Generate randomized building")) { building.GenerateRandomizedBuilding(); } }
/// <summary> /// Generates the simplest type of house - a shack /// A shack is made of either (cobble?) stone or wood, /// it consists of only 1 room, with basic objects inside (bed, chair, table) /// </summary> /// <param name="house"></param> /// <param name="vox"></param> /// <returns></returns> public static House GenerateShack(GenerationRandom genRan, House house, out BuildingVoxels vox, BuildingGenerationPlan plan) { vox = new BuildingVoxels(house.Width, World.ChunkHeight, house.Height); Tile[,] floor = new Tile[house.Width, house.Height]; BuildingGenerator.BuildBoundingWallRect(vox, house.Width, house.Height, 6, Voxel.wood); //BuildingGenerator.ConnectBoundingWall(vox, house.BoundingWall, Voxel.wood, 5); BuildingGenerator.SetTiles(floor, 0, 0, house.Width - 1, house.Height - 1, Tile.STONE_FLOOR); house.SetBuilding(floor); BuildingGenerator.ChooseEntrancePoint(genRan, vox, house, plan); BuildingGenerator.AddWindow(genRan, vox, house, size: genRan.RandomInt(1, 4), autoReattempt: true); BuildingGenerator.AddWindow(genRan, vox, house, size: genRan.RandomInt(1, 4), autoReattempt: true); BuildingGenerator.AddWindow(genRan, vox, house, size: genRan.RandomInt(1, 4), autoReattempt: false); BuildingGenerator.AddWindow(genRan, vox, house, size: genRan.RandomInt(1, 4), autoReattempt: false); BuildingGenerator.AddWindow(genRan, vox, house, size: genRan.RandomInt(1, 4), autoReattempt: false); house.InsideWallPoints = BuildingGenerator.FindInsideWallBoundryPoints(vox, house); /*foreach (Vec2i v in house.InsideWallPoints) * { * //house.AddObjectReference(new Chest().SetPosition(v)); * WorldObjectData bed = new Bed().SetPosition(v); * bed.SetRotation(Vec2i.Angle(Vec2i.Forward, BuildingGenerator.GetWallPointDirection(house, v))); * if(!house.ObjectIntersects(bed)) * house.AddObjectReference(bed); * }*/ BuildingGenerator.PlaceObjectAgainstWall(genRan, new DoubleBed(), 0, vox, house, .3f, distToEntr: 4, attemptsCount: 40); BuildingGenerator.PlaceObjectAgainstWall(genRan, new Chest(), 0, vox, house, 0.1f, distToEntr: 3, attemptsCount: 40); for (int i = 0; i < house.BoundingWall.Length; i++) { BuildingGenerator.PlaceObjectAgainstWall(genRan, new WallTorch(), 1.5f, vox, house, 0f, requireWallBacking: true); } house.AddExternalObject(new BuildingInternalNoWalkFloor(new Vector3(1, 0, 1), new Vector3(house.Width - 2, 5, house.Height - 2))); BuildingGenerator.AddRoof(genRan, vox, house, Voxel.thatch); BuildingSubworldBuilder b = new BuildingSubworldBuilder(house, vox, plan); b.CreateSubworld(); //ChunkData[,] subChunks = new ChunkData[1, 1]; return(house); }
public void Generate(bool randomizeConfig = true) { if (constantSeed) { Random.InitState(0); } if (randomizeConfig) { GeneratePalette(); config.palette.wallColor = GetMainColor(); } if (generator == null) { generator = new BuildingGenerator(); } if (building != null) { if (Application.isPlaying) { Destroy(building); } else { DestroyImmediate(building); } } generator.SetFacadePlanner(facadePlanner); generator.SetFacadeConstructor(facadeConstructor); generator.SetRoofPlanner(roofPlanner); generator.SetRoofConstructor(roofConstructor); var foundationPolygon = foundationPolygons[currentPolygon]; config.roofConfig.type = roofTypes[currentRoofType]; building = generator.Generate(foundationPolygon.vertices, config).gameObject; var rect = Geometry.GetRect(foundationPolygon.vertices); float platformRadius = Geometry.GetCircumradius(rect) + platformRadiusOffset; var platformDraft = Platform(platformRadius, platformHeight); AssignDraftToMeshFilter(platformDraft, platformMeshFilter, ref platformMesh); }
public void Regenerate() { Debug.Log("Regenerating buildings"); //find all the buildings in the scene foreach (GameObject building in GameObject.FindGameObjectsWithTag("Building")) { buildings.Add(building); } Debug.Log("There are " + buildings.Count + " buildings."); //regenerate blocks in each building foreach (GameObject building in buildings) { BuildingGenerator buildGen = building.GetComponent <BuildingGenerator>(); //first, remove all blocks from each building if (buildGen.temp.Count > 0) { for (int i = buildGen.temp.Count - 1; i >= 0; i--) { GameObject t = buildGen.temp[i]; buildGen.temp.RemoveAt(i); Destroy(t); } } //then generate new blocks for each building buildGen.StartCoroutine("Generate"); //activate car lanes foreach (GameObject carLane in GameObject.FindGameObjectsWithTag("CarLane")) { carLanes.Add(carLane); carLane.GetComponent <CarLane>().spawnActive = true; carLane.GetComponent <CarLane>().StartCoroutine("Spawner"); } } }
void GenerateBuilding(int x, int z) { BuildingGenerator building = GetComponent <BuildingGenerator>(); building.GenerateRandomizedBuilding(); string buildingName = "Building: " + buildingCounter; GameObject.Find("Building").name = buildingName; SetPositionOfBuilding(buildingName, x, z); try { buildings[buildingCounter] = building; } catch (IndexOutOfRangeException) { Debug.LogError("Not enough buildings"); } buildingCounter++; }
private void attemptPlaceHouses(Edge e) { //we try to place a house on both sides of the edge Vector2 edgeMiddle = Vector2.Lerp(e.n1.pos, e.n2.pos, 0.5f); float edgePop = CoordinateHelper.worldToPop(edgeMiddle.x, edgeMiddle.y); float edgeLength = (e.n2.pos - e.n1.pos).magnitude; Vector2 edgeDirection = e.n2.pos - e.n1.pos; Vector2 edgePerpen = new Vector2(edgeDirection.y, -edgeDirection.x); //make sure we place houses only in low pop areas if (edgePop < CityGenerator.skyscraperPopThreshold) { //two iterations (both sides of road), we have -1 and 1 for i for (int i = -1; i <= 1; i += 2) { float width = Mathf.Min(Random.Range(0.65f * edgeLength, 0.87f * edgeLength), CityGenerator.maxHouseWidth); float depth = Random.Range(width / 2.5f, width); int nrOfFloors = (edgePop < (CityGenerator.skyscraperPopThreshold / 2)) ? 1 : 2; Vector2 position = edgeMiddle + (i * edgePerpen.normalized * ((depth / 2) + (CityGenerator.streetWidth / 2) + 4)); Vector2 direction = -i * edgePerpen.normalized; int layerMask1 = 1 << LayerMask.NameToLayer("Edge"); int layerMask2 = 1 << LayerMask.NameToLayer("Building"); int layerMask = layerMask1 | layerMask2; //or operator Vector3 halfExtends = new Vector3((depth / 2) - 1, (nrOfFloors * CityGenerator.floorHeight) / 2, (width / 2) - 1); Vector3 position3D = new Vector3(position.x, CoordinateHelper.worldToTerrainHeight(position), position.y); // not underwater if (position3D.y < 0) { continue; } Vector3 edgeMiddle3D = position3D - new Vector3(edgeMiddle.x, position3D.y, edgeMiddle.y); if (!Physics.CheckBox(position3D, halfExtends, Quaternion.LookRotation(edgeMiddle3D, Vector3.up), layerMask)) { //place the house BuildingGenerator.generateHouse(position, direction, width, depth, nrOfFloors); } } } }
public void Generate() { targetPalette = RandomE.TetradicPalette(0.25f, 0.75f); targetPalette.Add(ColorHSV.Lerp(targetPalette[2], targetPalette[3], 0.5f)); var buildingDraft = BuildingGenerator.BuildingDraft(width, length, floorCount, hasAttic, targetPalette[0].WithS(0.8f).WithV(0.8f).ToColor()); var buildingMesh = buildingDraft.ToMesh(); buildingMesh.RecalculateBounds(); buildingMeshFilter.mesh = buildingMesh; float buildingRadius = Mathf.Sqrt(length / 2f * length / 2f + width / 2f * width / 2f); float platformRadius = buildingRadius + platformRadiusOffset; var platformMesh = Platform(platformRadius, platformBaseOffset, platformSegments, platformHeight).ToMesh(); platformMesh.RecalculateBounds(); platformMeshFilter.mesh = platformMesh; }
private void PlaceBuildings(List <BuildingPlan> buildings) { foreach (BuildingPlan bp in buildings) { Building b = BuildingGenerator.CreateBuilding(bp); Recti r = null; int i = 0; while (r == null && i < 5) { r = AddBuilding(b); i++; } if (r == null) { continue; } this.Buildings.Add(b); //SurroundByPath(r.X, r.Y, r.Width, r.Height, 2); SettlementPathNode[] nodes = AddPlot(r); } }
private void Awake() { var generator = new BuildingGenerator(); generator.SetFacadePlanner(facadePlanner); generator.SetFacadeConstructor(facadeConstructor); generator.SetRoofPlanner(roofPlanner); generator.SetRoofConstructor(roofConstructor); float xOffset = (xCount - 1) * 0.5f * cellSize; float zOffset = (zCount - 1) * 0.5f * cellSize; for (int z = 0; z < zCount; z++) { for (int x = 0; x < xCount; x++) { config.roofConfig.type = RandomE.GetRandom(RoofType.Flat, RoofType.Hipped, RoofType.Gabled); var building = generator.Generate(foundationPolygon.vertices, config); building.position = new Vector3(x * cellSize - xOffset, 0, z * cellSize - zOffset); } } }
private static void PlaceOutsideObjects(GenerationRandom genRan, Blacksmith smith, BuildingVoxels vox, Vec2i outMin, Vec2i outMax) { List <WorldObjectData> toPlace = new List <WorldObjectData>(new WorldObjectData[] { new Anvil(), new Anvil() }); bool isFinished = false; while (!isFinished) { WorldObjectData toPlaceCur = toPlace[0]; toPlace.RemoveAt(0); Vector3 pos = genRan.RandomVector3(outMin.x, outMax.x, 0, 0, outMin.z, outMax.z); toPlaceCur.SetPosition(pos); while (!BuildingGenerator.AddObject(smith, vox, toPlaceCur)) { pos = genRan.RandomVector3(outMin.x, outMax.x, 0, 0, outMin.z, outMax.z); toPlaceCur.SetPosition(pos); } if (toPlace.Count == 0) { isFinished = true; } } }