public static bool[,] createPeriodicalMap(RCT rct, char axis, int offset, int step)
{
bool[,] map = createLayerMap(rct);
int row, element, nextElement = step;
for (int x = 0; x < map.GetLength(0); x++)
{
for (int z = 0; z < map.GetLength(1); z++)
{
if (axis == 'v')
{
row = z;
element = x;
}
else
{
row = x;
element = z;
}
if (row == offset && element == nextElement)
{
nextElement += step;
map[x, z] = true;
}
else
{
map[x, z] = false;
}
}
}
return(map);
}
public List <MapElement> CreateOpenablePortal(RCT rct, string innername, string outername, string outsidename)
{
Portal exit = new Portal(rct, floorNumber, innername, outername, true);
RCT doorRCT = CreatePortal(exit);
MapElement mapElement = Stage.GetNode(doorRCT.Start, GetFloorNumber()).mapElement;
Portal entrence;
if (mapElement.GetType() == typeof(Building))
{
entrence = new Portal(doorRCT, floorNumber, innername, outsidename, false);
Building building = mapElement as Building;
building.CreatePortal(entrence);
}
else
{
entrence = new Portal(doorRCT, floorNumber, outername, outsidename, false);
Room room = mapElement as Room;
room.CreatePortal(entrence);
}
Portal.Bind(exit, entrence);
return(new List <MapElement>()
{
exit, entrence
});
}
public Room CreateRoom(RCT rct)
{
Room room = new Room(rct, floorNumber);
addNewElement(room);
return(room);
}
protected bool defaultIsWalkable;//доступен ли для передвижения по умолчанию
public Floor(int number, Stage stage)
{
this.number = number;
this.stage = stage;
this.rct = stage.rct.Clone();
map = new Node[stage.height, stage.width];
}
private RCT createRCT(CRD start, string furnitureDirection, int width, int height)
{
this.furnitureDirection = furnitureDirection;
RCT rct;
switch (furnitureDirection)
{
case "l":
rct = new RCT(start, width, height);
this.origin = rct.Start.Clone();
break;
case "r":
rct = new RCT(start, width, height);
this.origin = rct.End.Clone();
break;
case "t":
rct = new RCT(start, height, width);
origin = new CRD(rct.Start.x, rct.End.z);
break;
case "b":
rct = new RCT(start, height, width);
this.origin = new CRD(rct.End.x, rct.Start.z);
break;
default:
rct = new RCT(start, width, height);
this.origin = rct.Start.Clone();
break;
}
return(rct);
}
public override List <NodeLayer> HookAddLayersToNode(List <NodeLayer> layers, Node node)
{
NodeLayer door = new NodeLayer(getPrefabNuber(), "Premetives/Portal", name);
if (isExit)
{
door.direction = parentElement.rct.GetDirection(node.crd);
}
else
{
RCT dirRCT = Brother.parentElement.rct.Clone();
dirRCT.Grow();
door.direction = dirRCT.GetDirection(node.crd);
door.InvertDirection();
}
door.hasMesh = false;
NodeLayer wall = node.Layers.Find(x => x.direction == door.direction && (x.name == "InnerWall" || x.name == "OuterWall"));
node.Layers.Remove(wall);
if (IsOpened() && isExit)
{
node.UnlinkNode(Brother.childNodes[0]);
Brother.childNodes[0].UnlinkNode(node);
node.LinkNode(Brother.childNodes[0], 1 + monoPortal.ExtraWeight);
Brother.childNodes[0].LinkNode(node, 1 + monoPortal.ExtraWeight);
}
return(new List <NodeLayer>()
{
door
});
}
public static RCT Addition(RCT rct1, RCT rct2)
{
int sx1 = rct1.Start.x, sx2 = rct2.start.x, ex1 = rct1.end.x, ex2 = rct2.end.x, sz1 = rct1.start.z, sz2 = rct2.start.z, ez1 = rct1.end.z, ez2 = rct2.end.z;
int MINsx = Mathf.Min(sx1, sx2), MINsz = Mathf.Min(sz1, sz2), MAXex = Mathf.Max(ex1, ex2), MAXez = Mathf.Max(ez1, ez2);
return(new RCT(new CRD(MINsx, MINsz), new CRD(MAXex, MAXez)));
}
public override void Upgrade()
{
if (rct.Height >= 2 && rct.Width >= 2)
{
RCT crosswalkRct;
if (axis == 'v')
{
crosswalkRct = new RCT(new CRD(rct.Start.x + 1, rct.Start.z), new CRD(rct.End.x - 1, rct.End.z));
}
else
{
crosswalkRct = new RCT(new CRD(rct.Start.x, rct.Start.z + 1), new CRD(rct.End.x, rct.End.z - 1));
}
List <RCT> newRCTs = RCT.Cuttind(rct, crosswalkRct);
List <MapElement> newElements = new List <MapElement>();
for (int i = 0; i < newRCTs.Count; i++)
{
//newRCTs[i].DebugLog(this.ToString() + " id:" + this.id);
if (newRCTs[i].Equals(crosswalkRct))
{
newElements.Add(new CrossroadCrosswalk(newRCTs[i], floorNumber, axis));
}
else
{
newElements.Add(new CrossroadRoad(newRCTs[i], floorNumber, axis));
}
}
parentElement.moveNodesFromMapElementToThis(this);
parentElement.addNewElements(newElements);
}
base.Upgrade();
}
public void CreateStreet(RCT rct, int floor, char axis, int sidewalk) //добавляет улицу
{
List <MapElement> newElements = new List <MapElement>();
for (int i = 0; i < this.childElements.Count; i++)
{
if (this.childElements[i].rct.checkCollision(rct) && childElements[i].floorNumber == floor)
{
if (this.childElements[i] is Area)
{
RCT collision = RCT.getCollision(childElements[i].rct, rct);
List <RCT> newRcts = RCT.Cuttind(childElements[i].rct, collision);
for (int n = 0; n < newRcts.Count; n++)
{
if (newRcts[n].Equals(collision))
{
newElements.Add(new Street(collision, floor, axis, sidewalk));
}
else
{
newElements.Add(new Area(newRcts[n], floor));
}
}
}
else if (this.childElements[i] is Street)
{
Street oldstreet = this.childElements[i] as Street;
int hsidewalk, vsidewalk;
if (oldstreet.axis == 'v')
{
vsidewalk = oldstreet.sidewalk;
hsidewalk = sidewalk;
}
else
{
vsidewalk = sidewalk;
hsidewalk = oldstreet.sidewalk;
}
RCT collision = RCT.getCollision(oldstreet.rct, rct);
List <RCT> newRcts = RCT.Cuttind(oldstreet.rct, collision);
for (int n = 0; n < newRcts.Count; n++)
{
if (newRcts[n].Equals(collision))
{
newElements.Add(new Crossroad(collision, floor, vsidewalk, hsidewalk));
}
else
{
newElements.Add(new Street(newRcts[n], floor, oldstreet.axis, oldstreet.sidewalk));
}
}
}
moveNodesFromMapElementToThis(childElements[i]);
childElements.Remove(childElements[i]);
i--;
}
}
addNewElements(newElements);
}
public static CRD GetRandomCRD(RCT rct)
{
int dHeigth = Mathf.RoundToInt(Random.Range(0, (rct.Height - 1) * 100) / 100);
int dWidth = Mathf.RoundToInt(Random.Range(0, (rct.Width - 1) * 100) / 100);
CRD crd = new CRD(rct.Start.x + dHeigth, rct.Start.z + dWidth);
return(crd);
}
public Building CreateBuilding(RCT rct)
{
Building building = new Building(rct, floorNumber);
addNewElement(building);
building.Init();
return(building);
}
public MapElement(RCT rct, int floor)
{
childElements = new List <MapElement>();
childNodes = new List <Node>();
floorNumber = floor;
this.rct = rct;
id = iterator;
iterator++;
}
public Room CreateSubRoom(RCT rct)
{
Room room = new Room(rct, floorNumber);
room.parentElement = parentElement;
room.HookAddToChildElements();
room.moveNodesFromMapElementToThis(this);
parentElement.childElements.Add(room);
return(room);
}
public void GrowFor(RCT rct)
{
if (parentElement.rct.isContainRCT(rct))
{
Area parentArea = parentElement as Area;
parentArea.RemoveElement(this);
this.rct = RCT.Addition(this.rct, rct);
parentArea.addNewElement(this);
}
}
public bool Equals(RCT rct) // проверяет равны ли прямоугольники
{
if (this.Start == rct.Start && this.End == rct.End)
{
return(true);
}
else
{
return(false);
}
}
public bool checkCollision(RCT rct)// проверяет пересекается ли данный прямоугольник с указанным прямоугольником
{
if (rct.End.z < this.Start.z || rct.Start.z > this.End.z || rct.Start.x > this.End.x || rct.End.x < this.Start.x)
{
return(false);
}
else
{
return(true);
}
}
public bool isContainRCT(RCT rct)//// проверяет находится ли прямоугольник внутри прямоугольника
{
if (this.isContainCRD(rct.start) && this.isContainCRD(rct.end))
{
return(true);
}
else
{
return(false);
}
}
public MapElement AppendRoom(RCT rct)
{
RCT growRCT = new RCT(rct.Start.Clone().ReturnStepLT(), rct.End.Clone().ReturnStepRB());
if (parentElement.rct.isContainRCT(growRCT))
{
GrowFor(growRCT);
Room room = CreateRoom(rct);
return(room);
}
return(this);
}
public override void Upgrade()
{
RCT roadRCT = this.rct.Clone();
List <MapElement> newElements = new List <MapElement>();
if (axis == 'v')
{
int lines = roadRCT.Width / 2;
int firststripeWidth = lines / 2;
RCT rct = new RCT(roadRCT.Start, firststripeWidth * 2, this.rct.Height);
RoadStripe firsrStripe = new RoadStripe(rct, floorNumber, axis);
newElements.Add(firsrStripe);
lines -= firststripeWidth;
roadRCT.Start = new CRD(roadRCT.Start.x, roadRCT.Start.z += firststripeWidth * 2);
rct = new RCT(new CRD(roadRCT.Start.x, roadRCT.End.z - (lines * 2 - 1)), this.rct.End);
RoadStripe secontStripe = new RoadStripe(rct, floorNumber, axis);
newElements.Add(secontStripe);
roadRCT.End = new CRD(roadRCT.End.x, roadRCT.End.z -= lines * 2);
if (roadRCT.sq > 0)
{
RoadSafetyZone safetyZone = new RoadSafetyZone(roadRCT, floorNumber, axis);
newElements.Add(safetyZone);
}
}
else
{
int lines = roadRCT.Height / 2;
int firststripeWidth = lines / 2;
RCT rct = new RCT(roadRCT.Start, this.rct.Width, firststripeWidth * 2);
RoadStripe firsrStripe = new RoadStripe(rct, floorNumber, axis);
newElements.Add(firsrStripe);
lines -= firststripeWidth;
roadRCT.Start = new CRD(roadRCT.Start.x += firststripeWidth * 2, roadRCT.Start.z);
rct = new RCT(new CRD(roadRCT.End.x - (lines * 2 - 1), roadRCT.Start.z), this.rct.End);
RoadStripe secontStripe = new RoadStripe(rct, floorNumber, axis);
newElements.Add(secontStripe);
roadRCT.End = new CRD(roadRCT.End.x -= lines * 2, roadRCT.End.z);
if (roadRCT.sq > 0)
{
RoadSafetyZone safetyZone = new RoadSafetyZone(roadRCT, floorNumber, axis);
newElements.Add(safetyZone);
}
}
this.addNewElements(newElements);
newElements.Clear();
}
public override void Upgrade()
{
List <MapElement> mapElements = new List <MapElement>();
RCT road;
if (axis == 'v')
{
road = new RCT(new CRD(this.rct.Start.x, this.rct.Start.z + this.sidewalk), this.width - sidewalk * 2, this.rct.Height);
}
else
{
road = new RCT(new CRD(this.rct.Start.x + this.sidewalk, this.rct.Start.z), this.rct.Width, this.width - sidewalk * 2);
}
List <RCT> rcts = RCT.Cuttind(this.rct, road);
for (int i = 0; i < rcts.Count; i++)
{
if (rcts[i].Equals(road))
{
mapElements.Add(new Road(rcts[i], floorNumber, this.axis));
}
else
{
string direction;
if (axis == 'v')
{
if (rcts[i].Start.z < road.Start.z)
{
direction = "r";
}
else
{
direction = "l";
}
}
else
{
if (rcts[i].Start.x < road.Start.x)
{
direction = "b";
}
else
{
direction = "t";
}
}
mapElements.Add(new Sidewalk(rcts[i], floorNumber, this.axis, direction));
}
}
addNewElements(mapElements);
}
public UndergrounRoom AddUndergroundRoom(RCT rct)
{
UndergrounRoom room = new UndergrounRoom(rct);
MapElement dirt = childElements.Find(x => x.floorNumber == 0 && x.GetType() == typeof(UndergroundDirt));
if (dirt != null)
{
dirt.addNewElement(room);
return(room);
}
else
{
return(null);
}
}
public List <Node> GetSiblingsNoDiagonals()// Получение соседних узлов
{
List <Node> siblings = new List <Node>();
RCT rct = Stage.GetStage().rct;
for (int x = -1; x <= 1; x++)
{
for (int z = -1; z <= 1; z++)
{
if ((z == 0 && x == 0) || !rct.isContainCRD(new CRD(crd.x + x, crd.z + z)) || (z != 0 && x != 0))
{
continue;
}
siblings.Add(Stage.GetNode(crd.x + x, crd.z + z, floor.number));
}
}
return(siblings);
}
public Street(RCT rct, int floor, char axis, int sidewalk) : base(rct, floor)
{
//Debug.Log("RCT " + rct.Start.x + "," + rct.Start.z + ":" + rct.End.x + "," + rct.End.z + " h: " + rct.Height + " w: " + rct.Width);
this.sidewalk = sidewalk;
this.axis = axis;
if (axis == 'v')
{
this.width = rct.Width;
this.start = rct.Start.z;
}
else
{
this.width = rct.Height;
this.start = rct.Start.x;
}
//Debug.Log("NEW STREET RCT: h: " + rct.Height + " w: " + rct.Width);
//Debug.Log("Street RCT " + this.rct.Start.x + "," + this.rct.Start.z + ":" + this.rct.End.x + "," + this.rct.End.z+" h: "+this.rct.Height+" w: "+this.rct.Width);
}
public static bool[,] createRandomMap(RCT rct, int treshold)
{
bool[,] map = createLayerMap(rct);
for (int x = 0; x < map.GetLength(0); x++)
{
for (int z = 0; z < map.GetLength(1); z++)
{
if (Random.Range(0, 100) < treshold)
{
map[x, z] = true;
}
else
{
map[x, z] = false;
}
}
}
return(map);
}
public static List <RCT> Cuttind(RCT rct1, RCT rct2) // получает два прямоугольника и получает несколько новых являющихся частями порезанных старых
{
rct1.End.StepRB();
rct2.End.StepRB();
List <int> xlines = new List <int>();
List <int> zlines = new List <int>();
List <RCT> newRCTs = new List <RCT>();
xlines.Add(rct1.Start.x);
xlines.Add(rct1.End.x);
xlines.Add(rct2.Start.x);
xlines.Add(rct2.End.x);
zlines.Add(rct1.Start.z);
zlines.Add(rct1.End.z);
zlines.Add(rct2.Start.z);
zlines.Add(rct2.End.z);
xlines.Sort();
zlines.Sort();
rct1.End.StepLT();
rct2.End.StepLT();
CRD star, end;
for (int x = 0; x < xlines.Count - 1; x++)
{
for (int z = 0; z < zlines.Count - 1; z++)
{
star = new CRD(xlines[x], zlines[z]);
end = new CRD(xlines[x + 1], zlines[z + 1]);
end.StepLT();
RCT rct = new RCT(star, end);
if (rct1.checkCollision(rct) || rct2.checkCollision(rct))
{
newRCTs.Add(rct);
}
}
}
return(newRCTs);
}
public void AddStreet(int start, int floor, char axis, int width, int sidewalk) //добавляет улицу
{
RCT rct;
if (width < 2)
{
width = 2;
}
if (width == 3)
{
width++;
}
if (axis == 'v')
{
rct = new RCT(new CRD(0, start), width + sidewalk * 2, stage.height);
}
else
{
rct = new RCT(new CRD(start, 0), stage.width, width + sidewalk * 2);
}
stage.CreateStreet(rct, floor, axis, sidewalk);
}
public override void Upgrade()
{
List <MapElement> mapElements = new List <MapElement>();
if (axis == 'v')
{
int linecount = this.rct.Width / 2;
for (int i = this.rct.Start.z; i <= this.rct.Start.z + linecount * 2; i += 2)
{
RCT rct = new RCT(new CRD(this.rct.Start.x, i), 2, this.rct.Height);
mapElements.Add(new RoadLine(rct, floorNumber, axis));
}
}
else
{
int linecount = this.rct.Height / 2;
for (int i = this.rct.Start.x; i <= this.rct.Start.x + linecount * 2; i += 2)
{
RCT rct = new RCT(new CRD(i, this.rct.Start.z), this.rct.Width, 2);
mapElements.Add(new RoadLine(rct, floorNumber, axis));
}
}
this.addNewElements(mapElements);
}
public SidewalkParking(RCT rct, int floor, char axis, int placeSize) : base(rct, floor)
{
this.placeSize = placeSize;
this.axis = axis;
}
public Area(RCT rct, int floor) : base(rct, floor)
{
}
public CrossroadSidewalk(RCT rct, int floor, CRD corner) : base(rct, floor)
{
this.corner = corner;
}
