omegga 0.1.85 → 1.0.2

package/src/omegga/commandInjector.js

@@ -1,228 +0,0 @@
-const { color, time } = require('../util/index.js');
-const _ = require('lodash');
-
-// A list of commands that can be injected to things with the log wrangler
-/**
- * List of injected commands
- * @type {Object}
- */
-const COMMANDS = {
-  /**
-   * Get a server status object containing bricks, time, players, player ping, player roles, etc
-   * @return {Promise<Object>} - Server Status
-   */
-  async getServerStatus() {
-    const statusLines = await this.watchLogChunk(
-      'Server.Status',
-      /^LogConsoleCommands: (.+)$/,
-      {
-        first: match => match[1].startsWith('Server Name:'),
-        timeoutDelay: 1000,
-      }
-    );
-
-    // the table lines all start with '* '
-    // find all those lines, and remove the asterisk
-    const [tableHeader, ...tableLines] = statusLines
-      .filter(l => l[1].startsWith('* '))
-      .map(l => l[1].slice(1));
-
-    // use the size of each column to build a regex that matches each row
-    const columnRegExp = new RegExp(
-      tableHeader
-        .match(/[^|]+/g) // get all strings between the |'s'
-        .map((line, i) => [line.slice(1, -1), line.length - (i === 5 ? 1 : 2)]) // calculate the lengths (and remove the spaces)
-        .map(
-          ([name, len]) => ` (?<${name.trim().toLowerCase()}>.{${len}})( |$)`
-        ) // create a regex pattern to match strings of that length (and trim off whitespace at the end)
-        .join('\\|')
-    ); // join the regexes with the |
-
-    const status = {
-      // easily extract certain values from the server status
-      serverName: statusLines[0][1].match(/^Server Name: (.*)$/)[1],
-      description: statusLines[1][1].match(/^Description: (.*)$/)[1],
-      bricks: Number(statusLines[2][1].match(/^Bricks: (\d+)$/)[1]),
-      components: Number(statusLines[3][1].match(/^Components: (\d+)$/)[1]),
-      time: time.parseDuration(statusLines[4][1].match(/^Time: (.*)$/)[1]),
-      // extract players using the generated table regex
-      players: tableLines.map(l => {
-        // match the player row with the generated regex
-        const {
-          groups: { name, ping, time: online, roles, address, id },
-        } = l.match(columnRegExp);
-        // trim and parse the matched data
-        return {
-          name: name.trim(),
-          ping: time.parseDuration(ping.trim()),
-          time: time.parseDuration(online.trim()),
-          roles: roles
-            .trim()
-            .split(', ')
-            .filter(r => r.length > 0), // roles are split by ', '
-          address: address.replace('(Owner)', '').trim(),
-          id: id.trim(),
-        };
-      }),
-    };
-
-    return status;
-  },
-
-  /**
-   * get every player's position and alive states
-   * @return {Promise<Array<Object>>}
-   */
-  async getAllPlayerPositions() {
-    const pawnRegExp =
-      /(?<index>\d+)\) BP_PlayerController_C .+?PersistentLevel\.(?<controller>BP_PlayerController_C_\d+)\.Pawn = (?:None|BP_FigureV2_C'.+?:PersistentLevel.(?<pawn>BP_FigureV2_C_\d+)')?$/;
-    const posRegExp =
-      /(?<index>\d+)\) CapsuleComponent .+?PersistentLevel\.(?<pawn>BP_FigureV2_C_\d+)\.CollisionCylinder\.RelativeLocation = \(X=(?<x>[\d.-]+),Y=(?<y>[\d.-]+),Z=(?<z>[\d.-]+)\)$/;
-    const deadFigureRegExp =
-      /(?<index>\d+)\) BP_FigureV2_C .+?PersistentLevel\.(?<pawn>BP_FigureV2_C_\d+)\.bIsDead = (?<dead>(True|False))$/;
-
-    // wait for the pawn and position watchers to return all the results
-    const [pawns, deadFigures, positions] = await Promise.all([
-      this.watchLogChunk('GetAll BP_PlayerController_C Pawn', pawnRegExp, {
-        first: 'index',
-        timeoutDelay: 250,
-      }),
-      this.watchLogChunk('GetAll BP_FigureV2_C bIsDead', deadFigureRegExp, {
-        first: 'index',
-        timeoutDelay: 250,
-      }),
-      this.watchLogChunk(
-        'GetAll SceneComponent RelativeLocation Name=CollisionCylinder',
-        posRegExp,
-        { first: 'index', timeoutDelay: 250 }
-      ),
-    ]);
-
-    return (
-      pawns
-        // iterate through the pawn+controllers
-        .map(pawn => ({
-          // find the player for the associated controller
-          player: this.getPlayer(pawn.groups.controller),
-          // find the position for the associated pawn
-          pos: positions.find(pos => pawn.groups.pawn === pos.groups.pawn),
-          isDead: deadFigures.find(
-            dead => pawn.groups.pawn === dead.groups.pawn
-          ),
-          pawn,
-        }))
-        // filter by only those who have both player. previously we filtered by position but this breaks for players without a pawn, instead it's preferable to pass null
-        .filter(p => p.player)
-        // turn the position into a [x, y, z] number array (last 3 items in the array)
-        .map(p => ({
-          player: p.player,
-          pawn: p.pawn.groups.pawn || null,
-          pos: p.pos ? p.pos.slice(3).map(Number) : null,
-          isDead: p.isDead ? p.isDead.groups.dead === 'True' : true,
-        }))
-    );
-  },
-
-  /**
-   * get all minigames and their players (and the player's teams)
-   * @return {Promise<Array<Object>>}
-   */
-  async getMinigames() {
-    // patterns to match the console logs
-    const ruleNameRegExp =
-      /^(?<index>\d+)\) BP_Ruleset_C (.+):PersistentLevel.(?<ruleset>BP_Ruleset_C_\d+)\.RulesetName = (?<name>.*)$/;
-    const ruleMembersRegExp =
-      /^(?<index>\d+)\) BP_Ruleset_C (.+):PersistentLevel.(?<ruleset>BP_Ruleset_C_\d+)\.MemberStates =$/;
-    const teamNameRegExp =
-      /^(?<index>\d+)\) BP_Team(_\w+)?_C (.+):PersistentLevel.(?<ruleset>BP_Ruleset_C_\d+)\.(?<team>BP_Team(_\w+)?_C_\d+)\.TeamName = (?<name>.*)$/;
-    const teamColorRegExp =
-      /^(?<index>\d+)\) BP_Team(_\w+)?_C (.+):PersistentLevel.(?<ruleset>BP_Ruleset_C_\d+)\.(?<team>BP_Team(_\w+)?_C_\d+)\.TeamColor = \(B=(?<b>\d+),G=(?<g>\d+),R=(?<r>\d+),A=(?<a>\d+)\)$/;
-    const teamMembersRegExp =
-      /^(?<index>\d+)\) BP_Team(_\w+)?_C (.+):PersistentLevel.(?<ruleset>BP_Ruleset_C_\d+)\.(?<team>BP_Team(_\w+)?_C_\d+)\.MemberStates =$/;
-    const playerStateRegExp =
-      /^\t(?<index>\d+): BP_PlayerState_C'(.+):PersistentLevel\.(?<state>BP_PlayerState_C_\d+)'$/;
-
-    try {
-      // parse console output to get the minigame info
-      const [rulesets, ruleMembers, teamMembers, teamNames, teamColors] =
-        await Promise.all([
-          this.watchLogChunk(
-            'GetAll BP_Ruleset_C RulesetName',
-            ruleNameRegExp,
-            {
-              first: 'index',
-            }
-          ),
-          this.watchLogArray(
-            'GetAll BP_Ruleset_C MemberStates',
-            ruleMembersRegExp,
-            playerStateRegExp
-          ),
-          this.watchLogArray(
-            'GetAll BP_Team_C MemberStates',
-            teamMembersRegExp,
-            playerStateRegExp
-          ),
-          this.watchLogChunk('GetAll BP_Team_C TeamName', teamNameRegExp, {
-            first: 'index',
-          }),
-          // team color in a5 is based on (B=255,G=255,R=255,A=255)
-          this.watchLogChunk('GetAll BP_Team_C TeamColor', teamColorRegExp, {
-            first: 'index',
-          }),
-        ]);
-
-      // figure out what to do with the matched color results
-      const handleColor = match => {
-        // color index, return the colorset color
-        if (match.color) return color.DEFAULT_COLORSET[Number(match)].slice();
-        else return [match.r, match.g, match.b, match.a].map(Number);
-      };
-
-      // join the data into a big object
-      return rulesets.map(r => ({
-        name: r.groups.name,
-        ruleset: r.groups.ruleset,
-
-        // get the players from the team members
-        members: ruleMembers
-          .find(m => m.item.ruleset === r.groups.ruleset)
-          .members // get the members from this ruleset
-          .map(m => this.getPlayer(m.state)), // get the players
-
-        // get the teams for this ruleset
-        teams: teamMembers
-          .filter(m => m.item.ruleset === r.groups.ruleset) // only get teams from this ruleset
-          .map(m => ({
-            // team name
-            name: _.get(
-              teamNames.find(t => t.groups.team === m.item.team),
-              'groups.name'
-            ),
-            team: m.item.team,
-
-            // get the colors (different for a4 and a5)
-            color: handleColor(
-              _.pick(
-                teamColors.find(t => t.groups.team === m.item.team).groups,
-                ['r', 'g', 'b', 'a']
-              )
-            ),
-
-            // get the players from the team
-            members: m.members.map(m => this.getPlayer(m.state)),
-          })),
-      }));
-    } catch (e) {
-      Omegga.error('error getting minigames', e);
-      return undefined;
-    }
-  },
-};
-
-// inject the commands into the object given a log wrangler
-module.exports = (obj, logWrangler) => {
-  for (const cmd in COMMANDS) {
-    obj[cmd] = COMMANDS[cmd].bind(logWrangler);
-  }
-};

