Playfield.jack

/** Implements a playfield */
class Playfield {

  field int width;
  field int height;
  field Array grid;

  /** Constructs a new Playfield. */
  constructor Playfield new() {
    var int i;
    let width = 10;
    let height = 18;
    let grid = Array.new(height);
    let i = 0;
    while (i < height) {
      let grid[i] = Array.new(width);
      let i = i + 1;
    }
    return this;
  }

  /** Disposes this playfield. */
  method void dispose() {
    do Memory.deAlloc(this);
    return;
  }

  /** Clears the playfield. */
  method void clear() {
    var int i;
    var int j;
    var Array row;
    var Square s;
    let i = 0;
    while (i < height) {
      let row = grid[i];
      let j = 0;
      while (j < width) {
        if (~(row[j] = null)) {
          let s = row[j];
          do s.erase();
          let row[j] = null;
        }
        let j = j + 1;
      }
      let i = i + 1;
    }
    return;
  }

  /** Gets the playfield width. */
  method int getWidth() {
    return width;
  }

  /** Gets the playfield height. */
  method int getHeight() {
    return height;
  }

  /** Gets the grid. */
  method Array getGrid() {
    return grid;
  }

  /** Sets a tetromino on the playfield. */
  method void setTetromino(Tetromino t) {
    var int i;
    var int xpos;
    var int ypos;
    var Array row;
    var Array squares;
    var Square square;
    let i = 0;
    let squares = t.getSquares();
    while (i < 4) {
      let square = squares[i];
      let ypos = square.getY();
      let row = grid[ypos];
      let row[square.getX()] = square;
      let i = i + 1;
    }
    return;
  }

  /** Checks if there is space for a tetromino in the given direction */
  method boolean isSpace(Tetromino t, int direction) {
    var Array row;
    var Array squares;
    var Square square;
    var int xpos;
    var int ypos;
    var int xdest;
    var int ydest;
    var boolean isSpace;
    var int i;
    let squares = t.getSquares();
    let isSpace = true;
    let i = 0;
    if (direction = 2) {
      while (isSpace & (i < 4)) {
        let square = squares[i];
        let xpos = square.getX();
        let ydest = square.getY() + 1;
        if (ydest < height) {
          let row = grid[ydest];
          if (~(row[xpos] = null)) {
            let isSpace = false;
          }
        } else {
          let isSpace = false;
        }
        let i = i + 1;
      }
    }
    if (direction = 3) {
      while (isSpace & (i < 4)) {
        let square = squares[i];
        let ypos = square.getY();
        let xdest = square.getX() - 1;
        if (ypos > 0) {
          if (xdest > -1) {
            let row = grid[ypos];
            if (~(row[xdest] = null)) {
              let isSpace = false;
            }
          } else {
            let isSpace = false;
          }
        }
        let i = i + 1;
      }
    }
    if (direction = 4) {
      while (isSpace & (i < 4)) {
        let square = squares[i];
        let ypos = square.getY();
        let xdest = square.getX() + 1;
        if (ypos > 0) {
          if (xdest < width) {
            let row = grid[ypos];
            if (~(row[xdest] = null)) {
              let isSpace = false;
            }
          } else {
            let isSpace = false;
          }
        }
        let i = i + 1;
      }
    }
    return isSpace;
  }

  /** Clears the bottom row after scoring. */
  method void clearRow(int rowIndex) {
    var int j;
    var Array row;
    var Square s;
    let j = 0;
    let row = grid[rowIndex];
    while (j < width) {
      let s = row[j];
      do s.erase();
      do s.dispose();
      let s = null;
      let row[j] = null;
      let j = j + 1;
    }
    return;
  }

  /** Shifts a row down */
  method void shiftRow(int rowIndex) {
    var int j;
    var Array row;
    var Array prevRow;
    var Square s;
    let row = grid[rowIndex];
    let prevRow = grid[rowIndex - 1];
    let j = 0;
    while (j < width) {
      if (~(prevRow[j] = null)) {
        let s = prevRow[j];
        do s.erase();
        do s.setY(s.getY() + 1);
        do s.draw();
        let prevRow[j] = null;
        let row[j] = s;
      }
      let j = j + 1;
    }
    return;
  }

  /** Checks if there is space for a new tetromino */
  method boolean isFull() {
    var Array row;
    var boolean full;
    let full = false;
    let row = grid[1];
    if (row[4] | row[5]) {
      let full = true;
    }
    return full;
  }

  /** Checks if the tetromino can be rotated. */
  method boolean canRotate(Tetromino tetromino) {
    var int type;
    var int orientation;
    var boolean canRotate;
    var Array squares;
    var Square s;
    let type = tetromino.getType();
    let orientation = tetromino.getOrientation();
    let squares = tetromino.getSquares();
    let canRotate = true;
    if (type = 0) {
      let canRotate = false;
    }
    if (type = 1) {
      if (orientation = 1) {
        let s = squares[0];
        if (s.getX() > 6) {
          let canRotate = false;
        }
      }
    }
    // TODO: check if tetromino can actually be rotated
    return canRotate;
  }
}