public void AssertThat_FloorSelector_SelectsNextMarkerDownAsFootprint()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Floors:
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Footprint []
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Ground []
"));
Assert.IsNotNull(b);
Random r = new Random(2);
var d = new NamedBoxCollection();
var selection = b.Internals(r.NextDouble, d, Finder);
Assert.AreEqual(2, selection.Footprints.Count());
Assert.IsTrue(selection.Footprints.Any(a => a.Index == 0));
Assert.IsTrue(selection.Footprints.Any(a => a.Index == 2));
Assert.IsTrue(selection.Footprints.Any(a => a.Marker is GroundMarker));
Assert.IsTrue(selection.Footprints.Any(a => a.Marker is FootprintMarker));
}
protected BaseSpecBuildingContainer(BuildingDesigner designer)
: base(designer.MaxHeight, float.MaxValue) //We ensure that building will fit into the given space by setting *min* allowable space to *max* possible building height
{
Contract.Requires(designer != null);
_designer = designer;
}
public void AssertThat_FacadeSelector_DoesNotOutputFacadeAcrossFootprintBreak()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Facades:
- Tags: { 1: { a: b } }
Bottom: !Id { Id: F }
Top: !Id { Id: F, Search: Up, Filter: Longest, NonOverlapping: true }
Floors:
- !Floor { Id: F, Tags: { 1: { a: b } }, Height: 1 }
- !Floor { Id: F, Tags: { 1: { a: b } }, Height: 1 }
- !Footprint []
- !Floor { Id: F, Tags: { 1: { a: c } }, Height: 1 }
- !Floor { Id: F, Tags: { 1: { a: d } }, Height: 1 }
- !Ground []
"));
Assert.IsNotNull(b);
Random r = new Random(2);
var d = new NamedBoxCollection();
var selection = b.Internals(r.NextDouble, d, Finder).Externals(r.NextDouble, d, Finder, _noNeighbours);
var facades = selection.Walls.SelectMany(a => a.Facades);
//2 facades for all 4 walls
Assert.AreEqual(2 * 4, facades.Count());
//1 facade at this height for all 4 walls
Assert.AreEqual(1 * 4, facades.Count(f => f.Bottom == 0 && f.Top == 1));
Assert.AreEqual(1 * 4, facades.Count(f => f.Bottom == 2 && f.Top == 3));
}
public void AssertThat_FloorSelector_SelectsGroundMarkerAsFootprint()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Facades:
- Tags: { 1: { a: b } }
Bottom: !Num { N: 0 }
Top: !Id { Id: Top, Search: Up, Filter: Longest, NonOverlapping: true }
Floors:
- !Floor { Id: Top, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: Bot, Tags: { 1: { a: b } } }
- !Ground []
"));
Assert.IsNotNull(b);
Random r = new Random(2);
var d = new NamedBoxCollection();
var selection = b.Internals(r.NextDouble, d, Finder).Externals(r.NextDouble, d, Finder, _noNeighbours);
//4 sides, 4 walls
Assert.AreEqual(4, selection.Walls.Count());
Assert.IsTrue(selection.Walls.All(a => a.BottomIndex == 0));
//Does one of the walls contain one of the seed points
Assert.AreEqual(1, selection.Walls.Count(a => a.Start == new Vector2(-10, -10)));
}
public void DeserializeFloor()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Floors:
- !Floor
Height:
!NormalValue
Min: 1
Mean: 3
Max: 5
Deviation: 2
Tags:
1: { tag: a }
2: { tag: b }
"));
Assert.IsNotNull(b);
Assert.AreEqual(1, b.FloorSelectors.Count());
var spec = (FloorSpec)b.FloorSelectors.Single();
var h = spec.Height;
Assert.AreEqual(1, h.MinValue);
Assert.AreEqual(5, h.MaxValue);
// ReSharper disable CompareOfFloatsByEqualityOperator
Assert.AreEqual(new KeyValuePair <string, string>("tag", "a"), spec.Tags.Single(a => a.Key == 1).Value.Single());
Assert.AreEqual(new KeyValuePair <string, string>("tag", "b"), spec.Tags.Single(a => a.Key == 2).Value.Single());
// ReSharper restore CompareOfFloatsByEqualityOperator
}
public void AssertThat_SingleFloorBuilding_WithNullFloor_OutputsNoFloors()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Floors:
- !Floor
Tags:
1: null
- !Ground []
"));
Assert.IsNotNull(b);
var r = new Random();
var d = new NamedBoxCollection();
var selection = b.Internals(r.NextDouble, d, Finder);
Assert.AreEqual(0, selection.AboveGroundFloors.Count());
Assert.AreEqual(0, selection.BelowGroundFloors.Count());
var lot = new Vector2[] {
new Vector2(-30, -30),
new Vector2(-30, 30f),
new Vector2(30, 30f),
new Vector2(30, -30f)
};
selection.Externals(r.NextDouble, d, Finder, new BuildingSideInfo[] {
new BuildingSideInfo(lot[0], lot[1], new BuildingSideInfo.NeighbourInfo[0]),
new BuildingSideInfo(lot[1], lot[2], new BuildingSideInfo.NeighbourInfo[0]),
new BuildingSideInfo(lot[2], lot[3], new BuildingSideInfo.NeighbourInfo[0]),
new BuildingSideInfo(lot[3], lot[0], new BuildingSideInfo.NeighbourInfo[0]),
});
}
public void AssertThat_FacadeSelector_Throws_WhenNotAllFloorsAreCovered()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Facades:
- Tags: { 1: { a: b } }
Bottom: !Num { N: 0 }
Top: !Id { Id: F, Search: Up, Filter: Shortest, NonOverlapping: true } #Matching to the *first* F does not cover all floors!
Floors:
- !Floor { Id: Top, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: Bot, Tags: { 1: { a: b } } }
- !Ground []
"));
Assert.IsNotNull(b);
Random r = new Random(2);
var d = new NamedBoxCollection();
b.Internals(r.NextDouble, d, Finder).Externals(r.NextDouble, d, Finder, _noNeighbours);
}
public void AssertThat_FacadeSelector_OutputsFacade()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Facades:
- Tags: { 1: { a: b } }
Bottom: !Num { N: 0 }
Top: !Id { Id: Top, Search: Up, Filter: Longest, NonOverlapping: true }
Floors:
- !Floor { Id: Top, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: Bot, Tags: { 1: { a: b } } }
- !Ground []
"));
Assert.IsNotNull(b);
Random r = new Random(2);
var d = new NamedBoxCollection();
var selection = b.Internals(r.NextDouble, d, Finder).Externals(r.NextDouble, d, Finder, _noNeighbours);
//One facade for each wall (4 walls)
Assert.AreEqual(4, selection.Walls.SelectMany(a => a.Facades).Count());
//Every wall has just one facade up it's entire height
Assert.IsTrue(selection.Walls.All(a => a.Facades.Count() == 1));
Assert.IsTrue(selection.Walls.SelectMany(a => a.Facades).All(a => a.Bottom == 0 && a.Top == 4));
}
public void AssertThat_MultiFloorSelector_OutputsMultipleFloors()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Floors:
- !Range
Includes:
- Count:
!UniformValue
Min: 1
Max: 5
Vary: true
Tags:
1: { a: a }
1: { a: b }
0: null
- !Ground []
"));
Assert.IsNotNull(b);
var r = new Random();
var d = new NamedBoxCollection();
var selection = b.Internals(r.NextDouble, d, Finder);
Assert.IsTrue(selection.AboveGroundFloors.Any() && selection.AboveGroundFloors.Count() <= 5);
Assert.AreEqual(0, selection.BelowGroundFloors.Count());
}
public void AssertThat_BuildingFloorsAreAllUnique_WithFloorepeat()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Aliases:
- &residential_floor_count !NormalValue
Min: 5
Max: 10
Floors:
- !Repeat
Count:
!NormalValue
Min: 1
Max: 5
Items:
- !Range
Includes:
- Count: *residential_floor_count
Tags: { 1: { a: b } }
- !Ground []
"));
var internals = b.Internals(new Random(1).NextDouble, new NamedBoxCollection(), Finder);
Assert.AreEqual(internals.Floors.Count(), internals.Floors.GroupBy(a => a.Index).Count());
}
public void AssertThat_SingleFloorBuilding_OutputsSingleFloor()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Floors:
- !Floor
Height:
!UniformValue
Min: 1
Max: 2
Tags:
1: { a: b }
- !Ground []
"));
Assert.IsNotNull(b);
Random r = new Random();
var d = new NamedBoxCollection();
var selection = b.Internals(r.NextDouble, d, Finder);
Assert.AreEqual(1, selection.AboveGroundFloors.Count());
Assert.AreEqual(0, selection.BelowGroundFloors.Count());
var h = selection.AboveGroundFloors.Single().Height;
Assert.IsTrue(h >= 1 && h <= 2);
}
public void DeserializeBuilding()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Floors: []
"));
Assert.IsNotNull(b);
Assert.AreEqual(0, b.FloorSelectors.Count());
}
public void DeserializeMarker()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Floors:
- !Ground []
"));
Assert.IsInstanceOfType(b.FloorSelectors.Single(), typeof(GroundMarker));
}
public void AssertThat_FacadeSelector_OutputsFacades_OnlyForNonObscuredFloors()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Facades:
- Tags: { 1: { a: a } }
Bottom: !Id { Id: F }
Top: !Id { Id: F, Search: Up, Filter: Longest, NonOverlapping: true }
Constraints: [ !Clearance { Distance: 20 } ]
- Tags: { 1: { a: b } }
Bottom: !Id { Id: '*' }
Top: !Id { Id: '*', Inclusive: true, Filter: First }
Floors:
- !Floor { Id: F, Tags: { 1: { a: c } }, Height: 1 }
- !Floor { Id: F, Tags: { 1: { a: d } }, Height: 1 }
- !Floor { Id: F, Tags: { 1: { a: e } }, Height: 1 }
- !Floor { Id: F, Tags: { 1: { a: f } }, Height: 1 }
- !Ground []
"));
Assert.IsNotNull(b);
//Entire length obscured to 1m
var n1 = new BuildingSideInfo.NeighbourInfo[] {
new BuildingSideInfo.NeighbourInfo(0, 1, 1, new BuildingSideInfo.NeighbourInfo.Resource[0])
};
//Entire length of the first side is obscured up to height 1m (floor 1)
var neighbours = new[] {
new BuildingSideInfo(new Vector2(-10, -10), new Vector2(10, -10), n1),
new BuildingSideInfo(new Vector2(10, -10), new Vector2(10, 10), n1),
new BuildingSideInfo(new Vector2(10, 10), new Vector2(-10, 10), n1),
new BuildingSideInfo(new Vector2(-10, 10), new Vector2(-10, -10), n1),
};
Random r = new Random(2);
var d = new NamedBoxCollection();
var selection = b.Internals(r.NextDouble, d, Finder).Externals(r.NextDouble, d, Finder, neighbours);
var wall = selection.Walls.First();
//Without an obstacle we would get 1 facade, floor 0->3 (FFFF)
//However, the ground floor is obscured, so we get 2 facades:
// F (blank) 0
// FFF (a) 1->3
Assert.AreEqual(2, wall.Facades.Count());
Assert.AreEqual(1, wall.Facades.Count(f => f.Bottom == 1 && f.Top == 3));
Assert.AreEqual(1, wall.Facades.Count(f => f.Bottom == 0 && f.Top == 0));
}
public void AssertThat_BuildingFloorsAreAllUnique_WithBasicFloors()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Floors:
- !Floor { Tags: { 1: { a: b } } }
- !Floor { Tags: { 1: { a: b } } }
- !Ground []
"));
var internals = b.Internals(new Random(1).NextDouble, new NamedBoxCollection(), Finder);
Assert.AreEqual(2, internals.Floors.GroupBy(a => a.Index).Count());
}
public void DeserializeRange()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Floors:
- !Range
Includes:
- Count:
!UniformValue
Min: 1
Max: 1
Vary: true
Continuous: false
Tags:
1: { tag: a }
"));
}
public void AssertThat_BuildingFloorsAreAllUnique_WithFloorRange()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Floors:
- !Range
Includes:
- Count: 10
Vary: false
Tags:
1: { a: b }
1: { a: c }
0: null
- !Ground []
"));
var internals = b.Internals(new Random(1).NextDouble, new NamedBoxCollection(), Finder);
Assert.AreEqual(internals.Floors.Count(), internals.Floors.GroupBy(a => a.Index).Count());
}
public void AssertThat_TwoFloors_WithHeightGroup_InheritsHeightFromRootGroup()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Aliases:
- &groupname !NormalValue
Vary: false
Min: 5
Max: 10
Verticals: []
Floors:
- !Floor
Height: *groupname
Tags:
1: { a: b }
- !Floor
Height: *groupname
Tags:
1: { a: b }
- !Ground []
"));
Assert.IsNotNull(b);
Random r = new Random();
var d = new NamedBoxCollection();
var selection = b.Internals(r.NextDouble, d, Finder);
Assert.AreEqual(2, selection.AboveGroundFloors.Count());
Assert.AreEqual(0, selection.BelowGroundFloors.Count());
var h = selection.AboveGroundFloors.First().Height;
Assert.IsTrue(h >= 5f && h <= 10f);
var h2 = selection.AboveGroundFloors.Skip(1).First().Height;
Assert.AreEqual(h, h2);
}
public void Playground()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals:
- Tags: { 1: { tag: lift } }
Bottom: !Id { Id: GroundFloor }
Top: !Id { Id: TopFloor }
Floors:
- !Floor { Id: TopFloor, Tags: { 1: { a: b } } }
- !Floor { Tags: { 1: { a: b} } }
- !Floor { Id: GroundFloor, Tags: { 1: { a: b } } }
- !Ground []
"));
Random r = new Random();
var d = new NamedBoxCollection();
var selection = b.Internals(r.NextDouble, d, Finder);
Assert.AreEqual(3, selection.AboveGroundFloors.Count());
Assert.AreEqual(1, selection.Verticals.Count());
}
public void AssertThat_FacadeSelector_OutputsFacades()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Verticals: []
Facades:
- Tags: { 1: { a: b } }
Bottom: !Id { Id: F }
Top: !Id { Id: F, Inclusive: true, Search: Up, Filter: Longest, NonOverlapping: true }
- Tags: { 1: { a: b } }
Bottom: !Num { N: 0 }
Top: !Num { N: 0, Inclusive: true }
- Tags: { 1: { a: b } }
Bottom: !Id { Id: Top }
Top: !Id { Id: Top, Inclusive: true }
Floors:
- !Floor { Id: Top, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: F, Tags: { 1: { a: b } } }
- !Floor { Id: Bot, Tags: { 1: { a: b } } }
- !Ground []
"));
Assert.IsNotNull(b);
Random r = new Random(2);
var d = new NamedBoxCollection();
var selection = b.Internals(r.NextDouble, d, Finder).Externals(r.NextDouble, d, Finder, _noNeighbours);
var wall = selection.Walls.First();
Assert.AreEqual(3, wall.Facades.Count());
Assert.AreEqual(1, wall.Facades.Count(f => f.Bottom == 0 && f.Top == 0));
Assert.AreEqual(1, wall.Facades.Count(f => f.Bottom == 1 && f.Top == 3));
Assert.AreEqual(1, wall.Facades.Count(f => f.Bottom == 4 && f.Top == 4));
}
public void TestMethod1()
{
var b = BuildingDesigner.Deserialize(new StringReader(@"
!Building
Aliases:
- &residential_floor_count !NormalValue
Min: 5
Max: 10
- &FloorHeight !UniformValue
Min: 2
Max: 5
Vary: true
Facades:
# Penthouse facade
- Tags: { 1: { tag: BlankFacade } }
Bottom: !Id { Id: Penthouse }
Top: !Id { Id: Penthouse, Inclusive: true }
# Skylobby facades
- Tags: { 1: { tag: BlankFacade } }
Bottom: !Id { Id: Skylobby }
Top: !Id { Id: Skylobby, Inclusive: true, Search: Up, Filter: First }
# Residential facades
- Tags: { 1: { tag: BlankFacade } }
Bottom: !Id { Id: Residential }
Top: !Id { Id: Residential, Inclusive: true, Search: Up, Filter: Longest, NonOverlapping: true }
# Ground entrances
- Tags: { 1: { tag: BlankFacade } }
Bottom: !Num { N: 0 }
Top: !Num { N: 0, Inclusive: true }
#Constraints: [ !Access { Type: Road } ]
- Tags: { 1: { tag: BlankFacade } }
Bottom: !Num { N: 0 }
Top: !Num { N: 0 }
Verticals:
# First lift from ground->lowest skylobby
- Tags: { 1: { tag: HollowVertical } }
Bottom: !Num { N: 0 }
Top: !Num { N: 5 }
Floors:
- !Floor
Id: Penthouse
Tags: { 50: { tag: SolidFloor }, 50: null }
- !Footprint
- !Shrink { Distance: 5 }
- !Twist { Angle: 15 }
- !Clip {}
- !Repeat
Count: !NormalValue
Min: 1
Max: 5
Items:
- !Footprint
- !Shrink { Distance: 5 }
- !Twist { Angle: 15 }
- !Clip {}
- !Floor
Id: Skylobby
Tags: { 1: { tag: SolidFloor } }
- !Repeat
Count: *residential_floor_count
Vary: true
Items:
- !Floor
Tags: { 1: { tag: SolidFloor } }
Id: Residential
- !Footprint
- !Shrink { Distance: 1 }
- !Twist { Angle: 15 }
- !Clip {}
- !Floor
Tags: { 1: { tag: SolidFloor } }
Height: *FloorHeight
- !Ground []
"));
Assert.IsNotNull(b);
Func <IEnumerable <KeyValuePair <string, string> >, Type[], ScriptReference> finder = (tags, types) => ScriptReferenceFactory.Create(typeof(TestScript), Guid.NewGuid(), string.Join(",", tags));
var lot = new Vector2[] {
new Vector2(-30, -30),
new Vector2(-30, 30f),
new Vector2(30, 30f),
new Vector2(30, -30f)
};
Random r = new Random(10);
var d = new NamedBoxCollection();
var selection = b.Internals(r.NextDouble, d, finder).Externals(r.NextDouble, d, finder, new BuildingSideInfo[] {
new BuildingSideInfo(lot[0], lot[1], new BuildingSideInfo.NeighbourInfo[0]),
new BuildingSideInfo(lot[1], lot[2], new BuildingSideInfo.NeighbourInfo[0]),
new BuildingSideInfo(lot[2], lot[3], new BuildingSideInfo.NeighbourInfo[0]),
new BuildingSideInfo(lot[3], lot[0], new BuildingSideInfo.NeighbourInfo[0]),
});
Assert.AreEqual(selection.Floors.Count(), selection.Floors.GroupBy(a => a.Index).Count());
var v = selection.Verticals;
Func <int, string> prefix = (floor) => new string(v.Select(a => a.Bottom <= floor && a.Top >= floor ? '|' : ' ').ToArray());
foreach (var item in selection.Floors.OrderByDescending(a => a.Index))
{
var pre = prefix(item.Index);
Console.WriteLine("{0} {1} {2:##.##}m", pre, item.Script.Name, item.Height);
}
}
