graphics/grid.js

  1. 'use strict';
  3. /**
  4.  * @class Grid
  5.  * @param {rows} rows - Number of rows in the grid.
  6.  * @param {cols} cols - Number of cols in the grid.
  7.  */
  8. function Grid(rows, cols) {
  9.     if (arguments.length !== 2) {
  10.         throw new Error('You should pass exactly 2 arguments to <span ' +
  11.             'class="code">new Grid(rows, cols)</span>');
  12.     }
  13.     if (typeof rows !== 'number' || !isFinite(rows)) {
  14.         throw new TypeError('Invalid value for <span class="code">rows' +
  15.             '</span>. Make sure you are passing finite numbers to <span ' +
  16.             'class="code">new Grid(rows, cols)</span>.');
  17.     }
  18.     if (typeof cols !== 'number' || !isFinite(cols)) {
  19.         throw new TypeError('Invalid value for <span class="code">cols' +
  20.             '</span>. Make sure you are passing finite numbers to <span ' +
  21.             'class="code">new Grid(rows, cols)</span>.');
  22.     }
  24.     rows = Math.max(0, rows);
  25.     cols = Math.max(0, cols);
  27.     this.grid = new Array(rows);
  28.     for (var i = 0; i < rows; i++) {
  29.         this.grid[i] = new Array(cols);
  30.     }
  31. }
  33. /**
  34.  * Initializes a Grid from an array.
  35.  * @param {array} arr - Array containing elements to be made into a Grid.
  36.  */
  37. Grid.prototype.initFromArray = function(arr) {
  38.     if (arguments.length !== 1) {
  39.         throw new Error('You should pass exactly 1 argument to ' +
  40.             '<span class="code">initFromArray</span>');
  41.     }
  42.     if (!Array.isArray(arr)) {
  43.         throw new Error('Invalid value passed to <span class="code">' +
  44.             'initFromArray</span>. Make sure you are passing an array.');
  45.     }
  46.     for (var i = 0; i < arr.length; i++) {
  47.         for (var j = 0; j < arr[0].length; j++) {
  48.             if (this.inBounds(i, j)) {
  49.                 this.set(i, j, arr[i][j]);
  50.             }
  51.         }
  52.     }
  53. };
  55. /**
  56.  * Initializes the contents of the grid with `value`.
  57.  * @param {number|string|object|boolean} value - The value to be inserted in all
  58.  * positions of the grid.
  59.  */
  60. Grid.prototype.init = function(value) {
  61.     if (arguments.length !== 1) {
  62.         throw new Error('You should pass exactly 1 argument to ' +
  63.             '<span class="code">init</span>');
  64.     }
  65.     if (typeof value !== 'boolean' && typeof value !== 'number' &&
  66.         typeof value !== 'string' && typeof value !== 'object') {
  67.         throw new TypeError('Invalid value passed to <span class="code">' +
  68.             'init</span>. You passed a value of type ' + typeof value +
  69.             '. Make sure you are passing a number, string, object, or ' +
  70.             'boolean value.');
  71.     }
  72.     if (typeof value === 'number' && !isFinite(value)) {
  73.         throw new TypeError('Non finite number passed to <span class="code">' +
  74.             'init</span>. If you are passing a number, make sure it is a ' +
  75.             'finite number.');
  76.     }
  78.     for (var i = 0; i < this.numRows(); i++) {
  79.         for (var j = 0; j < this.numCols(); j++) {
  80.             this.grid[i][j] = value;
  81.         }
  82.     }
  83. };
  85. /**
  86.  * Gets the object stored at the requested row and column.
  87.  * @param {number} row - The row of the desired object.
  88.  * @param {number} col - The col of the desired object.
  89.  * @returns {number|string|object|boolean} The value stored in the grid
  90.  * at that position.
  91.  */
  92. Grid.prototype.get = function(row, col) {
  93.     if (arguments.length !== 2) {
  94.         throw new Error('You should pass exactly 2 arguments to <span ' +
  95.             'class="code">get(row, col)</span>');
  96.     }
  97.     if (typeof row !== 'number' || !isFinite(row)) {
  98.         throw new TypeError('Invalid value for <span class="code">row' +
  99.             '</span>. Make sure you are passing finite numbers to <span ' +
  100.             'class="code">get(row, col)</span>.');
  101.     }
  102.     if (typeof col !== 'number' || !isFinite(col)) {
  103.         throw new TypeError('Invalid value for <span class="code">col' +
  104.             '</span>. Make sure you are passing finite numbers to <span ' +
  105.             'class="code">get(row, col)</span>.');
  106.     }
  107.     return this.grid[row][col];
  108. };
  110. /**
  111.  * Sets an object at the requested row and column.
  112.  * @param {number} row - The row of the destination of the object.
  113.  * @param {number} col - The column of the destination of the object.
  114.  * @param {number|string|object|boolean} value - The value to be stored at
  115.  * the specified location in the grid
  116.  */
  117. Grid.prototype.set = function(row, col, value) {
  118.     if (arguments.length !== 3) {
  119.         throw new Error('You should pass exactly 3 arguments to <span ' +
  120.             'class="code">set(row, col, value)</span>');
  121.     }
  122.     if (typeof row !== 'number' || !isFinite(row)) {
  123.         throw new TypeError('Invalid value for <span class="code">row' +
  124.             '</span>. You passed a value of type ' + typeof row +
  125.             '. Make sure you are passing a number.');
  126.     }
  127.     if (typeof col !== 'number' || !isFinite(col)) {
  128.         throw new TypeError('Invalid value for <span class="code">col' +
  129.             '</span>. You passed a value of type ' + typeof col +
  130.             '. Make sure you are passing a number.');
  131.     }
  132.     if (typeof value !== 'boolean' && typeof value !== 'number' &&
  133.         typeof value !== 'string' && typeof value !== 'object') {
  134.         throw new TypeError('Invalid value passed to <span class="code">' +
  135.             'set</span>. You passed a value of type ' + typeof value +
  136.             '. Make sure you are passing a number, string, object, or ' +
  137.             'boolean value.');
  138.     }
  139.     if (typeof value === 'number' && !isFinite(value)) {
  140.         throw new TypeError('Non finite value passed to <span class="code">' +
  141.             'set</span>. If you are passing a number, make sure it is a ' +
  142.             'finite number.');
  143.     }
  144.     this.grid[row][col] = value;
  145. };
  147. /**
  148.  * Returns the number of rows in the grid.
  149.  * @returns {number} The number of rows in the grid.
  150.  */
  151. Grid.prototype.numRows = function() {
  152.     return this.grid.length;
  153. };
  155. /**
  156.  * Returns the number of cols in the grid.
  157.  * @returns {number} The number of cols in the grid.
  158.  */
  159. Grid.prototype.numCols = function() {
  160.     return this.grid[0].length;
  161. };
  163. /**
  164.  * Checks whether the given row and col exist in the grid.
  165.  * @param {number} row - Row of the position being checked.
  166.  * @param {number} col - Col of the position being checked.
  167.  * @returns {boolean} Whether or not the given position is in bounds.
  168.  */
  169. Grid.prototype.inBounds = function(row, col) {
  170.     if (arguments.length !== 2) {
  171.         throw new Error('You should pass exactly 2 arguments to <span ' +
  172.             'class="code">inBounds(row, col)</span>');
  173.     }
  174.     if (typeof row !== 'number' || !isFinite(row)) {
  175.         throw new TypeError('Invalid value for <span class="code">row' +
  176.             '</span>. Make sure you are passing finite numbers to <span ' +
  177.             'class="code">inBounds(row, col)</span>.');
  178.     }
  179.     if (typeof col !== 'number' || !isFinite(col)) {
  180.         throw new TypeError('Invalid value for <span class="code">col' +
  181.             '</span>. Make sure you are passing finite numbers to <span ' +
  182.             'class="code">inBounds(row, col)</span>.');
  183.     }
  185.     if (row < 0 || col < 0) {
  186.         return false;
  187.     }
  188.     if (row >= this.numRows() || col >= this.numCols()) {
  189.         return false;
  190.     }
  191.     return true;
  192. };
  194. /**
  195.  * Converts a grid to a list.
  196.  * For example:
  197.  * -------
  198.  * A B C D
  199.  * E F G H
  200.  * I J K L
  201.  * -------
  202.  * would convert to:
  203.  * -------
  204.  * [[0, 0, 'A'], [0, 1, 'B'], [0, 2, 'C'], [0, 3, 'D'], [1, 0, 'E']...[2, 3, 'L']]
  205.  * @returns {array} List representation of the Grid.
  206.  */
  207. Grid.prototype.toList = function() {
  208.     var list = [];
  209.     for (var i = 0; i < this.grid.length; i++) {
  210.         for (var j = 0; j < this.grid[0].length; j++) {
  211.             var value = this.grid[i][j];
  212.             if (value && value !== 0) {
  213.                 list.push([i, j, value]);
  214.             }
  215.         }
  216.     }
  217.     return list;
  218. };
  220. /**
  221.  * Generates a string representation of the Grid.
  222.  * @returns {string} A representatino of a grid of the format
  223.  * "A B C \nD E F \nG H I \n"
  224.  */
  225. Grid.prototype.toString = function() {
  226.     var result = '';
  227.     for (var i = 0; i < this.numRows(); i++) {
  228.         for (var j = 0; j < this.numCols(); j++) {
  229.             result += this.get(i, j) + ' ';
  230.         }
  231.         result += '\n';
  232.     }
  233.     return result;
  234. };
  236. module.exports = Grid;