hyperrogue/rogueviz/nilrider/levels.cpp

namespace nilrider {

bool all(checkerparam c) { return c.t->collected_triangles == Flag(isize(c.l->triangles))-1; }

goalchecker basic_check(ld time_limit, ld rev_limit) {
  return [=] (checkerparam c) {
    if(c.t->timer > time_limit || c.rev > rev_limit) return grFailed;
    if(all(c)) return grSuccess;
    return grNone;
    };
  }

goalchecker get_any(ld time_limit, ld rev_limit) {
  return [=] (checkerparam c) {
    if(c.t->timer > time_limit || c.rev > rev_limit) return grFailed;
    if(c.t->collected_triangles) return grSuccess;
    return grNone;
    };
  }

goalchecker get_ordered(ld time_limit, ld rev_limit) {
  return [=] (checkerparam c) {
    if(c.t->timer > time_limit || c.rev > rev_limit) return grFailed;
    if(c.t->collected_triangles & (c.t->collected_triangles+1)) return grFailed;
    if(all(c)) return grSuccess;
    return grNone;
    };
  }

goalchecker yplus_check(ld time_limit, ld rev_limit) {
  return [=] (checkerparam c) {
    if(c.t->timer > time_limit || c.rev > rev_limit) return grFailed;
    if(c.t->where[1] < 0) return grFailed;
    if(all(c)) return grSuccess;
    return grNone;
    };
  }

goalchecker fullstop_check(ld time_limit, ld rev_limit) {
  return [=] (checkerparam c) {
    if(c.t->timer > time_limit || c.rev > rev_limit) return grFailed;
    if(all(c) && c.t->vel == 0) return grSuccess;
    return grNone;
    };
  }

ld f_heisenberg0(hyperpoint h) { return 0; }

ld rot_plane(hyperpoint h) {
  return h[0] * h[1] / 2;
  }

ld f_rot_well(hyperpoint h) {
  return h[0] * h[1] / 2 + h[0] * h[0] + h[1] * h[1];
  }

ld long_x(hyperpoint h) {
  return h[0] * h[1];
  }

ld geodesics_0(hyperpoint h) {
  ld r = hypot_d(2, h);
  ld phi = atan2(h[1], h[0]);
  
  ld z = (phi / TAU) * (M_PI * r * r + TAU);
  return z + rot_plane(h);
  }

ld geodesics_at_4(hyperpoint h) {
  ld r = 4;
  ld phi = atan2(h[1], h[0]);
  
  ld z = (phi / TAU) * (M_PI * r * r + TAU);
  return z + rot_plane(h);
  }

map<char, color_t> bcols = {
  {' ', 0xFF101010},
  {'W', 0xFFFFFFFF},
  {'g', 0xFF008000},
  {'h', 0xFF20A020},
  {'r', 0xFFFF4040},
  {'u', 0xFF4040FF},
  {'b', 0xFF804000},
  {'l', 0xFF0000C0},
  {'f', 0xFF603000},
  {'F', 0xFF804000},
  {'2', 0xFF404040},
  {'4', 0xFF808080},
  {'6', 0xFFC0C0C0},
  {'!', 0xFF000000}
  };

const int pixel_per_block = 16;

map<char, array<string, pixel_per_block> > submaps = {
  {'o', {
    "WWWWWWWWWWWWWWWW",
    "W22222222222222W",
    "W22222666622222W",
    "W22266222266222W",
    "W22622222222622W",
    "W22622222222622W",
    "W26222222222262W",
    "W262222WW222262W",
    "W262222WW222262W",
    "W26222222222262W",
    "W22622222222622W",
    "W22622222222622W",
    "W22266222266222W",
    "W22222666622222W",
    "W22222222222222W",
    "WWWWWWWWWWWWWWWW"
    }},
  {'x', {
    "WWWWWWWWWWWWWWWW",
    "W22222222222222W",
    "W22222222222222W",
    "W22222222222222W",
    "W22222222222222W",
    "W22222222222222W",
    "W22222622622222W",
    "W222222rW222222W",
    "W222222Wr222222W",
    "W22222622622222W",
    "W22222222222222W",
    "W22222222222222W",
    "W22222222222222W",
    "W22222222222222W",
    "W22222222222222W",
    "WWWWWWWWWWWWWWWW"
    }},
  {'b', {
    "                ",
    " rrr rrr rrr rrr",
    "                ",
    "rr rrr rrr rrr r",
    "                ",
    " rrr rrr rrr rrr",
    "                ",
    "rr rrr rrr rrr r",
    "                ",
    " rrr rrr rrr rrr",
    "                ",
    "rr rrr rrr rrr r",
    "                ",
    " rrr rrr rrr rrr",
    "                ",
    "rr rrr rrr rrr r",
    }},
  {'f', {
    "FfFfFfFfFfFfFfFf",
    "fFfFfFfFfFfFfFfF",
    "FfFfFfFfFfFfFfFf",
    "fFfFfFfFfFfFfFfF",
    "FfFfFfFfFfFfFfFf",
    "fFfFfFfFfFfFfFfF",
    "FfFfFfFfFfFfFfFf",
    "fFfFfFfFfFfFfFfF",
    "FfFfFfFfFfFfFfFf",
    "fFfFfFfFfFfFfFfF",
    "FfFfFfFfFfFfFfFf",
    "fFfFfFfFfFfFfFfF",
    "FfFfFfFfFfFfFfFf",
    "fFfFfFfFfFfFfFfF",
    "FfFfFfFfFfFfFfFf",
    "fFfFfFfFfFfFfFfF",
    }},
  {'l', {
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    "llllllllllllllll",
    }},
  {'g', {
    "ghghghghghghghgh",
    "hghghghghghghghg",
    "ghghghghghghghgh",
    "hghghghghghghghg",
    "ghghghghghghghgh",
    "hghghghghghghghg",
    "ghghghghghghghgh",
    "hghghghghghghghg",
    "ghghghghghghghgh",
    "hghghghghghghghg",
    "ghghghghghghghgh",
    "hghghghghghghghg",
    "ghghghghghghghgh",
    "hghghghghghghghg",
    "ghghghghghghghgh",
    "hghghghghghghghg",
    }},
  {'G', {
    "ghghghghghghghgh",
    "hghghghghghWhghg",
    "ghghrhghghWlWhgh",
    "hghrWrhghghWhghg",
    "ghghrhghghghghgh",
    "hghghghghghghghg",
    "ghghghghghghghgh",
    "hghghghlhghghghg",
    "ghghghlWlhghghgh",
    "hghghghlhghghghg",
    "ghghghghghghgrgh",
    "hghglghghghgrWrg",
    "ghglWlghghghgrgh",
    "hghglghghghghghg",
    "ghghghghghghghgh",
    "hghghghghghghghg",
    }},
  {'r', {
    "rrrrrrrrrrrrrrru",
    "ubbbbbbbbbbbbbbu",
    "ubbbbbbbbbbbbbbu",
    "ubbbbbbbbbbbbbbu",
    "ubbbbbbbbbbbbbbu",
    "ubbbbbbbbbbbbbbu",
    "ubbbbbbbbbbbbbbu",
    "ubbbbbbbbbbbbbbu",
    "ubbbbbbbbbbbbbbu",
    "ubbbbbbbbbbbbbbu",
    "ubbbbbbbbbbbbbbu",
    "ubbbbbbbbbbbbbbu",
    "ubbbbbbbbbbbbbbu",
    "ubbbbbbbbbbbbbbu",
    "ubbbbbbbbbbbbbbu",
    "urrrrrrrrrrrrrrr",
    }},
  {'*', {
    "WWWWWW WW WWWWWW",
    "W              W",
    "W              W",
    "W              W",
    "W              W",
    "W      rr       W",
    "       rr       ",
    "W     r  r     W",
    "W     r  r     W",
    "     r    r     ",
    "W    r    r    W",
    "W   rrrrrrrr   W",
    "W              W",
    "W              W",
    "W              W",
    "WWWWWW WW WWWWWW",
    }},
  {'+', {
    "gh     WW     gh",
    "hg     WW     hg",
    "       WW       ",
    "                ",
    "                ",
    "       WW       ",
    "       WW       ",
    "WWW  WWWWWW  WWW",
    "WWW  WWWWWW  WWW",
    "       WW       ",
    "       WW       ",
    "                ",
    "                ",
    "       WW       ",
    "gh     WW     gh",
    "hg     WW     hg",
    }},
  {'-', {
    "ghghghghghghghgh",
    "hghghghghghghghg",
    "                ",
    "                ",
    "                ",
    "                ",
    "                ",
    "WWW  WWWWWW  WWW",
    "WWW  WWWWWW  WWW",
    "                ",
    "                ",
    "                ",
    "                ",
    "                ",
    "ghghghghghghghgh",
    "hghghghghghghghg",
    }},
  {'|', {
    "gh     WW     gh",
    "hg     WW     hg",
    "gh     WW     gh",
    "hg            hg",
    "gh            gh",
    "hg     WW     hg",
    "gh     WW     gh",
    "hg     WW     hg",
    "gh     WW     gh",
    "hg     WW     hg",
    "gh     WW     gh",
    "hg            hg",
    "gh            gh",
    "hg     WW     hg",
    "gh     WW     gh",
    "hg     WW     hg",
    }},
  };

level rotplane(
  "Trying to be horizontal", 'r', 0,
  "Collect all the triangles!\n\n"
  "All the lines going through the center are horizontal.\n"
  "However, this is Nil geometry. The other lines are NOT horizontal! Clockwise ones slope upwards, and counterclockwise ones slop edownwards.\n"
  "Your unicycle is powered only by the gravity. Use that to your advantage!"
  ,

  -7.5*dft_block, 7.5*dft_block, 8.5*dft_block, -8.5*dft_block,
  {
  "ggggggggggggggg!",
  "ggggggfffgggggg!",
  "ggggggfffgggggg!",
  "gggg|ggggg|gggg!",
  "ggg-*-----*-ggg!",
  "gggg|ggggf|gggg!",
  "ggGg|g+ggg|grgG!",
  "gGgg|g|xgo|gggg!",
  "ggGg|g|ggg|grgg!",
  "gggg|g|ggg|gggg!",
  "gg--*-+---*--gg!",
  "gggg|ggggg|gggg!",
  "gggggggGGgggggg!",
  "ggggggggggggggg!",
  "ggggggggggggggg!",
  "!!!!!!!!!!!!!!!!"
  },
  6, 6,
  rot_plane,
  {
    // the solver[0.25] result is 36.92
    goal{0x40FF40, "Collect all the triangles in below 60 seconds", basic_check(60, 999)},
    goal{0xFFD500, "Collect all the triangles in below 38 seconds", basic_check(38, 999)}
    }
  );

level longtrack(
  "A Long Track", 'l', 0,
  "The main street is horizontal, as well as the lines orthogonal to it.",
  0*dft_block, +6.5*dft_block, 64*dft_block, -1.5*dft_block,
  {
  "Ggggggggr!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!",
  "Ggggggggr!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!",
  "Ggggggggr!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!x!",
  "Ggggxgggr!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!",
  "gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg",
  "ggggggggrggggggrggggggggrGggggggggGGggggGGGgggggGGGGggggggggggGG",
  "--------------------------------------------------------------*G",
  "gggggfffffggggggggggggggggggggggggggggggggggggggggggggggggggggGG"
  },
  0, 5,
  long_x,
  {
    // the solver[0.25] result is 1:08.56 (reduced to 1:08.45 by removing some points)
    goal{0xFFD500, "Collect the triangle in below 1:15", basic_check(75, 999)},
    // the solver[0.25] + some manual modifications achieves 1:37.44
    goal{0xFF4040, "Stop where the triangle is in below 1:45", fullstop_check(75, 999)},
    // the solver[0.25] result is 1:45.52
    goal{0x303030, "Reach the triangle without going on the right side of the road below 2:00", yplus_check(120, 999)},
    }
  );

level geodesical(
  "Roads are Geodesics", 'g', nrlPolar,
  "Geodesics are the lines that are (locally) shortest. In the default settings, "
  "the space in Nil Rider is rendered according to the Fermat's principle, that is, "
  "light rays are assumed to be geodesics.\n\n"
  "Geodesics in Nil are horizontal, vertical, and helical. "
  "In this level, all the roads are (fragments of) helical geodesics.",
  -45._deg, 3*dft_block, 225._deg, 0,
  // -8*dft_block, +8*dft_block, +8*dft_block, 0, 
  {
  "ffffffffffffffff",
  "----------------",
  "----------------",
  "*--------------*",
  "----------------",
  "----------------",
  "----------------",
  "bbbbbbbbbbbbbbbb",
  },
  0, 6,
  geodesics_0,
  {
    // the solver[0.25] result is 26.10
    goal{0xFFD500, "Collect both triangles in below 30 seconds", basic_check(30, 999)}
    }
  );

level geodesical4(
  "Helical Geodesic", 's', nrlPolar,
  "The main road here is a helical geodesic. Orthogonal lines are horizontal.",  
  -80._deg, 8.5*dft_block, 260._deg, 0.5*dft_block,
  // -8*dft_block, +8*dft_block, +8*dft_block, 0, 
  {
  "!!!!!!!!!!!!!!!!",
  "ffffffffffffffff",
  "gggggggggggggggg",
  "ggGggggggggGgggg",
  "+--------------*",
  "gggggGggggGggggg",
  "gggGgggggGgggggg",
  "ffffffffffffffff",
  },
  0, 5,
  geodesics_at_4,
  {
    // the solver[0.25] result is 32.04
    goal{0xFFD500, "Collect the triangle in below 35 seconds", basic_check(35, 999)}
    }
  );

level heisenberg0(
  "Heisenberg Zero", 'z', 0,
  "This is the plane z=0 in the Heisenberg group model of Nil. The roads are x=0, y=0 axes.",  
  -7.5*dft_block, 7.5*dft_block, 8.5*dft_block, -8.5*dft_block,
  {
  "ggggggg|ggggggg!",
  "grggggg|gggggrg!",
  "gg*gggg|gggg*gg!",
  "gggffgg|ggggggg!",
  "gggffgg|ggfrggg!",
  "ggggggg|gggggGg!",
  "ggggggg|ggggggg!",
  "-------+-------!",
  "ggggggg|ggggggg!",
  "gggGgog|ggggggg!",
  "ggggggg|ggrgrgg!",
  "gggGgGg|ggggggg!",
  "gg*gggg|gggg*gg!",
  "grggggg|gggggrg!",
  "ggggggg|ggggggg!",
  "!!!!!!!!!!!!!!!!"
  },
  8, 8,
  f_heisenberg0,
  {
    // the solver[0.25] result is 49:15
    goal{0x40FFd0, "Collect all triangles in below 0:55", basic_check(55, 999)}
    }
  );

level rotwell(
  "Deep Well", 'd', nrlOrder,
  "Can you escape this well?\n\n"
  "The sculpture in the center is built around eight helical geodesics which start in a point on the floor, and all cross in a point in the sky. Try to find that point and "
  "look below!\n\n"
  "Note: you can move the camera freely (using the arrow keys and PageUp/Down/Home/End) while the game is paused."
  ,
  -7.5*dft_block, 7.5*dft_block, 8.5*dft_block, -8.5*dft_block,
  {
  "ggggggggggggggg!",
  "gogggggggggggog!",
  "ggggg--*--ggggg!",
  "gggg*ggggg*gggg!",
  "ggg*ggGfGgg*ggg!",
  "gg|ggfgggfgg|gg!",
  "gg|gGgggggGg|gg!",
  "gg*gfggxggfg*gg!",
  "gg|gGgggggGg|gg!",
  "gg|ggfgggfgg|gg!",
  "ggg*ggGfGgg*ggg!",
  "gggg*ggggg*gggg!",
  "ggggg--*--ggggg!",
  "gogggggggggggog!",
  "ggggggggggggggg!",
  "!!!!!!!!!!!!!!!!"
  },
  8, 8,
  f_rot_well,
  {
    // the solver[0.5] result is 1:19.54 (obtained using get_ordered)
    goal{0xFFD500, "Collect all triangles below 1:25", basic_check(85, 999)}
    }
  );

level labyrinth(
  "Labyrinth", 'l', 0,
  "You will have to go clockwise this time!\n\n"
  "The squares of this level have half of their usual length.",
  -7.5*dft_block/2, 7.5*dft_block/2, 8.5*dft_block/2, -8.5*dft_block/2,
  {
  "ogggrfffffffffo!",
  "g*ggrgggggggggg!",
  "ggggrgggggggggg!",
  "ggggrgggggggggg!",
  "ggggrgggrrggggg!",
  "ggggrgGGGrrgggg!",
  "ggggrGgggGrgggg!",
  "ggggrGgxgGrgggg!",
  "ggggrGgggGrgggg!",
  "ggggrrGGGrrgggg!",
  "gggggrrrrrggggg!",
  "ggggggggggggggg!",
  "ggggggggggggggg!",
  "ggggggggggggggg!",
  "offfffffffffffo!",
  "!!!!!!!!!!!!!!!!"
  },
  8, 8,
  rot_plane,
  {
    // the solver[0.1] result is 1:03.53
    // the solver[0.15] result is 1:06.58
    // the solver[0.24] result is 1:08.54
    // the solver[0.25] result is 1:22.09 (it goes north for some reason)
    goal{0xFFD500, "Collect the triangle in below 1:15", basic_check(75, 999)}
    }
  );

level obstacle(
  "Obstacle Course", 'o', 0,
  "The main street is horizontal, as well as the lines orthogonal to it.",
  0*dft_block, 2.5*dft_block, 64*dft_block, -5.5*dft_block,
  {
  "ggggggGrggGrgggggggggggggggggggggGrxgggggggggGrggggggggGrggggggo",
  "ggggggGrggGrgggGrgggggGrgggggggggGrgggggggggggggGrgggggGrggggggo",
  "-----------r----r------r----r-----r--r---------r---------------*",
  "ggggggGrgggggggGrgggggGrggggggggggggGrggggggGrgggggggggGrggggggo",
  "ggggggGrgggggggGrgggggggggggggggggggGrgggggggggGrggggggGrggggggo",
  "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!",
  "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!",
  "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!",
  },
  0, 4,
  long_x,
  {
    goal{0xFFFFC0, "Collect the triangle in below 1:25, reversing time at most 3 times", basic_check(85, 3)},
    goal{0xFFD500, "Collect the triangle in below 1:10, reversing time at most 3 times", basic_check(70, 3)},
    }
  );

level *curlev = &rotplane;

struct complex_surface {
  hyperpoint cur;
  map<pair<int, int>, surface_fun> blocks;

