Loads a unit.

@param {Object} unitConfig The config of the unit.
@param {Floor} floor The floor of the level.
433872
function loadUnit(
  {
    name,
    character,
    color,
    maxHealth,
    reward,
    enemy,
    bound,
    abilities,
    effects,
    playTurn,
    position,
  },
  floor,
) {
  const unit = new Unit(
    name,
    character,
    color,
    maxHealth,
    reward,
    enemy,
    bound,
  );
  loadAbilities(unit, abilities);
  loadEffects(unit, effects);
  unit.playTurn = playTurn;
  floor.addUnit(unit, position);
}
517826
async function loadSources (sources, options) {
  const mergedConfig = {};

  function handleSourceLoad (sourceConfig) {
    if (sourceConfig) merge(sourceConfig, mergedConfig);
  }

  for (const source of sources) {
    let sourceConfig;

    if (source == null) {
            // No-op... skip this source
      continue;
    } else if (typeof source === 'string') {
            // Load a source from a JSON file
      sourceConfig = await loadFileSource(source, options);
    } else if (Array.isArray(source)) {
      sourceConfig = await loadSources(source, options); // Load and merge all of the sources
    } else if (typeof source === 'function') {
      sourceConfig = await source(); // Invoke the function to asynchronously load the config object for this source
    } else if (typeof source === 'object') {
      sourceConfig = source; // Just merge the object
    } else {
      throw new Error('Invalid configuration source: ' + source);
    }

    handleSourceLoad(sourceConfig);
  }

  return mergedConfig;
}
250479
function floorSelf() {
         return this._set(Math.floor(this.x), Math.floor(this.y), Math.floor(this.z));
       }
1363882
function loadConfigAndGenerateSite(useServer, port) {
  var config = loadConfig();
  if (port) config.port = port;
  generateSite(config, useServer);
}
47699
function(name, config) {
            config = config || {};
            config = _.defaults(config, {
                loader: configs.resources.loader
            });
            config = _.extend(config, {
                namespace: name
            });
            Resources.namespaces[name] = config;
        }
605603
function loadFromConfig(router, providers, sessionStore) {
  const sitesMap = siteService.sites(),
    siteHosts = _.uniq(_.map(sitesMap, 'host'));

  // iterate through the hosts
  _.each(siteHosts, hostname => {
    const sites = _.filter(sitesMap, {host: hostname}).sort(sortByDepthOfPath);

    addHost({
      router,
      hostname,
      sites,
      providers,
      sessionStore
    });
  });

  return router;
}
635210
function loadConfigPolicy(config_items, versions, config_policy, group_name, org) {
	logger.debug('loadConfigPolicy - %s - policy name: %s', group_name, config_policy.key);
	logger.debug('loadConfigPolicy - %s - version: %s', group_name, config_policy.value.version);
	logger.debug('loadConfigPolicy - %s - mod_policy: %s', group_name, config_policy.value.mod_policy);

	versions.version = config_policy.value.version;
	loadPolicy(config_items, versions, config_policy.key, config_policy.value.policy, group_name, org);
}
1003850
function(config) {

        this.config = config;
        this.appContext = null;

        this.injectAppContext = this.config.injectAppContext === true ? true : false;

        //cache of loaded dependencies
        this.moduleMap = {};
    }
919692
protected void load(URL url) {
		try {
			config = configBuilder.properties(url);
		} catch (ConfigurationException e) {
			JK.throww(e);
		}
	}
718334
function(level, callback) {
                _getFloors(config, level, floor, function(error, floors, options) {
                    return callback(error, floors, options);
                })
            }
1200294
function (config) {

            this._config = config;
            this._pageProvider = config.pageProvider;
            ariaEmbedPlaceholderManager.register(this);
            this._pageProvider.$addListeners({
                "pageDefinitionChange" : this._onPageDefinitionChangeListener
            });

            this._pageProvider.loadSiteConfig({
                onsuccess : {
                    fn : this._loadRootModule,
                    scope : this
                },
                onfailure : this._getErrorCallbackConfig([this.SITE_CONFIG_NOT_AVAILABLE])
            });

        }
890599
function(config, level, floor, callback) {
    var floors = [];
    var fromIdentifier = level ? level.identifier : null;    
    var options = FloorSelectionOptions.createFromIdentifiers(fromIdentifier, floor);
             
    try{
        floors = FloorController.getFloors(config.floorsDir, options);
        return callback(null, floors, options); 
    } catch(error) {
        return callback(error);
    }
}
246998
function loadAbilities(unit, abilities = {}) {
  Object.entries(abilities).forEach(([abilityName, abilityCreator]) => {
    const ability = abilityCreator(unit);
    unit.addAbility(abilityName, ability);
  });
}
1083278
function(app) {
  app.loadConfigBaseApp(Constants.RESERVED.MASTER, path.join(app.get(Constants.RESERVED.SERVICE_PATH), Constants.FILEPATH.MASTER));
  app.master = app.get(Constants.RESERVED.MASTER);
}
1347235
function(config) {

		this.property_name = config.property;
		this.from = config.from || 0;
		this.delta = config.delta;
		this.unit = config.unit || 'px';

	}
1092930
private final static void loadConfig() {
		try {
			conf = Configurations.loadConfig(configFilePath);
		} catch (ConfigurationException e) {
			terminate();
			throw new InitializationException(INIT_FAILED, e);
		}
	}
1316145
function init(config){
    var logger = new LogglyLogger(config);
    logger.validateConfig();

    logger.config = config;
    logger.client = loggly.createClient({
        token: config.token,
        subdomain: config.application,
        auth: config.auth,

        // TOOD: pushing more tags onto this array, or not using them, should be configurable
        tags: [
            config.domain,
            config.machine
        ]

        // Loggly docs say it uses json stringify if json:true
        // JSON stringify does not handle Errors or circulare references well
        // Logger.createEntry handles them well
    });
    return logger;
}