package/src/omegga/index.js

@@ -1,22 +0,0 @@
-module.exports = {
-  // contains omegga server
-  Server: require('./server.js'),
-
-  // Plugin loader format
-  Plugin: require('./plugin.js'),
-
-  // Player interface
-  Player: require('./player.js'),
-
-  // acts as the interface between server logs and matchers
-  OmeggaWrapper: require('./wrapper.js'),
-
-  // auth token generation helpers
-  auth: require('./auth.js'),
-
-  // tackles the problem of reading brickadia logs
-  LogWrangler: require('./logWrangler.js'),
-
-  // injects commands that only need a log wrangler to function
-  commandInjector: require('./commandInjector.js'),
-};

package/src/omegga/logWrangler.js

@@ -1,323 +0,0 @@
-/*
-  The wrapper combines the things looking at or waiting for logs with the actual server logs
-*/
-
-const GENERIC_LINE_REGEX =
-  /^(\[(?<date>\d{4}\.\d\d.\d\d-\d\d.\d\d.\d\d:\d{3})\]\[\s*(?<counter>\d+)\])?(?<generator>\w+): (?<data>.+)$/;
-
-class LogWrangler {
-  // list of patterns and callbacks watching the brickadia logs in general
-  #matchers = [];
-
-  // list of patterns and promises waiting for specific console logs
-  #watchers = [];
-
-  constructor(omegga) {
-    // passthru functions
-    this.exec = cmd => omegga.writeln(cmd);
-    this.getPlayer = arg => omegga.getPlayer(arg);
-    this.getVersion = () => omegga.version;
-
-    // callback reads in new lines
-    this.callback = this.handleLog.bind(this);
-
-    this.addMatcher = this.addMatcher.bind(this);
-    this.addWatcher = this.addWatcher.bind(this);
-    this.watchLogArray = this.watchLogArray.bind(this);
-    this.watchLogChunk = this.watchLogChunk.bind(this);
-    this.omegga = omegga;
-  }
-
-  // add a new matcher to listen in on the logs
-  // pattern is regex or a function that returns a match
-  // callback is a function that receives the result of the pattern
-  // returns a deregister function
-  addMatcher(pattern, callback) {
-    if (
-      (typeof pattern !== 'function' && !(pattern instanceof RegExp)) ||
-      typeof callback !== 'function'
-    )
-      return undefined;
-
-    // create the matcher from the callback and pattern, add it to the matchers
-    const matcher = { pattern, callback };
-    this.#matchers.push(matcher);
-
-    // return a function to remove this matcher from the list of matchers
-    return () => {
-      const index = this.#matchers.indexOf(matcher);
-      if (index > -1) this.#matchers.splice(index, 0);
-    };
-  }
-
-  // wait for stdout to match this regex or matcher fn, returns the match or times out
-  // pattern is regex or a function that returns a match
-  // if bundle is set to true, it returns all matches after the timeout ends rather than resolving (can't be used with delay 0)
-  // exec is a function run after adding the watcher
-  // debounce (used with bundle) waits extra time after each match before timing out
-  // afterMatchDelay (used with debounce) indicates to run a new timeout after the first match
-  // last (used with bundle) is a function run on the match. when it returns true, the watcher resolves early
-  // returns a promise, rejects after timeout ends
-  addWatcher(
-    pattern,
-    {
-      timeoutDelay = 50,
-      bundle = false,
-      debounce = false,
-      afterMatchDelay = 0,
-      last,
-      exec,
-    } = {}
-  ) {
-    if (typeof pattern !== 'function' && !(pattern instanceof RegExp))
-      return undefined;
-
-    return new Promise((resolve, reject) => {
-      // create the watcher
-      const watcher = {
-        pattern,
-        bundle,
-        debounce,
-        timeoutDelay,
-        afterMatchDelay,
-        last,
-        matches: [],
-      };
-
-      (watcher.resolve = (...args) => {
-        clearTimeout(watcher.timeout);
-        resolve(args);
-      }),
-        // remove helper
-        (watcher.remove = () => {
-          const index = this.#watchers.indexOf(watcher);
-          if (index > -1) {
-            this.#watchers.splice(index, 1);
-          }
-        });
-
-      // what the watcher dones when it completes
-      watcher.done = () => {
-        // remove the watcher if it exists
-        watcher.remove();
-
-        // if the bundle option is set to true, resolve on timeout end
-        if (bundle) {
-          resolve(watcher.matches);
-        } else {
-          // reject the promise
-          reject('timed out');
-        }
-      };
-
-      // if the delay is non 0, kill the promise after some time
-      if (timeoutDelay !== 0) {
-        watcher.timeout = setTimeout(watcher.done, timeoutDelay);
-      }
-
-      this.#watchers.push(watcher);
-      exec && exec();
-    });
-  }
-
-  // match a group of console logs that have the same counter (ran on the same thread)
-  // first is a function or 'index' for the index capture group that determines if this is match is the first log
-  // last is a function that determines if this match is the last log (and can terminate early)
-  // aftermatch delay is borrowed from addWatcher
-  watchLogChunk(
-    cmd,
-    pattern,
-    { first, last, afterMatchDelay = 10, timeoutDelay = 100 }
-  ) {
-    // we're focused on the counter part of this, the rest will be passed to the pattern matcher
-    const logLineRegExp =
-      /\[(?<date>\d{4}\.\d\d.\d\d-\d\d.\d\d.\d\d:\d{3})\]\[\s*(?<counter>\d+)\](?<rest>.*)$/;
-
-    // keep track of the current log line
-    let currentCounter = -1;
-
-    // create the
-    return this.addWatcher(
-      line => {
-        const logLineMatch = line.match(logLineRegExp);
-        if (!logLineMatch) return;
-
-        // get the counter and rest of line from the log line match
-        const {
-          groups: { counter, rest },
-        } = logLineMatch;
-
-        // run the regular pattern matcher
-        const match =
-          pattern instanceof RegExp
-            ? rest.match(pattern)
-            : pattern(rest, rest.match(GENERIC_LINE_REGEX));
-
-        // end the watcher early if there is no match and the match has started (log chunks are uninterrupted)
-        // this usually means that two commands were run so quickly that the output occured on the same counter
-        if (!match && currentCounter !== -1) {
-          return '[OMEGGA_WATCHER_DONE]';
-        }
-
-        // ignore things that don't match
-        if (!match) return;
-
-        // determine if this is the first log in the chunk
-        let isFirst = false;
-
-        // if there is a first parameter
-        if (first) {
-          // if it's a function, use that function to match
-          if (typeof first === 'function') isFirst = first(match);
-          // if it's 'index', use the index capture group
-          else if (first === 'index') isFirst = match.groups.index === '0';
-        } else {
-          // otherwise, it doesn't matter
-          isFirst = true;
-        }
-
-        // assign counter if it's not set and it's the first, or no first function is set
-        if (currentCounter === -1 && isFirst) {
-          currentCounter = counter;
-        }
-        if (currentCounter === -1 && !isFirst) {
-          return;
-        }
-
-        // prematurely terminate the match if another log is found
-        if (counter !== currentCounter) return '[OMEGGA_WATCHER_DONE]';
-
-        // add the match to the bundle
-        return match;
-      },
-      {
-        last,
-        exec: () => this.exec(cmd),
-        bundle: true,
-        debounce: true,
-        timeoutDelay,
-        afterMatchDelay,
-      }
-    );
-  }
-
-  // get a chunked array from the log
-  // patterns are actually regex and must have capture groups
-  // the itemPattern must have an (?<index>) capture group
-  // the return is in the format of:
-  /*
-    [{
-      item: (itemPattern group),
-      members: [
-        ...memberPattern groups,
-      ],
-    }, ...]
-  */
-  async watchLogArray(cmd, itemPattern, memberPattern) {
-    const results = await this.watchLogChunk(
-      cmd,
-      line => {
-        // match on items
-        const itemMatch = line.match(itemPattern);
-        if (itemMatch) return ['item', itemMatch];
-
-        // match on members
-        const memberMatch = line.match(memberPattern);
-        if (memberMatch) return ['member', memberMatch];
-      },
-      { first: arr => arr[0] === 'item' && arr[1].groups.index === '0' }
-    );
-
-    const array = [];
-
-    // insert the results into the array
-    for (const [type, { groups }] of results) {
-      // insert an item into the array
-      if (type === 'item') {
-        array.push({ item: groups, members: [] });
-
-        // insert a member into an item
-      } else if (type === 'member' && array.length > 0) {
-        array[array.length - 1].members.push(groups);
-      }
-    }
-
-    return array;
-  }
-
-  // check all the matchers against this line
-  handleLog(line) {
-    // generic match the log
-    const logMatch = line.match(GENERIC_LINE_REGEX);
-
-    // pattern matcher handlers
-    const patternMatchers = [
-      {
-        array: this.#matchers,
-        onMatch(match, matcher) {
-          // if the matcher's callback is a function, run it
-          if (typeof matcher.callback === 'function') matcher.callback(match);
-        },
-      },
-      {
-        array: this.#watchers,
-        onMatch(match, watcher) {
-          // if the watcher is in bundle mode, add the match to its matches
-          if (watcher.bundle) {
-            // allow the watcher to terminate early
-            if (match === '[OMEGGA_WATCHER_DONE]') {
-              clearTimeout(watcher.timeout);
-              watcher.done();
-              return;
-            }
-
-            watcher.matches.push(match);
-
-            // check if this is the last line and terminate early
-            if (watcher.last && watcher.last(match)) {
-              clearTimeout(watcher.timeout);
-              watcher.done();
-              return;
-            }
-
-            // if the watcher is debounced, reset the timer
-            if (watcher.debounce) {
-              clearTimeout(watcher.timeout);
-              watcher.timeout = setTimeout(
-                watcher.done,
-                watcher.afterMatchDelay || watcher.timeoutDelay
-              );
-            }
-
-            // otherwise resolve with the result and remove the watcher from the list
-          } else {
-            watcher.resolve(match);
-            watcher.remove();
-          }
-        },
-      },
-    ];
-
-    // loop through matchers and run callbacks if they match
-    for (const { array, onMatch } of patternMatchers) {
-      // iterate in reverse because removing indices will not skip over any elements
-      for (let i = array.length - 1; i >= 0; i--) {
-        const matcher = array[i];
-        try {
-          // run the match on a pattern or test with a function
-          const match =
-            matcher.pattern instanceof RegExp
-              ? line.match(matcher.pattern)
-              : matcher.pattern(line, logMatch);
-
-          // if there's  match, handle it for this type of matcher
-          if (match) onMatch(match, matcher);
-        } catch (e) {
-          Omegga.error('error in matcher', matcher.pattern, e);
-        }
-      }
-    }
-  }
-}
-
-module.exports = LogWrangler;

