src/yuu/core.js

   1 /* Copyright 2014 Yukkuri Games
   2    Licensed under the terms of the GNU GPL v2 or later
   3    @license http://www.gnu.org/licenses/gpl-2.0.html
   4    @source: http://yukkurigames.com/yuu/
   5 */
   6
   7 (function (yuu) {
   8     "use strict";
   9
  10
  11     yuu.require = function (m) {
  12         try { return require(m); }
  13         catch (exc) { return null; }
  14     };
  15
  16     if (!Math.sign)
  17         require("./pre");
  18
  19     var yT = this.yT || require("./yT");
  20     var yf = this.yf || require("./yf");
  21     var gui = yuu.require("nw.gui");
  22     var fs = yuu.require("fs");
  23     var stringLerp = this.stringLerp || yuu.require("string-lerp");
  24
  25     var initHooks = [];
  26     var initOptions = null;
  27
  28     if (typeof document !== "undefined") {
  29         var scripts = document.getElementsByTagName('script');
  30         var path = yf.last(scripts).src.split('?')[0];
  31         yuu.PATH = path.split('/').slice(0, -1).join('/') + '/';
  32     } else {
  33         yuu.PATH = "file://" + escape(module.__dirname) + "/";
  34     }
  35
  36     yuu.registerInitHook = initHooks.push.bind(initHooks);
  37         /** Register a hook to be called during Yuu initialization
  38
  39             Hooks are called in registration order with the module and
  40             the options dictionary passed to the init method. (This is
  41             also set to the module.)
  42         */
  43
  44     function showError (exc, kind) {
  45         var prefix = "yuu-" + (kind || "") + "error";
  46         yuu.logError(exc);
  47         var dialog = document.getElementById(prefix);
  48         var errorMessage = document.getElementById(prefix + "-message");
  49         if (errorMessage)
  50             errorMessage.textContent = exc.message;
  51         var errorStack = document.getElementById(prefix + "-stack");
  52         if (errorStack)
  53             errorStack.textContent = exc.message + "\n\n" + exc.stack;
  54         return dialog;
  55     }
  56     yuu.showError = showError;
  57
  58     function fatalError (exc) {
  59         var dialog = showError(exc, "fatal-");
  60         if (dialog)
  61             dialog.style.display = "block";
  62         if (gui) {
  63             gui.Window.get().show();
  64             gui.Window.get().focus();
  65         }
  66         throw exc;
  67     }
  68
  69     yuu.init = function (options) {
  70         /** Initialize Yuu and call all registered hooks
  71          */
  72
  73         if (gui) {
  74             var win = gui.Window.get();
  75             var nativeMenuBar = new gui.Menu({ type: "menubar" });
  76             if (nativeMenuBar.createMacBuiltin) {
  77                 nativeMenuBar.createMacBuiltin(
  78                     document.title, { hideEdit: true });
  79                 win.menu = nativeMenuBar;
  80             }
  81             var wkdoc = document;
  82             win.on("minimize", function () {
  83                 var ev = new Event("visibilitychange");
  84                 wkdoc.hidden = true;
  85                 wkdoc.dispatchEvent(ev);
  86             });
  87             win.on("restore", function () {
  88                 var ev = new Event("visibilitychange");
  89                 wkdoc.hidden = false;
  90                 wkdoc.dispatchEvent(ev);
  91             });
  92         }
  93
  94         return new Promise(function (resolve) {
  95             // TODO: Some kind of loading progress bar.
  96             initOptions = options || {};
  97             yuu.log("messages", "Initializing Yuu engine.");
  98             var promises = [];
  99             yf.each(function (hook) {
 100                 promises.push(hook.call(yuu, initOptions));
 101             }, initHooks);
 102             initHooks = null; // Bust future registerInitHook calls.
 103             yuu.log("messages", "Initialization hooks complete.");
 104             if (gui) {
 105                 gui.Window.get().show();
 106                 gui.Window.get().focus();
 107             }
 108             resolve(Promise.all(yf.filter(null, promises)));
 109         }).then(function () {
 110             yuu.log("messages", "Loading complete.");
 111         }).catch(fatalError);
 112     };
 113
 114     yuu.log = yf.argv(function (category, args) {
 115         /** Log a message to the console.
 116
 117             This supports simple filtering by setting e.g.
 118             `yuu.log.errors = true` to log anything with the
 119             `"errors"` category.
 120         */
 121         if (!category || this.log[category]) {
 122             switch (category) {
 123             case "errors": return console.error.apply(console, args);
 124             case "warnings": return console.warn.apply(console, args);
 125             default: return console.log.apply(console, args);
 126             }
 127         }
 128     });
 129
 130     yuu.log.errors = true;
 131     yuu.log.warnings = true;
 132     yuu.log.messages = true;
 133
 134     yuu.logError = function (e) {
 135         yuu.log("errors", e.message || "unknown error", e);
 136     };
 137
 138     yuu.GET = function (url, params) {
 139         /** Promise the HTTP GET the contents of a URL. */
 140         return new Promise(function (resolve, reject) {
 141             var req = new XMLHttpRequest();
 142             req.open("GET", url, true);
 143             for (var k in params)
 144                 req[k] = params[k];
 145             req.onload = function () {
 146                 var status = this.status;
 147                 // status === 0 is given by node-webkit for success.
 148                 if ((status >= 200 && status < 300) || status === 0)
 149                     resolve(this.response);
 150                 else
 151                     reject(new Error(
 152                         url + ": " + status + ": " + this.statusText));
 153             };
 154             req.onabort = function () { reject(new Error("aborted")); };
 155             req.onerror = function () { reject(new Error("network error")); };
 156             req.ontimeout = function () { reject(new Error("timed out")); };
 157             req.send(null);
 158         });
 159     };
 160
 161     yuu.Image = function (src) {
 162         /** Promises a DOM Image. */
 163         return new Promise(function (resolve, reject) {
 164             var img = new Image();
 165             img.onload = function () {
 166                 resolve(img);
 167             };
 168             img.onerror = function () {
 169                 var msg = "Unable to load " + img.src;
 170                 yuu.log("errors", msg);
 171                 reject(new Error(msg));
 172             };
 173             img.src = src;
 174         });
 175     };
 176
 177     /** Command parsing and execution
 178
 179         The command API serves several roles. It is a way to enable or
 180         disable different game logic within different scenes; capture
 181         and replay or automate game events; loosely or late-bind game
 182         modules; customize input mappings; and a debugging tool to
 183         help inspect or modify the state of a running program.
 184
 185         A command is a string of a command name followed by arguments
 186         separated by whitespace. It's similar to a fully bound
 187         closure. It is less flexible but easier to inspect, store,
 188         replay, and pass around.
 189
 190         Command names are mapped to functions, grouped into sets, and
 191         the sets pushed onto a stack. They are executed by passing the
 192         command string to the execute function which walks the stack
 193         looking for the matching command.
 194
 195         If the command string is prefaced with + or -, true or false
 196         are appended to the argument list. e.g. `+command` is
 197         equivalent to `command true` and `-command 1 b` is equivalent
 198         to `command 1 b false`. By convention, commands of those forms
 199         return their internal state when called with neither true or
 200         false. This is useful for another special prefix, ++. When
 201         called as `++command`, it is executed with no arguments, the
 202         result inverted (with !), and then called again passing that
 203         inverted value as the last argument.
 204     */
 205
 206     function isCommand (f) {
 207         return yf.isFunction(f) && f._isCommandFunction;
 208     }
 209
 210     function cmdbind () {
 211         // Commands are practically a subtype of functions. Binding
 212         // them (which happens often, e.g. when Scenes register
 213         // commands) should also return a command.
 214         var f = Function.prototype.bind.apply(this, arguments);
 215         // usage is still valid iff no new arguments were given.
 216         return cmd(f, arguments.length <= 1 && this.usage, this.description);
 217     }
 218
 219     var cmd = yuu.cmd = yf.argcd(
 220         /** Decorate a function for command execution
 221
 222             Command functions need some special attributes to work
 223             correctly. This decorator makes sure they have them.
 224         */
 225         function (f) { return yuu.cmd(f, null, null); },
 226         function (f, description) { return yuu.cmd(f, null, description); },
 227         function (f, usage, description) {
 228             f._isCommandFunction = true;
 229             f.usage = usage || " <value>".repeat(f.length).substring(1);
 230             f.description = description || "no description provided";
 231             f.bind = cmdbind;
 232             return f;
 233         }
 234     );
 235
 236     yuu.propcmd = function (o, prop, desc, valspec) {
 237         /** Generate a command function that controls a property
 238
 239             A common pattern for command functions is to simply get or
 240             set a single object property. This wrapper will generate a
 241             correct function to do that.
 242         */
 243         valspec = valspec || typeof o[prop];
 244         desc = desc || "Retrieve or modify the value of " + prop;
 245         return cmd(function () {
 246             if (arguments.length)
 247                 o[prop] = arguments[0];
 248             return o[prop];
 249         }, "<" + valspec + "?>", desc);
 250     };
 251
 252     var QUOTED_SPLIT = /[^"\s]+|"(?:\\"|[^"])+"/g;
 253     var COMMAND_SPLIT = /\s+(&&|\|\||;)\s+/g;
 254
 255     function parseParam (param) {
 256         if (yf.head(param) === "{" && yf.last(param) === "}")
 257             return resolvePropertyPath(
 258                 this, param.substr(1, param.length - 2));
 259         try { return JSON.parse(param); }
 260         catch (exc) { return param; }
 261     }
 262
 263     function parseCommand (cmdstring, ctx) {
 264         /** Parse a command string into an invocation object.
 265
 266             The command string has a form like `+quux 1 2 3` or
 267             `foobar "hello world"`.
 268
 269             Multiple commands can be joined in one string with &&, ||,
 270             or ;. To use these characters literally as a command
 271             argument place them in quotes.
 272
 273             Arguments wrapped in {}s are interpreted as property paths
 274             for the provided context object. `{x[0].y}` will resolve
 275             `ctx.x[0].y` and put that into the arguments array. To
 276             avoid this behavior and get a literal string bounded by
 277             {}, JSON-encode the string beforehand (e.g. `"{x[0].y}"`).
 278
 279             The returned array contains objects with three properties:
 280             `name` - the command name to execute
 281             `args` - an array of objects to pass as arguments
 282             `toggle` - if the command value should be toggled ('++')
 283                        and pushed into args
 284             `cond` - "&&", "||", or ";", indicating what kind of
 285                      conditional should be applied.
 286         */
 287
 288         var invs = [];
 289         var conds = cmdstring.split(COMMAND_SPLIT);
 290         for (var i = -1; i < conds.length; i += 2) {
 291             var args = conds[i + 1].match(QUOTED_SPLIT).map(parseParam, ctx);
 292             var name = args.shift();
 293             var toggle = false;
 294             if (name[0] === "+" && name[1] === "+") {
 295                 name = name.substring(2);
 296                 toggle = true;
 297             } else if (name[0] === "+") {
 298                 name = name.substring(1);
 299                 args.push(true);
 300             } else if (name[0] === "-") {
 301                 name = name.substring(1);
 302                 args.push(false);
 303             }
 304             invs.push({ name: name, args: args, toggle: toggle,
 305                         cond: conds[i] || ";"});
 306         }
 307         return invs;
 308     }
 309
 310     yuu.CommandStack = yT({
 311         constructor: function () {
 312             /** A stack of command sets for command lookup and execution */
 313             this._cmdsets = yf.slice(arguments);
 314         },
 315
 316         push: function (cmdset) {
 317             /** Add a command set to the lookup stack. */
 318             this._cmdsets = this._cmdsets.concat(cmdset);
 319         },
 320
 321         remove: function (cmdset) {
 322             /** Remove a command set from the lookup stack. */
 323             this._cmdsets = yf.without(this._cmdsets, cmdset);
 324         },
 325
 326         insertBefore: function (cmdset, before) {
 327             this._cmdsets = yf.insertBefore(
 328                 this._cmdsets.slice(), cmdset, before);
 329         },
 330
 331         execute: function (cmdstring, ctx) {
 332             /* Execute a command given a command string.
 333
 334                The command stack is searched top-down for the first
 335                command with a matching name, and it is invoked.  No
 336                other commands are called.
 337
 338                A command set may also provide a special function named
 339                `$`. If no matching command name is found, this
 340                function is called with the raw invocation object (the
 341                result of yuu.parseCommand) and may return true to stop
 342                processing as if the command had been found.
 343             */
 344             var invs = parseCommand(cmdstring, ctx);
 345             var cond;
 346             var res;
 347             yf.each.call(this, function (inv) {
 348                 if ((inv.cond === "&&" && !cond) || (inv.cond === "||" && cond))
 349                     return;
 350                 if (!yf.eachrUntil(function (cmdset) {
 351                     var cmd = cmdset[inv.name];
 352                     if (cmd) {
 353                         if (inv.toggle)
 354                             inv.args.push(!cmd.apply(null, inv.args));
 355                         yuu.log("commands", "Executing:", inv.name,
 356                                 inv.args.map(JSON.stringify).join(" "));
 357                         res = cmd.apply(null, inv.args);
 358                         cond = res === undefined ? cond : !!res;
 359                         yuu.log("commands", "Result:", JSON.stringify(res));
 360                         return true;
 361                     }
 362                     return cmdset.$ && cmdset.$(inv);
 363                 }, this._cmdsets))
 364                     yuu.log("errors", "Unknown command", inv.name);
 365             }, invs);
 366             return res;
 367         }
 368     });
 369
 370     yuu.extractCommands = function (object) {
 371         var commands = {};
 372         yf.each(function (prop) {
 373             // Check the descriptor before checking the value, because
 374             // checking the value of accessors (which should never be
 375             // stable commands) is generally a bad idea during
 376             // constructors, and command sets are often filled in during
 377             // constructors.
 378             if (yT.isDataDescriptor(yT.getPropertyDescriptor(object, prop))
 379                 && isCommand(object[prop]))
 380                 commands[prop] = object[prop].bind(object);
 381         }, yf.allKeys(object));
 382         return commands;
 383     };
 384
 385     yuu.commandStack = new yuu.CommandStack(yuu.defaultCommands = {
 386         /** The default command stack and set. */
 387         cmds: yuu.cmd(function (term) {
 388             term = term || "";
 389             var cmds = [];
 390             yuu.commandStack._cmdsets.forEach(function (cmdset) {
 391                 for (var cmdname in cmdset) {
 392                     if (cmdname.indexOf(term) >= 0) {
 393                         var cmd = cmdset[cmdname];
 394                         var msg;
 395                         if (cmd.usage)
 396                             msg = [cmdname, cmd.usage, "--", cmd.description];
 397                         else
 398                             msg = [cmdname, "--", cmd.description];
 399                         cmds.push(msg.join(" "));
 400                     }
 401                 }
 402             });
 403             yuu.log("messages", cmds.join("\n"));
 404         }, "<term?>", "display available commands (matching the term)"),
 405
 406         echo: yuu.cmd(function () {
 407             yuu.log("messages", arguments);
 408         }, "...", "echo arguments to the console"),
 409
 410         log: yuu.cmd(function (name, state) {
 411             if (state !== undefined)
 412                 yuu.log[name] = !!state;
 413             return yuu.log[name];
 414         }, "<category> <boolean?>", "enable/disable a logging category")
 415
 416     });
 417
 418     yuu.defaultCommands.showDevTools = yuu.cmd(function () {
 419         if (gui)
 420             gui.Window.get().showDevTools();
 421     }, "show developer tools");
 422
 423     var anchorPoint = yuu.anchorPoint = yf.argcd(
 424         /** Calculate the anchor point for a box given extents and anchor mode
 425
 426             This function is the inverse of yuu.bottomLeft.
 427         */
 428         function (anchor, aabb) {
 429             return anchorPoint(anchor, aabb.x0, aabb.y0, aabb.x1, aabb.y1);
 430         },
 431         function (anchor, x0, y0, x1, y1) {
 432             switch (anchor) {
 433             case "center": return [(x0 + x1) / 2, (y0 + y1) / 2];
 434             case "top": return [(x0 + x1) / 2, y1];
 435             case "bottom": return [(x0 + x1) / 2, y0];
 436             case "left": return [x0, (y0 + y1) / 2];
 437             case "right": return [x1, (y0 + y1) / 2];
 438             case "topleft": return [x0, y1];
 439             case "topright": return [x1, y1];
 440             case "bottomleft": return [x0, y0];
 441             case "bottomright": return [x0, y0];
 442             default: return [anchor[0], anchor[1]];
 443             }
 444         }
 445     );
 446
 447     yuu.bottomLeft = function (anchor, x, y, w, h) {
 448         /** Calculate the bottom-left for a box given size and anchor mode
 449
 450             This function is the inverse of yuu.anchorPoint.
 451         */
 452         switch (anchor) {
 453         case "center": return [x - w / 2, y - h / 2];
 454         case "top": return [x - w / 2, y - h];
 455         case "bottom": return [x - w / 2, y];
 456         case "left": return [x, y - h / 2];
 457         case "right": return [x - w, y - h / 2];
 458
 459         case "topleft": return [x, y - h];
 460         case "topright": return [x - w, y - h];
 461         case "bottomleft": return [x, y];
 462         case "bottomright": return [x - w, y];
 463         default: return [anchor[0], anchor[1]];
 464         }
 465     };
 466
 467     yuu.lerp = function (a, b, p) {
 468         return (a !== null && a !== undefined && a.lerp)
 469             ? a.lerp(b, p) : (b !== null && b !== undefined && b.lerp)
 470             ? b.lerp(a, 1 - p) : p < 0.5 ? a : b;
 471     };
 472
 473     yuu.bilerp = function (x0y0, x1y0, x0y1, x1y1, px, py) {
 474         /** Bilinearly interpolate between four values in two dimensions */
 475         return yuu.lerp(yuu.lerp(x0y0, x1y0, px), yuu.lerp(x0y1, x1y1, px), py);
 476     };
 477
 478     function resolvePropertyPath (object, path) {
 479         /** Look up a full property path
 480
 481             If a null is encountered in the path, this function returns
 482             null. If undefined is encountered or a property is missing, it
 483             returns undefined.
 484         */
 485         var parts = path.replace(/\[(\w+)\]/g, '.$1').split('.');
 486         for (var i = 0;
 487              i < parts.length && object !== undefined && object !== null;
 488              ++i) {
 489             object = object[parts[i]];
 490         }
 491         return object;
 492     }
 493
 494     yuu.Random = yT({
 495         /** Somewhat like Python's random.Random.
 496
 497             Passed a function that returns a uniform random variable in
 498             [0, 1) it can do other useful randomization algorithms.
 499
 500             Its methods are implemented straightforwardly rather than
 501             rigorously - this means they may not behave correctly in
 502             common edge cases like precision loss.
 503         */
 504         constructor: function (generator) {
 505             this.random = generator || Math.random;
 506             this._spareGauss = null;
 507         },
 508
 509         choice: function (seq) {
 510             /** Return a random element from the provided array. */
 511             return seq[this.randrange(0, seq.length)];
 512         },
 513
 514         randrange: yf.argcd(
 515             function (a) {
 516                 /** Return a uniform random integer in [0, a). */
 517                 return (this.random() * a) | 0;
 518             },
 519
 520             function (a, b) {
 521                 /** Return a uniform random integer in [a, b). */
 522                 a = a | 0;
 523                 b = b | 0;
 524                 return a + ((this.random() * (b - a)) | 0);
 525             },
 526
 527             function (a, b, step) {
 528                 /** Return a uniform random number in [a, b).
 529
 530                     The number is constrained to values of a + i * step
 531                     where i is a non-negative integer.
 532                 */
 533                 var i = Math.ceil((b - a) / step);
 534                 return a + this.randrange(i) * step;
 535             }
 536         ),
 537
 538         uniform: yf.argcd(
 539             function (a) {
 540                 /** Return a uniform random variable in [0, a). */
 541                 return a * this.random();
 542             },
 543             function (a, b) {
 544                 /** Return a uniform random variable in [a, b). */
 545                 return a + (b - a) * this.random();
 546             }
 547         ),
 548
 549         gauss: function (mean, sigma) {
 550             var u = this._spareGauss, v, s;
 551             this._spareGauss = null;
 552
 553             if (u === null) {
 554                 do {
 555                     u = this.uniform(-1, 1);
 556                     v = this.uniform(-1, 1);
 557                     s = u * u + v * v;
 558                 } while (s >= 1.0 || s === 0.0);
 559                 var t = Math.sqrt(-2.0 * Math.log(s) / s);
 560                 this._spareGauss = v * t;
 561                 u *= t;
 562             }
 563             return mean + sigma * u;
 564         },
 565
 566         randbool: yf.argcd(
 567             /** Return true the given percent of the time (default 50%). */
 568             function () { return this.random() < 0.5; },
 569             function (a) { return this.random() < a; }
 570         ),
 571
 572         randsign: function (v) {
 573             return this.randbool() ? v : -v;
 574         },
 575
 576         shuffle: function (seq) {
 577             for (var i = seq.length - 1; i > 0; --i) {
 578                 var index = this.randrange(i + 1);
 579                 var temp = seq[i];
 580                 seq[i] = seq[index];
 581                 seq[index] = temp;
 582             }
 583             return seq;
 584         },
 585
 586         discard: function (z) {
 587             z = z | 0;
 588             while (z-- > 0)
 589                 this.random();
 590         }
 591     });
 592
 593     yuu.createLCG = yf.argcd(
 594         /** Linear congruential random generator
 595
 596             This returns a function that generates numbers [0, 1) as
 597             with Math.random. You can also read or assign the `state`
 598             attribute to set the internal state.
 599         */
 600         function () { return yuu.createLCG(Math.random() * 2147483647); },
 601         function (seed) {
 602             var state = seed | 0;
 603             return function generator () {
 604                 state = (state * 1664525 + 1013904223) % 4294967296;
 605                 return state / 4294967296;
 606             };
 607         }
 608     );
 609
 610     yuu.random = new yuu.Random();
 611
 612     function defaultKey (args) {
 613         // Cache things that can be constructed with one string.
 614         return args.length === 1 && yf.isString(args[0]) ? args[0] : null;
 615     }
 616
 617     yuu.Caching = function (Type, cacheKey) {
 618         function ctor () {
 619             var k = ctor._cacheKey(arguments);
 620             var o = k && ctor._cache[k];
 621             if (!o)
 622                 o = ctor._cache[k] = yf.construct(ctor.Uncached, arguments);
 623             return o;
 624         }
 625         ctor._cacheKey = cacheKey || defaultKey;
 626         ctor._cache = {};
 627         ctor.Uncached = Type;
 628         return ctor;
 629     };
 630
 631     yuu.transpose2d = function (a) {
 632         for (var x = 0; x < a.length; ++x) {
 633             for (var y = 0; y < x; ++y) {
 634                 var t = a[x][y];
 635                 a[x][y] = a[y][x];
 636                 a[y][x] = t;
 637             }
 638         }
 639     };
 640
 641     yuu.normalizeRadians = function (theta) {
 642         var PI = Math.PI;
 643         return (theta + 3 * PI) % (2 * PI) - PI;
 644     };
 645
 646     yuu.radians = function (v) {
 647         return v * (Math.PI / 180.0);
 648     };
 649
 650     yuu.degrees = function (v) {
 651         return v * (180.0 / Math.PI);
 652     };
 653
 654     var SHORT = /(\/|^)@(.+)$/;
 655     yuu.resourcePath = function (path, category, ext) {
 656         var match;
 657         if ((match = path.match(SHORT))) {
 658             path = path.replace(/^yuu\/@/, yuu.PATH + "@")
 659                 .replace(SHORT, "$1data/" + category + "/$2");
 660             if (match[2].indexOf(".") === -1)
 661                 path += "." + ext;
 662         }
 663         return path;
 664     };
 665
 666     yuu.ready = function (resources, result) {
 667         return Promise.all(yf.filter(null, yf.pluck("ready", resources)))
 668             .then(yf.K(result));
 669     };
 670
 671     yuu.openURL = function (url) {
 672         if (gui && gui.Shell)
 673             gui.Shell.openExternal(url);
 674         else
 675             window.open(url);
 676     };
 677
 678     function crossPlatformFilename (basename) {
 679         return basename
 680             // Replace D/M/Y with D-M-Y, and H:M:S with H.M.S.
 681             .replace(/\//g, "-").replace(/:/g, ".")
 682             // Replace all other problematic characters with _.
 683             .replace(/["<>*?|\\]/g, "_");
 684     }
 685
 686     yuu.downloadURL = function (url, suggestedName) {
 687         var regex = /^data:[^;+]+;base64,(.*)$/;
 688         var matches = url.match(regex);
 689         suggestedName = crossPlatformFilename(suggestedName);
 690         if (matches && fs) {
 691             var data = matches[1];
 692             var buffer = new Buffer(data, 'base64');
 693             var HOME = process.env.HOME
 694                 || process.env.HOMEPATH
 695                 || process.env.USERPROFILE;
 696             var filename = HOME + "/" + suggestedName;
 697             console.log("Saving to", filename);
 698             fs.writeFileSync(filename, buffer);
 699         } else {
 700             var link = document.createElement('a');
 701             link.style.display = "none";
 702             link.href = url;
 703             link.download = suggestedName;
 704             // Firefox (as of 28) won't download from a link not rooted in
 705             // the document; so, root it and then remove it when done.
 706             document.body.appendChild(link);
 707             link.click();
 708             document.body.removeChild(link);
 709         }
 710     };
 711
 712     yuu.AABB = yT({
 713         constructor: yf.argcd(
 714             function () { this.constructor(0, 0, 0, 0); },
 715             function (w, h) { this.constructor(0, 0, w, h); },
 716             function (x0, y0, x1, y1) {
 717                 this.x0 = x0;
 718                 this.y0 = y0;
 719                 this.x1 = x1;
 720                 this.y1 = y1;
 721             }
 722         ),
 723
 724         xc: {
 725             get: function () { return (this.x0 + this.x1) / 2; }
 726         },
 727         yc: {
 728             get: function () { return (this.y0 + this.y1) / 2; }
 729         },
 730
 731         w: {
 732             get: function () { return this.x1 - this.x0; },
 733             set: function (w) { this.x1 = this.x0 + w; }
 734         },
 735
 736         h: {
 737             get: function () { return this.y1 - this.y0; },
 738             set: function (h) { this.y1 = this.y0 + h; }
 739         },
 740
 741         size: { swizzle: "wh" },
 742
 743         contains: yf.argcd(
 744             function (p) { return this.contains(p.x, p.y); },
 745             function (x, y) {
 746                 return x >= this.x0 && x < this.x1
 747                     && y >= this.y0 && y < this.y1;
 748             }
 749         ),
 750
 751         matchAspectRatio: function (outer) {
 752             var matched = new this.constructor(
 753                 this.x0, this.y0, this.x1, this.y1);
 754             var aRatio = matched.w / matched.h;
 755             var bRatio = outer.w / outer.h;
 756             if (aRatio > bRatio) {
 757                 // too wide, must be taller
 758                 var h = matched.w / bRatio;
 759                 var dh = h - matched.h;
 760                 matched.y0 -= dh / 2;
 761                 matched.y1 += dh / 2;
 762             } else {
 763                 // too tall, must be wider
 764                 var w = matched.h * bRatio;
 765                 var dw = w - matched.w;
 766                 matched.x0 -= dw / 2;
 767                 matched.x1 += dw / 2;
 768             }
 769             return matched;
 770         },
 771
 772         alignedInside: function (outer, alignment) {
 773             var x0, y0;
 774             switch (alignment) {
 775             case "bottomleft":
 776                 x0 = outer.x0;
 777                 y0 = outer.y0;
 778                 break;
 779             case "bottom":
 780                 x0 = outer.x0 + (outer.w - this.w) / 2;
 781                 y0 = outer.y0;
 782                 break;
 783             case "bottomright":
 784                 x0 = outer.x0 - this.w;
 785                 y0 = outer.y0;
 786                 break;
 787             case "left":
 788                 x0 = outer.x0;
 789                 y0 = outer.x0 + (outer.h - this.h) / 2;
 790                 break;
 791             case "center":
 792                 x0 = outer.x0 + (outer.w - this.w) / 2;
 793                 y0 = outer.x0 + (outer.h - this.h) / 2;
 794                 break;
 795             case "right":
 796                 x0 = outer.x1 - this.w;
 797                 y0 = outer.x0 + (outer.h - this.h) / 2;
 798                 break;
 799             case "topleft":
 800                 x0 = outer.x0;
 801                 y0 = outer.y1 - this.h;
 802                 break;
 803             case "top":
 804                 x0 = outer.x0 + (outer.w - this.w) / 2;
 805                 y0 = outer.y1 - this.h;
 806                 break;
 807             case "topright":
 808                 x0 = outer.x1 - this.w;
 809                 y0 = outer.y1 - this.h;
 810                 break;
 811             }
 812             return new this.constructor(x0, y0, x0 + this.w, y0 + this.h);
 813         }
 814     });
 815
 816     function splitPathExtension (path) {
 817         var dot = path.lastIndexOf(".");
 818         if (dot <= 0) return [path, ""];
 819
 820         var dir = path.lastIndexOf("/");
 821         if (dot < dir) return [path, ""];
 822
 823         return [path.substring(0, dot), path.substring(dot)];
 824     }
 825     yuu.splitPathExtension = splitPathExtension;
 826
 827     if (stringLerp) {
 828         yT.defineProperty(String.prototype, "lerp", function (b, p) {
 829             b = b.toString();
 830             // Never numericLerp - if that's desired force Numbers.
 831             // Be more conservative than stringLerp since this runs
 832             // often and the diff can't be easily hoisted.
 833             return this.length * b.length > 256
 834                 ? stringLerp.fastLerp(this, b, p)
 835                 : stringLerp.diffLerp(this, b, p);
 836         });
 837     }
 838
 839     yT.defineProperties(Number.prototype, {
 840         lerp: function (b, p) { return this + (b - this) * p; }
 841     });
 842
 843     yT.defineProperties(Array.prototype, {
 844         lerp: function (b, p) {
 845             var length = Math.round(this.length.lerp(b.length, p));
 846             var c = new this.constructor(length);
 847             for (var i = 0; i < length; ++i) {
 848                 if (i >= this.length)
 849                     c[i] = b[i];
 850                 else if (i >= b.length)
 851                     c[i] = this[i];
 852                 else
 853                     c[i] = this[i].lerp(b[i], p);
 854             }
 855             return c;
 856         }
 857     });
 858
 859     /** Typed array extensions
 860
 861         https://www.khronos.org/registry/typedarray/specs/1.0/
 862         BUT: Read on for fun times in browser land~
 863
 864         Ideally we could just set these once on ArrayBufferView, but
 865         the typed array specification doesn't require that such a
 866         constructor actually exist. And in Firefox (18), it doesn't.
 867
 868         More infurating, in Safari (7.0.3) Int8Array etc. are not
 869         functions so this needs to be added to the prototype
 870         directly. This is a violation of the specification which
 871         requires such constructors, and ECMA which requires
 872         constructors be functions, and common decency.
 873     */
 874
 875     [ Float32Array, Float64Array, Int8Array, Uint8Array,
 876       Int16Array, Uint16Array, Int32Array, Uint32Array
 877     ].forEach(function (A) {
 878         yT.defineProperties(A.prototype, {
 879             slice: yf.argcd(
 880                 /** Like Array's slice, but for typed arrays */
 881                 function () { return new this.constructor(this); },
 882                 function (begin) {
 883                     return new this.constructor(this.subarray(begin));
 884                 },
 885                 function (begin, end) {
 886                     return new this.constructor(this.subarray(begin, end));
 887                 }
 888             ),
 889
 890             fill: Array.prototype.fill,
 891             reverse: Array.prototype.reverse,
 892
 893             lerp: function (b, p) {
 894                 if (p === 0)
 895                     return this.slice();
 896                 else if (p === 1)
 897                     return b.slice();
 898                 var c = new this.constructor(this.length);
 899                 for (var i = 0; i < this.length; ++i)
 900                     c[i] = this[i] + (b[i] - this[i]) * p;
 901                 return c;
 902             }
 903         });
 904     });
 905
 906 }).call(typeof exports === "undefined" ? this : exports,
 907         typeof exports === "undefined" ? (this.yuu = {}) : exports);