StickGuy[] people;
Building building1;
Building building2;
Monster monster;
int peopleCount = 10;
int ground;

void setup()
{
  background(255);
  size(400, 400, P2D);

  ground = height - 25;

  people = new StickGuy[peopleCount];
  for (int i = 0; i < peopleCount; i++)
  {
    // start at doors 150 and 325
    people[i] = new StickGuy(random(0, width), ground);
  }

  building1 = new Building(150, ground, 120, 75);
  building2 = new Building(325, ground, 220, 90);
  monster = new Monster();
}

void draw()
{
  background(255);

  building1.render();
  building2.render();

  // draw people
  for (int i = 0; i < peopleCount; i++)
  {
    if (people[i].render() == true)
    {
      // start at doors 150 and 325
      people[i] = new StickGuy(random(-1, 1) > 0 ? 150 : 325, ground);
    }
  } 

  monster.render();

  // draw ground
  stroke(0);
  line(0, ground, width, ground);
}

void mousePressed()
{
  stroke(0);
  monster.shoot(mouseX, ground);

  for (int i = 0; i < peopleCount; i++)
  {
    StickGuy guy = people[i];
    if (guy.hitTest(mouseX, mouseY) == true)
    {
      guy.kill();
    }
  }
}

void keyPressed()
{
  if (keyCode == 'S')
  {
    saveFrame("monster.png");
  }
}

class BWSmoke 
{ 
  int renderThrottle = 3;
  int frameCounter = 0;

  float x;
  float y;
  int pSize;
  int pCount;
  int realPCount;
  boolean stopped;
  float[] xPoints;
  float[] yPoints;

  BWSmoke(float x, float y, int pSize, int pCount)
  {
    this.x = x;
    this.y = y;
    this.pSize = pSize;
    this.pCount = pCount;
    this.realPCount = 0;
    this.stopped = false;

    xPoints = new float[pCount];
    yPoints = new float[pCount];
  }

  void stop()
  {
    stopped = true;
  }

  void start()
  {
    stopped = false;
  }

  void render()
  {
    if (stopped && realPCount == 0)
    {
      return;
    }

    frameCounter++;

    // don't update particles every frame
    if (frameCounter % renderThrottle == 0)
    {
      if (stopped)
      {
        realPCount--;
      }
      else if (realPCount < pCount)
      {
        realPCount++;
      }   

      // shift up
      for (int i = realPCount - 1; i > 0; i--)
      {
        xPoints[i] = xPoints[i - 1];
        yPoints[i] = yPoints[i - 1];
        yPoints[i] -= random(pSize / 3, pSize / 2);
        yPoints[i] += random(-1, 1);
      }

      // reset frame counter
      frameCounter = 0;
      xPoints[0] = random(-pSize / 2, pSize / 2) + x;
      yPoints[0] = y;
    }

    noStroke();
    //  draw the particles
    for (int i = 0; i < realPCount; i++)
    {
      fill(0, map(i, 0, realPCount, 200, 20));
      float realPSize = map(i, 0, pSize, pSize, pSize / 1.2);

      pushMatrix();
      translate(xPoints[i], yPoints[i]);
      rotate(TWO_PI / random(1, 10));
      rect(-realPSize / 2, -realPSize / 2, realPSize, realPSize);
      popMatrix();
    }
  }
}

class Building
{
  int h;
  int w;
  int x;
  int y;
  BWSmoke smoke1;
  BWSmoke smoke2;

  Building(int x, int y, int h, int w)
  {
    this.x = x;
    this.y = y;
    this.h = h;
    this.w = w;
    smoke1 = new BWSmoke(x - w / 3, y - h - 2, 8, 28);
    smoke2 = new BWSmoke(x + w / 8, y - h - 8, 7, 20);
  }

  void render()
  {
    stroke(0);
    // sides
    line(x - w / 2, y, x - w / 2, y - h);
    line(x + w / 2, y, x + w / 2, y - h);
    // roof
    line(x - w / 2, y - h, x - w / 4, y - h + 7);
    line(x - w / 4, y - h + 7, x, y - h - 12);
    line(x, y - h - 12, x + w / 8, y - h);
    line(x + w / 8, y - h, x + w / 4, y - h - 20);
    line(x + w / 4, y - h - 20, x + w * 3 / 8, y - h + 5);
    line(x + w * 3 / 8, y - h + 5, x + w / 2, y - h);

    // draw windows
    fill(255);
    for (int i = y - h + 25; i < y - 30; i += 25)
    {
      for (int j = -1; j < 2; j++)
      {
        rect(x - 5 + ((w / 3) * j), i, 8, 12);
      }
    }

    // door
    fill(255);
    rect(x - w / 16, y - 20, w / 8, 20);

    smoke1.render();
    smoke2.render();
  }
}

