Ejemplo n.º 1
0
  // joku randomilla tämän vierestä
  // tylsä bruteforcemenetelmä hajotusfiiliksen tuotoksena
  int[] getadj(PApplet pa, int x, int y, int z, boolean[] visited) {
    // {-x, x, -y, y, -z, z}
    int[][] dirs = {
      {-1, 0, 0},
      {1, 0, 0},
      {0, -1, 0},
      {0, 1, 0},
      {0, 0, -1},
      {0, 0, 1}
    };
    boolean ok = true;
    int[] dir;
    do {
      int i = (int) (pa.random(0, 6));
      dir = dirs[i];

      ok = true;
      if (x == 0 && i == 0) ok = false;
      if (y == 0 && i == 2) ok = false;
      if (z == 0 && i == 4) ok = false;
      if (x == size - 1 && i == 1) ok = false;
      if (y == size - 1 && i == 3) ok = false;
      if (z == size - 1 && i == 5) ok = false;
    } while (!ok || visited[world.at(x + dir[0], y + dir[1], z + dir[2])]);
    return dir;
  }
Ejemplo n.º 2
0
 // full == tästä ei pääse enää mihinkään uuteen paikkaan
 boolean full(boolean[] visited, int x, int y, int z) {
   return (x == 0 ? true : visited[world.at(x - 1, y, z)])
       && (x == size - 1 ? true : visited[world.at(x + 1, y, z)])
       && (y == 0 ? true : visited[world.at(x, y - 1, z)])
       && (y == size - 1 ? true : visited[world.at(x, y + 1, z)])
       && (z == 0 ? true : visited[world.at(x, y, z - 1)])
       && (z == size - 1 ? true : visited[world.at(x, y, z + 1)]);
 }
Ejemplo n.º 3
0
  void generate(PApplet pa) {
    int space = World.space;
    // sz^3 pisteitä, joiden välillä space tyhjää (tyhjä 0: kuutio)
    // eli (sz + (sz - 1) * space) ^ 3 tileä
    // visited ~ V_new wikipedian algossa

    boolean[] visited = new boolean[size3];
    int[] visitorder = new int[size3]; // indeksoidaan järjestysnumerolla

    // aluksi size on pisteiden määrä, newsize sitten kun niiden väliin on venytetty kulkuväyliä
    int newsz = size + (size - 1) * space;
    int newsz3 = newsz * newsz * newsz;
    map = new int[newsz3];

    // lähtöpaikka
    visitorder[0] = 0;
    visited[0] = true;
    map[0] = 0xffffffff;

    // käydään kaikki alkuperäiset pisteet läpi, jokaiseen mennään jotenkin
    for (int count = 1; count < size3; count++) {
      // - arvo tiili reunalta
      // (randomilla saattaa tulla sellainenkin joka ei ole reunalla, ei väliä kun ei jättikarttoja)
      // vois tietty pitää listaa sellaisista joista ei vielä pääse kaikkialle...
      // - arvo sille suunta
      // - visitoi se.
      int vidx;
      do {
        vidx = (int) (pa.random(0, count)); // monesko jo visitoitu leviää.
      } while (full(visited, visitorder[vidx]));

      int idx = visitorder[vidx];
      int z = idx / (size * size), y = idx / size % size, x = idx % size;

      // joku vierestä, dir on akselin suuntainen yksikkövektori
      int[] dir = getadj(pa, x, y, z, visited);
      int nx = x + dir[0], ny = y + dir[1], nz = z + dir[2];
      int newidx = world.at(nx, ny, nz);

      visitorder[count] = newidx;
      visited[newidx] = true;

      // nykykohta venytetyssä maailmassa
      int i = x * (space + 1), j = y * (space + 1), k = z * (space + 1);

      // nurkkien välillä debugväreillä
      for (int a = 0; a < space; a++) {
        i += dir[0];
        j += dir[1];
        k += dir[2];
        // vihreä kasvaa iteraatioiden kasvaessa, sininen taas z:n mukaan
        map[world.at(i, j, k, newsz)] =
            pa.color(1, (int) ((float) count / size3 * 255), (int) ((float) k / newsz * 255));
      }
      // verkon kärkipisteet punaisia
      map[world.at(i + dir[0], j + dir[1], k + dir[2], newsz)] = pa.color(255, 0, 0);
    }

    world.size = newsz;
    world.size3 = newsz3;
    world.map = map;
  }