static void Main(string[] args)
{
int seed = System.Environment.TickCount;
int timeStart = System.Environment.TickCount;
float ratio = 0.3f;
Console.Out.WriteLine("Seed: " + seed);
Console.Out.WriteLine();
Console.Out.WriteLine("Without Connecting Rooms");
CaveGenerator caveFactory = new CaveGenerator(79, 50, seed, ratio);
caveFactory.GenerateMap(false);
PrintMap(caveFactory);
Console.Out.WriteLine("With Connecting Rooms");
caveFactory = new CaveGenerator(79, 50, seed, ratio);
caveFactory.GenerateMap(true);
PrintMap(caveFactory);
Console.Out.WriteLine();
Console.Out.WriteLine("Time To Generate: " + ((System.Environment.TickCount - timeStart) / 1000).ToString() + "s");
Console.In.ReadLine();
}
static void Main(string[] args)
{
int mapWidth, mapHeight, fillPercent;
if (args.Length < 3)
{
Console.WriteLine("Usage: *.exe <width> <height> <fill%>");
return;
}
else
{
mapWidth = Int32.Parse(args[0]);
mapHeight = Int32.Parse(args[1]);
fillPercent = Int32.Parse(args[2]);
}
CaveGenerator caveGenerator = new CaveGenerator();
Renderer renderer = new Renderer();
ImageRenderer imageRenderer = new ImageRenderer();
int[] playerPos = { 0, 0 };
byte[,] mapContent = new byte[mapWidth, mapHeight];
bool[,] map = new bool[mapWidth, mapHeight];
caveGenerator.GenerateCave(ref map, ref mapContent, 2, fillPercent);
// caveGenerator.SpawnPlayer(ref map, ref mapContent, ref playerPos);
// renderer.DrawMap(ref map, ref mapContent);
Console.WriteLine("Rendering image...");
imageRenderer.DrawMap(ref mapContent);
Console.WriteLine("Done.");
return;
}
void Start()
{
knownColors.Add(Color.yellow);
knownColors.Add(Color.black);
knownColors.Add(Color.blue);
knownColors.Add(Color.cyan);
knownColors.Add(Color.gray);
knownColors.Add(Color.green);
knownColors.Add(Color.magenta);
knownColors.Add(Color.red);
knownColors.Add(Color.white);
//???? idunno maine
knownColors.Add(new Color(0.2f, 0.1f, 0.6f));
knownColors.Add(new Color(0.6f, 0.2f, 0.1f));
knownColors.Add(new Color(0.2f, 0.6f, 0.1f));
knownColors.Add(new Color(0.2f, 0.9f, 0.5f));
knownColors.Add(new Color(0.2f, 0.5f, 0.9f));
knownColors.Add(new Color(0.5f, 0.9f, 0.2f));
objContainer = GameObject.Find("ObjectContainer").GetComponent <ObjectContainer>();
player = GameObject.Find("Player");
caveGenerator = new CaveGenerator(randomFillPercent, automataIterations, groundTile, wallTile);
GenerateRoomContainers();
GenerateRooms();
GenerateLevel();
}
private void OnEnable()
{
caveGenerator = new CaveGenerator();
areAdvancedOptionsActive = new AnimBool(false, Repaint);
texture = new Texture2D(mapwidth, mapHeight);
wallsMaterial = AssetDatabase.LoadAssetAtPath(CaveGeneratorUtilities.CaveSave.RootFolderPath + "/Materials/DefaultCaveWalls.mat", typeof(Material)) as Material;
groundMaterial = AssetDatabase.LoadAssetAtPath(CaveGeneratorUtilities.CaveSave.RootFolderPath + "/Materials/DefaultCaveGround.mat", typeof(Material)) as Material;
}
public override void OnInspectorGUI()
{
CaveGenerator room = target as CaveGenerator;
if (DrawDefaultInspector())
{
room.GenerateMap();
}
}
private IEnumerator DestroyLevel()
{
yield return(new WaitForEndOfFrame());
CaveGenerator caveGen = FindObjectOfType <CaveGenerator>();
GrammarGenerator grammarGen = FindObjectOfType <GrammarGenerator>();
caveGen.ClearAll();
grammarGen.ClearAll();
}
private void GenerateMap()
{
if (mapType == MapType.Forest)
{
ForestGenerator forestGen = new ForestGenerator(mapData);
}
if (mapType == MapType.Cave)
{
CaveGenerator caveGen = new CaveGenerator(mapData);
}
}
void GenerateCave()
{
CaveGenerator caveGenerator = terrain.GetComponent <CaveGenerator>();
caveGenerator.Generate();
CaveGenerator.Point?point = caveGenerator.FindNearestSpace(caveGenerator.currentMap, new CaveGenerator.Point(0, 0)); //Find nearest clear point to bottom corner of map
if (point.HasValue)
{
player.position = new Vector3(point.Value.x, point.Value.y, player.position.z) + terrain.position; //Terrain transform may not be at zero so map coordinates will be offset by its position
}
}
private void GenerateMap()
{
if (mapType == MapType.Forest)
{
ForestGenerator forestGen = new ForestGenerator(mapData);
}
if (mapType == MapType.Cave)
{
CaveGenerator caveGen = new CaveGenerator(mapData);
}
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
CaveGenerator c = (CaveGenerator)target;
if (GUILayout.Button("Generate"))
{
c.Generate();
}
}
void Start()
{
//To get the same random numbers each time we run the script
Random.InitState(100);
caveGenerator = new CaveGenerator(randomFillPercent, gridSize);
caveGenerator.RandomizeMap();
//For testing that init is working
GenerateAndDisplayTexture(caveGenerator.GetMap());
//Start the simulation
StartCoroutine(SimulateCavePattern());
}
// Use this for initialization
void Start()
{
// generate cave
caveGenerator = GetComponent <CaveGenerator>();
caveGenerator.GenerateCave();
// generate player
player = caveGenerator.GeneratePlayer();
cameraController.player = player.gameObject; // set camera to follow player
string[] percepts = caveGenerator.GetCaveInfluence(curRoom.row, curRoom.col);
PrintPercepts(percepts);
}
/// <summary>
/// Set up a scene.
/// </summary>
/// <param name="level"> Level id. </param>
/// <param name="gen"> Generator for custom level. </param>
public void SetupScene(int level, IMapGenerator gen = null)
{
IMapGenerator levelGenerator = gen;
if (levelGenerator == null)
{
GameLogger.LogMessage("Custom generator is null", "LevelManager");
if (level == 5)
{
GameLogger.LogMessage("Boss level selected", "LevelManager");
levelGenerator = new ReaderGenerator("Levels/NewBossLevel");
}
else
{
levelGenerator = new CaveGenerator(150, 150);
}
}
GameLogger.LogMessage($"Current level: {level}", "LevelManager");
this.currentLevel = new Level(levelGenerator, level);
this.currentLevel.AddFloorAsset(this.caveFloor, MapObject.Floor);
this.currentLevel.AddObjectAsset(this.caveGoldOre, MapObject.GoldOre);
this.currentLevel.AddObjectAsset(this.cavePurpleOre, MapObject.HealOre);
this.currentLevel.AddObjectAsset(this.caveBlockage, MapObject.Blockage);
this.currentLevel.AddObjectAsset(this.enemyFighterSpawner, MapObject.EnemyFighterSpawner);
this.currentLevel.AddObjectAsset(this.enemyFighter, MapObject.EnemyFighter);
this.currentLevel.AddObjectAsset(this.enemySuiciderSpawner, MapObject.EnemySuiciderSpawner);
this.currentLevel.AddObjectAsset(this.enemySuicider, MapObject.EnemySuicider);
this.currentLevel.AddObjectAsset(this.enemyBomberSpawner, MapObject.EnemyBomberSpawner);
this.currentLevel.AddObjectAsset(this.enemyBomber, MapObject.EnemyBomber);
this.currentLevel.AddObjectAsset(this.enemyBoss, MapObject.EnemyFlagman);
this.currentLevel.AddWallAsset(this.caveWall, MapObject.Wall);
this.currentLevel.AddWallAsset(this.caveGoldOre[0], MapObject.GoldOre);
this.currentLevel.AddWallAsset(this.cavePurpleOre[0], MapObject.HealOre);
this.currentLevel.AddWallAsset(this.caveBlockage[0], MapObject.Blockage);
GameLogger.LogMessage("Assets added", "LevelManager");
this.LevelSetup(this.currentLevel);
}
static void Main(string[] args)
{
CaveGenerator caveGenerator = new CaveGenerator(0.3f, 10);
caveGenerator.RandomizeMap();
for (int i = 0; i < 10; ++i)
{
print(caveGenerator.GetMap());
Console.ReadKey();
caveGenerator.SmoothMap();
}
Console.WriteLine("End CaveGenerator Test");
}
void CreatePrefab(CaveGenerator caveGenerator)
{
Cave cave = caveGenerator.ExtractCave();
Assert.IsNotNull(cave, "Internal error: extracted null cave.");
string path = CreateFolder(ROOT_FOLDER, CAVE_FOLDER);
CreateMeshAssets(cave.GetFloors(), FLOOR_FOLDER, path);
CreateMeshAssets(cave.GetCeilings(), CEILING_FOLDER, path);
CreateMeshAssets(cave.GetWalls(), WALL_FOLDER, path);
CreateCavePrefab(cave.GameObject, path);
Destroy(cave.GameObject);
}
private IEnumerator PerformRegen()
{
yield return(new WaitForEndOfFrame());
CaveGenerator caveGen = FindObjectOfType <CaveGenerator>();
GrammarGenerator grammarGen = FindObjectOfType <GrammarGenerator>();
caveGen.Generate();
grammarGen.Generate();
earnedLevelLife = false;
Respawn();
loadSplash.SetActive(false);
gameState = GameState.PLAYING;
regenQueued = false;
}
private void MapGeneration()
{
CaveGeneratorFactory factory = new CaveGeneratorFactory();
ThreeTierCaveConfiguration ttcc = new ThreeTierCaveConfiguration();
ttcc.CaveType = ThreeTierCaveType.Enclosed;
AKSaigyouji.Modules.HeightMaps.HeightMapRocky ceiling_gen = new AKSaigyouji.Modules.HeightMaps.HeightMapRocky();
AKSaigyouji.HeightMaps.LayeredNoiseParameters ceiling_param = new AKSaigyouji.HeightMaps.LayeredNoiseParameters();
ceiling_param.SetHeightRange(MIN_WALL, MAX_WALL);
ceiling_param.SetSmoothness(10);
ceiling_param.SetLayers(4, 0.5f, 2f);
ceiling_gen.Properties = ceiling_param;
ttcc.CeilingHeightMapModule = ceiling_gen;
ttcc.CeilingMaterial = ceiling;
AKSaigyouji.Modules.HeightMaps.HeightMapConstant floor_gen = new AKSaigyouji.Modules.HeightMaps.HeightMapConstant();
floor_gen.Height = 0;
ttcc.FloorHeightMapModule = floor_gen;
ttcc.FloorMaterial = floor;
ttcc.WallModule = new AKSaigyouji.Modules.CaveWalls.CaveWallFlat();
ttcc.WallMaterial = wall;
AKSaigyouji.Modules.MapGeneration.MapGenCellAutomata map_gen = new AKSaigyouji.Modules.MapGeneration.MapGenCellAutomata();
AKSaigyouji.Modules.MapGeneration.MapParameters param = new AKSaigyouji.Modules.MapGeneration.MapParameters
{
Length = 100,
Width = 100,
InitialDensity = 0.5f,
ExpandTunnels = true,
BorderSize = 1,
MinWallSize = 15,
MinFloorSize = 15
};
map_gen.Properties = param;
ttcc.MapGenerator = map_gen;
ttcc.Scale = 2;
ttcc.SetSeed(seed);
CaveGenerator cg = factory.BuildThreeTierCaveGen(ttcc);
//CaveGenerator cg = new MyCaveGenerator(ttcc);
GameObject map = cg.Generate();
}
// Use this for initialization
void Start () {
//getting components
if(prev)
{
prevCaveGenerator = prev.GetComponent<CaveGenerator>();
//prevHillGenerator = prev.GetComponent<HillGenerator>();
prevPlatformGenerator = prev.GetComponent<PlatformGenerator>();
}
caveGenerator = terrain.GetComponent<CaveGenerator>();
//hillGenerator = terrain.GetComponent<HillGenerator>();
platformGenerator = terrain.GetComponent<PlatformGenerator>();
nextCaveGenerator = next.GetComponent<CaveGenerator>();
//nextHillGenerator = next.GetComponent<HillGenerator>();
nextPlatformGenerator = next.GetComponent<PlatformGenerator>();
GenerateAll();
}
private void Update()
{
if (Player.transform.position.x > gridSize - 1 && Player.transform.position.y > gridSize - 1)
{
float addgrid = (float)gridSize * ((float)growMap / 100);
gridSize += (int)addgrid;
//Debug.Log("addgrid size is: " + addgrid);
// Debug.Log("grid size is: "+gridSize);
caveGenerator = new CaveGenerator(randomFillPercent, gridSize);
//Calculate the new values
caveGenerator.RandomizeMap();
caveGenerator.SmoothMap(gridSize);
//Generate texture and display it on the plane
GenerateAndDisplayTexture(caveGenerator.GetMap());
Player.transform.position = new Vector3(2.16f, 1.47f, 0);
}
}
public static void PrintMap(CaveGenerator map)
{
for (int row = 1; row <= map.Map.Rows; row++)
{
for (int column = 1; column <= map.Map.Columns; column++)
{
if (map.Map.GetTile(column, row) == CaveGenerator.TileWall || map.Map.GetTile(column, row) == CaveGenerator.TilePermanantWall)
{
Console.Write("#");
}
else
{
Console.Write(".");
}
} //column
Console.Write(System.Environment.NewLine);
} //row
} // PrintGrid
public void CreatePrefab(CaveGenerator caveGenerator)
{
GameObject cave = caveGenerator.ExtractCave();
if (cave == null)
{
Debug.Log("Cavegenerator: no cave object found!");
return;
}
string guid = AssetDatabase.CreateFolder("Assets", "GeneratedCave");
string path = AssetDatabase.GUIDToAssetPath(guid) + "/";
foreach (MapMeshes meshes in caveGenerator.GeneratedMeshes)
{
CreateMeshAssets(meshes, path);
}
CreateCavePrefab(path, cave);
Destroy(cave);
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
CaveGenerator caveGenerator = (CaveGenerator)target;
if (Application.isPlaying)
{
if (GUILayout.Button("Generate New Map"))
{
caveGenerator.GenerateCave();
}
if (GUILayout.Button("Create Prefab"))
{
CreatePrefab(caveGenerator);
}
}
}
public override void OnInspectorGUI()
{
DrawProperties();
serializedObject.ApplyModifiedProperties();
CaveGenerator caveGenerator = (CaveGenerator)target;
if (Application.isPlaying)
{
if (GUILayout.Button("Generate New Map"))
{
caveGenerator.Generate();
}
if (GUILayout.Button("Create Prefab"))
{
CreatePrefab(caveGenerator);
}
}
}
void OnTriggerEnter2D(Collider2D col)
{
if(col.gameObject.CompareTag("Player"))
{
Debug.Log("Player passed trigger");
if(prev)
{
Destroy(prev.gameObject);
}
prev = terrain;
terrain = next;
transform.position += new Vector3(36f, 0f, 0f);
GameObject nextGO = (GameObject)Instantiate(terrainPrefab, transform.position, Quaternion.identity);
next = nextGO.transform;
nextCaveGenerator = next.GetComponent<CaveGenerator>();
//nextHillGenerator = next.GetComponent<HillGenerator>();
nextPlatformGenerator = next.GetComponent<PlatformGenerator>();
nextCaveGenerator.Generate();
nextPlatformGenerator.Append();
}
}
private void OnCollisionEnter2D(Collision2D collision)
{
if (collision.gameObject.CompareTag("Enemy"))
{
Destroy(gameObject);
}
else if (collision.gameObject.GetComponent <Tilemap>())
{
Vector3 hitPos = Vector3.zero;
CaveGenerator cave = FindObjectOfType <CaveGenerator>();
foreach (ContactPoint2D hit in collision.contacts)
{
hitPos.x = hit.point.x - 0.01f * hit.normal.x;
hitPos.y = hit.point.y - 0.01f * hit.normal.y;
cave.TryDestroyTile(hitPos);
}
Destroy(gameObject);
}
}
public void forestgen_allSequence()
{
CaveGenerator gen = new CaveGenerator();
gen.setMapSize(40, 40);
gen.setRoomsNumberRange(3, 3);
gen.setRoomSizeRange(12, 15);
gen.setCorridorLengthRange(5, 7);
gen.setCorridorWidthRange(1, 3);
gen.setSeed(123456);
gen.setCellularFillChance(80);
gen.setCellularSmoothingSteps(5);
gen.setMapMargin(2);
gen.setPlotter(new Forest012Plotter());
CaveBoard board = gen.asBoard();
Assert.AreEqual(5, board.all().Length);
Assert.AreEqual("RectShape", board.all()[0].GetType().ToString());
Assert.AreEqual("FreeShape", board.all()[1].GetType().ToString());
Assert.AreEqual("RectShape", board.all()[2].GetType().ToString());
Assert.AreEqual("FreeShape", board.all()[3].GetType().ToString());
Assert.AreEqual("ElliShape", board.all()[4].GetType().ToString());
}
void Awake()
{
main = this;
}
private static BlockPrototype[][] generateWorld(int width, int height)
{
BlockPrototype[][] world = new BlockPrototype[width][];
for (int i = 0; i < width; i++)
{
world[i] = new BlockPrototype[height];
}
/*for (int i = 0; i < width; i++) {
* for (int j = 10; j < height; j++) {
* world[i][j] = BlockPrototype.grass;
* }
* }
* for (int i = 0; i < width; i++) {
* for (int j = 0; j < height; j++) {
* if (world[i][j] == null) {
* world[i][j] = BlockPrototype.air;
* }
* }
* }*/
int level = 250;
List <int> results = new List <int>();
Random random = new Random();
int index = 0;
int timesSinceLastTree = 0;
int sandTime = 0;
foreach (BlockPrototype[] blocks in world)
{
index++;
int rand = random.Next(18);
results.Add(rand);
if (rand <= 4)
{
level++;
}
else if (rand > 11)
{
level--;
} //Otherwise, make no change.
if (level > 450)
{
level = 345;
}
if (level < 20)
{
level = 40;
}
if (random.Next(20) > 18)
{
sandTime = (random.Next(10));
}
if (sandTime > 0)
{
sandTime--;
blocks[level] = BlockPrototype.sand;
}
else
{
blocks[level] = BlockPrototype.grass;
}
int blocksDown = 0;
for (int i = level; i < height; i++)
{
blocksDown++;
if (blocksDown == 1)
{
//Possibility of generating tree
//Tore it out, replacing with better algorithm (again)
/*blocks[i] = BlockPrototype.grass;
* if (random.Next(40) > 35) {
* blocks[i] = BlockPrototype.log;
* int treeHeight = random.Next(6, 20);
* for (int j = i - 1; j > (i - treeHeight); j--) {
* blocks[j] = BlockPrototype.log;
* if (random.Next(10) > 7) {
* if(index > (width - 5)) {
* continue;
* }
* world[index][j] = BlockPrototype.log;
* }
* if (random.Next(10) < 3) {
* try {
* world[index - 1][j] = BlockPrototype.log;
* } catch (Exception e) {
* //It happens
* }
* }
* }
* }*/
//Possibility of generating a tree
try {
if (random.Next(40) > 36)
{
if (timesSinceLastTree > 8)
{
char[][] tree = TreeGenerator.getRandomTree();
for (int j = 0; j < tree.Count(); j++)
{
for (int k = 0; k < tree[j].Count(); k++)
{
if (tree[j][k] == ' ')
{
continue;
}
else if (tree[j][k] == 'g')
{
world[index + j][i - k] = BlockPrototype.leaves;
}
else if (tree[j][k] == 'L')
{
world[index + j][i - k] = BlockPrototype.log;
}
}
}
}
timesSinceLastTree = 0;
}
else
{
timesSinceLastTree++;
}
} catch (IndexOutOfRangeException e) {
//It happens, but we'll end up with a pretty messed up tree
}
}
else if (sandTime > 0 && blocksDown < 4 && random.Next(100) > 20)
{
blocks[i] = BlockPrototype.sand;
}
else if (blocksDown < 8)
{
blocks[i] = BlockPrototype.dirt;
}
else
{
/*if (random.Next(40) > 38) {
* blocks[i] = BlockPrototype.oreCoal;
* } else if (random.Next(100) > 98) {
* blocks[i] = BlockPrototype.ironOre;
* } else {*/
blocks[i] = BlockPrototype.stone;
//}
}
}
for (int i = 0; i < blocks.Count(); i++)
{
if (blocks[i] == null)
{
blocks[i] = BlockPrototype.air;
}
}
/*for (int i = height - 1; i > 0; i--) {
* if (blocks[i] == BlockPrototype.air && random.Next(100) == 3) {
* int treeHeight = 6;
* for (int j = i + i; j > (i - treeHeight); j--) {
* if (j >= height) {
* continue;
* }
* blocks[j] = BlockPrototype.log;
* if (random.Next(4) > 3) {
* world[index + 1][j] = BlockPrototype.log;
* }
* if (random.Next(4) < 2) {
* world[index - 1][j] = BlockPrototype.log;
* }
* }
* }
* if (blocks[i] == BlockPrototype.air) {
* break;
* }
* }*/
}
/*int ind = 0; //Standing for index, but apparently index is already defined
* foreach (BlockPrototype[] blocks in world) { //Generate leaves
* ind++;
* for (int i = 0; i < blocks.Count(); i++) {
* try {
* if (world[ind][i] == BlockPrototype.log && random.Next(4) > 2 && world[ind - 2][i] == BlockPrototype.air) {
* blocks[i] = BlockPrototype.leaves;
* }
* if (world[ind - 2][i] == BlockPrototype.log && random.Next(4) > 2 && world[ind][i] == BlockPrototype.air) {
* blocks[i] = BlockPrototype.leaves;
* }
* } catch (Exception e) {
* //Do nothing, it happens
* }
* }
* }
* ind = 0;
* foreach (BlockPrototype[] blocks in world) { //Generate leaves for the second time
* ind++;
* for (int i = 0; i < blocks.Count(); i++) {
* try {
* if ((world[ind][i] == BlockPrototype.log || world[ind][i] == BlockPrototype.leaves) && random.Next(4) > 2 && world[ind][i] == BlockPrototype.air) {
* blocks[i] = BlockPrototype.leaves;
* }
* if ((world[ind - 2][i] == BlockPrototype.log || world[ind - 2][i] == BlockPrototype.leaves) && random.Next(4) > 2 && world[ind - 2][i] == BlockPrototype.air) {
* blocks[i] = BlockPrototype.leaves;
* }
* } catch (Exception e) {
* //Do nothing, it happens
* }
* }
* }*/
/*if (false) { //Ore generation is disabled
* veinBlocks.Add(BlockPrototype.oreCoal, 3);
* veinBlocks.Add(BlockPrototype.dirt, 10);
* veinBlocks.Add(BlockPrototype.ironOre, 2);
* int ind = 0;
* LoadingForm lf = new LoadingForm();
* lf.Show();
* int blocksToGo = world.Count();
* foreach (BlockPrototype[] blocks in world) {
* lf.setProgress("Generating Ores...", (int)((((double)ind) / ((double)blocksToGo)) * 100D));
* ind++;
* if (ind % 50 != 0) {
* continue;
* }
* for (int i = 0; i < blocks.Count(); i++) {
* if (CaveGenerator.random.Next(200) < 199) {
* continue;
* }
* BlockPrototype generatedOre = null;
* int num = CaveGenerator.random.Next(veinBlocks.Count);
* int k = 0;
* foreach (KeyValuePair<BlockPrototype, int> pair in veinBlocks) {
* k++;
* if (k >= num) {
* generatedOre = pair.Key;
* break;
* }
* }
* if (generatedOre == null) {
* continue;
* }
* if (blocks[i] == BlockPrototype.stone) {
* for (int j = 0; j < veinBlocks[generatedOre]; j++) {
* int xDiff = CaveGenerator.random.Next(20) - 10;
* int yDiff = CaveGenerator.random.Next(10) - 5;
* try {
* //if (i < 2 || world[ind + xDiff - 1][i + yDiff] == generatedOre || world[ind + xDiff + 1][i + yDiff] == generatedOre || world[ind + xDiff][i + yDiff - 1] == generatedOre || world[ind + xDiff][i + yDiff + 1] == generatedOre) {
* world[ind + xDiff][i + yDiff] = generatedOre;
* /*} else {
* j--;
* continue;
* }* / //<-- I made this not an uncomment for technical reasons
* } catch (IndexOutOfRangeException e) {
* break;
* }
* }
* }
* i += 25;
* }
* }
* }*/
/*veinBlocks.Add(BlockPrototype.oreCoal, 3);
* veinBlocks.Add(BlockPrototype.dirt, 10);
* veinBlocks.Add(BlockPrototype.ironOre, 2);
* for (int i = 0; i < world.Count(); i++) {
* for (int j = 0; j < world[i].Count(); j++) {
* if (random.Next(100) > 98) {
* //Decide which block to place
* int total = 0;
* foreach (BlockPrototype prototype in veinBlocks) {
*
* }
* }
* }
* }*/
CaveGenerator.generateCaves(world);
return(world);
}
public RenderContext(RenderEvent renderEvent, object data, CaveGenerator parent)
{
Event = renderEvent;
Data = data;
Parent = parent;
}
// START:
/// <summary>
/// Start this instance.
/// </summary>
public void Start()
{
// Get the components
dungeonGenerator = GetComponent<DungeonGenerator> ();
sceneryGenerator = GetComponent<SceneryGenerator> ();
stairsGenerator = GetComponent<StairsGenerator> ();
roomGenerator = GetComponent<RoomGenerator> ();
perimeterGenerator = GetComponent<PerimeterGenerator> ();
entranceGenerator = GetComponent<EntranceGenerator> ();
corridorGenerator = GetComponent<CorridorGenerator> ();
voidGenerator = GetComponent<VoidGenerator> ();
pitGenerator = GetComponent<PitGenerator> ();
chestGenerator = GetComponent<ChestGenerator> ();
caveGenerator = GetComponent<CaveGenerator> ();
terrainCarver = GetComponent<TerrainCarver> ();
terrainGenerator = GetComponent<TerrainGenerator> ();
textureGenerator = GetComponent<TerrainTextureGenerator> ();
// Initialize the instances
stairsGenerator.Start ();
roomGenerator.Start ();
perimeterGenerator.Start ();
entranceGenerator.Start ();
corridorGenerator.Start ();
voidGenerator.Start ();
pitGenerator.Start ();
chestGenerator.Start ();
caveGenerator.Start ();
terrainCarver.Start ();
terrainGenerator.Start ();
textureGenerator.Start ();
// Initialize the floor array
allFloors = new Floor[dungeonGenerator.numFloors];
}
void Awake()
{
_generator = new CaveGenerator();
_renderer = CaveRenderer.newInstance(this);
}
void OnGUI()
{
//Create required setup fields
width = EditorGUILayout.IntField("CaveMap Width : ", width);
height = EditorGUILayout.IntField("CaveMap Height : ", height);
fillProbability = EditorGUILayout.IntSlider("Wall Percent : ", fillProbability, 1, 100, GUILayout.MinWidth(100));
//Threshold for walls - Autoadjusts to new width & height for reasonable value
threshold = EditorGUILayout.IntSlider("Threshold : ", threshold, 1, (width * height) / 3, GUILayout.MinWidth(100));
//Set seed to "0" for random generation or any number other than "0" to be able to regenerate cave next time
seed = EditorGUILayout.IntField("Seed : ", seed);
//Button to Generate Cave
if (GUILayout.Button("Generate Cave"))
{
//Destroy previous cave if it exists
if (CaveGenerator.cave != null)
{
DestroyImmediate(CaveGenerator.cave);
}
CaveGenerator.CreateCaveMap(width, height, fillProbability, threshold, seed);
}
//Disable buttons by default
EditorGUI.BeginDisabledGroup(CaveGenerator.cave == null);
//Button to Save Cave as Prefab with a unique name
if (GUILayout.Button("Save Generated Cave as Prefab"))
{
string prefabPath = "Assets/ProceduralCaveGenerator/Prefabs/";
Object prefab = PrefabUtility.CreateEmptyPrefab(prefabPath + CaveGenerator.cave.name + System.DateTime.Now.ToString("_MMddyyhhmmss") + ".prefab");
//Null check for new cave
if (CaveGenerator.cave != null)
{
PrefabUtility.ReplacePrefab(CaveGenerator.cave, prefab, ReplacePrefabOptions.ConnectToPrefab);
}
else
{
Debug.LogError("Cannot find a newly generated cave. Please generate a new cave to save as prefab."); //Just for safety - control should not be able to come here
}
//Log output path
Debug.Log("Saved to " + prefabPath);
}
//Button to optionally remove single walls if any
if (GUILayout.Button("Remove Single Walls"))
{
//Null check for new cave
if (CaveGenerator.cave != null)
{
CaveGenerator.CleanCaveMap();
}
else
{
Debug.LogError("Cannot find a newly generated cave. Please generate a new cave to check for single walls."); //Just for safety - control should not be able to come here
}
}
EditorGUI.EndDisabledGroup();
}
public void GenerateCave()
{
bool[,] caveMap = CaveGenerator.GenerateCave(caveSize, simulationSteps);
for (int y = 0; y < caveSize; y++)
{
for (int x = 0; x < caveSize; x++)
{
if (x == 0 || y == 0 || x == caveSize - 1 || y == caveSize - 1)
{
// creates a wall around the border of the cave
caveMap[x, y] = true;
}
if (caveMap[x, y])
{
tilemap.SetTile(new Vector3Int(x, y, 0), blackTile);
}
else
{
tilemap.SetTile(new Vector3Int(x, y, 0), regions[2].tile);
}
}
}
caveMap = CaveGenerator.FloodFill(caveMap, caveSize);
int totalCaveSize = 0;
for (int y = 0; y < caveSize; y++)
{
for (int x = 0; x < caveSize; x++)
{
if (caveMap[x, y])
{
tilemap.SetTile(new Vector3Int(x, y, 0), regions[2].tile);
totalCaveSize++;
}
else
{
tilemap.SetTile(new Vector3Int(x, y, 0), blackTile);
}
}
}
int minCaveSize = (caveSize * caveSize) / 2;
if (totalCaveSize <= minCaveSize)
{
GenerateCave();
}
else
{
for (int y = 1; y < caveSize - 1; y++)
{
for (int x = 1; x < caveSize - 1; x++)
{
if (tilemap.GetTile(new Vector3Int(x, y, 0)) == blackTile)
{
//Checks 8 coords around current x and y to see if it's wall or black
if (caveMap[x + 1, y] == regions[2].tile || caveMap[x - 1, y] == regions[2].tile ||
caveMap[x, y + 1] == regions[2].tile || caveMap[x, y - 1] == regions[2].tile ||
caveMap[x + 1, y + 1] == regions[2].tile || caveMap[x - 1, y + 1] == regions[2].tile ||
caveMap[x + 1, y - 1] == regions[2].tile || caveMap[x - 1, y - 1] == regions[2].tile)
{
tilemap.SetTile(new Vector3Int(x, y, 0), regions[6].tile);
}
}
}
}
}
}
static void Init()
{
curWindow = (CaveGenerator)EditorWindow.GetWindow(typeof(CaveGenerator));
curWindow.titleContent = new GUIContent("Cave generator");
}