  static transmatrix flatpush(hyperpoint h) { return rgpushxto0(point31(h[0], h[1], rot_plane(h))); }
  static transmatrix hpush(hyperpoint h) { h[1] = 0; h[2] = 0; return flatpush(h); }
  static transmatrix vpush(hyperpoint h) { h[0] = 0; h[2] = 0; return flatpush(h); }

  static hyperpoint spin_around(hyperpoint h, hyperpoint start, hyperpoint ctr, ld dir) {
    auto h1 = h - ctr;

    auto d = hypot_d(2, h1);
    ld r = 2;
    h1 = h1 * (r / d);
    ld phi = atan2(h1[1], h1[0]) + 90._deg;
    ld phis = atan2((start-ctr)[1], (start-ctr)[0]) + 90._deg;
    cyclefix(phi, phis);
    h1 += ctr;
    auto z = [&] (ld a) { return point31(r*sin(a), -r*cos(a), (r * r / 2) * (a-sin(a)*cos(a))); };

    if(0) {
      // not smooth enough ....
      transmatrix q = gpushxto0(z(phis)) * rgpushxto0(z(phi));
      hyperpoint arc = rgpushxto0(start) * q * flatpush(h-h1) * C0;
      return arc;
      }

    hyperpoint h2 = h; if(start[0] == ctr[0]) h2[1] = start[1]; else h2[0] = start[0];
    hyperpoint pre = rgpushxto0(start) * flatpush(h2-start) * flatpush(h-h2) * C0;

    hyperpoint last = rgpushxto0(start) * gpushxto0(z(phis)) * rgpushxto0(z(phis + dir * 90._deg)) * C0;
    hyperpoint h3 = h; if(start[0] != ctr[0]) h3[1] = last[1]; else h3[0] = last[0];
    hyperpoint post = rgpushxto0(last) * flatpush(h3-last) * flatpush(h-h3) * C0;

    ld p = (1+sin((phi-phis)*2 - 90._deg)) / 2.;

    pre[2] = pre[2] + (post[2] - pre[2]) * p;

    // println(hlog, "START = ", start, " LAST = ", last, " h = ", h, " h2 = ", h2, " h3 = ", h3, " p = ", p, " pre = ", pre);
    // exit(1);

    return pre;
    // flatpush(h1 - start) * flatpush(h - h1) * C0;
    }

