public void AddHallCollideExistingHall()
{
// add on top of existing hall, no consequences
TestFloorPlan floorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
Array.Empty <Rect>(),
new Rect[] { new Rect(1, 1, 2, 3) },
Array.Empty <Tuple <char, char> >());
TestFloorPlan compareFloorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
Array.Empty <Rect>(),
new Rect[] { new Rect(1, 1, 2, 3), new Rect(2, 2, 4, 4) },
Array.Empty <Tuple <char, char> >());
var gen = new Mock <TestFloorPlanGen>(MockBehavior.Loose)
{
CallBase = true
};
gen.SetupGet(p => p.Draw).Returns(new Rect(2, 2, 4, 4));
gen.Object.Identifier = 'b';
floorPlan.AddHall(gen.Object);
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void EraseRoomHallHall()
{
// erase existent rooms in the middle of a list, checking for room consistency
// and adjacency consistency
TestFloorPlan floorPlan;
{
var links = new Tuple <char, char>[]
{
Tuple.Create('a', 'b'),
Tuple.Create('b', 'c'),
Tuple.Create('c', 'a'),
Tuple.Create('A', 'a'),
Tuple.Create('B', 'b'),
Tuple.Create('C', 'c'),
};
floorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { Rect.Empty, Rect.Empty, Rect.Empty },
new Rect[] { Rect.Empty, Rect.Empty, Rect.Empty },
links);
}
TestFloorPlan compareFloorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { Rect.Empty, Rect.Empty, Rect.Empty },
new Rect[] { Rect.Empty, Rect.Empty },
new Tuple <char, char>[] { Tuple.Create('b', 'a'), Tuple.Create('A', 'a'), Tuple.Create('C', 'b') });
((TestFloorPlanGen)compareFloorPlan.GetRoomHall(new RoomHallIndex(1, true)).RoomGen).Identifier = 'c';
floorPlan.EraseRoomHall(new RoomHallIndex(1, true));
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void AddRoomToExisting()
{
// add with adjacents
TestFloorPlan floorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { new Rect(1, 1, 2, 3) },
new Rect[] { new Rect(6, 1, 3, 3) },
Array.Empty <Tuple <char, char> >());
TestFloorPlan compareFloorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { new Rect(1, 1, 2, 3), new Rect(3, 2, 3, 5) },
new Rect[] { new Rect(6, 1, 3, 3) },
new Tuple <char, char>[] { Tuple.Create('A', 'B'), Tuple.Create('a', 'B') });
var gen = new Mock <TestFloorPlanGen>(MockBehavior.Loose)
{
CallBase = true
};
gen.SetupGet(p => p.Draw).Returns(new Rect(3, 2, 3, 5));
gen.Object.Identifier = 'B';
floorPlan.AddRoom(gen.Object, false, new RoomHallIndex(0, false), new RoomHallIndex(0, true));
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void AddHall()
{
// add to empty space
TestFloorPlan floorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
Array.Empty <Rect>(),
Array.Empty <Rect>(),
Array.Empty <Tuple <char, char> >());
TestFloorPlan compareFloorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
Array.Empty <Rect>(),
new Rect[] { new Rect(1, 1, 2, 3) },
Array.Empty <Tuple <char, char> >());
var gen = new Mock <TestFloorPlanGen>(MockBehavior.Loose)
{
CallBase = true
};
gen.SetupGet(p => p.Draw).Returns(new Rect(1, 1, 2, 3));
gen.Object.Identifier = 'a';
floorPlan.AddHall(gen.Object);
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void PlaceRoomMultiAdjacent()
{
// the new room touches adjacents of two sides of the old room
TestFloorPlan floorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { new Rect(3, 3, 6, 6), new Rect(3, 1, 2, 2), new Rect(1, 3, 2, 2) },
Array.Empty <Rect>(),
new Tuple <char, char>[] { Tuple.Create('A', 'B'), Tuple.Create('A', 'C') });
TestFloorPlan compareFloorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { new Rect(3, 1, 2, 2), new Rect(1, 3, 2, 2), new Rect(3, 3, 2, 2) },
Array.Empty <Rect>(),
new Tuple <char, char>[] { Tuple.Create('C', 'B'), Tuple.Create('C', 'A') });
((TestFloorPlanGen)compareFloorPlan.GetRoom(0)).Identifier = 'B';
((TestFloorPlanGen)compareFloorPlan.GetRoom(1)).Identifier = 'C';
((TestFloorPlanGen)compareFloorPlan.GetRoom(2)).Identifier = 'D';
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
var gen = new TestFloorPlanGen('D');
gen.PrepareDraw(new Rect(3, 3, 2, 2));
var mockRooms = new Mock <IRandPicker <RoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
var mockHalls = new Mock <IRandPicker <PermissiveRoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
var pathGen = new AddSpecialRoomTestStep(mockRooms.Object, mockHalls.Object);
pathGen.PlaceRoom(testRand.Object, floorPlan, gen, new RoomHallIndex(0, false));
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void ConnectFail()
{
// A-B-C-D-E
TestFloorPlan floorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { new Rect(3, 3, 2, 2), new Rect(5, 3, 2, 2), new Rect(7, 3, 2, 2), new Rect(9, 3, 2, 2), new Rect(11, 3, 2, 2) },
Array.Empty <Rect>(),
new Tuple <char, char>[] { Tuple.Create('A', 'B'), Tuple.Create('B', 'C'), Tuple.Create('C', 'D'), Tuple.Create('D', 'E') });
TestFloorPlan compareFloorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { new Rect(3, 3, 2, 2), new Rect(5, 3, 2, 2), new Rect(7, 3, 2, 2), new Rect(9, 3, 2, 2), new Rect(11, 3, 2, 2) },
Array.Empty <Rect>(),
new Tuple <char, char>[] { Tuple.Create('A', 'B'), Tuple.Create('B', 'C'), Tuple.Create('C', 'D'), Tuple.Create('D', 'E') });
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
testRand.Setup(p => p.Next(It.IsAny <int>())).Returns(0);
var mockHalls = new Mock <IRandPicker <PermissiveRoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
var pathGen = new ConnectBranchTestStep(mockHalls.Object);
pathGen.ApplyToPath(testRand.Object, floorPlan);
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void PlaceRoomAllSupport()
{
// needs a supporting hall for all sides
TestFloorPlan floorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { new Rect(3, 3, 6, 6), new Rect(5, 9, 2, 2), new Rect(1, 5, 2, 2), new Rect(5, 1, 2, 2), new Rect(9, 5, 2, 2) },
Array.Empty <Rect>(),
new Tuple <char, char>[] { Tuple.Create('A', 'B'), Tuple.Create('A', 'C'), Tuple.Create('A', 'D'), Tuple.Create('A', 'E') });
TestFloorPlan compareFloorPlan;
{
var links = new Tuple <char, char>[]
{
Tuple.Create('E', 'a'),
Tuple.Create('E', 'b'),
Tuple.Create('E', 'c'),
Tuple.Create('E', 'd'),
Tuple.Create('a', 'A'),
Tuple.Create('b', 'B'),
Tuple.Create('c', 'C'),
Tuple.Create('d', 'D'),
};
compareFloorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { new Rect(5, 9, 2, 2), new Rect(1, 5, 2, 2), new Rect(5, 1, 2, 2), new Rect(9, 5, 2, 2), new Rect(5, 5, 2, 2) },
new Rect[] { new Rect(5, 7, 2, 2), new Rect(3, 5, 2, 2), new Rect(5, 3, 2, 2), new Rect(7, 5, 2, 2) },
links);
}
((TestFloorPlanGen)compareFloorPlan.GetRoom(0)).Identifier = 'B';
((TestFloorPlanGen)compareFloorPlan.GetRoom(1)).Identifier = 'C';
((TestFloorPlanGen)compareFloorPlan.GetRoom(2)).Identifier = 'D';
((TestFloorPlanGen)compareFloorPlan.GetRoom(3)).Identifier = 'E';
((TestFloorPlanGen)compareFloorPlan.GetRoom(4)).Identifier = 'F';
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
var gen = new TestFloorPlanGen('F');
gen.PrepareDraw(new Rect(5, 5, 2, 2));
var mockRooms = new Mock <IRandPicker <RoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
Mock <IRandPicker <PermissiveRoomGen <IFloorPlanTestContext> > > mockHalls = new Mock <IRandPicker <PermissiveRoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
Moq.Language.ISetupSequentialResult <PermissiveRoomGen <IFloorPlanTestContext> > hallSeq = mockHalls.SetupSequence(p => p.Pick(testRand.Object));
hallSeq = hallSeq.Returns(new TestFloorPlanGen('a'));
hallSeq = hallSeq.Returns(new TestFloorPlanGen('b'));
hallSeq = hallSeq.Returns(new TestFloorPlanGen('c'));
hallSeq = hallSeq.Returns(new TestFloorPlanGen('d'));
var pathGen = new AddSpecialRoomTestStep(mockRooms.Object, mockHalls.Object);
pathGen.PlaceRoom(testRand.Object, floorPlan, gen, new RoomHallIndex(0, false));
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void ConnectOther()
{
/* A D
* B-CE */
TestFloorPlan floorPlan;
{
var links = new Tuple <char, char>[]
{
Tuple.Create('A', 'B'),
Tuple.Create('B', 'a'),
Tuple.Create('a', 'C'),
Tuple.Create('C', 'D'),
Tuple.Create('C', 'E'),
};
floorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { new Rect(3, 3, 2, 2), new Rect(3, 5, 2, 3), new Rect(7, 5, 2, 3), new Rect(7, 3, 2, 2), new Rect(9, 6, 2, 2) },
new Rect[] { new Rect(5, 6, 2, 2) },
links);
}
TestFloorPlan compareFloorPlan;
{
var links = new Tuple <char, char>[]
{
Tuple.Create('A', 'B'),
Tuple.Create('B', 'a'),
Tuple.Create('a', 'C'),
Tuple.Create('C', 'D'),
Tuple.Create('C', 'E'),
Tuple.Create('A', 'b'),
Tuple.Create('b', 'D'),
};
compareFloorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { new Rect(3, 3, 2, 2), new Rect(3, 5, 2, 3), new Rect(7, 5, 2, 3), new Rect(7, 3, 2, 2), new Rect(9, 6, 2, 2) },
new Rect[] { new Rect(5, 6, 2, 2), new Rect(5, 3, 2, 2) },
links);
}
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
testRand.Setup(p => p.Next(It.IsAny <int>())).Returns(0);
var mockHalls = new Mock <IRandPicker <PermissiveRoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
mockHalls.Setup(p => p.Pick(testRand.Object)).Returns(new TestFloorPlanGen('b'));
var pathGen = new ConnectBranchTestStep(mockHalls.Object)
{
ConnectPercent = 100
};
pathGen.ApplyToPath(testRand.Object, floorPlan);
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void PlaceRoomsOnFloorIntrusiveHalls()
{
// place a ring of rooms connected by halls
string[] inGrid =
{
"A.0",
". .",
"A#B",
". .",
"0.B",
};
TestGridFloorPlan gridPlan = TestGridFloorPlan.InitGridToContext(inGrid, 5, 5);
for (int ii = 0; ii < gridPlan.RoomCount; ii++)
{
var gen = new TestFloorPlanGen(((TestGridRoomGen)gridPlan.GetRoom(ii)).Identifier)
{
ProposedSize = new Loc(2, 2),
};
gridPlan.PublicArrayRooms[ii].RoomGen = gen;
}
gridPlan.PublicHHalls[0][1].SetGen(new TestFloorPlanGen('a'));
TestFloorPlan compareFloorPlan = TestFloorPlan.InitFloorToContext(
gridPlan.Size,
new Rect[] { new Rect(0, 0, 2, 2), new Rect(9, 15, 2, 2) },
new Rect[] { new Rect(2, 1, 4, 10), new Rect(6, 6, 3, 10) },
new Tuple <char, char>[] { Tuple.Create('A', 'a'), Tuple.Create('a', 'b'), Tuple.Create('b', 'B') });
((TestFloorPlanGen)compareFloorPlan.PublicHalls[1].RoomGen).Identifier = 'a';
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
Moq.Language.ISetupSequentialResult <int> seq = testRand.SetupSequence(p => p.Next(4));
seq = seq.Returns(0);
seq = seq.Returns(3);
seq = testRand.SetupSequence(p => p.Next(10));
seq = seq.Returns(0);
seq = seq.Returns(9);
var floorPlan = new TestFloorPlan();
floorPlan.InitSize(gridPlan.Size);
Mock <IFloorPlanTestContext> mockMap = new Mock <IFloorPlanTestContext>(MockBehavior.Strict);
mockMap.SetupGet(p => p.Rand).Returns(testRand.Object);
mockMap.SetupGet(p => p.RoomPlan).Returns(floorPlan);
gridPlan.PlaceRoomsOnFloor(mockMap.Object);
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void ResizeFloor(Dir8 expandDir, Dir8 anchorDir, int newX, int newY, int newRoomX, int newRoomY)
{
// add to empty space
TestFloorPlan floorPlan = TestFloorPlan.InitFloorToContext(
new Rect(Loc.Zero, new Loc(22, 14)),
new Rect[] { new Rect(4, 3, 2, 3) },
Array.Empty <Rect>(),
Array.Empty <Tuple <char, char> >());
TestFloorPlan compareFloorPlan = TestFloorPlan.InitFloorToContext(
new Rect(new Loc(newX, newY), new Loc(26, 17)),
new Rect[] { new Rect(newRoomX, newRoomY, 2, 3) },
Array.Empty <Rect>(),
Array.Empty <Tuple <char, char> >());
floorPlan.Resize(new Loc(26, 17), expandDir, anchorDir);
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void AddDisconnectedLateBorder()
{
// confirm bottom right corner can be used
TestFloorPlan floorPlan;
{
floorPlan = TestFloorPlan.InitFloorToContext(
new Loc(20, 20),
new Rect[] { },
new Rect[] { },
new Tuple <char, char>[] { });
}
TestFloorPlan compareFloorPlan;
{
compareFloorPlan = TestFloorPlan.InitFloorToContext(
new Loc(20, 20),
new Rect[] { new Rect(16, 16, 4, 4) },
new Rect[] { },
new Tuple <char, char>[] { });
}
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
testRand.Setup(p => p.Next(1, 1)).Returns(1);
testRand.Setup(p => p.Next(0, 17)).Returns(16);
var roomGen = new TestFloorPlanGen('A')
{
ProposedSize = new Loc(4, 4)
};
var mockRooms = new Mock <IRandPicker <RoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
mockRooms.Setup(p => p.Pick(testRand.Object)).Returns(roomGen);
var pathGen = new AddDisconnectedRoomsStep <IFloorPlanTestContext>(mockRooms.Object)
{
Amount = new RandRange(1)
};
pathGen.ApplyToPath(testRand.Object, floorPlan);
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void AddDisconnectedNoCollide()
{
// fail via collision
TestFloorPlan floorPlan;
{
floorPlan = TestFloorPlan.InitFloorToContext(
new Loc(20, 20),
new Rect[] { new Rect(4, 4, 16, 16) },
new Rect[] { },
new Tuple <char, char>[] { });
}
TestFloorPlan compareFloorPlan;
{
compareFloorPlan = TestFloorPlan.InitFloorToContext(
new Loc(20, 20),
new Rect[] { new Rect(4, 4, 16, 16), new Rect(0, 0, 3, 3) },
new Rect[] { },
new Tuple <char, char>[] { });
}
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
testRand.Setup(p => p.Next(1, 1)).Returns(1);
testRand.Setup(p => p.Next(0, 18)).Returns(0);
var roomGen = new TestFloorPlanGen('B')
{
ProposedSize = new Loc(3, 3)
};
var mockRooms = new Mock <IRandPicker <RoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
mockRooms.Setup(p => p.Pick(testRand.Object)).Returns(roomGen);
var pathGen = new AddDisconnectedRoomsStep <IFloorPlanTestContext>(mockRooms.Object)
{
Amount = new RandRange(1)
};
pathGen.ApplyToPath(testRand.Object, floorPlan);
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void PlaceRoomOneSupport()
{
// needs a supporting hall for one side
TestFloorPlan floorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { new Rect(3, 3, 6, 6), new Rect(5, 1, 2, 2), new Rect(5, 9, 2, 2) },
Array.Empty <Rect>(),
new Tuple <char, char>[] { Tuple.Create('A', 'B'), Tuple.Create('A', 'C') });
TestFloorPlan compareFloorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
new Rect[] { new Rect(5, 1, 2, 2), new Rect(5, 9, 2, 2), new Rect(5, 3, 2, 2) },
new Rect[] { new Rect(5, 5, 2, 4) },
new Tuple <char, char>[] { Tuple.Create('C', 'A'), Tuple.Create('C', 'a'), Tuple.Create('a', 'B') });
((TestFloorPlanGen)compareFloorPlan.GetRoom(0)).Identifier = 'B';
((TestFloorPlanGen)compareFloorPlan.GetRoom(1)).Identifier = 'C';
((TestFloorPlanGen)compareFloorPlan.GetRoom(2)).Identifier = 'D';
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
var gen = new TestFloorPlanGen('D');
gen.PrepareDraw(new Rect(5, 3, 2, 2));
var mockRooms = new Mock <IRandPicker <RoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
Mock <IRandPicker <PermissiveRoomGen <IFloorPlanTestContext> > > mockHalls = new Mock <IRandPicker <PermissiveRoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
mockHalls.Setup(p => p.Pick(testRand.Object)).Returns(new TestFloorPlanGen('a'));
var pathGen = new AddSpecialRoomTestStep(mockRooms.Object, mockHalls.Object);
pathGen.PlaceRoom(testRand.Object, floorPlan, gen, new RoomHallIndex(0, false));
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void PlaceRoomsOnFloorRing()
{
// place a ring of rooms connected by halls
string[] inGrid =
{
"A#B",
"# #",
"D#C",
};
TestGridFloorPlan gridPlan = TestGridFloorPlan.InitGridToContext(inGrid, 5, 5);
for (int ii = 0; ii < gridPlan.RoomCount; ii++)
{
var gen = new TestFloorPlanGen(((TestGridRoomGen)gridPlan.GetRoom(ii)).Identifier)
{
ProposedSize = new Loc(5, 5),
};
gridPlan.PublicArrayRooms[ii].RoomGen = gen;
}
gridPlan.PublicVHalls[0][0].SetGen(new TestFloorPlanGen('a'));
gridPlan.PublicVHalls[1][0].SetGen(new TestFloorPlanGen('b'));
gridPlan.PublicHHalls[0][0].SetGen(new TestFloorPlanGen('c'));
gridPlan.PublicHHalls[0][1].SetGen(new TestFloorPlanGen('d'));
TestFloorPlan compareFloorPlan;
{
var links = new Tuple <char, char>[]
{
Tuple.Create('A', 'a'),
Tuple.Create('a', 'D'),
Tuple.Create('B', 'b'),
Tuple.Create('b', 'C'),
Tuple.Create('A', 'c'),
Tuple.Create('c', 'B'),
Tuple.Create('D', 'd'),
Tuple.Create('d', 'C'),
};
compareFloorPlan = TestFloorPlan.InitFloorToContext(
gridPlan.Size,
new Rect[] { new Rect(0, 0, 5, 5), new Rect(6, 0, 5, 5), new Rect(6, 6, 5, 5), new Rect(0, 6, 5, 5) },
new Rect[] { new Rect(0, 5, 5, 1), new Rect(6, 5, 5, 1), new Rect(5, 0, 1, 5), new Rect(5, 6, 1, 5) },
links);
}
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
testRand.Setup(p => p.Next(It.IsAny <int>())).Returns(0);
var floorPlan = new TestFloorPlan();
floorPlan.InitSize(gridPlan.Size);
Mock <IFloorPlanTestContext> mockMap = new Mock <IFloorPlanTestContext>(MockBehavior.Strict);
mockMap.SetupGet(p => p.Rand).Returns(testRand.Object);
mockMap.SetupGet(p => p.RoomPlan).Returns(floorPlan);
gridPlan.PlaceRoomsOnFloor(mockMap.Object);
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
public void ConnectNonArm()
{
/* E G
* A D-F
* B-C */
TestFloorPlan floorPlan;
{
Rect[] rooms = new Rect[]
{
new Rect(3, 3, 2, 4),
new Rect(3, 7, 2, 3),
new Rect(7, 7, 2, 3),
new Rect(7, 3, 2, 4),
new Rect(7, 1, 2, 2),
new Rect(11, 3, 2, 4),
new Rect(11, 1, 2, 2),
};
var links = new Tuple <char, char>[]
{
Tuple.Create('A', 'B'),
Tuple.Create('B', 'a'),
Tuple.Create('a', 'C'),
Tuple.Create('C', 'D'),
Tuple.Create('D', 'E'),
Tuple.Create('D', 'b'),
Tuple.Create('b', 'F'),
Tuple.Create('F', 'G'),
};
floorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
rooms,
new Rect[] { new Rect(5, 8, 2, 2), new Rect(9, 4, 2, 2) },
links);
}
TestFloorPlan compareFloorPlan;
{
Rect[] rooms = new Rect[]
{
new Rect(3, 3, 2, 4),
new Rect(3, 7, 2, 3),
new Rect(7, 7, 2, 3),
new Rect(7, 3, 2, 4),
new Rect(7, 1, 2, 2),
new Rect(11, 3, 2, 4),
new Rect(11, 1, 2, 2),
};
var links = new Tuple <char, char>[]
{
Tuple.Create('A', 'B'),
Tuple.Create('B', 'a'),
Tuple.Create('a', 'C'),
Tuple.Create('C', 'D'),
Tuple.Create('D', 'E'),
Tuple.Create('D', 'b'),
Tuple.Create('b', 'F'),
Tuple.Create('F', 'G'),
Tuple.Create('A', 'c'),
Tuple.Create('c', 'D'),
Tuple.Create('E', 'd'),
Tuple.Create('d', 'G'),
};
compareFloorPlan = TestFloorPlan.InitFloorToContext(
new Loc(22, 14),
rooms,
new Rect[] { new Rect(5, 8, 2, 2), new Rect(9, 4, 2, 2), new Rect(5, 3, 2, 4), new Rect(9, 1, 2, 2) },
links);
}
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
testRand.Setup(p => p.Next(It.IsAny <int>())).Returns(0);
var mockHalls = new Mock <IRandPicker <PermissiveRoomGen <IFloorPlanTestContext> > >(MockBehavior.Strict);
Moq.Language.ISetupSequentialResult <PermissiveRoomGen <IFloorPlanTestContext> > hallSeq = mockHalls.SetupSequence(p => p.Pick(testRand.Object));
hallSeq = hallSeq.Returns(new TestFloorPlanGen('c'));
hallSeq = hallSeq.Returns(new TestFloorPlanGen('d'));
var pathGen = new ConnectBranchTestStep(mockHalls.Object)
{
ConnectPercent = 100
};
pathGen.ApplyToPath(testRand.Object, floorPlan);
TestFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}