warriorjs-engine/lib/LevelLoader.js

The bowels of WarriorJS

'use strict';

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

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 _Attack = require('./abilities/actions/Attack');

var _Attack2 = _interopRequireDefault(_Attack);

var _Bind = require('./abilities/actions/Bind');

var _Bind2 = _interopRequireDefault(_Bind);

var _Detonate = require('./abilities/actions/Detonate');

var _Detonate2 = _interopRequireDefault(_Detonate);

var _Explode = require('./abilities/actions/Explode');

var _Explode2 = _interopRequireDefault(_Explode);

var _Pivot = require('./abilities/actions/Pivot');

var _Pivot2 = _interopRequireDefault(_Pivot);

var _Rescue = require('./abilities/actions/Rescue');

var _Rescue2 = _interopRequireDefault(_Rescue);

var _Rest = require('./abilities/actions/Rest');

var _Rest2 = _interopRequireDefault(_Rest);

var _Shoot = require('./abilities/actions/Shoot');

var _Shoot2 = _interopRequireDefault(_Shoot);

var _Walk = require('./abilities/actions/Walk');

var _Walk2 = _interopRequireDefault(_Walk);

var _DirectionOf = require('./abilities/senses/DirectionOf');

var _DirectionOf2 = _interopRequireDefault(_DirectionOf);

var _DirectionOfStairs = require('./abilities/senses/DirectionOfStairs');

var _DirectionOfStairs2 = _interopRequireDefault(_DirectionOfStairs);

var _DistanceOf = require('./abilities/senses/DistanceOf');

var _DistanceOf2 = _interopRequireDefault(_DistanceOf);

var _Feel = require('./abilities/senses/Feel');

var _Feel2 = _interopRequireDefault(_Feel);

var _Health = require('./abilities/senses/Health');

var _Health2 = _interopRequireDefault(_Health);

var _Listen = require('./abilities/senses/Listen');

var _Listen2 = _interopRequireDefault(_Listen);

var _Look = require('./abilities/senses/Look');

var _Look2 = _interopRequireDefault(_Look);

var _Archer = require('./units/Archer');

var _Archer2 = _interopRequireDefault(_Archer);

var _Captive = require('./units/Captive');

var _Captive2 = _interopRequireDefault(_Captive);

var _Sludge = require('./units/Sludge');

var _Sludge2 = _interopRequireDefault(_Sludge);

var _ThickSludge = require('./units/ThickSludge');

var _ThickSludge2 = _interopRequireDefault(_ThickSludge);

var _Warrior = require('./units/Warrior');

var _Warrior2 = _interopRequireDefault(_Warrior);

var _Wizard = require('./units/Wizard');

var _Wizard2 = _interopRequireDefault(_Wizard);

var _Floor = require('./Floor');

var _Floor2 = _interopRequireDefault(_Floor);

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 UNITS = {
  archer: _Archer2.default,
  captive: _Captive2.default,
  sludge: _Sludge2.default,
  thickSludge: _ThickSludge2.default,
  warrior: _Warrior2.default,
  wizard: _Wizard2.default
};

var ABILITIES = {
  attack: _Attack2.default,
  bind: _Bind2.default,
  detonate: _Detonate2.default,
  directionOf: _DirectionOf2.default,
  directionOfStairs: _DirectionOfStairs2.default,
  distanceOf: _DistanceOf2.default,
  explode: _Explode2.default,
  feel: _Feel2.default,
  health: _Health2.default,
  listen: _Listen2.default,
  look: _Look2.default,
  pivot: _Pivot2.default,
  rescue: _Rescue2.default,
  rest: _Rest2.default,
  shoot: _Shoot2.default,
  walk: _Walk2.default
};

var LevelLoader = function () {
  function LevelLoader(level) {
    _classCallCheck(this, LevelLoader);

    this._level = level;
  }

  _createClass(LevelLoader, [{
    key: 'load',
    value: function load(levelConfig) {
      var _this = this;

      this._level.timeBonus = levelConfig.timeBonus;

      var _levelConfig$floor = levelConfig.floor;
      var size = _levelConfig$floor.size;
      var stairs = _levelConfig$floor.stairs;
      var warrior = _levelConfig$floor.warrior;
      var units = _levelConfig$floor.units;


      this._setFloor(size, stairs);

      var name = warrior.name;
      var x = warrior.x;
      var y = warrior.y;
      var facing = warrior.facing;
      var abilities = warrior.abilities;

      this._placeWarrior(name, x, y, facing, abilities);

      units.forEach(function (unit) {
        return _this._placeUnit(unit.type, unit.x, unit.y, unit.facing, unit.abilities);
      });
    }
  }, {
    key: '_setFloor',
    value: function _setFloor(size, stairs) {
      var width = size.width;
      var height = size.height;

      this._level.floor = new _Floor2.default(width, height);

      var x = stairs.x;
      var y = stairs.y;

      this._level.floor.placeStairs(x, y);
    }
  }, {
    key: '_placeWarrior',
    value: function _placeWarrior(name, x, y, facing, abilities) {
      var warrior = this._placeUnit('warrior', x, y, facing, abilities);
      warrior.name = name;
      this._level.warrior = warrior;
    }
  }, {
    key: '_placeUnit',
    value: function _placeUnit(type, x, y, facing) {
      var abilities = arguments.length <= 4 || arguments[4] === undefined ? [] : arguments[4];

      if (!(type in UNITS)) {
        throw new Error('Unknown unit \'' + type + '\'.');
      }

      var unit = new UNITS[type]();

      abilities.forEach(function (_ref) {
        var name = _ref.name;
        var args = _ref.args;

        if (!(name in ABILITIES)) {
          throw new Error('Unknown ability \'' + name + '\'.');
        }

        unit.abilities[name] = new (Function.prototype.bind.apply(ABILITIES[name], [null].concat([unit], _toConsumableArray(args))))();
      });

      this._level.floor.addUnit(unit, x, y, facing);

      return unit;
    }
  }]);

  return LevelLoader;
}();

exports.default = LevelLoader;