  static hyperpoint rel(int x, int y) { return point30(x, y, 0); };

  surface_fun& at(hyperpoint h) {
    int ax = int(floor(h[0] / 4));
    int ay = int(floor(h[1] / 4));
    return blocks[{ax, ay}];
    };

  void right_block() {
    auto c = cur;
    println(hlog, "RIGHT at ", c);
    auto f = [c] (hyperpoint h) { return rgpushxto0(c) * hpush(h-c) * vpush(h-c) * C0; };
    at(c+rel(2, 0)) = [f] (hyperpoint h) { return f(h)[2]; };
    cur = f(c+rel(4, 0));
    }

  void left_block() {
    auto c = cur;
    println(hlog, "LEFT at ", c);
    auto f = [c] (hyperpoint h) { return rgpushxto0(c) * hpush(h-c) * vpush(h-c) * C0; };
    at(c+rel(-2, 0)) = [f] (hyperpoint h) { return f(h)[2]; };
    cur = f(c+rel(-4, 0));
    }

  void up_block() {
    auto c = cur;
    println(hlog, "UP at ", c);
    auto f = [c] (hyperpoint h) { return rgpushxto0(c) * vpush(h-c) * hpush(h-c) * C0; };
    at(c+rel(0, 2)) = [f] (hyperpoint h) { return f(h)[2]; };
    cur = f(c+rel(0, 4));
    }

