public void FizzBuzzTest()
{
rules.AddRule(3, "Fizz");
rules.AddRule(5, "Buzz");
Assert.AreEqual(rules.GetNumberAsSingleKeyword(3), "Fizz");
Assert.AreEqual(rules.GetNumberAsSingleKeyword(5), "Buzz");
Assert.AreEqual(rules.GetNumberAsWholeKeyword(15), "FizzBuzz");
Assert.AreEqual(rules.GetNumberAsWholeKeyword(30), "FizzBuzz");
Assert.AreEqual(rules.GetNumberAsWholeKeyword(315), "FizzBuzz");
Assert.AreEqual(rules.GetNumberAsWholeKeyword(630), "FizzBuzz");
}
public static (List <List <IShape> >, List <(IShape, List <IShape>)>) Run(int min, int max, uint times)
{
Rules rules = new Rules();
rules.AddRule(
new Attributes(
),
(Quad quad) => {
Vertex b1 = quad.l1.Bisect();
Vertex b2 = quad.l2.Bisect();
Vertex b3 = quad.l3.Bisect();
Vertex b4 = quad.l4.Bisect();
Vertex c = (b1 + b2 + b3 + b4) / 4f;
Quad q4 = new Quad(rules, quad.Attributes.Copy(), (0, 0), (b4, c, b3, quad.v4));
Quad q1 = new Quad(rules, quad.Attributes.Copy(), (1, 0), (quad.v1, b1, c, b4));
Quad q3 = new Quad(rules, quad.Attributes.Copy(), (0, 1), (c, b2, quad.v3, b3));
Quad q2 = new Quad(rules, quad.Attributes.Copy(), (1, 1), (b1, quad.v2, b2, c));
if (quad.VC == null || !quad.VC.Persistant)
{
VirtualConnection.Connect(q4, q1, false, false, true);
VirtualConnection.Connect(q3, q2, true, false, true);
}
return(new List <IShape> {
q1, q2, q3, q4
});
}
internal IRuleDefinition <T> Define()
{
CurrentRule = new Rule <T>();
Rules.AddRule(CurrentRule);
return(this);
}
private int Solve(bool part2)
{
var rules = new Rules(part2);
var tests = new List <string>();
foreach (var line in _input)
{
if (line.Contains(':'))
{
rules.AddRule(line);
}
else
{
tests.Add(line);
}
}
var regex = new Regex($"^{rules.GetRegex(0)}$", RegexOptions.Compiled);
return(tests.Count(regex.IsMatch));
}
public static (List <List <IShape> >, List <(IShape, List <IShape>)>) Run(int min, int max, uint times)
{
Rules rules = new Rules();
rules.AddRule(
new Attributes(
("Floors", new ScalarAttribute(3f))
),
(Start start) => {
Vertex[] v1 = start.l2.Sections(0.3f, 0.65f);
Vertex[] v2 = start.l4.Sections(0.35f, 0.7f);
Floor f1 = new Floor(rules, start.Attributes.Copy(), (0, 2), (start.v1, start.v2, v1[1], v2[0]));
Floor f2 = new Floor(rules, start.Attributes.Copy(), (0, 1), (v2[0], v1[1], v1[0], v2[1]));
Floor f3 = new Floor(rules, start.Attributes.Copy(), (0, 0), (v2[1], v1[0], start.v3, start.v4));
return(new List <IShape> {
f1, f2, f3
});
}
);
rules.AddRule(
new Attributes(
("Floors", new ScalarAttribute(2f)),
("Wide", new ScalarAttribute(0f))
),
(Start start) => {
Vertex[] v1 = start.l1.Sections(4);
Vertex[] v2 = start.l3.Sections(4);
Attributes a = start.Attributes.Copy();
a.Set("RoofSlanted", new ScalarAttribute(1f));
Vertical s1 = new Vertical(rules, a.Copy(), (0, 0), (start.v1, v1[3], v2[0], start.v4));
Vertical s2 = new Vertical(rules, start.Attributes.Copy(), (1, 0), (v1[3], v1[2], v2[1], v2[0]));
Vertical s3 = new Vertical(rules, start.Attributes.Copy(), (2, 0), (v1[2], v1[1], v2[2], v2[1]));
Vertical s4 = new Vertical(rules, start.Attributes.Copy(), (3, 0), (v1[1], v1[0], v2[3], v2[2]));
Vertical s5 = new Vertical(rules, a.Copy(), (4, 0), (v1[0], start.v2, start.v3, v2[3]));
VirtualConnection.Connect(s1, s5, true, false, true);
return(new List <IShape> {
s1, s2, s3, s4, s5
});
}
);
rules.AddRule(
new Attributes(
("Floors", new ScalarAttribute(2f)),
("Wide", new ScalarAttribute(1f))
),
(Start start) => {
Vertex[] v1 = start.l1.Sections(10);
Vertex[] v2 = start.l3.Sections(10);
Vertical s1 = new Vertical(rules, start.Attributes.Copy(), (0, 0), (start.v1, v1[9], v2[0], start.v4));
Vertical s2 = new Vertical(rules, start.Attributes.Copy(), (1, 0), (v1[9], v1[8], v2[1], v2[0]));
Vertical s3 = new Vertical(rules, start.Attributes.Copy(), (2, 0), (v1[8], v1[7], v2[2], v2[1]));
Vertical s4 = new Vertical(rules, start.Attributes.Copy(), (3, 0), (v1[7], v1[6], v2[3], v2[2]));
Vertical s5 = new Vertical(rules, start.Attributes.Copy(), (4, 0), (v1[6], v1[5], v2[4], v2[3]));
Vertical s6 = new Vertical(rules, start.Attributes.Copy(), (5, 0), (v1[5], v1[4], v2[5], v2[4]));
Vertical s7 = new Vertical(rules, start.Attributes.Copy(), (6, 0), (v1[4], v1[3], v2[6], v2[5]));
Vertical s8 = new Vertical(rules, start.Attributes.Copy(), (7, 0), (v1[3], v1[2], v2[7], v2[6]));
Vertical s9 = new Vertical(rules, start.Attributes.Copy(), (8, 0), (v1[2], v1[1], v2[8], v2[7]));
Vertical s10 = new Vertical(rules, start.Attributes.Copy(), (9, 0), (v1[1], v1[0], v2[9], v2[8]));
Vertical s11 = new Vertical(rules, start.Attributes.Copy(), (10, 0), (v1[0], start.v2, start.v3, v2[9]));
return(new List <IShape> {
s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11
});
}
);
rules.AddRule(
new Attributes(
("RoofSlanted", new ScalarAttribute(0f))
),
(Vertical vertical) => {
Vertex[] v1 = vertical.l2.Sections(0.3f, 0.65f);
Vertex[] v2 = vertical.l4.Sections(0.35f, 0.7f);
Section s1 = new Section(rules, vertical.Attributes.Copy(), (0, 2), (vertical.v1, vertical.v2, v1[1], v2[0]));
Section s2 = new Section(rules, vertical.Attributes.Copy(), (0, 1), (v2[0], v1[1], v1[0], v2[1]));
Roof r = new Roof(rules, vertical.Attributes.Copy(), (0, 0), (v2[1], v1[0], vertical.v3, vertical.v4));
return(new List <IShape> {
s1, s2, r
});
}
);
rules.AddRule(
new Attributes(
("RoofSlanted", new ScalarAttribute(1f))
),
(Vertical vertical) => {
Vertex[] v1 = vertical.l2.Sections(0.3f, 0.65f);
Vertex[] v2 = vertical.l4.Sections(0.35f, 0.7f);
Section s = new Section(rules, vertical.Attributes.Copy(), (0, 2), (vertical.v1, vertical.v2, v1[1], v2[0]));
Roof r = new Roof(rules, vertical.Attributes.Copy(), (0, 1), (v2[0], v1[1], v1[0], v2[1]));
return(new List <IShape> {
s, r
});
}
);
rules.AddRule(
new Attributes(
("RoofSlanted", new ScalarAttribute(1f))
),
(Roof roof) => {
Vertex v = roof.l2.Bisect();
Triad t = new Triad(rules, roof.Attributes.Copy(), (0, 0), (v, roof.v1, roof.v2));
return(new List <IShape> {
t
});
}
);
rules.AddRule(
new Attributes(
("RoofSize", new ScalarAttribute(1f)),
("RoofSlanted", new ScalarAttribute(0f))
),
(Roof roof) => {
Vertex v1 = roof.l2.Bisect(0.6f);
Vertex v2 = roof.l4.Bisect(0.4f);
Quad q = new Quad(rules, roof.Attributes.Copy(), (0, 0), (roof.v2, v1, v2, roof.v1));
return(new List <IShape> {
q
});
}
);
rules.AddRule(
new Attributes(
("RoofSize", new ScalarAttribute(2f)),
("RoofSlanted", new ScalarAttribute(0f))
),
(Roof roof) => {
Vertex v1 = roof.l2.Bisect(0.7f);
Vertex v2 = roof.l4.Bisect(0.3f);
Quad q = new Quad(rules, roof.Attributes.Copy(), (0, 0), (roof.v2, v1, v2, roof.v1));
return(new List <IShape> {
q
});
}
);
rules.AddRule(
new Attributes(
("RoofSize", new ScalarAttribute(3f)),
("RoofSlanted", new ScalarAttribute(0f))
),
(Roof roof) => {
Vertex v1 = roof.l2.Bisect(0.8f);
Vertex v2 = roof.l4.Bisect(0.2f);
Quad q = new Quad(rules, roof.Attributes.Copy(), (0, 0), (roof.v2, v1, v2, roof.v1));
return(new List <IShape> {
q
});
}
);
rules.AddRule(
new Attributes(
("Sections", new ScalarAttribute(5f))
),
(Floor floor) => {
Vertex[] v1 = floor.l1.Sections(4);
Vertex[] v2 = floor.l3.Sections(4);
Section s1 = new Section(rules, floor.Attributes.Copy(), (0, 0), (floor.v1, v1[3], v2[0], floor.v4));
Section s2 = new Section(rules, floor.Attributes.Copy(), (1, 0), (v1[3], v1[2], v2[1], v2[0]));
Section s3 = new Section(rules, floor.Attributes.Copy(), (2, 0), (v1[2], v1[1], v2[2], v2[1]));
Section s4 = new Section(rules, floor.Attributes.Copy(), (3, 0), (v1[1], v1[0], v2[3], v2[2]));
Section s5 = new Section(rules, floor.Attributes.Copy(), (4, 0), (v1[0], floor.v2, floor.v3, v2[3]));
return(new List <IShape> {
s1, s2, s3, s4, s5
});
}
);
rules.AddRule(
new Attributes(
("Sections", new ScalarAttribute(4f))
),
(Floor floor) => {
Vertex[] v1 = floor.l1.Sections(3);
Vertex[] v2 = floor.l3.Sections(3);
Section s1 = new Section(rules, floor.Attributes.Copy(), (0, 0), (floor.v1, v1[2], v2[0], floor.v4));
Section s2 = new Section(rules, floor.Attributes.Copy(), (1, 0), (v1[2], v1[1], v2[1], v2[0]));
Section s3 = new Section(rules, floor.Attributes.Copy(), (2, 0), (v1[1], v1[0], v2[2], v2[1]));
Section s4 = new Section(rules, floor.Attributes.Copy(), (4, 0), (v1[0], floor.v2, floor.v3, v2[2]));
return(new List <IShape> {
s1, s2, s3, s4
});
}
);
rules.AddRule(
new Attributes(
("Door", new ScalarAttribute(0f)),
("Corn", new ScalarAttribute(1f)),
("Bar", new ScalarAttribute(1f)),
("Stairs", new ScalarAttribute(0f))
),
(Section section) => {
Vertex[] v1 = section.l2.Sections(0.1f, 0.85f);
Vertex[] v2 = section.l4.Sections(0.15f, 0.9f);
Attributes a = section.Attributes.Copy();
a.Set("Corn", new ScalarAttribute(0f));
a.Set("Bar", new ScalarAttribute(0f));
Attributes b = a.Copy();
b.Set("R", new ScalarAttribute(255f));
b.Set("G", new ScalarAttribute(255f));
b.Set("B", new ScalarAttribute(255f));
Cornice c = new Cornice(rules, b.Copy(), (0, 0), (section.v1, section.v2, v1[1], v2[0]));
Section s = new Section(rules, a, (0, 1), (v2[0], v1[1], v1[0], v2[1]));
Bar bar = new Bar(rules, b.Copy(), (0, 2), (v2[1], v1[0], section.v3, section.v4));
return(new List <IShape> {
c, s, bar
});
}
);
rules.AddRule(
new Attributes(
("Door", new ScalarAttribute(0f)),
("Corn", new ScalarAttribute(1f)),
("Bar", new ScalarAttribute(0f)),
("Stairs", new ScalarAttribute(0f))
),
(Section section) => {
Vertex[] v1 = section.l2.Sections(0.1f);
Vertex[] v2 = section.l4.Sections(0.9f);
Attributes a = section.Attributes.Copy();
a.Set("Corn", new ScalarAttribute(0f));
a.Set("Bar", new ScalarAttribute(0f));
Attributes b = a.Copy();
b.Set("R", new ScalarAttribute(255f));
b.Set("G", new ScalarAttribute(255f));
b.Set("B", new ScalarAttribute(255f));
Section s = new Section(rules, a, (0, 0), (section.v1, section.v2, v1[0], v2[0]));
Cornice c = new Cornice(rules, b, (0, 1), (v2[0], v1[0], section.v3, section.v4));
return(new List <IShape> {
s, c
});
}
);
rules.AddRule(
new Attributes(
("Corn", new ScalarAttribute(0f)),
("Bar", new ScalarAttribute(0f)),
("Door", new ScalarAttribute(0f)),
("Sections", new ScalarAttribute(4f)),
("Stairs", new ScalarAttribute(0f))
),
(Section section) => {
Vertex[] v1 = section.l1.Sections(0.25f, 0.75f);
Vertex[] v2 = section.l3.Sections(0.25f, 0.75f);
Line l1 = new Line(v1[0], v2[1]);
Line l2 = new Line(v1[1], v2[0]);
Vertex[] v3 = l1.Sections(0.1f, 0.82f);
Vertex[] v4 = l2.Sections(0.1f, 0.82f);
Quad q1 = new Quad(rules, section.Attributes.Copy(), (0, 0), (section.v1, section.v4, v2[0], v1[1]));
Quad q2 = new Quad(rules, section.Attributes.Copy(), (0, 2), (v1[0], v2[1], section.v3, section.v2));
Quad q3 = new Quad(rules, section.Attributes.Copy(), (0, 3), (v2[0], v4[0], v3[0], v2[1]));
Quad q4 = new Quad(rules, section.Attributes.Copy(), (0, 4), (v1[1], v4[1], v3[1], v1[0]));
Attributes a = section.Attributes.Copy();
a.Set("R", new ScalarAttribute(255f));
a.Set("G", new ScalarAttribute(255f));
a.Set("B", new ScalarAttribute(255f));
Window w = new Window(rules, a, (1, 0), (v4[0], v4[1], v3[1], v3[0]));
return(new List <IShape> {
q1, q2, q3, q4, w
});
}
);
rules.AddRule(
new Attributes(
("Corn", new ScalarAttribute(0f)),
("Bar", new ScalarAttribute(0f)),
("Door", new ScalarAttribute(0f)),
("Sections", new ScalarAttribute(5f)),
("Stairs", new ScalarAttribute(0f))
),
(Section section) => {
Vertex[] v1 = section.l1.Sections(0.2f, 0.8f);
Vertex[] v2 = section.l3.Sections(0.2f, 0.8f);
Line l1 = new Line(v1[0], v2[1]);
Line l2 = new Line(v1[1], v2[0]);
Vertex[] v3 = l1.Sections(0.1f, 0.82f);
Vertex[] v4 = l2.Sections(0.1f, 0.82f);
Quad q1 = new Quad(rules, section.Attributes.Copy(), (0, 0), (section.v1, section.v4, v2[0], v1[1]));
Quad q2 = new Quad(rules, section.Attributes.Copy(), (0, 2), (v1[0], v2[1], section.v3, section.v2));
Quad q3 = new Quad(rules, section.Attributes.Copy(), (0, 3), (v2[0], v4[0], v3[0], v2[1]));
Quad q4 = new Quad(rules, section.Attributes.Copy(), (0, 4), (v1[1], v4[1], v3[1], v1[0]));
Window w = new Window(rules, section.Attributes.Copy(), (1, 0), (v4[0], v4[1], v3[1], v3[0]));
return(new List <IShape> {
q1, q2, q3, q4, w
});
}
);
rules.AddRule(
new Attributes(
("Stairs", new ScalarAttribute(1f))
),
(Section section) => {
Vertex[] v1 = section.l1.Sections(0.15f, 0.85f);
Vertex[] v2 = section.l3.Sections(0.15f, 0.85f);
Quad q1 = new Quad(rules, section.Attributes.Copy(), (0, 0), (section.v1, section.v4, v2[0], v1[1]));
Quad q2 = new Quad(rules, section.Attributes.Copy(), (0, 2), (v1[0], v2[1], section.v3, section.v2));
Window w = new Window(rules, section.Attributes.Copy(), (1, 0), (v2[0], v1[1], v1[0], v2[1]));
return(new List <IShape> {
q1, q2, w
});
}
);
rules.AddRule(
new Attributes(
("Door", new RangeAttribute(1f, 2f))
),
(Section section) => {
Vertex[] v1 = section.l2.Sections(0.20f, 0.25f);
Vertex[] v2 = section.l4.Sections(0.75f, 0.8f);
Line l = new Line(v1[1], v2[0]);
Vertex[] v3 = l.Sections(0.07f, 0.93f);
Vertex[] v4 = section.l1.Sections(0.07f, 0.93f);
// Upper area
Door door = new Door(rules, section.Attributes.Copy(), (1, 0), (v4[1], v4[0], v3[1], v3[0]));
Quad mid = new Quad(rules, section.Attributes.Copy(), (2, 0), (v2[0], v1[1], v1[0], v2[1]));
Quad upper = new Quad(rules, section.Attributes.Copy(), (3, 0), (v2[1], v1[0], section.v3, section.v4));
// Sides
Quad side1 = new Quad(rules, section.Attributes.Copy(), (0, 1), (section.v1, v2[0], v3[0], v4[1]));
Quad side2 = new Quad(rules, section.Attributes.Copy(), (1, 1), (section.v2, v4[0], v3[1], v1[1]));
return(new List <IShape> {
door, mid, upper, side1, side2
});
}
);
rules.AddRule(
new Attributes(
),
(Window window) => {
Vertex[] v1 = window.l1.Sections(0.05f, 0.95f);
Vertex[] v2 = window.l3.Sections(0.05f, 0.95f);
Line l1 = new Line(v1[0], v2[1]);
Line l2 = new Line(v1[1], v2[0]);
Vertex[] v3 = l1.Sections(0.1f, 0.9f);
Vertex[] v4 = l2.Sections(0.1f, 0.9f);
Quad q1 = new Quad(rules, window.Attributes.Copy(), (0, 0), (window.v1, window.v4, v2[0], v1[1]));
Quad q2 = new Quad(rules, window.Attributes.Copy(), (0, 2), (v1[0], v2[1], window.v3, window.v2));
Quad q3 = new Quad(rules, window.Attributes.Copy(), (0, 3), (v2[0], v4[0], v3[0], v2[1]));
Quad q4 = new Quad(rules, window.Attributes.Copy(), (0, 4), (v1[1], v4[1], v3[1], v1[0]));
Glass g = new Glass(rules, window.Attributes.Copy(), (1, 0), (v4[0], v4[1], v3[1], v3[0]));
return(new List <IShape> {
q1, q2, q3, q4, g
});
}
private void AddRule(Rule <T> rule)
{
rule.Engine = this;
Rules.AddRule(rule);
}
public static (List <List <IShape> >, List <(IShape, List <IShape>)>) Run(int min, int max, uint times)
{
Rules rules = new Rules();
rules.AddRule(
new Attributes(
("Wave", new ScalarAttribute(0f))
),
(Quad quad) => {
Vertex b1 = quad.l1.Bisect();
Vertex b2 = quad.l2.Bisect();
Vertex b3 = quad.l3.Bisect();
Vertex b4 = quad.l4.Bisect();
Vertex c = (b1 + b2 + b3 + b4) / 4f;
Quad q4 = new Quad(rules, quad.Attributes.Copy(), (0, 0), (b4, c, b3, quad.v4));
Quad q1 = new Quad(rules, quad.Attributes.Copy(), (1, 0), (quad.v1, b1, c, b4));
Quad q3 = new Quad(rules, quad.Attributes.Copy(), (0, 1), (c, b2, quad.v3, b3));
Quad q2 = new Quad(rules, quad.Attributes.Copy(), (1, 1), (b1, quad.v2, b2, c));
return(new List <IShape> {
q1, q2, q3, q4
});
});
rules.AddRule(
new Attributes(
("Wave", new ScalarAttribute(1f))
),
(Quad quad) => {
Vertex th = quad.l1.Bisect();
Triad t1 = new Triad(rules, quad.Attributes.Copy(), (quad.v1, th, quad.v4));
Triad t2 = new Triad(rules, quad.Attributes.Copy(), (quad.v4, th, quad.v3));
Triad t3 = new Triad(rules, quad.Attributes.Copy(), (th, quad.v2, quad.v3));
return(new List <IShape> {
t1, t2, t3
});
}
);
rules.AddRule(
new Attributes(
("Wave", new ScalarAttribute(2f))
),
(Quad quad) => {
Vertex[] v1 = quad.l1.Sections(2);
Vertex[] v2 = quad.l3.Sections(2);
Attributes na = quad.Attributes.Copy();
na.Set("Wave", new ScalarAttribute(3f));
Quad q1 = new Quad(rules, na.Copy(), (quad.v1, v1[1], v2[0], quad.v4));
Quad q2 = new Quad(rules, na.Copy(), (v1[1], v1[0], v2[1], v2[0]));
Quad q3 = new Quad(rules, na.Copy(), (v1[0], quad.v2, quad.v3, v2[1]));
return(new List <IShape> {
q1, q2, q3
});
}
);
rules.AddRule(
new Attributes(
("Wave", new ScalarAttribute(3f))
),
(Quad quad) => {
return(new List <IShape>());
}
);
rules.AddRule(
new Attributes(
("Wave", new ScalarAttribute(4f))
),
(Quad quad) => {
Vertex[] v1 = quad.l1.Sections(2);
Vertex[] v2 = quad.l2.Sections(2);
Vertex[] v3 = quad.l3.Sections(2);
Vertex[] v4 = quad.l4.Sections(2);
Vertex c1 = v1[1] * 0.75f + v2[0] * 0.25f;
Vertex c2 = v1[1] * 0.25f + v2[0] * 0.75f;
Vertex c3 = v3[1] * 0.75f + v4[0] * 0.25f;
Vertex c4 = v3[1] * 0.25f + v4[0] * 0.75f;
Attributes qa = quad.Attributes.Copy();
qa.Set("Wave", new ScalarAttribute(3f));
// Quads
// Quad q1 = new Quad(rules, qa.Copy(), (v1[0], c1, c4, v4[1]));
// Quad q2 = new Quad(rules, qa.Copy(), (c1, v1[1], v2[0], c2));
// Quad q3 = new Quad(rules, qa.Copy(), (v3[0], c3, c2, v2[1]));
// Quad q4 = new Quad(rules, qa.Copy(), (v4[0], c4, c3, v3[1]));
// Quad q5 = new Quad(rules, qa.Copy(), (c1, c2, c3, c4));
// Triangles
Triad t1 = new Triad(rules, qa.Copy(), (quad.v1, v1[1], v4[0]));
Triad t2 = new Triad(rules, qa.Copy(), (v1[1], v1[0], c1));
Triad t3 = new Triad(rules, qa.Copy(), (v1[0], quad.v2, v2[1]));
Triad t4 = new Triad(rules, qa.Copy(), (c2, v2[1], v2[0]));
Triad t5 = new Triad(rules, qa.Copy(), (v3[1], v2[0], quad.v3));
Triad t6 = new Triad(rules, qa.Copy(), (v3[0], c3, v3[1]));
Triad t7 = new Triad(rules, qa.Copy(), (quad.v4, v4[1], v3[0]));
Triad t8 = new Triad(rules, qa.Copy(), (v4[1], v4[0], c4));
// return new List<IShape> {q1, q2, q3, q4, t1, t2, t3, t4, t5, t6, t7, t8};
return(new List <IShape> {
t1, t2, t3, t4, t5, t6, t7, t8
});
}
);
rules.AddRule(null, (Triad triad) => {
return(new List <IShape>());
});
Quad start = new Quad(
rules,
new Attributes(
("Wave", new ScalarAttribute(0f))
),
(new Vertex(min, max),
new Vertex(max, max),
new Vertex(max, min),
new Vertex(min, min))
);
// Define the control grammar
Control control = new Control();
// Add a simple control grammar that evokes WFC1
control.Grammar.AddRule("S", ((0, 0), "WFC1"));
// Add a WFC
control.AddWFC("WFC1");
control.WFC["WFC1"].AddRule("A", ("Wave", 0f, "S"), 1f, "B", "C");
control.WFC["WFC1"].AddRule("B", ("Wave", 1f, ""), 1f, "A", "C", "D");
control.WFC["WFC1"].AddRule("C", ("Wave", 2f, ""), 1f, "A", "B", "D");
control.WFC["WFC1"].AddRule("D", ("Wave", 4f, ""), 1f, "B", "C");
start.Control.Add("S");
// List<IShape> shapes = Interpreter.Interpret(start, 10);
List <List <IShape> > shapes = Interpreter2.Interpret(start, rules, control, times);
return(shapes, rules.RuleExamples(100f));
}
public static void Main(string[] args)
{
// build up a very simple vowel inventory
// make sure features are within simple set in Inventory's place/manner/voicing
Inventory inventory = new Inventory();
inventory.AddConsonant("b", "voiced", "bilabial", "plosive");
inventory.AddConsonant("p", "voiceless", "bilabial", "plosive");
inventory.AddConsonant("g", "voiced", "velar", "plosive");
inventory.AddConsonant("k", "voiceless", "velar", "plosive");
inventory.AddConsonant("d", "voiced", "dental", "plosive");
inventory.AddConsonant("t", "voiceless", "dental", "plosive");
inventory.AddConsonant("h", "voiceless", "glottal", "fricative");
inventory.AddConsonant("l", "voiced", "alveolar", "lateral");
inventory.AddConsonant("r", "voiced", "alveolar", "approximant");
inventory.AddConsonant("w", "voiced", "velar", "approximant");
// build up very simple consonant inventory
// make sure features are within simple set in Inventory's height/backness/rounding
inventory.AddVowel("i", "close", "front", "unrounded");
inventory.AddVowel("a", "open", "central", "unrounded");
inventory.AddVowel("u", "close", "back", "rounded");
// recall features using any letter
Debug.Log(inventory.GetFeatures("b"));
// This finds "b":
List <string> testFeaturesList = new List <string> {
"voiced", "bilabial", "plosive"
};
inventory.GetLetter(testFeaturesList);
// This will not find "b":
testFeaturesList [0] = "bilabial";
testFeaturesList [1] = "voiced";
inventory.GetLetter(testFeaturesList);
Syllable syllableStructure = new Syllable();
syllableStructure.AddStructure(new List <string> {
"C", "V"
});
syllableStructure.AddStructure(new List <string> {
"C", "V", "V"
});
syllableStructure.AddStructure(new List <string> {
"C", "V", "C"
});
syllableStructure.AddStructure(new List <string> {
"C", "V", "V", "C"
});
Rules rules = new Rules();
rules.AddRule("voiced", "voiceless", "_ voiceless");
Affixes affixes = new Affixes();
// add prefixes and suffixes
// trusts you to use only characters found in inventory (matters for rule application)
affixes.AddAffix("human", "-", "g", "u", "d");
affixes.AddAffix("nonhuman", "-", "i", "d");
affixes.AddAffix("strong", "t", "-");
affixes.AddAffix("small", "l", "-");
affixes.AddAffix("strange", "g", "-");
// TODO structure language
Language language = new Language(inventory, syllableStructure, rules, affixes);
// build a long proper noun
List <string> properNoun = language.BuildWord(3, true, "strong", "nonhuman");
Debug.Log(string.Join("", properNoun.ToArray()));
// build a short regular noun
List <string> justSomeNoun = language.BuildWord(2);
// add both to the dictionary
language.AddEntry(properNoun, "Wolf");
language.AddEntry(justSomeNoun, "food");
Debug.Log(language.PrintDictionary());
}
public static (List <List <IShape> >, List <(IShape, List <IShape>)>) Run(int min, int max, uint times)
{
Rules rules = new Rules();
rules.AddRule(
new Attributes(
("Diamond", new ScalarAttribute(1f))
),
(Quad quad) => {
Vertex nv1 = quad.l1.Bisect(0.5f);
Vertex nv2 = quad.l2.Bisect(0.5f);
Vertex nv3 = quad.l3.Bisect(0.5f);
Vertex nv4 = quad.l4.Bisect(0.5f);
// A quad with the vertices as bipartitions of original's edges
Attributes attrs = new Attributes(quad.Attributes);
if (quad.Attributes.Get("Angle").Start == 1f)
{
attrs.Set("Angle", new ScalarAttribute(0f));
}
else
{
attrs.Set("Angle", new ScalarAttribute(1f));
}
Quad q = new Quad(
rules,
attrs,
(1, 0),
(nv1, nv2, nv3, nv4)
);
// Triangles
Triad t1 = new Triad(rules, quad.Attributes.Copy(), (0, 0), (nv1, quad.v2, nv2));
Triad t2 = new Triad(rules, quad.Attributes.Copy(), (0, 1), (nv2, quad.v3, nv3));
Triad t3 = new Triad(rules, quad.Attributes.Copy(), (0, 2), (nv3, quad.v4, nv4));
Triad t4 = new Triad(rules, quad.Attributes.Copy(), (0, 3), (nv4, quad.v1, nv1));
return(new List <IShape> {
q, t1, t2, t3, t4
});
}
);
rules.AddRule(
new Attributes(
("Angle", new ScalarAttribute(0f))
),
(Quad quad) => {
Vertex[] nv1 = quad.l1.Sections(3);
Vertex[] nv2 = quad.l3.Sections(3);
Quad q1 = new Quad(rules, quad.Attributes.Copy(), (0, 0), (quad.v1, nv1[2], nv2[0], quad.v4));
Quad q2 = new Quad(rules, quad.Attributes.Copy(), (1, 0), (nv1[2], nv1[1], nv2[1], nv2[0]));
Quad q3 = new Quad(rules, quad.Attributes.Copy(), (2, 0), (nv1[1], nv1[0], nv2[2], nv2[1]));
Quad q4 = new Quad(rules, quad.Attributes.Copy(), (3, 0), (nv1[0], quad.v2, quad.v3, nv2[2]));
return(new List <IShape> {
q1, q2, q3, q4
});
}
);
rules.AddRule(
new Attributes(
("Angle", new ScalarAttribute(1f))
),
(Quad quad) => {
Vertex nv1 = quad.l1.Bisect(0.5f);
Vertex nv2 = quad.l3.Bisect(0.5f);
Quad q1 = new Quad(rules, quad.Attributes.Copy(), (0, 0), (quad.v1, nv1, nv2, quad.v4));
Quad q2 = new Quad(rules, quad.Attributes.Copy(), (1, 0), (nv1, quad.v2, quad.v3, nv2));
return(new List <IShape> {
q1, q2
});
}
);
rules.AddRule(null, (Triad triad) => {
return(new List <IShape> {
new Epsilon()
});
});
rules.AddRule(null, (Triad triad) => {
return(new List <IShape>());
});
Quad start = new Quad(
rules,
new Attributes(
("Angle", new ScalarAttribute(0f)),
("Diamond", new ScalarAttribute(0f))
),
(new Vertex(min, max),
new Vertex(max, max),
new Vertex(max, min),
new Vertex(min, min))
);
start.Control.Add("A");
// Define the control grammar
Control control = new Control();
control.Grammar.AddRule("A", new string[] { "N", "Y", "Y" });
control.Grammar.AddRule("N", ((~0u, 0), "Diamond", 0f, ""));
control.Grammar.AddRule("Y", ((1, 0), "Diamond", 1f, "A"));
control.Grammar.AddRule("Y", ((2, 0), "Diamond", 1f, "A"));
// List<IShape> shapes = Interpreter.Interpret(start, 10);
List <List <IShape> > shapes = Interpreter2.Interpret(start, rules, control, times);
return(shapes, null);
}
