warriorjs-engine/lib/units/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 _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }

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

var _Turn = require('../Turn');

var _Turn2 = _interopRequireDefault(_Turn);

var _Logger = require('../Logger');

var _Logger2 = _interopRequireDefault(_Logger);

var _constantsActions = require('../constants/Actions');

var _constantsActions2 = _interopRequireDefault(_constantsActions);

var _constantsSenses = require('../constants/Senses');

var _constantsSenses2 = _interopRequireDefault(_constantsSenses);

var _abilitiesAttack = require('../abilities/Attack');

var _abilitiesAttack2 = _interopRequireDefault(_abilitiesAttack);

var _abilitiesBind = require('../abilities/Bind');

var _abilitiesBind2 = _interopRequireDefault(_abilitiesBind);

var _abilitiesDetonate = require('../abilities/Detonate');

var _abilitiesDetonate2 = _interopRequireDefault(_abilitiesDetonate);

var _abilitiesDirectionOf = require('../abilities/DirectionOf');

var _abilitiesDirectionOf2 = _interopRequireDefault(_abilitiesDirectionOf);

var _abilitiesDirectionOfStairs = require('../abilities/DirectionOfStairs');

var _abilitiesDirectionOfStairs2 = _interopRequireDefault(_abilitiesDirectionOfStairs);

var _abilitiesDistanceOf = require('../abilities/DistanceOf');

var _abilitiesDistanceOf2 = _interopRequireDefault(_abilitiesDistanceOf);

var _abilitiesExplode = require('../abilities/Explode');

var _abilitiesExplode2 = _interopRequireDefault(_abilitiesExplode);

var _abilitiesFeel = require('../abilities/Feel');

var _abilitiesFeel2 = _interopRequireDefault(_abilitiesFeel);

var _abilitiesHealth = require('../abilities/Health');

var _abilitiesHealth2 = _interopRequireDefault(_abilitiesHealth);

var _abilitiesListen = require('../abilities/Listen');

var _abilitiesListen2 = _interopRequireDefault(_abilitiesListen);

var _abilitiesLook = require('../abilities/Look');

var _abilitiesLook2 = _interopRequireDefault(_abilitiesLook);

var _abilitiesPivot = require('../abilities/Pivot');

var _abilitiesPivot2 = _interopRequireDefault(_abilitiesPivot);

var _abilitiesRescue = require('../abilities/Rescue');

var _abilitiesRescue2 = _interopRequireDefault(_abilitiesRescue);

var _abilitiesRest = require('../abilities/Rest');

var _abilitiesRest2 = _interopRequireDefault(_abilitiesRest);

var _abilitiesShoot = require('../abilities/Shoot');

var _abilitiesShoot2 = _interopRequireDefault(_abilitiesShoot);

var _abilitiesWalk = require('../abilities/Walk');