class Monster
{
  boolean isShooting;
  float x;
  float y;
  float nextX = random(width / 4, width * 3 / 4);

  float targetX;
  float targetY;
  float bulletX;
  float bulletY;
  float shotX;
  float shotY;
  int shotMaxCount;
  int shotCount;

  Monster()
  {
    isShooting = false;
    shotMaxCount = 6;
    x = width / 2;
    y = 50;
  }

  void render()
  { 
    if (abs(nextX - x) < 5)
    {
      nextX = random(width / 8, width * 7 / 8);
    }

    x += (nextX - x) / abs((nextX - x) / 1.4);

    // base
    noStroke();
    fill(0);
    ellipse(x, y, 100, 60);
    ellipse(x, y + 20, 100, 20);
    triangle(x - 30, y - 20, x - 30, y - 50, x - 25, y - 20);
    triangle(x + 30, y - 20, x + 30, y - 50, x + 25, y - 20); 

    // eye white
    fill(255);
    ellipse(x, y, 25, 25);

    // eye
    fill(0);
    float eyeX = map(mouseX, 0, width, -8, 8);
    float eyeY = map(abs(mouseX - width/2) + width/2, 0, width/2, -16, -8);
    ellipse(x + eyeX, y - eyeY, 10, 10);

    // teeth
    fill(255);
    stroke(0);

    for (int i = (int)x - 40; i <= x + 40; i += 10)
    {
      triangle(i - 3, y + 20, i + 3, y + 20, i, y + 30);
    }

    if (isShooting)
    {
      float currX = map(shotCount, 0, shotMaxCount, shotX, targetX);
      float currY = map(shotCount, 0, shotMaxCount, shotY, targetY);

      stroke(0);
      float oldStrokeWeight = g.strokeWeight;
      strokeWeight(1.25);
      line(targetX, targetY, currX, currY);
      strokeWeight(oldStrokeWeight);

      shotCount++;
      if (shotCount >= shotMaxCount)
      {
        isShooting = false;
      }
    }
  }

  void shoot(int x, int y)
  {
    if (isShooting)
    {
      return;
    }

    isShooting = true;
    targetX = x;
    targetY = y;
    shotX = this.x;
    shotY = this.y + 30;
    shotCount = 0;
  }
}

class StickGuy
{
  float x;
  float y;
  boolean isDead;
  int persistFrames;
  int deadFrames;
  BWSmoke smoke;
  int direction;
  float speed;

  StickGuy(float x, float y)
  {
    isDead = false;
    persistFrames = 1000;
    this.x = x;
    this.y = y;
    direction = (int)pow(-1, int(random(0, 2)));
    speed = random(0.2, 0.8);
  }

  void kill()
  {
    if (isDead)
    {
      return;
    }

    smoke = new BWSmoke(x, y - 4, 3, 12);

    deadFrames = 0;
    isDead = true;
  }

  boolean hitTest(int x, int y)
  {
    if (x >= this.x - 4
      && x <= this.x + 4
      && y >= this.y - 15
      && y <= this.y)
    {
      return true;
    }

    return false;
  }

  // return true if the guy is gone
  boolean render()
  {
    stroke(0);
    fill(255);

    if (isDead == false)
    {
      return renderAlive();
    }
    else
    {
      return renderDead();
    }
  }

  boolean renderAlive()
  {
    x += speed * direction;

    if (x > width)
    {
      direction = -1;
    }
    else if (x < 0)
    {
      direction = 1;
    }

    // body
    line(x, y - 4, x, y - 10);

    // legs
    line(x - 3, y, x, y - 4);
    line(x + 3, y, x, y - 4);

    // arms
    line(x - 3, y - 9, x, y - 6);
    line(x + 3, y - 9, x, y - 6);

    // head
    ellipse(x, y - 13, 5, 5);

    // is not gone
    return false;
  }

  boolean renderDead()
  {
    if (deadFrames == persistFrames)
    {
      // is gone
      return true;
    }

    // stop smoking after a while
    if (deadFrames >= persistFrames / 1.5 && smoke.stopped == false)
    {
      smoke.stop();
    }

    deadFrames++;

    fill(0);
    stroke(0);
    triangle(x, y - 3, x - 4, y, x + 4, y);
    smoke.render();

    // is gone
    return false;
  }
}