blacklight

/**************************************************

 *

 * Size of each cell calculated with a 

 * division of stage's width with a multiple of 8

 *

 * 1024 / 16 = 64

 * 768 / 16 = 43

 * 1280 / 16 = 80

 *

 **************************************************/

int videoScale = 80;

int width = 1280;

int height = 720;

int cols, rows;

Cell[][] cells = {

};

// Players x,y

int mX ;

int mY;

PFont _regular_;

BlackMinion blackminion;

void setup() {

  _regular_ = loadFont ("Code-Bold-48.vlw");

  size(width, height);  

  cols = width/videoScale;

  rows = height/videoScale;

  //noLoop();

  drawGrid();

  // Setup blackminion

  blackminion = new BlackMinion();

  blackminion.setup();

}

void draw() {

  background(159, 182, 205);

  for (int i = 0; i < this.cells.length; i++) {

    //rows

    for (int j = 0; j < this.cells[i].length; j++) {

      this.cells [i][j].setup ( this.cells[i][j].lifeBar, this.cells[i][j].animating );

      this.cells [i][j].draw();

    }

  }

  moveBlack();

  this.blackminion.draw();

}

/**************************************************

 *

 * Draw grid once

 *

 **************************************************/

void drawGrid () {

  for (int i = 0; i < cols; i++) {

    Cell [] column = new Cell [rows];

    for (int j = 0; j < rows; j++) {

      // Scaling up to draw a rectangle at (x,y)

      int x = i*videoScale;

      int y = j*videoScale;

      Cell cell = new Cell (x, y, videoScale);

      column [j] = cell;

      //cell.setup();

    }

    this.cells = (Cell[][]) append (this.cells, column);

  }

}

/**************************************************

 *

 * Returns cell affected by player

 *

 **************************************************/

Cell getCell (int x, int y)

{

  int cellX = floor (cols * x) / this.width;

  int cellY = floor (rows * y) / this.height;

  //println ("cellX " + cellX + ", cellY " + cellY);

  return this.cells [cellX][cellY];

}

/**************************************************

 *

 * Simulated White Player

 *

 **************************************************/

void mouseMoved() {

  mX = mouseX;

  mY = mouseY;

  Cell cell = this.getCell ( mX, mY);

  cell.update(0);

}

void moveBlack() {

  // Bounce

  if ( blackminion.posX <= 0 )  keyCode = RIGHT;

  if ( blackminion.posX >= 1270 )  keyCode = LEFT;

  if ( blackminion.posY <= 0 )  keyCode = DOWN;

  if ( blackminion.posY >= 710 )  keyCode = UP;

  switch(keyCode) {

  case UP: 

    blackminion.posY -= 5; 

    break;

  case DOWN: 

    blackminion.posY += 5; 

    break;

  case LEFT: 

    blackminion.posX -= 5; 

    break;

  case RIGHT: 

    blackminion.posX += 5; 

    break;

  }

  Cell cell = this.getCell ( blackminion.posX, blackminion.posY);

  cell.update(1);

}

/**************************************************

 *

 * Simulated Black Player

 *

 **************************************************/

class BlackMinion {

  int posX = 0;

  int posY = 0;

  void setup() {

  };

  void draw() {

    display();

  }

  void display() {

    println("posY" + posY);

    fill(0);

    ellipse (posX, posY, 20, 20);

  }

}; 

class Cell {

  // Form

  int posX = 0;

  int posY = 0;

  int area = 0;

  int animX = 0;

  // Propreties

  int lifeBar = 127;

  Boolean animating = false;

  // 0 -> white 

  // 1 -> black 

  // 2-> null

  int side = 2;

  //Piece is a quad so receives x, y and quad area to deal later

  Cell ( int x, int y, int area) {

    this.posX = x;

    this.posY = y;

    this.area = area;

  }

  /**************************************************

   *

   * Upon creation it recieves the last lifeBar

   * and state from cell in same position

   *

   ***************************************************/

  void setup ( int lifeBar, Boolean animating ) {

    this.lifeBar = lifeBar;

    this.animating = animating;

    // Don't let lifebar escalate

    if (this.lifeBar >= 255) this.lifeBar = 255; 

    if (this.lifeBar <= 0) this.lifeBar = 0; 

    stroke (159, 182, 205);

    strokeWeight (2);

    // paints cell according to side

    switch(side) {

    case 2: 

      fill(127); 

      break;

    case 0: 

      fill(255); 

      break;

    case 1: 

      fill(0); 

      break;

    }

  };

  void draw() {

    // debug for cell

    //textFont (_regular_, 48);

    //text ( this.num , posX, posY );

    // if is not between animation draw cell and circle color

    if ( this.animating == false ) {

      quad(

      this.posX, 

      this.posY, 

      this.posX + area, 

      this.posY, 

      this.posX + area, 

      this.posY + area, 

      this.posX, 

      this.posY + area);

      if ( this.side == 1) {

        fill(255);

      }

      fill(lifeBar) ;

      noStroke();

      arc(this.posX + 40, this.posY + 40, 30, 30, 0, 360);

    }

    // if white conquers plays animate white

    if (this.lifeBar >= 255 && this.side != 0) {

      this.lifeBar = 255;

      animateCell(255, 0);

    }

    // if black conquers plays animate black

    if (this.lifeBar <= 0 && this.side != 1) {

      this.lifeBar = 0;

      animateCell(0, 1);

    }

  };

  /**************************************************

   *

   * Updates cell conquer power

   *

   ***************************************************/

  void update (int player) {

    if ( this.animating == false ) {

      switch(player) {

      case 0: 

        updateWhite(); 

        break; 

      case 1: 

        updateBlack(); 

        break;

      }

    }

  };

  void updateWhite () {

    this.lifeBar += 5;

    println(lifeBar);

  };

  void updateBlack() {

    println("updateBlack");

    this.lifeBar -= 5;

    println(lifeBar);

  }

  /**************************************************

   *

   * Animates current cell

   *

   ***************************************************/

  void animateCell( int clr, int side ) {

    this.animating = true;

    if (  animX <= this.area) {

      if ( animX > area /2 ) {

        fill(clr);        

        print("animX " + animX);

      }

      else {

        fill(127);

      }

      quad(

      this.posX+animX, 

      this.posY, 

      (this.posX + area) - animX, 

      this.posY, 

      (this.posX + area) -animX, 

      this.posY + area, 

      this.posX + animX, 

      this.posY + area);

    }

    else {

      this.animating = false;

      this.side = side;

      animX = 0;

    }

    animX +=3*0.7;

  };

}