void GenerateRoomCenter(GameObject roomBorder)
{
RoomCenter roomCenterSelected;
if (roomBorder == roomBorders[0])
{
roomCenterSelected = roomCenterStart;
}
else if (roomBorder == roomBorders[roomBorders.Count - 1])
{
roomCenterSelected = roomCenterEnd;
}
else if (roomBorder == roomBorders[shopRoomIndex])
{
roomCenterSelected = roomCenterShop;
}
else
{
roomCenterSelected = roomCenters[Random.Range(0, roomCenters.Length)];
}
RoomCenter newRoomCenter = (RoomCenter)Instantiate(roomCenterSelected, roomBorder.transform.position, roomBorder.transform.rotation);
newRoomCenter.theRoom = roomBorder.GetComponent <RoomController>();
}
private void AttachCenterToOutline(RoomCenter roomCenter, GameObject outline)
{
RoomCenter newCenter = Instantiate(
roomCenter,
outline.transform.position,
outline.transform.rotation
);
newCenter.theRoom = outline.GetComponent <Room>();
}
Transform[,] mapGenerator(List <Room> roomList, Transform[,] emptyMap)
{
for (int k = 0; k < roomList.Count - 1; k++)
{
RoomCenter firstRoom = roomList[k].FindCenter();
RoomCenter secondRoom = roomList[k + 1].FindCenter();
int xIndex = firstRoom.x;
if (firstRoom.x > secondRoom.x)
{
int xHallLength = firstRoom.x - secondRoom.x;
for (int i = 0; i < xHallLength; i++)
{
emptyMap[firstRoom.x - i, firstRoom.y] = floor;
emptyMap[firstRoom.x - i, firstRoom.y + 1] = floor;
}
xIndex = firstRoom.x - xHallLength;
}
else if (firstRoom.x < secondRoom.x)
{
int xHallLength = secondRoom.x - firstRoom.x;
for (int i = 0; i < xHallLength; i++)
{
emptyMap[firstRoom.x + i, firstRoom.y] = floor;
emptyMap[firstRoom.x + i, firstRoom.y + 1] = floor;
}
xIndex = firstRoom.x + xHallLength;
}
if (firstRoom.y > secondRoom.y)
{
int yHallLength = firstRoom.y - secondRoom.y;
for (int i = 0; i < yHallLength; i++)
{
emptyMap[xIndex, firstRoom.y - i] = floor;
emptyMap[xIndex + 1, firstRoom.y - i] = floor;
}
}
else if (firstRoom.y < secondRoom.y)
{
int yHallLength = secondRoom.y - firstRoom.y;
for (int i = 0; i < yHallLength; i++)
{
emptyMap[xIndex, firstRoom.y + i] = floor;
emptyMap[xIndex + 1, firstRoom.y + i] = floor;
}
}
}
return(emptyMap);
}
public Transform[,] MakeRoom(Transform[,] emptyMap)
{
for (int i = xCorner; i < xCorner + xSize; i++)
{
for (int j = yCorner; j < yCorner + ySize; j++)
{
if (CheckOverlap(emptyMap[i, j]))
{
return(emptyMap);
}
}
}
for (int i = xCorner; i < xCorner + xSize; i++)
{
for (int j = yCorner; j < yCorner + ySize; j++)
{
emptyMap[i, j] = basicFloor;
}
}
center = FindCenter();
return(emptyMap);
}
public void PopulateRoomCenters()
{
// TODO: BETTER PROCEDURAL LEVEL GENERATION
// For now, we want to pick a random room center and assign it to each room outline.
// Plus, we want to make sure our room center knows which room it is in.
foreach (GameObject outline in generatedRoomOutlines)
{
bool generateCenter = true;
// Assign the start room' center first (which we know must be at Vector3.zero).
if (outline.transform.position == Vector3.zero)
{
RoomCenter start = Instantiate(centerStart, outline.transform.position, outline.transform.rotation);
start._myRoom = outline.GetComponent <Room>();
generateCenter = false;
}
// Assign the end room' center second (which we know must be at Vector3.zero).
if (outline.transform.position == endRoom.transform.position)
{
RoomCenter end = Instantiate(centerEnd, outline.transform.position, outline.transform.rotation);
end._myRoom = outline.GetComponent <Room>();
generateCenter = false;
}
// Finally, if we are allowed to generate a center for this room, we simply pick one random center.
if (generateCenter)
{
int randomCenterRoom = Random.Range(0, roomCenters.Length);
RoomCenter center = Instantiate(roomCenters[randomCenterRoom], outline.transform.position, outline.transform.rotation);
center._myRoom = outline.GetComponent <Room>();
}
}
}
void Start()
{
// Create dungeon shape
Instantiate(layoutRoom, generatorPoint.position, generatorPoint.rotation);
for (int i = 0; i < distanceToEnd; i++)
{
selectedDirection = (Direction)Random.Range(0, 4);
MoveGenerationPoint();
while (Physics2D.OverlapCircle(generatorPoint.position, .2f, whatIsRoom))
{
MoveGenerationPoint();
}
GameObject newRoom = Instantiate(layoutRoom, generatorPoint.position, generatorPoint.rotation);
layoutRoomObjects.Add(newRoom);
if (i + 1 == distanceToEnd)
{
layoutRoomObjects.RemoveAt(layoutRoomObjects.Count - 1);
endRoom = newRoom;
}
}
// Place room frames
CreateRoomOutline(Vector3.zero + zOffset);
foreach (GameObject room in layoutRoomObjects)
{
CreateRoomOutline(room.transform.position);
}
CreateRoomOutline(endRoom.transform.position);
// Place room centers
foreach (GameObject outline in generatedOutlines)
{
Vector3 centerPosition = new Vector3(outline.transform.position.x, outline.transform.position.y, outline.transform.position.z + 1);
RoomCenter currentCenter = null;
if (outline.transform.position == Vector3.zero + zOffset)
{
currentCenter = Instantiate(centerStart, centerPosition, transform.rotation);
}
else if (outline.transform.position == endRoom.transform.position)
{
currentCenter = Instantiate(centerEnd, centerPosition, transform.rotation);
endRoomCenter = currentCenter;
}
else
{
int centerSelect = Random.Range(0, potentialCenters.Length);
currentCenter = Instantiate(potentialCenters[centerSelect], centerPosition, transform.rotation);
}
roomCenters.Add(centerPosition, currentCenter);
currentCenter.theRoom = outline.GetComponent <Room>();
currentCenter.activator.doors = currentCenter.theRoom.doors;
}
foreach (KeyValuePair <Vector3, RoomCenter> entry in roomCenters)
{
// Store adjacent information
Vector3 roomPosition = entry.Key;
RoomActivator activator = entry.Value.activator;
List <Vector3> adjacents = new List <Vector3>()
{
roomPosition + new Vector3(0f, yOffset, 0f),
roomPosition + new Vector3(0f, -yOffset, 0f),
roomPosition + new Vector3(-xOffset, 0f, 0f),
roomPosition + new Vector3(xOffset, 0f, 0f)
};
foreach (Vector3 roomPos in adjacents)
{
activator.adjacent.Add(roomCenters.ContainsKey(roomPos) ? roomCenters[roomPos].activator : null);
}
// Store information on normal and boss room(s)
Vector3 endPos = endRoomCenter.transform.position;
activator.endRoom = roomPosition != endPos ? roomCenters[endPos].activator : null;
}
}
private void RoomOutlineGenerator()
{
InstantiateRoomOutline(Vector3.zero);
foreach (GameObject room in _roomObject)
{
InstantiateRoomOutline(room.transform.position);
}
if (_shop)
{
InstantiateRoomOutline(_shopRoom.transform.position);
}
if (_chest)
{
InstantiateRoomOutline(_chestRoom.transform.position);
}
InstantiateRoomOutline(_endRoom.transform.position);
foreach (GameObject outline in _generateOutline)
{
bool generateCenter = true;
if (outline.transform.position == Vector3.zero)
{
RoomCenter centerStartOutline = Instantiate(_centerStart, outline.transform.position, transform.rotation);
centerStartOutline.TheRoom = outline.GetComponent <Room>();
centerStartOutline.TheRoom.FirstRoomActive = true;
centerStartOutline.transform.parent = _roomSlot.transform;
generateCenter = false;
}
if (outline.transform.position == _endRoom.transform.position)
{
RoomCenter centerEndOutline = Instantiate(_centerEnd, outline.transform.position, transform.rotation);
centerEndOutline.TheRoom = outline.GetComponent <Room>();
centerEndOutline.transform.parent = _roomSlot.transform;
generateCenter = false;
}
if (_shop)
{
if (outline.transform.position == _shopRoom.transform.position)
{
RoomCenter centerShopOutline = Instantiate(_centerShop, outline.transform.position, transform.rotation);
centerShopOutline.TheRoom = outline.GetComponent <Room>();
centerShopOutline.transform.parent = _roomSlot.transform;
generateCenter = false;
}
}
if (_chest)
{
if (outline.transform.position == _chestRoom.transform.position)
{
RoomCenter centerChestOutline = Instantiate(_centerChest, outline.transform.position, transform.rotation);
centerChestOutline.TheRoom = outline.GetComponent <Room>();
centerChestOutline.transform.parent = _roomSlot.transform;
generateCenter = false;
}
}
if (generateCenter)
{
int centerSelect = Random.Range(0, _center.Length);
RoomCenter centerOutline = Instantiate(_center[centerSelect], outline.transform.position, transform.rotation);
centerOutline.TheRoom = outline.GetComponent <Room>();
centerOutline.transform.parent = _roomSlot.transform;
}
}
}
public void Move( RoomCenter room )
{
currentRoom = room;
moveAgent.destination = room.transform.position;
moveAgent.Resume();
}
// Start is called before the first frame update
void Start()
{
Instantiate(layoutRoom, generatorPoint.position, generatorPoint.rotation).GetComponent <SpriteRenderer>().color = startColor;
selectedDirection = (Direction)Random.Range(0, 4);
MoveGenerationPoint();
for (int i = 0; i < distanceToEnd; i++)
{
GameObject newRoom = Instantiate(layoutRoom, generatorPoint.position, generatorPoint.rotation);
layoutRoomObjects.Add(newRoom);
if (i + 1 == distanceToEnd)
{
newRoom.GetComponent <SpriteRenderer>().color = endColor;
layoutRoomObjects.RemoveAt(layoutRoomObjects.Count - 1);
endRoom = newRoom;
}
selectedDirection = (Direction)Random.Range(0, 4);
MoveGenerationPoint();
while (Physics2D.OverlapCircle(generatorPoint.position, .2f, whatIsRoom))
{
MoveGenerationPoint();
}
}
CreateRoomOutline(Vector3.zero);
foreach (GameObject room in layoutRoomObjects)
{
CreateRoomOutline(room.transform.position);
}
CreateRoomOutline(endRoom.transform.position);
foreach (GameObject outline in generatedOutlines)
{
bool generateCenter = true;
if (outline.transform.position == Vector3.zero)
{
Room startRoom = Instantiate(centerStart, outline.transform.position, transform.rotation).room = outline.GetComponent <Room>();
startRoom.noEnemies = true;
generateCenter = false;
}
if (outline.transform.position == endRoom.transform.position)
{
Room endRoom = Instantiate(centerEnd, outline.transform.position, transform.rotation).room = outline.GetComponent <Room>();
endRoom.noEnemies = true;
generateCenter = false;
}
if (generateCenter)
{
if (outline.GetComponent <Room>().onlyHorizontalEntry)
{
int centerSelected = Random.Range(0, horizontalCenters.Length);
currentCenter = Instantiate(horizontalCenters[centerSelected], outline.transform.position, transform.rotation);
currentCenter.room = outline.GetComponent <Room>();
foreach (GameObject enemy in currentCenter.enemies)
{
GameManager.instance.stageEnemies.Add(enemy);
}
}
else if (outline.GetComponent <Room>().onlyVerticalEntry)
{
int centerSelected = Random.Range(0, verticalCenters.Length);
currentCenter = Instantiate(verticalCenters[centerSelected], outline.transform.position, transform.rotation);
currentCenter.room = outline.GetComponent <Room>();
foreach (GameObject enemy in currentCenter.enemies)
{
GameManager.instance.stageEnemies.Add(enemy);
}
}
else
{
int centerSelected = Random.Range(0, potentialCenters.Length);
currentCenter = Instantiate(potentialCenters[centerSelected], outline.transform.position, transform.rotation);
currentCenter.room = outline.GetComponent <Room>();
foreach (GameObject enemy in currentCenter.enemies)
{
GameManager.instance.stageEnemies.Add(enemy);
}
}
}
}
GameManager.instance.GenerateKey();
}
