2d-dungeon/dist/pieces/piece.js

prodecural dungeon generator for games

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _array2d = require("../utils/array2d");

var _array2d2 = _interopRequireDefault(_array2d);

var _rectangle = require("../utils/rectangle");

var _rectangle2 = _interopRequireDefault(_rectangle);

var _utils = require("../utils");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var next_piece_id = 0;

// base dungeon piece class, to be extended

var Piece = function () {
  function Piece(options) {
    _classCallCheck(this, Piece);

    options = Object.assign({
      size: [1, 1],
      position: [0, 0],
      parent: null,
      max_exits: 10,
      tag: ""
    }, options);

    Object.assign(this, options);

    this.options = options;

    this.id = next_piece_id++;
    this.walls = new _array2d2.default(this.size, true);
    this.perimeter = [];
    this.exits = [];
    this.children = [];
  }

  _createClass(Piece, [{
    key: "is_exit",
    value: function is_exit(_ref) {
      var _ref2 = _slicedToArray(_ref, 2),
          x = _ref2[0],
          y = _ref2[1];

      return this.exits.filter(function (_ref3) {
        var _ref4 = _toArray(_ref3),
            exit_x = _ref4[0],
            exit_y = _ref4[1],
            rest = _ref4.slice(2);

        return exit_x === x && exit_y === y;
      }).length !== 0;
    }
  }, {
    key: "get_non_wall_tiles",
    value: function get_non_wall_tiles() {
      var retv = [];
      this.walls.iter(function (pos, is_wall) {
        if (!is_wall) {
          retv.push(pos);
        }
      });
      return retv;
    }
  }, {
    key: "get_perimeter_by_facing",
    value: function get_perimeter_by_facing(facing) {
      return this.perimeter.filter(function (_ref5) {
        var _ref6 = _slicedToArray(_ref5, 2),
            _ref6$ = _slicedToArray(_ref6[0], 2),
            x = _ref6$[0],
            y = _ref6$[1],
            f = _ref6[1];

        return facing === f;
      });
    }
  }, {
    key: "get_inner_perimeter",
    value: function get_inner_perimeter() {
      var _this = this;

      // returns array of tiles in the piece that are adjacent to a wall,
      // but not an exit;

      var retv = [];
      var haswall = void 0;
      var exit_adjacent = void 0;

      this.walls.iter(function (pos, is_wall) {
        if (!is_wall && !_this.is_exit(pos)) {
          haswall = false;
          exit_adjacent = false;
          (0, _utils.iter_adjacent)(pos, function (p) {
            haswall = haswall || _this.walls.get(p);
            exit_adjacent = exit_adjacent || _this.is_exit(p);
          });
          if (haswall && !exit_adjacent) {
            retv.push(pos);
          }
        }
      });

      return retv;
    }

    // local position to parent position

  }, {
    key: "parent_pos",
    value: function parent_pos(_ref7) {
      var _ref8 = _slicedToArray(_ref7, 2),
          x = _ref8[0],
          y = _ref8[1];

      return [this.position[0] + x, this.position[1] + y];
    }

    // local position to global position

  }, {
    key: "global_pos",
    value: function global_pos(pos) {
      pos = this.parent_pos(pos);
      if (this.parent) {
        pos = this.parent.global_pos(pos);
      }
      return pos;
    }

    // parent position to local position

  }, {
    key: "local_pos",
    value: function local_pos(pos) {
      return [pos[0] - this.position[0], pos[1] - this.position[1]];
    }

    // get (roughly) center tile position for the piece
    // @TODO consider if should use Math.floor instead of Math.round

  }, {
    key: "get_center_pos",
    value: function get_center_pos() {
      return [Math.floor(this.size[0] / 2), Math.floor(this.size[1] / 2)];
    }
  }, {
    key: "add_perimeter",
    value: function add_perimeter(p_from, p_to, facing) {
      var _this2 = this;

      (0, _utils.iter_range)(p_from, p_to, function (pos) {
        _this2.perimeter.push([pos, facing]);
      });
    }
  }, {
    key: "remove_perimeter",
    value: function remove_perimeter(rect) {
      this.perimeter = this.perimeter.filter(function (_ref9) {
        var _ref10 = _slicedToArray(_ref9, 3),
            x = _ref10[0],
            y = _ref10[1],
            facing = _ref10[2];

        return !rect.contains(x, y, 1, 1);
      });
    }
  }, {
    key: "intersects",
    value: function intersects(piece) {
      return (0, _utils.intersects)(this.position, this.size, piece.position, piece.size);
    }
  }, {
    key: "add_piece",
    value: function add_piece(piece) {
      var position = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

      if ((0, _utils.array_test)(this.children, function (c) {
        return c.id === piece.id;
      })) {
        return;
      }
      piece.parent = this;
      if (position) {
        piece.position = position;
      }
      this.children.push(piece);
      this.paste_in(piece);
    }
  }, {
    key: "paste_in",
    value: function paste_in(piece) {
      var _this3 = this;

      (0, _utils.iter_2d)(piece.size, function (pos) {
        var is_wall = piece.walls.get(pos);
        if (!is_wall) {
          _this3.walls.set(piece.parent_pos(pos), false);
        }
      });
    }
  }, {
    key: "add_exit",
    value: function add_exit(exit, room) {
      this.walls.set(exit[0], false);
      if (this.parent) {
        this.parent.paste_in(this);
      }
      this.exits.push([exit[0], exit[1], room]);
    }
  }, {
    key: "print",
    value: function print() {
      for (var y = 0; y < this.size[1]; y++) {
        var row = "";
        for (var x = 0; x < this.size[0]; x++) {
          if (this.start_pos && this.start_pos[0] === x && this.start_pos[1] === y) {
            row += "s";
          } else {
            row += this.walls.get([x, y]) ? "x" : " ";
          }
        }
        console.log(row);
      }
    }
  }, {
    key: "rect",
    get: function get() {
      return new _rectangle2.default(this.position[0], this.position[1], this.size[0], this.size[1]);
    }
  }]);

  return Piece;
}();

exports.default = Piece;