public void FulfillRoomBordersNoneMissingIntersect()
{
// two intersecting sidereqs met with only one tile (do nothing)
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
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",
"XXXX.XXX",
"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(4, 7), Dir4.Down);
roomGen.Object.ReceiveBorderRange(new IntRange(2, 5), Dir4.Down);
roomGen.Object.FulfillRoomBorders(testContext, false);
roomGen.Verify(p => p.DigAtBorder(It.IsAny <ITiledGenContext>(), It.IsAny <Dir4>(), It.IsAny <int>()), Times.Never());
}
public void SetRoomBordersSubFulfillable()
{
var roomGen = new TestRoomGenException <ITiledGenContext>
{
OpenDown = true,
OpenLeft = true,
OpenUp = true,
OpenRight = true,
};
string[] inGrid =
{
"XXXXXXXX",
"XX.....X",
"XX.....X",
"XX.....X",
"XX.....X",
"XXXXXXXX",
"XXXXXXXX",
};
TestGenContext testContext = TestGenContext.InitGridToContext(inGrid);
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
roomGen.PrepareSize(testRand.Object, new Loc(5, 4));
roomGen.SetLoc(new Loc(2, 1));
roomGen.SetRoomBorders(testContext);
Assert.That(roomGen.PublicOpenedBorder[Dir4.Down], Is.EqualTo(new bool[] { false, false, true, false, false }));
Assert.That(roomGen.PublicOpenedBorder[Dir4.Left], Is.EqualTo(new bool[] { false, false, true, false }));
Assert.That(roomGen.PublicOpenedBorder[Dir4.Up], Is.EqualTo(new bool[] { false, false, true, false, false }));
Assert.That(roomGen.PublicOpenedBorder[Dir4.Right], Is.EqualTo(new bool[] { false, false, true, false }));
}
public void SetRoomBordersClear()
{
var roomGen = new TestRoomGen <ITiledGenContext>();
string[] inGrid =
{
"XXXXXXXX",
"XX.....X",
"XX.....X",
"XX.....X",
"XX.....X",
"XXXXXXXX",
"XXXXXXXX",
};
TestGenContext testContext = TestGenContext.InitGridToContext(inGrid);
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
roomGen.PrepareSize(testRand.Object, new Loc(5, 4));
roomGen.SetLoc(new Loc(2, 1));
roomGen.SetRoomBorders(testContext);
Assert.That(roomGen.PublicOpenedBorder[Dir4.Down], Is.EqualTo(new bool[] { true, true, true, true, true }));
Assert.That(roomGen.PublicOpenedBorder[Dir4.Left], Is.EqualTo(new bool[] { true, true, true, true }));
Assert.That(roomGen.PublicOpenedBorder[Dir4.Up], Is.EqualTo(new bool[] { true, true, true, true, true }));
Assert.That(roomGen.PublicOpenedBorder[Dir4.Right], Is.EqualTo(new bool[] { true, true, true, true }));
}
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 DrawOnMapMin()
{
// verify it fills up the entire square area!
var roomGen = new RoomGenBlocked <ITiledGenContext>
{
BlockWidth = new RandRange(2),
BlockHeight = new RandRange(1),
BlockTerrain = new TestTile(1),
};
string[] inGrid =
{
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
};
string[] outGrid =
{
"XXXXXXXX",
"X......X",
"X.XX...X",
"X......X",
"X......X",
"XXXXXXXX",
"XXXXXXXX",
};
TestGenContext testContext = TestGenContext.InitGridToContext(inGrid);
TestGenContext resultContext = TestGenContext.InitGridToContext(outGrid);
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
testRand.Setup(p => p.Next(1, 1)).Returns(1);
testRand.Setup(p => p.Next(2, 2)).Returns(2);
testRand.Setup(p => p.Next(1, 3)).Returns(1);
testRand.Setup(p => p.Next(1, 2)).Returns(1);
testContext.SetTestRand(testRand.Object);
roomGen.PrepareSize(testRand.Object, new Loc(6, 4));
roomGen.SetLoc(new Loc(1, 1));
roomGen.DrawOnMap(testContext);
Assert.That(testContext.Tiles, Is.EqualTo(resultContext.Tiles));
testRand.Verify(p => p.Next(1, 1), Times.Exactly(1));
testRand.Verify(p => p.Next(2, 2), Times.Exactly(1));
testRand.Verify(p => p.Next(1, 3), Times.Exactly(1));
testRand.Verify(p => p.Next(1, 2), Times.Exactly(1));
}
public void DrawOnMap4x7()
{
// larger width circle 4x7
Mock <RoomGenRound <ITiledGenContext> > roomGen = new Mock <RoomGenRound <ITiledGenContext> > {
CallBase = true
};
roomGen.Setup(p => p.SetRoomBorders(It.IsAny <ITiledGenContext>()));
string[] inGrid =
{
"XXXXXXXXXX",
"XXXXXXXXXX",
"XXXXXXXXXX",
"XXXXXXXXXX",
"XXXXXXXXXX",
"XXXXXXXXXX",
"XXXXXXXXXX",
"XXXXXXXXXX",
"XXXXXXXXXX",
"XXXXXXXXXX",
};
string[] outGrid =
{
"XXXXXXXXXX",
"XXX..XXXXX",
"XX....XXXX",
"XX....XXXX",
"XX....XXXX",
"XX....XXXX",
"XX....XXXX",
"XXX..XXXXX",
"XXXXXXXXXX",
"XXXXXXXXXX",
};
TestGenContext testContext = TestGenContext.InitGridToContext(inGrid);
TestGenContext resultContext = TestGenContext.InitGridToContext(outGrid);
roomGen.Object.PrepareSize(testContext.Rand, new Loc(4, 7));
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());
}
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 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 FulfillRoomBordersNoneOneMissing(int fulfillRoll, int expectedX)
{
// one sidereq not met (with rng)
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
testRand.Setup(p => p.Next(1)).Returns(0);
testRand.Setup(p => p.Next(4)).Returns(fulfillRoll);
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, 7), Dir4.Down);
roomGen.Object.FulfillRoomBorders(testContext, false);
roomGen.Verify(p => p.DigAtBorder(testContext, Dir4.Down, expectedX), Times.Once());
testRand.Verify(p => p.Next(1), Times.Exactly(1));
testRand.Verify(p => p.Next(4), Times.Exactly(1));
}
public void DrawOnMap()
{
// verify it fills up the entire square area!
var roomGen = new RoomGenSquare <ITiledGenContext>();
string[] inGrid =
{
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
"XXXXXXXX",
};
string[] outGrid =
{
"XXXXXXXX",
"XX.....X",
"XX.....X",
"XX.....X",
"XX.....X",
"XXXXXXXX",
"XXXXXXXX",
};
TestGenContext testContext = TestGenContext.InitGridToContext(inGrid);
TestGenContext resultContext = TestGenContext.InitGridToContext(outGrid);
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
roomGen.PrepareSize(testRand.Object, new Loc(5, 4));
roomGen.SetLoc(new Loc(2, 1));
roomGen.DrawOnMap(testContext);
Assert.That(testContext.Tiles, Is.EqualTo(resultContext.Tiles));
}
public void FulfillRoomBordersNoneOneMissingFillAll()
{
// one sidereq not met, fulfilled completely, only fulfillable borders
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
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",
"XXXXXXXX",
"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));
roomGen.Object.PublicFulfillableBorder[Dir4.Down][2] = false;
roomGen.Object.PublicFulfillableBorder[Dir4.Down][3] = false;
// find where the class chose to dig
roomGen.Object.ReceiveBorderRange(new IntRange(2, 7), Dir4.Down);
roomGen.Object.FulfillRoomBorders(testContext, true);
roomGen.Verify(p => p.DigAtBorder(testContext, Dir4.Down, 2), Times.Once());
roomGen.Verify(p => p.DigAtBorder(testContext, Dir4.Down, 3), Times.Once());
roomGen.Verify(p => p.DigAtBorder(testContext, Dir4.Down, 6), Times.Once());
}
public void DigAtBorder(Dir4 dir, int scalar, int resultGrid, bool exception)
{
var roomGen = new TestRoomGen <ITiledGenContext>();
string[] inGrid =
{
"XXXXXXXX",
"XX..X..X",
"XX....XX",
"XX...XXX",
"XX....XX",
"XXXXXXXX",
"XXXXXXXX",
};
string[] outGrid;
switch (resultGrid)
{
case 1:
outGrid = new string[]
{
"XXXXXXXX",
"XX.....X",
"XX....XX",
"XX...XXX",
"XX....XX",
"XXXXXXXX",
"XXXXXXXX",
};
break;
case 2:
outGrid = new string[]
{
"XXXXXXXX",
"XX..X..X",
"XX....XX",
"XX.....X",
"XX....XX",
"XXXXXXXX",
"XXXXXXXX",
};
break;
case 3:
outGrid = new string[]
{
"XXXXXXXX",
"XX..X..X",
"XX.....X",
"XX...X.X",
"XX.....X",
"XXXXXX.X",
"XXXXXXXX",
};
break;
default:
outGrid = inGrid;
break;
}
TestGenContext testContext = TestGenContext.InitGridToContext(inGrid);
TestGenContext resultContext = TestGenContext.InitGridToContext(outGrid);
Mock <IRandom> testRand = new Mock <IRandom>(MockBehavior.Strict);
roomGen.PrepareSize(testRand.Object, new Loc(5, 5));
roomGen.SetLoc(new Loc(2, 1));
if (exception)
{
Assert.Throws <ArgumentException>(() => { roomGen.DigAtBorder(testContext, dir, scalar); });
}
else
{
roomGen.DigAtBorder(testContext, dir, scalar);
Assert.That(testContext.Tiles, Is.EqualTo(resultContext.Tiles));
}
}
