ranvier

#!/usr/bin/env node
'use strict';

/**
 * Main file, use this to run the server:
 * node ranvier [options]
 *
 * Options:
 *   -v Verbose loggin
 *   --port Port to listen on
 *   --locale Locale to act as the default
 *   --save Minutes between autosave
 *   --respawn Minutes between respawn
 */


/* NPM Modules */
const semver = require('semver');
const net = require('net');
const commander = require('commander');
const wrap = require('wrap-ansi');
const argv = require('optimist').argv;

// Package.json for versioning
const pkg = require('./package.json');

if (!semver.satisfies(process.version, pkg.engines.node)) {
  throw new Error(
    `Ranvier's core engine requires Node version ${pkg.engines.node},
    you are currently running Node ${process.version}.`
  );
}

// State managers and factories
const AccountManager = require('./src/AccountManager');
const AreaManager = require('./src/AreaManager');
const BehaviorManager = require('./src/BehaviorManager');
const ChannelManager = require('./src/ChannelManager');
const ClassManager = require('./src/ClassManager');
const CommandManager = require('./src/CommandManager');
const EffectFactory = require('./src/EffectFactory');
const EventManager = require('./src/EventManager');
const GameServer = require('./src/GameServer');
const HelpManager = require('./src/HelpManager');
const ItemFactory = require('./src/ItemFactory');
const ItemManager = require('./src/ItemManager');
const MobFactory = require('./src/MobFactory');
const MobManager = require('./src/MobManager');
const PartyManager = require('./src/PartyManager');
const PlayerManager = require('./src/PlayerManager');
const QuestFactory = require('./src/QuestFactory');
const QuestGoalManager = require('./src/QuestGoalManager');
const QuestRewardManager = require('./src/QuestRewardManager');
const RoomManager = require('./src/RoomManager');
const SkillManager = require('./src/SkillManager');

// Wrapper for ranvier.json
const Config = require('./src/Config');

// cmdline options
commander
  .version(pkg.version)
  .option('-s, --save [time]', 'Number of seconds between auto-save ticks [10]', 10)
  .option('-r, --respawn [time]', 'Number of minutes between respawn ticks [120]', 120)
  .option('-p, --port [portNumber]', 'Port to host the server [23]', Config.get('port', 23))
  .option('-v, --verbose', 'Verbose console logging.', true)
  .option('-e, --prettyErrors', 'Pretty-print formatting for error stack traces.', false)
  .parse(process.argv);

// Set debug variable and encoding.
// 'net' by default to help find possible server errors.
process.env.NODE_DEBUG = 'net';
process.stdin.setEncoding('utf8');

const Logger = require('./src/Logger');
const logfile = Config.get('logfile');
if (logfile) {
  Logger.setFileLogging(logfile);
}

if (commander.prettyErrors) {
  Logger.enablePrettyErrors();
}

// Set logging level based on CLI option or environment variable.
const logLevel = commander.verbose ?
  'verbose' :
  process.env.LOG_LEVEL || Config.get('logLevel') || 'debug';
Logger.setLevel(logLevel);


// Global state object, server instance and configurable intervals.
let GameState = {};
let saveInterval, tickInterval, playerTickInterval;

/**
 * Do the dirty work
 */
function init(restartServer) {
  Logger.log("START - Loading entities");
  restartServer = typeof restartServer === 'undefined' ? true : restartServer;

  GameState = {
    AccountManager: new AccountManager(),
    AreaManager: new AreaManager(),
    ChannelManager: new ChannelManager(),
    ClassManager: new ClassManager(), // player class manager
    CommandManager: new CommandManager(),
    Config, // All global server settings like default respawn time, save interval, port, what bundles to load, etc.
    EffectFactory: new EffectFactory(),
    HelpManager: new HelpManager(),
    InputEventManager: new EventManager(),
    ItemBehaviorManager: new BehaviorManager(),
    ItemFactory: new ItemFactory(),
    ItemManager: new ItemManager(),
    MobBehaviorManager: new BehaviorManager(),
    MobFactory: new MobFactory(),
    MobManager: new MobManager(),
    PartyManager: new PartyManager(),
    PlayerManager: new PlayerManager(),
    QuestFactory: new QuestFactory(),
    QuestGoalManager: new QuestGoalManager(),
    QuestRewardManager: new QuestRewardManager(),
    RoomBehaviorManager: new BehaviorManager(),
    RoomManager: new RoomManager(),
    SkillManager: new SkillManager(),
    SpellManager: new SkillManager(),
    ServerEventManager: new EventManager(),
    GameServer: new GameServer(),
  };

  // Setup bundlemanager
  const BundleManager = new (require('./src/BundleManager'))(GameState);
  GameState.BundleManager = BundleManager;
  BundleManager.loadBundles();
  GameState.ServerEventManager.attach(GameState.GameServer);

  // Set up web API
  // TODO: move into a server-events bundle
  const WebInterface = new (require('./src/Api/WebInterface'))(GameState);
  WebInterface.init();

  if (restartServer) {
    Logger.log("START - Starting server");
    GameState.GameServer.startup(commander);

    // Save every 10 minutes by default.
    Logger.log(`Setting autosave to ${commander.save} seconds.`);
    clearInterval(saveInterval);
    saveInterval = setInterval(() => {
      GameState.PlayerManager.saveAll();
    }, commander.save * 1000);

    // Ticks for effect processing and combat happen every half second
    clearInterval(tickInterval);
    tickInterval = setInterval(() => {
      GameState.AreaManager.tickAll(GameState);
      GameState.ItemManager.tickAll();
    }, Config.get('entityTickFrequency', 100));

    clearInterval(playerTickInterval);
    playerTickInterval = setInterval(() => {
      GameState.PlayerManager.emit('updateTick');
    }, Config.get('playerTickFrequency', 100));
  }
}

// START IT UP!
init();
// vim: set syn=javascript :