Parsing a string with regex to build JSON
I would manipulate RegExp.lastIndex with the sticky flag to avoid slicing the source string:

function parseGame(text) {
  const RX_HEADER = /!report Game Type:\s*(\d|\w+)(?:\s*(\w.*))?/y;
  const RX_TEAM = /Team:\s*(\d+)/y;
  const RX_DISCORD = /&lt;@(\d+)&gt;/y;
  const RX_POSITION_DISCORD = /(\d+):\s*&lt;@(\d+)&gt;\s*(?:\w+\s?\w+)?/y;
  const RX_WHITESPACE = /\s+/y;

  let pos = 0;
  const data = {players: []};

  function match(rx) {
    rx.lastIndex = pos;
    const matches = rx.exec(text);
    if (!matches) {
      return [];
    }
    pos = rx.lastIndex;
    if (pos &lt; text.length) {
      RX_WHITESPACE.lastIndex = pos;
      RX_WHITESPACE.exec(text);
      pos = RX_WHITESPACE.lastIndex || pos;
    }
    return matches;
  }

  function readHeader() {
    const ID_NAME_MAP = {
      1: 'Diplo',
      2: 'Always War',
      3: 'FFA',
      4: 'No Diplo',
      5: 'Team',
      6: 'Duel',
      7: 'No War',
    };
    let [_, gameType, gameMod] = match(RX_HEADER);
    if (!gameType) {
      return;
    }
    gameType = gameType.toLowerCase();
    for (const type in ID_NAME_MAP) {
      if (type === gameType || ID_NAME_MAP[type].toLowerCase() === gameType) {
        data.type = Number(type);
        break;
      }
    }
    if (gameMod) {
      data.moddifier = gameMod;
    }
  }

  function readTeams() {
    let teamId;
    while ((teamId = Number(match(RX_TEAM)[1]))) {
      let position = 0;
      let discordId;
      while ((discordId = match(RX_DISCORD)[1])) {
        data.players.push({
          teamId,
          discordId,
          position: ++position,
        });
      }
    }
  }

  function readPlayers() {
    while (true) {
      const [_, position, discordId] = match(RX_POSITION_DISCORD);
      if (position) {
        data.players.push({
          discordId,
          position: Number(position),
        });
      } else {
        break;
      }
    }
  }

  readHeader();
  if (data.type === 5) {
    readTeams();
  } else {
    readPlayers();
  }
  return data;
}


And just to nitpick:


[\s+]? matches whitespace and a + which seems weird so I replaced it with  \s*
[\s\S]? in rePlayer is ambiguous as it allows any single character, which seems weird.
I would expect only whitespace and new line(s) allowed e.g. \s*
I usually specify a match group is unused via ?: e.g. (?:foo)?
Indent the code consistently
Consistently use spaces before opening braces e.g. if (foo) { instead of if(foo){
No need for var generally if you use ES6 anyway
Use const for variables you don't reassign (more info)
Use a consistent type for the id and position instead of mixing strings &amp; numbers
Use a JS linter like eslint to catch the errors like a global player variable
Use camelCase for properties and variable names
Use object literals like arr.push({foo: 'bar'}) without an interim variable