/* Create a zone of the specified type and number of nodes. */
public Zone(String ID, zoneType ty, int zoneLevel, int numberOfnodes) : base(ID)
{
if (zoneLevel < 1 || numberOfnodes < 2)
{
throw new ArgumentException(LevelTooLow);
}
type = ty;
level = zoneLevel;
if (ty == zoneType.STARTzone) //eerste node van startzone is startnode
{
level = 1;
Node startnode = new Node(NodeType.STARTnode, "Z1N1");
nodeCounter++;
startnode.capacity = 0;
startnode.zone = this;
nodes.Add(startnode);
Dungeon.startnode = startnode;
for (int i = 2; i < numberOfnodes; i++)
{
addCommonNode();
}
nodeCounter = 1;
makeBridge();
}
if (ty == zoneType.InBETWEENzone)
{
for (int i = 1; i < numberOfnodes; i++)
{
addCommonNode();
}
nodeCounter = 1;
makeBridge();
}
if (ty == zoneType.EXITzone)
{
for (int i = 1; i < numberOfnodes; i++)
{
addCommonNode();
}
Node exitnode = new Node(NodeType.EXITnode, "" + this.ID + "N" + nodeCounter);
nodeCounter = 1;
exitnode.capacity = 0;
exitnode.zone = this;
connectRandom(exitnode);
nodes.Add(exitnode);
Dungeon.exitnode = exitnode;
}
// When compiled in the Debug-build, check the following conditions:
Debug.Assert(nodes.Count >= 2);
Debug.Assert(ty == zoneType.STARTzone ? HelperPredicates.hasOneStartZone(this) : true);
Debug.Assert(ty == zoneType.EXITzone ? HelperPredicates.hasOneExitZone(this) : true);
Debug.Assert(HelperPredicates.isConnected(this));
}
[TestCase(DungeonShapeType.RANDOMshape, 4, 1)] //exactly enough capacity
public void Test_Dungeon_Constructor(DungeonShapeType shape, int rooms, int cap)
{
// Create the dungeon variable
Dungeon dungeon = null;
Exception exc = null;
//Pre-Condition
if (rooms < 3 || cap < 1)
{
//Check if constructor throws an exception when pre-condition is not met
Assert.Throws <ArgumentException>(() => new Dungeon(shape, rooms, cap));
}
//Post-Condition
else
{
//Try creating the dungeon
try
{
dungeon = new Dungeon(shape, rooms, cap);
}
catch (Exception e)
{
exc = e;
}
Assert.IsTrue(dungeon != null);
Assert.IsTrue(HelperPredicates.AllIdsAreUnique(dungeon)); //Check if all ids are unique
Assert.IsTrue(dungeon.Rooms.Count == rooms); //Check the number of rooms
Assert.IsTrue(HelperPredicates.Forall(dungeon.Rooms, r => r.Capacity <= cap)); //Check the capacity of each room
switch (shape)
{
case DungeonShapeType.LINEARshape:
Assert.IsTrue(HelperPredicates.IsLinear(dungeon));
break;
case DungeonShapeType.TREEshape:
Assert.IsTrue(HelperPredicates.IsTree(dungeon));
break;
case DungeonShapeType.RANDOMshape:
Assert.IsTrue(HelperPredicates.HasUniqueStartAndExit(dungeon));
Assert.IsTrue(HelperPredicates.AllReachableFromStart(dungeon));
Assert.IsFalse(HelperPredicates.IsTree(dungeon));
Assert.IsFalse(HelperPredicates.IsLinear(dungeon));
break;
}
}
}
public void Test_IsLinear()
{
var start = new Room("start", RoomType.STARTroom, 0);
var r1 = new Room("r1", RoomType.ORDINARYroom, 10);
var r2 = new Room("r2", RoomType.ORDINARYroom, 10);
var exit = new Room("exit", RoomType.EXITroom, 0);
start.Connect(r1);
r1.Connect(r2);
r2.Connect(exit);
var dungeon = new DummyDungeon();
// start -- r1 -- r2 -- exit
dungeon.Rooms.Add(start);
dungeon.Rooms.Add(r1);
dungeon.Rooms.Add(r2);
dungeon.Rooms.Add(exit);
Assert.IsFalse(HelperPredicates.IsLinear(dungeon));
dungeon.StartRoom = start;
dungeon.ExitRoom = exit;
Assert.IsTrue(HelperPredicates.IsLinear(dungeon));
// start -- r1 -- r2 exit
r2.Disconnect(exit);
Assert.IsFalse(HelperPredicates.IsLinear(dungeon));
// start -- r1 -- r2 -- exit
// |___________|
r2.Connect(exit);
r1.Connect(exit);
Assert.IsFalse(HelperPredicates.IsLinear(dungeon));
// start -- r1 ------ exit
// |___r2
r1.Disconnect(r2);
r2.Disconnect(exit);
start.Connect(r2);
Assert.IsFalse(HelperPredicates.IsLinear(dungeon));
}
public void NodeCap()
{
TemporalSpecification RNodeCap = new Always(G => HelperPredicates.forall(G.dungeon.nodes(), n => n.monsters.Count <= n.capacity));
Assert.AreEqual(Judgement.RelevantlyValid, RNodeCap.evaluate(testsuites, threshold));
}