package/src/omegga/matchers/auth.js

@@ -1,49 +0,0 @@
-module.exports = omegga => {
-  // patterns for leave message and host detection
-  const hostRegExp = /^Logged in as (?<name>.+) \((?<id>[0-9a-fA-F-]{36})\)\.$/;
-  const invalidRegExp =
-    /^(Error: AuthState is Invalid on dedicated server - exiting\.|Changing AuthState from \w+ to Invalid\.)$/;
-  const validRegExp =
-    /^Changing AuthState from \w+ to Valid(Online|Offline)\.$/;
-
-  return {
-    // listen for auth messages
-    pattern(_line, logMatch) {
-      // line is not generic console log
-      if (!logMatch) return;
-
-      const { generator, data } = logMatch.groups;
-      // check if log is an auth log
-      if (generator !== 'LogAuthManager') return;
-
-      // match against the patterns
-      const hostMatch = data.match(hostRegExp);
-      const invalidMatch = data.match(invalidRegExp);
-      const validMatch = data.match(validRegExp);
-
-      // if the log matches one of the patterns, return the result
-      if (hostMatch) {
-        const { name, id } = hostMatch.groups;
-        return ['host', { name, id }];
-      } else if (invalidMatch) {
-        return ['invalid', null];
-      } else if (validMatch) {
-        return ['valid', null];
-      }
-    },
-    // when there's a match, emit the chat message event
-    callback([type, host]) {
-      if (type == 'host') {
-        // store the host info
-        omegga.host = Object.freeze(host);
-        omegga.emit('host', Object.freeze(host));
-      } else if (type === 'valid') {
-        // let the server know it has started
-        omegga.emit('start', { map: omegga.currentMap });
-      } else if (type === 'invalid') {
-        omegga.emit('unauthorized');
-        // do nothing with invalid auth?? how did we get here
-      }
-    },
-  };
-};

