!7

import static java.lang.Math.*;
import java.awt.geom.*;

p-substance {
  showPackedFrame(new PenroseTiling);
  hideConsole();
}

sclass PenroseTiling extends JPanel {
  // ignores missing hash code
  class Tile {
      double x, y, angle, size;
      Type type;

      Tile(Type t, double x, double y, double a, double s) {
          type = t;
          this.x = x;
          this.y = y;
          angle = a;
          size = s;
      }

      @Override
      public boolean equals(Object o) {
          if (o instanceof Tile) {
              Tile t = (Tile) o;
              return type == t.type && x == t.x && y == t.y && angle == t.angle;
          }
          return false;
      }
  }

  enum Type {
      Kite, Dart
  }

  static final double G = (1 + sqrt(5)) / 2; // golden ratio
  static final double T = toRadians(36); // theta

  new L<Tile> tiles;

  *() {
    int w = 700, h = 450;
    setPreferredSize(new Dimension(w, h));
    setBackground(Color.white);

    tiles = deflateTiles(setupPrototiles(w, h), 5);
  }

  L<Tile> setupPrototiles(int w, int h) {
    new L<Tile> proto;

    // sun
    for (double a = PI / 2 + T; a < 3 * PI; a += 2 * T)
        proto.add(new Tile(Type.Kite, w / 2, h / 2, a, w / 2.5));

    ret proto;
  }

  List<Tile> deflateTiles(List<Tile> tls, int generation) {
      if (generation <= 0)
          return tls;

      List<Tile> next = new ArrayList<>();

      for (Tile tile : tls) {
          double x = tile.x, y = tile.y, a = tile.angle, nx, ny;
          double size = tile.size / G;

          if (tile.type == Type.Dart) {
              next.add(new Tile(Type.Kite, x, y, a + 5 * T, size));

              for (int i = 0, sign = 1; i < 2; i++, sign *= -1) {
                  nx = x + cos(a - 4 * T * sign) * G * tile.size;
                  ny = y - sin(a - 4 * T * sign) * G * tile.size;
                  next.add(new Tile(Type.Dart, nx, ny, a - 4 * T * sign, size));
              }

          } else {

              for (int i = 0, sign = 1; i < 2; i++, sign *= -1) {
                  next.add(new Tile(Type.Dart, x, y, a - 4 * T * sign, size));

                  nx = x + cos(a - T * sign) * G * tile.size;
                  ny = y - sin(a - T * sign) * G * tile.size;
                  next.add(new Tile(Type.Kite, nx, ny, a + 3 * T * sign, size));
              }
          }
      }
      // remove duplicates
      tls = uniquify(next);

      return deflateTiles(tls, generation - 1);
  }

  void drawTiles(Graphics2D g) {
      double[][] dist = {{G, G, G}, {-G, -1, -G}};
      for (Tile tile : tiles) {
          double angle = tile.angle - T;
          Path2D path = new Path2D.Double();
          path.moveTo(tile.x, tile.y);

          int ord = tile.type.ordinal();
          for (int i = 0; i < 3; i++) {
              double x = tile.x + dist[ord][i] * tile.size * cos(angle);
              double y = tile.y - dist[ord][i] * tile.size * sin(angle);
              path.lineTo(x, y);
              angle += T;
          }
          path.closePath();
          g.setColor(ord == 0 ? Color.orange : Color.yellow);
          g.fill(path);
          g.setColor(Color.darkGray);
          g.draw(path);
      }
  }

  @Override
  public void paintComponent(Graphics og) {
      super.paintComponent(og);
      Graphics2D g = (Graphics2D) og;
      g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
              RenderingHints.VALUE_ANTIALIAS_ON);
      drawTiles(g);
  }
}