public int dWidth;
public int dHeight;
PFont font;

int pixelFactor = 32;
int margin = 4;

public float[][] level;
public float[][] dLevel;

boolean drawStroke = true;
boolean drawFill = true;
boolean pushUp = true;
boolean sizeMod = false;
boolean highDrag = false;

void setup() {
  //size(int(screen.width*0.75), int(screen.height*0.75));
  size(800,600);
  
  font = loadFont("ProggySquare-11.vlw");
  textFont(font);

  dWidth = width/pixelFactor;
  dHeight = height/pixelFactor;

  background(0);
  frameRate(25);

  level = new float[dWidth][dHeight];
  for(int x=0; x<dWidth; x++) {
    level[x] = new float[dWidth];
    for(int y=0; y<dHeight; y++) {
      level[x][y] = 0.0;
    }
  }

  dLevel = new float[dWidth][dHeight];
  for(int x=0; x<dWidth; x++) {
    dLevel[x] = new float[dWidth];
    for(int y=0; y<dHeight; y++) {
      dLevel[x][y] = 0.0;
    }
  }
  
  setHelp();
}

void draw() {

  if (mouseDown) {
    mouseImpulse();
  }

  updateLake();
  updateLake();
  updateLake();
  boat.update();

  fill(0);
  rect(0,0,width, height);

  float contrast = 6.0;

  noStroke();
  noFill();

  int rectSize = pixelFactor - margin - margin;
  float currentLevel;
  float currentLevelX;
  float ratio;

  int x;
  for(int x2=0; x2<dWidth; x2++) {
    if (x2 < dWidth/2) {
      x = x2;
    } 
    else {
      x = dWidth - ( x2 - (dWidth/2) ) -1;
    }
    for(int y=0; y<dHeight; y++) {
      currentLevel = level[x][y];
      currentLevelX = currentLevel*contrast;
      
      boolean pinkYellow = false;
      if (drawStroke){
        if (pinkYellow) {
          stroke(
            198.0 + 232.0,
            98.0 + 204.0,
            197.0 + 126.0
            );
        } 
        else {
          stroke(
          currentLevelX*10.0 + 10.0,
          currentLevelX*20.0 + 20.0,
          max(64.0, currentLevelX*20.0 + 64.0)
            );
        }
      }
      if (drawFill) {
        fill(
        currentLevelX*5.0 + 10.0,
        currentLevelX*10.0 + 20.0,
        currentLevelX*10.0 + 64.0
          );
      }

      ratio = float(x) / float(dWidth-1);
      ratio = ratio * 2.0 - 1.0;
      
      rect(
      x*pixelFactor + int(currentLevel*50.0)*ratio, 
      y*pixelFactor - int(currentLevel*22.0),
      rectSize*(sizeMod?currentLevel:1), rectSize*(sizeMod?currentLevel:1));
    }
  }

  //boat.draw();

  if (showFps) {
    fill(0, 0, 0);
    text(frameRate, 5+1, 5+textAscent()+1);
    fill(255.0, 0, 0);
    text(frameRate, 5, 5+textAscent());
  }
  
  if (showHelp) {
    fill(0, 0, 0);
    text(halp, 15+1, 25+textAscent()+1);
    fill(255.0, 0, 0);
    text(halp, 15, 25+textAscent());
  }

}

Boolean showHelp = true;
Boolean showFps = false;

String halp = "??";

void setHelp() {
  halp = 
  "Help:\n\n" + 
  "Drag on the canvas!\n" +
  "1-5: resolution\n" + 
  "7: toggle drag intensity (currently " + (highDrag ? "HIGH" : "LOW") + " drag)\n" + 
  "8: toggle size modulation\n" +
  "9: toggle outlines\n" +  
  "0: toggle fill\n" + 
  "h: toggle this message\n" + 
  "f: toggle fps (25 max)\n\n" + 
  "v0.1.1";
}
  
void keyPressed() {
  switch (key) {
  case '1':
  case '2':
  case '3':
  case '4':
  case '5':
    pixelFactor = int(pow(2.0, parseInt(key + "") + 1.0));
    margin = parseInt(key+"");
    println("pixelFactor " + pixelFactor);
    setup();
    break;

  case '7':
    highDrag = !highDrag;
    setHelp();
    println("drag " + highDrag);
    break;
  case '8':
    sizeMod = !sizeMod;
    break;
  case '9':
    drawStroke = !drawStroke;
    break;
  case '0':
    drawFill = !drawFill;
    break;
    
  case 'h':
    showHelp = !showHelp;
    break;
  
  case 'f':
    showFps = !showFps;
    break;
    
  case 'a':
    boat.turnLeft = true;
    break;
  case 'd':
    boat.turnRight = true;
    break;
  case 'w':
    boat.accel = true;
    break;
  }

  if (keyCode == 16) {
    // left shift
    pushUp = false;
  }

  println(keyCode);
}