package/src/omegga/matchers/chat.js

@@ -1,73 +0,0 @@
-module.exports = omegga => {
-  // pattern to get PlayerController from a leave message
-  const chatRegExp = /^(?<name>.+?): (?<message>.+)$/;
-  const kickRegExp =
-    /^(?<name>.+?) was kicked by (?<kicker>.+?) \((?<reason>.+?)\)$/;
-
-  const exists = name => omegga.players.some(p => p.name === name);
-
-  const sanitizeMsg = msg =>
-    msg
-      .toString()
-      .replace(/&gt;/g, '>')
-      .replace(/&und;/g, '_')
-      .replace(/&lt;/g, '<')
-      .replace(/&scl;/g, ';');
-
-  const sanitizeName = name => name.toString().replace(/&und;/g, '_');
-
-  return {
-    // listen for chat messages
-    pattern(_line, logMatch) {
-      // line is not generic console log
-      if (!logMatch) return;
-
-      const { generator, data } = logMatch.groups;
-      // check if log is a chat log
-      if (generator !== 'LogChat') return;
-
-      // match the chat log to the chat message pattern
-      const chatMatch = data.match(chatRegExp);
-      const kickMatch = data.match(kickRegExp);
-
-      if (chatMatch) {
-        let { name, message } = chatMatch.groups;
-
-        name = sanitizeName(name);
-        message = sanitizeMsg(message);
-
-        // no player has this name. probably a bug
-        if (!exists(name)) return;
-
-        // return the player with the corresponding controller
-        return { type: 'chat', name, message };
-      } else if (kickMatch) {
-        let { name, kicker, reason } = kickMatch.groups;
-        name = sanitizeName(name);
-        kicker = sanitizeName(kicker);
-        reason = sanitizeMsg(reason);
-
-        if (!exists(name) || !exists(kicker)) return;
-
-        return { type: 'kick', name, kicker, reason };
-      }
-    },
-    // when there's a match, emit the chat message event
-    callback({ type, name, kicker, message, reason }) {
-      if (type === 'chat') {
-        omegga.emit('chat', name, message);
-
-        // chat command parsing, emit `chatcmd:test` when `!test` is sent in chat
-        if (message.startsWith('!')) {
-          const [cmd, ...args] = message.slice(1).split(' ');
-          if (cmd.length > 0) {
-            omegga.emit('chatcmd:' + cmd.toLowerCase(), name, ...args);
-            omegga.emit('chatcmd', cmd.toLowerCase(), name, ...args);
-          }
-        }
-      } else if (type === 'kick') {
-        omegga.emit('kick', name, kicker, reason);
-      }
-    },
-  };
-};