!7

static int features = 1;

static int hWidth = 10, hHeight = 10;

!include #1009151 // AI Game & API

p {

  newImageText = "New Letter!";

  makeInstruction();

  pGame();

  swing {

    setFrameTitle(is, "A. I. Game 7");

    final JSpinner spinner = jSpinner(features, 1, 100);

    addToWindowPack(is, withMargin(jRightAligned(withLabel("Number of features to use:", spinner))));

    onChange(spinner, r {

      features = intFromSpinner(spinner);

      makeInstruction();

      restartAIs();

    });

  }

}

svoid makeInstruction {

  setInstruction("Reproduce this image with " + n(features, "Haar-like feature") + ":");

}

sclass Haar {

  Rect black, white;

  *() {}

  *(Rect *black, Rect *white) {}

  bool vertical() { ret black.x == white.x; }

}

sclass Submission {

  new L<Haar> features;

  *() {}

  *(Haar... features) { this.features = asList(features); check(); }

  *(L<Haar> *features) { check(); }

  void check {

    assertEquals(main.features, l(features));

  }

}

//////////////////

// PUZZLE MAKER //

//////////////////

sS lastLetter;

static RGBImage makeImage() {

  //ret loadRGBImage(/*#1006930*/#1006944);

  S letter;

  do {

    letter = "" + randomCharBetween('A', 'Z');

  } while (eq(letter, lastLetter));

  lastLetter = letter;

  renderText_withLeading = false;

  ret new RGBImage(renderText(#1004568, 100, letter));

}

////////////////

// FORM MAKER //

////////////////

static JComponent makeTheForm(final GameForAI game) {

  null;

  // TODO

}

static Pt ptFromForm(JTextField x, JTextField y) {

  ret new Pt(intFromTextField(x), intFromTextField(y));

}

static Pt ptFromForm(JSpinner x, JSpinner y) {

  ret new Pt(intFromSpinner(x), intFromSpinner(y));

}

///////////////

// RENDERERS //

///////////////

static RGBImage renderImage(Submission s) {

  ret new RGBImage(renderImage1(s));

}

static BufferedImage renderImage1(Submission s) {

  BufferedImage bi = newBufferedImage(w, h, Color.gray);

  for (Haar h : s.features)

    paintHaar(bi, h.black, h.white);

  ret bi;

}

static RGBImage renderWithHints(Submission s) {

  ret new RGBImage(renderImage1(s));

}

//////////////////////////////////////

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

//////////////////////////////////////

AI > AI_Random {

  new Best<Submission> best;

  Haar randomFeature() {

    Rect r;

    Pair<Rect> p;

    if (tossCoin()) {

      r = randomRect(image(), hWidth, hHeight*2);

      p = splitRectInVerticalHalves(r);

    } else {

      r = randomRect(image(), hHeight*2, hWidth);

      p = splitRectInHorizontalHalves(r);

    }

    if (oneInTwoChance()) p = reversePair(p);

    ret new Haar(p.a, p.b);

  }

  void go {

    //print("Round: " + round());

    if (round() == 1 && best.has()) // TODO: automate this

      submit(best.get());

    else {

      Submission guess = guess();

      updateBest(guess, submit(guess));

    }

  }

  void updateBest(Submission guess, double score) {

    best.put(guess, score);

  }

  Submission guess() {

    ret new Submission(produceN(func { randomFeature() }, features));

  }

}

AI_Random > AI_RandomWithVariation {

  int n, range = 10;

  Submission guess() {

    if (odd(n++) && best.has())

      ret vary(best.get());

    else

      ret super.guess();

  }

  Submission vary(Submission s) {

    s = cloneThroughStructure(s);

    varyFeature(random(s.features));

    ret s;

  }

  void varyFeature(Haar h) {

    /*int deltaX = random(-range, range+1), deltaY = random(-range, range+1);

    Rect a = translateRect(h.black, deltaX, deltaY);

    Rect b = translateRect(h.white, deltaX, deltaY);

    if (rectContains(imageRect(), a) && rectContains(imageRect(), b)) {

      h.black = a;

      h.white = b;

    }*/

    Rect r = rectUnion(h.black, h.white);

    Rect r2 = randomRect(image(), r.w, r.h);

    h.black = translateRect(h.black, r2.x-r.x, r2.y-r.y);

    h.white = translateRect(h.white, r2.x-r.x, r2.y-r.y);

  }

  int varyWidth(Rect r) {

    ret max(r.x+1, min(w, random(r.x2()-range, r.x2()+range+1)))-r.x;

  }

  int varyHeight(Rect r) {

    ret max(r.y+1, min(h, random(r.y2()-range, r.y2()+range+1)))-r.y;

  }

}

/*

AI > AI_Racer {

  AI_RandomWithVariation leader, overtaker;

  new Best<Submission> leadersBest;

  int discardEvery = 5000;

  int roundsSinceChange;

  AI_RandomWithVariation newAI() { ret new AI_RandomWithVariation; }

  void go {

    if (round() == 1 && leadersBest.has()) // TODO: automate this

      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);

      overtaker.updateBest(guess, score);

      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;

      }

    }

  }

}

*/