level 3 basics

src/generator.h

@@ -144,13 +144,21 @@ struct AcceleronGenerator: public Generator
     MultiPathCarver m_checkerboard_carver;
 };
 
-struct gen3: public Generator
+struct RadionGenerator: public Generator
 {
-    gen3();
+    RadionGenerator();
     void generate(struct level *) override;
-    ~gen3() override = default;
+    ~RadionGenerator() override = default;
 
-    path_carver m_path_carvers[3];
+    num generate_blue_spiral(struct level *level, num z);
+    num generate_ascending_grid(struct level *level, num z);
+
+    void change_phase(void);
+
+    num m_z;
+    bool m_initial;
+    int m_phase;
+    MultiPathCarver m_multi_carver;
 };
 
 #endif /* GENERATOR_H */

src/generator/gen3.cpp

@@ -2,19 +2,166 @@
 #include "../level.h"
 #include <stdlib.h>
 
-#define N PLATFORM_COUNT
+/* Geometric parameters */
+#define G_PLATFORM_LEN           num(1.5)
+#define G_PLATFORM_SPC           num(0.5)
+#define G_PLATFORM_LEN_INITIAL   num(6.0)
 
-gen3::gen3(): m_path_carvers{{0}, {N/3}, {2*N/3}}
+RadionGenerator::RadionGenerator():
+    m_multi_carver{3}
 {
     srand(123456);
+    m_initial = true;
+    m_z = 0.0;
+    m_phase = 0;
+
+    int faces[3] = { 0, 4, 8 };
+    m_multi_carver.set_faces(faces);
+    m_multi_carver.set_noskip(false);
+    m_multi_carver.set_checkerboard(false);
 }
 
-void gen3::generate(struct level *level)
+/* Generate a blue/white spiral going full circle.
+
+   0123456789
+   .........B
+   ........B|
+   .......B|.
+   ......B|.#
+   .....B|.#|
+   ....B|.#|.
+   ...B|.#|..
+   ..B|.#|...
+   .B|.#|....
+   B|.#|.....
+   |.#|.....#
+   .#|......|
+   #|........
+   |......... */
+num RadionGenerator::generate_blue_spiral(struct level *level, num z)
 {
-    struct platform p;
-    for(int i = 0; i < 3; i++) {
-        if(m_path_carvers[i].next(3.0, &p)) {
-            level->platform_buffer.push_back(p);
+    for(int i = 0; i < 14; i++) {
+        if(i < 10) {
+            struct platform p;
+            p.type = PLATFORM_BLUE;
+            p.face = PLATFORM_COUNT - 1 - i;
+            p.z = z;
+            p.length = 2 * G_PLATFORM_LEN;
+            p.height = 0.0;
+            add(level, p);
         }
+        if(i >= 3 && i <= 12) {
+            struct platform p;
+            p.type = PLATFORM_WHITE;
+            p.face = PLATFORM_COUNT - 1 - (i - 3);
+            p.z = z;
+            p.length = 2 * G_PLATFORM_LEN;
+            p.height = 0.0;
+            add(level, p);
+        }
+        if(i == 10) {
+            struct platform p;
+            p.type = PLATFORM_WHITE;
+            p.face = PLATFORM_COUNT - 1;
+            p.z = z;
+            p.length = 2 * G_PLATFORM_LEN;
+            p.height = 0.0;
+            add(level, p);
+        }
+
+        z += G_PLATFORM_LEN + G_PLATFORM_SPC;
+    }
+
+    return z;
+}
+
+/* Generate an ascending grid leading up to step #4.
+
+   0123456789
+   #.#.#.#.#. [h=0]
+   .#.#.#.#.# [h=1]
+   #.#.#.#.#. [h=2]
+   .#.#.#.#.# [h=3]
+   #.#.#.#.#. [h=4]
+   .#.#.#.#.# [h=4]
+   #.#.#.#.#. [h=4]
+   BBBBBBBBBB [h=4]
+   |||||||||| [h=4]
+   .#.#.#.#.# [h=4]
+   #.#.#.#.#. [h=1] */
+num RadionGenerator::generate_ascending_grid(struct level *level, num z)
+{
+    for(int i = 0; i < 11; i++) {
+        int height = (i <= 4) ? i : (i == 10) ? 1 : 4;
+
+        for(int j = 0; j < 10; j++) {
+            if((i != 7) && ((i & 1) != (j & 1)))
+                continue;
+
+            struct platform p;
+            p.type = (i == 7) ? PLATFORM_BLUE : PLATFORM_WHITE;
+            p.face = j;
+            p.z = z;
+            p.length = (i == 7 ? 4 : 2) * G_PLATFORM_LEN;
+            p.height = height * PLATFORM_HEIGHT_STEP;
+            add(level, p);
+        }
+
+        z += 2 * G_PLATFORM_LEN;
+    }
+
+    return z;
+}
+
+void RadionGenerator::change_phase(void)
+{
+    static int const freq_table[] = {
+        0,
+        1,
+    };
+    int const FREQ_TABLE_SIZE = sizeof freq_table / sizeof freq_table[0];
+
+    int p = m_phase;
+
+    while(1) {
+        p = freq_table[rand() % FREQ_TABLE_SIZE];
+
+        /* Do not repeat the same phase twice in a row */
+        if(p == m_phase)
+            continue;
+
+        break;
+    }
+
+    m_phase = p;
+}
+
+void RadionGenerator::generate(struct level *level)
+{
+/*    m_multi_carver.next(level, m_z, G_PLATFORM_LEN);
+    m_z += G_PLATFORM_LEN;
+*/
+    /* Friendly platform at start of level */
+    if(m_initial) {
+        struct platform p;
+        p.type = PLATFORM_WHITE;
+        p.face = 0;
+        p.z = m_z;
+        p.length = G_PLATFORM_LEN_INITIAL;
+        p.height = 0.0;
+
+        add(level, p);
+        m_z += p.length;
+        m_initial = false;
+        m_phase = 0;
+    }
+
+    if(m_phase == 0) {
+        m_z = this->generate_blue_spiral(level, m_z);
+        this->change_phase();
+    }
+    else if(m_phase == 1) {
+        m_z = this->generate_ascending_grid(level, m_z);
+        this->change_phase();
     }
 }

src/level.cpp

@@ -21,8 +21,8 @@ struct level level_create(int level)
             break;
         case 3:
             l.name = "radion";
-            l.gen = std::make_unique<struct gen3>();
-            l.bgcolor = C_WHITE;
+            l.gen = std::make_unique<RadionGenerator>();
+            l.bgcolor = RGB24(0xe17c6a);
             break;
     }
     return l;