public void PrepareFulfillableBorders()
{
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
testRand.Setup(p => p.Next(1, 3)).Returns(1);
testRand.Setup(p => p.Next(1, 7)).Returns(2);
Moq.Language.ISetupSequentialResult <int> seq = testRand.SetupSequence(p => p.Next(2));
seq = seq.Returns(1);
seq = seq.Returns(0);
var roomGen = new TestRoomGenCross <ITiledGenContext>
{
MajorWidth = new RandRange(2, 4),
MajorHeight = new RandRange(3, 9),
MinorWidth = new RandRange(1, 3),
MinorHeight = new RandRange(1, 7),
};
var expectedFulfillable = new Dictionary <Dir4, bool[]>
{
[Dir4.Down] = new bool[] { false, true },
[Dir4.Left] = new bool[] { true, true, false },
[Dir4.Up] = new bool[] { false, true },
[Dir4.Right] = new bool[] { true, true, false },
};
roomGen.PrepareSize(testRand.Object, new Loc(2, 3));
Assert.That(roomGen.PublicFulfillableBorder, Is.EqualTo(expectedFulfillable));
testRand.Verify(p => p.Next(It.IsAny <int>(), It.IsAny <int>()), Times.Exactly(2));
testRand.Verify(p => p.Next(It.IsAny <int>()), Times.Exactly(2));
}
public void DrawOnMap()
{
// verify pieces stay in contact even with adversarial rolls
Mock <RoomGenCross <ITiledGenContext> > roomGen = new Mock <RoomGenCross <ITiledGenContext> > {
CallBase = true
};
roomGen.Setup(p => p.SetRoomBorders(It.IsAny <ITiledGenContext>()));
roomGen.Object.MajorWidth = new RandRange(2, 6);
roomGen.Object.MajorHeight = new RandRange(3, 9);
roomGen.Object.MinorWidth = new RandRange(1, 2);
roomGen.Object.MinorHeight = new RandRange(1, 2);
string[] inGrid =
{
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
};
string[] outGrid =
{
"XXXXXXXX",
"XX.....X",
"XXXXXX.X",
"XXXXXX.X",
"XXXXXX.X",
"XXXXXXXX",
"XXXXXXXX",
};
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
Moq.Language.ISetupSequentialResult <int> seq = testRand.SetupSequence(p => p.Next(1, 2));
seq = seq.Returns(1);
seq = seq.Returns(1);
testRand.Setup(p => p.Next(5)).Returns(4);
testRand.Setup(p => p.Next(4)).Returns(0);
TestGenContext testContext = TestGenContext.InitGridToContext(inGrid);
testContext.SetTestRand(testRand.Object);
TestGenContext resultContext = TestGenContext.InitGridToContext(outGrid);
roomGen.Object.PrepareSize(testContext.Rand, new Loc(5, 4));
roomGen.Object.SetLoc(new Loc(2, 1));
roomGen.Object.DrawOnMap(testContext);
Assert.That(testContext.Tiles, Is.EqualTo(resultContext.Tiles));
roomGen.Verify(p => p.SetRoomBorders(testContext), Times.Once());
testRand.Verify(p => p.Next(1, 2), Times.Exactly(2));
testRand.Verify(p => p.Next(5), Times.Exactly(1));
testRand.Verify(p => p.Next(4), Times.Exactly(1));
}
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 ChooseRoomBounds(int boundW, int boundH, int tryW, int tryH, int w, int h, int rMaxX, int rMaxY, int randX, int randY)
{
const int boundX = 10;
const int boundY = 13;
Mock <TestGridFloorPlan> floorPlan = new Mock <TestGridFloorPlan> {
CallBase = true
};
floorPlan.Object.InitSize(4, 4, 8, 5);
floorPlan.Setup(p => p.GetCellBounds(Rect.Empty)).Returns(new Rect(boundX, boundY, boundW, boundH));
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
Moq.Language.ISetupSequentialResult <int> seq = testRand.SetupSequence(p => p.Next(rMaxX));
seq = seq.Returns(randX);
if (rMaxX == rMaxY)
{
seq = seq.Returns(randY);
}
else
{
Moq.Language.ISetupSequentialResult <int> seq2 = testRand.SetupSequence(p => p.Next(rMaxY));
seq2 = seq2.Returns(randY);
}
Mock <IRoomGen> mockRoom = new Mock <IRoomGen>(MockBehavior.Strict);
mockRoom.Setup(p => p.ProposeSize(testRand.Object)).Returns(new Loc(tryW, tryH));
mockRoom.Setup(p => p.PrepareSize(testRand.Object, new Loc(w, h)));
int x = boundX + randX;
int y = boundY + randY;
mockRoom.Setup(p => p.SetLoc(new Loc(x, y)));
// manually place the mock object instead of using AddRoom to copy it over
floorPlan.Object.PublicArrayRooms.Add(new GridRoomPlan(Rect.Empty, mockRoom.Object));
floorPlan.Object.ChooseRoomBounds(testRand.Object, 0);
// verify all were called
if (rMaxX == rMaxY)
{
testRand.Verify(p => p.Next(rMaxX), Times.Exactly(2));
}
else
{
testRand.Verify(p => p.Next(rMaxX), Times.Exactly(1));
testRand.Verify(p => p.Next(rMaxY), Times.Exactly(1));
}
mockRoom.Verify(p => p.ProposeSize(It.IsAny <IRandom>()), Times.Exactly(1));
mockRoom.Verify(p => p.PrepareSize(It.IsAny <IRandom>(), It.IsAny <Loc>()), Times.Exactly(1));
mockRoom.Verify(p => p.SetLoc(It.IsAny <Loc>()), Times.Exactly(1));
}
public void Comb4Choose3B()
{
string[] inGrid =
{
"0.0.0.0.0",
". . . . .",
"0.A#C#E#G",
". # # # #",
"0.B.D.F.H",
". . . . .",
"0.0.0.0.0",
};
string[] outGrid =
{
"0.0.0.0.0",
". . . . .",
"0.A#C#E#G",
". # # # #",
"0.B#D.F#H",
". . . . .",
"0.0.0.0.0",
};
TestGridFloorPlan floorPlan = TestGridFloorPlan.InitGridToContext(inGrid);
TestGridFloorPlan compareFloorPlan = TestGridFloorPlan.InitGridToContext(outGrid);
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
testRand.Setup(p => p.Next(It.IsNotIn <int>(100, 4))).Returns(0);
testRand.Setup(p => p.Next(4)).Returns(3);
Moq.Language.ISetupSequentialResult <int> seq = testRand.SetupSequence(p => p.Next(100));
seq = seq.Returns(0);
seq = seq.Returns(0);
seq = seq.Returns(0);
seq = seq.Returns(99);
var pathGen = new ConnectGridBranchStep <IGridPathTestContext> {
ConnectPercent = 50
};
Mock <IRandPicker <PermissiveRoomGen <IGridPathTestContext> > > mockHalls = new Mock <IRandPicker <PermissiveRoomGen <IGridPathTestContext> > >(MockBehavior.Strict);
mockHalls.Setup(p => p.Pick(testRand.Object)).Returns(new TestGridRoomGen());
pathGen.GenericHalls = mockHalls.Object;
pathGen.ApplyToPath(testRand.Object, floorPlan);
TestGridFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
}
[TestCase(2, 2, 2, 2, 0, 0, 4)] // all on another room is possible
public void RoomSpawnStepSpawnRandInCandRooms(int seq1, int seq2, int seq3, int seq4, int room1s, int room2s, int room3s)
{
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
// choose freetile count
Moq.Language.ISetupSequentialResult <int> seq = testRand.SetupSequence(p => p.Next(3));
seq = seq.Returns(seq1);
seq = seq.Returns(seq2);
seq = seq.Returns(seq3);
seq = seq.Returns(seq4);
Mock <IPlaceableRoomTestContext> mockMap = new Mock <IPlaceableRoomTestContext>(MockBehavior.Strict);
mockMap.SetupGet(p => p.Rand).Returns(testRand.Object);
var spawningRooms = new SpawnList <RoomHallIndex>
{
{ new RoomHallIndex(0, false), 1 },
{ new RoomHallIndex(1, false), 1 },
{ new RoomHallIndex(2, false), 1 },
};
// get a list of spawns
List <SpawnableChar> spawns = new List <SpawnableChar>();
foreach (Dir4 dir in DirExt.VALID_DIR4)
{
spawns.Add(new SpawnableChar('a'));
}
var roomSpawner = new Mock <RandomRoomSpawnStep <IPlaceableRoomTestContext, SpawnableChar> >(null, false)
{
CallBase = true
};
roomSpawner.Setup(p => p.SpawnInRoom(mockMap.Object, new RoomHallIndex(0, false), new SpawnableChar('a'))).Returns(true);
roomSpawner.Setup(p => p.SpawnInRoom(mockMap.Object, new RoomHallIndex(1, false), new SpawnableChar('a'))).Returns(true);
roomSpawner.Setup(p => p.SpawnInRoom(mockMap.Object, new RoomHallIndex(2, false), new SpawnableChar('a'))).Returns(true);
roomSpawner.Object.SpawnRandInCandRooms(mockMap.Object, spawningRooms, spawns, 100);
roomSpawner.Verify(p => p.SpawnInRoom(mockMap.Object, new RoomHallIndex(0, false), new SpawnableChar('a')), Times.Exactly(room1s));
roomSpawner.Verify(p => p.SpawnInRoom(mockMap.Object, new RoomHallIndex(1, false), new SpawnableChar('a')), Times.Exactly(room2s));
roomSpawner.Verify(p => p.SpawnInRoom(mockMap.Object, new RoomHallIndex(2, false), new SpawnableChar('a')), Times.Exactly(room3s));
// assert that the right values have been taken out of the lists
Assert.That(spawningRooms.Count, Is.EqualTo(3));
Assert.That(spawns.Count, Is.EqualTo(0));
}
public void FulfillRoomBordersNoneMultiMissingIntersect(int roll1, int roll2, int expected1, int expected2)
{
// full sidereq not met on one side, one adjacent sidereq not met on a corner tile
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
Moq.Language.ISetupSequentialResult <int> seq = testRand.SetupSequence(p => p.Next(4));
seq = seq.Returns(roll1);
seq = testRand.SetupSequence(p => p.Next(3));
seq = seq.Returns(roll2);
seq = testRand.SetupSequence(p => p.Next(1));
seq = seq.Returns(0);
seq = seq.Returns(0);
Mock <TestRoomGen <ITiledGenContext> > roomGen = new Mock <TestRoomGen <ITiledGenContext> > {
CallBase = true
};
roomGen.Setup(p => p.DigAtBorder(It.IsAny <ITiledGenContext>(), It.IsAny <Dir4>(), It.IsAny <int>()));
string[] inGrid =
{
"XXXXXXXX",
"XX.....X",
"XX....XX",
"XX....XX",
"XX.XXXXX",
"XXXXXXXX",
"XXXXXXXX",
};
TestGenContext testContext = TestGenContext.InitGridToContext(inGrid);
testContext.SetTestRand(testRand.Object);
roomGen.Object.PrepareSize(testRand.Object, new Loc(5, 4));
roomGen.Object.SetLoc(new Loc(2, 1));
// find where the class chose to dig
roomGen.Object.ReceiveBorderRange(new IntRange(3, 7), Dir4.Down);
roomGen.Object.ReceiveBorderRange(new IntRange(2, 5), Dir4.Right);
roomGen.Object.FulfillRoomBorders(testContext, false);
roomGen.Verify(p => p.DigAtBorder(testContext, Dir4.Down, expected1), Times.Once());
roomGen.Verify(p => p.DigAtBorder(testContext, Dir4.Right, expected2), Times.Once());
testRand.Verify(p => p.Next(4), Times.Exactly(1));
testRand.Verify(p => p.Next(3), Times.Exactly(1));
testRand.Verify(p => p.Next(1), Times.Exactly(2));
}
public void RoomSpawnStepSpawnInRoom(int chosenRand, int locX, int locY)
{
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
// choose freetile count
Moq.Language.ISetupSequentialResult <int> seq = testRand.SetupSequence(p => p.Next(4));
seq = seq.Returns(chosenRand);
Mock <IPlaceableRoomTestContext> mockMap = new Mock <IPlaceableRoomTestContext>(MockBehavior.Strict);
mockMap.SetupGet(p => p.Rand).Returns(testRand.Object);
// get free tiles
var freeLocs = new List <Loc>
{
new Loc(1, 2),
new Loc(3, 4),
new Loc(5, 5),
new Loc(3, 2),
};
mockMap.Setup(p => p.GetFreeTiles(new Rect(10, 20, 30, 40))).Returns(freeLocs);
// expect place item
mockMap.Setup(p => p.PlaceItem(new Loc(locX, locY), new SpawnableChar('a')));
Mock <IRoomGen> mockRoom = new Mock <IRoomGen>(MockBehavior.Strict);
mockRoom.SetupGet(p => p.Draw).Returns(new Rect(10, 20, 30, 40));
var roomPlan = new FloorRoomPlan(mockRoom.Object);
Mock <FloorPlan> mockFloor = new Mock <FloorPlan>(MockBehavior.Strict);
mockFloor.Setup(p => p.GetRoomHall(new RoomHallIndex(0, false))).Returns(roomPlan);
mockMap.SetupGet(p => p.RoomPlan).Returns(mockFloor.Object);
var roomSpawner = new Mock <RoomSpawnStep <IPlaceableRoomTestContext, SpawnableChar> >(null)
{
CallBase = true
};
roomSpawner.Object.SpawnInRoom(mockMap.Object, new RoomHallIndex(0, false), new SpawnableChar('a'));
// verify the correct placeitem was called
mockMap.Verify(p => p.PlaceItem(new Loc(locX, locY), new SpawnableChar('a')), Times.Exactly(1));
}
public void LoopedRand()
{
var amountRange = new RandRange(3, 6);
var valueRange = new RandRange(0, 4);
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
testRand.SetupSequence(p => p.Next(3, 6)).Returns(4);
Moq.Language.ISetupSequentialResult <int> seq = testRand.SetupSequence(p => p.Next(0, 4));
seq = seq.Returns(0);
seq = seq.Returns(1);
seq = seq.Returns(2);
seq = seq.Returns(3);
LoopedRand <int> looped = new LoopedRand <int>(valueRange, amountRange);
List <int> result = looped.Roll(testRand.Object);
List <int> compare = new List <int> {
0, 1, 2, 3
};
Assert.That(result, Is.EquivalentTo(compare));
testRand.Verify(p => p.Next(It.IsAny <int>(), It.IsAny <int>()), Times.Exactly(5));
}
public void CreateErrorPath()
{
string[] inGrid =
{
"0.0",
". .",
"0.0",
};
string[] outGrid =
{
"A.0",
". .",
"0.0",
};
var pathGen = new Mock <GridPathStartStepGeneric <IGridPathTestContext> > {
CallBase = true
};
Moq.Language.ISetupSequentialResult <RoomGen <IGridPathTestContext> > defaultSeq = pathGen.SetupSequence(p => p.GetDefaultGen());
defaultSeq = defaultSeq.Returns(new TestGridRoomGen('A'));
Mock <IRandPicker <PermissiveRoomGen <IGridPathTestContext> > > mockHalls = new Mock <IRandPicker <PermissiveRoomGen <IGridPathTestContext> > >(MockBehavior.Strict);
pathGen.Object.GenericHalls = mockHalls.Object;
Mock <IRandPicker <RoomGen <IGridPathTestContext> > > mockRooms = new Mock <IRandPicker <RoomGen <IGridPathTestContext> > >(MockBehavior.Strict);
pathGen.Object.GenericRooms = mockRooms.Object;
Mock <IRandom> mockRand = new Mock <IRandom>(MockBehavior.Strict);
TestGridFloorPlan floorPlan = TestGridFloorPlan.InitGridToContext(inGrid);
TestGridFloorPlan compareFloorPlan = TestGridFloorPlan.InitGridToContext(outGrid);
pathGen.Object.CreateErrorPath(mockRand.Object, floorPlan);
TestGridFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
pathGen.Verify(p => p.GetDefaultGen(), Times.Exactly(1));
}
public void FulfillRoomBordersNoneOneMissingIntersect()
{
// two intersecting sidereqs not met
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
Moq.Language.ISetupSequentialResult <int> seq = testRand.SetupSequence(p => p.Next(2));
seq = seq.Returns(1);
seq = seq.Returns(0);
testRand.Setup(p => p.Next(1)).Returns(0);
Mock <TestRoomGen <ITiledGenContext> > roomGen = new Mock <TestRoomGen <ITiledGenContext> > {
CallBase = true
};
roomGen.Setup(p => p.DigAtBorder(It.IsAny <ITiledGenContext>(), It.IsAny <Dir4>(), It.IsAny <int>()));
string[] inGrid =
{
"XXXXXXXX",
"XX.....X",
"XX.....X",
"XX.....X",
"XX.XXXXX",
"XXXXXXXX",
"XXXXXXXX",
};
TestGenContext testContext = TestGenContext.InitGridToContext(inGrid);
testContext.SetTestRand(testRand.Object);
roomGen.Object.PrepareSize(testRand.Object, new Loc(5, 4));
roomGen.Object.SetLoc(new Loc(2, 1));
// find where the class chose to dig
roomGen.Object.ReceiveBorderRange(new IntRange(3, 6), Dir4.Down);
roomGen.Object.ReceiveBorderRange(new IntRange(4, 7), Dir4.Down);
roomGen.Object.FulfillRoomBorders(testContext, false);
roomGen.Verify(p => p.DigAtBorder(testContext, Dir4.Down, 4), Times.Once());
testRand.Verify(p => p.Next(2), Times.Exactly(2));
testRand.Verify(p => p.Next(1), Times.Exactly(1));
}
public void CreatePathMinSize()
{
string[] inGrid =
{
"0.0",
};
string[] outGrid =
{
"A#B",
};
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
var pathGen = new GridPathTwoSides <IGridPathTestContext> {
GapAxis = Axis4.Horiz
};
Mock <IRandPicker <PermissiveRoomGen <IGridPathTestContext> > > mockHalls = new Mock <IRandPicker <PermissiveRoomGen <IGridPathTestContext> > >(MockBehavior.Strict);
mockHalls.Setup(p => p.Pick(testRand.Object)).Returns(new TestGridRoomGen());
pathGen.GenericHalls = mockHalls.Object;
Mock <IRandPicker <RoomGen <IGridPathTestContext> > > mockRooms = new Mock <IRandPicker <RoomGen <IGridPathTestContext> > >(MockBehavior.Strict);
Moq.Language.ISetupSequentialResult <RoomGen <IGridPathTestContext> > roomSeq = mockRooms.SetupSequence(p => p.Pick(testRand.Object));
roomSeq = roomSeq.Returns(new TestGridRoomGen('A'));
roomSeq = roomSeq.Returns(new TestGridRoomGen('B'));
pathGen.GenericRooms = mockRooms.Object;
TestGridFloorPlan floorPlan = TestGridFloorPlan.InitGridToContext(inGrid);
TestGridFloorPlan compareFloorPlan = TestGridFloorPlan.InitGridToContext(outGrid);
pathGen.ApplyToPath(testRand.Object, floorPlan);
TestGridFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
mockHalls.Verify(p => p.Pick(testRand.Object), Times.Exactly(1));
mockRooms.Verify(p => p.Pick(testRand.Object), Times.Exactly(2));
}
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 CreatePathMedSize()
{
string[] inGrid =
{
"0.0.0.0",
". . . .",
"0.0.0.0",
". . . .",
"0.0.0.0",
};
string[] outGrid =
{
"A#C.C#B",
"# . . .",
"D#F.F#E",
"# . . .",
"G#I.I#H",
};
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
testRand.Setup(p => p.Next(2)).Returns(0);
var pathGen = new Mock <GridPathTwoSides <IGridPathTestContext> > {
CallBase = true
};
pathGen.Object.GapAxis = Axis4.Horiz;
Moq.Language.ISetupSequentialResult <RoomGen <IGridPathTestContext> > defaultSeq = pathGen.SetupSequence(p => p.GetDefaultGen());
defaultSeq = defaultSeq.Returns(new TestGridRoomGen('C'));
defaultSeq = defaultSeq.Returns(new TestGridRoomGen('F'));
defaultSeq = defaultSeq.Returns(new TestGridRoomGen('I'));
Mock <IRandPicker <PermissiveRoomGen <IGridPathTestContext> > > mockHalls = new Mock <IRandPicker <PermissiveRoomGen <IGridPathTestContext> > >(MockBehavior.Strict);
mockHalls.Setup(p => p.Pick(testRand.Object)).Returns(new TestGridRoomGen());
pathGen.Object.GenericHalls = mockHalls.Object;
Mock <IRandPicker <RoomGen <IGridPathTestContext> > > mockRooms = new Mock <IRandPicker <RoomGen <IGridPathTestContext> > >(MockBehavior.Strict);
Moq.Language.ISetupSequentialResult <RoomGen <IGridPathTestContext> > roomSeq = mockRooms.SetupSequence(p => p.Pick(testRand.Object));
roomSeq = roomSeq.Returns(new TestGridRoomGen('A'));
roomSeq = roomSeq.Returns(new TestGridRoomGen('B'));
roomSeq = roomSeq.Returns(new TestGridRoomGen('D'));
roomSeq = roomSeq.Returns(new TestGridRoomGen('E'));
roomSeq = roomSeq.Returns(new TestGridRoomGen('G'));
roomSeq = roomSeq.Returns(new TestGridRoomGen('H'));
pathGen.Object.GenericRooms = mockRooms.Object;
TestGridFloorPlan floorPlan = TestGridFloorPlan.InitGridToContext(inGrid);
TestGridFloorPlan compareFloorPlan = TestGridFloorPlan.InitGridToContext(outGrid);
pathGen.Object.ApplyToPath(testRand.Object, floorPlan);
TestGridFloorPlan.CompareFloorPlans(floorPlan, compareFloorPlan);
testRand.Verify(p => p.Next(2), Times.Exactly(2));
mockHalls.Verify(p => p.Pick(testRand.Object), Times.Exactly(8));
mockRooms.Verify(p => p.Pick(testRand.Object), Times.Exactly(6));
pathGen.Verify(p => p.GetDefaultGen(), Times.Exactly(3));
}
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);
}
