Change how HTML links are handled.
[pwl6.git] / src / pwl6.js
1 "use strict";
2
3 var storage;
4 var SIGILS;
5 var BOOK;
6 var handScene;
7 var circleScene;
8 var NOISY_BLOCKS;
9
10 var sounds;
11
12 var TOP = 0;
13 var LEFT = 1;
14 var BOTTOM = 2;
15 var RIGHT = 3;
16
17 var MenuScene, CircleScene, HandScene, BookScene, GridScene;
18
19 yuu.Texture.DEFAULTS.magFilter = yuu.Texture.DEFAULTS.minFilter = "nearest";
20
21 var TICK_ROT = quat.rotateZ(quat.create(), quat.create(), Math.PI / 30);
22 var TICK_REV = quat.invert(quat.create(), TICK_ROT);
23 var TICK_ROT2 = quat.rotateZ(quat.create(), quat.create(), Math.PI / 60);
24
25 function sawtooth (p) {
26 /** Sawtooth wave, Û = 1, T = 2π, f(0) = 0, f′(0) > 0 */
27 var _2PI = 2 * Math.PI;
28 return 2 * (p / _2PI - Math.floor(0.5 + p / _2PI));
29 }
30
31 function triangle (p) {
32 /** Triangle wave, Û = 1, T = 2π, f(0) = 0, f′(0) > 0 */
33 return 2 * Math.abs(sawtooth(p + Math.PI / 2)) - 1;
34 }
35
36 function waveshift (period, peak, xoffset, yoffset) {
37 period /= 2 * Math.PI;
38 xoffset = xoffset || 0;
39 yoffset = yoffset || 0;
40 return function (f) {
41 return function (p) {
42 return yoffset + peak * f.call(this, (p + xoffset) / period);
43 };
44 };
45 }
46
47 function cycler (scale) {
48 var f = waveshift(scale, 0.5, -Date.now(), 0.5)(triangle);
49 return function () { return f(Date.now()); };
50 }
51
52 function load () {
53 storage = ystorage.getStorage();
54 yuu.audio.storage = storage;
55
56 NOISY_BLOCKS = new yuu.ShaderProgram(null, ["@noise.glsl", "@noisyblocks"]);
57
58 SIGILS = new yuu.Material("@sigils");
59 BOOK = new yuu.Material("@book", NOISY_BLOCKS);
60 BOOK.uniforms.cut = yf.volatile(cycler(20000));
61 BOOK.uniforms.range = 0.06;
62 BOOK.texture.ready.then(function (texture) {
63 BOOK.uniforms.resolution = new Float32Array(
64 [texture.width / 4, texture.height / 4]);
65 });
66
67 sounds = {
68 tick: new yuu.Instrument("@tick"),
69 tock: new yuu.Instrument("@tock"),
70 regear: new yuu.Instrument("@regear"),
71 winding: new yuu.Instrument("@winding"),
72 slam: new yuu.Instrument("@slam"),
73 switch: new yuu.Instrument("@switch"),
74 clicking: new yuu.Instrument("@clicking"),
75 bookAppear: new yuu.Instrument("@book-appear"),
76 switchBroke: new yuu.Instrument({
77 sample: { "@switch": { duration: 0.27, offset: 0.1 } } }),
78 switchOn: new yuu.Instrument({
79 sample: { "@switch": { duration: 0.2 } } }),
80 switchOff: new yuu.Instrument({
81 sample: { "@switch": { offset: 0.2 } } }),
82 chime: new yuu.Instrument({
83 envelope: { "0": 1, "0.7": 0.2, "3": 0 },
84 modulator: {
85 envelope: { "0": 1, "0.7": 0.2, "3": 0 },
86 frequency: "x1.5",
87 }
88 }),
89 };
90
91 yuu.director.pushScene(circleScene = new CircleScene());
92 yuu.director.pushScene(handScene = new HandScene());
93 yuu.director.pushScene(new MenuScene());
94 if (!storage.getFlag("instructions")) {
95 yuu.director.entity0.attach(new yuu.Ticker(function () {
96 yuu.director.pushScene(new BookScene());
97 }, 60));
98 }
99
100 return yuu.ready(
101 [SIGILS, BOOK]
102 .concat(yf.map(yf.getter.bind(sounds), Object.keys(sounds)))
103 );
104 }
105
106 function start () {
107 yuu.director.start();
108 }
109
110 window.addEventListener("load", function() {
111 yuu.registerInitHook(load);
112 yuu.init({ backgroundColor: [0, 0, 0, 1], antialias: false }).then(start);
113 });
114
115 var PALETTE = [[ 0.76, 0.13, 0.13 ],
116 [ 0.33, 0.49, 0.71 ],
117 [ 0.45, 0.68, 0.32 ],
118 [ 0.51, 0.32, 0.63 ],
119 [ 0.89, 0.49, 0.11 ],
120 [ 1.00, 1.00, 0.30 ]];
121
122 var LEVELS = [
123 { name: "12345654321",
124 randomSlammer: [3, 5],
125 deps: "50040@easy 53535@easy 44404@easy 1302@easy 12321@easy 20124@easy"
126 },
127
128 { slammer: [1, 1], sets: "tutorial",
129 scramble: { easy: "01", hard: "0122" } },
130 { slammer: [1, 1, 1], deps: "tutorial",
131 scramble: { easy: "11", hard: "1212" } },
132 { slammer: [2, 1], deps: "tutorial", sets: "asymmetric",
133 scramble: { easy: "32", hard: "3321" } },
134 { slammer: [1, 2, 1], deps: "tutorial", sets: "unequal",
135 scramble: { easy: "112", hard: "3210" } },
136 { slammer: [2, 0], deps: "asymmetric", sets: "zero",
137 scramble: { easy: "23", hard: "032" } },
138 { slammer: [2, 0, 2], deps: "zero",
139 scramble: { easy: "11", hard: "2211" } },
140 { slammer: [1, 1, 1, 1], deps: "tutorial" },
141 { slammer: [2, 1, 1], deps: "asymmetric" },
142 { slammer: [1, 2, 1, 2], deps: "asymmetric",
143 scramble: { easy: "012" } },
144 { slammer: [1, 2, 3, 4], deps: "asymmetric", sets: "solid",
145 scramble: { easy: "110" } },
146 { slammer: [5, 0, 0, 4, 0], deps: "unequal zero",
147 scramble: { easy: "112" } },
148 { slammer: [5, 3, 5, 3, 5], deps: "unequal solid",
149 scramble: { easy: "3232" } },
150 { slammer: [4, 4, 4, 0, 4], deps: "solid zero",
151 scramble: { easy: "0321" } },
152 { slammer: [1, 3, 0, 2], deps: "unequal zero" },
153 { slammer: [1, 2, 3, 2, 1], deps: "unequal",
154 scramble: { easy: "3333" } },
155 { slammer: [2, 0, 1, 2, 4], deps: "unequal zero" },
156 ];
157
158 function levelName (level) {
159 return (level.name || level.slammer.join("")).trim();
160 }
161
162 function wonLevel (level, difficulty) {
163 if (level.sets)
164 storage.setFlag(level.sets);
165 storage.setFlag(levelName(level) + "@" + difficulty);
166 }
167
168 function hasBeaten (level, difficulty) {
169 return storage.getFlag(levelName(level) + "@" + difficulty);
170 }
171
172 function scrambleForLevel (rnd, level, difficulty) {
173 var c = difficulty === "easy" ? 0 : 1;
174 if (difficulty === "random")
175 c = rnd.randrange(2, 5);
176 var length = level.slammer.length;
177 return rnd.randrange(length * c, length * (c + 1)) + 2;
178 }
179
180 function difficultyForLevel (level) {
181 if (level.deps && !level.deps.split(" ").every(storage.getFlag, storage))
182 return null;
183 if (hasBeaten(level, "hard"))
184 return "random";
185 if (hasBeaten(level, "easy"))
186 return "hard";
187 else
188 return "easy";
189 }
190
191 function levelRandom (level, difficulty) {
192 if (difficulty === "random")
193 return yuu.random;
194 else
195 return new yuu.Random(yuu.createLCG(+level.slammer.join("")));
196 }
197
198 function generateBoard (rnd, level) {
199 var size = level.length;
200 var board = new Array(size);
201 for (var i = 0; i < size; ++i)
202 board[i] = yf.repeat(i % PALETTE.length + 1, size);
203 if (rnd.randbool())
204 yuu.transpose2d(board);
205 return board;
206 }
207
208 function generateSlammer (rnd, level) {
209 var s = new Array(level.length);
210 for (var i = 0; i < s.length; ++i)
211 s[i] = yf.repeat(0, level[i]);
212 if (rnd.randbool())
213 s.reverse();
214 return s;
215 }
216
217 var AnimationQueue = yT(yuu.C, {
218 constructor: function () {
219 this._queue = [];
220 },
221
222 attached: function () {
223 this._queue = [];
224 },
225
226 _runNext: function () {
227 var next = this._queue[0];
228 if (next && this.entity)
229 this.entity.attach(new yuu.Animation(
230 next.timeline, next.params, this._complete.bind(this)));
231 },
232
233 _complete: function () {
234 var next = this._queue.shift();
235 next.resolve();
236 this._runNext();
237 },
238
239 enqueue: function (timeline, params) {
240 return new Promise(function (resolve) {
241 this._queue.push({
242 timeline: timeline,
243 params: params,
244 resolve: resolve
245 });
246 // FIXME: Simply chaining the promise doesn't work here
247 // because the tick between the two handlers is often long
248 // enough to render a frame, and that frame will have some
249 // undesirable intermediate state.
250 if (this._queue.length === 1)
251 this._runNext();
252 }.bind(this));
253 },
254
255 SLOTS: ["animationQueue"]
256 });
257
258 var SLAMMER_ROTATE = {
259 0: { tween1: { yaw: "yaw" }, duration: 10 }
260 };
261
262 var ROTATE_ALL = {
263 0: { tweenAll: { yaw: "yaws" }, duration: 10 }
264 };
265
266 var SLAMMER_BOUNCE = {
267 0: { tween1: { y: 0.5 }, duration: 5, repeat: -1 }
268 };
269
270 var SLIDE_BLOCKS = {
271 0: { tweenAll: { position: "positions" },
272 duration: 8, easing: "linear" },
273 };
274
275 var SLAMMER_SLAM = {
276 0: { tween1: { y: -1.5 }, easing: "linear", duration: 6 },
277 6: { event: "slideBoardBlocks" },
278 15: { event: "slam",
279 tween1: { y: 0 }, easing: "linear", duration: 8 }
280 };
281
282 var GRID_DISMISS = {
283 0: { tween1: { yaw: 2 * Math.PI, x: "x", y: "y", scale: [0.3, 0.3, 1] },
284 duration: 45 }
285 };
286
287 var GRID_FINISHED = {
288 0: { tween: { arm: { scale: [0, 0, 1], yaw: "armYaw", y: "armY" },
289 board: { y: "boardY" } },
290 duration: 45 }
291 };
292
293 function rotateCw (d) { return (--d + 4) % 4; }
294 function rotateCcw (d) { return ++d % 4; }
295 function opposite (d) { return (d + 2) % 4; }
296
297 var FlagSet = yT({
298 /** Manage a set of semaphore-like counting flags. */
299
300 constructor: function () {
301 /** Construct a flag set for the provided flags.
302
303 Flags are initialized to 0 by default.
304 */
305 this._counts = {};
306 for (var i = 0; i < arguments.length; ++i)
307 this._counts[arguments[i]] = 0;
308 },
309
310 increment: function () {
311 /** Increment the provided flags. */
312 for (var i = 0; i < arguments.length; ++i)
313 this._counts[arguments[i]]++;
314 },
315
316 decrement: function () {
317 /** Decrement the provided flags.
318
319 No underflow checks are performed. A flag with a negative
320 value is considered set exactly as a flag with a positive
321 value.
322 */
323 for (var i = 0; i < arguments.length; ++i)
324 this._counts[arguments[i]]--;
325 },
326
327 some: function () {
328 /** Return true if any of the provided flags are set. */
329 return yf.some.call(this._counts, yf.getter, arguments);
330 },
331
332 every: function () {
333 /** Return true if all of the provided flags are set. */
334 return yf.every.call(this._counts, yf.getter, arguments);
335 },
336
337 none: function () {
338 /** Return true if none of the provided flags are set. */
339 return !this.some.apply(this, arguments);
340 },
341
342 incrementer: function () {
343 /** Provide a bound 0-ary function to increment the provided flags.
344
345 Useful for wrapps around context-free callbacks.
346 */
347 var that = this, args = arguments;
348 return function () { that.increment.apply(that, args); };
349 },
350
351 decrementer: function () {
352 /** Provide a bound 0-ary function to decrement the provided flags.
353
354 Useful for wrapps around context-free callbacks.
355 */
356 var that = this, args = arguments;
357 return function () { that.decrement.apply(that, args); };
358 }
359 });
360
361 var BoardController = yT(yuu.C, {
362 constructor: function (rnd, level, colors) {
363 this.contents = generateBoard(rnd, level.slammer);
364 this.colors = colors;
365 },
366 updateChildren: function () {
367 this.entity.data.quads.forEach(function (q) {
368 q.quad.position = [q.x, q.y];
369 var i = this.contents[q.x][q.y];
370 q.quad.color = this.colors[i];
371 q.quad.texBounds = [i / 6, 0.5, (i + 1) / 6, 1.0];
372 }, this);
373 },
374 isComplete: function() {
375 var x, y;
376 var rows = true, cols = true;
377 for (x = 1; x < this.contents.length && rows; ++x)
378 for (y = 0; y < this.contents[x].length && rows; ++y)
379 rows = this.contents[x - 1][y] === this.contents[x][y];
380 for (x = 0; x < this.contents.length && cols; ++x)
381 for (y = 1; y < this.contents[x].length && cols; ++y)
382 cols = this.contents[x][y - 1] === this.contents[x][y];
383 return rows || cols;
384 },
385
386 shift: [
387 function (x, replacement) {
388 var lost = this.contents[x].pop();
389 this.contents[x].unshift(replacement);
390 return lost;
391 },
392 function (y, replacement) {
393 yuu.transpose2d(this.contents);
394 var lost = this.shift[BOTTOM].call(this, y, replacement);
395 yuu.transpose2d(this.contents);
396 return lost;
397 },
398 function (x, replacement) {
399 var lost = this.contents[x].shift();
400 this.contents[x].push(replacement);
401 return lost;
402 },
403 function (y, replacement) {
404 yuu.transpose2d(this.contents);
405 var lost = this.shift[TOP].call(this, y, replacement);
406 yuu.transpose2d(this.contents);
407 return lost;
408 }
409 ],
410
411 SLOTS: ["controller"]
412 });
413
414 var SlammerController = yT(yuu.C, {
415 constructor: function (rnd, level, colors) {
416 this.blocks = generateSlammer(rnd, level.slammer);
417 this.orientation = TOP;
418 this.colors = colors;
419 this._undoRecord = [];
420 },
421 isComplete: function() {
422 return yf.none(yf.some.bind(null, null), this.blocks);
423 },
424 updateChildren: function () {
425 this.entity.data.quads.forEach(function (q) {
426 var i = this.blocks[q.x][q.y];
427 q.quad.position = [q.x, q.y];
428 q.quad.color = this.colors[i];
429 q.quad.texBounds = [i / 6, 0.5, (i + 1) / 6, 1.0];
430 }, this);
431 },
432
433 lastUndoRecord: { get: function () {
434 return yf.last(this._undoRecord);
435 } },
436
437 clearUndoRecord: function () {
438 this._undoRecord = [];
439 },
440
441 slam: function (board) {
442 var undoable = (this.orientation !== this.lastUndoRecord);
443 var length = this.blocks.length;
444 this.orientation = opposite(this.orientation);
445 this.blocks = yf.mapr.call(this, function (a, y) {
446 return yf.map(board.shift[this.orientation].bind(board, y), a)
447 .reverse();
448 }, this.blocks, (this.orientation & 2)
449 ? yf.range(length)
450 : yf.range(length - 1, -1, -1));
451 yf.each(function (i) {
452 i.x = length - (i.x + 1);
453 }, this.entity.data.quads);
454 this.updateChildren();
455 board.updateChildren();
456 if (undoable)
457 this._undoRecord.push(this.orientation);
458 else
459 this._undoRecord.pop();
460 },
461
462 SLOTS: ["controller"]
463 });
464
465 function randSide (rnd, except) {
466 return (rnd || yuu.random).choice(
467 yf.without([TOP, LEFT, BOTTOM, RIGHT], except));
468 }
469
470 var HANDS_LEFT = {
471 0: { tween: { left: { yaw: -0.3 } }, duration: 3 },
472 3: { tween: { left: { yaw: 0.0 } }, duration: 7 },
473 };
474
475 var HANDS_RIGHT = {
476 0: { tween: { right: { yaw: -0.3 } }, duration: 3 },
477 3: { tween: { right: { yaw: 0.0 } }, duration: 7 },
478 };
479
480 var HANDS_UNDO = {
481 0: { tween: { left: { yaw: 0.2 }, right: { yaw: 0.2 } },
482 duration: 3 },
483 3: { tween: { left: { yaw: 0.0 }, right: { yaw: 0.0 } },
484 duration: 7 }
485 };
486
487 var HANDS_MENU_CHOICE = {
488 0: { tween: { left: { x: -1.3 },
489 right: { x: -1.3 } },
490 duration: 15, easing: "ease_in"
491 },
492
493 10: { tween: { left: { scaleX: 1 },
494 right: { scaleX: 1 } },
495 duration: 20 },
496
497 20: { set: { leftQuad: { color: "frontColor" },
498 rightQuad: { color: "frontColor" } },
499 tween: { left: { x: 0 }, right: { x: 0 } },
500 duration: 15
501 },
502 };
503
504 var HANDS_RETURN = {
505 0: { tween: { left: { x: -1.3 },
506 right: { x: -1.3 } },
507 duration: 20
508 },
509
510 10: { tween: { left: { scaleX: -1 },
511 right: { scaleX: -1 } },
512 duration: 20 },
513
514 20: { set: { leftQuad: { color: "backColor" },
515 rightQuad: { color: "backColor" } },
516 tween: { left: { x: -1 }, right: { x: -1 } },
517 duration: 10
518 },
519 };
520
521 var HANDS_SLAM = [
522 // TOP
523 { 0: { tween: { left: { yaw: -0.2, scaleX: 0.8, y: -0.1 },
524 right: { yaw: -0.2, scaleX: 0.8, y: -0.1 },
525 }, duration: 10, repeat: -1 },
526 },
527
528 // LEFT
529 { 0: { tween: { left: { scaleX: 0.8, x: 0.1 },
530 right: { scaleX: 0.9 },
531 }, duration: 10, repeat: -1 },
532 },
533
534 // BOTTOM
535 { 0: { tween: { left: { yaw: 0.2, scaleX: 0.8 },
536 right: { yaw: 0.2, scaleX: 0.8 },
537 }, duration: 10, repeat: -1 },
538 },
539
540 // RIGHT
541 { 0: { tween: { left: { scaleX: 0.9 },
542 right: { scaleX: 0.8, x: 0.1 },
543 }, duration: 10, repeat: -1 },
544 },
545 ];
546
547 var HANDS_ROTATE_CW = {
548 0: { tween: { left: { scaleX: 0.8 } }, duration: 5 },
549 5: { tween: { left: { scaleX: 1.0 } }, duration: 5 },
550 };
551
552 var HANDS_ROTATE_CCW = {
553 0: { tween: { right: { scaleX: 0.8 } }, duration: 5 },
554 5: { tween: { right: { scaleX: 1 } }, duration: 5 },
555 };
556
557 var BUTTONS_IN = {
558 0: { tween: { a: { x: 0 }, b: { x: 1.5 } }, duration: 25 }
559 };
560
561 var BUTTONS_OUT = {
562 0: { tween: { a: { x: -1.5 }, b: { x: 0 } }, duration: 25 }
563 };
564
565 HandScene = yT(yuu.Scene, {
566 constructor: function () {
567 yuu.Scene.call(this);
568 var hands = new yuu.Material("@hand");
569 this.left = new yuu.E(new yuu.Transform());
570 var l = new yuu.E(
571 new yuu.Transform([-0.5, 0.5, 0]),
572 new yuu.DataC({ command: "left" }),
573 this.leftQuad = new yuu.QuadC(hands));
574 this.left.addChild(l);
575 var r = new yuu.E(
576 new yuu.Transform([-0.5, 0.5, 0]),
577 new yuu.DataC({ command: "right" }),
578 this.rightQuad = new yuu.QuadC(hands));
579 this.right = new yuu.E(new yuu.Transform());
580 this.right.addChild(r);
581 var SIZE_X = yuu.random.gauss(1.2, 0.15) * 0.35;
582 var SIZE_Y = yuu.random.gauss(1.1, 0.05) * 0.51;
583 var hand = yuu.random.randrange(3);
584 this.leftQuad.texBounds = this.rightQuad.texBounds = [
585 hand / 2.99, 0, (hand + 1) / 3.01, 1];
586 this.layer0.resize(-0.75, 0, 1.5, 1.5);
587 var leftWrist = new yuu.E(
588 new yuu.Transform([-0.20, 0, 0], null,
589 [SIZE_X, SIZE_Y, 1]));
590 var rightWrist = new yuu.E(
591 new yuu.Transform([0.20, 0, 0], null,
592 [-SIZE_X, SIZE_Y, 1]));
593 leftWrist.addChild(this.left);
594 rightWrist.addChild(this.right);
595 this.addEntities(leftWrist, rightWrist);
596 this.backColor = yuu.hslToRgb(
597 (yuu.random.gauss(0.1, 0.1) + 10) % 1,
598 yuu.random.uniform(0.2, 0.7),
599 yuu.random.uniform(0.2, 0.6),
600 1.0);
601 this.leftQuad.alpha = this.rightQuad.alpha = 0.2;
602 var hsl = yuu.rgbToHsl(this.backColor);
603 hsl[2] = hsl[2].lerp(1, 0.15);
604 hsl[1] = hsl[1].lerp(0, 0.30);
605 hsl[3] = 0.4;
606 this.frontColor = yuu.hslToRgb(hsl);
607 this.leftQuad.color = this.rightQuad.color = this.frontColor;
608 this.ready = hands.ready;
609
610 function Button (i, command) {
611 return new yuu.E(
612 new yuu.Transform(),
613 new yuu.DataC({ command: command }),
614 new yuu.QuadC(SIGILS)
615 .setTexBounds([i / 6, 0, (i + 1) / 6, 0.5])
616 .setColor(PALETTE[i]));
617 }
618
619 this.helpButton = new Button(1, "help");
620 this.backButton = new Button(3, "back");
621 this.backButton.transform.x -= 1.5;
622 this.leftButtons = new yuu.E(new yuu.Transform());
623 this.leftButtons.addChildren(this.helpButton, this.backButton);
624 this.rightButton = new Button(2, "showOverlay preferences");
625 this.leftButtons.transform.scale
626 = this.rightButton.transform.scale
627 = [0.075, 0.075, 1];
628 this.entity0.addChildren(this.leftButtons, this.rightButton);
629 this.buttons = [this.helpButton, this.backButton, this.rightButton,
630 l, r];
631 },
632
633 inputs: {
634 resize: function () {
635 var base = new yuu.AABB(-0.75, 0, 0.75, 1.5);
636 var vp = base.matchAspectRatio(yuu.viewport);
637 vp.y1 -= vp.y0;
638 vp.y0 = 0;
639 this.leftButtons.transform.xy = [
640 vp.x0 + this.leftButtons.transform.scaleX,
641 vp.y1 - this.leftButtons.transform.scaleY];
642 this.rightButton.transform.xy = [
643 vp.x1 - this.rightButton.transform.scaleX,
644 vp.y1 - this.rightButton.transform.scaleY];
645 this.layer0.resize(vp.x0, vp.y0, vp.w, vp.h);
646 },
647
648 mousemove: function (p) {
649 p = this.layer0.worldFromDevice(p);
650 this.cursor = "";
651 for (var i = 0; i < this.buttons.length; ++i) {
652 if (this.buttons[i].transform.contains(p)) {
653 this.cursor = "pointer";
654 }
655 }
656 },
657
658 tap: function (p) {
659 p = this.layer0.worldFromDevice(p);
660 for (var i = 0; i < this.buttons.length; ++i) {
661 if (this.buttons[i].transform.contains(p)) {
662 yuu.director.execute(this.buttons[i].data.command);
663 return true;
664 }
665 }
666 },
667
668 doubletap: function () {
669 return this.inputs.tap.apply(this, arguments);
670 },
671 },
672
673 _anim: function (timeline) {
674 this.entity0.attach(new yuu.Animation(
675 timeline, {
676 left: this.left.transform,
677 right: this.right.transform,
678 leftQuad: this.leftQuad,
679 rightQuad: this.rightQuad,
680 frontColor: this.frontColor,
681 backColor: this.backColor
682 }));
683 },
684
685 undo: function () { this._anim(HANDS_UNDO); },
686 movedLeft: function () { this._anim(HANDS_LEFT); },
687 movedRight: function () { this._anim(HANDS_RIGHT); },
688 slam: function (o) { this._anim(HANDS_SLAM[o]); },
689 rotatedCw: function () { this._anim(HANDS_ROTATE_CW); },
690 rotatedCcw: function () { this._anim(HANDS_ROTATE_CCW); },
691 menuChoice: function () {
692 this.entity0.attach(new yuu.Animation(
693 BUTTONS_IN, {
694 a: this.backButton.transform,
695 b: this.helpButton.transform
696 }));
697 this._anim(HANDS_MENU_CHOICE);
698 },
699 finished: function () {
700 this.entity0.attach(new yuu.Animation(
701 BUTTONS_OUT, {
702 a: this.backButton.transform,
703 b: this.helpButton.transform
704 }));
705 this._anim(HANDS_RETURN);
706 },
707 });
708
709 var GRID_APPEAR = {
710 0: { set1: { y: 5 },
711 tween1: { y: 0 }, duration: 10 },
712 };
713
714 GridScene = yT(yuu.Scene, {
715 constructor: function (level, difficulty) {
716 yuu.Scene.call(this);
717 this.entity0.attach(new yuu.Transform());
718 this.level = level;
719 this.difficulty = difficulty;
720 this._locks = new FlagSet("slam", "spin", "quit");
721 var rnd = levelRandom(level, difficulty);
722 var colors = yuu.random.shuffle(PALETTE.slice());
723 colors.unshift([1.0, 1.0, 1.0]);
724 this.board = new yuu.E(new BoardController(rnd, level, colors),
725 new yuu.Transform(),
726 new yuu.DataC({ quads: [] }));
727 this.slammer = new yuu.E(new SlammerController(rnd, level, colors),
728 new yuu.Transform(),
729 new yuu.DataC({ quads: [] }));
730 this.slammerHead = new yuu.E(new yuu.Transform());
731 this.slammerRoot = new yuu.E(new yuu.Transform());
732 var length = level.slammer.length;
733 var maxSize = length * length;
734 var slammerBatch = new yuu.QuadBatchC(maxSize);
735 slammerBatch.material = SIGILS;
736 var boardBatch = new yuu.QuadBatchC(maxSize);
737 boardBatch.material = SIGILS;
738 this.slammerRoot.transform.xy = [length / 2 - 0.5, length / 2 - 0.5];
739 this.slammerHead.transform.xy = [-length / 2 + 0.5, length / 2 + 2];
740 this.slammerRoot.addChild(this.slammerHead);
741 this.slammerHead.addChild(this.slammer);
742 this.slammer.attach(slammerBatch);
743 this.board.attach(boardBatch);
744 yf.irange.call(this, function (x) {
745 yf.irange.call(this, function (y) {
746 var quad = boardBatch.createQuad();
747 quad.color = colors[this.board.controller.contents[x][y]];
748 quad.position = [x, y];
749 this.board.data.quads.push({ quad: quad, x: x, y: y });
750 }, length);
751 }, length);
752
753 for (var x = 0; x < this.slammer.controller.blocks.length; ++x) {
754 for (var y = 0; y < this.slammer.controller.blocks[x].length; ++y) {
755 var quad = slammerBatch.createQuad();
756 quad.color = colors[this.slammer.controller.blocks[x][y]];
757 quad.position = [x, y];
758 this.slammer.data.quads.push({ quad: quad, x: x, y: y });
759 }
760 }
761 this.addEntities(this.board, this.slammerRoot);
762 this.scramble(rnd);
763 if (!(this.cheating = yuu.director.input.pressed["`"])) {
764 this.slammer.controller.clearUndoRecord();
765 }
766 this._dragging = 0;
767
768 this.gridBB = new yuu.AABB(-0.5, -0.5, length - 0.5, length - 0.5);
769 this.leftBB = new yuu.AABB(
770 -Infinity, this.gridBB.y0, this.gridBB.x0, this.gridBB.y1);
771 this.rightBB = new yuu.AABB(
772 this.gridBB.x1, this.gridBB.y0, Infinity, this.gridBB.y1);
773 this.topBB = new yuu.AABB(
774 this.gridBB.x0, this.gridBB.y1, this.gridBB.x1, Infinity);
775 this.bottomBB = new yuu.AABB(
776 this.gridBB.x0, -Infinity, this.gridBB.x1, this.gridBB.y0);
777 },
778
779 init: function () {
780 this._locks.increment("slam");
781 this.entity0.attach(new yuu.Animation(
782 GRID_APPEAR, { $: this.slammer.transform },
783 this._locks.decrementer("slam")));
784 },
785
786 scramble: function (rnd) {
787 var scramble = (this.level.scramble || {})[this.difficulty];
788 var slammerCon = this.slammer.controller;
789 var boardCon = this.board.controller;
790 if (!scramble) {
791 var count = scrambleForLevel(rnd, this.level, this.difficulty);
792 while (this.isComplete()) {
793 var c = count;
794 while (c--) {
795 slammerCon.orientation = randSide(rnd, slammerCon.orientation);
796 slammerCon.slam(boardCon);
797 }
798 }
799 } else {
800 for (var i =0; i < scramble.length; ++i) {
801 slammerCon.orientation = +scramble[i];
802 slammerCon.slam(boardCon);
803 }
804 }
805 slammerCon.orientation = randSide();
806 this.slammerRoot.transform.yaw = slammerCon.orientation * Math.PI / 2;
807 },
808
809 isComplete: function () {
810 return this.slammer.controller.isComplete()
811 && this.board.controller.isComplete();
812 },
813
814 rotateTo: yuu.cmd(function (orientation) {
815 return new Promise(function (resolve) {
816 if (this._locks.some("spin"))
817 return this;
818 this.slammer.controller.orientation = orientation;
819 this._locks.increment("slam");
820 var yaw0 = this.slammerRoot.transform.yaw;
821 var yaw1 = orientation * Math.PI / 2;
822
823 sounds.clicking.play();
824 this.entity0.attach(new yuu.Animation(
825 SLAMMER_ROTATE, {
826 $: this.slammerRoot.transform,
827 yaw: yaw0 + yuu.normalizeRadians(yaw1 - yaw0)
828 }, function () {
829 this._locks.decrement("slam");
830 resolve(this);
831 }.bind(this)));
832 }.bind(this));
833 }, "<top/bottom/left/right>", "move the slammer to the top"),
834
835 rotateCw: yuu.cmd(function () {
836 handScene.rotatedCw();
837 circleScene.rotated();
838 this.rotateTo(rotateCw(this.slammer.controller.orientation));
839 }, "", "rotate the active piece clockwise"),
840
841 rotateCcw: yuu.cmd(function () {
842 handScene.rotatedCcw();
843 circleScene.rotated();
844 this.rotateTo(rotateCcw(this.slammer.controller.orientation));
845 }, "", "rotate the active piece counter-clockwise"),
846
847 left: yuu.cmd(function () { this.rotateCw(); }),
848 right: yuu.cmd(function () { this.rotateCcw(); }),
849
850 undo: yuu.cmd(function (v) {
851 var con = this.slammer.controller;
852 var _ = function () { this.undo(this._undo); }.bind(this);
853 if ((this._undo = v) && con.lastUndoRecord !== undefined) {
854 if (con.orientation !== con.lastUndoRecord) {
855 circleScene.reverse();
856 handScene.undo();
857 this.rotateTo(con.lastUndoRecord)
858 .then(this.slam.bind(this))
859 .then(_);
860 } else {
861 this.slam().then(_);
862 }
863 }
864 }, "", "rotate the active piece counter-clockwise"),
865
866 checkWon: function () {
867 if (this.isComplete() && !this._locks.some("quit")) {
868 this._locks.increment("quit", "slam", "spin");
869 var firstTime = !hasBeaten(this.level, this.difficulty);
870 if (!this.cheating)
871 wonLevel(this.level, this.difficulty);
872 var scene = new MenuScene(this.level);
873 yuu.director.pushScene(scene);
874 scene.didWinLevel(this.level, this.difficulty, firstTime);
875 this.entity0.attach(new yuu.Animation(
876 GRID_FINISHED, {
877 arm: this.slammerRoot.transform,
878 armYaw: this.slammerRoot.transform.yaw + 3 * Math.PI,
879 armY: this.slammerRoot.transform.y + 1.5,
880 board: this.board.transform,
881 boardY: this.level.slammer.length * 3
882 }, function () {
883 yuu.director.removeScene(this);
884 }.bind(this)
885 ));
886 }
887 },
888
889 slideBoardBlocks: function (anim, params) {
890 var dx = 0, dy = 0;
891 var orientation = this.slammer.controller.orientation;
892 switch (orientation) {
893 case LEFT: dx = 1.5; break;
894 case TOP: dy = -1.5; break;
895 case RIGHT: dx = -1.5; break;
896 case BOTTOM: dy = 1.5; break;
897 }
898 var sgnx = Math.sign(dx);
899 var sgny = Math.sign(dy);
900 var $s = [];
901 var positions = [];
902 var blocks = this.slammer.controller.blocks;
903 this.slammer.data.quads.forEach(function (q) {
904 var d = blocks[q.x].length;
905 $s.push(q.quad);
906 positions.push([q.quad.position[0], q.quad.position[1] - d]);
907 }, this);
908 this.board.data.quads.forEach(function (q) {
909 var x = orientation === TOP ? q.x : blocks.length - (q.x + 1);
910 var y = orientation === LEFT ? q.y : blocks.length - (q.y + 1);
911
912 $s.push(q.quad);
913 positions.push([q.quad.position[0] + sgnx * blocks[y].length,
914 q.quad.position[1] + sgny * blocks[x].length]);
915 }, this);
916 this.entity0.attach(new yuu.Animation(SLIDE_BLOCKS, {
917 $s: $s,
918 positions: positions
919 }));
920 },
921
922 slam: yuu.cmd(function () {
923 var r = new Promise(function (resolve, reject) {
924 if (this._locks.some("slam")) {
925 reject("slamming is locked");
926 return;
927 }
928 this._locks.increment("spin", "slam");
929 circleScene.slam();
930 sounds.slam.play();
931 handScene.slam(this.slammer.controller.orientation);
932 this.entity0.attach(new yuu.Animation(
933 SLAMMER_SLAM, {
934 $: this.slammer.transform,
935 slam: function () {
936 this._locks.decrement("spin");
937 this.slammer.controller.slam(this.board.controller);
938 this.slammerRoot.transform.yaw = Math.PI / 2 *
939 this.slammer.controller.orientation;
940 }.bind(this),
941 slideBoardBlocks: this.slideBoardBlocks.bind(this)
942 }, function () {
943 this.checkWon();
944 this._locks.decrement("slam");
945 resolve(this);
946 }.bind(this)));
947 }.bind(this));
948 return r;
949 }, "", "slam the active piece"),
950
951 back: yuu.cmd(function (x, y) {
952 if (this._locks.some("quit"))
953 return;
954 this._locks.increment("quit", "slam", "spin");
955 var scene = new MenuScene(this.level);
956 yuu.director.pushScene(scene);
957 var v = [x || yuu.random.uniform(-1, 1),
958 y || yuu.random.uniform(-1, 1)];
959 var size = this.board.controller.contents.length * 5;
960 vec2.scale(v, vec2.normalize(v, v), size);
961 this.entity0.attach(new yuu.Animation(
962 GRID_DISMISS, {
963 $: this.entity0.transform,
964 x: v[0], y: v[1]
965 }, function () {
966 yuu.director.removeScene(this);
967 }.bind(this)
968 ));
969 circleScene.lose();
970 }, "", "go back to the menu"),
971
972 slammerBB: { get: function (p) {
973 var length = this.level.slammer.length;
974 switch (this.slammer.controller.orientation) {
975 case LEFT:
976 return new yuu.AABB(-Infinity, -0.5, -1, length - 0.5);
977 case RIGHT:
978 return new yuu.AABB(length + 1, -0.5, Infinity, length - 0.5);
979 case TOP:
980 return new yuu.AABB(-0.5, length + 1, length - 0.5, Infinity);
981 case BOTTOM:
982 return new yuu.AABB(-0.5, -Infinity, length - 0.5, -1);
983 }
984 } },
985
986 _swipe: function (p0, p1) {
987 p0 = this.layer0.worldFromDevice(p0);
988 p1 = this.layer0.worldFromDevice(p1);
989 if (this.slammerBB.contains(p0)) {
990 this.slam();
991 return true;
992 }
993 if (this.gridBB.contains(p0) && !this.gridBB.contains(p1)) {
994 this.back(p1.x - p0.x, p1.y - p0.y);
995 return true;
996 }
997 },
998
999 inputs: {
1000 resize: function () {
1001 var length = this.level.slammer.length;
1002 var base = new yuu.AABB(-length - 2.5, -length - 2.5,
1003 2 * length + 1.5, 2 * length + 1.5);
1004 var vp = base.matchAspectRatio(yuu.viewport);
1005 this.layer0.resize(vp.x0, vp.y0, vp.w, vp.h);
1006 },
1007
1008 tap: function (p) {
1009 p = this.layer0.worldFromDevice(p);
1010 if (this.gridBB.contains(p)) {
1011 this.slam();
1012 return true;
1013 }
1014 },
1015
1016 touch: function (p) {
1017 var length = this.level.slammer.length;
1018 var middle = (length - 1) / 2;
1019 p = this.layer0.worldFromDevice(p);
1020 if (this.slammerBB.contains(p)) {
1021 this.slammer.attach(new yuu.Animation(
1022 SLAMMER_BOUNCE, { $: this.slammer.transform }));
1023 } else if (this.leftBB.contains(p)) {
1024 this.rotateTo(LEFT);
1025 handScene.rotatedCw();
1026 return true;
1027 } else if (this.rightBB.contains(p)) {
1028 this.rotateTo(RIGHT);
1029 handScene.rotatedCcw();
1030 return true;
1031 } else if (this.topBB.contains(p)) {
1032 this.rotateTo(TOP);
1033 if (p.x < middle)
1034 handScene.rotatedCw();
1035 else
1036 handScene.rotatedCcw();
1037 return true;
1038 } else if (this.bottomBB.contains(p)) {
1039 this.rotateTo(BOTTOM);
1040 if (p.x < middle)
1041 handScene.rotatedCw();
1042 else
1043 handScene.rotatedCcw();
1044 return true;
1045 }
1046 },
1047
1048 doubletap: function () {
1049 return this.inputs.tap.apply(this, arguments);
1050 },
1051
1052 hold: function (p) {
1053 p = this.layer0.worldFromDevice(p);
1054 if (this.gridBB.contains(p)) {
1055 this.undo(true);
1056 return true;
1057 }
1058 },
1059
1060 dragstart: function (p) {
1061 p = this.layer0.worldFromDevice(p);
1062 this._dragging = this.slammerBB.contains(p);
1063 },
1064
1065 drag: function (p0, p1) {
1066 var p = this.layer0.worldFromDevice(p1);
1067 if (this._dragging && !this._locks.some("slam")) {
1068 var inGrid = this.gridBB.contains(p);
1069 var length = this.level.slammer.length;
1070 var o;
1071 if (this._dragging === true && inGrid) {
1072 this.slam();
1073 } else if (p.x > 0 && p.x < length && !inGrid) {
1074 o = p.y < 0 ? BOTTOM : TOP;
1075 if (o !== this.slammer.controller.orientation) {
1076 this.rotateTo(o);
1077 this._dragging = 2;
1078 }
1079 } else if (p.y > 0 && p.y < length && !inGrid) {
1080 o = p.x < 0 ? LEFT : RIGHT;
1081 if (o !== this.slammer.controller.orientation) {
1082 this.rotateTo(o);
1083 this._dragging = 2;
1084 }
1085 }
1086 }
1087 return this._dragging;
1088 },
1089
1090 dragend: function (p0, p1) {
1091 this._dragging = false;
1092 },
1093
1094 release: function () {
1095 this.undo(false);
1096 },
1097
1098 swipeleft: function (p0, p1) {
1099 return this._swipe(p0, p1);
1100 },
1101 swiperight: function (p0, p1) {
1102 return this._swipe(p0, p1);
1103 },
1104 swipeup: function (p0, p1) {
1105 return this._swipe(p0, p1);
1106 },
1107 swipedown: function (p0, p1) {
1108 return this._swipe(p0, p1);
1109 },
1110 },
1111
1112 KEYBINDS: {
1113 w: "rotateCw",
1114 a: "rotateCcw",
1115 s: "rotateCcw",
1116 d: "rotateCw",
1117 left: "rotateCcw",
1118 right: "rotateCw",
1119 up: "rotateCw",
1120 down: "rotateCcw",
1121 shift: "slam",
1122 space: "slam",
1123 z: "slam",
1124 backspace: "+undo",
1125 c: "+undo",
1126 escape: "back",
1127 back: "back",
1128 gamepadbutton0: "slam",
1129 gamepadbutton1: "+undo",
1130 gamepadbutton2: "slam",
1131 gamepadbutton3: "+undo",
1132 gamepadbutton4: "rotateCcw",
1133 gamepadbutton5: "rotateCw",
1134 gamepadbutton8: "back",
1135 gamepadbutton14: "rotateCcw",
1136 gamepadbutton15: "rotateCw",
1137 }
1138 });
1139
1140 var MENU_APPEAR = {
1141 0: [{ set1: { x: 5, y: 5, scaleX: 0, scaleY: 0 } },
1142 { tween1: { x: 0, y: 0, scaleX: 1 }, duration: 24 },
1143 { tween1: { scaleY: 1 },
1144 duration: 55, easing: yuu.Tween.METASPRING(1, 10)}],
1145 };
1146
1147 var MENU_SLIDE = {
1148 0: { tween1: { x: "x" }, duration: "duration" }
1149 };
1150
1151 var FLASH = {
1152 0: { tween1: { luminance: 1, alpha: 1 }, duration: 32, repeat: -1 }
1153 };
1154
1155 var MENU_SLAM = {
1156 0: { tween: { cursor: { y: "mid" } }, duration: 8 },
1157 8: { tween: { cursor: { y: "line" },
1158 select: { y: -1.0 }
1159 }, duration: 12 },
1160 20: { tween: { scene: { y: 10 },
1161 select: { y: -11.5, scale: [3, 3, 1] }
1162 }, duration: 18 },
1163 38: { event: "appear",
1164 tween: { select: { y: 0, scale: [1, 0, 1] } },
1165 duration: 20 }
1166 };
1167
1168 function menuEntityForLevel (level, i) {
1169 var activated = false;
1170 function randomizeSlammer () {
1171 var min = level.randomSlammer[0];
1172 var max = level.randomSlammer[1];
1173 var size = yuu.random.randrange(min, max + 1);
1174 level.slammer = [];
1175 do {
1176 for (var i = 0; i < size; ++i)
1177 level.slammer[i] = yuu.random.randrange(0, size);
1178 } while (Math.min.apply(Math, level.slammer) === max
1179 || Math.max.apply(Math, level.slammer) === 0);
1180 }
1181
1182 function generateQuads() {
1183 batch.disposeAll();
1184 var rgb = PALETTE[i % PALETTE.length];
1185 var fit = level.slammer.length + 1;
1186 batch.createQuad().color = rgb;
1187 level.slammer.forEach(function (size, y) {
1188 var c = batch.createQuad();
1189 c.color = [0, 0, 0];
1190 c.alpha = hasBeaten(level, "easy") ? 0.5 : 1.0;
1191 c.size = [size / fit, 1 / fit];
1192 c.position = [0, -0.5 + (y + 1) / fit];
1193 });
1194 ce.data.flasher = batch.createQuad();
1195 ce.data.flasher.alpha = 0;
1196 return ce;
1197 }
1198
1199 if (level.randomSlammer)
1200 randomizeSlammer();
1201
1202 // 14 = maximum slammer size + 1 background + 1 flasher
1203 var batch = new yuu.QuadBatchC(14);
1204 var ce = new yuu.E(
1205 new yuu.Transform([2 * i, 0, 0]),
1206 batch,
1207 new yuu.DataC({
1208 activate: function () {
1209 activated = true;
1210 var scene = new GridScene(level, difficultyForLevel(level));
1211 yuu.director.insertUnderScene(scene);
1212 }
1213 })
1214 );
1215
1216 if (level.randomSlammer) {
1217 ce.attach(new yuu.Ticker(function () {
1218 if (!activated && yuu.random.randbool(0.7)) {
1219 randomizeSlammer();
1220 ++i;
1221 generateQuads();
1222 }
1223 return !activated;
1224 }, 30, 15));
1225 }
1226
1227 generateQuads();
1228 return ce;
1229 }
1230
1231 var HAND_TICK_BACK = {
1232 0: { tween1: { rotation: "rotation" }, duration: 6, repeat: -1 }
1233 };
1234
1235 MenuScene = yT(yuu.Scene, {
1236 constructor: function (initialLevel) {
1237 yuu.Scene.call(this);
1238 this.entity0.attach(new yuu.Transform(),
1239 new AnimationQueue());
1240
1241 this.pointer = new yuu.E(
1242 new yuu.Transform([5, 8, 0]),
1243 new yuu.QuadC());
1244
1245 var menu = this.menu = new yuu.E(new yuu.Transform([5, 6.5, 0]));
1246 this.addEntities(menu, this.pointer);
1247 this.availableLevels = LEVELS.filter(difficultyForLevel);
1248 this.availableLevels
1249 .map(menuEntityForLevel)
1250 .forEach(menu.addChild, menu);
1251
1252 var initialIdx = this.availableLevels.indexOf(initialLevel);
1253 this._locks = new FlagSet("slam", "move");
1254 this.activeIndex = Math.max(initialIdx, 0);
1255 menu.transform.x = 5 - 2 * this.activeIndex;
1256 this.changeActiveIndex(this.activeIndex, false);
1257 this._dragStartX = null;
1258
1259 this.entity0.attach(
1260 new yuu.Ticker(this._animation.bind(this), 60));
1261 },
1262
1263 _animation: function (count) {
1264 var length = this.availableLevels.length;
1265 var range = Math.pow(2, length);
1266 var rand = yuu.random.randrange(range);
1267 var targets = [];
1268 var yaws = [];
1269 for (var i = 0; i < length; ++i) {
1270 var child = this.menu.children[i];
1271 var level = this.availableLevels[i];
1272 var won = hasBeaten(level, "hard");
1273 if ((won || ((count ^ i) & 1)) && ((count ^ rand) & (1 << i))) {
1274 var dyaw = won
1275 ? yuu.random.randsign(Math.PI / 2)
1276 : -Math.PI / 2;
1277 targets.push(child.transform);
1278 yaws.push(child.transform.yaw + dyaw);
1279 }
1280 }
1281 if (targets.length) {
1282 this.entity0.attach(new yuu.Animation(
1283 ROTATE_ALL, { $s: targets, yaws: yaws }));
1284 }
1285 circleScene.clockTick(TICK_ROT2, HAND_TICK_BACK);
1286 sounds[["tick", "tock"][count & 1]]
1287 .createSound(yuu.audio, yuu.audio.currentTime, 0, 0.2, 1.0)
1288 .connect(yuu.audio.music);
1289
1290 return true;
1291 },
1292
1293 init: function () {
1294 circleScene.toBottom();
1295 handScene.finished();
1296 this._locks.increment("slam", "move");
1297 this.entity0.animationQueue.enqueue(
1298 MENU_APPEAR,
1299 { $: this.entity0.transform })
1300 .then(this._locks.decrementer("slam", "move"));
1301 },
1302
1303 didWinLevel: function (level, difficulty, firstTime) {
1304 var idx = this.availableLevels.indexOf(level);
1305 circleScene.win();
1306 if (firstTime)
1307 this.entity0.animationQueue.enqueue(
1308 FLASH, { $: this.menu.children[idx].data.flasher });
1309 for (var i = idx; i < this.availableLevels.length; ++i) {
1310 if (!hasBeaten(this.availableLevels[i], difficulty)) {
1311 this._locks.increment("move");
1312 this.changeActiveIndex(i, true)
1313 .then(this._locks.decrementer("move"));
1314
1315 break;
1316 }
1317 }
1318 },
1319
1320 changeActiveIndex: function (index, animate) {
1321 var oldIndex = this.activeIndex;
1322 var p;
1323 this.activeIndex = index = yf.clamp(
1324 index, 0, this.menu.children.length - 1);
1325 if (index !== oldIndex && animate) {
1326 this._locks.increment("slam");
1327 var duration = Math.ceil(8 * Math.abs(oldIndex - index));
1328 p = this.entity0.animationQueue.enqueue(
1329 MENU_SLIDE, {
1330 $: this.menu.transform,
1331 x: 5 - 2 * index,
1332 duration: duration
1333 });
1334 p.then(this._locks.decrementer("slam"));
1335 }
1336 return p || Promise.resolve();
1337 },
1338
1339 left: yuu.cmd(function () {
1340 if (!this._locks.some("move")) {
1341 sounds[this.activeIndex === 0 ? "switchBroke" : "switch"].play();
1342 handScene.movedLeft();
1343 this.changeActiveIndex(this.activeIndex - 1, true);
1344 }
1345 }, "move the cursor left"),
1346 right: yuu.cmd(function () {
1347 if (!this._locks.some("move")) {
1348 sounds[this.activeIndex === this.availableLevels.length - 1
1349 ? "switchBroke" : "switch"].play();
1350 handScene.movedRight();
1351 this.changeActiveIndex(this.activeIndex + 1, true);
1352 }
1353 }, "move the cursor right"),
1354
1355 slam: yuu.cmd(function () {
1356 if (this._locks.some("slam"))
1357 return;
1358 var activeChild = this.menu.children[this.activeIndex];
1359 this._locks.increment("slam", "move");
1360 handScene.menuChoice();
1361 circleScene.toBack();
1362 circleScene.slam();
1363 sounds.winding.play();
1364 this.entity0.animationQueue.enqueue(
1365 MENU_SLAM, {
1366 cursor: this.pointer.transform,
1367 select: activeChild.transform,
1368 scene: this.entity0.transform,
1369 mid: this.pointer.transform.y - 0.5,
1370 line: this.pointer.transform.y - 1.5,
1371 appear: activeChild.data.activate
1372 }).then(function () {
1373 this._locks.decrementer("slam", "move");
1374 yuu.director.removeScene(this);
1375 }.bind(this));
1376 }, "choose the active menu item"),
1377
1378 inputs: {
1379 resize: function () {
1380 var base = new yuu.AABB(0, 0, 10, 10);
1381 var vp = base.matchAspectRatio(yuu.viewport);
1382 this.layer0.resize(vp.x0, vp.y0, vp.w, vp.h);
1383 },
1384
1385 pinchout: function (p0, p1) {
1386 p0 = this.layer0.worldFromDevice(p0);
1387 p1 = this.layer0.worldFromDevice(p1);
1388 if (vec2.sqrDist(p0, p1) > 1) {
1389 this.slam();
1390 return true;
1391 }
1392 },
1393
1394 hold: function (p) {
1395 return this.inputs.dragstart.call(this, p);
1396 },
1397
1398 release: function (p) {
1399 if (this._dragStartX !== null)
1400 return this.inputs.dragend.call(this, p);
1401 },
1402
1403 dragstart: function (p) {
1404 if (this._locks.some("move"))
1405 return false;
1406 p = this.layer0.worldFromDevice(p);
1407 if (p.y > 6 && p.y < 8.5 && p.inside && this._dragStartX === null) {
1408 sounds.switchOn.play();
1409 this._locks.increment("move");
1410 this._dragStartX = this.menu.transform.x;
1411 return true;
1412 }
1413 },
1414
1415 dragdown: function (p0, p1) {
1416 p0 = this.layer0.worldFromDevice(p0);
1417 p1 = this.layer0.worldFromDevice(p1);
1418
1419 if (p0.x >= 4.5 && p0.x <= 5.5
1420 && p0.y >= 6.0 && p0.y <= 8.5
1421 && p0.y - p1.y > 1) {
1422 this.slam();
1423 return true;
1424 }
1425 },
1426
1427 drag: function (p0, p1) {
1428 if (this._dragStartX !== null) {
1429 p0 = this.layer0.worldFromDevice(p0);
1430 p1 = this.layer0.worldFromDevice(p1);
1431 this.menu.transform.x = this._dragStartX + (p1.x - p0.x);
1432 var index = Math.round((5 - this.menu.transform.x) / 2);
1433 this.changeActiveIndex(index);
1434 return true;
1435 }
1436 },
1437
1438 dragend: function (p0, p1) {
1439 if (this._dragStartX !== null) {
1440 sounds.switchOff.play();
1441 this._locks.decrement("move");
1442 this._dragStartX = null;
1443 var index = this.activeIndex;
1444 this.activeIndex = (5 - this.menu.transform.x) / 2;
1445 this.changeActiveIndex(index, true);
1446 return true;
1447 }
1448 },
1449
1450 tap: function (p) {
1451 p = this.layer0.worldFromDevice(p);
1452 if (p.y > 6 && p.y < 7 && p.inside) {
1453 var dx = Math.round((p.x - 5) / 2);
1454 if (dx === 0) this.slam();
1455 else if (dx < 0) handScene.movedLeft();
1456 else if (dx > 0) handScene.movedRight();
1457 var idx = this.activeIndex;
1458 this.changeActiveIndex(this.activeIndex + dx, true);
1459 if (idx !== this.activeIndex)
1460 sounds.switch.play();
1461 else
1462 sounds.switchBroke.play();
1463 return true;
1464 }
1465
1466 },
1467
1468 doubletap: function (p) {
1469 p = this.layer0.worldFromDevice(p);
1470 if (p.x >= 4.5 && p.x <= 5.5 && p.y >= 6.0 && p.y <= 8.5) {
1471 this.slam();
1472 return true;
1473 }
1474 },
1475 },
1476
1477 resetEverything: yuu.cmd(function () {
1478 storage.clear();
1479 yuu.director.stop();
1480 start();
1481 }, "reset all saved data"),
1482
1483 unlock: yuu.cmd(function (d) {
1484 LEVELS.forEach(function (level) { wonLevel(level, d); });
1485 yuu.director.pushPopScene(new MenuScene());
1486 }, "<difficulty>", "unlock all levels to the given difficulty"),
1487
1488 KEYBINDS: {
1489 left: "left",
1490 right: "right",
1491 up: "right",
1492 down: "left",
1493 w: "right",
1494 a: "left",
1495 s: "left",
1496 d: "right",
1497 shift: "slam",
1498 space: "slam",
1499 z: "slam",
1500 "`+r+e": "resetEverything",
1501 "`+u+e": "unlock easy",
1502 "`+u+h": "unlock hard",
1503 gamepadbutton0: "slam",
1504 gamepadbutton8: "help",
1505 gamepadbutton9: "slam",
1506 gamepadbutton13: "slam",
1507 gamepadbutton14: "left",
1508 gamepadbutton15: "right",
1509 }
1510 });
1511
1512
1513 var BOOK_APPEAR = {
1514 0: { set1: { y: 1.5, x: -1.5 },
1515 tween: { bgQuad: { alpha: 0.75 }, $: { y: 0, x: 0 }, },
1516 duration: 30 }
1517 };
1518
1519 var BOOK_DISMISS = {
1520 0: { tween: { bgQuad: { alpha: 0 }, $: { y: 1.5, x: -1.5, } },
1521 duration: 30 }
1522 };
1523
1524 var KEYBOARD_PAGE = [0.25, 0.50, 0.50, 1.00];
1525 var POINTERS_PAGE = [0.25, 0.00, 0.50, 0.50];
1526 var GAMEPAD_PAGE = [0.00, 0.00, 0.25, 0.50];
1527
1528 var BOOK_FORWARD = [
1529 { 0: { set: { page2Quad: { color: [0.2, 0.2, 0.2, 1], texBounds: "page" } },
1530 tween: { page1: { x: -1/3 / 2, scaleX: 0 },
1531 page2: { x: +1/3 / 2 },
1532 page2Quad: { color: [1, 1, 1, 1] },
1533 }, duration: 15, easing: "linear" },
1534 15: { set: { page1Quad: { z: 0, texBounds: [0.25, 0.5, 0.00, 1] },
1535 page2Quad: { z: 0, texBounds: "page" } },
1536 tween: { page1: { x: -1/3, scaleX: -2/3 },
1537 page2: { x: +1/3 }
1538 }, duration: 15, easing: "linear" },
1539 },
1540
1541 { 0: { tween: { page1: { x: -1/3 / 2 },
1542 page2: { x: +1/3 / 2, scaleX: 0 }
1543 }, duration: 15, easing: "linear" },
1544 15: { set: { page1Quad: { z: 0, texBounds: [0.25, 0.5, 0.00, 1] },
1545 page2Quad: { z: 1, texBounds: [1.00, 0.5, 0.75, 1] } },
1546 tween: { page1Quad: { color: [0.2, 0.2, 0.2, 1] },
1547 page1: { x: 0 },
1548 page2: { x: 0, scaleX: -2/3 },
1549 }, duration: 15, easing: "linear" },
1550 },
1551
1552 BOOK_DISMISS
1553 ];
1554
1555 var BOOK_BACKWARD = [
1556 { 0: { tween: { page1: { x: -1/3 / 2, scaleX: 0 },
1557 page2: { x: +1/3 / 2 },
1558 }, duration: 15, easing: "linear" },
1559 15: { set: { page1Quad: { z: 1, texBounds: [0.50, 0.5, 0.75, 1] },
1560 page2Quad: { z: 0 } },
1561 tween: { page2Quad: { color: [0.2, 0.2, 0.2, 1] },
1562 page1: { x: 0, scaleX: 2/3 },
1563 page2: { x: 0 },
1564 }, duration: 15, easing: "linear" },
1565 },
1566
1567 { 0: { set: { page1Quad: { color: [0.2, 0.2, 0.2, 1] } },
1568 tween: { page1Quad: { color: [1.0, 1.0, 1.0, 1] },
1569 page1: { x: -1/3 / 2 },
1570 page2: { x: +1/3 / 2, scaleX: 0 }
1571 }, duration: 15, easing: "linear" },
1572
1573 15: { set: { page1Quad: { z: 0, texBounds: [0.25, 0.5, 0.00, 1] },
1574 page2Quad: { z: 0, texBounds: "page" } },
1575 tween: { page1: { x: -1/3 },
1576 page2: { x: +1/3, scaleX: 2/3 },
1577 }, duration: 15, easing: "linear" },
1578 },
1579 ];
1580
1581 BookScene = new yT(yuu.Scene, {
1582 constructor: function () {
1583 yuu.Scene.call(this);
1584 var bg = new yuu.E(
1585 new yuu.Transform().setScale([20, 20, 1]),
1586 this.bgQuad = new yuu.QuadC()
1587 .setColor([0, 0, 0, 0])
1588 .setZ(-1));
1589 this.page1 = new yuu.E(new yuu.Transform(),
1590 this.page1Quad = new yuu.QuadC(BOOK));
1591 this.page1Quad.texBounds = [0.50, 0.5, 0.75, 1];
1592 this.page1Quad.z = 1;
1593 this.page2 = new yuu.E(new yuu.Transform(),
1594 this.page2Quad = new yuu.QuadC(BOOK));
1595 this.page2Quad.texBounds = [0.25, 0.5, 0.50, 1];
1596 this.page1.transform.scale = [2/3, 1, 1];
1597 this.page2.transform.scale = [2/3, 1, 1];
1598 this.entity0.attach(new yuu.Transform());
1599 this.current = 0;
1600 this._locks = new FlagSet("turn");
1601 this.addEntities(bg, this.page1, this.page2);
1602
1603 this.dismissSound = new yuu.Instrument("@book-dismiss");
1604 this.pageSounds = [new yuu.Instrument("@page-turn-1"),
1605 new yuu.Instrument("@page-turn-2"),
1606 new yuu.Instrument("@page-turn-3")];
1607
1608 this.ready = yuu.ready([this.dismissSound].concat(this.pageSounds));
1609 },
1610
1611 help: yuu.cmd(function () {
1612 this.skip();
1613 }, "dismiss the help screen"),
1614
1615 licensing: yuu.cmd(function () {
1616 var licensing = document.getElementById("yuu-licensing");
1617 var parent = licensing.parentNode;
1618 var spinner = document.createElement("div");
1619 spinner.className = "yuu-spinner";
1620 spinner.id = licensing.id;
1621 parent.replaceChild(spinner, licensing);
1622 Promise.all(
1623 yf.map(yuu.GET,
1624 [yuu.PATH + "data/license.txt", "data/license.txt"]))
1625 .then(function (texts) {
1626 var text = texts.join("\n-- \n\n");
1627 var p = document.createElement("pre");
1628 p.textContent = text;
1629 p.id = spinner.id;
1630 parent.replaceChild(p, spinner);
1631 });
1632 }, "why would you ever want to run this?"),
1633
1634 init: function () {
1635 this._anim(BOOK_APPEAR);
1636 storage.setFlag("instructions");
1637 },
1638
1639 _anim: function (anim) {
1640 this._locks.increment("turn");
1641 // FIXME: Need hooks from animations to audio
1642 var completion = this._locks.decrementer("turn");
1643 switch (anim) {
1644 case BOOK_DISMISS:
1645 this.dismissSound.play();
1646 completion = yuu.director.removeScene.bind(yuu.director, this);
1647 break;
1648 case BOOK_APPEAR:
1649 sounds.bookAppear.play();
1650 break;
1651 default:
1652 yuu.random.choice(this.pageSounds).play();
1653 break;
1654 }
1655
1656 var device = yuu.director.preferredDevice();
1657 this.entity0.attach(new yuu.Animation(
1658 anim, {
1659 $: this.entity0.transform,
1660 page: device === "keyboard" ? KEYBOARD_PAGE
1661 : device === "gamepad" ? GAMEPAD_PAGE
1662 : POINTERS_PAGE,
1663 page1: this.page1.transform,
1664 page2: this.page2.transform,
1665 page1Quad: this.page1Quad,
1666 page2Quad: this.page2Quad,
1667 bgQuad: this.bgQuad
1668 }, completion));
1669 },
1670
1671 advance: yuu.cmd(function () {
1672 if (this._locks.some("turn"))
1673 return;
1674 this._anim(BOOK_FORWARD[this.current++]);
1675 }),
1676
1677 skip: yuu.cmd(function () {
1678 if (this._locks.some("turn"))
1679 return;
1680 this._anim(BOOK_DISMISS);
1681 }),
1682
1683 back: yuu.cmd(function () {
1684 if (this._locks.some("turn"))
1685 return;
1686 if (this.current > 0)
1687 this._anim(BOOK_BACKWARD[--this.current]);
1688 }),
1689
1690 LOGOTYPE: new yuu.AABB(-0.16, -0.41, 0.12, -0.33),
1691 COLOPHON: new yuu.AABB(-0.06, -0.41, 0.11, -0.28),
1692
1693 inputs: {
1694 resize: function () {
1695 var base = new yuu.AABB(-0.7, -0.55, 0.7, 0.55);
1696 var vp = base.matchAspectRatio(yuu.viewport);
1697 this.layer0.resize(vp.x0, vp.y0, vp.w, vp.h);
1698 },
1699
1700 mousemove: function (p) {
1701 p = this.layer0.worldFromDevice(p);
1702 if (this.current === BOOK_FORWARD.length - 1
1703 && this.LOGOTYPE.contains(p)) {
1704 this.cursor = "pointer";
1705 } else if (this.current === 0 && this.COLOPHON.contains(p)) {
1706 this.cursor = "pointer";
1707 } else if (this.current === 0 || p.x >= -0.2) {
1708 this.cursor = "";
1709 } else {
1710 this.cursor = "W-resize";
1711 }
1712 },
1713
1714 tap: function (p) {
1715 p = this.layer0.worldFromDevice(p);
1716 if (this.current === BOOK_FORWARD.length - 1
1717 && this.LOGOTYPE.contains(p)) {
1718 yuu.openURL("http://www.yukkurigames.com/");
1719 } else if (this.current === 0 && this.COLOPHON.contains(p)) {
1720 yuu.director.showOverlay("colophon");
1721 } else if (this.current === 0 || p.x >= -0.2) {
1722 this.advance();
1723 } else {
1724 this.back();
1725 }
1726 return true;
1727 },
1728 swipeleft: function (event) { this.advance(); return true; },
1729 swiperight: function (event) { this.back(); return true; },
1730 dragleft: function (event) { this.advance(); return true; },
1731 dragright: function (event) { this.back(); return true; },
1732 swipeup: function (event) { this.skip(); return true; },
1733 dragup: function (event) { this.skip(); return true; },
1734
1735 consume: yuu.Director.prototype.GESTURES
1736 .concat(yuu.Director.prototype.CANVAS_EVENTS)
1737 },
1738
1739 KEYBINDS: {
1740 space: "advance",
1741 shift: "advance",
1742 z: "advance",
1743 x: "advance",
1744 right: "advance",
1745 left: "back",
1746 back: "skip",
1747 escape: "skip",
1748 gamepadbutton0: "advance",
1749 gamepadbutton1: "skip",
1750 gamepadbutton4: "back",
1751 gamepadbutton5: "advance",
1752 gamepadbutton8: "skip",
1753 gamepadbutton9: "skip",
1754 gamepadbutton14: "back",
1755 gamepadbutton15: "advance",
1756 }
1757 });
1758
1759 var OUTER_FLIP_TICK = {
1760 0: { tween1: { yaw: "yaw" }, duration: 15 }
1761 };
1762
1763 var CIRCLE_TO_BOTTOM = {
1764 0: { tween1: { pitch: Math.PI * 0.35, y: -0.3 }, duration: 35 }
1765 };
1766
1767 var CIRCLE_TO_BACK = {
1768 0: { tween1: { pitch: Math.PI * 0.15, y: -0.1 }, duration: 35 }
1769 };
1770
1771 var CIRCLE_INNER_RATCHET = {
1772 0: { tween1: { rotation: "rotation1" }, duration: 15 },
1773 10: { tween1: { rotation: "rotation2" }, duration: 10 },
1774 20: { tween1: { rotation: "rotation1" }, duration: 20,
1775 easing: yuu.Tween.STEPPED(5) },
1776 40: { tween1: { rotation: "rotation2" }, duration: 15 }
1777 };
1778
1779 var CIRCLE_INNER_WIND = {
1780 0: { tween1: { rotation: "rotation1" }, duration: 8 },
1781 15: { tween1: { rotation: "rotation2" }, duration: 20 },
1782 };
1783
1784 var BACKGROUND_DRIFT = {
1785 0: [{ tween1: { yaw: Math.PI * 2 },
1786 duration: 13 * 60 * 60, repeat: -Infinity, easing: "linear" },
1787 { tween1: { scaleX: 0.5 },
1788 duration: 11 * 60 * 60, repeat: -Infinity },
1789 { tween1: { scaleY: 0.5 },
1790 duration: 7 * 60 * 60, repeat: -Infinity }]
1791 };
1792
1793 var HAND_TICK = {
1794 0: { tween1: { rotation: "rotation" }, duration: 6 }
1795 };
1796
1797 var CHIMES = [
1798 // Nearly all derived from
1799 // http://www.clockguy.com/SiteRelated/SiteReferencePages/ClockChimeTunes.html
1800 //
1801 // All transposition & transcription errors are mine.
1802
1803 { name: "Westminster",
1804 keys: ["D4", "E4"],
1805 bars: ["0 2 1 -3",
1806 "0 1 2 0",
1807 "2 0 1 -3",
1808 "2 1 0 -3",
1809 "-3 1 2 0"]
1810 },
1811
1812 { name: "Wittington",
1813 keys: ["Eb4", "E4"],
1814 bars: ["1 2 3 5 4 6 7 0",
1815 "1 3 5 7 6 4 2 0",
1816 "3 1 2 4 5 6 7 0",
1817 "4 3 5 2 6 1 7 0",
1818 "6 7 2 5 4 1 3 0",
1819 "7 1 6 2 5 3 4 0",
1820 "7 3 2 1 4 5 6 0",
1821 "7 3 6 2 5 1 4 0",
1822 "7 5 3 1 6 4 2 0",
1823 "7 5 6 4 1 3 2 0",
1824 "7 6 3 2 5 4 1 0",
1825 "7 6 5 4 3 2 1 0"]
1826 },
1827
1828 { name: "Canterbury",
1829 keys: ["D4", "E4"],
1830 bars: ["2 0 5 3 1 4",
1831 "3 5 1 4 0 2",
1832 "3 5 4 2 1 0",
1833 "5 3 1 4 2 0",
1834 "1 3 5 2 0 4",
1835 "0 5 3 1 2 4",
1836 "5 3 1 2 4 0"]
1837 },
1838
1839 { name: "Trinity",
1840 keys: ["F3", "D4"],
1841 bars: ["5 4 3 2 1 0",
1842 "2 4 3 1 2 0",
1843 "5 3 4 2 1 0",
1844 "4 3 2 1 5 2",
1845 "5 0 4 3 2 1"]
1846 },
1847
1848 /*
1849 { name: "St. Michael's",
1850 keys: ["F3", "C4"],
1851 bars: ["7 6 5 4 3 2 1 0",
1852 "7 1 2 3 6 4 5 0",
1853 "4 3 2 5 1 6 7 0",
1854 "6 7 2 3 1 4 5 0",
1855 "4 6 2 7 3 1 5 0"]
1856 },
1857 */
1858
1859 { name: "Winchester",
1860 keys: ["C4", "E4"],
1861 bars: ["5 3 1 0 2 4",
1862 "0 1 3 5 4 2",
1863 "5 3 1 4 2 0",
1864 "1 2 5 4 0 1",
1865 "5 1 3 2 4 0"]
1866 }
1867
1868 ];
1869
1870 function third (s) {
1871 return "Q " + s.replace(/([^ ]+ [^ ]+)/g, "$1 Z");
1872 }
1873
1874 function silence (s) {
1875 return "Q " + s.replace(/[^ ]+/g, "Z");
1876 }
1877
1878 var TIMES1 = ["Q", "H", "H", "H", "H.", "H.", "W", "W"];
1879 var TIMES2 = ["Q", "Q", "Q", "Q", "Q", "Q", "Q", "Q", "Q",
1880 third, third, "Q.", "Q.",
1881 "H", "H"];
1882 var TIMES3 = ["Q", "Q", silence, silence,
1883 third, third, third, third,
1884 "Q.", "Q.",
1885 "H", "H"];
1886
1887 function deck (pack, random) {
1888 random = random || yuu.random;
1889 var stock = [];
1890 return function () {
1891 if (stock.length === 0)
1892 stock = random.shuffle(pack.slice());
1893 return stock.pop();
1894 };
1895 }
1896
1897 function generateScore () {
1898 var chimes = yuu.random.choice(CHIMES);
1899 var bar = deck(chimes.bars);
1900 function draw (t) {
1901 return yf.isFunction(t) ? t(bar()) : t + " " + bar();
1902 }
1903
1904 function line (times) {
1905 return yf.map(draw, yuu.random.shuffle(times)).join(" ");
1906 }
1907
1908 var track = "{ - W HZ " + line(TIMES1)
1909 + " { W HZ Z " + line(TIMES2)
1910 + " { W HZ Z Z I Z " + line(TIMES3);
1911 var key = yuu.random.choice(chimes.keys);
1912 yuu.log("messages", "Playing " + chimes.name + " in " + key + " major.");
1913 var score = yuu.parseScore(track, yuu.Scales.MAJOR, key);
1914 score.key = key;
1915 return score;
1916 }
1917
1918 CircleScene = yT(yuu.Scene, {
1919 constructor: function () {
1920 yuu.Scene.call(this);
1921 this.layer0.resize(-0.6, -0.6, 1.2, 1.2);
1922 var arm = this.arm = new yuu.E(new yuu.Transform());
1923 this.outer = new yuu.E(
1924 new yuu.Transform([Math.sqrt(2) / 5, -Math.sqrt(2) / 5, 0]),
1925 this.outerQuad = new yuu.QuadC(new yuu.Material("@circle-outer"))
1926 .setZ(1)
1927 .setLuminance(0.4)
1928 .setSize([0.35417, 0.35417]));
1929 arm.addChild(this.outer);
1930
1931 var rim = new yuu.E(
1932 new yuu.Transform(),
1933 this.rimQuad = new yuu.QuadC(new yuu.Material("@circle-rim"))
1934 .setLuminance(0.2));
1935 var inner = this.inner = new yuu.E(
1936 new yuu.Transform(),
1937 this.innerQuad = new yuu.QuadC(new yuu.Material("@circle-inner"))
1938 .setLuminance(0.3));
1939
1940 var NOISY_QUADS = new yuu.ShaderProgram(
1941 ["@noise.glsl", "@noisyquads"], ["yuu/@color"]);
1942
1943 var bgMat = new yuu.Material(
1944 yuu.Texture.DEFAULT, NOISY_QUADS, { range: 0.8 });
1945 bgMat.uniforms.cut = yf.volatile(cycler(100000));
1946 var DIM = 16;
1947 var batch = new yuu.QuadBatchC(DIM * DIM);
1948 batch.material = bgMat;
1949 var bg = new yuu.E(new yuu.Transform(), batch);
1950 yf.irange(function (x) {
1951 yf.irange(function (y) {
1952 var quad = batch.createQuad();
1953 quad.size = [1/4, 1/4];
1954 quad.position = [(x - DIM / 2) * 1/4,
1955 (y - DIM / 2) * 1/4];
1956 quad.color = [0.12, 0.08, 0.16];
1957 quad.texBounds = yf.repeat(x * DIM + y, 4);
1958 }, DIM);
1959 }, DIM);
1960
1961 this.entity0.addChild(bg);
1962 this.entity0.attach(new yuu.Animation(
1963 BACKGROUND_DRIFT, { $: bg.transform }));
1964
1965 this.ground = new yuu.E(new yuu.Transform());
1966 this.ground.addChildren(rim, inner, arm);
1967 this.entity0.addChild(this.ground);
1968
1969 this.music = yuu.audio.createGain();
1970 this.music.gain.value = 0.3;
1971 this.music.connect(yuu.audio.music);
1972 this._finished = false;
1973
1974 this.ready = yuu.ready([
1975 this.outerQuad.material,
1976 this.innerQuad.material,
1977 this.rimQuad.material,
1978 bgMat.ready
1979 ]);
1980 },
1981
1982 help: yuu.cmd(function () {
1983 yuu.director.pushScene(new BookScene());
1984 }, "bring up the help screen"),
1985
1986 yuu: yuu.cmd(function () {
1987 this.outerQuad.material = new yuu.Material("@circle-outer-ee");
1988 }, "yuu~"),
1989
1990 KEYBINDS: {
1991 slash: "help",
1992 f1: "help",
1993 gamepadbutton6: "help",
1994 f10: "showOverlay preferences",
1995 "shift+y+u+`": "yuu",
1996 "gamepadbutton10+gamepadbutton11": "yuu",
1997 },
1998
1999 inputs: {
2000 resize: function () {
2001 var vp = new yuu.AABB(-0.6, -0.6, 0.6, 0.6)
2002 .matchAspectRatio(yuu.viewport);
2003 this.layer0.resize(vp.x0, vp.y0, vp.w, vp.h);
2004 }
2005 },
2006
2007 toBottom: function () {
2008 this.entity0.attach(
2009 new yuu.Animation(CIRCLE_TO_BOTTOM, { $: this.ground.transform }));
2010 },
2011
2012 wind: function () {
2013 var rot1 = this.inner.transform.rotation;
2014 quat.rotateZ(rot1, rot1, Math.PI / (2 * Math.E));
2015 var rot2 = quat.rotateX(quat.create(), rot1, -Math.PI / 2);
2016 quat.rotateY(rot2, rot2, Math.PI / 2);
2017 quat.rotateX(rot2, rot2, -Math.PI / 2);
2018 this.entity0.attach(
2019 new yuu.Animation(CIRCLE_INNER_WIND, {
2020 $: this.inner.transform,
2021 rotation1: rot1,
2022 rotation2: rot2
2023 }));
2024 this.tension = 0.5;
2025 this.reversed = 0;
2026 var score = [];
2027 score.key = this.score && this.score.key;
2028 this.score = score;
2029 },
2030
2031 _musicSchedule: function (count) {
2032 var t = yuu.director.currentAudioTime;
2033 var note;
2034
2035 if (this._finished) {
2036 if (this._finished === "won" && this.score.key) {
2037 var score = yuu.parseScore(
2038 yuu.random.choice([
2039 "1 3 2 Z 0 { - 1 Z 2 Z 0",
2040 "1 2 3 Z 0 { - 1 Z 3 Z 0",
2041 "0 1 2 Z 4 { - 0 Z 2 Z 4",
2042 ]),
2043 yuu.Scales.MAJOR, this.score.key);
2044 while ((note = score.shift())) {
2045 sounds.chime.createSound(
2046 yuu.audio,
2047 t + note.time / 4,
2048 note.hz,
2049 1.0, note.duration
2050 ).connect(this.music);
2051 }
2052 }
2053 this._finished = false;
2054 return false;
2055 }
2056
2057 if (!(this.score && this.score.length)) {
2058 this.score = generateScore();
2059 this.playing = 0;
2060 }
2061
2062 ++this.playing;
2063 while (this.score.length && this.score[0].time < this.playing) {
2064 note = this.score.shift();
2065 sounds.chime.createSound(
2066 yuu.audio,
2067 t + note.time % 1 + yuu.random.gauss(0, 0.015),
2068 note.hz,
2069 1.0, note.duration
2070 ).connect(this.music);
2071 }
2072
2073 if ((this.tension *= 0.95) > 1) {
2074 this.tension /= 2;
2075 sounds.winding.createSound(yuu.audio, t, 0, 1.0, 1.0)
2076 .connect(this.music);
2077 var flip = !this.outer.transform.yaw * yuu.random.randsign(Math.PI);
2078 this.entity0.attach(
2079 new yuu.Animation(OUTER_FLIP_TICK, {
2080 $: this.outer.transform,
2081 yaw: flip
2082 }));
2083 } else {
2084 [sounds.tick, sounds.tock][count & 1]
2085 .createSound(yuu.audio, t, 0, 0.5, 1.0)
2086 .connect(this.music);
2087 }
2088
2089 this.clockTick(this.reversed-- > 0 ? TICK_REV : TICK_ROT);
2090
2091 return true;
2092 },
2093
2094 clockTick: function (amount, anim) {
2095 var rot = this.arm.transform.rotation;
2096 quat.multiply(rot, rot, amount || TICK_ROT);
2097 this.arm.attach(new yuu.Animation(
2098 anim || HAND_TICK,
2099 { $: this.arm.transform, rotation: rot }));
2100 },
2101
2102 toBack: function () {
2103 this.wind();
2104 this.entity0.attach(
2105 new yuu.Animation(CIRCLE_TO_BACK, { $: this.ground.transform }));
2106
2107 this.playing = 4;
2108 this.arm.attach(
2109 new yuu.Ticker(this._musicSchedule.bind(this), 60));
2110 },
2111
2112 win: function () {
2113 this._finished = "won";
2114 this.wind();
2115 this.entity0.attach(
2116 new yuu.Animation(FLASH, { $: this.innerQuad }),
2117 new yuu.Animation(FLASH, { $: this.rimQuad }, null, 32),
2118 new yuu.Animation(FLASH, { $: this.outerQuad }, null, 48)
2119 );
2120 },
2121
2122 lose: function () {
2123 this._finished = "lose";
2124 var rot1 = this.inner.transform.rotation;
2125 quat.rotateZ(rot1, rot1, -Math.PI / Math.E);
2126 var rot2 = quat.rotateZ(quat.create(), rot1, Math.PI / Math.E);
2127 this.entity0.attach(
2128 new yuu.Animation(CIRCLE_INNER_RATCHET, {
2129 $: this.inner.transform,
2130 rotation1: rot1,
2131 rotation2: rot2
2132 }));
2133 sounds.regear.play();
2134 },
2135
2136 rotated: function () {
2137 this.tension += yuu.random.uniform(0.1);
2138 },
2139
2140 slam: function () {
2141 this.tension += yuu.random.uniform(0.2);
2142 },
2143
2144 reverse: function () {
2145 this.tension -= yuu.random.uniform(0.1);
2146 this.reversed = Math.max(this.reversed, 0) + 1;
2147 }
2148
2149 });