  void down_block() {
    auto c = cur;
    println(hlog, "DOWN at ", c);
    auto f = [c] (hyperpoint h) { return rgpushxto0(c) * vpush(h-c) * hpush(h-c) * C0; };
    at(c+rel(0, -2)) = [f] (hyperpoint h) { return f(h)[2]; };
    cur = f(c+rel(0, -4));
    }

  /* counterclockwise */
  void turn_up_block() {
    auto c = cur;
    println(hlog, "TURN UP at ", c);
    auto f = [c] (hyperpoint h) { return (spin_around(h, c, c+rel(0, 2), 1)); };
    at(c+rel(2, 0)) = [f] (hyperpoint h) { return f(h)[2]; };
    cur = f(c+rel(2, 2));
    };
  void turn_left_block() {
    auto c = cur;
    auto f = [c] (hyperpoint h) { return (spin_around(h, c, c+rel(-2, 0), 1)); };
    at(c+rel(0, 2)) = [f] (hyperpoint h) { return f(h)[2]; };
    cur = f(c+rel(-2, 2));
    };
  void turn_down_block () {
    auto c = cur;
    auto f = [c] (hyperpoint h) { return (spin_around(h, c, c+rel(0, -2), 1)); };
    at(c+rel(-2, 0)) = [f] (hyperpoint h) { return f(h)[2]; };
    cur = f(c+rel(-2, -2));
    };
  void turn_right_block() {
    auto c = cur;
    auto f = [c] (hyperpoint h) { return (spin_around(h, c, c+rel(2, 0), 1)); };
    at(c+rel(0, -2)) = [f] (hyperpoint h) { return f(h)[2]; };
    cur = f(c+rel(2, -2));
    };

