graphics/thing.js

  1. 'use strict';
  3. /**
  4.  * @constructor
  5.  */
  6. function Thing() {
  7.     this.x = 0;
  8.     this.y = 0;
  9.     this.color = '#000000';
  10.     this.stroke = '#000000';
  11.     this.type = 'Thing';
  12.     this.lineWidth = 1;
  13.     this.filled = true;
  14.     this.hasBorder = false;
  15.     this.rotation = 0;
  16. }
  18. Thing.DEGREES = 0;
  19. Thing.RADIANS = 1;
  21. /**
  22.  * Sets a Thing object to filled.
  23.  * Throws an error if an argument is not passed.
  24.  *
  25.  * @param {bool} filled - A boolean of whether or not Thing is filled.
  26.  */
  27. Thing.prototype.setFilled = function(filled) {
  28.     if (arguments.length !== 1) {
  29.         throw new Error('You should pass exactly 1 argument to ' +
  30.             '<span class="code">setFilled</span>');
  31.     }
  32.     if (typeof filled !== 'boolean') {
  33.         throw new Error('Invalid value passed to <span class="code">' +
  34.             'setFilled</span>. Make sure you are passing a ' +
  35.             'boolean value.');
  36.     }
  37.     this.filled = filled;
  38. };
  40. /**
  41.  * Returns if a Thing is filled.
  42.  *
  43.  * @returns {boolean} True if the Thing is filled.
  44.  */
  45. Thing.prototype.isFilled = function() {
  46.     return this.filled;
  47. };
  49. /**
  50.  * Sets a Thing object to filled.
  51.  * Throws an error if an argument is not passed.
  52.  *
  53.  * @param {bool} hasBorder - A boolean of whether or not Thing has a border.
  54.  */
  55. Thing.prototype.setBorder = function(hasBorder) {
  56.     if (arguments.length !== 1) {
  57.         throw new Error('You should pass exactly 1 argument to <span class=' +
  58.             '"code">setBorder</span>');
  59.     }
  60.     if (typeof hasBorder !== 'boolean') {
  61.         throw new Error('Invalid value passed to <span class="code">' +
  62.             'setBorder</span>. Make sure you are passing a ' +
  63.             'boolean value.');
  64.     }
  65.     this.hasBorder = hasBorder;
  66. };
  68. /**
  69.  * Returns if a Thing has a border.
  70.  *
  71.  * @returns {boolean} True if the Thing has a border.
  72.  */
  73. Thing.prototype.hasBorder = function() {
  74.     return this.hasBorder;
  75. };
  77. /**
  78.  * Sets a Thing object's type.
  79.  * Questionable of whether or not this method is used.
  80.  *
  81.  * @param {type} type - A type to set the Thing to.
  82.  */
  83. Thing.prototype.setType = function(type) {
  84.     if (arguments.length !== 1) {
  85.         throw new Error('You should pass exactly 1 argument to <span ' +
  86.             'class="code">setType</span>');
  87.     }
  88.     this.type = type;
  89. };
  91. /**
  92.  * Returns the type of a Thing.
  93.  *
  94.  * @returns {type} The type of the Thing.
  95.  */
  96. Thing.prototype.getType = function() {
  97.     return this.type;
  98. };
  100. /**
  101.  * Sets the position of a Thing.
  102.  * Throws an error if there are fewer than 2 params or if
  103.  * they are not numbers.
  104.  *
  105.  * @param {number} x - The destination x coordinate of this Thing.
  106.  * @param {number} y - The destination y coordinate of this Thing.
  107.  */
  108. Thing.prototype.setPosition = function(x, y) {
  109.     if (arguments.length !== 2) {
  110.         throw new Error('You should pass exactly 2 arguments to <span ' +
  111.             'class="code">setPosition(x, y)</span>');
  112.     }
  113.     if (typeof x !== 'number' || !isFinite(x)) {
  114.         throw new TypeError('Invalid value for x-coordinate. ' +
  115.             'Make sure you are passing finite numbers to <span ' +
  116.             'class="code">setPosition(x, y)</span>. Did you ' +
  117.             'forget the parentheses in <span class="code">getWidth()</span> ' +
  118.             'or <span class="code">getHeight()</span>? Or did you perform a ' +
  119.             'calculation on a variable that is not a number?');
  120.     }
  121.     if (typeof y !== 'number' || !isFinite(y)) {
  122.         throw new TypeError('Invalid value for y-coordinate. ' +
  123.             'Make sure you are passing finite numbers to <span ' +
  124.             'class="code">setPosition(x, y)</span>. Did you ' +
  125.             'forget the parentheses in <span class="code">getWidth()</span> ' +
  126.             'or <span class="code">getHeight()</span>? Or did you perform a ' +
  127.             'calculation on a variable that is not a number?');
  128.     }
  129.     this.x = x;
  130.     this.y = y;
  131. };
  133. /**
  134.  * Sets the rotation of a Thing in degrees.
  135.  * Throws an error if there are fewer than 1 params or if they
  136.  * are not numbers.
  137.  *
  138.  * @param {number} degrees - The degrees to rotate degrees.
  139.  * @param {number} angleUnit - Whether it is degrees or radians. Defaults to
  140.  *                             degrees.
  141.  */
  142. Thing.prototype.setRotation = function(degrees, angleUnit) {
  143.     if (arguments.length < 1 || arguments.length > 2) {
  144.         throw new Error('You should pass 1 or 2 arguments to <span ' +
  145.             'class="code">setRotation(degrees, angleUnit)</span>');
  146.     }
  147.     if (typeof degrees !== 'number' || !isFinite(degrees)) {
  148.         throw new TypeError('Invalid value for degrees. ' +
  149.             'Make sure you are passing finite numbers to <span ' +
  150.             'class="code">setRotation(degrees, angleUnit)</span>. Did you ' +
  151.             'perform a calculation on a variable that is not a number?');
  152.     }
  153.     if (!angleUnit) {
  154.         angleUnit = Thing.DEGREES;
  155.     }
  156.     if (typeof angleUnit !== 'number' || !isFinite(angleUnit)) {
  157.         throw new TypeError('Invalid value for <span class="code">angleUnit' +
  158.             '</span>. Make sure you are passing finite numbers to <span ' +
  159.             'class="code">setRotation(degrees, angleUnit)</span>');
  160.     }
  161.     if (angleUnit == Thing.DEGREES) {
  162.         this.rotation = degrees * Math.PI / 180;
  163.     } else {
  164.         this.rotation = degrees;
  165.     }
  166. };
  168. /**
  169.  * Rotates a Thing an additional amount of degrees.
  170.  *
  171.  * @param {number} degrees - The degrees to rotate degrees.
  172.  * @param {number} angleUnit - Whether it is degrees or radians. Defaults to
  173.  *                             degrees.
  174.  */
  175. Thing.prototype.rotate = function(degrees, angleUnit) {
  176.     if (arguments.length < 1 || arguments.length > 2) {
  177.         throw new Error('You should pass exactly 1 argument to <span ' +
  178.             'class="code">rotate(degrees, angleUnit)</span>');
  179.     }
  180.     if (typeof degrees !== 'number' || !isFinite(degrees)) {
  181.         throw new TypeError('Invalid value for degrees. ' +
  182.             'Make sure you are passing finite numbers to <span ' +
  183.             'class="code">rotate(degrees, angleUnit)</span>. Did you perform ' +
  184.             'a calculation on a variable that is not a number?');
  185.     }
  186.     if (!angleUnit) {
  187.         angleUnit = Thing.DEGREES;
  188.     }
  189.     if (typeof angleUnit !== 'number' || !isFinite(angleUnit)) {
  190.         throw new TypeError('Invalid value for <span class="code">angleUnit' +
  191.             '</span>. Make sure you are passing finite numbers to <span ' +
  192.             'class="code">rotate(degrees, angleUnit)</span>');
  193.     }
  194.     if (angleUnit == Thing.DEGREES) {
  195.         this.rotation += degrees * Math.PI / 180;
  196.     } else {
  197.         this.rotation += degrees;
  198.     }
  199. };
  201. /**
  202.  * Sets the color of a Thing.
  203.  * Throws an error if there are fewer than 1 params or if
  204.  * the param is undefined.
  205.  *
  206.  * @param {Color} color - The resulting color of Thing.
  207.  */
  208. Thing.prototype.setColor = function(color) {
  209.     if (arguments.length !== 1) {
  210.         throw new Error('You should pass exactly 1 argument to <span ' +
  211.             'class="code">setColor</span>');
  212.     }
  213.     if (color === undefined) {
  214.         throw new TypeError('Invalid color');
  215.     }
  216.     this.color = color;
  217. };
  219. /**
  220.  * Gets the color of a Thing.
  221.  *
  222.  * @returns {Color} The destination y coordinate of this Thing.
  223.  */
  224. Thing.prototype.getColor = function() {
  225.     return this.color;
  226. };
  228. /**
  229.  * Sets the border color of a Thing.
  230.  * Throws an error if there are fewer than 1 params or if
  231.  * the param is undefined.
  232.  *
  233.  * @param {Color} color - The resulting color of the Thing's border.
  234.  */
  235. Thing.prototype.setBorderColor = function(color) {
  236.     if (arguments.length !== 1) {
  237.         throw new Error('You should pass exactly 1 argument to <span ' +
  238.             'class="code">setBorderColor</span>');
  239.     }
  240.     if (color === undefined) {
  241.         throw new TypeError('Invalid color.');
  242.     }
  243.     this.stroke = color;
  244.     this.hasBorder = true;
  245. };
  248. /**
  249.  * Gets the border color of a Thing.
  250.  *
  251.  * @returns {Color} The color of the Thing's border.
  252.  */
  253. Thing.prototype.getBorderColor = function() {
  254.     return this.stroke;
  255. };
  257. /**
  258.  * Sets the width of a Thing's border.
  259.  * Throws an error if there is not 1 argument.
  260.  *
  261.  * @param {number} width - The resulting width of the Thing's border.
  262.  */
  263. Thing.prototype.setBorderWidth = function(width) {
  264.     if (arguments.length !== 1) {
  265.         throw new Error('You should pass exactly 1 argument to <span ' +
  266.             'class="code">setBorderWidth</span>');
  267.     }
  268.     if (typeof width !== 'number' || !isFinite(width)) {
  269.         throw new Error('Invalid value for border width. Make sure you are ' +
  270.             'passing a finite number to <span class="code">' +
  271.             'setBorderWidth</span>');
  272.     }
  273.     this.lineWidth = width;
  274.     this.hasBorder = true;
  275. };
  277. /**
  278.  * Gets the width of the Thing's border.
  279.  *
  280.  * @returns {number} The width of the Thing's border.
  281.  */
  282. Thing.prototype.getBorderWidth = function() {
  283.     return this.lineWidth;
  284. };
  286. /**
  287.  * Changes the possition of a thing by a specified x and y amount.
  288.  *
  289.  * @param {number} dx - The resulting change in the Thing's x position.
  290.  * @param {number} dy - The resulting change in the Thing's y position.
  291.  */
  292. Thing.prototype.move = function(dx, dy) {
  293.     if (arguments.length !== 2) {
  294.         throw new Error('You should pass exactly 2 arguments to <span ' +
  295.             'class="code">move</span>');
  296.     }
  297.     if (typeof dx !== 'number' || !isFinite(dx)) {
  298.         throw new TypeError('Invalid number passed for <span class="code">' +
  299.             'dx</span>. Make sure you are passing finite numbers to <span ' +
  300.             'class="code">move(dx, dy)</span>');
  301.     }
  302.     if (typeof dy !== 'number' || !isFinite(dy)) {
  303.         throw new TypeError('Invalid number passed for <span class="code">' +
  304.             'dy</span>. Make sure you are passing finite numbers to <span ' +
  305.             'class="code">move(dx, dy)</span>');
  306.     }
  307.     this.x += dx;
  308.     this.y += dy;
  309. };
  311. /**
  312.  * Gets the x position of the Thing.
  313.  *
  314.  * @returns {number} The x position of the Thing.
  315.  */
  316. Thing.prototype.getX = function() {
  317.     return this.x;
  318. };
  320. /**
  321.  * Gets the y position of the Thing.
  322.  *
  323.  * @returns {number} The y position of the Thing.
  324.  */
  325. Thing.prototype.getY = function() {
  326.     return this.y;
  327. };
  329. /**
  330.  * This function is overridden in subclasses of Thing.
  331.  */
  332. Thing.prototype.draw = function() {
  334. };
  336. /**
  337.  * Check if a given point is within the Thing.
  338.  * This function only works in subclasses of Thing.
  339.  *
  340.  * @param {number} x - The x coordinate of the point being checked.
  341.  * @param {number} y - The y coordinate of the point being checked.
  342.  * @returns {boolean} Whether the point x, y is within the Thing.
  343.  */
  344. Thing.prototype.containsPoint = function(x, y) {
  345.     return false;
  346. };
  348. module.exports = Thing;