warriorjs-engine/lib/abilities/Base.js

The bowels of WarriorJS

'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; }; })();

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

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

var _constantsRelativeDirections = require('../constants/RelativeDirections');

var _constantsRelativeDirections2 = _interopRequireDefault(_constantsRelativeDirections);

var Base = (function () {
  function Base(unit) {
    _classCallCheck(this, Base);

    this._unit = unit;
  }

  _createClass(Base, [{
    key: 'getDescription',
    value: function getDescription() {
      return this._description;
    }
  }, {
    key: 'offset',
    value: function offset(direction) {
      var forward = arguments.length <= 1 || arguments[1] === undefined ? 1 : arguments[1];
      var right = arguments.length <= 2 || arguments[2] === undefined ? 0 : arguments[2];

      switch (direction) {
        case _constantsRelativeDirections2['default'].forward:
          return [forward, -right];
        case _constantsRelativeDirections2['default'].backward:
          return [-forward, right];
        case _constantsRelativeDirections2['default'].right:
          return [right, forward];
        case _constantsRelativeDirections2['default'].left:
          return [-right, -forward];
        default:
          throw new Error('Unknown direction \'' + direction + '\'');
      }
    }
  }, {
    key: 'getSpace',
    value: function getSpace(direction) {
      var forward = arguments.length <= 1 || arguments[1] === undefined ? 1 : arguments[1];
      var right = arguments.length <= 2 || arguments[2] === undefined ? 0 : arguments[2];

      var _offset = this.offset(direction, forward, right);

      var _offset2 = _slicedToArray(_offset, 2);

      var forwardOffset = _offset2[0];
      var rightOffset = _offset2[1];

      return this._unit.getPosition().getRelativeSpace(forwardOffset, rightOffset);
    }
  }, {
    key: 'getUnit',
    value: function getUnit(direction) {
      var forward = arguments.length <= 1 || arguments[1] === undefined ? 1 : arguments[1];
      var right = arguments.length <= 2 || arguments[2] === undefined ? 0 : arguments[2];

      return this.getSpace(direction, forward, right).getUnit();
    }
  }, {
    key: 'damage',
    value: function damage(receiver, amount) {
      receiver.takeDamage(amount);
      if (!receiver.isAlive()) {
        this._unit.earnPoints(receiver.getMaxHealth());
      }
    }
  }, {
    key: 'passTurn',
    value: function passTurn() {
      // Callback which is triggered every turn
    }
  }, {
    key: 'verifyDirection',
    value: function verifyDirection(direction) {
      var directions = Object.values(_constantsRelativeDirections2['default']);
      if (!directions.includes(direction)) {
        throw new Error('Unknown direction \'' + direction + '\'. Should be one of: ' + directions.join(', ') + '.');
      }
    }
  }]);

  return Base;
})();

exports['default'] = Base;
module.exports = exports['default'];