  /* clockwise */
  void turn_up_block2() {
    auto c = cur;
    println(hlog, "TURN UP at ", c);
    auto f = [c] (hyperpoint h) { return (spin_around(h, c, c+rel(0, 2), -1)); };
    at(c+rel(-2, 0)) = [f] (hyperpoint h) { return f(h)[2]; };
    cur = f(c+rel(-2, 2));
    };
  void turn_left_block2() {
    auto c = cur;
    auto f = [c] (hyperpoint h) { return (spin_around(h, c, c+rel(-2, 0), -1)); };
    at(c+rel(0, -2)) = [f] (hyperpoint h) { return f(h)[2]; };
    cur = f(c+rel(-2, -2));
    };
  void turn_down_block2() {
    auto c = cur;
    auto f = [c] (hyperpoint h) { return (spin_around(h, c, c+rel(0, -2), -1)); };
    at(c+rel(2, 0)) = [f] (hyperpoint h) { return f(h)[2]; };
    cur = f(c+rel(2, -2));
    };
  void turn_right_block2() {
    auto c = cur;
    auto f = [c] (hyperpoint h) { return (spin_around(h, c, c+rel(2, 0), -1)); };
    at(c+rel(0, 2)) = [f] (hyperpoint h) { return f(h)[2]; };
    cur = f(c+rel(2, 2));
    };

