public void NavigationService_weighs_values()
{
RoomService roomService = NSubstitute.Substitute.For <RoomService>();
FloorPlan plan = new FloorPlan(20, 20, fill: true);
RoomPlan roomPlan = new RoomPlan
{
Name = "Test",
Width = 5,
Height = 5,
WallValue = 20,
FloorValue = 1,
DoorTile = new DoorTile(4, 2, cost: 3, notes: "Door")
};
IFloorRoom room = roomService.GenerateRoom(roomPlan);
plan.AddRoom(room, new Location(3, 12));
var display = plan.Print();
Debug.WriteLine(display);
NavigationService navService = NSubstitute.Substitute.For <NavigationService>(plan);
var path = navService.FindPath(new Location(1, 1), new Location(5, 14));
display = plan.Print(path);
Debug.Write(display);
}
public async Task <ActionResult <RoomPlan> > PostRoomPlan(RoomPlan roomPlan)
{
_context.RoomPlans.Add(roomPlan);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetRoomPlan", new { id = roomPlan.Id }, roomPlan));
}
public async Task <IActionResult> PutRoomPlan(int id, RoomPlan roomPlan)
{
if (id != roomPlan.Id)
{
return(BadRequest());
}
_context.Entry(roomPlan).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RoomPlanExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Generate()
{
bool[,] map = new bool[width, height];
FillMap(map);
for (int i = 0; i < 5; i++)
{
map = CellularAutomataPass(map);
}
RemoveUnconnectedParts(map);
nearestTiles = new Vector2[width, height];
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
if (map[x, y])
{
InstantiateFloorTile(map, x, y);
if (IsFloor(map, x, y + 1) && IsFloor(map, x, y - 1) && IsFloor(map, x + 1, y) && IsFloor(map, x - 1, y))
{
nearestTiles[x, y] = new Vector2(x, y);
}
else
{
nearestTiles[x, y] = -Vector2.one;
}
}
else
{
nearestTiles[x, y] = -Vector2.one;
}
}
}
PrefillNearestTiles(map);
if (topDoor == null)
{
GameObject door = Instantiate(doorPrefab, fallbackTopDoorPosition, Quaternion.identity, transform) as GameObject;
topDoor = door.GetComponent <Door>();
Debug.LogWarning("Top door in fallback position");
}
topDoor.room = this;
if (bottomDoor == null)
{
GameObject door = Instantiate(doorPrefab, fallbackBottomDoorPosition, Quaternion.identity, transform) as GameObject;
bottomDoor = door.GetComponent <Door>();
Debug.LogWarning("Bottom door in fallback position");
}
bottomDoor.room = this;
bottomDoor.doorToHub = true;
RoomPlan = RoomPlanFactory.getInstance().getRoomPlan(this.ID, this);
}
public RoomControl(RoomPlan roomPlan, ProjectFile assignedProject, Point insertPoint)
{
InitializeComponent();
RoomAssignment = new RoomAssignment(roomPlan, assignedProject, (int)insertPoint.X, (int)insertPoint.Y);
if (RoomAssignment.RoomPlan.RoomPlanImage == null)
{
RoomAssignment.RoomPlan.SaveRoomPlanImage();
}
}
public RoomPlanDto ToRoomPlanDto(RoomPlan roomPlan)
{
return(new RoomPlanDto()
{
Id = roomPlan.Id,
Columns = roomPlan.Columns,
Rows = roomPlan.Rows,
Seats = SeatPositionsStringToList(roomPlan.Seats)
});
}
public void OpenRoomPlan(RoomPlan roomPlan)
{
RoomPlanGrid roomPlanGrid = new RoomPlanGrid(roomPlan);
roomPlanGrid.ChangeObserved += RoomPlanGrid_ChangeObserved;
roomPlanGrid.RoomNameChanged += PlanGrid_NameChanged;
tabControl.SelectedIndex = AddTab(roomPlanGrid, roomPlan.Name, roomTabStyle, Guid.NewGuid().ToString());
SetCurrentTabItemBold(tabControl.Items[tabControl.SelectedIndex] as TabItem);
}
public void RoomService_generates_room()
{
RoomService service = NSubstitute.Substitute.For <RoomService>();
// North door
RoomPlan roomType = new RoomPlan
{
Name = "Test",
Width = 3,
Height = 3,
WallValue = 5,
FloorValue = 1,
DoorTile = new DoorTile(1, 0, cost: 3, notes: "Door")
};
IFloorRoom room = service.GenerateRoom(roomType);
string display = room.FloorTiles.Print();
Debug.WriteLine(display);
display.ShouldBeEquivalentTo("535" + Environment.NewLine + "5_5" + Environment.NewLine + "555" + Environment.NewLine);
// East door
roomType.DoorTile = new DoorTile(2, 1, cost: 3, notes: "Door");
room = service.GenerateRoom(roomType);
display = room.FloorTiles.Print();
Debug.WriteLine(display);
display.ShouldBeEquivalentTo("555" + Environment.NewLine + "5_3" + Environment.NewLine + "555" + Environment.NewLine);
// South door
roomType.DoorTile = new DoorTile(1, 2, cost: 3, notes: "Door");
room = service.GenerateRoom(roomType);
display = room.FloorTiles.Print();
Debug.WriteLine(display);
display.ShouldBeEquivalentTo("555" + Environment.NewLine + "5_5" + Environment.NewLine + "535" + Environment.NewLine);
// West door
roomType.DoorTile = new DoorTile(0, 1, cost: 3, notes: "Door");
room = service.GenerateRoom(roomType);
display = room.FloorTiles.Print();
Debug.WriteLine(display);
display.ShouldBeEquivalentTo("555" + Environment.NewLine + "3_5" + Environment.NewLine + "555" + Environment.NewLine);
// North door wide
roomType.Width = 4;
roomType.DoorTile = new DoorTile(1, 0, cost: 3, notes: "Door");
room = service.GenerateRoom(roomType);
display = room.FloorTiles.Print();
Debug.WriteLine(display);
display.ShouldBeEquivalentTo("5355" + Environment.NewLine + "5__5" + Environment.NewLine + "5555" + Environment.NewLine);
}
public RoomPlanGrid(RoomPlan roomPlan)
{
InitializeComponent();
predictInnerRoomTimer = new DispatcherTimer();
predictInnerRoomTimer.Interval = TimeSpan.FromMilliseconds(500);
isInit = false;
RoomPlanViewModel vm = DataContext as RoomPlanViewModel;
roomPlan.Load();
vm.RoomPlan = roomPlan;
roomPlan.ChangeManager.ChangeObserved += ChangeManager_ChangeObserved;
vm.RoomNameChanged += Vm_RoomNameChanged;
vm.GridSizeChanged += Vm_GridSizeChanged;
vm.ChangeObserved += ChangeManager_ChangeObserved;
predictInnerRoomTimer.Tick += PredictInnerRoomTimer_Tick;
AddTilesAndPlaceables();
}
public int SaveRoomPlan(RoomPlan Details)
{
HotelInformation hotelInfo = new HotelInformation();
return(hotelInfo.SaveRoomPlan(Details));
}
private int Separation(RoomPlan a, RoomPlan b)
{
var path = Tools.AStar<RoomPlan>(a, b,
x => x.Doors.Keys.Select(y => Tuple.Create(y, (x.Rect.TopLeft - y.Rect.TopLeft).ManhattanLength)),
x => x.Rect.TopLeft + new Position(x.Rect.Width / 2, x.Rect.Height / 2));
return path.Length;
}
private bool CanGenerateDoor(RoomPlan a, RoomPlan b)
{
if (a.Index >= b.Index) return false;
if (!a.Rect.IsAdjacent(b.Rect)) return false;
var i = a.Rect.Intersection(b.Rect);
return i.Width >= 3 || i.Height >= 3;
}
public override IEnumerable<RoomPlan> Generate(Level level, Random rand)
{
int destArea = rand.Next(MinArea, MaxArea);
var plans = new List<RoomPlan>();
int range = (int) Math.Sqrt(destArea);
var hubs = new Hub[Math.Max(1, rand.Next(MinHubs, MaxHubs + 1))];
for (int i = 0; i < hubs.Length; ++i) {
hubs[i].Position = new Position(rand.Next(-range, range), rand.Next(-range, range));
hubs[i].Density = rand.Next(MinHubDensity, MaxHubDensity);
}
ProgressStart("Creating rooms: ");
int area = 0;
while (area < destArea) {
var generator = GetRandomGenerator(rand);
var size = new Rectangle(Position.Zero, generator.RoomLayout.GenerateSize(rand));
var hub = hubs[rand.Next(hubs.Length)];
var hubPos = hub.Position;
var best = Rectangle.Zero;
RoomPlan neighbour = null;
if (plans.Count > 0) {
int bestDist = 0;
int tries = 0;
while (best == Rectangle.Zero || ++tries <= hub.Density) {
var othr = plans[rand.Next(plans.Count)];
var rect = GenerateAdjacentRect(othr.Rect, size, rand);
if (plans.Any(x => x.Rect.Intersects(rect))) continue;
int dist = (rect.NearestPosition(hubPos) - hubPos).ManhattanLength;
if (best != Rectangle.Zero && dist >= bestDist) continue;
best = rect;
bestDist = dist;
neighbour = othr;
tries = 0;
}
} else {
best = new Rectangle(-size.Width / 2, -size.Height / 2, size.Width, size.Height);
}
var info = new RoomPlan(best, generator, plans.Count);
if (neighbour != null) {
var door = GenerateDoor(info.Rect, neighbour.Rect, rand);
info.AddDoor(neighbour, door);
neighbour.AddDoor(info, door);
}
plans.Add(info);
area += best.Area;
ProgressUpdate(area, destArea);
}
ProgressEnd();
var spareDoors = plans
.SelectMany(x => plans
.Where(y => CanGenerateDoor(x, y) && !x.Doors.ContainsKey(y))
.Select(y => Tuple.Create(x, y)))
.ToList();
ProgressStart("Creating Doors: ");
int doorCount = Tools.Clamp((int) (rand.NextFloat(MinConnectivity, MaxConnectivity) * spareDoors.Count), 0, spareDoors.Count);
for (int d = 0; d < doorCount; ++d) {
Tuple<RoomPlan, RoomPlan> door = null;
int bestScore = 0;
foreach (var elem in spareDoors) {
var score = Separation(elem.Item1, elem.Item2);
score = score * score + rand.Next(50);
if (score > bestScore) {
door = elem;
bestScore = score;
}
}
spareDoors.Remove(door);
var rect = GenerateDoor(door.Item1.Rect, door.Item2.Rect, rand);
door.Item1.AddDoor(door.Item2, rect);
door.Item2.AddDoor(door.Item1, rect);
ProgressUpdate(d + 1, doorCount);
}
ProgressEnd();
return plans;
}
public RoomControl(RoomPlan roomPlan, ProjectFile assignedProject) : this(roomPlan, assignedProject, new Point())
{
}
public Result AddRoom(Room room, RoomPlan roomPlan, ICollection <SeatPosition> seatPositions)
{
try
{
ICollection <SeatPosition> dbSeatPositions = databaseContext.SeatPositions.ToList();
int id = dbSeatPositions.Count + 1;
bool duplicateId = false;
List <SeatPosition> addedSeatPositions = new List <SeatPosition>();
foreach (SeatPosition seatPosition in seatPositions)
{
do
{
duplicateId = dbSeatPositions.Any(x => x.Id == id);
if (duplicateId)
{
id++;
}
} while (duplicateId);
seatPosition.Id = id;
addedSeatPositions.Add(seatPosition);
id++;
}
databaseContext.SeatPositions.AddRange(addedSeatPositions);
databaseContext.SaveChanges();
ICollection <RoomPlan> roomPlans = databaseContext.RoomPlans.ToList();
id = roomPlans.Count + 1;
do
{
duplicateId = roomPlans.Any(x => x.Id == id);
if (duplicateId)
{
id++;
}
} while (duplicateId);
roomPlan.Id = id;
roomPlan.Seats = SeatPositionsListToString(seatPositions);
databaseContext.RoomPlans.Add(roomPlan);
databaseContext.SaveChanges();
ICollection <Room> rooms = GetRooms();
id = rooms.Count + 1;
do
{
duplicateId = rooms.Any(x => x.Id == id);
if (duplicateId)
{
id++;
}
} while (duplicateId);
room.Id = id;
room.RoomPlanId = id;
databaseContext.Rooms.Add(room);
databaseContext.SaveChanges();
return(new Result(room.Id));
}
catch (Exception ex)
{
return(new Result(ex));
}
}
public Result UpdateRoom(Room room, RoomPlan roomPlan, ICollection <SeatPosition> added, ICollection <SeatPosition> updated)
{
try
{
string seatPositionIds = "";
foreach (SeatPosition seatPosition in updated)
{
SeatPosition dbSeatPosition = GetSeatPositionById(seatPosition.Id);
if (dbSeatPosition != null)
{
dbSeatPosition.Column = seatPosition.Column;
dbSeatPosition.Rotation = seatPosition.Rotation;
dbSeatPosition.Row = seatPosition.Row;
dbSeatPosition.SeatTypeId = seatPosition.SeatTypeId;
databaseContext.SeatPositions.Update(dbSeatPosition);
seatPositionIds += seatPositionIds == "" ? seatPosition.Id.ToString() : ";" + seatPosition.Id;
}
}
if (added.Count > 0)
{
ICollection <SeatPosition> dbSeatPositions = databaseContext.SeatPositions.ToList();
int id = dbSeatPositions.Count + 1;
bool duplicateId = false;
foreach (SeatPosition seatPosition in added)
{
do
{
duplicateId = dbSeatPositions.Any(x => x.Id == id);
if (duplicateId)
{
id++;
}
} while (duplicateId);
seatPosition.Id = id;
seatPositionIds += seatPositionIds == "" ? id.ToString() : ";" + id;
id++;
}
databaseContext.SeatPositions.AddRange(added);
}
string[] oldSeatPositionIds = roomPlan.Seats.Split(';', StringSplitOptions.RemoveEmptyEntries);
foreach (string seatPositionId in oldSeatPositionIds)
{
if (!seatPositionIds.Contains(seatPositionId))
{
SeatPosition seatPosition = databaseContext.SeatPositions.FirstOrDefault(x => x.Id == int.Parse(seatPositionId));
if (seatPosition != null)
{
databaseContext.SeatPositions.Remove(seatPosition);
}
}
}
roomPlan.Seats = seatPositionIds;
databaseContext.RoomPlans.Update(roomPlan);
room.RoomPlanId = roomPlan.Id;
databaseContext.Rooms.Update(room);
databaseContext.SaveChanges();
return(new Result());
}
catch (Exception ex)
{
return(new Result(ex));
}
}
