=3)Object.defineProperty(t,n,{get:function(){return delete this[n],this[n]=r.call(this)},configurable:!0,enumerable:!0});else if(2===arguments.length)for(var s in n)e.lazy(t,s,n[s]);return t},live:function(t,n,r){if(arguments.length>=3)Object.defineProperty(t,n,{get:function(){var t=this["_"+n],e=r.get&&r.get.call(this,t);return void 0!==e?e:t},set:function(t){var e=this["_"+n],s=r.set&&r.set.call(this,t,e);this["_"+n]=void 0!==s?s:t},configurable:r.configurable,enumerable:r.enumerable});else if(2===arguments.length)for(var s in n)e.live(t,s,n[s]);return t}},include:function(){var t=arguments[arguments.length-1],n=2===arguments.length?arguments[0]:!1,r=document.createElement("script");return n?Promise.resolve():new Promise(function(n,s){e.set(r,{async:!0,onload:function(){n(),e.remove(r)},onerror:function(){s()},src:t,inside:document.head})})},fetch:function(t,n){if(!t)throw new TypeError("URL parameter is mandatory and cannot be "+t);t=new URL(t,location),n=n||{},n.data=n.data||"",n.method=n.method||"GET",n.headers=n.headers||{};var r=new XMLHttpRequest;"string"!==e.type(n.data)&&(n.data=Object.keys(n.data).map(function(t){return t+"="+encodeURIComponent(n.data[t])}).join("&")),"GET"===n.method&&n.data&&(t.search+=n.data),document.body.setAttribute("data-loading",t),r.open(n.method,t,!n.sync);for(var s in n)if(s in r)try{r[s]=n[s]}catch(i){self.console&&console.error(i)}"GET"===n.method||n.headers["Content-type"]||n.headers["Content-Type"]||r.setRequestHeader("Content-type","application/x-www-form-urlencoded");for(var o in n.headers)r.setRequestHeader(o,n.headers[o]);return new Promise(function(t,e){r.onload=function(){document.body.removeAttribute("data-loading"),0===r.status||r.status>=200&&r.status<300||304===r.status?t(r):e(Error(r.statusText))},r.onerror=function(){document.body.removeAttribute("data-loading"),e(Error("Network Error"))},r.send("GET"===n.method?null:n.data)})}});var n=e.property;e.Element=function(t){this.subject=t,this.data={},this.bliss={}},e.Element.prototype={set:function(t){"string"===e.type(arguments[0])&&(t={},t[arguments[0]]=arguments[1]);for(var n in t)n in e.setProps?e.setProps[n].call(this,t[n]):n in this?this[n]=t[n]:(this.setAttribute||console.log(this),this.setAttribute(n,t[n]))},transition:function(t,n){return n=+n||400,new Promise(function(r,s){if("transition"in this.style){var i=e.extend({},this.style,/^transition(Duration|Property)$/);e.style(this,{transitionDuration:(n||400)+"ms",transitionProperty:Object.keys(t).join(", ")}),e.once(this,"transitionend",function(){clearTimeout(o),e.style(this,i),r(this)});var o=setTimeout(r,n+50,this);e.style(this,t)}else e.style(this,t),r(this)}.bind(this))},fire:function(t,n){var r=document.createEvent("HTMLEvents");r.initEvent(t,!0,!0),this.dispatchEvent(e.extend(r,n))}},e.setProps={style:function(t){e.extend(this.style,t)},attributes:function(t){for(var e in t)this.setAttribute(e,t[e])},properties:function(t){e.extend(this,t)},events:function(t){if(t&&t.addEventListener){var e=this;if(t[n]&&t[n].bliss){var r=t[n].bliss.listeners;for(var s in r)r[s].forEach(function(t){e.addEventListener(s,t.callback,t.capture)})}for(var i in t)0===i.indexOf("on")&&(this[i]=t[i])}else for(var o in t)o.split(/\s+/).forEach(function(e){this.addEventListener(e,t[o])},this)},once:function(t){2==arguments.length&&(t={},t[arguments[0]]=arguments[1]);var n=this;e.each(t,function(t,e){t=t.split(/\s+/);var r=function(){return t.forEach(function(t){n.removeEventListener(t,r)}),e.apply(n,arguments)};t.forEach(function(t){n.addEventListener(t,r)})})},delegate:function(t){3===arguments.length?(t={},t[arguments[0]]={},t[arguments[0]][arguments[1]]=arguments[2]):2===arguments.length&&(t={},t[arguments[0]]=arguments[1]);var n=this;e.each(t,function(t,e){n.addEventListener(t,function(t){for(var n in e)t.target.matches(n)&&e[n].call(this,t)})})},contents:function(t){(t||0===t)&&(Array.isArray(t)?t:[t]).forEach(function(t){var n=e.type(t);/^(string|number)$/.test(n)?t=document.createTextNode(t+""):"object"===n&&(t=e.create(t)),t instanceof Node&&this.appendChild(t)},this)},inside:function(t){t.appendChild(this)},before:function(t){t.parentNode.insertBefore(this,t)},after:function(t){t.parentNode.insertBefore(this,t.nextSibling)},start:function(t){t.insertBefore(this,t.firstChild)},around:function(t){t.parentNode&&e.before(this,t),(/^template$/i.test(this.nodeName)?this.content||this:this).appendChild(t)}},e.Array=function(t){this.subject=t},e.Array.prototype={all:function(t){var e=$$(arguments).slice(1);return this[t].apply(this,e)}},e.add=function(t,n,r){n=e.extend({$:!0,element:!0,array:!0},n),"string"===e.type(arguments[0])&&(t={},t[arguments[0]]=arguments[1]),e.each(t,function(t,s){"function"==e.type(s)&&(!n.element||t in e.Element.prototype&&r||(e.Element.prototype[t]=function(){return this.subject&&e.defined(s.apply(this.subject,arguments),this.subject)}),!n.array||t in e.Array.prototype&&r||(e.Array.prototype[t]=function(){var t=arguments;return this.subject.map(function(n){return n&&e.defined(s.apply(n,t),n)})}),n.$&&(e.sources[t]=e[t]=s,(n.array||n.element)&&(e[t]=function(){var r=[].slice.apply(arguments),s=r.shift(),i=n.array&&Array.isArray(s)?"Array":"Element";return e[i].prototype[t].apply({subject:s},r)})))})},e.add(e.Array.prototype,{element:!1}),e.add(e.Element.prototype),e.add(e.setProps),e.add(e.classProps,{element:!1,array:!1});var r=document.createElement("_");e.add(e.extend({},HTMLElement.prototype,function(t){return"function"===e.type(r[t])}),null,!0)}(),function(t){"use strict";if(Bliss&&!Bliss.shy){var e=Bliss.property;if(t.add({clone:function(){var e=this.cloneNode(!0),n=t.$("*",e).concat(e);return t.$("*",this).concat(this).forEach(function(e,r,s){t.events(n[r],e)}),e}},{array:!1}),Object.defineProperty(Node.prototype,e,{get:function o(){return Object.defineProperty(Node.prototype,e,{get:void 0}),Object.defineProperty(this,e,{value:new t.Element(this)}),Object.defineProperty(Node.prototype,e,{get:o}),this[e]},configurable:!0}),Object.defineProperty(Array.prototype,e,{get:function(){return Object.defineProperty(this,e,{value:new t.Array(this)}),this[e]},configurable:!0}),self.EventTarget&&"addEventListener"in EventTarget.prototype){var n=EventTarget.prototype.addEventListener,r=EventTarget.prototype.removeEventListener,s=function(t,e,n){return n.callback===t&&n.capture==e},i=function(){return!s.apply(this,arguments)};EventTarget.prototype.addEventListener=function(t,r,i){if(this[e]&&r){var o=this[e].bliss.listeners=this[e].bliss.listeners||{};o[t]=o[t]||[],0===o[t].filter(s.bind(null,r,i)).length&&o[t].push({callback:r,capture:i})}return n.call(this,t,r,i)},EventTarget.prototype.removeEventListener=function(t,n,s){if(this[e]&&n){var o=this[e].bliss.listeners=this[e].bliss.listeners||{};o[t]&&(o[t]=o[t].filter(i.bind(null,n,s)))}return r.call(this,t,n,s)}}self.$=self.$||t,self.$$=self.$$||t.$}}(Bliss);
--------------------------------------------------------------------------------
/src/lib/LinkedList.js:
--------------------------------------------------------------------------------
1 | /*
2 | A high-speed doubly-linked list of objects. Note that for speed reasons (using a dictionary lookup of
3 | cached nodes) there can only be a single instance of an object in the list at the same time. Adding the same
4 | object a second time will result in a silent return from the add method.
5 |
6 | In order to keep a track of node links, an object must be able to identify itself with a uniqueID function.
7 |
8 | To add an item use:
9 |
10 | list.add(newItem);
11 |
12 |
13 | You can iterate using the first and next members, such as:
14 |
15 | var node = list.first;
16 | while (node)
17 | {
18 | node.object().DOSOMETHING();
19 | node = node.next();
20 | }
21 |
22 | */
23 | (function() {
24 | var LinkedListNode = function() {
25 | this.obj = null;
26 | this.next = null;
27 | this.prev = null;
28 | this.free = true;
29 | };
30 |
31 | var LinkedList = function() {
32 | this.first = null;
33 | this.last = null;
34 | this.length = 0;
35 | this.objToNodeMap = {}; // a quick lookup list to map linked list nodes to objects
36 | this.uniqueID = Date.now() + '' + Math.floor(Math.random()*1000);
37 |
38 | this.sortArray = [];
39 | };
40 |
41 | // static function for utility
42 | LinkedList.generateID = function() {
43 | return Math.random().toString(36).slice(2) + Date.now();
44 | };
45 |
46 | LinkedList.prototype = {
47 | /*
48 | Get the LinkedListNode for this object.
49 | @param obj The object to get the node for
50 | */
51 | getNode: function(obj) {
52 | // objects added to a list must implement a uniqueID which returns a unique object identifier string
53 | return this.objToNodeMap[obj.uniqueID];
54 | },
55 |
56 | /*
57 | Adds a new node to the list -- typically only used internally unless you're doing something funky
58 | Use add() to add an object to the list, not this.
59 | */
60 | addNode: function(obj) {
61 | var node = new LinkedListNode();
62 | if (!obj.uniqueID) {
63 | try {
64 | obj.uniqueID = LinkedList.generateID();
65 | // console.log('New ID: '+obj.uniqueID);
66 | }
67 | catch (err) {
68 | console.error('[LinkedList.addNode] obj passed is immutable: cannot attach necessary identifier');
69 | return null;
70 | }
71 | }
72 |
73 | node.obj = obj;
74 | node.free = false;
75 | this.objToNodeMap[obj.uniqueID] = node;
76 | return node;
77 | },
78 |
79 | swapObjects: function(node, newObj) {
80 | this.objToNodeMap[node.obj.uniqueID] = null;
81 | this.objToNodeMap[newObj.uniqueID] = node;
82 | node.obj = newObj;
83 | },
84 |
85 | /*
86 | Add an item to the list
87 | @param obj The object to add
88 | */
89 | add: function(obj) {
90 | var node = this.objToNodeMap[obj.uniqueID];
91 |
92 | if (!node) {
93 | node = this.addNode(obj);
94 | }
95 | else {
96 | if (node.free === false) return;
97 |
98 | // reusing a node, so we clean it up
99 | // this caching of node/object pairs is the reason an object can only exist
100 | // once in a list -- which also makes things faster (not always creating new node
101 | // object every time objects are moving on and off the list
102 | node.obj = obj;
103 | node.free = false;
104 | node.next = null;
105 | node.prev = null;
106 | }
107 |
108 | // append this obj to the end of the list
109 | if (!this.first) { // is this the first?
110 | this.first = node;
111 | this.last = node;
112 | node.next = null; // clear just in case
113 | node.prev = null;
114 | }
115 | else {
116 | if (!this.last) {
117 | throw new Error("[LinkedList.add] No last in the list -- that shouldn't happen here");
118 | }
119 |
120 | // add this entry to the end of the list
121 | this.last.next = node; // current end of list points to the new end
122 | node.prev = this.last;
123 | this.last = node; // new object to add becomes last in the list
124 | node.next = null; // just in case this was previously set
125 | }
126 | this.length++;
127 |
128 | if (this.showDebug) this.dump('after add');
129 | },
130 |
131 | has: function(obj) {
132 | return !!this.objToNodeMap[obj.uniqueID];
133 | },
134 |
135 | /*
136 | Moves this item upwards in the list
137 | @param obj
138 | */
139 | moveUp: function(obj) {
140 | this.dump('before move up');
141 | var c = this.getNode(obj);
142 | if (!c) throw "Oops, trying to move an object that isn't in the list";
143 | if (!c.prev) return; // already first, ignore
144 |
145 | // This operation makes C swap places with B:
146 | // A <-> B <-> C <-> D
147 | // A <-> C <-> B <-> D
148 |
149 | var b = c.prev;
150 | var a = b.prev;
151 |
152 | // fix last
153 | if (c == this.last) this.last = b;
154 |
155 | var oldCNext = c.next;
156 |
157 | if (a) a.next = c;
158 | c.next = b;
159 | c.prev = b.prev;
160 |
161 | b.next = oldCNext;
162 | b.prev = c;
163 |
164 | // check to see if we are now first
165 | if (this.first == b) this.first = c;
166 | },
167 |
168 | /*
169 | Moves this item downwards in the list
170 | @param obj
171 | */
172 | moveDown: function(obj) {
173 | var b = this.getNode(obj);
174 | if (!b) throw "Oops, trying to move an object that isn't in the list";
175 | if (!b.next) return; // already last, ignore
176 |
177 | // This operation makes B swap places with C:
178 | // A <-> B <-> C <-> D
179 | // A <-> C <-> B <-> D
180 |
181 | var c = b.next;
182 | this.moveUp(c.obj);
183 |
184 | // check to see if we are now last
185 | if (this.last == c) this.last = b;
186 | },
187 |
188 | /*
189 | Take everything off the list and put it in an array, sort it, then put it back.
190 | */
191 | sort: function(compare) {
192 | var sortArray = this.sortArray;
193 | var i, l, node = this.first;
194 | sortArray.length = 0;
195 |
196 | while (node) {
197 | sortArray.push(node.obj);
198 | node = node.next;
199 | }
200 |
201 | this.clear();
202 |
203 | sortArray.sort(compare);
204 | // console.log(sortArray);
205 | l = sortArray.length;
206 | for (i = 0; i < l; i++) {
207 | this.add(sortArray[i]);
208 | }
209 | },
210 |
211 | /*
212 | Removes an item from the list
213 | @param obj The object to remove
214 | @returns boolean true if the item was removed, false if the item was not on the list
215 | */
216 | remove: function(obj) {
217 | var node = this.getNode(obj);
218 | if (!node || node.free){
219 | return false; // ignore this error (trying to remove something not there)
220 | }
221 |
222 | // pull this object out and tie up the ends
223 | if (node.prev) node.prev.next = node.next;
224 | if (node.next) node.next.prev = node.prev;
225 |
226 | // fix first and last
227 | if (!node.prev) // if this was first on the list
228 | this.first = node.next; // make the next on the list first (can be null)
229 | if (!node.next) // if this was the last
230 | this.last = node.prev; // then this node's previous becomes last
231 |
232 | node.free = true;
233 | node.prev = null;
234 | node.next = null;
235 |
236 | this.length--;
237 |
238 | return true;
239 | },
240 |
241 | // remove the head and return it's object
242 | shift: function() {
243 | var node = this.first;
244 | if (this.length === 0) return null;
245 | // if (node == null || node.free == true) return null;
246 |
247 | // pull this object out and tie up the ends
248 | if (node.prev) {
249 | node.prev.next = node.next;
250 | }
251 | if (node.next) {
252 | node.next.prev = node.prev;
253 | }
254 |
255 | // make the next on the list first (can be null)
256 | this.first = node.next;
257 | if (!node.next) this.last = null; // make sure we clear this
258 |
259 | node.free = true;
260 | node.prev = null;
261 | node.next = null;
262 |
263 | this.length--;
264 | return node.obj;
265 | },
266 |
267 | // remove the tail and return it's object
268 | pop: function() {
269 | var node = this.last;
270 | if (this.length === 0) return null;
271 |
272 | // pull this object out and tie up the ends
273 | if (node.prev) {
274 | node.prev.next = node.next;
275 | }
276 | if (node.next) {
277 | node.next.prev = node.prev;
278 | }
279 |
280 | // this node's previous becomes last
281 | this.last = node.prev;
282 | if (!node.prev) this.first = null; // make sure we clear this
283 |
284 | node.free = true;
285 | node.prev = null;
286 | node.next = null;
287 |
288 | this.length--;
289 | return node.obj;
290 | },
291 |
292 | /**
293 | * Add the passed list to this list, leaving it untouched.
294 | */
295 | concat: function(list) {
296 | var node = list.first;
297 | while (node) {
298 | this.add(node.obj);
299 | node = node.next;
300 | }
301 | },
302 |
303 | /**
304 | * Clears the list out
305 | */
306 | clear: function() {
307 | var next = this.first;
308 |
309 | while (next) {
310 | next.free = true;
311 | next = next.next;
312 | }
313 |
314 | this.first = null;
315 | this.length = 0;
316 | },
317 |
318 | dispose: function() {
319 | var next = this.first;
320 |
321 | while (next) {
322 | next.obj = null;
323 | next = next.next;
324 | }
325 | this.first = null;
326 |
327 | this.objToNodeMap = null;
328 | },
329 |
330 | /*
331 | Outputs the contents of the current list for debugging.
332 | */
333 | dump: function(msg) {
334 | console.log('====================' + msg + '=====================');
335 | var a = this.first;
336 | while (a) {
337 | console.log("{" + a.obj.toString() + "} previous=" + (a.prev ? a.prev.obj : "NULL"));
338 | a = a.next();
339 | }
340 | console.log("===================================");
341 | console.log("Last: {" + (this.last ? this.last.obj : 'NULL') + "} " +
342 | "First: {" + (this.first ? this.first.obj : 'NULL') + "}");
343 | }
344 | };
345 |
346 | LinkedList.prototype.constructor = LinkedList;
347 |
348 | vg.LinkedList = LinkedList;
349 | }());
--------------------------------------------------------------------------------
/examples/pathfinding.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 | Grid
9 |
10 |
11 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
315 |
316 |
317 |
--------------------------------------------------------------------------------
/src/grids/SqrGrid.js:
--------------------------------------------------------------------------------
1 | /*
2 | Graph of squares. Handles grid cell management (placement math for eg pathfinding, range, etc) and grid conversion math.
3 | Interface:
4 | type
5 | size - number of cells (in radius); only used if the map is generated
6 | cellSize
7 | cells - a hash so we can have sparse maps
8 | numCells
9 | extrudeSettings
10 | autogenerated
11 | cellShape
12 | cellGeo
13 | cellShapeGeo
14 |
15 | @author Corey Birnbaum https://github.com/vonWolfehaus/
16 | */
17 | vg.SqrGrid = function(config) {
18 | config = config || {};
19 | /* ______________________________________________
20 | GRID INTERFACE:
21 | */
22 | this.type = vg.SQR;
23 | this.size = 5; // only used for generated maps
24 | this.cellSize = typeof config.cellSize === 'undefined' ? 10 : config.cellSize;
25 | this.cells = {};
26 | this.numCells = 0;
27 |
28 | this.extrudeSettings = null;
29 | this.autogenerated = false;
30 |
31 | // create base shape used for building geometry
32 | var verts = [];
33 | verts.push(new THREE.Vector3());
34 | verts.push(new THREE.Vector3(-this.cellSize, this.cellSize));
35 | verts.push(new THREE.Vector3(this.cellSize, this.cellSize));
36 | verts.push(new THREE.Vector3(this.cellSize, -this.cellSize));
37 | // copy the verts into a shape for the geometry to use
38 | this.cellShape = new THREE.Shape();
39 | this.cellShape.moveTo(-this.cellSize, -this.cellSize);
40 | this.cellShape.lineTo(-this.cellSize, this.cellSize);
41 | this.cellShape.lineTo(this.cellSize, this.cellSize);
42 | this.cellShape.lineTo(this.cellSize, -this.cellSize);
43 | this.cellShape.lineTo(-this.cellSize, -this.cellSize);
44 |
45 | this.cellGeo = new THREE.Geometry();
46 | this.cellGeo.vertices = verts;
47 | this.cellGeo.verticesNeedUpdate = true;
48 |
49 | this.cellShapeGeo = new THREE.ShapeGeometry(this.cellShape);
50 |
51 | /* ______________________________________________
52 | PRIVATE
53 | */
54 |
55 | this._fullCellSize = this.cellSize * 2;
56 | this._hashDelimeter = '.';
57 | // pre-computed permutations
58 | this._directions = [new vg.Cell(+1, 0, 0), new vg.Cell(0, -1, 0),
59 | new vg.Cell(-1, 0, 0), new vg.Cell(0, +1, 0)];
60 | this._diagonals = [new vg.Cell(-1, -1, 0), new vg.Cell(-1, +1, 0),
61 | new vg.Cell(+1, +1, 0), new vg.Cell(+1, -1, 0)];
62 | // cached objects
63 | this._list = [];
64 | this._vec3 = new THREE.Vector3();
65 | this._cel = new vg.Cell();
66 | this._conversionVec = new THREE.Vector3();
67 | this._geoCache = [];
68 | this._matCache = [];
69 | };
70 |
71 | vg.SqrGrid.prototype = {
72 | /*
73 | ________________________________________________________________________
74 | High-level functions that the Board interfaces with (all grids implement)
75 | */
76 |
77 | cellToPixel: function(cell) {
78 | this._vec3.x = cell.q * this._fullCellSize;
79 | this._vec3.y = cell.h;
80 | this._vec3.z = cell.r * this._fullCellSize;
81 | return this._vec3;
82 | },
83 |
84 | pixelToCell: function(pos) {
85 | var q = Math.round(pos.x / this._fullCellSize);
86 | var r = Math.round(pos.z / this._fullCellSize);
87 | return this._cel.set(q, r, 0);
88 | },
89 |
90 | getCellAt: function(pos) {
91 | var q = Math.round(pos.x / this._fullCellSize);
92 | var r = Math.round(pos.z / this._fullCellSize);
93 | this._cel.set(q, r);
94 | return this.cells[this.cellToHash(this._cel)];
95 | },
96 |
97 | getNeighbors: function(cell, diagonal, filter) {
98 | // always returns an array
99 | var i, n, l = this._directions.length;
100 | this._list.length = 0;
101 | for (i = 0; i < l; i++) {
102 | this._cel.copy(cell);
103 | this._cel.add(this._directions[i]);
104 | n = this.cells[this.cellToHash(this._cel)];
105 | if (!n || (filter && !filter(cell, n))) {
106 | continue;
107 | }
108 | this._list.push(n);
109 | }
110 | if (diagonal) {
111 | for (i = 0; i < l; i++) {
112 | this._cel.copy(cell);
113 | this._cel.add(this._diagonals[i]);
114 | n = this.cells[this.cellToHash(this._cel)];
115 | if (!n || (filter && !filter(cell, n))) {
116 | continue;
117 | }
118 | this._list.push(n);
119 | }
120 | }
121 | return this._list;
122 | },
123 |
124 | getRandomCell: function() {
125 | var c, i = 0, x = vg.Tools.randomInt(0, this.numCells);
126 | for (c in this.cells) {
127 | if (i === x) {
128 | return this.cells[c];
129 | }
130 | i++;
131 | }
132 | return this.cells[c];
133 | },
134 |
135 | cellToHash: function(cell) {
136 | return cell.q+this._hashDelimeter+cell.r; // s is not used in a square grid
137 | },
138 |
139 | distance: function(cellA, cellB) {
140 | var d = Math.max(Math.abs(cellA.q - cellB.q), Math.abs(cellA.r - cellB.r));
141 | d += cellB.h - cellA.h; // include vertical size
142 | return d;
143 | },
144 |
145 | clearPath: function() {
146 | var i, c;
147 | for (i in this.cells) {
148 | c = this.cells[i];
149 | c._calcCost = 0;
150 | c._priority = 0;
151 | c._parent = null;
152 | c._visited = false;
153 | }
154 | },
155 |
156 | traverse: function(cb) {
157 | var i;
158 | for (i in this.cells) {
159 | cb(this.cells[i]);
160 | }
161 | },
162 |
163 | generateTile: function(cell, scale, material) {
164 | var height = Math.abs(cell.h);
165 | if (height < 1) height = 1;
166 |
167 | var geo = this._geoCache[height];
168 | if (!geo) {
169 | this.extrudeSettings.depth = height;
170 | geo = new THREE.ExtrudeGeometry(this.cellShape, this.extrudeSettings);
171 | this._geoCache[height] = geo;
172 | }
173 |
174 | /*mat = this._matCache[c.matConfig.mat_cache_id];
175 | if (!mat) { // MaterialLoader? we currently only support basic stuff though. maybe later
176 | mat.map = Loader.loadTexture(c.matConfig.imgURL);
177 | delete c.matConfig.imgURL;
178 | mat = new THREE[c.matConfig.type](c.matConfig);
179 | this._matCache[c.matConfig.mat_cache_id] = mat;
180 | }*/
181 |
182 | var t = new vg.Tile({
183 | size: this.cellSize,
184 | scale: scale,
185 | cell: cell,
186 | geometry: geo,
187 | material: material
188 | });
189 |
190 | cell.tile = t;
191 |
192 | return t;
193 | },
194 |
195 | generateTiles: function(config) {
196 | config = config || {};
197 | var tiles = [];
198 | var settings = {
199 | tileScale: 0.95,
200 | cellSize: this.cellSize,
201 | material: null,
202 | extrudeSettings: {
203 | depth: 1,
204 | bevelEnabled: true,
205 | bevelSegments: 1,
206 | steps: 1,
207 | bevelSize: this.cellSize/20,
208 | bevelThickness: this.cellSize/20
209 | }
210 | }
211 | settings = vg.Tools.merge(settings, config);
212 |
213 | /*if (!settings.material) {
214 | settings.material = new THREE.MeshPhongMaterial({
215 | color: vg.Tools.randomizeRGB('30, 30, 30', 10)
216 | });
217 | }*/
218 |
219 | // overwrite with any new dimensions
220 | this.cellSize = settings.cellSize;
221 | this._fullCellSize = this.cellSize * 2;
222 |
223 | this.autogenerated = true;
224 | this.extrudeSettings = settings.extrudeSettings;
225 |
226 | var i, t, c;
227 | for (i in this.cells) {
228 | c = this.cells[i];
229 | t = this.generateTile(c, settings.tileScale, settings.material);
230 | t.position.copy(this.cellToPixel(c));
231 | t.position.y = 0;
232 | tiles.push(t);
233 | }
234 | return tiles;
235 | },
236 |
237 | generateTilePoly: function(material) {
238 | if (!material) {
239 | material = new THREE.MeshBasicMaterial({color: 0x24b4ff});
240 | }
241 | var mesh = new THREE.Mesh(this.cellShapeGeo, material);
242 | this._vec3.set(1, 0, 0);
243 | mesh.rotateOnAxis(this._vec3, vg.PI/2);
244 | return mesh;
245 | },
246 |
247 | // create a flat, square-shaped grid
248 | generate: function(config) {
249 | config = config || {};
250 | this.size = typeof config.size === 'undefined' ? this.size : config.size;
251 | var x, y, c;
252 | var half = Math.ceil(this.size / 2);
253 | for (x = -half; x < half; x++) {
254 | for (y = -half; y < half; y++) {
255 | c = new vg.Cell(x, y + 1);
256 | this.add(c);
257 | }
258 | }
259 | },
260 |
261 | generateOverlay: function(size, overlayObj, overlayMat) {
262 | var x, y;
263 | var half = Math.ceil(size / 2);
264 | for (x = -half; x < half; x++) {
265 | for (y = -half; y < half; y++) {
266 | this._cel.set(x, y); // define the cell
267 | var line = new THREE.Line(this.cellGeo, overlayMat);
268 | line.position.copy(this.cellToPixel(this._cel));
269 | line.rotation.x = 90 * vg.DEG_TO_RAD;
270 | overlayObj.add(line);
271 | }
272 | }
273 | },
274 |
275 | add: function(cell) {
276 | var h = this.cellToHash(cell);
277 | if (this.cells[h]) {
278 | // console.warn('A cell already exists there');
279 | return;
280 | }
281 | this.cells[h] = cell;
282 | this.numCells++;
283 |
284 | return cell;
285 | },
286 |
287 | remove: function(cell) {
288 | var h = this.cellToHash(cell);
289 | if (this.cells[h]) {
290 | delete this.cells[h];
291 | this.numCells--;
292 | }
293 | },
294 |
295 | dispose: function() {
296 | this.cells = null;
297 | this.numCells = 0;
298 | this.cellShape = null;
299 | this.cellGeo.dispose();
300 | this.cellGeo = null;
301 | this.cellShapeGeo.dispose();
302 | this.cellShapeGeo = null;
303 | this._list = null;
304 | this._vec3 = null;
305 | this._conversionVec = null;
306 | this._geoCache = null;
307 | this._matCache = null;
308 | },
309 |
310 | /*
311 | Load a grid from a parsed json object.
312 | json = {
313 | extrudeSettings,
314 | size,
315 | cellSize,
316 | autogenerated,
317 | cells: [],
318 | materials: [
319 | {
320 | cache_id: 0,
321 | type: 'MeshLambertMaterial',
322 | color, ambient, emissive, reflectivity, refractionRatio, wrapAround,
323 | imgURL: url
324 | },
325 | {
326 | cacheId: 1, ...
327 | }
328 | ...
329 | ]
330 | }
331 | */
332 | load: function(url, callback, scope) {
333 | vg.Tools.getJSON({
334 | url: url,
335 | callback: function(json) {
336 | this.fromJSON(json);
337 | callback.call(scope || null, json);
338 | },
339 | cache: false,
340 | scope: this
341 | });
342 | },
343 |
344 | fromJSON: function(json) {
345 | var i, c;
346 | var cells = json.cells;
347 |
348 | this.cells = {};
349 | this.numCells = 0;
350 |
351 | this.size = json.size;
352 | this.cellSize = json.cellSize;
353 | this._fullCellSize = this.cellSize * 2;
354 | this.extrudeSettings = json.extrudeSettings;
355 | this.autogenerated = json.autogenerated;
356 |
357 | for (i = 0; i < cells.length; i++) {
358 | c = new vg.Cell();
359 | c.copy(cells[i]);
360 | this.add(c);
361 | }
362 | },
363 |
364 | toJSON: function() {
365 | var json = {
366 | size: this.size,
367 | cellSize: this.cellSize,
368 | extrudeSettings: this.extrudeSettings,
369 | autogenerated: this.autogenerated
370 | };
371 | var cells = [];
372 | var c, k;
373 |
374 | for (k in this.cells) {
375 | c = this.cells[k];
376 | cells.push({
377 | q: c.q,
378 | r: c.r,
379 | s: c.s,
380 | h: c.h,
381 | walkable: c.walkable,
382 | userData: c.userData
383 | });
384 | }
385 | json.cells = cells;
386 |
387 | return json;
388 | }
389 | };
390 |
391 | vg.SqrGrid.prototype.constructor = vg.SqrGrid;
392 |
--------------------------------------------------------------------------------
/src/grids/HexGrid.js:
--------------------------------------------------------------------------------
1 | /*
2 | Graph of hexagons. Handles grid cell management (placement math for eg pathfinding, range, etc) and grid conversion math.
3 | [Cube/axial coordinate system](http://www.redblobgames.com/grids/hexagons/), "flat top" version only. Since this is 3D, just rotate your camera for pointy top maps.
4 | Interface:
5 | type
6 | size - number of cells (in radius); only used if the map is generated
7 | cellSize
8 | cells - a hash so we can have sparse maps
9 | numCells
10 | extrudeSettings
11 | autogenerated
12 | cellShape
13 | cellGeo
14 | cellShapeGeo
15 |
16 | @author Corey Birnbaum https://github.com/vonWolfehaus/
17 | */
18 | // 'utils/Loader', 'graphs/Hex', 'utils/Tools'
19 | vg.HexGrid = function(config) {
20 | config = config || {};
21 | /* ______________________________________________
22 | GRID INTERFACE:
23 | */
24 | this.type = vg.HEX;
25 | this.size = 5; // only used for generated maps
26 | this.cellSize = typeof config.cellSize === 'undefined' ? 10 : config.cellSize;
27 | this.cells = {};
28 | this.numCells = 0;
29 |
30 | this.extrudeSettings = null;
31 | this.autogenerated = false;
32 |
33 | // create base shape used for building geometry
34 | var i, verts = [];
35 | // create the skeleton of the hex
36 | for (i = 0; i < 6; i++) {
37 | verts.push(this._createVertex(i));
38 | }
39 | // copy the verts into a shape for the geometry to use
40 | this.cellShape = new THREE.Shape();
41 | this.cellShape.moveTo(verts[0].x, verts[0].y);
42 | for (i = 1; i < 6; i++) {
43 | this.cellShape.lineTo(verts[i].x, verts[i].y);
44 | }
45 | this.cellShape.lineTo(verts[0].x, verts[0].y);
46 | this.cellShape.autoClose = true;
47 |
48 | this.cellGeo = new THREE.Geometry();
49 | this.cellGeo.vertices = verts;
50 | this.cellGeo.verticesNeedUpdate = true;
51 |
52 | this.cellShapeGeo = new THREE.ShapeGeometry(this.cellShape);
53 |
54 | /* ______________________________________________
55 | PRIVATE
56 | */
57 |
58 | this._cellWidth = this.cellSize * 2;
59 | this._cellLength = (vg.SQRT3 * 0.5) * this._cellWidth;
60 | this._hashDelimeter = '.';
61 | // pre-computed permutations
62 | this._directions = [new vg.Cell(+1, -1, 0), new vg.Cell(+1, 0, -1), new vg.Cell(0, +1, -1),
63 | new vg.Cell(-1, +1, 0), new vg.Cell(-1, 0, +1), new vg.Cell(0, -1, +1)];
64 | this._diagonals = [new vg.Cell(+2, -1, -1), new vg.Cell(+1, +1, -2), new vg.Cell(-1, +2, -1),
65 | new vg.Cell(-2, +1, +1), new vg.Cell(-1, -1, +2), new vg.Cell(+1, -2, +1)];
66 | // cached objects
67 | this._list = [];
68 | this._vec3 = new THREE.Vector3();
69 | this._cel = new vg.Cell();
70 | this._conversionVec = new THREE.Vector3();
71 | this._geoCache = [];
72 | this._matCache = [];
73 | };
74 |
75 | vg.HexGrid.TWO_THIRDS = 2 / 3;
76 |
77 | vg.HexGrid.prototype = {
78 | /* ________________________________________________________________________
79 | High-level functions that the Board interfaces with (all grids implement)
80 | */
81 |
82 | // grid cell (Hex in cube coordinate space) to position in pixels/world
83 | cellToPixel: function(cell) {
84 | this._vec3.x = cell.q * this._cellWidth * 0.75;
85 | this._vec3.y = cell.h;
86 | this._vec3.z = -((cell.s - cell.r) * this._cellLength * 0.5);
87 | return this._vec3;
88 | },
89 |
90 | pixelToCell: function(pos) {
91 | // convert a position in world space ("pixels") to cell coordinates
92 | var q = pos.x * (vg.HexGrid.TWO_THIRDS / this.cellSize);
93 | var r = ((-pos.x / 3) + (vg.SQRT3/3) * pos.z) / this.cellSize;
94 | this._cel.set(q, r, -q-r);
95 | return this._cubeRound(this._cel);
96 | },
97 |
98 | getCellAt: function(pos) {
99 | // get the Cell (if any) at the passed world position
100 | var q = pos.x * (vg.HexGrid.TWO_THIRDS / this.cellSize);
101 | var r = ((-pos.x / 3) + (vg.SQRT3/3) * pos.z) / this.cellSize;
102 | this._cel.set(q, r, -q-r);
103 | this._cubeRound(this._cel);
104 | return this.cells[this.cellToHash(this._cel)];
105 | },
106 |
107 | getNeighbors: function(cell, diagonal, filter) {
108 | // always returns an array
109 | var i, n, l = this._directions.length;
110 | this._list.length = 0;
111 | for (i = 0; i < l; i++) {
112 | this._cel.copy(cell);
113 | this._cel.add(this._directions[i]);
114 | n = this.cells[this.cellToHash(this._cel)];
115 | if (!n || (filter && !filter(cell, n))) {
116 | continue;
117 | }
118 | this._list.push(n);
119 | }
120 | if (diagonal) {
121 | for (i = 0; i < l; i++) {
122 | this._cel.copy(cell);
123 | this._cel.add(this._diagonals[i]);
124 | n = this.cells[this.cellToHash(this._cel)];
125 | if (!n || (filter && !filter(cell, n))) {
126 | continue;
127 | }
128 | this._list.push(n);
129 | }
130 | }
131 | return this._list;
132 | },
133 |
134 | getRandomCell: function() {
135 | var c, i = 0, x = vg.Tools.randomInt(0, this.numCells);
136 | for (c in this.cells) {
137 | if (i === x) {
138 | return this.cells[c];
139 | }
140 | i++;
141 | }
142 | return this.cells[c];
143 | },
144 |
145 | cellToHash: function(cell) {
146 | return cell.q+this._hashDelimeter+cell.r+this._hashDelimeter+cell.s;
147 | },
148 |
149 | distance: function(cellA, cellB) {
150 | var d = Math.max(Math.abs(cellA.q - cellB.q), Math.abs(cellA.r - cellB.r), Math.abs(cellA.s - cellB.s));
151 | d += cellB.h - cellA.h; // include vertical height
152 | return d;
153 | },
154 |
155 | clearPath: function() {
156 | var i, c;
157 | for (i in this.cells) {
158 | c = this.cells[i];
159 | c._calcCost = 0;
160 | c._priority = 0;
161 | c._parent = null;
162 | c._visited = false;
163 | }
164 | },
165 |
166 | traverse: function(cb) {
167 | var i;
168 | for (i in this.cells) {
169 | cb(this.cells[i]);
170 | }
171 | },
172 |
173 | generateTile: function(cell, scale, material) {
174 | var height = Math.abs(cell.h);
175 | if (height < 1) height = 1;
176 |
177 | var geo = this._geoCache[height];
178 | if (!geo) {
179 | this.extrudeSettings.depth = height;
180 | geo = new THREE.ExtrudeGeometry(this.cellShape, this.extrudeSettings);
181 | this._geoCache[height] = geo;
182 | }
183 |
184 | /*mat = this._matCache[c.matConfig.mat_cache_id];
185 | if (!mat) { // MaterialLoader? we currently only support basic stuff though. maybe later
186 | mat.map = Loader.loadTexture(c.matConfig.imgURL);
187 | delete c.matConfig.imgURL;
188 | mat = new THREE[c.matConfig.type](c.matConfig);
189 | this._matCache[c.matConfig.mat_cache_id] = mat;
190 | }*/
191 |
192 | var tile = new vg.Tile({
193 | size: this.cellSize,
194 | scale: scale,
195 | cell: cell,
196 | geometry: geo,
197 | material: material
198 | });
199 |
200 | cell.tile = tile;
201 |
202 | return tile;
203 | },
204 |
205 | generateTiles: function(config) {
206 | config = config || {};
207 | var tiles = [];
208 | var settings = {
209 | tileScale: 0.95,
210 | cellSize: this.cellSize,
211 | material: null,
212 | extrudeSettings: {
213 | depth: 1,
214 | bevelEnabled: true,
215 | bevelSegments: 1,
216 | steps: 1,
217 | bevelSize: this.cellSize/20,
218 | bevelThickness: this.cellSize/20
219 | }
220 | }
221 | settings = vg.Tools.merge(settings, config);
222 |
223 | /*if (!settings.material) {
224 | settings.material = new THREE.MeshPhongMaterial({
225 | color: vg.Tools.randomizeRGB('30, 30, 30', 10)
226 | });
227 | }*/
228 |
229 | // overwrite with any new dimensions
230 | this.cellSize = settings.cellSize;
231 | this._cellWidth = this.cellSize * 2;
232 | this._cellLength = (vg.SQRT3 * 0.5) * this._cellWidth;
233 |
234 | this.autogenerated = true;
235 | this.extrudeSettings = settings.extrudeSettings;
236 |
237 | var i, t, c;
238 | for (i in this.cells) {
239 | c = this.cells[i];
240 | t = this.generateTile(c, settings.tileScale, settings.material);
241 | t.position.copy(this.cellToPixel(c));
242 | t.position.y = 0;
243 | tiles.push(t);
244 | }
245 | return tiles;
246 | },
247 |
248 | generateTilePoly: function(material) {
249 | if (!material) {
250 | material = new THREE.MeshBasicMaterial({color: 0x24b4ff});
251 | }
252 | var mesh = new THREE.Mesh(this.cellShapeGeo, material);
253 | this._vec3.set(1, 0, 0);
254 | mesh.rotateOnAxis(this._vec3, vg.PI/2);
255 | return mesh;
256 | },
257 |
258 | // create a flat, hexagon-shaped grid
259 | generate: function(config) {
260 | config = config || {};
261 | this.size = typeof config.size === 'undefined' ? this.size : config.size;
262 | var x, y, z, c;
263 | for (x = -this.size; x < this.size+1; x++) {
264 | for (y = -this.size; y < this.size+1; y++) {
265 | z = -x-y;
266 | if (Math.abs(x) <= this.size && Math.abs(y) <= this.size && Math.abs(z) <= this.size) {
267 | c = new vg.Cell(x, y, z);
268 | this.add(c);
269 | }
270 | }
271 | }
272 | },
273 |
274 | generateOverlay: function(size, overlayObj, overlayMat) {
275 | var x, y, z;
276 | var geo = this.cellShape.createPointsGeometry();
277 | for (x = -size; x < size+1; x++) {
278 | for (y = -size; y < size+1; y++) {
279 | z = -x-y;
280 | if (Math.abs(x) <= size && Math.abs(y) <= size && Math.abs(z) <= size) {
281 | this._cel.set(x, y, z); // define the cell
282 | var line = new THREE.Line(geo, overlayMat);
283 | line.position.copy(this.cellToPixel(this._cel));
284 | line.rotation.x = 90 * vg.DEG_TO_RAD;
285 | overlayObj.add(line);
286 | }
287 | }
288 | }
289 | },
290 |
291 | add: function(cell) {
292 | var h = this.cellToHash(cell);
293 | if (this.cells[h]) {
294 | // console.warn('A cell already exists there');
295 | return;
296 | }
297 | this.cells[h] = cell;
298 | this.numCells++;
299 |
300 | return cell;
301 | },
302 |
303 | remove: function(cell) {
304 | var h = this.cellToHash(cell);
305 | if (this.cells[h]) {
306 | delete this.cells[h];
307 | this.numCells--;
308 | }
309 | },
310 |
311 | dispose: function() {
312 | this.cells = null;
313 | this.numCells = 0;
314 | this.cellShape = null;
315 | this.cellGeo.dispose();
316 | this.cellGeo = null;
317 | this.cellShapeGeo.dispose();
318 | this.cellShapeGeo = null;
319 | this._list = null;
320 | this._vec3 = null;
321 | this._conversionVec = null;
322 | this._geoCache = null;
323 | this._matCache = null;
324 | },
325 |
326 | /*
327 | Load a grid from a parsed json object.
328 | json = {
329 | extrudeSettings,
330 | size,
331 | cellSize,
332 | autogenerated,
333 | cells: [],
334 | materials: [
335 | {
336 | cache_id: 0,
337 | type: 'MeshLambertMaterial',
338 | color, ambient, emissive, reflectivity, refractionRatio, wrapAround,
339 | imgURL: url
340 | },
341 | {
342 | cacheId: 1, ...
343 | }
344 | ...
345 | ]
346 | }
347 | */
348 | load: function(url, cb, scope) {
349 | var self = this;
350 | vg.Tools.getJSON({
351 | url: url,
352 | callback: function(json) {
353 | self.fromJSON(json);
354 | cb.call(scope || null, json);
355 | },
356 | cache: false,
357 | scope: self
358 | });
359 | },
360 |
361 | fromJSON: function(json) {
362 | var i, c;
363 | var cells = json.cells;
364 |
365 | this.cells = {};
366 | this.numCells = 0;
367 |
368 | this.size = json.size;
369 | this.cellSize = json.cellSize;
370 | this._cellWidth = this.cellSize * 2;
371 | this._cellLength = (vg.SQRT3 * 0.5) * this._cellWidth;
372 |
373 | this.extrudeSettings = json.extrudeSettings;
374 | this.autogenerated = json.autogenerated;
375 |
376 | for (i = 0; i < cells.length; i++) {
377 | c = new vg.Cell();
378 | c.copy(cells[i]);
379 | this.add(c);
380 | }
381 | },
382 |
383 | toJSON: function() {
384 | var json = {
385 | size: this.size,
386 | cellSize: this.cellSize,
387 | extrudeSettings: this.extrudeSettings,
388 | autogenerated: this.autogenerated
389 | };
390 | var cells = [];
391 | var c, k;
392 |
393 | for (k in this.cells) {
394 | c = this.cells[k];
395 | cells.push({
396 | q: c.q,
397 | r: c.r,
398 | s: c.s,
399 | h: c.h,
400 | walkable: c.walkable,
401 | userData: c.userData
402 | });
403 | }
404 | json.cells = cells;
405 |
406 | return json;
407 | },
408 |
409 | /* ________________________________________________________________________
410 | Hexagon-specific conversion math
411 | Mostly commented out because they're inlined whenever possible to increase performance.
412 | They're still here for reference.
413 | */
414 |
415 | _createVertex: function(i) {
416 | var angle = (vg.TAU / 6) * i;
417 | return new THREE.Vector3((this.cellSize * Math.cos(angle)), (this.cellSize * Math.sin(angle)), 0);
418 | },
419 |
420 | /*_pixelToAxial: function(pos) {
421 | var q, r; // = x, y
422 | q = pos.x * ((2/3) / this.cellSize);
423 | r = ((-pos.x / 3) + (vg.SQRT3/3) * pos.y) / this.cellSize;
424 | this._cel.set(q, r, -q-r);
425 | return this._cubeRound(this._cel);
426 | },*/
427 |
428 | /*_axialToCube: function(h) {
429 | return {
430 | q: h.q,
431 | r: h.r,
432 | s: -h.q - h.r
433 | };
434 | },*/
435 |
436 | /*_cubeToAxial: function(cell) {
437 | return cell; // yep
438 | },*/
439 |
440 | /*_axialToPixel: function(cell) {
441 | var x, y; // = q, r
442 | x = cell.q * this._cellWidth * 0.75;
443 | y = (cell.s - cell.r) * this._cellLength * 0.5;
444 | return {x: x, y: -y};
445 | },*/
446 |
447 | /*_hexToPixel: function(h) {
448 | var x, y; // = q, r
449 | x = this.cellSize * 1.5 * h.x;
450 | y = this.cellSize * vg.SQRT3 * (h.y + (h.x * 0.5));
451 | return {x: x, y: y};
452 | },*/
453 |
454 | /*_axialRound: function(h) {
455 | return this._cubeRound(this.axialToCube(h));
456 | },*/
457 |
458 | _cubeRound: function(h) {
459 | var rx = Math.round(h.q);
460 | var ry = Math.round(h.r);
461 | var rz = Math.round(h.s);
462 |
463 | var xDiff = Math.abs(rx - h.q);
464 | var yDiff = Math.abs(ry - h.r);
465 | var zDiff = Math.abs(rz - h.s);
466 |
467 | if (xDiff > yDiff && xDiff > zDiff) {
468 | rx = -ry-rz;
469 | }
470 | else if (yDiff > zDiff) {
471 | ry = -rx-rz;
472 | }
473 | else {
474 | rz = -rx-ry;
475 | }
476 |
477 | return this._cel.set(rx, ry, rz);
478 | },
479 |
480 | /*_cubeDistance: function(a, b) {
481 | return Math.max(Math.abs(a.q - b.q), Math.abs(a.r - b.r), Math.abs(a.s - b.s));
482 | }*/
483 | };
484 |
485 | vg.HexGrid.prototype.constructor = vg.HexGrid;
486 |
--------------------------------------------------------------------------------
/src/lib/Signal.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | var SignalBinding = function (signal, listener, isOnce, listenerContext, priority) {
3 | /**
4 | * @property _listener - Handler function bound to the signal.
5 | * @private
6 | */
7 | this._listener = listener;
8 |
9 | /**
10 | * @property {boolean} isOnce - If binding should be executed just once.
11 | * @private
12 | */
13 | this.isOnce = isOnce;
14 |
15 | /**
16 | * @property {object|undefined|null} context - Context on which listener will be executed (object that should represent the `this` variable inside listener function).
17 | */
18 | this.context = listenerContext;
19 |
20 | /**
21 | * @property {Signal} signal - Reference to Signal object that listener is currently bound to.
22 | * @private
23 | */
24 | this.signal = signal;
25 |
26 | /**
27 | * @property {number} _priority - Listener priority.
28 | * @private
29 | */
30 | this._priority = priority || 0;
31 | };
32 |
33 | SignalBinding.prototype = {
34 | /**
35 | * If binding is active and should be executed.
36 | * @property {boolean} active
37 | * @default
38 | */
39 | active: true,
40 |
41 | /**
42 | * Default parameters passed to listener during `Signal.dispatch` and `SignalBinding.execute` (curried parameters).
43 | * @property {array|null} params
44 | * @default
45 | */
46 | params: null,
47 |
48 | /**
49 | * Call listener passing arbitrary parameters.
50 | * If binding was added using `Signal.addOnce()` it will be automatically removed from signal dispatch queue, this method is used internally for the signal dispatch.
51 | * @method SignalBinding#execute
52 | * @param {array} [paramsArr] - Array of parameters that should be passed to the listener.
53 | * @return {any} Value returned by the listener.
54 | */
55 | execute: function(paramsArr) {
56 |
57 | var handlerReturn, params;
58 |
59 | if (this.active && !!this._listener) {
60 | params = this.params ? this.params.concat(paramsArr) : paramsArr;
61 | handlerReturn = this._listener.apply(this.context, params);
62 |
63 | if (this.isOnce) {
64 | this.detach();
65 | }
66 | }
67 |
68 | return handlerReturn;
69 |
70 | },
71 |
72 | /**
73 | * Detach binding from signal.
74 | * alias to: @see mySignal.remove(myBinding.listener);
75 | * @method SignalBinding#detach
76 | * @return {function|null} Handler function bound to the signal or `null` if binding was previously detached.
77 | */
78 | detach: function () {
79 | return this.isBound() ? this.signal.remove(this._listener, this.context) : null;
80 | },
81 |
82 | /**
83 | * @method SignalBinding#isBound
84 | * @return {boolean} True if binding is still bound to the signal and has a listener.
85 | */
86 | isBound: function () {
87 | return (!!this.signal && !!this._listener);
88 | },
89 |
90 | /**
91 | * Delete instance properties
92 | * @method SignalBinding#_destroy
93 | * @private
94 | */
95 | _destroy: function () {
96 | delete this.signal;
97 | delete this._listener;
98 | delete this.context;
99 | },
100 |
101 | /**
102 | * @method SignalBinding#toString
103 | * @return {string} String representation of the object.
104 | */
105 | toString: function () {
106 | return '[SignalBinding isOnce:' + this.isOnce +', isBound:'+ this.isBound() +', active:' + this.active + ']';
107 | }
108 | };
109 |
110 | SignalBinding.prototype.constructor = SignalBinding;
111 |
112 |
113 |
114 | /**
115 | * @author Miller Medeiros http://millermedeiros.github.com/js-signals/
116 | * @author Richard Davey
117 | * @copyright 2014 Photon Storm Ltd.
118 | * @license {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
119 | */
120 |
121 | /**
122 | * A Signal is used for object communication via a custom broadcaster instead of Events.
123 | *
124 | * @class Signal
125 | * @constructor
126 | */
127 | var Signal = function () {
128 | /**
129 | * @property {Array.} _bindings - Internal variable.
130 | * @private
131 | */
132 | this._bindings = [];
133 |
134 | /**
135 | * @property {any} _prevParams - Internal variable.
136 | * @private
137 | */
138 | this._prevParams = null;
139 |
140 | // enforce dispatch to aways work on same context (#47)
141 | var self = this;
142 |
143 | /**
144 | * @property {function} dispatch - The dispatch function is what sends the Signal out.
145 | */
146 | this.dispatch = function(){
147 | Signal.prototype.dispatch.apply(self, arguments);
148 | };
149 |
150 | };
151 |
152 | Signal.prototype = {
153 | /**
154 | * If Signal should keep record of previously dispatched parameters and
155 | * automatically execute listener during `add()`/`addOnce()` if Signal was
156 | * already dispatched before.
157 | * @property {boolean} memorize
158 | */
159 | memorize: false,
160 |
161 | /**
162 | * @property {boolean} _shouldPropagate
163 | * @private
164 | */
165 | _shouldPropagate: true,
166 |
167 | /**
168 | * If Signal is active and should broadcast events.
169 | * IMPORTANT: Setting this property during a dispatch will only affect the next dispatch, if you want to stop the propagation of a signal use `halt()` instead.
170 | * @property {boolean} active
171 | * @default
172 | */
173 | active: true,
174 |
175 | /**
176 | * @method Signal#validateListener
177 | * @param {function} listener - Signal handler function.
178 | * @param {string} fnName - Function name.
179 | * @private
180 | */
181 | validateListener: function (listener, fnName) {
182 | if (typeof listener !== 'function') {
183 | throw new Error('Signal: listener is a required param of {fn}() and should be a Function.'.replace('{fn}', fnName));
184 | }
185 | },
186 |
187 | /**
188 | * @method Signal#_registerListener
189 | * @private
190 | * @param {function} listener - Signal handler function.
191 | * @param {boolean} isOnce - Should the listener only be called once?
192 | * @param {object} [listenerContext] - The context under which the listener is invoked.
193 | * @param {number} [priority] - The priority level of the event listener. Listeners with higher priority will be executed before listeners with lower priority. Listeners with same priority level will be executed at the same order as they were added. (default = 0).
194 | * @return {SignalBinding} An Object representing the binding between the Signal and listener.
195 | */
196 | _registerListener: function (listener, isOnce, listenerContext, priority) {
197 | var prevIndex = this._indexOfListener(listener, listenerContext);
198 | var binding;
199 |
200 | if (prevIndex !== -1) {
201 | binding = this._bindings[prevIndex];
202 |
203 | if (binding.isOnce !== isOnce) {
204 | throw new Error('You cannot add' + (isOnce ? '' : 'Once') + '() then add' + (!isOnce ? '' : 'Once') + '() the same listener without removing the relationship first.');
205 | }
206 | }
207 | else {
208 | binding = new SignalBinding(this, listener, isOnce, listenerContext, priority);
209 | this._addBinding(binding);
210 | }
211 |
212 | if (this.memorize && this._prevParams) {
213 | binding.execute(this._prevParams);
214 | }
215 |
216 | return binding;
217 | },
218 |
219 | /**
220 | * @method Signal#_addBinding
221 | * @private
222 | * @param {SignalBinding} binding - An Object representing the binding between the Signal and listener.
223 | */
224 | _addBinding: function (binding) {
225 | // Simplified insertion sort
226 | var n = this._bindings.length;
227 |
228 | do {
229 | n--;
230 | }
231 | while (this._bindings[n] && binding._priority <= this._bindings[n]._priority);
232 |
233 | this._bindings.splice(n + 1, 0, binding);
234 | },
235 |
236 | /**
237 | * @method Signal#_indexOfListener
238 | * @private
239 | * @param {function} listener - Signal handler function.
240 | * @return {number} The index of the listener within the private bindings array.
241 | */
242 | _indexOfListener: function (listener, context) {
243 | var n = this._bindings.length;
244 | var cur;
245 |
246 | while (n--) {
247 | cur = this._bindings[n];
248 |
249 | if (cur._listener === listener && cur.context === context) {
250 | return n;
251 | }
252 | }
253 |
254 | return -1;
255 | },
256 |
257 | /**
258 | * Check if listener was attached to Signal.
259 | *
260 | * @method Signal#has
261 | * @param {function} listener - Signal handler function.
262 | * @param {object} [context] - Context on which listener will be executed (object that should represent the `this` variable inside listener function).
263 | * @return {boolean} If Signal has the specified listener.
264 | */
265 | has: function (listener, context) {
266 | return this._indexOfListener(listener, context) !== -1;
267 | },
268 |
269 | /**
270 | * Add a listener to the signal.
271 | *
272 | * @method Signal#add
273 | * @param {function} listener - The function to call when this Signal is dispatched.
274 | * @param {object} [listenerContext] - The context under which the listener will be executed (i.e. the object that should represent the `this` variable).
275 | * @param {number} [priority] - The priority level of the event listener. Listeners with higher priority will be executed before listeners with lower priority. Listeners with same priority level will be executed at the same order as they were added (default = 0)
276 | * @return {SignalBinding} An Object representing the binding between the Signal and listener.
277 | */
278 | add: function (listener, listenerContext, priority) {
279 | this.validateListener(listener, 'add');
280 |
281 | return this._registerListener(listener, false, listenerContext, priority);
282 | },
283 |
284 | /**
285 | * Add listener to the signal that should be removed after first execution (will be executed only once).
286 | *
287 | * @method Signal#addOnce
288 | * @param {function} listener - The function to call when this Signal is dispatched.
289 | * @param {object} [listenerContext] - The context under which the listener will be executed (i.e. the object that should represent the `this` variable).
290 | * @param {number} [priority] - The priority level of the event listener. Listeners with higher priority will be executed before listeners with lower priority. Listeners with same priority level will be executed at the same order as they were added (default = 0)
291 | * @return {SignalBinding} An Object representing the binding between the Signal and listener.
292 | */
293 | addOnce: function (listener, listenerContext, priority) {
294 | this.validateListener(listener, 'addOnce');
295 |
296 | return this._registerListener(listener, true, listenerContext, priority);
297 | },
298 |
299 | /**
300 | * Remove a single listener from the dispatch queue.
301 | *
302 | * @method Signal#remove
303 | * @param {function} listener - Handler function that should be removed.
304 | * @param {object} [context] - Execution context (since you can add the same handler multiple times if executing in a different context).
305 | * @return {function} Listener handler function.
306 | */
307 | remove: function (listener, context) {
308 | this.validateListener(listener, 'remove');
309 |
310 | var i = this._indexOfListener(listener, context);
311 |
312 | if (i !== -1) {
313 | this._bindings[i]._destroy(); //no reason to a SignalBinding exist if it isn't attached to a signal
314 | this._bindings.splice(i, 1);
315 | }
316 |
317 | return listener;
318 | },
319 |
320 | /**
321 | * Remove all listeners from the Signal.
322 | *
323 | * @method Signal#removeAll
324 | * @param {object} [context=null] - If specified only listeners for the given context will be removed.
325 | */
326 | removeAll: function (context) {
327 | if (typeof context === 'undefined') { context = null; }
328 |
329 | var n = this._bindings.length;
330 |
331 | while (n--) {
332 | if (context) {
333 | if (this._bindings[n].context === context) {
334 | this._bindings[n]._destroy();
335 | this._bindings.splice(n, 1);
336 | }
337 | }
338 | else {
339 | this._bindings[n]._destroy();
340 | }
341 | }
342 |
343 | if (!context) {
344 | this._bindings.length = 0;
345 | }
346 | },
347 |
348 | /**
349 | * Gets the total number of listeneres attached to ths Signal.
350 | *
351 | * @method Signal#getNumListeners
352 | * @return {number} Number of listeners attached to the Signal.
353 | */
354 | getNumListeners: function () {
355 | return this._bindings.length;
356 | },
357 |
358 | /**
359 | * Stop propagation of the event, blocking the dispatch to next listeners on the queue.
360 | * IMPORTANT: should be called only during signal dispatch, calling it before/after dispatch won't affect signal broadcast.
361 | * @see Signal.prototype.disable
362 | *
363 | * @method Signal#halt
364 | */
365 | halt: function () {
366 | this._shouldPropagate = false;
367 | },
368 |
369 | /**
370 | * Dispatch/Broadcast Signal to all listeners added to the queue.
371 | *
372 | * @method Signal#dispatch
373 | * @param {any} [params] - Parameters that should be passed to each handler.
374 | */
375 | dispatch: function () {
376 | if (!this.active) {
377 | return;
378 | }
379 |
380 | var paramsArr = Array.prototype.slice.call(arguments);
381 | var n = this._bindings.length;
382 | var bindings;
383 |
384 | if (this.memorize) {
385 | this._prevParams = paramsArr;
386 | }
387 |
388 | if (!n) {
389 | // Should come after memorize
390 | return;
391 | }
392 |
393 | bindings = this._bindings.slice(); //clone array in case add/remove items during dispatch
394 | this._shouldPropagate = true; //in case `halt` was called before dispatch or during the previous dispatch.
395 |
396 | //execute all callbacks until end of the list or until a callback returns `false` or stops propagation
397 | //reverse loop since listeners with higher priority will be added at the end of the list
398 | do {
399 | n--;
400 | }
401 | while (bindings[n] && this._shouldPropagate && bindings[n].execute(paramsArr) !== false);
402 | },
403 |
404 | /**
405 | * Forget memorized arguments.
406 | * @see Signal.memorize
407 | *
408 | * @method Signal#forget
409 | */
410 | forget: function() {
411 | this._prevParams = null;
412 | },
413 |
414 | /**
415 | * Remove all bindings from signal and destroy any reference to external objects (destroy Signal object).
416 | * IMPORTANT: calling any method on the signal instance after calling dispose will throw errors.
417 | *
418 | * @method Signal#dispose
419 | */
420 | dispose: function () {
421 | this.removeAll();
422 |
423 | delete this._bindings;
424 | delete this._prevParams;
425 | },
426 |
427 | /**
428 | *
429 | * @method Signal#toString
430 | * @return {string} String representation of the object.
431 | */
432 | toString: function () {
433 | return '[Signal active:'+ this.active +' numListeners:'+ this.getNumListeners() +']';
434 | }
435 |
436 | };
437 |
438 | Signal.prototype.constructor = Signal;
439 |
440 | vg.Signal = Signal;
441 | }());
442 |
--------------------------------------------------------------------------------
/editor/lib/riot.min.js:
--------------------------------------------------------------------------------
1 | /* Riot v2.3.12, @license MIT, (c) 2015 Muut Inc. + contributors */
2 | (function(e,t){"use strict";var n={version:"v2.3.12",settings:{}},r=0,i=[],o={},f="riot-",u=f+"tag",a="string",s="object",c="undefined",l="function",p=/^(?:opt(ion|group)|tbody|col|t[rhd])$/,d=["_item","_id","_parent","update","root","mount","unmount","mixin","isMounted","isLoop","tags","parent","opts","trigger","on","off","one"],g=(e&&e.document||{}).documentMode|0;n.observable=function(e){e=e||{};var t={},n=function(e,t){e.replace(/\S+/g,t)},r=function(t,n){Object.defineProperty(e,t,{value:n,enumerable:false,writable:false,configurable:false})};r("on",function(r,i){if(typeof i!="function")return e;n(r,function(e,n){(t[e]=t[e]||[]).push(i);i.typed=n>0});return e});r("off",function(r,i){if(r=="*")t={};else{n(r,function(e){if(i){var n=t[e];for(var r=0,o;o=n&&n[r];++r){if(o==i)n.splice(r--,1)}}else delete t[e]})}return e});r("one",function(t,n){function r(){e.off(t,r);n.apply(e,arguments)}return e.on(t,r)});r("trigger",function(r){var i=arguments.length-1,o=new Array(i);for(var f=0;fa-zA-Z0-9'",;\\]/.test(e)){throw new Error('Unsupported brackets "'+e+'"')}r=r.concat(e.replace(/(?=[[\]()*+?.^$|])/g,"\\").split(" "));n=p}r[4]=n(r[1].length>1?/{[\S\s]*?}/:/{[^}]*}/,r);r[5]=n(/\\({|})/g,r);r[6]=n(/(\\?)({)/g,r);r[7]=RegExp("(\\\\?)(?:([[({])|("+r[3]+"))|"+o,t);r[8]=e;return r}function g(e){if(!e)e=f;if(e!==c[8]){c=d(e);s=e===f?l:p;c[9]=s(/^\s*{\^?\s*([$\w]+)(?:\s*,\s*(\S+))?\s+in\s+(\S.*)\s*}/);c[10]=s(/(^|[^\\]){=[\S\s]*?}/);h._rawOffset=c[0].length}a=e}function h(e){return e instanceof RegExp?s(e):c[e]}h.split=function y(e,t,n){if(!n)n=c;var r=[],i,o,f,a,s=n[6];o=f=s.lastIndex=0;while(i=s.exec(e)){a=i.index;if(o){if(i[2]){s.lastIndex=p(i[2],s.lastIndex);continue}if(!i[3])continue}if(!i[1]){l(e.slice(f,a));f=s.lastIndex;s=n[6+(o^=1)];s.lastIndex=f}}if(e&&f2||r[0]){var i,o,u=[];for(i=o=0;i2&&!t?""+(n.push(e)-1)+"~":e}).replace(/\s+/g," ").trim().replace(/\ ?([[\({},?\.:])\ ?/g,"$1");if(e){var r=[],i=0,f;while(e&&(f=e.match(a))&&!f.index){var u,s,c=/,|([[{(])|$/g;e=RegExp.rightContext;u=f[2]?n[f[2]].slice(1,-1).trim().replace(/\s+/g," "):f[1];while(s=(f=c.exec(e))[1])l(s,c);s=e.slice(0,f.index);e=RegExp.rightContext;r[i++]=d(s,1,u)}e=!i?d(e,t):i>1?"["+r.join(",")+'].join(" ").trim()':r[0]}return e;function l(t,n){var r,i=1,o=t==="("?/[()]/g:t==="["?/[[\]]/g:/[{}]/g;o.lastIndex=n.lastIndex;while(r=o.exec(e)){if(r[0]===t)++i;else if(!--i)break}n.lastIndex=i?e.length:o.lastIndex}}var l='"in this?this:'+(typeof e!=="object"?"global":"window")+").";var p=/[,{][$\w]+:|(^ *|[^$\w\.])(?!(?:typeof|true|false|null|undefined|in|instanceof|is(?:Finite|NaN)|void|NaN|new|Date|RegExp|Math)(?![$\w]))([$_A-Za-z][$\w]*)/g;function d(e,t,n){var r;e=e.replace(p,function(e,t,n,i,o){if(n){i=r?0:i+e.length;if(n!=="this"&&n!=="global"&&n!=="window"){e=t+'("'+n+l+n;if(i)r=(o=o[i])==="."||o==="("||o==="["}else if(i)r=!/^(?=(\.[$\w]+))\1(?:[^.[(]|$)/.test(o.slice(i))}return e});if(r){e="try{return "+e+"}catch(e){E(e,this)}"}if(n){e=(r?"function(){"+e+"}.call(this)":"("+e+")")+'?"'+n+'":""'}else if(t){e="function(v){"+(r?e.replace("return ","v="):"v=("+e+")")+';return v||v===0?v:""}.call(this)'}return e}n.parse=function(e){return e};return n}();v.version=h.version="v2.3.19";var m=function(e){var t={tr:"tbody",th:"tr",td:"tr",tbody:"table",col:"colgroup"},n="div";e=e&&e<10;function r(r){var o=r&&r.match(/^\s*<([-\w]+)/),f=o&&o[1].toLowerCase(),u=t[f]||n,a=W(u);a.stub=true;if(e&&f&&(o=f.match(p)))i(a,r,f,!!o[1]);else a.innerHTML=r;return a}function i(e,t,r,i){var o=W(n),f=i?"select>":"table>",u;o.innerHTML="<"+f+t+"r){var i=t[--n];t.splice(n,1);i.unmount()}}function w(e,t){Object.keys(e.tags).forEach(function(n){var r=e.tags[n];if(U(r))A(r,function(e){F(e,n,t)});else F(r,n,t)})}function x(e,t,n){var r=e._root;e._virts=[];while(r){var i=r.nextSibling;if(n)t.insertBefore(r,n._root);else t.appendChild(r);e._virts.push(r);r=i}}function _(e,t,n,r){var i=e._root;for(var o=0;o|>\s*<\/yield\s*>)/gi,t||"")}function ee(e,t){return(t||document).querySelectorAll(e)}function te(e,t){return(t||document).querySelector(e)}function ne(e){function t(){}t.prototype=e;return new t}function re(e){return R(e,"id")||R(e,"name")}function ie(e,t,n){var r=re(e),i=function(i){if(z(n,r))return;var o=U(i);if(!i)t[r]=e;else if(!o||o&&!z(i,e)){if(o)i.push(e);else t[r]=[i,e]}};if(!r)return;if(v.hasExpr(r))t.one("updated",function(){r=re(e);i(t[r])});else i(t[r])}function oe(e,t){return e.slice(0,t.length)===t}var fe=function(){if(!e)return;var t=W("style"),n=te("style[type=riot]");k(t,"type","text/css");if(n){n.parentNode.replaceChild(t,n);n=null}else document.getElementsByTagName("head")[0].appendChild(t);return t.styleSheet?function(e){t.styleSheet.cssText+=e}:function(e){t.innerHTML+=e}}();var ue=function(e){return e.requestAnimationFrame||e.webkitRequestAnimationFrame||e.mozRequestAnimationFrame||function(e){setTimeout(e,1e3/60)}}(e||{});function ae(e,t,n){var r=o[t],f=e._innerHTML=e._innerHTML||e.innerHTML;e.innerHTML="";if(r&&e)r=new C(r,{root:e,opts:n},f);if(r&&r.mount){r.mount();if(!z(i,r))i.push(r)}return r}n.util={brackets:h,tmpl:v};n.mixin=function(){var e={};return function(t,n){if(!n)return e[t];e[t]=n}}();n.tag=function(e,t,n,r,i){if(O(r)){i=r;if(/^[\w\-]+\s?=/.test(n)){r=n;n=""}else r=""}if(n){if(O(n))i=n;else if(fe)fe(n)}o[e]={name:e,tmpl:t,attrs:r,fn:i};return e};n.tag2=function(e,t,n,r,i,f){if(n&&fe)fe(n);o[e]={name:e,tmpl:t,attrs:r,fn:i};return e};n.mount=function(e,t,n){var r,i,f=[];function c(e){var t="";A(e,function(e){t+=", *["+u+'="'+e.trim()+'"]'});return t}function l(){var e=Object.keys(o);return e+c(e)}function p(e){var r;if(e.tagName){if(t&&(!(r=R(e,u))||r!=t))k(e,u,t);var i=ae(e,t||e.getAttribute(u)||e.tagName.toLowerCase(),n);if(i)f.push(i)}else if(e.length)A(e,p)}if(typeof t===s){n=t;t=0}if(typeof e===a){if(e==="*")e=i=l();else e+=c(e.split(","));r=e?ee(e):[]}else r=e;if(t==="*"){t=i||l();if(r.tagName)r=ee(t,r);else{var d=[];A(r,function(e){d.push(ee(t,e))});r=d}t=0}if(r.tagName)p(r);else A(r,p);return f};n.update=function(){return A(i,function(e){e.update()})};n.Tag=C;if(typeof exports===s)module.exports=n;else if(typeof define===l&&typeof define.amd!==c)define(function(){return e.riot=n});else e.riot=n})(typeof window!="undefined"?window:void 0);
3 |
--------------------------------------------------------------------------------
/lib/OrbitControls.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @author qiao / https://github.com/qiao
3 | * @author mrdoob / http://mrdoob.com
4 | * @author alteredq / http://alteredqualia.com/
5 | * @author WestLangley / http://github.com/WestLangley
6 | * @author erich666 / http://erichaines.com
7 | */
8 | /*global THREE, console */
9 |
10 | // This set of controls performs orbiting, dollying (zooming), and panning. It maintains
11 | // the "up" direction as +Y, unlike the TrackballControls. Touch on tablet and phones is
12 | // supported.
13 | //
14 | // Orbit - left mouse / touch: one finger move
15 | // Zoom - middle mouse, or mousewheel / touch: two finger spread or squish
16 | // Pan - right mouse, or arrow keys / touch: three finter swipe
17 | //
18 | // This is a drop-in replacement for (most) TrackballControls used in examples.
19 | // That is, include this js file and wherever you see:
20 | // controls = new THREE.TrackballControls( camera );
21 | // controls.target.z = 150;
22 | // Simple substitute "OrbitControls" and the control should work as-is.
23 |
24 | THREE.OrbitControls = function ( object, domElement ) {
25 |
26 | this.object = object;
27 | this.domElement = ( domElement !== undefined ) ? domElement : document;
28 |
29 | // API
30 |
31 | // Set to false to disable this control
32 | this.enabled = true;
33 |
34 | // "target" sets the location of focus, where the control orbits around
35 | // and where it pans with respect to.
36 | this.target = new THREE.Vector3();
37 |
38 | // center is old, deprecated; use "target" instead
39 | this.center = this.target;
40 |
41 | // This option actually enables dollying in and out; left as "zoom" for
42 | // backwards compatibility
43 | this.noZoom = false;
44 | this.zoomSpeed = 1.0;
45 |
46 | // Limits to how far you can dolly in and out
47 | this.minDistance = 0;
48 | this.maxDistance = Infinity;
49 |
50 | // Set to true to disable this control
51 | this.noRotate = false;
52 | this.rotateSpeed = 1.0;
53 |
54 | // Set to true to disable this control
55 | this.noPan = false;
56 | this.keyPanSpeed = 7.0; // pixels moved per arrow key push
57 |
58 | // Set to true to automatically rotate around the target
59 | this.autoRotate = false;
60 | this.autoRotateSpeed = 2.0; // 30 seconds per round when fps is 60
61 |
62 | // How far you can orbit vertically, upper and lower limits.
63 | // Range is 0 to Math.PI radians.
64 | this.minPolarAngle = 0; // radians
65 | this.maxPolarAngle = Math.PI; // radians
66 |
67 | // How far you can orbit horizontally, upper and lower limits.
68 | // If set, must be a sub-interval of the interval [ - Math.PI, Math.PI ].
69 | this.minAzimuthAngle = - Infinity; // radians
70 | this.maxAzimuthAngle = Infinity; // radians
71 |
72 | // Set to true to disable use of the keys
73 | this.noKeys = false;
74 |
75 | // The four arrow keys
76 | this.keys = { LEFT: 37, UP: 38, RIGHT: 39, BOTTOM: 40 };
77 |
78 | // Mouse buttons
79 | this.mouseButtons = { ORBIT: THREE.MOUSE.LEFT, ZOOM: THREE.MOUSE.MIDDLE, PAN: THREE.MOUSE.RIGHT };
80 |
81 | ////////////
82 | // internals
83 |
84 | var scope = this;
85 |
86 | var EPS = 0.000001;
87 |
88 | var rotateStart = new THREE.Vector2();
89 | var rotateEnd = new THREE.Vector2();
90 | var rotateDelta = new THREE.Vector2();
91 |
92 | var panStart = new THREE.Vector2();
93 | var panEnd = new THREE.Vector2();
94 | var panDelta = new THREE.Vector2();
95 | var panOffset = new THREE.Vector3();
96 |
97 | var offset = new THREE.Vector3();
98 |
99 | var dollyStart = new THREE.Vector2();
100 | var dollyEnd = new THREE.Vector2();
101 | var dollyDelta = new THREE.Vector2();
102 |
103 | var theta;
104 | var phi;
105 | var phiDelta = 0;
106 | var thetaDelta = 0;
107 | var scale = 1;
108 | var pan = new THREE.Vector3();
109 |
110 | var lastPosition = new THREE.Vector3();
111 | var lastQuaternion = new THREE.Quaternion();
112 |
113 | var STATE = { NONE : -1, ROTATE : 0, DOLLY : 1, PAN : 2, TOUCH_ROTATE : 3, TOUCH_DOLLY : 4, TOUCH_PAN : 5 };
114 |
115 | var state = STATE.NONE;
116 |
117 | // for reset
118 |
119 | this.target0 = this.target.clone();
120 | this.position0 = this.object.position.clone();
121 |
122 | // so camera.up is the orbit axis
123 |
124 | var quat = new THREE.Quaternion().setFromUnitVectors( object.up, new THREE.Vector3( 0, 1, 0 ) );
125 | var quatInverse = quat.clone().inverse();
126 |
127 | // events
128 |
129 | var changeEvent = { type: 'change' };
130 | var startEvent = { type: 'start'};
131 | var endEvent = { type: 'end'};
132 | var wheelEvent = { type: 'wheel'};
133 |
134 | this.rotateLeft = function ( angle ) {
135 |
136 | if ( angle === undefined ) {
137 |
138 | angle = getAutoRotationAngle();
139 |
140 | }
141 |
142 | thetaDelta -= angle;
143 |
144 | };
145 |
146 | this.rotateUp = function ( angle ) {
147 |
148 | if ( angle === undefined ) {
149 |
150 | angle = getAutoRotationAngle();
151 |
152 | }
153 |
154 | phiDelta -= angle;
155 |
156 | };
157 |
158 | // pass in distance in world space to move left
159 | this.panLeft = function ( distance ) {
160 |
161 | var te = this.object.matrix.elements;
162 |
163 | // get X column of matrix
164 | panOffset.set( te[ 0 ], te[ 1 ], te[ 2 ] );
165 | panOffset.multiplyScalar( - distance );
166 |
167 | pan.add( panOffset );
168 |
169 | };
170 |
171 | // pass in distance in world space to move up
172 | this.panUp = function ( distance ) {
173 |
174 | var te = this.object.matrix.elements;
175 |
176 | // get Y column of matrix
177 | panOffset.set( te[ 4 ], te[ 5 ], te[ 6 ] );
178 | panOffset.multiplyScalar( distance );
179 |
180 | pan.add( panOffset );
181 |
182 | };
183 |
184 | // pass in x,y of change desired in pixel space,
185 | // right and down are positive
186 | this.pan = function ( deltaX, deltaY ) {
187 |
188 | var element = scope.domElement === document ? scope.domElement.body : scope.domElement;
189 |
190 | if ( scope.object.fov !== undefined ) {
191 |
192 | // perspective
193 | var position = scope.object.position;
194 | var offset = position.clone().sub( scope.target );
195 | var targetDistance = offset.length();
196 |
197 | // half of the fov is center to top of screen
198 | targetDistance *= Math.tan( ( scope.object.fov / 2 ) * Math.PI / 180.0 );
199 |
200 | // we actually don't use screenWidth, since perspective camera is fixed to screen height
201 | scope.panLeft( 2 * deltaX * targetDistance / element.clientHeight );
202 | scope.panUp( 2 * deltaY * targetDistance / element.clientHeight );
203 |
204 | } else if ( scope.object.top !== undefined ) {
205 |
206 | // orthographic
207 | scope.panLeft( deltaX * (scope.object.right - scope.object.left) / element.clientWidth );
208 | scope.panUp( deltaY * (scope.object.top - scope.object.bottom) / element.clientHeight );
209 |
210 | } else {
211 |
212 | // camera neither orthographic or perspective
213 | console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.' );
214 |
215 | }
216 |
217 | };
218 |
219 | this.dollyIn = function ( dollyScale ) {
220 |
221 | if ( dollyScale === undefined ) {
222 |
223 | dollyScale = getZoomScale();
224 |
225 | }
226 |
227 | scale /= dollyScale;
228 |
229 | };
230 |
231 | this.dollyOut = function ( dollyScale ) {
232 |
233 | if ( dollyScale === undefined ) {
234 |
235 | dollyScale = getZoomScale();
236 |
237 | }
238 |
239 | scale *= dollyScale;
240 |
241 | };
242 |
243 | this.update = function () {
244 |
245 | var position = this.object.position;
246 |
247 | offset.copy( position ).sub( this.target );
248 |
249 | // rotate offset to "y-axis-is-up" space
250 | offset.applyQuaternion( quat );
251 |
252 | // angle from z-axis around y-axis
253 |
254 | theta = Math.atan2( offset.x, offset.z );
255 |
256 | // angle from y-axis
257 |
258 | phi = Math.atan2( Math.sqrt( offset.x * offset.x + offset.z * offset.z ), offset.y );
259 |
260 | if ( this.autoRotate && state === STATE.NONE ) {
261 |
262 | this.rotateLeft( getAutoRotationAngle() );
263 |
264 | }
265 |
266 | theta += thetaDelta;
267 | phi += phiDelta;
268 |
269 | // restrict theta to be between desired limits
270 | theta = Math.max( this.minAzimuthAngle, Math.min( this.maxAzimuthAngle, theta ) );
271 |
272 | // restrict phi to be between desired limits
273 | phi = Math.max( this.minPolarAngle, Math.min( this.maxPolarAngle, phi ) );
274 |
275 | // restrict phi to be betwee EPS and PI-EPS
276 | phi = Math.max( EPS, Math.min( Math.PI - EPS, phi ) );
277 |
278 | var radius = offset.length() * scale;
279 |
280 | // restrict radius to be between desired limits
281 | radius = Math.max( this.minDistance, Math.min( this.maxDistance, radius ) );
282 |
283 | // move target to panned location
284 | this.target.add( pan );
285 |
286 | offset.x = radius * Math.sin( phi ) * Math.sin( theta );
287 | offset.y = radius * Math.cos( phi );
288 | offset.z = radius * Math.sin( phi ) * Math.cos( theta );
289 |
290 | // rotate offset back to "camera-up-vector-is-up" space
291 | offset.applyQuaternion( quatInverse );
292 |
293 | position.copy( this.target ).add( offset );
294 |
295 | this.object.lookAt( this.target );
296 |
297 | thetaDelta = 0;
298 | phiDelta = 0;
299 | scale = 1;
300 | pan.set( 0, 0, 0 );
301 |
302 | // update condition is:
303 | // min(camera displacement, camera rotation in radians)^2 > EPS
304 | // using small-angle approximation cos(x/2) = 1 - x^2 / 8
305 |
306 | if ( lastPosition.distanceToSquared( this.object.position ) > EPS
307 | || 8 * (1 - lastQuaternion.dot(this.object.quaternion)) > EPS ) {
308 |
309 | this.dispatchEvent( changeEvent );
310 |
311 | lastPosition.copy( this.object.position );
312 | lastQuaternion.copy (this.object.quaternion );
313 |
314 | }
315 |
316 | };
317 |
318 |
319 | this.reset = function () {
320 |
321 | state = STATE.NONE;
322 |
323 | this.target.copy( this.target0 );
324 | this.object.position.copy( this.position0 );
325 |
326 | this.update();
327 |
328 | };
329 |
330 | this.getPolarAngle = function () {
331 |
332 | return phi;
333 |
334 | };
335 |
336 | this.getAzimuthalAngle = function () {
337 |
338 | return theta
339 |
340 | };
341 |
342 | function getAutoRotationAngle() {
343 |
344 | return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
345 |
346 | }
347 |
348 | function getZoomScale() {
349 |
350 | return Math.pow( 0.95, scope.zoomSpeed );
351 |
352 | }
353 |
354 | function onMouseDown( event ) {
355 |
356 | if ( scope.enabled === false ) return;
357 | event.preventDefault();
358 |
359 | if ( event.button === scope.mouseButtons.ORBIT ) {
360 | if ( scope.noRotate === true ) return;
361 |
362 | state = STATE.ROTATE;
363 |
364 | rotateStart.set( event.clientX, event.clientY );
365 |
366 | } else if ( event.button === scope.mouseButtons.ZOOM ) {
367 | if ( scope.noZoom === true ) return;
368 |
369 | state = STATE.DOLLY;
370 |
371 | dollyStart.set( event.clientX, event.clientY );
372 |
373 | } else if ( event.button === scope.mouseButtons.PAN ) {
374 | if ( scope.noPan === true ) return;
375 |
376 | state = STATE.PAN;
377 |
378 | panStart.set( event.clientX, event.clientY );
379 |
380 | }
381 |
382 | if ( state !== STATE.NONE ) {
383 | document.addEventListener( 'mousemove', onMouseMove, false );
384 | document.addEventListener( 'mouseup', onMouseUp, false );
385 | scope.dispatchEvent( startEvent );
386 | }
387 |
388 | }
389 |
390 | function onMouseMove( event ) {
391 |
392 | if ( scope.enabled === false ) return;
393 |
394 | event.preventDefault();
395 |
396 | var element = scope.domElement === document ? scope.domElement.body : scope.domElement;
397 |
398 | if ( state === STATE.ROTATE ) {
399 |
400 | if ( scope.noRotate === true ) return;
401 |
402 | rotateEnd.set( event.clientX, event.clientY );
403 | rotateDelta.subVectors( rotateEnd, rotateStart );
404 |
405 | // rotating across whole screen goes 360 degrees around
406 | scope.rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed );
407 |
408 | // rotating up and down along whole screen attempts to go 360, but limited to 180
409 | scope.rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed );
410 |
411 | rotateStart.copy( rotateEnd );
412 |
413 | } else if ( state === STATE.DOLLY ) {
414 |
415 | if ( scope.noZoom === true ) return;
416 |
417 | dollyEnd.set( event.clientX, event.clientY );
418 | dollyDelta.subVectors( dollyEnd, dollyStart );
419 |
420 | if ( dollyDelta.y > 0 ) {
421 |
422 | scope.dollyIn();
423 |
424 | } else {
425 |
426 | scope.dollyOut();
427 |
428 | }
429 |
430 | dollyStart.copy( dollyEnd );
431 |
432 | } else if ( state === STATE.PAN ) {
433 |
434 | if ( scope.noPan === true ) return;
435 |
436 | panEnd.set( event.clientX, event.clientY );
437 | panDelta.subVectors( panEnd, panStart );
438 |
439 | scope.pan( panDelta.x, panDelta.y );
440 |
441 | panStart.copy( panEnd );
442 |
443 | }
444 |
445 | if ( state !== STATE.NONE ) scope.update();
446 |
447 | }
448 |
449 | function onMouseUp( /* event */ ) {
450 |
451 | if ( scope.enabled === false ) return;
452 |
453 | document.removeEventListener( 'mousemove', onMouseMove, false );
454 | document.removeEventListener( 'mouseup', onMouseUp, false );
455 | scope.dispatchEvent( endEvent );
456 | state = STATE.NONE;
457 |
458 | }
459 |
460 | function onMouseWheel( event ) {
461 |
462 | if ( scope.enabled === false || scope.noZoom === true || state !== STATE.NONE ) return;
463 |
464 | event.preventDefault();
465 | event.stopPropagation();
466 |
467 | var delta = 0;
468 |
469 | if ( event.wheelDelta !== undefined ) { // WebKit / Opera / Explorer 9
470 |
471 | delta = event.wheelDelta;
472 |
473 | } else if ( event.detail !== undefined ) { // Firefox
474 |
475 | delta = - event.detail;
476 |
477 | }
478 |
479 | if ( delta > 0 ) {
480 |
481 | scope.dollyOut();
482 |
483 | } else {
484 |
485 | scope.dollyIn();
486 |
487 | }
488 |
489 | scope.update();
490 | scope.dispatchEvent( wheelEvent );
491 | // scope.dispatchEvent( endEvent );
492 |
493 | }
494 |
495 | function onKeyDown( event ) {
496 |
497 | if ( scope.enabled === false || scope.noKeys === true || scope.noPan === true ) return;
498 |
499 | switch ( event.keyCode ) {
500 |
501 | case scope.keys.UP:
502 | scope.pan( 0, scope.keyPanSpeed );
503 | scope.update();
504 | break;
505 |
506 | case scope.keys.BOTTOM:
507 | scope.pan( 0, - scope.keyPanSpeed );
508 | scope.update();
509 | break;
510 |
511 | case scope.keys.LEFT:
512 | scope.pan( scope.keyPanSpeed, 0 );
513 | scope.update();
514 | break;
515 |
516 | case scope.keys.RIGHT:
517 | scope.pan( - scope.keyPanSpeed, 0 );
518 | scope.update();
519 | break;
520 |
521 | }
522 |
523 | }
524 |
525 | function touchstart( event ) {
526 |
527 | if ( scope.enabled === false ) return;
528 |
529 | switch ( event.touches.length ) {
530 |
531 | case 1: // one-fingered touch: rotate
532 |
533 | if ( scope.noRotate === true ) return;
534 |
535 | state = STATE.TOUCH_ROTATE;
536 |
537 | rotateStart.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );
538 | break;
539 |
540 | case 2: // two-fingered touch: dolly
541 |
542 | if ( scope.noZoom === true ) return;
543 |
544 | state = STATE.TOUCH_DOLLY;
545 |
546 | var dx = event.touches[ 0 ].pageX - event.touches[ 1 ].pageX;
547 | var dy = event.touches[ 0 ].pageY - event.touches[ 1 ].pageY;
548 | var distance = Math.sqrt( dx * dx + dy * dy );
549 | dollyStart.set( 0, distance );
550 | break;
551 |
552 | case 3: // three-fingered touch: pan
553 |
554 | if ( scope.noPan === true ) return;
555 |
556 | state = STATE.TOUCH_PAN;
557 |
558 | panStart.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );
559 | break;
560 |
561 | default:
562 |
563 | state = STATE.NONE;
564 |
565 | }
566 |
567 | if ( state !== STATE.NONE ) scope.dispatchEvent( startEvent );
568 |
569 | }
570 |
571 | function touchmove( event ) {
572 |
573 | if ( scope.enabled === false ) return;
574 |
575 | event.preventDefault();
576 | event.stopPropagation();
577 |
578 | var element = scope.domElement === document ? scope.domElement.body : scope.domElement;
579 |
580 | switch ( event.touches.length ) {
581 |
582 | case 1: // one-fingered touch: rotate
583 |
584 | if ( scope.noRotate === true ) return;
585 | if ( state !== STATE.TOUCH_ROTATE ) return;
586 |
587 | rotateEnd.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );
588 | rotateDelta.subVectors( rotateEnd, rotateStart );
589 |
590 | // rotating across whole screen goes 360 degrees around
591 | scope.rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed );
592 | // rotating up and down along whole screen attempts to go 360, but limited to 180
593 | scope.rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed );
594 |
595 | rotateStart.copy( rotateEnd );
596 |
597 | scope.update();
598 | break;
599 |
600 | case 2: // two-fingered touch: dolly
601 |
602 | if ( scope.noZoom === true ) return;
603 | if ( state !== STATE.TOUCH_DOLLY ) return;
604 |
605 | var dx = event.touches[ 0 ].pageX - event.touches[ 1 ].pageX;
606 | var dy = event.touches[ 0 ].pageY - event.touches[ 1 ].pageY;
607 | var distance = Math.sqrt( dx * dx + dy * dy );
608 |
609 | dollyEnd.set( 0, distance );
610 | dollyDelta.subVectors( dollyEnd, dollyStart );
611 |
612 | if ( dollyDelta.y > 0 ) {
613 |
614 | scope.dollyOut();
615 |
616 | } else {
617 |
618 | scope.dollyIn();
619 |
620 | }
621 |
622 | dollyStart.copy( dollyEnd );
623 |
624 | scope.update();
625 | break;
626 |
627 | case 3: // three-fingered touch: pan
628 |
629 | if ( scope.noPan === true ) return;
630 | if ( state !== STATE.TOUCH_PAN ) return;
631 |
632 | panEnd.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );
633 | panDelta.subVectors( panEnd, panStart );
634 |
635 | scope.pan( panDelta.x, panDelta.y );
636 |
637 | panStart.copy( panEnd );
638 |
639 | scope.update();
640 | break;
641 |
642 | default:
643 |
644 | state = STATE.NONE;
645 |
646 | }
647 |
648 | }
649 |
650 | function touchend( /* event */ ) {
651 |
652 | if ( scope.enabled === false ) return;
653 |
654 | scope.dispatchEvent( endEvent );
655 | state = STATE.NONE;
656 |
657 | }
658 |
659 | this.domElement.addEventListener( 'contextmenu', function ( event ) { event.preventDefault(); }, false );
660 | this.domElement.addEventListener( 'mousedown', onMouseDown, false );
661 | this.domElement.addEventListener( 'mousewheel', onMouseWheel, false );
662 | this.domElement.addEventListener( 'DOMMouseScroll', onMouseWheel, false ); // firefox
663 |
664 | this.domElement.addEventListener( 'touchstart', touchstart, false );
665 | this.domElement.addEventListener( 'touchend', touchend, false );
666 | this.domElement.addEventListener( 'touchmove', touchmove, false );
667 |
668 | window.addEventListener( 'keydown', onKeyDown, false );
669 |
670 | // force an update at start
671 | this.update();
672 |
673 | };
674 |
675 | THREE.OrbitControls.prototype = Object.create( THREE.EventDispatcher.prototype );
676 | THREE.OrbitControls.prototype.constructor = THREE.OrbitControls;
677 |
--------------------------------------------------------------------------------
/editor/app.js:
--------------------------------------------------------------------------------
1 | !function(){function e(e){if(n.hasOwnProperty(e))return n[e]
2 | throw'[require-shim] Cannot find module "'+e+'"'}function i(i,o,r){var d=null,t=r&&void 0!==r
3 | if(t){if(r.hasOwnProperty(i))throw"[define-shim] Module "+i+" already exists"}else if(n.hasOwnProperty(i))throw"[define-shim] Module "+i+" already exists"
4 | d="function"==typeof o?o(e):o,t?r[i]=d:n[i]=d}var n={}
5 | window.define=i,window.define.amd=!1,window.require=e}()
6 |
7 | window.addEventListener('load', function(evt) {
8 | var data = require('data');
9 | var tower = require('tower');
10 | var nexus = require('nexus');
11 | var keyboard = require('keyboard');
12 | var motor = require('motor');
13 |
14 | var Input = require('Input');
15 | var EditorPlane = require('EditorPlane');
16 |
17 | data.load();
18 | var map = data.get('map');
19 |
20 | var timeTilAutoSave = 200; // timer runs per frame, 60fps
21 | var saveTimer = 10;
22 | var dirtyMap = false;
23 | var shiftDown = false;
24 | var paintMode = false;
25 | var deleteMode = false;
26 | var addMode = false;
27 |
28 | var saveBtn = document.getElementById('save-btn');
29 | saveBtn.onmouseup = function(evt) {
30 | saveMap();
31 | return false;
32 | };
33 |
34 | var loadBtn = document.getElementById('load-btn');
35 | loadBtn.addEventListener('click', function() {
36 | fileInput.click();
37 | }, false);
38 |
39 | var fileInput = document.createElement('input');
40 | fileInput.type = 'file';
41 | fileInput.addEventListener('change', function(evt) {
42 | var file = fileInput.files[0];
43 | if (!file) {
44 | return;
45 | }
46 |
47 | var reader = new FileReader();
48 | reader.onload = function(e) {
49 | var json = null;
50 | try {
51 | json = JSON.parse(e.target.result);
52 | }
53 | catch(err) {
54 | console.warn('File is not json format');
55 | return;
56 | }
57 | loadMap(json);
58 | };
59 |
60 | reader.readAsText(file);
61 |
62 | return false;
63 | });
64 |
65 | keyboard.on();
66 | motor.on();
67 |
68 | // setup the thing
69 | var canvas = document.getElementById('view');
70 | var scene = new vg.Scene({
71 | element: canvas,
72 | cameraPosition: {x:0, y:300, z:120}
73 | }, true);
74 |
75 | // listen to the orbit controls to disable the raycaster while user adjusts the view
76 | scene.controls.addEventListener('wheel', onControlWheel);
77 |
78 | var grid = new vg.HexGrid({
79 | rings: 5,
80 | cellSize: 10
81 | });
82 | var board = new vg.Board(grid);
83 | var mouse = new vg.MouseCaster(board.group, scene.camera, canvas);
84 | var input = new Input(board.group, mouse);
85 | var plane = new EditorPlane(board.group, grid, mouse);
86 |
87 | nexus.input = input;
88 | nexus.plane = plane;
89 | nexus.board = board;
90 | nexus.grid = grid;
91 | nexus.scene = scene;
92 | nexus.mouse = mouse;
93 |
94 | var boardSize = 20; // TODO: get from settings
95 | plane.generatePlane(boardSize * boardSize * 1.8, boardSize * boardSize * 1.8);
96 | plane.addHoverMeshToGroup(scene.container);
97 |
98 | board.generateOverlay(boardSize);
99 |
100 | tower.tileAction.add(onMapChange, this);
101 |
102 | // scene.add(board.group);
103 | scene.focusOn(board.group);
104 |
105 | if (map) {
106 | loadMap(map);
107 | }
108 | else {
109 | board.generateTilemap();
110 | map = grid.toJSON();
111 | data.set('map', map);
112 | console.log('Created a new map');
113 | }
114 | scene.add(board.group);
115 |
116 | function update() {
117 | if (wheelTimer < 10) {
118 | wheelTimer++;
119 | if (wheelTimer === 10) {
120 | mouse.active = true;
121 | }
122 | }
123 | if (dirtyMap) {
124 | saveTimer--;
125 | if (saveTimer === 0) {
126 | dirtyMap = false;
127 | data.set('map', map);
128 | data.save();
129 | console.log('Map saved');
130 | }
131 | }
132 | mouse.update();
133 | input.update();
134 | plane.update();
135 | scene.render();
136 | };
137 | motor.add(update);
138 |
139 | var wheelTimer = 10;
140 | function onControlWheel() {
141 | mouse.active = false;
142 | wheelTimer = 0;
143 | }
144 |
145 | function onMapChange() {
146 | dirtyMap = true;
147 | saveTimer = timeTilAutoSave;
148 | map = grid.toJSON();
149 | }
150 |
151 | function loadMap(json) {
152 | grid.fromJSON(json);
153 | board.setGrid(grid);
154 |
155 | if (json.autogenerated) {
156 | board.generateTilemap();
157 | }
158 | console.log('Map load complete');
159 | }
160 |
161 | function saveMap() {
162 | var output = null;
163 |
164 | map = grid.toJSON();
165 |
166 | try {
167 | output = JSON.stringify(map, null, '\t');
168 | output = output.replace(/[\n\t]+([\d\.e\-\[\]]+)/g, '$1');
169 | } catch (e) {
170 | output = JSON.stringify(map);
171 | }
172 |
173 | exportString(output, 'hex-map.json');
174 | }
175 |
176 | // taken from https://github.com/mrdoob/three.js/blob/master/editor/js/Menubar.File.js
177 | var link = document.createElement('a');
178 | link.style.display = 'none';
179 | document.body.appendChild(link);
180 |
181 | function exportString(output, filename) {
182 | var blob = new Blob([output], {type: 'text/plain'});
183 | var objectURL = URL.createObjectURL(blob);
184 |
185 | link.href = objectURL;
186 | link.download = filename || 'data.json';
187 | link.target = '_blank';
188 |
189 | var evt = document.createEvent('MouseEvents');
190 | evt.initMouseEvent(
191 | 'click', true, false, window, 0, 0, 0, 0, 0,
192 | false, false, false, false, 0, null
193 | );
194 | link.dispatchEvent(evt);
195 | }
196 | });
197 | define('keyboard', function() {
198 |
199 | function onDown(evt) {
200 | switch (evt.keyCode) {
201 | case 16:
202 | k.shift = true;
203 | break;
204 | case 17:
205 | k.ctrl = true;
206 | break;
207 | }
208 | k.signal.dispatch(k.eventType.DOWN, evt.keyCode);
209 | }
210 |
211 | function onUp(evt) {
212 | switch (evt.keyCode) {
213 | case 16:
214 | k.shift = false;
215 | break;
216 | case 17:
217 | k.ctrl = false;
218 | break;
219 | }
220 | k.signal.dispatch(k.eventType.UP, evt.keyCode);
221 | }
222 |
223 | var k = {
224 | shift: false,
225 | ctrl: false,
226 |
227 | eventType: {
228 | DOWN: 'down',
229 | UP: 'up'
230 | },
231 |
232 | signal: new vg.Signal(),
233 |
234 | on: function() {
235 | document.addEventListener('keydown', onDown, false);
236 | document.addEventListener('keyup', onUp, false);
237 | },
238 |
239 | off: function() {
240 | document.removeEventListener('keydown', onDown);
241 | document.removeEventListener('keyup', onUp);
242 | },
243 |
244 | code: {
245 | A: 'A'.charCodeAt(0),
246 | B: 'B'.charCodeAt(0),
247 | C: 'C'.charCodeAt(0),
248 | D: 'D'.charCodeAt(0),
249 | E: 'E'.charCodeAt(0),
250 | F: 'F'.charCodeAt(0),
251 | G: 'G'.charCodeAt(0),
252 | H: 'H'.charCodeAt(0),
253 | I: 'I'.charCodeAt(0),
254 | J: 'J'.charCodeAt(0),
255 | K: 'K'.charCodeAt(0),
256 | L: 'L'.charCodeAt(0),
257 | M: 'M'.charCodeAt(0),
258 | N: 'N'.charCodeAt(0),
259 | O: 'O'.charCodeAt(0),
260 | P: 'P'.charCodeAt(0),
261 | Q: 'Q'.charCodeAt(0),
262 | R: 'R'.charCodeAt(0),
263 | S: 'S'.charCodeAt(0),
264 | T: 'T'.charCodeAt(0),
265 | U: 'U'.charCodeAt(0),
266 | V: 'V'.charCodeAt(0),
267 | W: 'W'.charCodeAt(0),
268 | X: 'X'.charCodeAt(0),
269 | Y: 'Y'.charCodeAt(0),
270 | Z: 'Z'.charCodeAt(0),
271 | ZERO: '0'.charCodeAt(0),
272 | ONE: '1'.charCodeAt(0),
273 | TWO: '2'.charCodeAt(0),
274 | THREE: '3'.charCodeAt(0),
275 | FOUR: '4'.charCodeAt(0),
276 | FIVE: '5'.charCodeAt(0),
277 | SIX: '6'.charCodeAt(0),
278 | SEVEN: '7'.charCodeAt(0),
279 | EIGHT: '8'.charCodeAt(0),
280 | NINE: '9'.charCodeAt(0),
281 | NUMPAD_0: 96,
282 | NUMPAD_1: 97,
283 | NUMPAD_2: 98,
284 | NUMPAD_3: 99,
285 | NUMPAD_4: 100,
286 | NUMPAD_5: 101,
287 | NUMPAD_6: 102,
288 | NUMPAD_7: 103,
289 | NUMPAD_8: 104,
290 | NUMPAD_9: 105,
291 | NUMPAD_MULTIPLY: 106,
292 | NUMPAD_ADD: 107,
293 | NUMPAD_ENTER: 108,
294 | NUMPAD_SUBTRACT: 109,
295 | NUMPAD_DECIMAL: 110,
296 | NUMPAD_DIVIDE: 111,
297 | F1: 112,
298 | F2: 113,
299 | F3: 114,
300 | F4: 115,
301 | F5: 116,
302 | F6: 117,
303 | F7: 118,
304 | F8: 119,
305 | F9: 120,
306 | F10: 121,
307 | F11: 122,
308 | F12: 123,
309 | F13: 124,
310 | F14: 125,
311 | F15: 126,
312 | COLON: 186,
313 | EQUALS: 187,
314 | UNDERSCORE: 189,
315 | QUESTION_MARK: 191,
316 | TILDE: 192,
317 | OPEN_BRACKET: 219,
318 | BACKWARD_SLASH: 220,
319 | CLOSED_BRACKET: 221,
320 | QUOTES: 222,
321 | BACKSPACE: 8,
322 | TAB: 9,
323 | CLEAR: 12,
324 | ENTER: 13,
325 | SHIFT: 16,
326 | CTRL: 17,
327 | ALT: 18,
328 | CAPS_LOCK: 20,
329 | ESC: 27,
330 | SPACEBAR: 32,
331 | PAGE_UP: 33,
332 | PAGE_DOWN: 34,
333 | END: 35,
334 | HOME: 36,
335 | LEFT: 37,
336 | UP: 38,
337 | RIGHT: 39,
338 | DOWN: 40,
339 | INSERT: 45,
340 | DELETE: 46,
341 | HELP: 47,
342 | NUM_LOCK: 144
343 | }
344 | };
345 |
346 | return k;
347 | });
348 |
349 | define('nexus', {
350 | grid: null,
351 | board: null,
352 | mouse: null,
353 | scene: null,
354 | input: null,
355 | plane: null,
356 | });
357 | define('tower', {
358 | tileAction: new vg.Signal(),
359 | objAction: new vg.Signal(),
360 | userAction: new vg.Signal(),
361 |
362 | saveMap: new vg.Signal(),
363 | loadMap: new vg.Signal(),
364 |
365 | TILE_CHANGE_HEIGHT: 'cell.change.height',
366 | TILE_ADD: 'cell.add',
367 | TILE_REMOVE: 'cell.remove',
368 | });
369 | /*
370 | Translates the MouseCaster's events into more relevant data that the editor uses.
371 | */
372 | define('Input', function() {
373 | var tower = require('tower');
374 | var nexus = require('nexus');
375 | var keyboard = require('keyboard');
376 |
377 | var Input = function(scene, mouse) {
378 | this.mouse = mouse;
379 | this.mouse.signal.add(this.onMouse, this);
380 |
381 | this.mouseDelta = new THREE.Vector3();
382 | this.mousePanMinDistance = 0.1;
383 | this.heightStep = 5;
384 | this.editorWorldPos = new THREE.Vector3(); // current grid position of mouse
385 |
386 | this.overTile = null;
387 |
388 | this._travel = 0;
389 |
390 | keyboard.signal.add(function(type, code) {
391 | if (type === keyboard.eventType.DOWN) {
392 | if (code === keyboard.code.SHIFT) nexus.scene.controls.enabled = false;
393 | }
394 | else {
395 | if (code === keyboard.code.SHIFT) nexus.scene.controls.enabled = true;
396 | }
397 | }, this);
398 | };
399 |
400 | Input.prototype = {
401 | update: function() {
402 | var hit = this.mouse.allHits[0];
403 | if (hit) {
404 | this.editorWorldPos.x = hit.point.x;
405 | this.editorWorldPos.y = hit.point.y;
406 | this.editorWorldPos.z = hit.point.z;
407 | }
408 | var dx = this.mouseDelta.x - this.mouse.screenPosition.x;
409 | var dy = this.mouseDelta.y - this.mouse.screenPosition.y;
410 | this._travel += Math.sqrt(dx * dx + dy * dy);
411 | },
412 |
413 | onMouse: function(type, obj) {
414 | var hit, cell;
415 | if (this.mouse.allHits && this.mouse.allHits[0]) {
416 | hit = this.mouse.allHits[0];
417 | }
418 | switch (type) {
419 | case vg.MouseCaster.WHEEL:
420 | tower.userAction.dispatch(vg.MouseCaster.WHEEL, this.overTile, obj);
421 | break;
422 |
423 | case vg.MouseCaster.OVER:
424 | if (obj) {
425 | this.overTile = obj.select();
426 | }
427 | tower.userAction.dispatch(vg.MouseCaster.OVER, this.overTile, hit);
428 | break;
429 |
430 | case vg.MouseCaster.OUT:
431 | if (obj) {
432 | obj.deselect();
433 | this.overTile = null;
434 | }
435 | tower.userAction.dispatch(vg.MouseCaster.OUT, this.overTile, hit);
436 | break;
437 |
438 | case vg.MouseCaster.DOWN:
439 | this.mouseDelta.copy(this.mouse.screenPosition);
440 | tower.userAction.dispatch(vg.MouseCaster.DOWN, this.overTile, hit);
441 | this._travel = 0;
442 | break;
443 |
444 | case vg.MouseCaster.UP:
445 | if (this._travel > this.mousePanMinDistance) {
446 | break;
447 | }
448 | tower.userAction.dispatch(vg.MouseCaster.UP, this.overTile, hit);
449 | break;
450 |
451 | case vg.MouseCaster.CLICK:
452 | tower.userAction.dispatch(vg.MouseCaster.CLICK, this.overTile, hit);
453 | break;
454 | }
455 | }
456 | };
457 |
458 | return Input;
459 | });
460 |
461 | /*
462 | 2D plane that the user moves mouse around on in order to build maps. Provides a working plane to navigate, and a visual aid for tile placement.
463 |
464 | @author Corey Birnbaum https://github.com/vonWolfehaus/
465 | */
466 | define('EditorPlane', function() {
467 |
468 | function EditorPlane(scene, grid, mouse) {
469 | this.nexus = require('nexus');
470 | this.tower = require('tower');
471 |
472 | this.geometry = null;
473 | this.mesh = null;
474 | this.material = new THREE.MeshBasicMaterial({
475 | color: 0xffffff,
476 | side: THREE.DoubleSide
477 | });
478 |
479 | this.scene = scene;
480 | this.grid = grid;
481 |
482 | this.hoverMesh = this.grid.generateTilePoly(new THREE.MeshBasicMaterial({
483 | color: 0x1aaeff,
484 | side: THREE.DoubleSide
485 | }));
486 |
487 | this.mouse = mouse;
488 |
489 | /*this.mouse.signal.add(onUserAction, this);
490 | function onUserAction(type, overCell) {
491 | switch (type) {
492 | case vg.MouseCaster.OVER:
493 | if (overCell) {
494 | this.hoverMesh.mesh.visible = false;
495 | }
496 | break;
497 |
498 | case vg.MouseCaster.OUT:
499 | this.hoverMesh.mesh.visible = true;
500 | break;
501 |
502 | case vg.MouseCaster.DOWN:
503 | this.hoverMesh.mesh.visible = false;
504 | break;
505 |
506 | case vg.MouseCaster.UP:
507 | if (!overCell) {
508 | this.hoverMesh.mesh.visible = true;
509 | }
510 | else {
511 | this.hoverMesh.mesh.visible = false;
512 | }
513 | break;
514 | }
515 | }*/
516 | }
517 |
518 | EditorPlane.prototype = {
519 |
520 | generatePlane: function(width, height) {
521 | if (this.mesh && this.mesh.parent) {
522 | this.mesh.parent.remove(this.mesh);
523 | }
524 | this.geometry = new THREE.PlaneBufferGeometry(width, width, 1, 1);
525 | this.mesh = new THREE.Mesh(this.geometry, this.material);
526 | this.mesh.rotation.x = 90 * vg.DEG_TO_RAD;
527 | this.mesh.position.y -= 0.1;
528 | this.scene.add(this.mesh);
529 | },
530 |
531 | addHoverMeshToGroup: function(group) {
532 | if (this.hoverMesh.parent) {
533 | this.hoverMesh.parent.remove(this.hoverMesh);
534 | }
535 | group.add(this.hoverMesh);
536 | },
537 |
538 | update: function() {
539 | if (this.mouse.allHits.length && !this.mouse.pickedObject) {
540 | var cell = this.grid.pixelToCell(this.nexus.input.editorWorldPos);
541 | this.hoverMesh.position.copy(this.grid.cellToPixel(cell));
542 | this.hoverMesh.position.y += 0.1;
543 | this.hoverMesh.visible = true;
544 | }
545 | else {
546 | this.hoverMesh.visible = false;
547 | }
548 | }
549 | };
550 |
551 | return EditorPlane;
552 | });
553 |
554 | /*
555 | This is the ONLY place in the app that has a requestAnimationFrame handler.
556 | All modules attach their functions to this module if they want in on the RAF.
557 | */
558 | define('motor', function() {
559 | var _brake = false;
560 | var _steps = [];
561 |
562 | function on() {
563 | _brake = false;
564 | window.requestAnimationFrame(_update);
565 | window.addEventListener('focus', onFocus, false);
566 | window.addEventListener('blur', onBlur, false);
567 | }
568 |
569 | function off() {
570 | _brake = true;
571 | window.removeEventListener('focus', onFocus, false);
572 | window.removeEventListener('blur', onBlur, false);
573 | }
574 |
575 | // in order to be able to ID functions we have to hash them to generate unique-ish keys for us to find them with later
576 | // if we don't do this, we won't be able to remove callbacks that were bound and save us from binding callbacks multiple times all over the place
577 | function add(cb, scope) {
578 | var k = _hashStr(cb.toString());
579 | var h = _has(k);
580 | if (h === -1) {
581 | _steps.push({
582 | func: cb,
583 | scope: scope,
584 | key: k
585 | });
586 | }
587 | }
588 |
589 | function remove(cb) {
590 | var k = _hashStr(cb.toString());
591 | var i = _has(k);
592 | if (i !== -1) {
593 | _steps.splice(i, 1);
594 | }
595 | }
596 |
597 | function _update() {
598 | if (_brake) return;
599 | window.requestAnimationFrame(_update);
600 |
601 | for (var i = 0; i < _steps.length; i++) {
602 | var o = _steps[i];
603 | o.func.call(o.scope || null);
604 | }
605 | }
606 |
607 | // check if the handler already has iaw.motor particular callback
608 | function _has(k) {
609 | var n = -1;
610 | var i;
611 | for (i = 0; i < _steps.length; i++) {
612 | n = _steps[i].key;
613 | if (n === k) {
614 | return i;
615 | }
616 | }
617 | return -1;
618 | }
619 |
620 | function onFocus(evt) {
621 | _brake = false;
622 | _update();
623 | }
624 |
625 | function onBlur(evt) {
626 | _brake = true;
627 | }
628 |
629 | function _hashStr(str) {
630 | var hash = 0, i, chr, len;
631 | if (str.length === 0) return hash;
632 | for (i = 0, len = str.length; i < len; i++) {
633 | chr = str.charCodeAt(i);
634 | hash = ((hash << 5) - hash) + chr;
635 | hash |= 0;
636 | }
637 | return hash;
638 | }
639 |
640 | return {
641 | on: on,
642 | off: off,
643 | add: add,
644 | remove: remove,
645 | }
646 | });
647 |
648 | /*
649 | Manages cells and objects on the map.
650 | */
651 | define('Editor', function() {
652 | var tower = require('tower');
653 | var nexus = require('nexus');
654 | var keyboard = require('keyboard');
655 | var motor = require('motor');
656 |
657 | // TODO: get these values from UI
658 | var heightStep = 3;
659 |
660 | // PRIVATE
661 | var lastHeight = 1;
662 | var currentGridCell = null;
663 | var prevGridCell = new THREE.Vector3();
664 | var _cel = new vg.Cell();
665 |
666 | tower.userAction.add(onUserAction, this);
667 | motor.add(update);
668 |
669 | function update() {
670 | currentGridCell = nexus.grid.pixelToCell(nexus.input.editorWorldPos);
671 | if (nexus.mouse.down && keyboard.shift && nexus.mouse.allHits && nexus.mouse.allHits.length) {
672 | // only check if the user's mouse is over the editor plane
673 | if (!currentGridCell.equals(prevGridCell)) {
674 | addTile(currentGridCell);
675 | }
676 | prevGridCell.copy(currentGridCell);
677 | }
678 | }
679 |
680 | function onUserAction(type, overTile, data) {
681 | var hit = nexus.mouse.allHits[0]
682 | switch (type) {
683 | case vg.MouseCaster.WHEEL:
684 | if (keyboard.shift && overTile) {
685 | if (!overTile.cell) {
686 | overTile.dispose();
687 | return;
688 | }
689 | _cel.copy(overTile.cell);
690 | _cel.tile = null;
691 |
692 | var dif = lastHeight - data;
693 | var last = _cel.h;
694 | _cel.h += dif > 0 ? -heightStep : heightStep;
695 | if (_cel.h < 1) _cel.h = 1;
696 |
697 | nexus.mouse.wheel = Math.round((_cel.h / heightStep) + (dif > 0 ? -1 : 1));
698 | lastHeight = nexus.mouse.wheel;
699 |
700 | if (last === _cel.h) return;
701 | removeTile(overTile);
702 |
703 | var tile = addTile(_cel);
704 | tile.select();
705 |
706 | tower.tileAction.dispatch(tower.TILE_CHANGE_HEIGHT, tile);
707 | }
708 | break;
709 |
710 | case vg.MouseCaster.OVER:
711 | if (keyboard.shift) {
712 | if (overTile && nexus.mouse.rightDown) {
713 | removeTile(overTile);
714 | }
715 | else if (!overTile && nexus.mouse.down) {
716 | addTile(currentGridCell);
717 | }
718 | }
719 | break;
720 |
721 | case vg.MouseCaster.OUT:
722 |
723 | break;
724 |
725 | case vg.MouseCaster.DOWN:
726 | if (keyboard.shift && nexus.mouse.down && data && !overTile) {
727 | // if shift is down then they're painting, so add a tile immediately
728 | addTile(currentGridCell);
729 | }
730 | break;
731 |
732 | case vg.MouseCaster.UP:
733 | if (nexus.mouse.down && data && !overTile) {
734 | // create a new tile, if one isn't already there
735 | addTile(currentGridCell);
736 | }
737 | else if (nexus.mouse.rightDown && overTile) {
738 | // remove a tile if it's there and right mouse is down
739 | removeTile(overTile);
740 | }
741 | break;
742 | }
743 | }
744 |
745 | function addTile(cell) {
746 | if (!cell || nexus.board.getTileAtCell(cell)) return;
747 |
748 | var newCell = new vg.Cell();
749 | newCell.copy(cell);
750 | newCell.h = Math.abs(nexus.mouse.wheel * heightStep);
751 |
752 | var newTile = nexus.grid.generateTile(newCell, 0.95);
753 |
754 | nexus.board.addTile(newTile);
755 |
756 | tower.tileAction.dispatch(tower.TILE_ADD, newTile);
757 |
758 | return newTile;
759 | }
760 |
761 | function removeTile(overTile) {
762 | nexus.board.removeTile(overTile);
763 |
764 | tower.tileAction.dispatch(tower.TILE_REMOVE, overTile);
765 | }
766 |
767 | return {
768 |
769 | }
770 | });
771 | /*
772 | Handles JSON for whatever data needs to be saved to localStorage, and provides a convenient signal for whenever that data changes.
773 | */
774 | define('data', {
775 | _store: {},
776 | changed: new vg.Signal(),
777 |
778 | get: function(key) {
779 | return this._store[key] || null;
780 | },
781 |
782 | set: function(key, val) {
783 | // fire event first so we can retrieve old data before it's overwritten (just in case)
784 | this.changed.dispatch(key, this._store[key], val);
785 | this._store[key] = val;
786 | },
787 |
788 | save: function() {
789 | window.localStorage['vongrid'] = JSON.stringify(this._store);
790 | },
791 |
792 | load: function(json) {
793 | var data = window.localStorage['vongrid'];
794 | if (json || data) {
795 | try {
796 | this._store = json || JSON.parse(data);
797 | this.changed.dispatch('load-success');
798 | }
799 | catch (err) {
800 | console.warn('Error loading editor data');
801 | this.changed.dispatch('load-failure');
802 | }
803 | }
804 | }
805 | });
806 | //# sourceMappingURL=app.js.map
807 |
--------------------------------------------------------------------------------