173 lines
3.9 KiB
C#
173 lines
3.9 KiB
C#
//$ Copyright 2015-22, Code Respawn Technologies Pvt Ltd - All Rights Reserved $//
|
|
using UnityEngine;
|
|
using System.Collections.Generic;
|
|
|
|
namespace DungeonArchitect
|
|
{
|
|
/// <summary>
|
|
/// Represents an integer rectangle
|
|
/// </summary>
|
|
[System.Serializable]
|
|
public struct Rectangle {
|
|
public Rectangle(int x, int z, int width, int length) {
|
|
location = new IntVector(x, 0, z);
|
|
size = new IntVector(width, 0, length);
|
|
}
|
|
public Rectangle(IntVector location, IntVector size) {
|
|
this.location = location;
|
|
this.size = size;
|
|
}
|
|
|
|
[SerializeField]
|
|
IntVector location;
|
|
public IntVector Location {
|
|
get {
|
|
return location;
|
|
}
|
|
set {
|
|
location = value;
|
|
}
|
|
}
|
|
|
|
[SerializeField]
|
|
IntVector size;
|
|
public IntVector Size {
|
|
get {
|
|
return size;
|
|
}
|
|
set {
|
|
size = value;
|
|
}
|
|
}
|
|
|
|
public int X {
|
|
get { return Location.x; }
|
|
}
|
|
public int Z {
|
|
get { return Location.z; }
|
|
}
|
|
public int Width {
|
|
get { return Size.x; }
|
|
}
|
|
public int Length {
|
|
get { return Size.z; }
|
|
}
|
|
|
|
public int Left { get { return X; } }
|
|
public int Right { get { return X + Width; } }
|
|
public int Back { get { return Z; } }
|
|
public int Front { get { return Z + Length; } }
|
|
|
|
public void SetY(int y) {
|
|
location.y = y;
|
|
}
|
|
|
|
public IntVector Center() {
|
|
return Location + Size / 2;
|
|
}
|
|
|
|
static Vector3 ToVector3(IntVector iv) {
|
|
return new Vector3(iv.x, iv.y, iv.z);
|
|
}
|
|
|
|
public Vector3 CenterF() {
|
|
return ToVector3(Location) + ToVector3(Size) / 2.0f;
|
|
}
|
|
|
|
public bool Contains(Rectangle rect) {
|
|
return(X <= rect.X) &&
|
|
((rect.X + rect.Width) <= (X + Width)) &&
|
|
(Z <= rect.Z) &&
|
|
((rect.Z + rect.Length) <= (Z + Length));
|
|
}
|
|
|
|
public bool Contains(IntVector Point) {
|
|
return Contains(Point.x, Point.z);
|
|
}
|
|
|
|
public bool Contains(int x, int z) {
|
|
return this.X <= x &&
|
|
x < this.X + this.Width &&
|
|
this.Z <= z &&
|
|
z < this.Z + this.Length;
|
|
}
|
|
|
|
public static Rectangle Intersect(Rectangle a, Rectangle b) {
|
|
int x1 = Mathf.Max(a.X, b.X);
|
|
int x2 = Mathf.Min(a.X + a.Width, b.X + b.Width);
|
|
int z1 = Mathf.Max(a.Z, b.Z);
|
|
int z2 = Mathf.Min(a.Z + a.Length, b.Z + b.Length);
|
|
|
|
if (x2 >= x1 && z2 >= z1) {
|
|
return new Rectangle(x1, z1, x2 - x1, z2 - z1);
|
|
}
|
|
return new Rectangle();
|
|
}
|
|
|
|
public bool IntersectsWith(Rectangle rect) {
|
|
return(rect.X < X + Width) &&
|
|
(X < (rect.X + rect.Width)) &&
|
|
(rect.Z < Z + Length) &&
|
|
(Z < rect.Z + rect.Length);
|
|
}
|
|
|
|
|
|
|
|
public static Rectangle ExpandBounds(Rectangle rect, int distance)
|
|
{
|
|
|
|
var location = rect.Location;
|
|
var size = rect.Size;
|
|
|
|
location.x -= distance;
|
|
location.z -= distance;
|
|
|
|
size.x += distance * 2;
|
|
size.z += distance * 2;
|
|
|
|
var result = rect;
|
|
result.location = location;
|
|
result.size = size;
|
|
|
|
return result;
|
|
}
|
|
|
|
public IntVector[] GetBorderPoints()
|
|
{
|
|
var result = new List<IntVector>();
|
|
for (int dx = 0; dx < size.x; dx++)
|
|
{
|
|
var x = location.x + dx;
|
|
var y = location.y;
|
|
var z = location.z;
|
|
var point = new IntVector(x, y, z);
|
|
result.Add(point);
|
|
|
|
if (size.z > 1) {
|
|
z = location.z + size.z - 1;
|
|
point = new IntVector(x, y, z);
|
|
result.Add(point);
|
|
}
|
|
}
|
|
|
|
for (int dz = 1; dz < size.z - 1; dz++)
|
|
{
|
|
var x = location.x;
|
|
var y = location.y;
|
|
var z = location.z + dz;
|
|
var point = new IntVector(x, y, z);
|
|
result.Add(point);
|
|
|
|
if (size.x > 1) {
|
|
x = location.x + size.x - 1;
|
|
point = new IntVector(x, y, z);
|
|
result.Add(point);
|
|
}
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
};
|
|
|
|
}
|