!7

static int lineWidth = 13;
static int lines = 2;
sS font = /*#1004568*/#1004970;
sbool oldVaryLine = false;

!include #1006931 // AI Game & API

p {
  newImageText = "New Letter!";
  makeInstruction();
  pGame();
  swing {
    setFrameTitle(is, "A. I. Game 5.2");
    final JSpinner spinner = jSpinner(lines, 1, 100);
    addToWindowPack(is, withMargin(jRightAligned(withLabel("Number of lines to use:", spinner))));
    onChange(spinner, r {
      lines = intFromSpinner(spinner);
      makeInstruction();
      restartAIs();
    });
  }
}

svoid makeInstruction {
  setInstruction("Reproduce this image with " + n(lines, "curved line") + ":");
}

sclass Curve {
  Pt a, b, c; // b = control point for curve
  
  *() {}
  *(Pt *a, Pt *b, Pt *c) {}
  
  Pt realb() {
    ret un_closerControlPoint(a, b, c);
  }
}

sclass Submission {
  new L<Curve> lines;
  
  *() {}
  *(Curve... lines) { this.lines = asList(lines); check(); }
  *(L<Curve> *lines) { check(); }
  
  void check {
    assertEquals(main.lines, l(lines));
  }
}

//////////////////
// PUZZLE MAKER //
//////////////////

sS lastLetter;

static RGBImage makeImage() {
  S letter;
  S choice = charRange('A', 'Z') + charRange('0', '9');
  do {
    letter = "" + oneOf(choice);
  } while (eq(letter, lastLetter));
  lastLetter = letter;
  aiTitle = letter + "/" + lines;
  ret rgbWhiteBorder(10, rgbAutoCrop(new RGBImage(renderText(font, 100, letter))));
}

//////////////////////
// FORM MAKER (NONE //
//////////////////////

static JComponent makeTheForm(final GameForAI game) { null; }

///////////////
// RENDERERS //
///////////////

static RGBImage renderImage(Submission s) {
  ret new RGBImage(renderImage1(s));
}

static BufferedImage renderImage1(Submission s) {
  BufferedImage bi = newBufferedImage(w, h, Color.white);
  for (Curve l : s.lines)
    drawRoundEdgeCurve(bi, l.a, l.realb(), l.c, Color.black, lineWidth);
  ret bi;
}

static RGBImage renderWithHints(Submission s) {
  //BufferedImage bi = renderImage1(s);
  BufferedImage bi = newBufferedImage(w, h, Color.white);
  int n = 0;
  for (Curve l : s.lines)
    drawRoundEdgeCurve(bi, l.a, l.realb(), l.c, rainbowColor(n++, l(s.lines)), lineWidth);
  RGBImage img = new RGBImage(bi);
  for (Curve l : s.lines) {
    rgbMarkPoints(img, Color.lightGray, 1, l.a, l.c);
    Pt control = l.b; // closerControlPoint(l.a, l.b, l.c);
    rgbMarkPoints(img, Color.red, 1, control); // control point in red
  }
  ret rgbUncache(img);
}

//////////////////////////////////////
// Test AIs. Just add your own here //
//////////////////////////////////////

AI > AI_Random {
  new Best<Submission> best;
  
  Curve randomLine() {
    ret new Curve(randomPoint(), randomPoint(), randomPoint());
  }
  
  Pt randomPoint() { ret main.randomPoint(image()); }

  void go {
    //print("Round: " + round());
    if (round() == 1 && best.has())
      submit(best.get());
    else {
      Submission guess = guess();
      updateBest(guess, submit(guess));
    }
  }
  
  bool updateBest(Submission guess, double score) {
    ret best.put(guess, score);
  }
  
  Submission guess() {
    ret new Submission(produceN(func { randomLine() }, lines));
  }
}

AI_Random > AI_RandomWithVariation {
  int n;
  
  Submission guess() {
    if (odd(n++) && best.has())
      ret vary(best.get());
    else
      ret super.guess();
  }
  
  Submission vary(Submission s) {
    s = cloneThroughStructure(s);
    varyLine(random(s.lines));
    ret s;
  }
  
  void varyLine(Curve l) {
    if (oldVaryLine)
      switch (random(3)) {
        case 0: l.a = varyPoint(l.a);
        case 1: l.b = varyPoint(l.b);
        case 2: l.c = varyPoint(l.c);
      }
    else if (oneIn(3))
      switch (random(3)) {
        case 0: l.a = randomPoint();
        case 1: l.b = randomPoint();
        case 2: l.c = randomPoint();
      }
    else {
      l.a = varyPoint2(l.a);
      l.b = varyPoint2(l.b);
      l.c = varyPoint2(l.c);
    }
  }
  
  Pt varyPoint(Pt p) {
    ret tossACoin() ? randomPoint() : varyPoint(p, 10);
  }
  
  Pt varyPoint2(Pt p) {
    ret varyPoint(p, 10);
  }
  
  Pt varyPoint(Pt p, int range) {
    range = max(range, 1);
    ret new Pt(
      random(p.x-range, p.x+range+1),
      random(p.y-range, p.y+range+1));
  }
}

AI > AI_Racer {
  AI_RandomWithVariation leader, overtaker;
  new Best<Submission> leadersBest;
  int discardEvery = 2500;
  int roundsSinceChange;
  static ImageSurface is;
  
  AI_RandomWithVariation newAI() { ret new AI_RandomWithVariation; }
  
  void go {
    if (round() == 1 && leadersBest.has())
      submit(leadersBest.get());
    else if (tossACoin()) {
      if (leader == null) leader = newAI();
      initSubAI(leader);
      Submission guess = leader.guess();
      double score = submit(guess);
      leader.updateBest(guess, score);
      leadersBest.put(guess, score);
    } else {
      if (overtaker == null) overtaker = newAI();
      initSubAI(overtaker);
      Submission guess = overtaker.guess();
      double score = submit(guess);
      if (overtaker.updateBest(guess, score)) {
        int percent = toIntPercent(score/leader.best.score());
        S title = percent + "% Challenger";
        bool first = is == null;
        is = showZoomedImage_centered(is, title, renderWithHints(guess));
        if (first) {
          setFrameWidth(is, 250);
          moveToTopRightCorner(is);
          moveFrameDown(is, 300);
        }
      }
      if (score > leadersBest.score()) {
        // displace leader!
        print("Overtake at " + formatScore(overtaker.best.score()) + " vs " + formatScore(leadersBest.score()));
        leader = overtaker;
        overtaker = null;
        roundsSinceChange = 0;
      } else if (roundsSinceChange++ >= discardEvery) {
        // make new overtaker
        print("Discarding overtaker at " + formatScore(overtaker.best.score()) + " vs " + formatScore(leadersBest.score()));
        overtaker = null;
        roundsSinceChange = 0;
      }
    }
  }
}