var _abilitiesWalk2 = _interopRequireDefault(_abilitiesWalk);

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

    this._name = 'Base';
    this._type = null;
    this._position = null;
    this._attackPower = 0;
    this._shootPower = 0;
    this._maxHealth = 0;
    this._health = null;
    this._actions = {};
    this._senses = {};
    this._currentTurn = null;
  }

  _createClass(Base, [{
    key: 'getName',
    value: function getName() {
      return this._name;
    }
  }, {
    key: 'getType',
    value: function getType() {
      return this._type;
    }
  }, {
    key: 'getPosition',
    value: function getPosition() {
      return this._position;
    }
  }, {
    key: 'setPosition',
    value: function setPosition(position) {
      this._position = position;
    }
  }, {
    key: 'getAttackPower',
    value: function getAttackPower() {
      return this._attackPower;
    }
  }, {
    key: 'getShootPower',
    value: function getShootPower() {
      return this._shootPower;
    }
  }, {
    key: 'getMaxHealth',
    value: function getMaxHealth() {
      return this._maxHealth;
    }
  }, {
    key: 'getHealth',
    value: function getHealth() {
      this._health = this._health !== null ? this._health : this.getMaxHealth();
      return this._health;
    }
  }, {
    key: 'setHealth',
    value: function setHealth(health) {
      this._health = health;
    }
  }, {
    key: 'getActions',
    value: function getActions() {
      return this._actions;
    }
  }, {
    key: 'getSenses',
    value: function getSenses() {
      return this._senses;
    }
  }, {
    key: 'getAbilities',
    value: function getAbilities() {
      return Object.assign({}, this.getActions(), this.getSenses());
    }
  }, {
    key: 'isAlive',
    value: function isAlive() {
      return this.getPosition() !== null;
    }
  }, {
    key: 'isBound',
    value: function isBound() {
      return this._bound;
    }
  }, {
    key: 'unbind',
    value: function unbind() {
      this._bound = false;
      this.say('released from bonds');
    }
  }, {
    key: 'bind',
    value: function bind() {
      this._bound = true;
    }
  }, {
    key: 'say',
    value: function say(message) {
      _Logger2['default'].log(this.getType(), this.getName() + ' ' + message);
    }
  }, {
    key: 'takeDamage',
    value: function takeDamage(amount) {
      if (this.isBound()) {
        this.unbind();
      }

      if (this.getHealth()) {
        var revisedAmount = this.getHealth() - amount < 0 ? this.getHealth() : amount;
        this._health -= revisedAmount;
        this.say('takes ' + amount + ' damage, ' + this.getHealth() + ' health power left');
        if (!this.getHealth()) {
          this.setPosition(null);
          this.say('dies');
        }
      }
    }
  }, {
    key: 'addActions',
    value: function addActions(newActions) {
      var _this = this;

      newActions.forEach(function (actionName) {
        var action = undefined;
        if (actionName === _constantsActions2['default'].attack) {
          action = new _abilitiesAttack2['default'](_this);
        } else if (actionName === _constantsActions2['default'].bind) {
          action = new _abilitiesBind2['default'](_this);
        } else if (actionName === _constantsActions2['default'].detonate) {
          action = new _abilitiesDetonate2['default'](_this);
        } else if (actionName === _constantsActions2['default'].explode) {
          action = new _abilitiesExplode2['default'](_this);
        } else if (actionName === _constantsActions2['default'].pivot) {
          action = new _abilitiesPivot2['default'](_this);
        } else if (actionName === _constantsActions2['default'].rescue) {
          action = new _abilitiesRescue2['default'](_this);
        } else if (actionName === _constantsActions2['default'].rest) {
          action = new _abilitiesRest2['default'](_this);
        } else if (actionName === _constantsActions2['default'].shoot) {
          action = new _abilitiesShoot2['default'](_this);
        } else if (actionName === _constantsActions2['default'].walk) {
          action = new _abilitiesWalk2['default'](_this);
        } else {
          throw new Error('Unknown action \'' + action + '\'.');
        }

        _this._actions[actionName] = action;
      });
    }
  }, {
    key: 'addSenses',
    value: function addSenses(newSenses) {
      var _this2 = this;

      newSenses.forEach(function (senseName) {
        var sense = undefined;
        if (senseName === _constantsSenses2['default'].directionOf) {
          sense = new _abilitiesDirectionOf2['default'](_this2);
        } else if (senseName === _constantsSenses2['default'].directionOfStairs) {
          sense = new _abilitiesDirectionOfStairs2['default'](_this2);
        } else if (senseName === _constantsSenses2['default'].distanceOf) {
          sense = new _abilitiesDistanceOf2['default'](_this2);
        } else if (senseName === _constantsSenses2['default'].feel) {
          sense = new _abilitiesFeel2['default'](_this2);
        } else if (senseName === _constantsSenses2['default'].health) {
          sense = new _abilitiesHealth2['default'](_this2);
        } else if (senseName === _constantsSenses2['default'].listen) {
          sense = new _abilitiesListen2['default'](_this2);
        } else if (senseName === _constantsSenses2['default'].look) {
          sense = new _abilitiesLook2['default'](_this2);
        } else {
          throw new Error('Unknown sense \'' + sense + '\'.');
        }

        _this2._senses[senseName] = sense;
      });
    }
  }, {
    key: 'getNextTurn',
    value: function getNextTurn() {
      return new _Turn2['default'](this.getActions(), this.getSenses());
    }
  }, {
    key: 'playTurn',
    value: function playTurn(turn) {// eslint-disable-line no-unused-vars
      // To be overriden by subclass
    }
  }, {
    key: 'prepareTurn',
    value: function prepareTurn() {
      this._currentTurn = this.getNextTurn();
      this.playTurn(this._currentTurn);
    }
  }, {
    key: 'performTurn',
    value: function performTurn() {
      if (this.getPosition()) {
        Object.values(this.getAbilities()).forEach(function (ability) {
          return ability.passTurn();
        });
        if (this._currentTurn.getAction() && !this.isBound()) {
          var _getActions$_name;

          var _currentTurn$getAction = this._currentTurn.getAction();

          var _currentTurn$getAction2 = _slicedToArray(_currentTurn$getAction, 2);

          var _name = _currentTurn$getAction2[0];
          var args = _currentTurn$getAction2[1];

          (_getActions$_name = this.getActions()[_name]).perform.apply(_getActions$_name, _toConsumableArray(args));
        }
      }
    }
  }, {
    key: 'earnPoints',
    value: function earnPoints(points) {// eslint-disable-line no-unused-vars
      // To be overriden by subclass
    }
  }, {
    key: 'toViewObject',
    value: function toViewObject() {
      return {
        name: this.getName(),
        type: this.getType(),
        position: this.getPosition().toViewObject()
      };
    }
  }, {
    key: 'toString',
    value: function toString() {
      return this.getName();
    }
  }]);

  return Base;
})();

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