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 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 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);
}