void keyReleased() {
  if (keyCode == 16) {
    // left shift
    pushUp = true;
  }
  switch (key) {
  case 'a':
    boat.turnLeft = false;
    break;
  case 'd':
    boat.turnRight = false;
    break;
  case 'w':
    boat.accel = false;
    break;
  }
}

void updateLake() {

  float avgLevel = 0.0;
  float diff = 0.0;

  for(int x=1; x<dWidth-1; x++) {
    for(int y=1; y<dHeight-1; y++) {

      // calc average surrounding level 
      avgLevel = 
        0.7*level[x-1][y-1] +
        level[x][y-1] + 
        0.7*level[x+1][y-1] +

        level[x+1][y] + 

        0.7*level[x+1][y+1] +
        level[x][y+1] +
        0.7*level[x-1][y+1] +

        level[x-1][y];

      avgLevel /= 6.8;

      // calc difference for this pixel to avg surrounding level
      diff = avgLevel - level[x][y];

      // accelerate level speed by difference (pull toward average)
      dLevel[x][y] += diff*0.07;

      // drag, so it evens out
      dLevel[x][y] *= highDrag ? 0.99 : 0.997;

    }
  }

  for(int x=1; x<dWidth-1; x++) {
    for(int y=1; y<dHeight-1; y++) {
      // apply level speed to levels
      level[x][y] += dLevel[x][y];
    }
  }

}

boolean mouseDown = false;
int lastMx = -1;
int lastMy = -1;

void mousePressed() {
  mouseDown = true;
}

void mouseReleased() {
  mouseDown = false;
  lastMx = -1;
  lastMy = -1;
}

void mouseImpulse() {
  int mx = mouseX/pixelFactor;
  int my = mouseY/pixelFactor;

  mx = constrain(mx, 1, dWidth-3);
  my = constrain(my, 1, dHeight-3);

  float amt = 0.05;
  if (!pushUp) {
    amt *= -1.0;
  }

  if (lastMx == -1) {
    println("dot at " + mx + "," + my);
    dLevel[mx][my] += amt;
    dLevel[mx+1][my] += amt;
    dLevel[mx][my+1] += amt;
    dLevel[mx+1][my+1] += amt;
  } 
  else {

    lastMx = constrain(lastMx, 1, dWidth-3);
    lastMy = constrain(lastMy, 1, dHeight-3);

    int distToLast = int( dist(mx, my, lastMx, lastMy) );
    println("Line from " + lastMx + "," + lastMy  + " to " + mx + ", " + my + ": " + distToLast);
    for (int i=0; i<=distToLast; i++) {
      float ratio = float(i)/float(distToLast);
      if (distToLast == 0) {
        ratio = 0.0;
      }

      int x = int(ratio*lastMx + (1-ratio)*mx);
      int y = int(ratio*lastMy + (1-ratio)*my);
      println(x + " ," + y + " ratio " + ratio);

      distToLast = max(1, distToLast);
      /*amt /= float(distToLast);*/

//            level[x][y] = amt;
//            level[x+1][y] = amt;
//            level[x][y+1] = amt;
//            level[x+1][y+1] = amt;

      dLevel[x][y] += amt;
      dLevel[x+1][y] += amt;
      dLevel[x][y+1] += amt;
      dLevel[x+1][y+1] += amt;
    }

  }

  lastMx = mx;
  lastMy = my;
}

Boat boat = new Boat();

class Boat {
  float x;
  float y;
  float angle;
  float speed;

  public boolean turnLeft = false;
  public boolean turnRight = false;
  public boolean accel = false;

  float turnSpeed = 0.1;

  void update() {
    angle += 
      (turnLeft ? -turnSpeed : 0.0) +
      (turnRight ? turnSpeed : 0.0);

    x += cos(angle) * speed;
    y += sin(angle) * speed;

    speed = constrain(speed+0.1, 0.0, 3.0);
  }
  void draw() {
    float sine = sin(angle);
    float cosine = cos(angle); 

    stroke(255.0, 20.0, 20.0);
    fill(180,10,10);
    quad(
    x,    y+30*sine,
    x-30*cosine,  y,
    x,    y-100*sine,
    x+30*cosine,  y
      );
  }
}