public void NonExitentTag()
{
var builder = new ReplacementRuleBuilder();
// don't move to nonexistent tag
Assert.ThrowsException <ArgumentException>(() => builder.MoveToTag("test"));
}
private Graph GenerateGraph()
{
var builder = new ReplacementRuleBuilder();
builder.MappedVertex <StartingRoom>("start")
.ReplacementVertexWithEdge <EmptyRoom, Edge>().ReplacementVertexWithEdge <EmptyRoom, Edge>()
.MoveToTag("start")
.ReplacementVertexWithEdge <EmptyRoom, Edge>().ReplacementVertexWithEdge <EmptyRoom, Edge>()
.MoveToTag("start")
.ReplacementVertexWithEdge <EmptyRoom, Edge>().ReplacementVertexWithEdge <EmptyRoom, Edge>();
var initialRule = builder.GetResult();
var dungeon = new Graph();
dungeon.Random = Game.Random;
dungeon.AddVertex(new StartingRoom());
dungeon.Replace(initialRule, true);
for (int i = 0; i < 20; i++)
{
int endurance = 10;
int ruleIndex;
bool ruleSuccess;
var rules = GetReplacementRules();
int acc = 0;
int[] absoluteDistribution = rules.Select(t => acc += t.Item2).ToArray();
do
{
if (endurance-- == 0)
{
builder.Reset()
.MappedVertex <EmptyRoom>()
.ReplacementVertexWithEdge <EmptyRoom, Edge>();
var addRoom = builder.GetResult();
dungeon.Replace(addRoom, true);
break;
}
int r = Game.Random.Next(acc);
for (ruleIndex = 0; ruleIndex < rules.Length; ruleIndex++)
{
if (r < absoluteDistribution[ruleIndex])
{
break;
}
}
ruleSuccess = dungeon.Replace(rules[ruleIndex].Item1, true);
} while (!ruleSuccess);
}
return(dungeon);
}
public void EdgeStart()
{
var builder = new ReplacementRuleBuilder();
// don't start with edge
Assert.ThrowsException <InvalidOperationException>(() => builder.PatternEdge <Edge>());
Assert.ThrowsException <InvalidOperationException>(() => builder.ReplacementEdge <Edge>());
Assert.ThrowsException <InvalidOperationException>(() => builder.MappedEdge <Edge>());
}
public void InvalidMappedVertexContinuation()
{
var builder = new ReplacementRuleBuilder();
// check impossible next states after adding mapped vertex
builder.MappedVertex <Vertex>();
Assert.ThrowsException <InvalidOperationException>(() => builder.PatternVertex <Vertex>());
Assert.ThrowsException <InvalidOperationException>(() => builder.ReplacementVertex <Vertex>());
Assert.ThrowsException <InvalidOperationException>(() => builder.MappedVertex <Vertex>());
}
public void Control()
{
var builder = new ReplacementRuleBuilder();
// invalid operations in "start" state
Assert.ThrowsException <InvalidOperationException>(() => builder.GetResult());
Assert.ThrowsException <InvalidOperationException>(() => builder.Continue());
builder.MappedVertex <Vertex>("test");
builder.MappedEdge <Edge>();
// can't get result if edge is unfinished
Assert.ThrowsException <InvalidOperationException>(() => builder.GetResult());
builder.MappedVertex <Vertex>();
builder.PatternEdge <Edge>();
// can't get result if edge is unfinished
Assert.ThrowsException <InvalidOperationException>(() => builder.GetResult());
// test continuing from end state
builder.PatternVertex <Vertex>().GetResult();
builder.Continue("test");
builder.ReplacementEdge <Edge>();
// can't get result if edge is unfinished
Assert.ThrowsException <InvalidOperationException>(() => builder.GetResult());
builder.ReplacementVertex <Vertex>();
// valid control:
var rule = builder.GetResult();
builder.Continue();
builder.MoveToTag("test");
builder.GetResult();
builder.Reset();
Assert.IsTrue(rule.Pattern.Vertices.Count == 3);
Assert.IsTrue(rule.Replacement.Vertices.Count == 3);
Assert.IsTrue(rule.Mapping.Count == 2);
}
public void Test()
{
Dungeon = new Graph();
int victoryPathLength = 10;
REssential[] victoryPath = new REssential[victoryPathLength];
for (int i = 0; i < victoryPathLength; i++)
{
victoryPath[i] = new REssential();
Dungeon.AddVertex(victoryPath[i]);
if (i > 0)
{
Dungeon.AddEdge(new Edge(victoryPath[i], victoryPath[i - 1]));
}
}
for (int i = 0; i < 2; i++)
{
var builder = new ReplacementRuleBuilder();
builder.MappedVertex <REssential>("loop")
.MappedVertexWithEdge <REssential, Edge>()
.MappedVertexWithEdge <REssential, Edge>()
.MappedVertexWithEdge <REssential, Edge>()
.ReplacementVertexWithEdge <RBasic, Edge>()
.ReplacementEdge <Edge>()
.MoveToTag("loop");
ReplacementRule addShortcut = builder.GetResult();
Assert.IsTrue(addShortcut.Pattern.Vertices.Count == 4);
Assert.IsTrue(addShortcut.Mapping.Count == 4);
Assert.IsTrue(addShortcut.Replacement.Vertices.Count == 5);
bool success = Dungeon.Replace(addShortcut, randomMatch: true);
Assert.IsTrue(success);
}
var bossTreasure = new ReplacementRule();
var anchorP = new RBasic();
bossTreasure.Pattern.AddVertex(anchorP);
var anchorR = new RBasic();
var boss = new RBoss();
var treasure = new RTreasure();
bossTreasure.Replacement.AddVertex(anchorR);
bossTreasure.Replacement.AddVertex(boss);
bossTreasure.Replacement.AddVertex(treasure);
bossTreasure.Replacement.AddEdge(new Edge(anchorR, boss));
bossTreasure.Replacement.AddEdge(new Edge(boss, treasure));
bossTreasure.Mapping[anchorP] = anchorR;
Assert.IsTrue(bossTreasure.Pattern.Vertices.Count == 1);
Assert.IsTrue(bossTreasure.Mapping.Count == 1);
Assert.IsTrue(bossTreasure.Replacement.Vertices.Count == 3);
bool success2 = Dungeon.Replace(bossTreasure, randomMatch: true);
Assert.IsTrue(success2);
File.WriteAllText("dungeon.gv", GraphPrinter.ToDot(Dungeon));
}
public void Start()
{
if (seed == 0)
{
seed = (int)System.DateTime.Now.Ticks;
}
Console.WriteLine("Seed: " + seed);
rnd = new Random(seed);
var builder = new ReplacementRuleBuilder();
builder.MappedVertex <StartingRoom>("start")
.ReplacementVertexWithEdge <BasicRoom, Edge>().ReplacementVertexWithEdge <BasicRoom, Edge>().MoveToTag("start")
.ReplacementVertexWithEdge <BasicRoom, Edge>().ReplacementVertexWithEdge <BasicRoom, Edge>().MoveToTag("start")
.ReplacementVertexWithEdge <BasicRoom, Edge>().ReplacementVertexWithEdge <BasicRoom, Edge>();
var initialRule = builder.GetResult();
var dungeon = new Graph();
dungeon.AddVertex(new StartingRoom());
dungeon.Replace(initialRule, true);
for (int i = 0; i < 15; i++)
{
builder.Reset()
.MappedVertex <BasicRoom>("a")
.PatternVertexWithEdge <BasicRoom, Edge>("b")
.MoveToTag("a").ReplacementVertexWithEdge <Junction, Edge>("j")
.ReplacementVertexWithEdge <BasicRoom, Edge>().MoveToTag("j")
.ReplacementVertexWithEdge <BasicRoom, Edge>().MapToTag("b");
var addJunction = builder.GetResult();
builder.Reset()
.MappedVertex <BasicRoom>("a")
.PatternVertexWithEdge <BasicRoom, Edge>("b").MoveToTag("a")
.ReplacementVertexWithEdge <BasicRoom, Edge>()
.ReplacementVertexWithEdge <BasicRoom, Edge>().MapToTag("b");
var stretch = builder.GetResult();
builder.Reset()
.MappedVertex <BasicRoom>("a")
.PatternVertexWithEdge <Junction, Edge>("j")
.PatternVertexWithEdge <BasicRoom, Edge>("b").MoveToTag("j")
.PatternVertexWithEdge <BasicRoom, Edge>("c").MoveToTag("a")
.ReplacementVertexWithEdge <BasicRoom, Edge>().MapToTag("b")
.ReplacementVertexWithEdge <BasicRoom, Edge>().MapToTag("c")
.ReplacementEdge <Edge>().MoveToTag("a");
var transformJunction = builder.GetResult();
builder.Reset()
.MappedVertex <BasicRoom>("a")
.MappedVertexWithEdge <BasicRoom, Edge>()
.MappedVertexWithEdge <BasicRoom, Edge>()
.MappedVertexWithEdge <BasicRoom, Edge>()
.ReplacementEdge <Edge>().MoveToTag("a");
var createLoop = builder.GetResult();
builder.Reset()
.MappedVertex <BasicRoom>()
.ReplacementVertexWithEdge <BasicRoom, Edge>();
var addRoom = builder.GetResult();
var rules = new Tuple <ReplacementRule, int>[]
{
Tuple.Create(addJunction, 3),
Tuple.Create(stretch, 2),
Tuple.Create(createLoop, 2),
Tuple.Create(transformJunction, 1)
};
int acc = 0;
int[] absoluteDistribution = rules.Select(t => acc += t.Item2).ToArray();
int endurance = 10;
int ruleIndex;
bool ruleSuccess;
do
{
if (endurance-- == 0)
{
dungeon.Replace(addRoom, true);
break;
}
int r = rnd.Next(acc);
for (ruleIndex = 0; ruleIndex < rules.Length; ruleIndex++)
{
if (r < absoluteDistribution[ruleIndex])
{
break;
}
}
ruleSuccess = dungeon.Replace(rules[ruleIndex].Item1, true);
} while (!ruleSuccess);
}
File.WriteAllText("advancedDungeon.gv", GraphPrinter.ToDot(dungeon));
}
private Tuple <ReplacementRule, int>[] GetReplacementRules()
{
var builder = new ReplacementRuleBuilder();
builder.Reset()
.MappedVertex <EmptyRoom>("a")
.PatternVertexWithEdge <EmptyRoom, Edge>("b")
.MoveToTag("a").ReplacementVertexWithEdge <Junction, Edge>("j")
.ReplacementVertexWithEdge <EmptyRoom, Edge>().MoveToTag("j")
.ReplacementVertexWithEdge <EmptyRoom, Edge>().MapToTag("b");
var addJunction = builder.GetResult();
builder.Reset()
.MappedVertex <EmptyRoom>("a")
.PatternVertexWithEdge <EmptyRoom, Edge>("b").MoveToTag("a")
.ReplacementVertexWithEdge <EmptyRoom, Edge>()
.ReplacementVertexWithEdge <EmptyRoom, Edge>().MapToTag("b");
var stretch = builder.GetResult();
builder.Reset()
.MappedVertex <EmptyRoom>("a")
.PatternVertexWithEdge <Junction, Edge>("j")
.PatternVertexWithEdge <EmptyRoom, Edge>("b").MoveToTag("j")
.PatternVertexWithEdge <EmptyRoom, Edge>("c").MoveToTag("a")
.ReplacementVertexWithEdge <EmptyRoom, Edge>().MapToTag("b")
.ReplacementVertexWithEdge <EmptyRoom, Edge>().MapToTag("c")
.ReplacementEdge <Edge>().MoveToTag("a");
var transformJunction = builder.GetResult();
builder.Reset()
.MappedVertex <EmptyRoom>("a")
.MappedVertexWithEdge <EmptyRoom, Edge>()
.MappedVertexWithEdge <EmptyRoom, Edge>()
.MappedVertexWithEdge <EmptyRoom, Edge>()
.ReplacementEdge <Edge>().MoveToTag("a");
var createLoop = builder.GetResult();
builder.Reset()
.MappedVertex <EmptyRoom>()
.ReplacementEdge <Edge>()
.ReplacementVertex <FountainRoom>();
var createFountain = builder.GetResult();
var randomMechs = new ReplacementRule();
var pattern = new Graph();
pattern.AddVertex(new EmptyRoom());
randomMechs.Pattern = pattern;
var replacement = new Graph();
replacement.AddVertex(new RandomMechsRoom());
randomMechs.Replacement = replacement;
randomMechs.Mapping = new Dictionary <Vertex, Vertex>()
{
{ pattern.Vertices.First(), replacement.Vertices.First() }
};
var rules = new[]
{
Tuple.Create(addJunction, 3),
Tuple.Create(stretch, 2),
Tuple.Create(createLoop, 1),
Tuple.Create(transformJunction, 1),
Tuple.Create(createFountain, 1),
Tuple.Create(randomMechs, 4)
};
return(rules);
}
