scramble-generator
Version:
Generate scrambles for Rubik's cubes
314 lines (275 loc) • 8.89 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["ScrambleGenerator"] = factory();
else
root["ScrambleGenerator"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/ });
/******/ }
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 1);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _defineProperty(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true });
} else {
obj[key] = value;
}return obj;
}
/**
* Axes for a cubic puzzle
*/
var Axes = exports.Axes = {
X: 'X',
Y: 'Y',
Z: 'Z'
};
/**
* Mapping from face to axis around which it turns
*/
var FaceAxisInfo = exports.FaceAxisInfo = {
R: Axes.X,
L: Axes.X,
U: Axes.Y,
D: Axes.Y,
F: Axes.Z,
B: Axes.Z
};
/**
* List of faces
*/
var FaceList = exports.FaceList = Object.keys(FaceAxisInfo);
/**
* Map of Faces.
* @example
* import { Faces } from 'scramble-generator';
* Faces.R; // 'R'
* Faces.U; // 'U'
*/
var Faces = exports.Faces = FaceList.reduce(function (map, face) {
return Object.assign(map, _defineProperty({}, face, face));
}, {});
/**
* Mapping of name constant to corresponding scramble modifier
*/
var Modifiers = exports.Modifiers = {
INVERTED: "'",
DOUBLE: '2',
WIDE: 'w'
};
/**
* Creates a move for a scramble.
* @returns An object representing a move for a scramble
*/
var createMove = exports.createMove = function createMove() {
var move = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var _move$face = move.face,
face = _move$face === undefined ? Faces.R : _move$face,
_move$inverted = move.inverted,
inverted = _move$inverted === undefined ? false : _move$inverted,
_move$double = move.double,
double = _move$double === undefined ? false : _move$double,
_move$layerCount = move.layerCount,
layerCount = _move$layerCount === undefined ? 1 : _move$layerCount;
return {
face: face,
inverted: !double && inverted,
double: double,
layerCount: layerCount
};
};
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.Faces = exports.formatScramble = undefined;
var _scrambleUtilsCommon = __webpack_require__(0);
Object.defineProperty(exports, 'Faces', {
enumerable: true,
get: function get() {
return _scrambleUtilsCommon.Faces;
}
});
var _helpers = __webpack_require__(2);
var _formatter = __webpack_require__(3);
var _formatter2 = _interopRequireDefault(_formatter);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
* Generates a random scramble for the given cube size.
* @example
* import generateScramble from 'scramble-generator';
* generateScramble();
* // R' U F D' L ...
*
* generateScramble({ cubeSize: 3, formatted: false });
* // [ { face: 'U', inverted: false, double: true },
* // { face: 'R', inverted: true, double: false },
* // { face: 'D', inverted: false, double: true }, ... ]
*/
var generateScramble = function generateScramble() {
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref$cubeSize = _ref.cubeSize,
cubeSize = _ref$cubeSize === undefined ? 3 : _ref$cubeSize,
_ref$length = _ref.length,
length = _ref$length === undefined ? (cubeSize - 2) * 20 || 8 : _ref$length,
_ref$formatted = _ref.formatted,
formatted = _ref$formatted === undefined ? true : _ref$formatted;
var scramble = [];
var maxLayers = Math.floor(cubeSize / 2);
var lastAxis = void 0;
for (var i = 0; i < length; i++) {
var faceSelections = _scrambleUtilsCommon.FaceList.filter(function (face) {
return _scrambleUtilsCommon.FaceAxisInfo[face] !== lastAxis;
});
var rand = (0, _helpers.randomInRange)(0, faceSelections.length);
var face = faceSelections[rand];
lastAxis = _scrambleUtilsCommon.FaceAxisInfo[face];
scramble.push((0, _scrambleUtilsCommon.createMove)({
face: face,
inverted: (0, _helpers.coinFlip)(),
double: (0, _helpers.coinFlip)(),
layerCount: (0, _helpers.randomInRange)(1, maxLayers + 1)
}));
}
return formatted ? (0, _formatter2.default)(scramble) : scramble;
};
exports.formatScramble = _formatter2.default;
exports.default = generateScramble;
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var randomInRange = exports.randomInRange = function randomInRange(min, max) {
return Math.floor(Math.random() * (max - min) + min);
};
var coinFlip = exports.coinFlip = function coinFlip() {
return !!randomInRange(0, 2);
};
/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _scrambleUtilsCommon = __webpack_require__(0);
/**
* Formats a given scramble as a string.
* @param [scramble] List of Move objects representing a scramble to be formatted.
* @returns String representation of the given scramble.
* @example
* import { formatScramble } from 'scramble-generator';
* import { Faces } from 'scramble-utils-common';
* format([{
* face: Faces.R,
* inverted: true
* }, {
* face: Faces.U,
* double: true
* }, {
* face: Faces.L
* }])
* // "R' U2 L"
*/
var formatScramble = function formatScramble(scramble) {
if (!Array.isArray(scramble)) return '';
return scramble.filter(function (move) {
return _scrambleUtilsCommon.Faces[move.face];
}).map(function (_ref) {
var double = _ref.double,
inverted = _ref.inverted,
layerCount = _ref.layerCount,
face = _ref.face;
var modifier = '';
if (layerCount > 1) {
modifier += _scrambleUtilsCommon.Modifiers.WIDE;
}
if (double) {
modifier += _scrambleUtilsCommon.Modifiers.DOUBLE;
} else if (inverted) {
modifier += _scrambleUtilsCommon.Modifiers.INVERTED;
}
return '' + (layerCount > 2 ? layerCount : '') + face + modifier;
}).join(' ');
};
exports.default = formatScramble;
/***/ })
/******/ ]);
});