From f7cb7c094a27c33cecf07dcd2e1bca6790c6d299 Mon Sep 17 00:00:00 2001 From: Gavin McDonald Date: Wed, 17 Feb 2016 10:32:14 -0500 Subject: [PATCH] drawing shapes on a canvas when the user clicks --- .gitignore | 9 + package.json | 17 + public/css/main.css | 278 ++++++++++++++++ public/index.html | 14 + public/js/main.js | 788 ++++++++++++++++++++++++++++++++++++++++++++ src/hex.js | 123 +++++++ src/main.js | 7 + src/onTap.js | 24 ++ src/point.js | 15 + src/sketch.js | 37 +++ src/tessellate.js | 62 ++++ src/tile.js | 11 + src/tileCircle.js | 26 ++ src/tileDiamond.js | 45 +++ src/tileHex.js | 97 ++++++ src/tileSquare.js | 43 +++ src/utils.js | 48 +++ webpack.config.js | 21 ++ 18 files changed, 1665 insertions(+) create mode 100644 .gitignore create mode 100644 package.json create mode 100644 public/css/main.css create mode 100644 public/index.html create mode 100644 public/js/main.js create mode 100644 src/hex.js create mode 100644 src/main.js create mode 100644 src/onTap.js create mode 100644 src/point.js create mode 100644 src/sketch.js create mode 100644 src/tessellate.js create mode 100644 src/tile.js create mode 100644 src/tileCircle.js create mode 100644 src/tileDiamond.js create mode 100644 src/tileHex.js create mode 100644 src/tileSquare.js create mode 100644 src/utils.js create mode 100644 webpack.config.js diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..78e1398 --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +*~ +*.swp +*.pyc +*.pyo +.DS_Store + +node_modules/* +hexmine + diff --git a/package.json b/package.json new file mode 100644 index 0000000..c18e20b --- /dev/null +++ b/package.json @@ -0,0 +1,17 @@ +{ + "name": "tessellate", + "version": "0.0.0", + "description": "", + "main": "index.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "author": "", + "license": "BSD-2-Clause", + "devDependencies": { + "webpack": "~1.12.13", + "babel-loader": "~6.2.2", + "babel-core": "~6.5.2", + "babel-preset-es2015": "~6.5.0" + } +} diff --git a/public/css/main.css b/public/css/main.css new file mode 100644 index 0000000..600fae6 --- /dev/null +++ b/public/css/main.css @@ -0,0 +1,278 @@ +/*! HTML5 Boilerplate v5.2.0 | MIT License | https://html5boilerplate.com/ */ + +/* + * What follows is the result of much research on cross-browser styling. + * Credit left inline and big thanks to Nicolas Gallagher, Jonathan Neal, + * Kroc Camen, and the H5BP dev community and team. + */ + +/* ========================================================================== + Base styles: opinionated defaults + ========================================================================== */ + +html { + color: #222; + font-size: 1em; + line-height: 1.4; +} + +/* + * Remove text-shadow in selection highlight: + * https://twitter.com/miketaylr/status/12228805301 + * + * These selection rule sets have to be separate. + * Customize the background color to match your design. + */ + +::-moz-selection { + background: #b3d4fc; + text-shadow: none; +} + +::selection { + background: #b3d4fc; + text-shadow: none; +} + +/* + * A better looking default horizontal rule + */ + +hr { + display: block; + height: 1px; + border: 0; + border-top: 1px solid #ccc; + margin: 1em 0; + padding: 0; +} + +/* + * Remove the gap between audio, canvas, iframes, + * images, videos and the bottom of their containers: + * https://github.com/h5bp/html5-boilerplate/issues/440 + */ + +audio, +canvas, +iframe, +img, +svg, +video { + vertical-align: middle; +} + +/* + * Remove default fieldset styles. + */ + +fieldset { + border: 0; + margin: 0; + padding: 0; +} + +/* + * Allow only vertical resizing of textareas. + */ + +textarea { + resize: vertical; +} + +/* ========================================================================== + Browser Upgrade Prompt + ========================================================================== */ + +.browserupgrade { + margin: 0.2em 0; + background: #ccc; + color: #000; + padding: 0.2em 0; +} + +/* ========================================================================== + Author's custom styles + ========================================================================== */ + +body { + margin: 0; + padding: 0; + width: 100vw; + height: 100vh; + overflow: hidden; +} + +#container { + width: 100vw; + height: 100vh; + overflow: hidden; +} + +/* ========================================================================== + Helper classes + ========================================================================== */ + +/* + * Hide visually and from screen readers: + */ + +.hidden { + display: none !important; +} + +/* + * Hide only visually, but have it available for screen readers: + * http://snook.ca/archives/html_and_css/hiding-content-for-accessibility + */ + +.visuallyhidden { + border: 0; + clip: rect(0 0 0 0); + height: 1px; + margin: -1px; + overflow: hidden; + padding: 0; + position: absolute; + width: 1px; +} + +/* + * Extends the .visuallyhidden class to allow the element + * to be focusable when navigated to via the keyboard: + * https://www.drupal.org/node/897638 + */ + +.visuallyhidden.focusable:active, +.visuallyhidden.focusable:focus { + clip: auto; + height: auto; + margin: 0; + overflow: visible; + position: static; + width: auto; +} + +/* + * Hide visually and from screen readers, but maintain layout + */ + +.invisible { + visibility: hidden; +} + +/* + * Clearfix: contain floats + * + * For modern browsers + * 1. The space content is one way to avoid an Opera bug when the + * `contenteditable` attribute is included anywhere else in the document. + * Otherwise it causes space to appear at the top and bottom of elements + * that receive the `clearfix` class. + * 2. The use of `table` rather than `block` is only necessary if using + * `:before` to contain the top-margins of child elements. + */ + +.clearfix:before, +.clearfix:after { + content: " "; /* 1 */ + display: table; /* 2 */ +} + +.clearfix:after { + clear: both; +} + +/* ========================================================================== + EXAMPLE Media Queries for Responsive Design. + These examples override the primary ('mobile first') styles. + Modify as content requires. + ========================================================================== */ + +@media only screen and (min-width: 35em) { + /* Style adjustments for viewports that meet the condition */ +} + +@media print, + (-webkit-min-device-pixel-ratio: 1.25), + (min-resolution: 1.25dppx), + (min-resolution: 120dpi) { + /* Style adjustments for high resolution devices */ +} + +/* ========================================================================== + Print styles. + Inlined to avoid the additional HTTP request: + http://www.phpied.com/delay-loading-your-print-css/ + ========================================================================== */ + +@media print { + *, + *:before, + *:after { + background: transparent !important; + color: #000 !important; /* Black prints faster: + http://www.sanbeiji.com/archives/953 */ + box-shadow: none !important; + text-shadow: none !important; + } + + a, + a:visited { + text-decoration: underline; + } + + a[href]:after { + content: " (" attr(href) ")"; + } + + abbr[title]:after { + content: " (" attr(title) ")"; + } + + /* + * Don't show links that are fragment identifiers, + * or use the `javascript:` pseudo protocol + */ + + a[href^="#"]:after, + a[href^="javascript:"]:after { + content: ""; + } + + pre, + blockquote { + border: 1px solid #999; + page-break-inside: avoid; + } + + /* + * Printing Tables: + * http://css-discuss.incutio.com/wiki/Printing_Tables + */ + + thead { + display: table-header-group; + } + + tr, + img { + page-break-inside: avoid; + } + + img { + max-width: 100% !important; + } + + p, + h2, + h3 { + orphans: 3; + widows: 3; + } + + h2, + h3 { + page-break-after: avoid; + } +} diff --git a/public/index.html b/public/index.html new file mode 100644 index 0000000..1987d8f --- /dev/null +++ b/public/index.html @@ -0,0 +1,14 @@ + + + + + + Tessellate + + + +
+ + + + diff --git a/public/js/main.js b/public/js/main.js new file mode 100644 index 0000000..1d4656f --- /dev/null +++ b/public/js/main.js @@ -0,0 +1,788 @@ +(function(e, a) { for(var i in a) e[i] = a[i]; }(this, /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].exports; +/******/ +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.loaded = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _tessellate = __webpack_require__(1); + + var _tessellate2 = _interopRequireDefault(_tessellate); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + var tessellate = new _tessellate2.default({ + element: '#container' + }); + +/***/ }, +/* 1 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + var _utils = __webpack_require__(2); + + var _onTap = __webpack_require__(3); + + var _onTap2 = _interopRequireDefault(_onTap); + + var _point = __webpack_require__(4); + + var _point2 = _interopRequireDefault(_point); + + var _sketch = __webpack_require__(5); + + var _sketch2 = _interopRequireDefault(_sketch); + + var _tileCircle = __webpack_require__(6); + + var _tileCircle2 = _interopRequireDefault(_tileCircle); + + var _tileDiamond = __webpack_require__(8); + + var _tileDiamond2 = _interopRequireDefault(_tileDiamond); + + var _tileHex = __webpack_require__(9); + + var _tileHex2 = _interopRequireDefault(_tileHex); + + var _tileSquare = __webpack_require__(10); + + var _tileSquare2 = _interopRequireDefault(_tileSquare); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var Tessellate = function () { + function Tessellate(settings) { + var _this = this; + + _classCallCheck(this, Tessellate); + + ['draw'].map(function (method) { + _this[method] = _this[method].bind(_this); + }); + + this.element = document.querySelector(settings.element); + + this.sketch = new _sketch2.default({ + element: this.element, + draw: this.draw + }); + + this.map = []; + + this.onTap = new _onTap2.default({ + element: this.element, + click: function click(event) { + var x = event.pageX; + var y = event.pageY; + var tiles = ['circle', 'diamond', 'hex', 'square']; + var styles = ['filled', 'outline']; + var scale = (0, _utils.random)(10, 50); + + _this.map.push({ + tile: tiles[(0, _utils.random)(tiles.length - 1)], + style: styles[(0, _utils.random)(styles.length - 1)], + x: x, + y: y, + scale: scale, + pointy: (0, _utils.random)(1) ? true : false, + color: 'rgba(' + (0, _utils.random)(255) + ', ' + (0, _utils.random)(255) + ', ' + (0, _utils.random)(255) + ', 0.5)' + }); + } + }); + + this.circle = new _tileCircle2.default({ context: this.sketch.getContext() }); + this.diamond = new _tileDiamond2.default({ context: this.sketch.getContext() }); + this.hex = new _tileHex2.default({ context: this.sketch.getContext() }); + this.square = new _tileSquare2.default({ context: this.sketch.getContext() }); + } + + _createClass(Tessellate, [{ + key: 'draw', + value: function draw(context, now, lastTime) { + var _this2 = this; + + var canvas = context.canvas; + var width = canvas.width; + var height = canvas.height; + + context.clearRect(0, 0, width, height); + + this.map.forEach(function (cell) { + return _this2[cell.tile][cell.style](cell); + }); + } + }]); + + return Tessellate; + }(); + + exports.default = Tessellate; + +/***/ }, +/* 2 */ +/***/ function(module, exports) { + + 'use strict'; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.throttleEvent = throttleEvent; + exports.clone = clone; + exports.extend = extend; + exports.hypotenuse = hypotenuse; + exports.random = random; + function throttleEvent(type, name, obj) { + obj = obj || window; + var running = false; + + var throttle = function throttle() { + if (!running) { + running = true; + + requestAnimationFrame(function () { + obj.dispatchEvent(new CustomEvent(name)); + running = false; + }); + } + }; + + obj.addEventListener(type, throttle); + } + + throttleEvent('resize', 'optimizedResize'); + + function clone(obj) { + return JSON.parse(JSON.stringify(obj)); + } + + function extend(obj, src) { + for (var key in src) { + if (src.hasOwnProperty(key)) obj[key] = src[key]; + } + + return obj; + } + + function hypotenuse(a, b) { + if (b == null) b = a; + + return Math.sqrt(a * a + b * b); + } + + function random(min, max) { + if (max == null) { + max = min; + min = 0; + } + + return min + Math.floor(Math.random() * (max - min + 1)); + } + +/***/ }, +/* 3 */ +/***/ function(module, exports) { + + 'use strict'; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var OnTap = function () { + function OnTap(settings) { + var _this = this; + + _classCallCheck(this, OnTap); + + this.element = settings.element || document.body; + + this.callbacks = {}; + + this.events = ['click']; + + this.events.map(function (method) { + _this[method] = _this[method].bind(_this); + + if (typeof settings[method] === 'function') { + _this.element.addEventListener(method, _this[method]); + _this.callbacks[method] = settings[method]; + } + }); + } + + _createClass(OnTap, [{ + key: 'click', + value: function click(event) { + this.callbacks.click(event); + } + }]); + + return OnTap; + }(); + + exports.default = OnTap; + +/***/ }, +/* 4 */ +/***/ function(module, exports) { + + "use strict"; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var Point = function () { + function Point(newX, newY) { + _classCallCheck(this, Point); + + this.x = newX; + this.y = newY; + } + + _createClass(Point, [{ + key: "getX", + value: function getX() { + return this.x; + } + }, { + key: "getY", + value: function getY() { + return this.y; + } + }, { + key: "setX", + value: function setX(newX) { + this.x = newX; + } + }, { + key: "setY", + value: function setY(newY) { + this.y = newY; + } + }, { + key: "getPoint", + value: function getPoint() { + return { x: this.x, y: this.y }; + } + }]); + + return Point; + }(); + + exports.default = Point; + ; + +/***/ }, +/* 5 */ +/***/ function(module, exports) { + + 'use strict'; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + //import {throttleEvent} from './utils.js'; + + var Sketch = function () { + function Sketch(settings) { + var _this = this; + + _classCallCheck(this, Sketch); + + this.lastTime = null; + + ['getContext', 'onResize', 'render'].map(function (method) { + return _this[method] = _this[method].bind(_this); + }); + + this.draw = settings.draw || function () {}; // () => {}; + this.container = settings.element || document.body; + + window.addEventListener('optimizedResize', this.onResize); + window.addEventListener('resize', function () { + return console.log('*** resize ***'); + }); + + this.canvas = document.createElement('canvas'); + this.canvas.width = this.container.offsetWidth; + this.canvas.height = this.container.offsetHeight; + + this.context = this.canvas.getContext('2d'); + + this.container.appendChild(this.canvas); + + requestAnimationFrame(this.render); + } + + _createClass(Sketch, [{ + key: 'getContext', + value: function getContext() { + return this.context; + } + }, { + key: 'onResize', + value: function onResize(event) { + console.log('sketch - onResize', arguments); + } + }, { + key: 'render', + value: function render(now) { + this.draw(this.context, now, this.lastTime); + + this.lastTime = now; + requestAnimationFrame(this.render); + } + }]); + + return Sketch; + }(); + + exports.default = Sketch; + +/***/ }, +/* 6 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + var _tile = __webpack_require__(7); + + var _tile2 = _interopRequireDefault(_tile); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + + function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var RGBA_DEFAULT = 'rgba(0, 0, 0, 0.5)'; + + var TileCircle = function (_Tile) { + _inherits(TileCircle, _Tile); + + function TileCircle(settings) { + _classCallCheck(this, TileCircle); + + return _possibleConstructorReturn(this, Object.getPrototypeOf(TileCircle).call(this, settings)); + } + + _createClass(TileCircle, [{ + key: 'filled', + value: function filled(settings) { + this.context.beginPath(); + this.context.arc(settings.x, settings.y, settings.scale, 0, 2 * Math.PI, false); + this.context.fillStyle = settings.color || RGBA_DEFAULT; + this.context.fill(); + } + }, { + key: 'outline', + value: function outline(settings) { + this.context.beginPath(); + this.context.arc(settings.x, settings.y, settings.scale, 0, 2 * Math.PI, false); + this.context.lineWidth = settings.width ? settings.width : 1; + this.context.strokeStyle = settings.color || RGBA_DEFAULT; + this.context.stroke(); + } + }]); + + return TileCircle; + }(_tile2.default); + + exports.default = TileCircle; + +/***/ }, +/* 7 */ +/***/ function(module, exports) { + + "use strict"; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var Tile = function () { + function Tile(settings) { + _classCallCheck(this, Tile); + + this.context = settings.context || null; + } + + _createClass(Tile, [{ + key: "setContext", + value: function setContext(newContext) { + this.context = newContext || this.context; + } + }]); + + return Tile; + }(); + + exports.default = Tile; + +/***/ }, +/* 8 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + var _tile = __webpack_require__(7); + + var _tile2 = _interopRequireDefault(_tile); + + var _utils = __webpack_require__(2); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + + function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var RGBA_DEFAULT = 'rgba(0, 0, 0, 0.5)'; + + var TileDiamond = function (_Tile) { + _inherits(TileDiamond, _Tile); + + function TileDiamond(settings) { + _classCallCheck(this, TileDiamond); + + return _possibleConstructorReturn(this, Object.getPrototypeOf(TileDiamond).call(this, settings)); + } + + _createClass(TileDiamond, [{ + key: 'filled', + value: function filled(settings) { + var x = settings.x; + var y = settings.y; + var scale = settings.scale; + + this.context.beginPath(); + this.context.moveTo(x + (0, _utils.hypotenuse)(scale), y); + this.context.lineTo(x, y - (0, _utils.hypotenuse)(scale)); + this.context.lineTo(x - (0, _utils.hypotenuse)(scale), y); + this.context.lineTo(x, y + (0, _utils.hypotenuse)(scale)); + + this.context.fillStyle = settings.color || RGBA_DEFAULT; + this.context.fill(); + } + }, { + key: 'outline', + value: function outline(settings) { + var x = settings.x; + var y = settings.y; + var scale = settings.scale; + + this.context.beginPath(); + this.context.moveTo(x + (0, _utils.hypotenuse)(scale), y); + this.context.lineTo(x, y - (0, _utils.hypotenuse)(scale)); + this.context.lineTo(x - (0, _utils.hypotenuse)(scale), y); + this.context.lineTo(x, y + (0, _utils.hypotenuse)(scale)); + this.context.closePath(); + + this.context.lineWidth = settings.width ? settings.width : 1; + this.context.strokeStyle = settings.color || RGBA_DEFAULT; + this.context.stroke(); + } + }]); + + return TileDiamond; + }(_tile2.default); + + exports.default = TileDiamond; + +/***/ }, +/* 9 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + var _tile = __webpack_require__(7); + + var _tile2 = _interopRequireDefault(_tile); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + + function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var RGBA_DEFAULT = 'rgba(0, 0, 0, 0.5)'; + + var TileHex = function (_Tile) { + _inherits(TileHex, _Tile); + + function TileHex(settings) { + _classCallCheck(this, TileHex); + + var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(TileHex).call(this, settings)); + + _this.sqrt3 = Math.sqrt(3); + + _this.hexSides = 6; + _this.pointyTopCornerX = []; + _this.pointyTopCornerY = []; + _this.flatTopCornerX = []; + _this.flatTopCornerY = []; + + // dice dots, 0,0 is center + // TODO: if pointy: [0].concat(flatTop), if flat: [0].concat(pointy) + // this.hexDotX = [0]; + // this.hexDotY = [0]; + + _this.hexSlices = 24; + _this.hexSliceX = [0]; + _this.hexSliceY = [0]; + + for (var hexSlice = 0; hexSlice < _this.hexSlices; hexSlice++) { + _this.hexSliceX[hexSlice] = parseInt(Math.cos(hexSlice / _this.hexSlices * _this.hexSides * (2 * Math.PI) / _this.hexSides) * 1000) / 1000; + _this.hexSliceY[hexSlice] = parseInt(Math.sin(hexSlice / _this.hexSlices * _this.hexSides * (2 * Math.PI) / _this.hexSides) * 1000) / 1000; + + if ((hexSlice - 2) % 4 === 0) { + var cur = (hexSlice - 2) / 4; + _this.pointyTopCornerX[cur] = _this.hexSliceX[hexSlice]; + _this.pointyTopCornerY[cur] = _this.hexSliceY[hexSlice]; + } + + if (hexSlice % 4 === 0) { + var cur = hexSlice / 4; + _this.flatTopCornerX[cur] = _this.hexSliceX[hexSlice]; + _this.flatTopCornerY[cur] = _this.hexSliceY[hexSlice]; + } + + // if (((hexSlice-2) % 4) === 0) { + // let cur = (hexSlice-2) / 4; + // this.hexCornerX[cur] = this.hexSliceX[hexSlice]; + // this.hexCornerY[cur] = this.hexSliceY[hexSlice]; + // } + // + // if ((hexSlice % 4) === 0) { + // let cur = hexSlice / 4; + // this.hexDotX[cur+1] = this.hexSliceX[hexSlice]; + // this.hexDotY[cur+1] = this.hexSliceY[hexSlice]; + // } + } + return _this; + } + + _createClass(TileHex, [{ + key: 'outline', + value: function outline(settings) { + var x = settings.x; + var y = settings.y; + var scale = settings.scale; + var hexCornerX = settings.pointy ? this.pointyTopCornerX : this.flatTopCornerX; + var hexCornerY = settings.pointy ? this.pointyTopCornerY : this.flatTopCornerY; + + this.context.beginPath(); + this.context.moveTo(x + scale * hexCornerX[0], y + scale * hexCornerY[0]); + this.context.lineTo(x + scale * hexCornerX[1], y + scale * hexCornerY[1]); + this.context.lineTo(x + scale * hexCornerX[2], y + scale * hexCornerY[2]); + this.context.lineTo(x + scale * hexCornerX[3], y + scale * hexCornerY[3]); + this.context.lineTo(x + scale * hexCornerX[4], y + scale * hexCornerY[4]); + this.context.lineTo(x + scale * hexCornerX[5], y + scale * hexCornerY[5]); + this.context.closePath(); + + this.context.lineWidth = settings.width ? settings.width : 1; + this.context.strokeStyle = settings.color || RGBA_DEFAULT; + this.context.stroke(); + } + }, { + key: 'filled', + value: function filled(settings) { + var x = settings.x; + var y = settings.y; + var scale = settings.scale; + var hexCornerX = settings.pointy ? this.pointyTopCornerX : this.flatTopCornerX; + var hexCornerY = settings.pointy ? this.pointyTopCornerY : this.flatTopCornerY; + + this.context.beginPath(); + this.context.moveTo(x + scale * hexCornerX[0], y + scale * hexCornerY[0]); + this.context.lineTo(x + scale * hexCornerX[1], y + scale * hexCornerY[1]); + this.context.lineTo(x + scale * hexCornerX[2], y + scale * hexCornerY[2]); + this.context.lineTo(x + scale * hexCornerX[3], y + scale * hexCornerY[3]); + this.context.lineTo(x + scale * hexCornerX[4], y + scale * hexCornerY[4]); + this.context.lineTo(x + scale * hexCornerX[5], y + scale * hexCornerY[5]); + + this.context.fillStyle = settings.color || RGBA_DEFAULT; + this.context.fill(); + } + }]); + + return TileHex; + }(_tile2.default); + + exports.default = TileHex; + +/***/ }, +/* 10 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + var _tile = __webpack_require__(7); + + var _tile2 = _interopRequireDefault(_tile); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + + function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var RGBA_DEFAULT = 'rgba(0, 0, 0, 0.5)'; + + var TileSquare = function (_Tile) { + _inherits(TileSquare, _Tile); + + function TileSquare(settings) { + _classCallCheck(this, TileSquare); + + return _possibleConstructorReturn(this, Object.getPrototypeOf(TileSquare).call(this, settings)); + } + + _createClass(TileSquare, [{ + key: 'filled', + value: function filled(settings) { + var x = settings.x; + var y = settings.y; + var scale = settings.scale; + + this.context.beginPath(); + this.context.moveTo(x + scale, y + scale); + this.context.lineTo(x + scale, y - scale); + this.context.lineTo(x - scale, y - scale); + this.context.lineTo(x - scale, y + scale); + + this.context.fillStyle = settings.color || RGBA_DEFAULT; + this.context.fill(); + } + }, { + key: 'outline', + value: function outline(settings) { + var x = settings.x; + var y = settings.y; + var scale = settings.scale; + + this.context.beginPath(); + this.context.moveTo(x + scale, y + scale); + this.context.lineTo(x + scale, y - scale); + this.context.lineTo(x - scale, y - scale); + this.context.lineTo(x - scale, y + scale); + this.context.closePath(); + + this.context.lineWidth = settings.width ? settings.width : 1; + this.context.strokeStyle = settings.color || RGBA_DEFAULT; + this.context.stroke(); + } + }]); + + return TileSquare; + }(_tile2.default); + + exports.default = TileSquare; + +/***/ } +/******/ ]))); +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["webpack:///webpack/bootstrap 26689b57c83d43c14107","webpack:///./src/main.js","webpack:///./src/tessellate.js","webpack:///./src/utils.js","webpack:///./src/onTap.js","webpack:///./src/point.js","webpack:///./src/sketch.js","webpack:///./src/tileCircle.js","webpack:///./src/tile.js","webpack:///./src/tileDiamond.js","webpack:///./src/tileHex.js","webpack:///./src/tileSquare.js"],"names":[],"mappings":"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","file":"main.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n/** WEBPACK FOOTER **\n ** webpack/bootstrap 26689b57c83d43c14107\n **/","\nimport Tessellate from './tessellate.js';\n\nvar tessellate = new Tessellate({\n\telement: '#container'\n});\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/main.js\n **/","\nimport {random} from './utils.js';\n\nimport OnTap from './onTap.js';\nimport Point from './point.js';\nimport Sketch from './sketch.js';\n\nimport TileCircle from './tileCircle.js';\nimport TileDiamond from './tileDiamond.js';\nimport TileHex    from './tileHex.js';\nimport TileSquare from './tileSquare.js';\n\nexport default class Tessellate {\n\tconstructor(settings) {\n\t\t['draw'].map(method => {this[method] = this[method].bind(this)});\n\n\t\tthis.element = document.querySelector(settings.element);\n\n\t\tthis.sketch = new Sketch({\n\t\t\telement: this.element,\n\t\t\tdraw: this.draw\n\t\t});\n\n\t\tthis.map = [];\n\n\t\tthis.onTap = new OnTap({\n\t\t\telement: this.element,\n\t\t\tclick: (event) => {\n\t\t\t\tlet x = event.pageX;\n\t\t\t\tlet y = event.pageY;\n\t\t\t\tlet tiles = ['circle', 'diamond', 'hex', 'square'];\n\t\t\t\tlet styles = ['filled', 'outline'];\n\t\t\t\tlet scale = random(10, 50);\n\n\t\t\t\tthis.map.push({\n\t\t\t\t\ttile: tiles[random(tiles.length-1)],\n\t\t\t\t\tstyle: styles[random(styles.length-1)],\n\t\t\t\t\tx,\n\t\t\t\t\ty,\n\t\t\t\t\tscale,\n\t\t\t\t\tpointy: random(1) ? true : false,\n\t\t\t\t\tcolor: `rgba(${ random(255) }, ${ random(255) }, ${ random(255) }, 0.5)`\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\n\t\tthis.circle  = new TileCircle({context: this.sketch.getContext()});\n\t\tthis.diamond = new TileDiamond({context: this.sketch.getContext()});\n\t\tthis.hex     = new TileHex({context: this.sketch.getContext()});\n\t\tthis.square  = new TileSquare({context: this.sketch.getContext()});\n\t}\n\n\tdraw(context, now, lastTime) {\n\t\tlet canvas = context.canvas;\n\t\tlet width = canvas.width;\n\t\tlet height = canvas.height;\n\n\t\tcontext.clearRect(0, 0, width, height);\n\n\t\tthis.map.forEach(cell => this[cell.tile][cell.style](cell));\n\t}\n}\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/tessellate.js\n **/","\nexport function throttleEvent(type, name, obj) {\n\tobj = obj || window;\n\tlet running = false;\n\n\tlet throttle = () => {\n\t\tif (!running) {\n\t\t\trunning = true;\n\n\t\t\trequestAnimationFrame(() => {\n\t\t\t\tobj.dispatchEvent(new CustomEvent(name));\n\t\t\t\trunning = false;\n\t\t\t});\n\t\t}\n\t}\n\n\tobj.addEventListener(type, throttle);\n}\n\nthrottleEvent('resize', 'optimizedResize');\n\nexport function clone(obj) {\n\treturn JSON.parse(JSON.stringify(obj));\n}\n\nexport function extend(obj, src) {\n\tfor (let key in src) {\n\t\tif (src.hasOwnProperty(key)) obj[key] = src[key];\n\t}\n\n\treturn obj;\n}\n\nexport function hypotenuse(a, b) {\n\tif (b == null) b = a;\n\n\treturn Math.sqrt(a*a + b*b);\n}\n\nexport function random(min, max) {\n\tif (max == null) {\n\t\tmax = min;\n\t\tmin = 0;\n\t}\n\n\treturn min + Math.floor(Math.random() * (max - min + 1));\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/utils.js\n **/","\nexport default class OnTap {\n\tconstructor(settings) {\n\t\tthis.element = settings.element || document.body;\n\n\t\tthis.callbacks = {};\n\n\t\tthis.events = ['click'];\n\n\t\tthis.events.map(method => {\n\t\t\tthis[method] = this[method].bind(this);\n\n\t\t\tif (typeof settings[method] === 'function') {\n\t\t\t\tthis.element.addEventListener(method, this[method]);\n\t\t\t\tthis.callbacks[method] = settings[method];\n\t\t\t}\n\t\t});\n\t}\n\n\tclick(event) {\n\t\tthis.callbacks.click(event);\n\t}\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/onTap.js\n **/","\nexport default class Point {\n\tconstructor(newX, newY) {\n\t\tthis.x = newX;\n\t\tthis.y = newY;\n\t}\n\n\tgetX() { return this.x; }\n\tgetY() { return this.y; }\n\n\tsetX(newX) { this.x = newX; }\n\tsetY(newY) { this.y = newY; }\n\n\tgetPoint() { return {x: this.x, y: this.y}; }\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/point.js\n **/","\n//import {throttleEvent} from './utils.js';\n\nexport default class Sketch {\n\tconstructor(settings) {\n\t\tthis.lastTime = null;\n\n\t\t['getContext', 'onResize', 'render'].map(method => this[method] = this[method].bind(this));\n\n\t\tthis.draw = settings.draw || function() {}; // () => {};\n\t\tthis.container = settings.element || document.body;\n\n\t\twindow.addEventListener('optimizedResize', this.onResize);\n\t\twindow.addEventListener('resize', () => console.log('*** resize ***'));\n\n\t\tthis.canvas = document.createElement('canvas');\n\t\tthis.canvas.width = this.container.offsetWidth;\n\t\tthis.canvas.height = this.container.offsetHeight;\n\n\t\tthis.context = this.canvas.getContext('2d');\n\n\t\tthis.container.appendChild(this.canvas);\n\n\t\trequestAnimationFrame(this.render);\n\t}\n\n\tgetContext() { return this.context; }\n\n\tonResize(event) {\n\t\tconsole.log('sketch - onResize', arguments);\n\t}\n\n\trender(now) {\n\t\tthis.draw(this.context, now, this.lastTime);\n\n\t\tthis.lastTime = now;\n\t\trequestAnimationFrame(this.render);\n\t}\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/sketch.js\n **/","\nimport Tile from './tile.js';\n\nlet RGBA_DEFAULT = 'rgba(0, 0, 0, 0.5)';\n\nexport default class TileCircle extends Tile {\n\tconstructor(settings) {\n\t\tsuper(settings);\n\t}\n\n\tfilled(settings) {\n\t\tthis.context.beginPath();\n\t\tthis.context.arc(settings.x, settings.y, settings.scale, 0, 2*Math.PI, false);\n\t\tthis.context.fillStyle = settings.color || RGBA_DEFAULT;\n\t\tthis.context.fill();\n\t}\n\n\toutline(settings) {\n\t\tthis.context.beginPath();\n\t\tthis.context.arc(settings.x, settings.y, settings.scale, 0, 2*Math.PI, false);\n\t\tthis.context.lineWidth = settings.width ? settings.width : 1;\n\t\tthis.context.strokeStyle = settings.color || RGBA_DEFAULT;\n\t\tthis.context.stroke();\n\t}\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/tileCircle.js\n **/","\nexport default class Tile {\n\tconstructor(settings) {\n\t\tthis.context = settings.context || null;\n\t}\n\n\tsetContext(newContext) {\n\t\tthis.context = newContext || this.context;\n\t}\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/tile.js\n **/","\nimport Tile from './tile.js';\n\nimport {hypotenuse} from './utils.js';\n\nlet RGBA_DEFAULT = 'rgba(0, 0, 0, 0.5)';\n\nexport default class TileDiamond extends Tile {\n\tconstructor(settings) {\n\t\tsuper(settings);\n\t}\n\n\tfilled(settings) {\n\t\tlet x = settings.x;\n\t\tlet y = settings.y;\n\t\tlet scale = settings.scale;\n\n\t\tthis.context.beginPath();\n\t\tthis.context.moveTo(x+hypotenuse(scale), y);\n\t\tthis.context.lineTo(x, y-hypotenuse(scale));\n\t\tthis.context.lineTo(x-hypotenuse(scale), y);\n\t\tthis.context.lineTo(x, y+hypotenuse(scale));\n\n\t\tthis.context.fillStyle = settings.color || RGBA_DEFAULT;\n\t\tthis.context.fill();\n\t}\n\n\toutline(settings) {\n\t\tlet x = settings.x;\n\t\tlet y = settings.y;\n\t\tlet scale = settings.scale;\n\n\t\tthis.context.beginPath();\n\t\tthis.context.moveTo(x+hypotenuse(scale), y);\n\t\tthis.context.lineTo(x, y-hypotenuse(scale));\n\t\tthis.context.lineTo(x-hypotenuse(scale), y);\n\t\tthis.context.lineTo(x, y+hypotenuse(scale));\n\t\tthis.context.closePath();\n\n\t\tthis.context.lineWidth = settings.width ? settings.width : 1;\n\t\tthis.context.strokeStyle = settings.color || RGBA_DEFAULT;\n\t\tthis.context.stroke();\n\t}\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/tileDiamond.js\n **/","\nimport Tile from './tile.js';\n\nlet RGBA_DEFAULT = 'rgba(0, 0, 0, 0.5)';\n\nexport default class TileHex extends Tile {\n\tconstructor(settings) {\n\t\tsuper(settings);\n\n\t\tthis.sqrt3 = Math.sqrt(3);\n\n\t\tthis.hexSides = 6;\n\t\tthis.pointyTopCornerX = [];\n\t\tthis.pointyTopCornerY = [];\n\t\tthis.flatTopCornerX = [];\n\t\tthis.flatTopCornerY = [];\n\n\t\t// dice dots, 0,0 is center\n\t\t// TODO: if pointy: [0].concat(flatTop), if flat: [0].concat(pointy)\n//\t\tthis.hexDotX = [0];\n//\t\tthis.hexDotY = [0];\n\n\t\tthis.hexSlices = 24;\n\t\tthis.hexSliceX = [0];\n\t\tthis.hexSliceY = [0];\n\n\t\tfor (let hexSlice = 0; hexSlice < this.hexSlices; hexSlice++) {\n\t\t\tthis.hexSliceX[hexSlice] = parseInt(Math.cos(((hexSlice/this.hexSlices)*this.hexSides) * (2 * Math.PI) / this.hexSides) * 1000) / 1000;\n\t\t\tthis.hexSliceY[hexSlice] = parseInt(Math.sin(((hexSlice/this.hexSlices)*this.hexSides) * (2 * Math.PI) / this.hexSides) * 1000) / 1000;\n\n\t\t\tif (((hexSlice-2) % 4) === 0) {\n\t\t\t\tlet cur = (hexSlice-2) / 4;\n\t\t\t\tthis.pointyTopCornerX[cur] = this.hexSliceX[hexSlice];\n\t\t\t\tthis.pointyTopCornerY[cur] = this.hexSliceY[hexSlice];\n\t\t\t}\n\n\t\t\tif ((hexSlice % 4) === 0) {\n\t\t\t\tlet cur = hexSlice / 4;\n\t\t\t\tthis.flatTopCornerX[cur] = this.hexSliceX[hexSlice];\n\t\t\t\tthis.flatTopCornerY[cur] = this.hexSliceY[hexSlice];\n\t\t\t}\n\n//\t\t\tif (((hexSlice-2) % 4) === 0) {\n//\t\t\t\tlet cur = (hexSlice-2) / 4;\n//\t\t\t\tthis.hexCornerX[cur] = this.hexSliceX[hexSlice];\n//\t\t\t\tthis.hexCornerY[cur] = this.hexSliceY[hexSlice];\n//\t\t\t}\n//\n//\t\t\tif ((hexSlice % 4) === 0) {\n//\t\t\t\tlet cur = hexSlice / 4;\n//\t\t\t\tthis.hexDotX[cur+1] = this.hexSliceX[hexSlice];\n//\t\t\t\tthis.hexDotY[cur+1] = this.hexSliceY[hexSlice];\n//\t\t\t}\n\t\t}\n\t}\n\n\toutline(settings) {\n\t\tlet x = settings.x;\n\t\tlet y = settings.y;\n\t\tlet scale = settings.scale;\n\t\tlet hexCornerX = settings.pointy ? this.pointyTopCornerX : this.flatTopCornerX;\n\t\tlet hexCornerY = settings.pointy ? this.pointyTopCornerY : this.flatTopCornerY;\n\n\t\tthis.context.beginPath();\n\t\tthis.context.moveTo(x + scale * hexCornerX[0], y + scale * hexCornerY[0]);\n\t\tthis.context.lineTo(x + scale * hexCornerX[1], y + scale * hexCornerY[1]);\n\t\tthis.context.lineTo(x + scale * hexCornerX[2], y + scale * hexCornerY[2]);\n\t\tthis.context.lineTo(x + scale * hexCornerX[3], y + scale * hexCornerY[3]);\n\t\tthis.context.lineTo(x + scale * hexCornerX[4], y + scale * hexCornerY[4]);\n\t\tthis.context.lineTo(x + scale * hexCornerX[5], y + scale * hexCornerY[5]);\n\t\tthis.context.closePath();\n\n\t\tthis.context.lineWidth = settings.width ? settings.width : 1;\n\t\tthis.context.strokeStyle = settings.color || RGBA_DEFAULT;\n\t\tthis.context.stroke();\n\t}\n\n\tfilled(settings) {\n\t\tlet x = settings.x;\n\t\tlet y = settings.y;\n\t\tlet scale = settings.scale;\n\t\tlet hexCornerX = settings.pointy ? this.pointyTopCornerX : this.flatTopCornerX;\n\t\tlet hexCornerY = settings.pointy ? this.pointyTopCornerY : this.flatTopCornerY;\n\n\t\tthis.context.beginPath();\n\t\tthis.context.moveTo(x + scale * hexCornerX[0], y + scale * hexCornerY[0]);\n\t\tthis.context.lineTo(x + scale * hexCornerX[1], y + scale * hexCornerY[1]);\n\t\tthis.context.lineTo(x + scale * hexCornerX[2], y + scale * hexCornerY[2]);\n\t\tthis.context.lineTo(x + scale * hexCornerX[3], y + scale * hexCornerY[3]);\n\t\tthis.context.lineTo(x + scale * hexCornerX[4], y + scale * hexCornerY[4]);\n\t\tthis.context.lineTo(x + scale * hexCornerX[5], y + scale * hexCornerY[5]);\n\n\t\tthis.context.fillStyle = settings.color || RGBA_DEFAULT;\n\t\tthis.context.fill();\n\t}\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/tileHex.js\n **/","\nimport Tile from './tile.js';\n\nlet RGBA_DEFAULT = 'rgba(0, 0, 0, 0.5)';\n\nexport default class TileSquare extends Tile {\n\tconstructor(settings) {\n\t\tsuper(settings);\n\t}\n\n\tfilled(settings) {\n\t\tlet x = settings.x;\n\t\tlet y = settings.y;\n\t\tlet scale = settings.scale;\n\n\t\tthis.context.beginPath();\n\t\tthis.context.moveTo(x+scale, y+scale);\n\t\tthis.context.lineTo(x+scale, y-scale);\n\t\tthis.context.lineTo(x-scale, y-scale);\n\t\tthis.context.lineTo(x-scale, y+scale);\n\n\t\tthis.context.fillStyle = settings.color || RGBA_DEFAULT;\n\t\tthis.context.fill();\n\t}\n\n\toutline(settings) {\n\t\tlet x = settings.x;\n\t\tlet y = settings.y;\n\t\tlet scale = settings.scale;\n\n\t\tthis.context.beginPath();\n\t\tthis.context.moveTo(x+scale, y+scale);\n\t\tthis.context.lineTo(x+scale, y-scale);\n\t\tthis.context.lineTo(x-scale, y-scale);\n\t\tthis.context.lineTo(x-scale, y+scale);\n\t\tthis.context.closePath();\n\n\t\tthis.context.lineWidth = settings.width ? settings.width : 1;\n\t\tthis.context.strokeStyle = settings.color || RGBA_DEFAULT;\n\t\tthis.context.stroke();\n\t}\n}\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/tileSquare.js\n **/"],"sourceRoot":""} \ No newline at end of file diff --git a/src/hex.js b/src/hex.js new file mode 100644 index 0000000..5e9dbac --- /dev/null +++ b/src/hex.js @@ -0,0 +1,123 @@ + +import Point from './point.js'; + +function computeY(x, z) { + return -x - z; +} + +// convert real numbers to integers: +// round off coords +// throw out whichever one changed the most +// re-establish "x + y + z = 0" +function roundOff(x, y, z) { + let rX = Math.round(x); + let rY = Math.round(y); + let rZ = Math.round(z); + + let xDiff = Math.abs(rX - x); + let yDiff = Math.abs(rY - y); + let zDiff = Math.abs(rZ - z); + + if ((xDiff > yDiff) && (xDiff > zDiff)) { + rX = -rY-rZ; + } + else if (yDiff > zDiff) { + rY = -rX-rZ; + } + else { + rZ = -rX-rY; + } + + x = rX === -0 ? 0 : rX; + y = rY === -0 ? 0 : rY; + z = rZ === -0 ? 0 : rZ; + + return {x, y, z}; +} + +export default class Hex extends Point { + + constructor() { + super(); + + if (arguments.length === 2) { // hex = Hex(q, r); + this.x = arguments[0]; + this.z = arguments[1]; + this.y = computeY(this.x, this.z); + } + else if (arguments.length === 3) { // hex = Hex(x, y, z); + this.x = arguments[0]; + this.y = arguments[1]; + this.z = arguments[2]; + } + + roundOff(this.x, this.y, this.z); + } + + return { + getX: function() {return this.x;}, + getY: function() {return this.y;}, + getZ: function() {return this.z;}, + + setX: function(newX) {this.x = newX; return this;}, + setY: function(newY) {this.y = newY; return this;}, + setZ: function(newZ) {this.z = newZ; return this;}, + + moveX: function(byX) {this.x += byX; return this;}, + moveY: function(byY) {this.y += byY; return this;}, + moveZ: function(byZ) {this.z += byZ; return this;}, + + getQ: function() {return this.x;}, + getR: function() {return this.z;}, + + setQ: function(newQ) { + this.x = newQ; + this.y = computeY(this.x, this.z); + return this; + }, + setR: function(newR) { + this.z = newR; + this.y = computeY(this.x, this.z); + return this; + }, + + moveQ: function(byQ) { + this.x += byQ; + this.y = computeY(this.x, this.z); + return this; + }, + moveR: function(byR) { + this.z += byR; + this.y = computeY(this.x, this.z); + return this; + }, + + getHex: function() { return {x: this.x, y: this.y, z: this.z}; }, + setHex: function(newHex) { + this.x = newHex.x; + this.y = newHex.y; + this.z = newHex.z; + return this; + }, + moveHex: function(byHex) { + this.x += byHex.x; + this.y += byHex.y; + this.z += byHex.z; + return this; + }, + + getAxial: function() {return {x: this.x, z: this.z};}, + setAxial: function(newAxial) { + this.x = newAxial.q; + this.z = newAxial.r; + this.y = computeY(this.x, this.y); + return this; + }, + moveAxial: function(byAxial) { + this.x += byAxial.q; + this.z += byAxial.r; + this.y = computeY(this.x, this.z); + return this; + } + }; +}; diff --git a/src/main.js b/src/main.js new file mode 100644 index 0000000..a047e0c --- /dev/null +++ b/src/main.js @@ -0,0 +1,7 @@ + +import Tessellate from './tessellate.js'; + +var tessellate = new Tessellate({ + element: '#container' +}); + diff --git a/src/onTap.js b/src/onTap.js new file mode 100644 index 0000000..f09fd0f --- /dev/null +++ b/src/onTap.js @@ -0,0 +1,24 @@ + +export default class OnTap { + constructor(settings) { + this.element = settings.element || document.body; + + this.callbacks = {}; + + this.events = ['click']; + + this.events.map(method => { + this[method] = this[method].bind(this); + + if (typeof settings[method] === 'function') { + this.element.addEventListener(method, this[method]); + this.callbacks[method] = settings[method]; + } + }); + } + + click(event) { + this.callbacks.click(event); + } +} + diff --git a/src/point.js b/src/point.js new file mode 100644 index 0000000..c5f9e33 --- /dev/null +++ b/src/point.js @@ -0,0 +1,15 @@ + +export default class Point { + constructor(newX, newY) { + this.x = newX; + this.y = newY; + } + + getX() { return this.x; } + getY() { return this.y; } + + setX(newX) { this.x = newX; } + setY(newY) { this.y = newY; } + + getPoint() { return {x: this.x, y: this.y}; } +}; diff --git a/src/sketch.js b/src/sketch.js new file mode 100644 index 0000000..6894595 --- /dev/null +++ b/src/sketch.js @@ -0,0 +1,37 @@ + +export default class Sketch { + constructor(settings) { + this.lastTime = null; + + ['getContext', 'onResize', 'render'].map(method => this[method] = this[method].bind(this)); + + this.draw = settings.draw || function() {}; // () => {}; + this.container = settings.element || document.body; + + window.addEventListener('optimizedResize', this.onResize); + + this.canvas = document.createElement('canvas'); + this.canvas.width = this.container.offsetWidth; + this.canvas.height = this.container.offsetHeight; + + this.context = this.canvas.getContext('2d'); + + this.container.appendChild(this.canvas); + + requestAnimationFrame(this.render); + } + + getContext() { return this.context; } + + onResize(event) { + console.log('sketch - onResize', arguments); + } + + render(now) { + this.draw(this.context, now, this.lastTime); + + this.lastTime = now; + requestAnimationFrame(this.render); + } +} + diff --git a/src/tessellate.js b/src/tessellate.js new file mode 100644 index 0000000..04f1d0e --- /dev/null +++ b/src/tessellate.js @@ -0,0 +1,62 @@ + +import {random} from './utils.js'; + +import OnTap from './onTap.js'; +import Point from './point.js'; +import Sketch from './sketch.js'; + +import TileCircle from './tileCircle.js'; +import TileDiamond from './tileDiamond.js'; +import TileHex from './tileHex.js'; +import TileSquare from './tileSquare.js'; + +export default class Tessellate { + constructor(settings) { + ['draw'].map(method => {this[method] = this[method].bind(this)}); + + this.element = document.querySelector(settings.element); + + this.sketch = new Sketch({ + element: this.element, + draw: this.draw + }); + + this.map = []; + + this.onTap = new OnTap({ + element: this.element, + click: (event) => { + let x = event.pageX; + let y = event.pageY; + let tiles = ['circle', 'diamond', 'hex', 'square']; + let styles = ['filled', 'outline']; + let scale = random(10, 50); + + this.map.push({ + tile: tiles[random(tiles.length-1)], + style: styles[random(styles.length-1)], + x, + y, + scale, + pointy: random(1) ? true : false, + color: `rgba(${ random(255) }, ${ random(255) }, ${ random(255) }, 0.5)` + }); + } + }); + + this.circle = new TileCircle({context: this.sketch.getContext()}); + this.diamond = new TileDiamond({context: this.sketch.getContext()}); + this.hex = new TileHex({context: this.sketch.getContext()}); + this.square = new TileSquare({context: this.sketch.getContext()}); + } + + draw(context, now, lastTime) { + let canvas = context.canvas; + let width = canvas.width; + let height = canvas.height; + + context.clearRect(0, 0, width, height); + + this.map.forEach(cell => this[cell.tile][cell.style](cell)); + } +} diff --git a/src/tile.js b/src/tile.js new file mode 100644 index 0000000..d123178 --- /dev/null +++ b/src/tile.js @@ -0,0 +1,11 @@ + +export default class Tile { + constructor(settings) { + this.context = settings.context || null; + } + + setContext(newContext) { + this.context = newContext || this.context; + } +} + diff --git a/src/tileCircle.js b/src/tileCircle.js new file mode 100644 index 0000000..240806e --- /dev/null +++ b/src/tileCircle.js @@ -0,0 +1,26 @@ + +import Tile from './tile.js'; + +let RGBA_DEFAULT = 'rgba(0, 0, 0, 0.5)'; + +export default class TileCircle extends Tile { + constructor(settings) { + super(settings); + } + + filled(settings) { + this.context.beginPath(); + this.context.arc(settings.x, settings.y, settings.scale, 0, 2*Math.PI, false); + this.context.fillStyle = settings.color || RGBA_DEFAULT; + this.context.fill(); + } + + outline(settings) { + this.context.beginPath(); + this.context.arc(settings.x, settings.y, settings.scale, 0, 2*Math.PI, false); + this.context.lineWidth = settings.width ? settings.width : 1; + this.context.strokeStyle = settings.color || RGBA_DEFAULT; + this.context.stroke(); + } +} + diff --git a/src/tileDiamond.js b/src/tileDiamond.js new file mode 100644 index 0000000..1f9f92f --- /dev/null +++ b/src/tileDiamond.js @@ -0,0 +1,45 @@ + +import Tile from './tile.js'; + +import {hypotenuse} from './utils.js'; + +let RGBA_DEFAULT = 'rgba(0, 0, 0, 0.5)'; + +export default class TileDiamond extends Tile { + constructor(settings) { + super(settings); + } + + filled(settings) { + let x = settings.x; + let y = settings.y; + let scale = settings.scale; + + this.context.beginPath(); + this.context.moveTo(x+hypotenuse(scale), y); + this.context.lineTo(x, y-hypotenuse(scale)); + this.context.lineTo(x-hypotenuse(scale), y); + this.context.lineTo(x, y+hypotenuse(scale)); + + this.context.fillStyle = settings.color || RGBA_DEFAULT; + this.context.fill(); + } + + outline(settings) { + let x = settings.x; + let y = settings.y; + let scale = settings.scale; + + this.context.beginPath(); + this.context.moveTo(x+hypotenuse(scale), y); + this.context.lineTo(x, y-hypotenuse(scale)); + this.context.lineTo(x-hypotenuse(scale), y); + this.context.lineTo(x, y+hypotenuse(scale)); + this.context.closePath(); + + this.context.lineWidth = settings.width ? settings.width : 1; + this.context.strokeStyle = settings.color || RGBA_DEFAULT; + this.context.stroke(); + } +} + diff --git a/src/tileHex.js b/src/tileHex.js new file mode 100644 index 0000000..4b8a071 --- /dev/null +++ b/src/tileHex.js @@ -0,0 +1,97 @@ + +import Tile from './tile.js'; + +let RGBA_DEFAULT = 'rgba(0, 0, 0, 0.5)'; + +export default class TileHex extends Tile { + constructor(settings) { + super(settings); + + this.sqrt3 = Math.sqrt(3); + + this.hexSides = 6; + this.pointyTopCornerX = []; + this.pointyTopCornerY = []; + this.flatTopCornerX = []; + this.flatTopCornerY = []; + + // dice dots, 0,0 is center + // TODO: if pointy: [0].concat(flatTop), if flat: [0].concat(pointy) +// this.hexDotX = [0]; +// this.hexDotY = [0]; + + this.hexSlices = 24; + this.hexSliceX = [0]; + this.hexSliceY = [0]; + + for (let hexSlice = 0; hexSlice < this.hexSlices; hexSlice++) { + this.hexSliceX[hexSlice] = parseInt(Math.cos(((hexSlice/this.hexSlices)*this.hexSides) * (2 * Math.PI) / this.hexSides) * 1000) / 1000; + this.hexSliceY[hexSlice] = parseInt(Math.sin(((hexSlice/this.hexSlices)*this.hexSides) * (2 * Math.PI) / this.hexSides) * 1000) / 1000; + + if (((hexSlice-2) % 4) === 0) { + let cur = (hexSlice-2) / 4; + this.pointyTopCornerX[cur] = this.hexSliceX[hexSlice]; + this.pointyTopCornerY[cur] = this.hexSliceY[hexSlice]; + } + + if ((hexSlice % 4) === 0) { + let cur = hexSlice / 4; + this.flatTopCornerX[cur] = this.hexSliceX[hexSlice]; + this.flatTopCornerY[cur] = this.hexSliceY[hexSlice]; + } + +// if (((hexSlice-2) % 4) === 0) { +// let cur = (hexSlice-2) / 4; +// this.hexCornerX[cur] = this.hexSliceX[hexSlice]; +// this.hexCornerY[cur] = this.hexSliceY[hexSlice]; +// } +// +// if ((hexSlice % 4) === 0) { +// let cur = hexSlice / 4; +// this.hexDotX[cur+1] = this.hexSliceX[hexSlice]; +// this.hexDotY[cur+1] = this.hexSliceY[hexSlice]; +// } + } + } + + outline(settings) { + let x = settings.x; + let y = settings.y; + let scale = settings.scale; + let hexCornerX = settings.pointy ? this.pointyTopCornerX : this.flatTopCornerX; + let hexCornerY = settings.pointy ? this.pointyTopCornerY : this.flatTopCornerY; + + this.context.beginPath(); + this.context.moveTo(x + scale * hexCornerX[0], y + scale * hexCornerY[0]); + this.context.lineTo(x + scale * hexCornerX[1], y + scale * hexCornerY[1]); + this.context.lineTo(x + scale * hexCornerX[2], y + scale * hexCornerY[2]); + this.context.lineTo(x + scale * hexCornerX[3], y + scale * hexCornerY[3]); + this.context.lineTo(x + scale * hexCornerX[4], y + scale * hexCornerY[4]); + this.context.lineTo(x + scale * hexCornerX[5], y + scale * hexCornerY[5]); + this.context.closePath(); + + this.context.lineWidth = settings.width ? settings.width : 1; + this.context.strokeStyle = settings.color || RGBA_DEFAULT; + this.context.stroke(); + } + + filled(settings) { + let x = settings.x; + let y = settings.y; + let scale = settings.scale; + let hexCornerX = settings.pointy ? this.pointyTopCornerX : this.flatTopCornerX; + let hexCornerY = settings.pointy ? this.pointyTopCornerY : this.flatTopCornerY; + + this.context.beginPath(); + this.context.moveTo(x + scale * hexCornerX[0], y + scale * hexCornerY[0]); + this.context.lineTo(x + scale * hexCornerX[1], y + scale * hexCornerY[1]); + this.context.lineTo(x + scale * hexCornerX[2], y + scale * hexCornerY[2]); + this.context.lineTo(x + scale * hexCornerX[3], y + scale * hexCornerY[3]); + this.context.lineTo(x + scale * hexCornerX[4], y + scale * hexCornerY[4]); + this.context.lineTo(x + scale * hexCornerX[5], y + scale * hexCornerY[5]); + + this.context.fillStyle = settings.color || RGBA_DEFAULT; + this.context.fill(); + } +} + diff --git a/src/tileSquare.js b/src/tileSquare.js new file mode 100644 index 0000000..09fa3c4 --- /dev/null +++ b/src/tileSquare.js @@ -0,0 +1,43 @@ + +import Tile from './tile.js'; + +let RGBA_DEFAULT = 'rgba(0, 0, 0, 0.5)'; + +export default class TileSquare extends Tile { + constructor(settings) { + super(settings); + } + + filled(settings) { + let x = settings.x; + let y = settings.y; + let scale = settings.scale; + + this.context.beginPath(); + this.context.moveTo(x+scale, y+scale); + this.context.lineTo(x+scale, y-scale); + this.context.lineTo(x-scale, y-scale); + this.context.lineTo(x-scale, y+scale); + + this.context.fillStyle = settings.color || RGBA_DEFAULT; + this.context.fill(); + } + + outline(settings) { + let x = settings.x; + let y = settings.y; + let scale = settings.scale; + + this.context.beginPath(); + this.context.moveTo(x+scale, y+scale); + this.context.lineTo(x+scale, y-scale); + this.context.lineTo(x-scale, y-scale); + this.context.lineTo(x-scale, y+scale); + this.context.closePath(); + + this.context.lineWidth = settings.width ? settings.width : 1; + this.context.strokeStyle = settings.color || RGBA_DEFAULT; + this.context.stroke(); + } +} + diff --git a/src/utils.js b/src/utils.js new file mode 100644 index 0000000..ad815f2 --- /dev/null +++ b/src/utils.js @@ -0,0 +1,48 @@ + +export function throttleEvent(type, name, obj) { + obj = obj || window; + let running = false; + + let throttle = () => { + if (!running) { + running = true; + + requestAnimationFrame(() => { + obj.dispatchEvent(new CustomEvent(name)); + running = false; + }); + } + } + + obj.addEventListener(type, throttle); +} + +throttleEvent('resize', 'optimizedResize'); + +export function clone(obj) { + return JSON.parse(JSON.stringify(obj)); +} + +export function extend(obj, src) { + for (let key in src) { + if (src.hasOwnProperty(key)) obj[key] = src[key]; + } + + return obj; +} + +export function hypotenuse(a, b) { + if (b == null) b = a; + + return Math.sqrt(a*a + b*b); +} + +export function random(min, max) { + if (max == null) { + max = min; + min = 0; + } + + return min + Math.floor(Math.random() * (max - min + 1)); +} + diff --git a/webpack.config.js b/webpack.config.js new file mode 100644 index 0000000..7bb8c12 --- /dev/null +++ b/webpack.config.js @@ -0,0 +1,21 @@ +var path = require('path'); + +module.exports = { + entry: path.join(__dirname, 'src', 'main.js'), + output: { + libraryTarget: 'this', + path: path.join(__dirname, 'public', 'js'), + filename: 'main.js' + }, + devtool: 'inline-source-map', + module: { + loaders: [{ + test: path.join(__dirname, 'src'), + loader: 'babel-loader', + query: { + presets: ['es2015'] + } + }] + } +}; +