Source: manufacturer.js

  1. const Puzzle = require('./puzzle');
  2. const Piece = require('./piece');
  3. const {Anchor} = require('./anchor');
  4. const {anchor} = require('./anchor');
  5. const {fixed, InsertSequence} = require('./sequence')
  6. const Metadata = require('./metadata');
  8. /**
  9.  * A manufacturer allows to create rectangular
  10.  * puzzles by automatically generating inserts
  11.  */
  12. class Manufacturer {
  13.   constructor() {
  14.     this.insertsGenerator = fixed;
  15.     this.metadata = [];
  16.     /** @type {Anchor} */
  17.     this.headAnchor = null;
  18.   }
  20.   /**
  21.    * Attach metadata to each piece
  22.    *
  23.    * @param {object[]} metadata list of metadata that will be attached to each generated piece
  24.    */
  25.   withMetadata(metadata) {
  26.     this.metadata = metadata;
  27.   }
  29.   /**
  30.    * @param {import('./sequence').InsertsGenerator} generator
  31.    */
  32.   withInsertsGenerator(generator) {
  33.     this.insertsGenerator = generator || this.insertsGenerator;
  34.   }
  36.   /**
  37.    * Sets the central anchor. If not specified, puzzle will be positioned
  38.    * at the distance of a whole piece from the origin
  39.    *
  40.    * @param {Anchor} anchor
  41.    */
  42.   withHeadAt(anchor) {
  43.     this.headAnchor = anchor;
  44.   }
  46.   /**
  47.    * If nothing is configured, default Puzzle structured is assumed
  48.    *
  49.    * @param {import('../src/puzzle').Settings} structure
  50.    */
  51.   withStructure(structure) {
  52.     this.structure = structure
  53.   }
  55.   /**
  56.    *
  57.    * @param {number} width
  58.    * @param {number} height
  59.    */
  60.   withDimensions(width, height) {
  61.     this.width = width;
  62.     this.height = height;
  63.   }
  65.    /**
  66.    * @returns {Puzzle}
  67.    */
  68.   build() {
  69.     const puzzle = new Puzzle(this.structure);
  70.     const positioner = new Positioner(puzzle, this.headAnchor);
  72.     let verticalSequence = this._newSequence();
  73.     let horizontalSequence;
  75.     for (let y = 0; y < this.height; y++) {
  76.       horizontalSequence = this._newSequence();
  77.       verticalSequence.next();
  79.       for (let x = 0; x < this.width; x++) {
  80.         horizontalSequence.next();
  81.         const piece = this._buildPiece(puzzle, horizontalSequence, verticalSequence);
  82.         piece.centerAround(positioner.naturalAnchor(x, y));
  83.       }
  84.     }
  85.     this._annotateAll(puzzle.pieces);
  86.     return puzzle;
  87.   }
  89.   /**
  90.    * @param {Piece[]} pieces
  91.    */
  92.   _annotateAll(pieces) {
  93.     pieces.forEach((piece, index) => this._annotate(piece, index));
  94.   }
  96.   /**
  97.    * @param {Piece} piece
  98.    * @param {number} index
  99.    */
  100.   _annotate(piece, index) {
  101.     const baseMetadata = this.metadata[index];
  102.     const metadata = baseMetadata ? Metadata.copy(baseMetadata) : {};
  103.     metadata.id = metadata.id || String(index + 1);
  104.     piece.annotate(metadata);
  105.   }
  107.   _newSequence() {
  108.     return new InsertSequence(this.insertsGenerator);
  109.   }
  111.   /**
  112.    * @param {Puzzle} puzzle
  113.    * @param {InsertSequence} horizontalSequence
  114.    * @param {InsertSequence} verticalSequence
  115.    */
  116.   _buildPiece(puzzle, horizontalSequence, verticalSequence) {
  117.     return puzzle.newPiece({
  118.       left: horizontalSequence.previousComplement(),
  119.       up: verticalSequence.previousComplement(),
  120.       right: horizontalSequence.current(this.width),
  121.       down: verticalSequence.current(this.height)
  122.     });
  123.   }
  124. }
  126. class Positioner {
  127.   /**
  128.    *
  129.    * @param {Puzzle} puzzle
  130.    * @param {Anchor} headAnchor
  131.    */
  132.   constructor(puzzle, headAnchor) {
  133.     this.puzzle = puzzle;
  134.     this.initializeOffset(headAnchor);
  135.   }
  137.   /**
  138.    * @param {Anchor} headAnchor
  139.    */
  140.   initializeOffset(headAnchor) {
  141.     if (headAnchor) {
  142.       /** @type {import('./vector').Vector} */
  143.       this.offset = headAnchor.asVector();
  144.     }
  145.     else {
  146.       this.offset = this.pieceDiameter;
  147.     }
  148.   }
  150.   get pieceDiameter() {
  151.     return this.puzzle.pieceDiameter;
  152.   }
  154.     /**
  155.    * @param {number} x
  156.    * @param {number} y
  157.    */
  158.   naturalAnchor(x, y) {
  159.     return anchor(
  160.       x * this.pieceDiameter.x + this.offset.x,
  161.       y * this.pieceDiameter.y + this.offset.y);
  162.   }
  163. }
  165. module.exports = Manufacturer;