// =====================================================
// Render dungeon in a texture and save it as a png file
// =====================================================
public void Export(string path)
{
generator = GetComponent<DungeonGenerator>();
dungeonTexture = DungeonToTexture();
TextureToFile(dungeonTexture, path);
}
// Use this for initialization
void OnTriggerEnter()
{
GameManager = GameObject.FindGameObjectWithTag ("Manager");
Grid = GameManager.GetComponent<GridManager> ();
Donjon = GameManager.GetComponent<DungeonGenerator> ();
foreach (GameObject room in Grid._Dungeon) {
Destroy (room);
}
GameObject[] endroom = GameObject.FindGameObjectsWithTag ("End");
foreach (GameObject item in endroom) {
if (item == gameObject) {
} else {
Destroy (item);
}
}
GameObject[] coins = GameObject.FindGameObjectsWithTag ("Coin");
foreach (GameObject coin in coins) {
Destroy (coin);
}
Donjon.NextLevel ();
Destroy (gameObject);
}
public void Start()
{
dungeonGenerator = GetComponent<DungeonGenerator> ();
terrainCarver = GetComponent<TerrainCarver> ();
textureGenerator = GetComponent<TerrainTextureGenerator> ();
toolkit = ter.GetComponent<TerrainToolkit> ();
}
// =====================================================
// Initialization
// =====================================================
public void Init(DungeonGenerator generator, Grid grid)
{
this.generator = generator;
this.grid = grid;
if (exportTexture) {
dungeonTexture = DungeonToTexture();
TextureToFile(dungeonTexture, "Dungeons/Dungeon" + generator.seed);
}
RenderDungeonToGrid();
}
void Start()
{
float seed = Random.value;
DungeonGenerator dg = new DungeonGenerator();
dg.config(seed, 30, 15, 5);// parameters (random seed, width, height, # of rooms)
ArrayList arr = dg.generateDungeon();
for (int i = 0; i < arr.Count; ++i)
{
Tile ts = (Tile)arr[i];
if (ts.type == "spawn")
{
//Instantiate(playerPrefab, new Vector3(ts.xPos*tileSize, ts.yPos*tileSize, 0.0f), Quaternion.identity );
//transform.position = new Vector3(ts.xPos*tileSize, ts.yPos*tileSize, -10); //I don't think this does what you think?
playerInstance.transform.position = new Vector3( ts.xPos * tileSize, ts.yPos * tileSize, 0.0f );
Camera.main.transform.position = new Vector3( ts.xPos * tileSize, ts.yPos * tileSize, -10.0f );
}
else if (ts.type == "enemy")
{
Instantiate(enemyPrefab, new Vector3(ts.xPos*tileSize, ts.yPos*tileSize, 0.0f), Quaternion.identity );
}
else if (ts.type == "floor")
{
GameObject tile = (GameObject)Instantiate(floorPrefab, new Vector3(ts.xPos*tileSize, ts.yPos*tileSize, 0.0f), Quaternion.identity );
tile.transform.parent = dungeon.transform;
}
else if (ts.type == "wall")
{
GameObject tile;
//Gen check.
if ( true )
{
//subtypes: wall, crack, vine
tile = (GameObject)Instantiate(wallPrefabMedieval, new Vector3(ts.xPos*tileSize, ts.yPos*tileSize, 0.0f), Quaternion.identity );
}
else if ( true )
{
tile = (GameObject)Instantiate(wallPrefabSteampunk, new Vector3(ts.xPos*tileSize, ts.yPos*tileSize, 0.0f), Quaternion.identity );
}
else if ( true )
{
tile = (GameObject)Instantiate(wallPrefabFuture, new Vector3(ts.xPos*tileSize, ts.yPos*tileSize, 0.0f), Quaternion.identity );
}
else
{
tile = (GameObject)Instantiate(wallPrefab, new Vector3(ts.xPos*tileSize, ts.yPos*tileSize, 0.0f), Quaternion.identity );
}
//Move it.
tile.transform.parent = dungeon.transform;
}
}
}
// Constructor
public QuadTree(AABB _aabb)
{
boundary = _aabb;
dungeon = DungeonGenerator.instance;
// room floor size + "BORDER" walls for each axis
// originally was * 2, but * 1 gives much better shapes
roomRealMinSize = dungeon.ROOM_MIN_SIZE + dungeon.ROOM_WALL_BORDER * 2 ;
this.tiles = new List<DungeonTile>();
this.color = new Color(Random.Range(0.2f, 1f), Random.Range(0.2f, 1f), Random.Range(0.2f, 1f));
this.materialFloor = new Material (Shader.Find(" Diffuse"));
this.materialFloor.color = this.color;
this.materialFloor.mainTexture = Resources.Load("dungeon/Textures/grid") as Texture2D;
this.materialFloor.SetTextureScale("_MainTex", new Vector2(0.333f,0.333f));
//this.materialFloor.SetTextureOffset("_MainTex", new Vector2(0.333f * Random.Range(0, 3) ,0.333f * Random.Range(0, 3)));
this.materialWall = new Material (Shader.Find(" Diffuse"));
this.materialWall.color = new Color(color.r * 0.75f, color.g * 0.75f, color.b * 0.75f);
this.materialWall.mainTexture = this.materialFloor.mainTexture;
this.materialWall.SetTextureScale("_MainTex", new Vector2(0.333f,0.333f));
}
public Dungeon(Rect room)
{
this.room = room;
generator = GameObject.Find("Map").GetComponent <DungeonGenerator>();
}
// Use this for initialization
void Start()
{
gen = GameObject.FindObjectOfType <DungeonGenerator>();
}
protected override void Run(DungeonGenerator generator)
{
PrepareForCulling(generator, generator.CurrentDungeon);
}
public static List <Vector2Int> CalculatePathNoCollisions(Vector2Int start, Vector2Int target)
{
if (dungeon == null)
{
dungeon = GameObject.Find("GameManager").GetComponent <DungeonGenerator>();
}
List <Vector2Int> path = new List <Vector2Int>();
openList = new List <Node>();
closedList = new List <Node>();
allNodes = new Node[dungeon.mapWidth, dungeon.mapHeight];
for (int y = 0; y < dungeon.mapHeight; y++)
{
for (int x = 0; x < dungeon.mapWidth; x++)
{
allNodes[x, y] = new Node();
}
}
Node firstNode = new Node()
{
position = start, gCost = 0, isOnClosedList = true
};
closedList.Add(firstNode);
foreach (Vector2Int position in GetNeighboursNoCollisions(firstNode.position))
{
Node node = new Node()
{
position = position, parent = firstNode, hCost = CalculateHCost(position, target), gCost = CalculateGCost(firstNode, position)
};
node.fCost = node.gCost + node.hCost;
node.isOnOpenList = true;
allNodes[position.x, position.y] = node;
openList.Add(node);
}
Node lastNode = new Node();
while (openList.Count > 0)
{
Node node = openList[0];
foreach (Node pathNode in openList)
{
if (node.fCost > pathNode.fCost || (node.fCost == pathNode.fCost && node.hCost > pathNode.hCost))
{
node = pathNode;
}
}
if (node.position == target)
{
lastNode = node;
break;
}
closedList.Add(node);
allNodes[node.position.x, node.position.y].isOnClosedList = true;
openList.Remove(node);
allNodes[node.position.x, node.position.y].isOnOpenList = false;
bool foundTarget = false;
foreach (Vector2Int position in GetNeighboursNoCollisions(node.position))
{
if (position == target)
{
foundTarget = true;
break;
}
if (MapManager.map[position.x, position.y].enemy == null)
{
Node neighbour = new Node()
{
position = position, parent = node, gCost = CalculateGCost(node, position), hCost = CalculateHCost(position, target), isOnOpenList = true
};
neighbour.fCost = neighbour.gCost + neighbour.hCost;
allNodes[position.x, position.y] = neighbour;
openList.Add(neighbour);
}
}
if (foundTarget)
{
openList.Clear();
lastNode = node;
break;
}
}
path.Add(target);
RetracePath(path, start, lastNode);
return(path);
}
public void Run()
{
var inputs = new List <GeneratorInput <IMapDescription <int> > >();
var settings = new JsonSerializerSettings()
{
PreserveReferencesHandling = PreserveReferencesHandling.All,
TypeNameHandling = TypeNameHandling.All,
};
inputs.Add(new GeneratorInput <IMapDescription <int> >(
"Gungeon 1_1",
JsonConvert.DeserializeObject <MapDescription <int> >(
File.ReadAllText("Resources/MapDescriptions/gungeon_1_1.json"), settings)));
var layoutDrawer = new SVGLayoutDrawer <int>();
var benchmarkRunner = new BenchmarkRunner <IMapDescription <int> >();
var benchmarkScenario = new BenchmarkScenario <IMapDescription <int> >("Gungeon", input =>
{
var configuration = new DungeonGeneratorConfiguration <int>()
{
RepeatModeOverride = RoomTemplateRepeatMode.NoImmediate,
ThrowIfRepeatModeNotSatisfied = true,
SimulatedAnnealingConfiguration = new SimulatedAnnealingConfigurationProvider(new SimulatedAnnealingConfiguration()
{
HandleTreesGreedily = true,
})
};
// var layoutGenerator = new PlatformersGenerator<int>(input.MapDescription, configuration);
//return new LambdaGeneratorRunner(() =>
//{
// var layouts = layoutGenerator.GenerateLayout();
// return new GeneratorRun(layouts != null, layoutGenerator.TimeTotal, layoutGenerator.IterationsCount);
//});
return(new LambdaGeneratorRunner(() =>
{
var layoutGenerator = new DungeonGenerator <int>(input.MapDescription, configuration);
layoutGenerator.InjectRandomGenerator(new Random(0));
var simulatedAnnealingArgsContainer = new List <SimulatedAnnealingEventArgs>();
void SimulatedAnnealingEventHandler(object sender, SimulatedAnnealingEventArgs eventArgs)
{
simulatedAnnealingArgsContainer.Add(eventArgs);
}
layoutGenerator.OnSimulatedAnnealingEvent += SimulatedAnnealingEventHandler;
var layout = layoutGenerator.GenerateLayout();
layoutGenerator.OnSimulatedAnnealingEvent -= SimulatedAnnealingEventHandler;
var additionalData = new AdditionalRunData()
{
SimulatedAnnealingEventArgs = simulatedAnnealingArgsContainer,
GeneratedLayoutSvg = layoutDrawer.DrawLayout(layout, 800, forceSquare: true),
// GeneratedLayout = layout,
};
var generatorRun = new GeneratorRun <AdditionalRunData>(layout != null, layoutGenerator.TimeTotal, layoutGenerator.IterationsCount, additionalData);
return generatorRun;
}));
});
// Constructor
public QuadTree(AABB _aabb)
{
boundary = _aabb;
dungeon = DungeonGenerator.instance;
roomRealMinSize = dungeon.ROOM_MIN_SIZE + dungeon.ROOM_WALL_BORDER*2; // room floor size + "BORDER" walls for each axis
}
public static void ContinueOldGame(SerializedGame game)
{
Check();
Random = new DotNetRandom();
mapLevel = game.mapLevel;
string ConsoleTitle = $"MagiCave - Level {mapLevel}";
rootConsole.Title = ConsoleTitle;
Random.Restore(game.Random);
steps = game.steps;
Player = game.Player;
for (int i = 0; i < game.Levels.Length; i++)
{
SchedulingSystem = new SchedulingSystem();
DungeonMap levelmap = new DungeonMap();
levelmap.Restore(game.Levels[i]);
levelmap.Doors = game.Doors[i].ToList();
for (int k = 0; k < mapWidth * mapHeight; k++)
{
if ((game.Levels[i].Cells[k] & MapState.CellProperties.Explored) == MapState.CellProperties.Explored)
{
int l;
int j;
if (k >= mapWidth)
{
j = k / mapWidth;
l = k - j * mapWidth;
}
else
{
l = k;
j = 0;
}
levelmap.SetCellProperties(l, j, levelmap.GetCell(l, j).IsTransparent, levelmap.GetCell(l, j).IsWalkable, true);
}
}
//levelmap.Rooms = game.Rooms[i].ToList();
levelmap.Monsters = game.MonstersOnLevel[i].ToList();
foreach (Monster m in levelmap.Monsters)
{
if (m.Items == null)
{
m.Items = new List <Interfaces.IItem>();
}
}
DungeonGenerator gen = new DungeonGenerator(levelmap);
gen.Restore(SchedulingSystem);
SchedulingSystems.AddLast(SchedulingSystem);
Levels.AddLast(levelmap);
i++;
}
CurrentSchedulingSystem = SchedulingSystems.First;
CurrentLevel = Levels.First;
for (int j = 0; j < mapLevel - 1; j++)
{
CurrentSchedulingSystem = CurrentSchedulingSystem.Next;
CurrentLevel = CurrentLevel.Next;
}
SchedulingSystem = CurrentSchedulingSystem.Value;
DungeonMap = CurrentLevel.Value;
MessageLog.Add("Game loaded successfully");
Player = game.Player;
DungeonMap.UpdatePlayerFieldOfView();
ts.Add(game.ts);
time.Start();
renderRequired = true;
}
public void Run()
{
var count = 20;
var name = "edges_0_3";
var graphs = GetGraphs(count, name);
var inputs = new List <DungeonGeneratorInput <int> >();
var chainDecompositionOld = new BreadthFirstChainDecompositionOld <int>();
for (var i = 0; i < graphs.Count; i++)
{
var graph = graphs[i];
for (int j = 0; j < 1; j++)
{
var withCorridors = j == 1;
var mapDescription = GetMapDescription(graph, withCorridors);
var chainDecomposition = new TwoStageChainDecomposition <int>(mapDescription, chainDecompositionOld);
inputs.Add(new DungeonGeneratorInput <int>($"RandomGraph {i} {(withCorridors ? "wc" : "")}", mapDescription, new DungeonGeneratorConfiguration <int>()
{
EarlyStopIfIterationsExceeded = 20000,
// Chains = chainDecomposition.GetChains(mapDescription.GetGraph()),
SimulatedAnnealingConfiguration = new SimulatedAnnealingConfigurationProvider(new SimulatedAnnealingConfiguration()
{
MaxIterationsWithoutSuccess = 150
})
}, null));
}
}
var benchmarkRunner = new BenchmarkRunner <IMapDescription <int> >();
var benchmarkScenario = new BenchmarkScenario <IMapDescription <int> >("RandomGraphs", input =>
{
var layoutDrawer = new SVGLayoutDrawer <int>();
var dungeonGeneratorInput = (DungeonGeneratorInput <int>)input;
var layoutGenerator = new DungeonGenerator <int>(input.MapDescription, dungeonGeneratorInput.Configuration);
layoutGenerator.InjectRandomGenerator(new Random(0));
return(new LambdaGeneratorRunner(() =>
{
var simulatedAnnealingArgsContainer = new List <SimulatedAnnealingEventArgs>();
void SimulatedAnnealingEventHandler(object sender, SimulatedAnnealingEventArgs eventArgs)
{
simulatedAnnealingArgsContainer.Add(eventArgs);
}
layoutGenerator.OnSimulatedAnnealingEvent += SimulatedAnnealingEventHandler;
var layout = layoutGenerator.GenerateLayout();
layoutGenerator.OnSimulatedAnnealingEvent -= SimulatedAnnealingEventHandler;
var additionalData = new AdditionalRunData()
{
SimulatedAnnealingEventArgs = simulatedAnnealingArgsContainer,
GeneratedLayoutSvg = layout != null ? layoutDrawer.DrawLayout(layout, 800, forceSquare: true) : null,
GeneratedLayout = layout,
};
var generatorRun = new GeneratorRun <AdditionalRunData>(layout != null, layoutGenerator.TimeTotal, layoutGenerator.IterationsCount, additionalData);
return generatorRun;
}));
});
private void Start()
{
manager = GameObject.Find("GameManager").GetComponent <GameManager>();
dungeon = GameObject.Find("GameManager").GetComponent <DungeonGenerator>();
}
public abstract void SetCorners(DungeonGenerator map);
public MapHandler()
{
DungeonGenerator gen = new DungeonGenerator();
int width = 1024;
int height = 1024;
int[,] map = gen.Generate(width, height, 50, 30, 250, 100);
World.width = height / World.chunkSize;
World.depth = width / World.chunkSize;
World.CreateChunks();
TextureHandler th = (TextureHandler)GameObject.FindObjectOfType <TextureHandler> ();
// Create pillars below rooms
List <KeyValuePair <int, int[]> > pillars = gen.GetPillars();
foreach (var p in pillars)
{
CreatePlane(p.Key, 100, p.Value[2], p.Value[0], p.Value[1]);
}
// Create lights
List <int[]> lights = gen.GetLights();
foreach (var l in lights)
{
// Create light pillars.
int size = 10;
for (int x = l[0] - size / 2 + 1; x < l[0] + size / 2 - 1; x++)
{
for (int y = l[1] - size / 2 + 1; y < l[1] + size / 2 - 1; y++)
{
float r = Random.Range(1, 15);
for (int h = 15; h > 15 - r; h--)
{
// World.blocks [x, h, y] = th.GetGroundColor2 (x, h);
World.blocks [x, h, y] = th.GetColor(th.pillars);
}
for (int h = 40; h > 15; h--)
{
//World.blocks [x, h, y] = th.GetGroundColor2 (x, h);
World.blocks [x, h, y] = th.GetColor(th.pillars);
}
}
}
CreateLight(l[0] - 1, 45, l[1] - 1);
}
// Create brdige lights
List <int[]> bridgeLights = gen.GetBridgeLights();
foreach (var l in bridgeLights)
{
// Create light pillars.
int size = 6;
for (int x = l[0] - size / 2; x < l[0] + size / 2; x++)
{
for (int y = l[1] - size / 2; y < l[1] + size / 2; y++)
{
float r = Random.Range(1, 15);
for (int h = 15; h > 15 - r; h--)
{
World.blocks [x, h, y] = th.GetColor(th.pillars);
// World.blocks [x, h, y] = th.GetGroundColor2 (x, h);
}
for (int h = 35; h > 15; h--)
{
// World.blocks [x, h, y] = th.GetGroundColor2 (x, h);
World.blocks [x, h, y] = th.GetColor(th.pillars);
}
}
}
World.blocks [l [0] - 1, 36, l [1] - 1] = (255 & 0xFF) << 24 | (255 & 0xFF) << 16 | (251 & 0xFF) << 8;
World.blocks [l [0] - 1, 37, l [1] - 1] = (255 & 0xFF) << 24 | (255 & 0xFF) << 16 | (251 & 0xFF) << 8;
CreateBridgeLight(l[0] - 1, 37, l[1] - 1);
}
// Fences on bridges
List <int[]> bridgeFence = gen.GetBridgeFence();
foreach (var l in bridgeFence)
{
// Create light pillars.
int size = 4;
for (int x = l[0] - size / 2; x < l[0] + size / 2; x++)
{
for (int y = l[1] - size / 2; y < l[1] + size / 2; y++)
{
World.blocks [x, 30, y] = th.GetColor(th.fence);
//World.blocks [x, 30, y] = th.GetFenceColor (x, y);
}
}
}
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
if (map [x, y] == (int)DungeonGenerator.types.Room)
{
// World.blocks [x, World.floorHeight, y] = th.GetGroundColor (x,y);
World.blocks [x, World.floorHeight, y] = th.GetColor(th.floor);
}
else if (map[x, y] == (int)DungeonGenerator.types.Road)
{
// World.blocks [x, World.floorHeight, y] = th.GetGroundColor2 (x,y);
World.blocks [x, World.floorHeight, y] = th.GetColor(th.bridge);
}
else if (map[x, y] == (int)DungeonGenerator.types.Player)
{
Player.player.obj.transform.position = new Vector3(x, World.floorHeight, y);
}
// ROOMS
if (x + 1 < width)
{
if (map [x + 1, y] == (int)DungeonGenerator.types.Empty && map [x, y] == (int)DungeonGenerator.types.Room)
{
int r = (int)Random.Range(4, 15);
for (int n = World.floorHeight - r; n <= World.floorHeight - 3; n++)
{
for (int i = 0; i < 6; i++)
{
World.blocks [x + i, n, y] = th.GetColor(th.wall);
// World.blocks [x + i, n, y] = th.GetWallColor (n, y);
}
}
for (int n = World.floorHeight - 3; n <= World.floorHeight + 2; n++)
{
for (int i = 0; i < 3; i++)
{
// World.blocks [x + i, n, y] = th.GetWallColor (n, y);
World.blocks [x + i, n, y] = th.GetColor(th.wall);
}
}
for (int n = World.floorHeight + 2; n <= World.floorHeight + 15; n++)
{
for (int i = 0; i < 6; i++)
{
/// World.blocks [x + i, n, y] = th.GetWallColor (n, y);
World.blocks [x + i, n, y] = th.GetColor(th.wall);
}
if (n == World.floorHeight + 15)
{
for (int i = 0; i < 6; i++)
{
//World.blocks [x + i, n, y] = th.GetGroundColor2 (x-i, y);
World.blocks [x + i, n, y] = th.GetColor(th.floor);
}
}
}
}
}
if (x - 1 > 0)
{
if (map [x - 1, y] == (int)DungeonGenerator.types.Empty && map [x, y] == (int)DungeonGenerator.types.Room)
{
int r = (int)Random.Range(4, 15);
for (int n = World.floorHeight - r; n <= World.floorHeight - 3; n++)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x - i, n, y] = th.GetWallColor (n, y);
World.blocks [x - i, n, y] = th.GetColor(th.wall);
}
}
for (int n = World.floorHeight - 3; n <= World.floorHeight + 2; n++)
{
for (int i = 0; i < 3; i++)
{
// World.blocks [x - i, n, y] = th.GetWallColor (n, y);
World.blocks [x - i, n, y] = th.GetColor(th.wall);
}
}
for (int n = World.floorHeight + 2; n <= World.floorHeight + 15; n++)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x - i, n, y] = th.GetWallColor (n, y);
World.blocks [x - i, n, y] = th.GetColor(th.wall);
}
if (n == World.floorHeight + 15)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x - i, n, y] = th.GetGroundColor2 (x+i, y);
World.blocks [x - i, n, y] = th.GetColor(th.floor);
}
}
}
}
}
if (y + 1 < height)
{
if (map [x, y + 1] == (int)DungeonGenerator.types.Empty && map [x, y] == (int)DungeonGenerator.types.Room)
{
int r = (int)Random.Range(4, 15);
for (int n = World.floorHeight - r; n <= World.floorHeight - 3; n++)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x, n, y+i] = th.GetWallColor (x, n);
World.blocks [x, n, y + i] = th.GetColor(th.wall);
}
}
for (int n = World.floorHeight - 3; n <= World.floorHeight + 2; n++)
{
for (int i = 0; i < 3; i++)
{
// World.blocks [x, n, y+i] = th.GetWallColor (x, n);
World.blocks [x, n, y + i] = th.GetColor(th.wall);
}
}
for (int n = World.floorHeight + 2; n <= World.floorHeight + 15; n++)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x, n, y+i] = th.GetWallColor (x, n);
World.blocks [x, n, y + i] = th.GetColor(th.wall);
}
if (n == World.floorHeight + 15)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x, n, y+i] = th.GetGroundColor2 (x, y+i);
World.blocks [x, n, y + i] = th.GetColor(th.floor);
}
}
}
}
}
if (y > 0)
{
if (map [x, y - 1] == (int)DungeonGenerator.types.Empty && map [x, y] == (int)DungeonGenerator.types.Room)
{
int r = (int)Random.Range(4, 15);
for (int n = World.floorHeight - r; n <= World.floorHeight - 3; n++)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x, n, y-i] = th.GetWallColor (x, n);
World.blocks [x, n, y - i] = th.GetColor(th.wall);
}
}
for (int n = World.floorHeight - 3; n <= World.floorHeight + 2; n++)
{
for (int i = 0; i < 3; i++)
{
World.blocks [x, n, y - i] = th.GetColor(th.wall);
// World.blocks [x, n, y-i] = th.GetWallColor (x, n);
}
}
for (int n = World.floorHeight + 2; n <= World.floorHeight + 15; n++)
{
for (int i = 0; i < 6; i++)
{
World.blocks [x, n, y - i] = th.GetColor(th.wall);
// World.blocks [x, n, y-i] = th.GetWallColor (x, n);
}
if (n == World.floorHeight + 15)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x, n, y-i] = th.GetGroundColor2 (x, y-i);
World.blocks [x, n, y - i] = th.GetColor(th.floor);
}
}
}
}
}
// ROADS
if (x + 1 < width)
{
if (map [x + 1, y] == (int)DungeonGenerator.types.Empty && map [x, y] == (int)DungeonGenerator.types.Road)
{
int r = (int)Random.Range(4, 10);
for (int n = World.floorHeight - r; n <= World.floorHeight - 3; n++)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x + i, n, y] = th.GetWallColor (n, y);
World.blocks [x + i, n, y] = th.GetColor(th.wall);
}
}
for (int n = World.floorHeight - 3; n <= World.floorHeight; n++)
{
for (int i = 0; i < 3; i++)
{
World.blocks [x + i, n, y] = th.GetColor(th.wall);
// World.blocks [x + i, n, y] = th.GetWallColor (n, y);
}
}
for (int n = World.floorHeight; n <= World.floorHeight + 2; n++)
{
for (int i = 0; i < 2; i++)
{
// World.blocks [x + i, n, y] = th.GetWallColor (n, y);
World.blocks [x + i, n, y] = th.GetColor(th.wall);
}
if (n == World.floorHeight + 2)
{
for (int i = 0; i < 6; i++)
{
World.blocks [x + i, n, y] = th.GetColor(th.floor);
// World.blocks [x + i, n, y] = th.GetGroundColor2 (x-i, y);
}
}
}
}
}
if (x - 1 > 0)
{
if (map [x - 1, y] == (int)DungeonGenerator.types.Empty && map [x, y] == (int)DungeonGenerator.types.Road)
{
int r = (int)Random.Range(4, 10);
for (int n = World.floorHeight - r; n <= World.floorHeight - 3; n++)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x - i, n, y] = th.GetWallColor (n, y);
World.blocks [x - i, n, y] = th.GetColor(th.wall);
}
}
for (int n = World.floorHeight - 3; n <= World.floorHeight; n++)
{
for (int i = 0; i < 3; i++)
{
World.blocks [x - i, n, y] = th.GetColor(th.wall);
// World.blocks [x - i, n, y] = th.GetWallColor (n, y);
}
}
for (int n = World.floorHeight; n <= World.floorHeight + 2; n++)
{
for (int i = 0; i < 6; i++)
{
World.blocks [x - i, n, y] = th.GetColor(th.wall);
// World.blocks [x - i, n, y] = th.GetWallColor (n, y);
}
if (n == World.floorHeight + 2)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x - i, n, y] = th.GetGroundColor2 (x+i, y);
World.blocks [x - i, n, y] = th.GetColor(th.floor);
}
}
}
}
}
if (y + 1 < height)
{
if (map [x, y + 1] == (int)DungeonGenerator.types.Empty && map [x, y] == (int)DungeonGenerator.types.Road)
{
int r = (int)Random.Range(4, 10);
for (int n = World.floorHeight - r; n <= World.floorHeight - 3; n++)
{
for (int i = 0; i < 6; i++)
{
World.blocks [x, n, y + i] = th.GetColor(th.wall);
// World.blocks [x, n, y+i] = th.GetWallColor (x, n);
}
}
for (int n = World.floorHeight - 3; n <= World.floorHeight; n++)
{
for (int i = 0; i < 3; i++)
{
World.blocks [x, n, y + i] = th.GetColor(th.wall);
// World.blocks [x, n, y+i] = th.GetWallColor (x, n);
}
}
for (int n = World.floorHeight; n <= World.floorHeight + 2; n++)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x, n, y+i] = th.GetWallColor (x, n);
World.blocks [x, n, y + i] = th.GetColor(th.wall);
}
if (n == World.floorHeight + 2)
{
for (int i = 0; i < 6; i++)
{
World.blocks [x, n, y + i] = th.GetColor(th.floor);
// World.blocks [x, n, y+i] = th.GetGroundColor2 (x, y+i);
}
}
}
}
}
if (y > 0)
{
if (map [x, y - 1] == (int)DungeonGenerator.types.Empty && map [x, y] == (int)DungeonGenerator.types.Road)
{
int r = (int)Random.Range(4, 10);
for (int n = World.floorHeight - r; n <= World.floorHeight - 3; n++)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x, n, y-i] = th.GetWallColor (x, n);
World.blocks [x, n, y - i] = th.GetColor(th.wall);
}
}
for (int n = World.floorHeight - 3; n <= World.floorHeight; n++)
{
for (int i = 0; i < 3; i++)
{
World.blocks [x, n, y - i] = th.GetColor(th.wall);
// World.blocks [x, n, y-i] = th.GetWallColor (x, n);
}
}
for (int n = World.floorHeight; n <= World.floorHeight + 2; n++)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x, n, y-i] = th.GetWallColor (x, n);
World.blocks [x, n, y - i] = th.GetColor(th.wall);
}
if (n == World.floorHeight + 2)
{
for (int i = 0; i < 6; i++)
{
// World.blocks [x, n, y-i] = th.GetGroundColor2 (x, y-i);
World.blocks [x, n, y - i] = th.GetColor(th.floor);
}
}
}
}
}
}
}
}
public abstract void SetEdges(DungeonGenerator map);
private void Awake()
{
Instance = this;
}
//public override void SetLights(DungeonGenerator map) {}
public override void SetCorners(DungeonGenerator map)
{
}
private void Init()
{
// Generation
DungeonGenerator dg = new DungeonGenerator();
GenerationProcessor gp = new GenerationProcessor(genPrefabs);
dg.Generate();
// Start room
GameObject goStart = gp.ProcessRoom(dg.start.tiles);
goStart.name = "Start";
List <Transform> lt = new List <Transform>(goStart.GetComponentsInChildren <Transform>());
GameObject doorRoot = new GameObject();
doorRoot.name = "Doors";
doorRoot.transform.SetParent(goStart.transform);
start = goStart.AddComponent <Room>();
start.SetCenter(dg.start.GetCenter());
start.SetPosition(dg.start.roomPosition);
lt = lt.FindAll(x => x.tag == "door");
lt.ForEach(x => {
x.SetParent(doorRoot.transform);
x.gameObject.GetComponent <Door>().SetParent(start);
});
start.SetDoorsRootObject(doorRoot);
// Spawnpoint
GameObject spawnpointRoot = new GameObject();
spawnpointRoot.name = "Spawnpoints";
spawnpointRoot.transform.SetParent(goStart.transform);
spawnpointRoot.transform.position = new Vector3(dg.start.roomPosition.x, dg.start.roomPosition.y, 0);
GameObject spawn = new GameObject();
spawn.transform.SetParent(spawnpointRoot.transform);
spawn.transform.position = new Vector3(dg.start.GetCenter().x, dg.start.GetCenter().y, 0);
start.SetSpawnPointsRootObject(spawnpointRoot);
start.Reload();
start.transform.SetParent(mapRoot.transform);
// Finish room
GameObject goFinish = gp.ProcessRoom(dg.end.tiles);
goFinish.name = "Finish";
List <Transform> ltf = new List <Transform>(goFinish.GetComponentsInChildren <Transform>());
GameObject doorRootf = new GameObject();
doorRootf.name = "Doors";
doorRootf.transform.SetParent(goFinish.transform);
ltf = ltf.FindAll(x => x.tag == "door");
finish = goFinish.AddComponent <Room>();
finish.SetPosition(dg.end.roomPosition);
finish.SetCenter(dg.end.GetCenter());
ltf.ForEach(x => {
x.SetParent(doorRootf.transform);
x.gameObject.GetComponent <Door>().SetParent(finish);
});
finish.SetDoorsRootObject(doorRootf);
// Spawnpoint
GameObject fspawnpointRoot = new GameObject();
fspawnpointRoot.name = "Spawnpoints";
fspawnpointRoot.transform.SetParent(goStart.transform);
fspawnpointRoot.transform.position = new Vector3(dg.end.roomPosition.x, dg.end.roomPosition.y, 0);
GameObject fspawn = new GameObject();
fspawn.transform.SetParent(fspawnpointRoot.transform);
fspawn.transform.position = new Vector3(dg.end.GetCenter().x, dg.end.GetCenter().y, 0);
finish.SetSpawnPointsRootObject(fspawnpointRoot);
finish.Reload();
finish.transform.SetParent(mapRoot.transform);
// Other Rooms
foreach (GenRoom gr in dg.rooms)
{
GameObject groom = gp.ProcessRoom(gr.tiles);
List <Transform> ltg = new List <Transform>(groom.GetComponentsInChildren <Transform>());
// Doors
GameObject doorRootg = new GameObject();
doorRootg.name = "Doors";
doorRootg.transform.SetParent(groom.transform);
Room grom = groom.AddComponent <Room>();
grom.SetCenter(gr.GetCenter());
grom.SetPosition(gr.roomPosition);
ltg = ltg.FindAll(x => x.tag == "door");
ltg.ForEach(x => {
x.SetParent(doorRootg.transform);
x.gameObject.GetComponent <Door>().SetParent(grom);
});
// Spawnpoints
GameObject tSpawnpointRoot = new GameObject();
tSpawnpointRoot.name = "Spawnpoints";
tSpawnpointRoot.transform.SetParent(groom.transform);
tSpawnpointRoot.transform.position = new Vector3(gr.roomPosition.x, gr.roomPosition.y, 0);
foreach (Vector2Int v in gr.spawnpoints)
{
GameObject tspawn = new GameObject();
tspawn.transform.SetParent(tSpawnpointRoot.transform);
tspawn.transform.position = new Vector3(v.x, v.y, 0); // is this the center or the top left corner of a block?
}
grom.SetSpawnPointsRootObject(tSpawnpointRoot);
grom.SetDoorsRootObject(doorRootg);
grom.Reload();
DungeonGenerator.GenerateObjective(grom);
groom.transform.SetParent(mapRoot.transform);
}
// Hallways
GameObject goHallways = gp.ProcessRoom(dg.path.tiles);
goHallways.name = "Hallways";
goHallways.AddComponent <Room>();
goHallways.transform.SetParent(mapRoot.transform);
}
void Awake()
{
instance = this;
bool intersected;
for (int i = 0; i < dungeonBounds.x; i++)
{
for (int j = 0; j < dungeonBounds.y; j++)
{
if (random.NextDouble() > (1 - density))
{
Rect r = new Rect(i, j, random.Next((int)minCellBounds.x, (int)maxCellBounds.x), random.Next((int)minCellBounds.y, (int)maxCellBounds.y));
intersected = false;
for (int k = 0; k < cells.Count; k++)
{
if (Intersects(r, cells[k]))
{
intersected = true;
break;
}
}
if (intersected)
{
j--;
continue;
}
else
{
cells.Add(r);
}
}
}
}
Debug.Log("Created Cells");
foreach (var o in cells)
{
foreach (var o2 in cells)
{
if (o.center != o2.center)
{
CreateConnection(o, o2);
}
}
}
Debug.Log("Created Connections");
foreach (var r in cells)
{
if (connections.ContainsKey(r))
{
var go = CreateFloor(r);
if (!cellWithVcorridors.Contains(r))
{
var go2 = CreateWall(r);
go2.transform.parent = go.transform;
}
rooms.Add(go);
}
}
Debug.Log("Created Rooms");
foreach (var r in Hcorridor)
{
CreateFloor(r);
CreateWall(r);
}
foreach (var r in Vcorridor)
{
CreateFloor(r);
}
Debug.Log("Created Corridors");
Debug.Log("Done");
}
private void Awake() => instance = this;
public void NewLevel()
{
level++;
Enemy enemy = new Enemy();
Artifact artifact = new Artifact();
for (int i = 0; i < Tile.SIZE; i++)
{
if (Enemy.occupied[i])
{
enemy.Destroy(i);
}
if (Artifact.titles[i] != Artifact.Title.None)
{
artifact.Destroy(i);
}
}
CameraMain.Cam.GetComponentInChildren <CameraFollow>().enabled = true;
if (PlayerStat.scoutRange >= 5)
{
CameraMain.Cam.GetComponentInChildren <Camera>().orthographicSize = (PlayerStat.scoutRange * 10) + 5;
}
else
{
CameraMain.Cam.GetComponentInChildren <Camera>().orthographicSize = 50;
}
DungeonGenerator dungeon = new DungeonGenerator();
switch (level)
{
case 1:
dungeon.GenerateDungeon(1, 1);
break;
case 2:
dungeon.GenerateDungeon(1, 1);
break;
case 3:
dungeon.GenerateDungeon(1, 1);
break;
case 4:
dungeon.GenerateDungeon(1, 1);
break;
case 5:
dungeon.GenerateDungeon(1, 1);
break;
case 6:
dungeon.GenerateDungeon(1, 1);
break;
case 7:
dungeon.GenerateDungeon(1, 1);
break;
case 8:
dungeon.GenerateDungeon(1, 1);
break;
case 9:
dungeon.GenerateDungeon(1, 1);
break;
case 10:
dungeon.GenerateDungeon(1, 1);
break;
case 11:
dungeon.GenerateDungeon(1, 1);
break;
case 12:
dungeon.GenerateDungeon(1, 1);
break;
}
UI.EndBtn.GetComponentInChildren <Text>().text = "End Turn";
Map map = new Map();
map.HideMap();
PlayerMovement playerMovement = new PlayerMovement();
playerMovement.MovePlayer(PlayerMovement.tilePos, PlayerMovement.tilePos);
FogOfWar fow = new FogOfWar();
fow.ScoutPath(PlayerMovement.tilePos, PlayerStat.scoutRange);
fow.ScoutTiles();
fow.ScoutEnemies();
map.UpdateMap();
Turn turn = new Turn();
turn.PlayerTurn();
PlayerStat playerStat = new PlayerStat();
playerStat.ResetStats();
}
void Start()
{
// Get game components
grid = GetComponent<Grid>();
dungeonGenerator = GetComponent<DungeonGenerator>();
dungeonRenderer = GetComponent<DungeonRenderer>();
// initialize grid
grid.Init();
// generate dungeon
GenerateDungeon(1);
}
public void G1_39_Tirnanog_Dungeon()
{
var dg = new DungeonGenerator("G1_39_Tirnanog_Dungeon", 2000, 370545889, 0, "");
var correct = @"
maze gen
000102030405060708
06 X X X S
05 X X X
04 X X X X
03 X X X X B X
02 X X X X X X
01 X X X X X X
00 X X X X X X
maze gen
000102030405060708
07 X X X
06 B X X X
05 S X X X X X X X
04 X X X X X X X
03 X X X X X X X
02 X X X X X X
01 X X X X X X
00 X X X X X X
maze gen
000102030405060708
06 X X
05 B X
04 X X X
03 X X X X X
02 X X X X X X
01 X S X X X X
00 X X X X X X
maze gen
000102030405060708
06 X S B
05 X X X
04 X X X X X
03 X X X X X X X
02 X X X X X
01 X X X X X X
00 X X X X X X X
maze gen
000102030405060708
06 X X X
05 X S X X X
04 X X X X X X
03 X X X X X
02 X X X X X X X
01 X X X X X X
00 X X B X
maze gen
000102030405060708
08 X X X X X X X
07 X X X X X X X
06 X X X X
05 X X X X X X
04 X X X X B X X
03 S X X X X X X
02 X X X X X X X X X
01 X X X X X X X X X
00 X X X X X X X X X
".Trim();
Assert.Equal(correct, GetMazeAsString(dg));
}
/// <summary>
/// Calculates the probabibilites of all the available rooms depending on some formulas.
/// </summary>
/// <param name="available_rooms"></param>
/// <returns></returns>
List <Possibility> CalculateProbabilites(List <string> available_rooms)
{
List <Possibility> appropriateProbabilities = new List <Possibility> ();
foreach (string room in available_rooms)
{
appropriateProbabilities.Add(room_type.Find(x => x.GetItem() == room));//Get only the available rooms probabilities.
}
float endRoomProbability;
float endRoomStartingProb = room_type.Find(x => x.GetItem() == "EndRoom").GetValue();
float t;
float probabilityNotEndroom;
if (!endRoomPlaced)
{
/*Variable to decide if the room has more probabilities to spawn the start, middle or the end of the dungeon.
* Low --------> High Power = Start --------> End.
*/
t = (float)System.Math.Pow((float)(DungeonGenerator.GetInstance().roomsPlaced + 1) / DungeonGenerator.GetInstance().RoomNumber, 10);
endRoomProbability = endRoomStartingProb * (1 - t) + 100 * t;
probabilityNotEndroom = 100 - endRoomProbability;
}
else
{
endRoomProbability = 0;
probabilityNotEndroom = 100;
}
for (int i = 0; i < appropriateProbabilities.Count; i++)
{
if (appropriateProbabilities[i].GetItem().Equals("EndRoom"))
{
appropriateProbabilities[i].SetValue(endRoomProbability);
}
else
{
appropriateProbabilities[i].SetValue(appropriateProbabilities[i].GetValue() * probabilityNotEndroom / (100 - endRoomStartingProb));
}
}
return(appropriateProbabilities);
}
public void TirCho_Alby_G15_Price_Of_Love_High()
{
var dg = new DungeonGenerator("TirCho_Alby_G15_Price_Of_Love_High", 2000, 370545889, 0, "");
var correct = @"
maze gen
000102030405060708
05 S X X X B
04 X X X
03 X X X
02 X X X X
01
00
maze gen
000102030405060708
05 B X
04 X X
03 X X X
02 X X X
01 S X
00 X X X
maze gen
000102030405060708
05
04 S
03 X X X
02 X X X X X X
01 X X X X
00 B
maze gen
000102030405060708
05 X X X
04 X X X
03 S X X
02 X X X B
01 X X
00
maze gen
000102030405060708
05 X S X
04 X X X
03 X X X
02 X X
01 X B X
00 X X X
maze gen
000102030405060708
05 X X
04 S X
03 X
02 X X X
01 X X X X X X
00 B X X X X
maze gen
000102030405060708
05
04
03 X
02 B X
01 X X X X S
00 X X X X X
".Trim();
Assert.Equal(correct, GetMazeAsString(dg));
}
// Start is called before the first frame update
void Start()
{
DungeonGenerator.GetInstance().CompleteDungeon(Stage_Manager.GetInstance().GetNextFloorRoomNumber());
}
private void btn_generate_Click(object sender, EventArgs e)
{
int n = 0;
if (Int32.TryParse(txt_numLevels.Text, out n))
{
for (int i = 0; i < n; i++)
{
var generator = new DungeonGenerator<Tile>();
Map<Tile> map = generator.GenerateA().SmallDungeon().ABitRandom().SomewhatSparse()
.WithMediumChanceToRemoveDeadEnds().WithMediumSizeRooms().WithLargeNumberOfRooms().Now();
Random r = new Random();
Room room = map.Rooms[r.Next(0, map.Rooms.Count)];
int centerX = room.Left + (room.Size.Width / 2);
int centerY = room.Top + (room.Size.Height / 2);
map.AllCells.ToList<Tile>()[centerX + centerY * map.Width].desc = "start";
room = map.Rooms[r.Next(0, map.Rooms.Count)];
centerX = room.Left + (room.Size.Width / 2);
centerY = room.Top + (room.Size.Height / 2);
map.AllCells.ToList<Tile>()[centerX + centerY * map.Width].desc = "end";
StreamWriter writer = new StreamWriter("level_" + i + ".txt");
for (int x = 0; x < map.Width+2; x++) {
writer.Write("x");
}
writer.WriteLine();
for (int y = 0; y < map.Height; y++)
{
writer.Write('x');
for (int x = 0; x < map.Width; x++)
{
Tile tile = map.GetCell(y, x);
if (tile.desc == "start")
{
writer.Write('s');
}
else if (tile.desc == "end")
{
writer.Write('e');
}
else
{
switch (tile.Terrain)
{
case TerrainType.Door:
writer.Write('d');
break;
case TerrainType.Floor:
writer.Write(' ');
break;
case TerrainType.Rock:
writer.Write('x');
break;
default:
break;
}
}
}
writer.Write('x');
writer.WriteLine();
}
for (int x = 0; x < map.Width+2; x++)
{
writer.Write("x");
}
writer.Close();
}
}
}
// Constructor
public QuadTree(AABB _aabb)
{
boundary = _aabb;
dungeon = DungeonGenerator.instance;
roomRealMinSize = dungeon.ROOM_MIN_SIZE + dungeon.ROOM_WALL_BORDER * 2; // room floor size + "BORDER" walls for each axis
}
public ActionResult Index(DungeonParameters dungeon)
{
if (dungeon.Width > 200) dungeon.Width = 200;
if (dungeon.Height > 300) dungeon.Height = 300;
if (dungeon.RoomCount < 0) dungeon.RoomCount = 0;
if (dungeon.RoomCount > 250) dungeon.RoomCount = 250;
if (dungeon.Randomness > 1) dungeon.Randomness = 1;
if (dungeon.Randomness < 0) dungeon.Randomness = 0;
if (dungeon.Sparseness > 1) dungeon.Sparseness = 1;
if (dungeon.Sparseness < 0) dungeon.Sparseness = 0;
if (dungeon.ChanceToRemoveDeadends > 1) dungeon.ChanceToRemoveDeadends = 1;
if (dungeon.ChanceToRemoveDeadends < 0) dungeon.ChanceToRemoveDeadends = 0;
if (!dungeon.ThemeNames.Contains(dungeon.Theme))
{
dungeon.Theme = "Dungeon";
}
if (!colorPattern.IsMatch(dungeon.RockColor))
{
dungeon.RockColor = "#794a1c";
}
if (!colorPattern.IsMatch(dungeon.FloorColor))
{
dungeon.FloorColor = "#be9641";
}
//TODO: When Theme is changed -- set default colors for theme.
var generator = new DungeonGenerator<Cell>();
var config = dungeon.GetConfig();
var map = generator.Generate(config);
var result = new StringBuilder();
result.AppendLine("<table class='map dungeon'>");
for (int y = 0; y < map.Height; y++)
{
result.AppendLine("<tr>");
for (int x = 0; x < map.Width; x++)
{
var cell = map.GetCell(y, x);
var adj = map.GetAllAdjacentCellsByDirection(cell);
switch (cell.Terrain)
{
case (TerrainType.Rock):
result.Append("<td class='rock'></td>");
break;
case (TerrainType.Door):
if (adj[Direction.East] == null || adj[Direction.East].Terrain == TerrainType.Rock)
{
result.Append("<td class='door east west'></td>");
}
else
{
result.Append("<td class='door north south'></td>");
}
break;
case (TerrainType.Floor):
var walls = new List<string>();
if (adj[Direction.North] == null || adj[Direction.North].Terrain == TerrainType.Rock) walls.Add("north");
if (adj[Direction.South] == null || adj[Direction.South].Terrain == TerrainType.Rock) walls.Add("south");
if (adj[Direction.East] == null || adj[Direction.East].Terrain == TerrainType.Rock) walls.Add("east");
if (adj[Direction.West] == null || adj[Direction.West].Terrain == TerrainType.Rock) walls.Add("west");
result.Append("<td class='" + string.Join(" ", walls.ToArray()) + "'></td>");
break;
}
result.AppendLine();
}
result.AppendLine("</tr>");
}
result.AppendLine("</table>");
dungeon.Result = result.ToString();
ViewBag.DungeonTable = result.ToString();
return View(dungeon);
}
protected abstract void PrepareForCulling(DungeonGenerator generator, Dungeon dungeon);
private void Awake()
{
dg = FindObjectOfType <DungeonGenerator>();
}
/// <summary>
/// Create an adjacent room on selected side.
/// </summary>
/// <param name="side"></param>
/// <param name="opening_location"></param>
/// <returns></returns>
public (IRoom, Vector3) CreateAdjacentRoom()
{
//Chose if next room is gonna be corridor or room.
string room_corridor = RandomnessMaestro.GetInstance().Choose_Room_Or_Corridor();
List <string> available_rooms = new List <string>();
//Get all the available rooms based on the available sides of the current room.
foreach (string availableSide in Available_Sides)
{
available_rooms.AddRange(ValidationMaestro.GetAppropriateRooms(room_corridor, GetAdjacentSide(availableSide)));
}
available_rooms = available_rooms.Distinct().ToList();//Remove duplicates.
if (room_corridor == "Room")
{
string roomsize = RandomnessMaestro.GetInstance().Choose_Room_Size(); //Select the room size.
(int sizex, int sizez) = DataManager.GetInstance().Search_Sizes_Dictionary(roomsize); //Get the room size data.
IRoom new_room = RoomFactory.Build(RandomnessMaestro.GetInstance().Choose_Room_Type(available_rooms), PrefabManager.GetInstance().GetAllRoomTiles(), sizex, sizez); //Construct the new room.
string connectionSide = "";
foreach (string avside in Available_Sides)
{
if (new_room.Available_Sides.Contains(GetAdjacentSide(avside)))
{
connectionSide = avside;
break;
}
}//Find the connection side between the current room and the new one.
string adjside = GetAdjacentSide(connectionSide);//Get the side that the new room needs to have available.
int openindex = CalculateOpening(connectionSide);
Vector3 opening_location = Instantiated_Tiles[openindex].transform.position; //Location of the tile that the opening is gonna be.
int new_opening_index = new_room.CalculateOpening(adjside); //Calculate the opening of the new room.
//Place new adjacent room appropriately.
Vector3 new_placed_location = LocationManager.GetApropriateLocationForRoom(connectionSide, opening_location, new_opening_index, new_room.Tiles_number_x, new_room.Tiles_number_z);
bool end = false;
//While location is taken by another object.
while (!ValidationMaestro.IsNotClaimed(new_placed_location, new_room.Tiles_number_x, new_room.Tiles_number_z) && !end)
{
//If the smallest room doesn't fit, stop.
if (roomsize == "Small")
{
end = true;
}
//Return a smaller size.
(roomsize, sizex, sizez) = DataManager.GetInstance().ReturnSmallerSize(roomsize, 1);
//Re-Construct the room.
new_room = RoomFactory.Build(RandomnessMaestro.GetInstance().Choose_Room_Type(available_rooms), PrefabManager.GetInstance().GetAllRoomTiles(), sizex, sizez);
//Re-Calculate opening.
new_opening_index = new_room.CalculateOpening(adjside);
//Re-Place the room appropriately.
new_placed_location = LocationManager.GetApropriateLocationForRoom(connectionSide, opening_location, new_opening_index, new_room.Tiles_number_x, new_room.Tiles_number_z);
}
if (end)//if smaller doesn't fit.
{
this.Available_Sides.Remove(connectionSide);
return(null, new Vector3(0, 0, 0));
}
if (new_room.Type.Equals("EndRoom"))//Check if the floor end room is placed.
{
new_room.Available_Sides.Clear();
RandomnessMaestro.GetInstance().endRoomPlaced = true;
Debug.LogError("Placed end room at: " + DungeonGenerator.GetInstance().roomsPlaced);
}
//If everything is okay, place the room normally.
this.Available_Sides.Remove(connectionSide);
new_room.Available_Sides.Remove(adjside);
if (this.Category.Equals("Room"))
{
CreateOpening(openindex, connectionSide); //Create opening if this is a room.
}
Vector3 newopenloc = new_room.CreateOpening(new_opening_index, adjside); //Create opening to the adjacent room.
//Make this room parent of the new one.
if (this.Category == "Room")
{
switch (connectionSide)
{
case "Left":
this.AdjRoomLeft = new_room;
break;
case "Top":
this.AdjRoomTop = new_room;
break;
case "Right":
this.AdjRoomRight = new_room;
break;
case "Bottom":
this.AdjRoomBottom = new_room;
break;
}
}
else
{
((Basic_Corridor)this).Child = new_room;
}
switch (adjside)
{
case "Left":
((Basic_Room)new_room).AdjRoomLeft = this;
break;
case "Top":
((Basic_Room)new_room).AdjRoomTop = this;
break;
case "Right":
((Basic_Room)new_room).AdjRoomRight = this;
break;
case "Bottom":
((Basic_Room)new_room).AdjRoomBottom = this;
break;
}
return(new_room, new_placed_location);
}
else
{
//Choose randomly the type of corridor.
string corridor_chosen_type = RandomnessMaestro.GetInstance().Choose_Corridor_Type();
//Choose only corridors that match the type
List <string> proper_rooms = available_rooms.Where(x => x.Contains(corridor_chosen_type)).ToList();
IRoom new_room = RoomFactory.Build(proper_rooms[Random.Range(0, proper_rooms.Count - 1)], PrefabManager.GetInstance().GetAllCorridorTiles(), 1, 1);
string connectionSide = "";
foreach (string avside in Available_Sides)
{
if (new_room.Available_Sides.Contains(GetAdjacentSide(avside)))
{
connectionSide = avside;
break;
}
}
string adjside = GetAdjacentSide(connectionSide);
int openindex = CalculateOpening(connectionSide);
Vector3 opening_location = Instantiated_Tiles[openindex].transform.position;
//Calculate the opening of the new room.
int new_opening_index = new_room.CalculateOpening(adjside);
//Place new adjacent room appropriately.
Vector3 new_placed_location = LocationManager.GetApropriateLocationForRoom(connectionSide, opening_location, new_opening_index, new_room.Tiles_number_x, new_room.Tiles_number_z);
//If location is taken by another object.
if (!ValidationMaestro.IsNotClaimed(new_placed_location, new_room.Tiles_number_x, new_room.Tiles_number_z))
{
this.Available_Sides.Remove(connectionSide);
return(null, new Vector3(0, 0, 0));
}
else
{
if (this.Category.Equals("Room"))
{
CreateOpening(openindex, connectionSide);
}
this.Available_Sides.Remove(connectionSide);
new_room.Available_Sides.Remove(adjside);
if (this.Category == "Room")
{
switch (connectionSide)
{
case "Left":
this.AdjRoomLeft = new_room;
break;
case "Top":
this.AdjRoomTop = new_room;
break;
case "Right":
this.AdjRoomRight = new_room;
break;
case "Bottom":
this.AdjRoomBottom = new_room;
break;
}
}
else
{
((Basic_Corridor)this).Child = new_room;
}
((Basic_Corridor)new_room).Parent = this;
return(new_room, new_placed_location);
}
}
}
void Awake()
{
instance = this;
}
/// <summary>
/// Start this instance.
/// </summary>
public void Start()
{
// Get the dungeon generator component
dungeonGenerator = GetComponent<DungeonGenerator> ();
// Get the floor generator component
floorGenerator = GetComponent<FloorGenerator> ();
// Get the entrance generator component
entranceGenerator = GetComponent<EntranceGenerator> ();
}
// 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];
}
public void Start()
{
dungeonGenerator = GetComponent<DungeonGenerator> ();
roomGenerator = GetComponent<RoomGenerator> ();
perimeterGenerator = GetComponent<PerimeterGenerator> ();
entranceGenerator = GetComponent<EntranceGenerator> ();
sceneryGenerator = GetComponent<SceneryGenerator> ();
}
static void Main()
{
DungeonGenerator dunGen = new DungeonGenerator();
LabMapContainer dungeon = dunGen.CreateSimpleDungeonMap(10, true);
DungeonRoom[] roomParams = { new DungeonRoom(RoomType.KeyLockedRoom), new DungeonRoom(RoomType.SecretRoom), new DungeonRoom(RoomType.SecretRoom), new DungeonRoom(RoomType.CollapsedRoom) };
Console.WriteLine(dungeon.ToString());
for (int i = 0; i < 100; i++)
{
dungeon = dunGen.CreateSimpleDungeonMap(8, true, roomParams);
using (StreamWriter sw = File.AppendText(@"dungeons260716-COLUMNS1.dnn"))
sw.WriteLine(dungeon.ToString());
}
Console.WriteLine("Success");
Console.ReadKey();
}
// Use this for initialization
void Start()
{
mGenerator = new DungeonGenerator<Cell>();
mBuilder = mGenerator.GenerateA()
.MediumDungeon()
.ABitRandom()
.SomewhatSparse()
.WithMediumChanceToRemoveDeadEnds()
.WithMediumSizeRooms()
.WithLargeNumberOfRooms();
mPrefabByWalls[EAST] = E;
mPrefabByWalls[EAST | WEST] = EW;
mPrefabByWalls[NORTH] = N;
mPrefabByWalls[NORTH | EAST] = NE;
mPrefabByWalls[NORTH | EAST | WEST] = NEW;
mPrefabByWalls[NORTH | EAST | SOUTH] = NES;
mPrefabByWalls[NORTH | EAST | WEST | SOUTH] = NEWS;
mPrefabByWalls[NORTH | SOUTH] = NS;
mPrefabByWalls[NORTH | SOUTH | WEST] = NSW;
mPrefabByWalls[NORTH | WEST] = NW;
mPrefabByWalls[0] = OPEN;
mPrefabByWalls[SOUTH] = S;
mPrefabByWalls[SOUTH | EAST] = SE;
mPrefabByWalls[SOUTH | EAST | WEST] = SEW;
mPrefabByWalls[SOUTH | WEST] = SW;
mPrefabByWalls[WEST] = W;
mCamHalfHeight = Camera.main.orthographicSize;
mCamHalfWidth = Camera.main.aspect * mCamHalfHeight;
mTopLeftPosition = new Vector3(-mCamHalfWidth + mMargin, mCamHalfHeight + mMargin, 0) + Camera.main.transform.position;
Generate();
}
// START:
/// <summary>
/// Start this instance.
/// </summary>
public void Start()
{
// Get the dungeon generator component
dungeonGenerator = GetComponent<DungeonGenerator> ();
corridorGenerator = GetComponent<CorridorGenerator> ();
}
public DungeonFeatureGenerator()
{
dungeonGenerator = DungeonGenerator.instance;
dungeon = Dungeon.instance;
grid = Grid.instance;
}
private static void OnGameUpdate(object sender, UpdateEventArgs e)
{
bool didPlayerAct = false;
RLKeyPress keyPress = rootConsole.Keyboard.GetKeyPress();
if (CommandSystem.IsPlayerTurn)
{
if (CommandSystem.PlayerIsDead)
{
time.Stop();
ts = time.Elapsed;
DeathMenu();
}
if (CommandSystem.IsGameEnded)
{
time.Stop();
ts = time.Elapsed;
WinMenu();
}
if (keyPress != null)
{
if (keyPress.Key == RLKey.Up)
{
didPlayerAct = CommandSystem.MovePlayer(Direction.Up);
}
else if (keyPress.Key == RLKey.Down)
{
didPlayerAct = CommandSystem.MovePlayer(Direction.Down);
}
else if (keyPress.Key == RLKey.Left)
{
didPlayerAct = CommandSystem.MovePlayer(Direction.Left);
}
else if (keyPress.Key == RLKey.Right)
{
didPlayerAct = CommandSystem.MovePlayer(Direction.Right);
}
else if (keyPress.Key == RLKey.I)
{
if (Player.Items.Count != 0)
{
inventoryConsole.Print(0, 2, ">", Colors.Text);
renderRequired = true;
rootConsole.Update -= OnGameUpdate;
rootConsole.Update += OnItemUpdate;
}
}
else if (keyPress.Key == RLKey.Escape)
{
rootConsole.Title = "MagiCave";
menuConsole.Clear();
for (int i = 0; i < 4; i++)
{
menuConsole.Print((menuConsole.Width - pauseOptions[i].Length) / 2, 40 + i * 5, pauseOptions[i], RLColor.White);
}
menuConsole.Print((menuConsole.Width - pauseOptions[0].Length) / 2, 40, pauseOptions[0], RLColor.LightRed);
Pause();
}
else if (keyPress.Key == RLKey.Period)
{
if (DungeonMap.CanMoveDownToNextLevel())
{
if (CurrentLevel.Next == null)
{
DungeonMap.SetIsWalkable(Player.X, Player.Y, true);
// If this is going to be a final level
if (mapLevel == 4)
{
SchedulingSystem A_SchedulingSystem = new SchedulingSystem();
CurrentSchedulingSystem = CurrentSchedulingSystem.Next;
CurrentSchedulingSystem = SchedulingSystems.AddLast(A_SchedulingSystem);
SchedulingSystem = A_SchedulingSystem;
DungeonGenerator mapGenerator = new DungeonGenerator(mapWidth, mapHeight, 20, 15, 7, ++mapLevel);
DungeonMap = mapGenerator.CreateFinalLevel(SchedulingSystem);
rootConsole.Title = $"MagiCave - Level {mapLevel}";
DungeonMap.UpdatePlayerFieldOfView();
didPlayerAct = true;
}
// Creating generic level
else
{
SchedulingSystem A_SchedulingSystem = new SchedulingSystem();
CurrentSchedulingSystem = CurrentSchedulingSystem.Next;
CurrentSchedulingSystem = SchedulingSystems.AddLast(A_SchedulingSystem);
SchedulingSystem = A_SchedulingSystem;
DungeonGenerator mapGenerator = new DungeonGenerator(mapWidth, mapHeight, 20, 15, 7, ++mapLevel);
DungeonMap = mapGenerator.CreateMap(SchedulingSystem);
rootConsole.Title = $"MagiCave - Level {mapLevel}";
didPlayerAct = true;
DungeonMap.UpdatePlayerFieldOfView();
}
CurrentLevel = CurrentLevel.Next;
CurrentLevel = Levels.AddLast(DungeonMap);
}
// Moving to already created level
else
{
DungeonMap.SetIsWalkable(Player.X, Player.Y, true);
DungeonMap = CurrentLevel.Next.Value;
Player.X = DungeonMap.Rooms.First()[DungeonMap.Rooms.First().Count / 2].X;
Player.Y = DungeonMap.Rooms.First()[DungeonMap.Rooms.First().Count / 2].Y;
SchedulingSystem = CurrentSchedulingSystem.Next.Value;
CurrentSchedulingSystem = CurrentSchedulingSystem.Next;
rootConsole.Title = $"MagiCave - Level {++mapLevel}";
didPlayerAct = true;
CurrentLevel = CurrentLevel.Next;
DungeonMap.UpdatePlayerFieldOfView();
}
}
// Moving to the previous level
if (DungeonMap.CanMoveUpToPreviousLevel() && !didPlayerAct)
{
if (CurrentLevel.Previous != null)
{
DungeonMap.SetIsWalkable(Player.X, Player.Y, true);
DungeonMap = CurrentLevel.Previous.Value;
SchedulingSystem = CurrentSchedulingSystem.Previous.Value;
CurrentSchedulingSystem = CurrentSchedulingSystem.Previous;
Player.X = DungeonMap.Rooms.Last()[DungeonMap.Rooms.Last().Count / 2].X;
Player.Y = DungeonMap.Rooms.Last()[DungeonMap.Rooms.Last().Count / 2].Y;
rootConsole.Title = $"MagiCave - Level {--mapLevel}";
didPlayerAct = true;
CurrentLevel = CurrentLevel.Previous;
DungeonMap.UpdatePlayerFieldOfView();
}
}
}
}
if (didPlayerAct)
{
steps++;
renderRequired = true;
CommandSystem.EndPlayerTurn();
}
}
else
{
CommandSystem.ActivateMonsters(SchedulingSystem);
renderRequired = true;
}
}
public static void Main(string[] args)
{
string usage = "\tUsage: $ DungeonGenerator.exe <width> <height> <seed>\n\tNote: Each dimension must be at least 3.\n\t\tAn average dimension size of 10 is optimal.";
if (args.Length < 3)
{
Console.WriteLine(usage);
System.Environment.Exit(1);
}
int width = Convert.ToInt32(args[0]);
int height = Convert.ToInt32(args[1]);
int seed = Convert.ToInt32(args[2]);
if(width < 3 || height < 3)
{
Console.WriteLine(usage);
System.Environment.Exit(1);
}
DungeonGenerator generator = new DungeonGenerator(width, height, seed);
generator.generateRooms();
generator.connectRooms();
generator.encodeRooms();
generator.addWalls();
generator.encodeWalls();
//generator.printColoredMap();
generator.printTextMap();
}
public void GenearateRooms(int randomSeed, int countRoom, Action onFinish = null)
{
RandomSeed = randomSeed;
sizeGridX = countRoom / 2;
sizeGridY = countRoom / 2;
NumbersOfRoom = countRoom;
Random.InitState(RandomSeed);
worldIsFinish = false;
DungeonGenerator generator = new DungeonGenerator(sizeGridX, sizeGridY, NumbersOfRoom);
rooms = null;
rooms = new Room[sizeGridX, sizeGridY];
rooms = generator.Generate();
ItemGenerator itemGenerator = new ItemGenerator();
for (int x = 0; x < sizeGridX; x++)
{
for (int y = 0; y < sizeGridY; y++)
{
if (rooms[x, y] != null)
{
switch (rooms[x, y].RoomType)
{
case RoomType.Start:
{
rooms[x, y].ShowRoom(CellDiametr, null);
startRoom = rooms[x, y];
break;
}
case RoomType.End:
{
rooms[x, y].ShowRoom(CellDiametr, null);
endRoom = rooms[x, y];
break;
}
default:
{
rooms[x, y].ShowRoom(CellDiametr, itemGenerator.GetRandomObject(rooms[x, y].RoomType));
break;
}
}
}
else
{
rooms[x, y] = new Room(CellDiametr, x, y, false, false, false, false, RoomType.Empty);
}
}
}
SizeWorld = rooms[sizeGridX - 1, sizeGridY - 1].WorldPosition;
// if(Math.Abs(SizeWorld.x % 10) < Mathf.Epsilon)
// SizeWorld += Vector2.one * CellDiametr;
worldIsFinish = true;
if (onFinish != null)
{
onFinish();
}
}
// Use this for initialization
public void Start()
{
dungeonGenerator = GetComponent<DungeonGenerator> ();
caveCellGrid = new CellType[dungeonGenerator.numCellsX, dungeonGenerator.numFloors, dungeonGenerator.numCellsZ];
}
private DungeonGenerator()
{
instance = this;
}
/// <summary>
/// Used for initialization.
/// </summary>
public void Start()
{
dungeonGenerator = GetComponent<DungeonGenerator> ();
roomGenerator = GetComponent<RoomGenerator> ();
}
public JsonResult GetMap()
{
return(Json(DungeonGenerator.Generate(null)));
}
/// <summary>
/// Used for initialization.
/// </summary>
public void Start()
{
dungeonGenerator = GetComponent<DungeonGenerator> ();
prefabCellWidth = Cell_Empty.localScale.x;
prefabCellHeight = Cell_Empty.localScale.z;
floorHeight = Cell_Empty.localScale.y / 2;
}
void Start()
{
dungeonGeneratorInstance = GameObject.FindObjectOfType <DungeonGenerator>();
}