  ld get(hyperpoint h) {
    int ax = int(floor(h[0] / 4));
    int ay = int(floor(h[1] / 4));
    if(blocks.count({ax, ay})) return blocks[{ax, ay}] (h);
    return 0;
    }

  complex_surface(hyperpoint h) : cur(h) {}
  };

complex_surface *spiral, *hilbert;

ld spiral_level(hyperpoint h) {
  if(!spiral) {
    spiral = new complex_surface(point31(-4, 2, 0));
    spiral->right_block();
    spiral->right_block();
    spiral->right_block();
    spiral->right_block();
    spiral->turn_up_block();
    spiral->up_block();
    spiral->up_block();
    spiral->turn_left_block();
    spiral->left_block();
    spiral->left_block();
    spiral->turn_down_block();
    spiral->down_block();
    spiral->turn_right_block();
    spiral->right_block();
    spiral->turn_up_block();
    spiral->turn_left_block();
    spiral->left_block();
    }
  return spiral->get(h);
  }

ld hilbert_level(hyperpoint h) {
  if(!hilbert) {
    hilbert = new complex_surface(point31(2, 0, 0));
    hilbert->up_block();
    hilbert->turn_right_block2();
    hilbert->turn_down_block2();
    hilbert->turn_right_block();
    hilbert->right_block();
    hilbert->turn_up_block();
    hilbert->turn_left_block();
    hilbert->turn_up_block2();
    hilbert->turn_right_block2();
    hilbert->turn_up_block();
    hilbert->turn_left_block();
    hilbert->left_block();
    hilbert->turn_down_block();
    hilbert->turn_left_block2();
    hilbert->turn_up_block2();
    hilbert->up_block();
    }
  return hilbert->get(h);
  }

level spirallev(
  "Square Spiral", 's', 0,
  "The projection of this track is shaped like a square spiral.",
  0.5*dft_block, 16.5*dft_block, 16.5*dft_block, 0.5*dft_block,

  {
  "!!!!!!!!!!!!!!!!",
  "rgggggggggggggr!",
  "g+-----------+g!",
  "g|gGgggggggGg|g!",
  "g|G!!!!!!!!!G|g!",
  "g|g!rgggggr!g|g!",
  "g|g!g*---+g!g|g!",
  "g|g!rgggg|g!g|g!",
  "g|G!!!!!x|g!g|g!",
  "g|gGgggGg|g!g|g!",
  "g+-------+g!g|g!",
  "rgggggggggr!g|g!",
  "!!!!!!!!!!!!G|g!",
  "fffggggggggGg|g!",
  "-------------+g!",
  "ggggggggggggggr!"
  },

  1, 15.4, spiral_level,
  {
    // the solver result is 55.239
    goal{0xFFD500, "Collect the triangle in below 60 seconds", basic_check(60, 999)},
    goal{0xFF4040, "Collect the triangle in below 70 seconds", basic_check(70, 999)},
  }
  );

level hilbertlev(
  "Hilbert's Curve", 's', 0,
  "The projection of this track is shaped like the Hilbert curve.",
  0.5*dft_block, 16.5*dft_block, 16.5*dft_block, 0.5*dft_block,

  {
  "!!!!!!!!!!!!!!!!",
  "ggg!rgggGGGgggr!",
  "g*g!gf-------fg!",
  "g|g!g|ggGGGgg|g!",
  "g|g!g|g!!!!!g|g!",
  "g|gxg|g!rgggg|g!",
  "gf---fg!gf---fg!",
  "rgggggr!g|ggggr!",
  "!!!!!!!!g|o!!!!!",
  "rgggggr!g|ggggr!",
  "gf---fg!gf---fg!",
  "g|ggg|g!rgggg|g!",
  "g|g!x|g!!!!!g|g!",
  "g|g!g|ggGGGgg|g!",
  "g|g!gf-------fg!",
  "g|g!rgggGGGgggr!"
  },

  2.4, 15.4, hilbert_level,
  {
    // the solver result is 50.94
    goal{0xFFD500, "Collect the triangle in below 55 seconds", basic_check(55, 999)},
    goal{0xFF4040, "Collect the triangle in below 60 seconds", basic_check(60, 999)},
  }
  );

vector<level*> all_levels = {
  &rotplane, &longtrack, &geodesical, &geodesical4, &heisenberg0, &rotwell, &labyrinth, &obstacle, &spirallev, &hilbertlev
  };
  
}