public override Vector2Int[] GetConnectionPoints(Primitives other) { int xDis = GetXDistance(other); int yDis = GetYDistance(other); if (other is RectAnglePrimitive) { RectAnglePrimitive otherRect = (RectAnglePrimitive)other; if (xDis < 0) { // Primitivs overlap in the x axis. int xTunnel = 0; if (origin.x < otherRect.origin.x) { xTunnel = (int)((otherRect.origin.x + origin.x + size.x) / 2); } else { xTunnel = (int)((origin.x + otherRect.origin.x + otherRect.size.x) / 2); } if (origin.y < otherRect.origin.y) { return(new Vector2Int[] { new Vector2Int(xTunnel, origin.y + size.y), new Vector2Int(xTunnel, otherRect.origin.y) }); } else { return(new Vector2Int[] { new Vector2Int(xTunnel, otherRect.origin.y + otherRect.size.y), new Vector2Int(xTunnel, origin.y) }); } } else if (yDis < 0) { // Primitivs overlap in the x axis. int yTunnel = 0; if (origin.y < otherRect.origin.y) { yTunnel = (int)((otherRect.origin.y + origin.y + size.y) / 2); } else { yTunnel = (int)((origin.y + otherRect.origin.y + otherRect.size.y) / 2); } if (origin.x < otherRect.origin.x) { return(new Vector2Int[] { new Vector2Int(origin.x + size.x, yTunnel), new Vector2Int(otherRect.origin.x, yTunnel) }); } else { return(new Vector2Int[] { new Vector2Int(otherRect.origin.x + otherRect.size.x, yTunnel), new Vector2Int(origin.x, yTunnel) }); } } } return(null); }
private void AddRoom() { int width = UnityEngine.Random.Range(roomWidth / 2, roomWidth); int height = UnityEngine.Random.Range(roomHeight / 2, roomHeight); int xOrigin = UnityEngine.Random.Range(1, currentMap.GetLength(0) - width - 1); int yOrigin = UnityEngine.Random.Range(1, currentMap.GetLength(1) - height - 1); RectAnglePrimitive newRect = new RectAnglePrimitive(new Vector2Int(xOrigin, yOrigin), new Vector2Int(width, height)); Room newRoom = new Room(newRect); // Check if this room poses any problems. List <Room> overlappinRooms = new List <Room>(); // Adds up all primitives that the new potential room would have. int primitiveCountOfNewRoom = 1; int sizeOfNewRoom = newRect.GetSize(); foreach (Room r in rooms) { if (newRoom.DoesRoomOverlap(r)) { // Found an overlapping room that can't be merged. if (!r.canMerge) { return; } primitiveCountOfNewRoom += r.primitives.Count; overlappinRooms.Add(r); sizeOfNewRoom += r.size; } } // Check if the new room would be to big. if (sizeOfNewRoom > maxRoomSize) { return; } // Check if the new room would have more primitives that allowed. if (primitiveCountOfNewRoom > maxRoomPrimitives) { return; } foreach (Room r in overlappinRooms) { rooms.Remove(r); newRoom.MergeRooms(r); } rooms.Add(newRoom); }
public override int GetYDistance(Primitives other) { if (other is RectAnglePrimitive) { RectAnglePrimitive otherRect = (RectAnglePrimitive)other; if (origin.y < otherRect.origin.y) { return(otherRect.origin.y - origin.y - size.y); } else { return(origin.y - otherRect.origin.y - otherRect.size.y); } } return(int.MaxValue); }
public bool RectangleCollision(RectAnglePrimitive other) { // Checks the collision between to rectancles by checking each axis seperatately. // If there is one axis in which the rectangles don't overlap, the rectalgles themself do therefore not collider. // The walls around the rectangles are still considered to be part of the room and // are therefore also calculated in this method. // Check x axis. if (origin.x + size.x + 1 <= other.origin.x - 1 || other.origin.x + other.size.x + 1 <= origin.x - 1) { return(false); } // Check y axis. if (origin.y + size.y + 1 <= other.origin.y - 1 || other.origin.y + other.size.y + 1 <= origin.y - 1) { return(false); } // Rectangles overlap in both axis and therefore they overlap as a whole. return(true); }
public override Primitives Copy() { RectAnglePrimitive newRect = new RectAnglePrimitive(origin, size); return(newRect); }
private void CheckVerticalDoubleTunnel(int x, int y, int tunnelWidth) { int endY = 0; bool failedToConnect = false; int startRoomIndex = currentMap[x, y]; if (startRoomIndex < 0 || startRoomIndex >= rooms.Count) { return; } Room startRoom = rooms[startRoomIndex]; Room endRoom = null; int endRoomIndex = 0; // Check in x direction. // Go throught for the whole width of the tunnel. for (int i = 0; i < tunnelWidth && x + i < currentMap.GetLength(0) && !failedToConnect; i++) { // Check if this a tile next to a wall and a potential connecting point for a tunnel. if (currentMap[x + i, y + 1] != -1) { break; } bool canConnectInThisRow = false; // Try to find an other room within the maximum tunnel legth. for (int j = 0; j < straightTunnelMax && j + y < currentMap.GetLength(1) && !failedToConnect; j++) { int value = currentMap[x + i, y + j]; if (value == -1 || value == startRoomIndex) { continue; } // First to hit an other room. if (endRoom == null) { if (startRoom.IsConnectedTo(rooms[value])) { failedToConnect = true; break; } endRoomIndex = value; endRoom = rooms[endRoomIndex]; endY = y + j; canConnectInThisRow = true; break; } else { // Check if the connection point has the same y as the previous one. if (endY != y + j) { failedToConnect = true; } else { canConnectInThisRow = true; } break; } } if (!canConnectInThisRow) { failedToConnect = true; } } if (!failedToConnect && startRoom != null && endRoom != null) { float ran = UnityEngine.Random.Range(0, 100); if (ran < tunnelRate) { rooms[startRoomIndex].ConnectNewRoom(rooms[endRoomIndex]); rooms[endRoomIndex].ConnectNewRoom(rooms[startRoomIndex]); RectAnglePrimitive rext = new RectAnglePrimitive(new Vector2Int(x, y + 1), new Vector2Int(tunnelWidth, endY - y - 1)); floors.Add(new Tunnel(new Primitives[] { rext }, TunnelDirection.Horizontal)); } } }