opt-cc/api/tools/log-parse-tool.js

'use strict';

const playerArrayContains = require('./util').playerArrayContains;

const WHITESPACE = ' ';

const VehicleClasses = Object.freeze({
  LIGHT: 'Leicht',
  HEAVY: 'Schwer',
  AIR: 'Flug',
  UNKNOWN: 'Unbekannt',
});

const playerNameRegex = /^(.*?)\s\(/;

const sideRegex = /(side:\s(.*?)\))/;

const magazineRegex = /(magazine:\s(.*?)\))/;

const vehicleRegex = /(vehicle:\s(.*?)\))/;

const parseWarLog = (lineArray, war) => {
  const NAME_TOO_LONG_ERROR = 'Error: ENAMETOOLONG: name too long, open \'';

  const stats = {
    war: war,
    clean: [],
    budget: [],
    points: [],
    kills: [],
    vehicles: [],
    respawn: [],
    revive: [],
    flag: [],
    transport: [],
    players: [],
  };

  const VEHICLE_BLACKLIST = [
    'Prowler (Unbewaffnet)', 'Prowler (Bewaffnet)', 'Hunter',
    'HEMTT Transporter', 'HEMTT Transporter (abgedeckt)', 'HEMTT SanitÀtsfahrzeug',
    'Remote Designator [NATO]', 'UGV Stomper',
    'Qilin (Unbewaffnet)', 'Qilin (Bewaffnet)', 'Ifrit',
    'Tempest-Transporter', 'Tempest-Transporter (abgedeckt)', 'Tempest SanitÀtsfahrzeug',
    'Remote Designator [CSAT]', 'UBF Saif',
    'Quad Bike', 'HuntIR',
  ];

  const addPlayerIfNotExists = (inputPlayer, steamUUID) => {
    console.log(inputPlayer)
    const player = getPlayerAndFractionFromString(inputPlayer);
    if (player && player.name && player.fraction && !playerArrayContains(stats.players, player)) {
      player[ 'warId' ] = war._id;
      player[ 'steamUUID' ] = steamUUID;
      stats.players.push(player);
    }
  };

  lineArray.some((line) => {
    /**
     * sanitize nameTooLongError coming up in first line
     */
    if (line.includes(NAME_TOO_LONG_ERROR)) {
      line = line.substring(line.indexOf(NAME_TOO_LONG_ERROR) + NAME_TOO_LONG_ERROR.length);
    }

    if (line.includes('(Abschuss)')) {
      /**
       * KILLS & VEHICLE KILLS
       */
      stats.clean.push(line);

      const shooterString = line.substring(line.lastIndexOf(' von: ') + 6, line.search(/$/) - 1);
      const shooter = getPlayerAndFractionFromString(shooterString);

      if (line.includes('Fahrzeug:')) {
        const targetString = line.substring(line.lastIndexOf(' --- Fahrzeug: ') + 15, line.lastIndexOf(' von:'));
        const target = getVehicleAndFractionFromString(targetString);
        if (target && shooter && target.fraction !== shooter.fraction) {
          stats.vehicles.push({
            war: war._id,
            time: getFullTimeDate(war.date, line.split(WHITESPACE)[ 5 ]),
            shooter: shooter ? shooter.name : null,
            target: target ? target.name : null,
            fraction: shooter ? shooter.fraction : 'NONE',
            vehicleClass: target.vehicleClass,
          });
        }
      } else {
        const targetString = line.substring(line.lastIndexOf(' --- Einheit: ') + 14, line.lastIndexOf(' von:'));
        const target = getPlayerAndFractionFromString(targetString);
        stats.kills.push({
          war: war._id,
          time: getFullTimeDate(war.date, line.split(WHITESPACE)[ 5 ]),
          shooter: shooter ? shooter.name : null,
          target: target ? target.name : null,
          friendlyFire: shooter ? target.fraction === shooter.fraction : false,
          fraction: shooter ? shooter.fraction : 'NONE',
        });
      }
    } else if (line.includes('(Budget)')) {
      /**
       * BUDGET
       */
      stats.clean.push(line);
      const budg = line.split(WHITESPACE);
      if (line.includes('Startbudget')) {
        stats.war[ 'budgetBlufor' ] = transformMoneyString(budg[ 9 ]);
        stats.war[ 'budgetOpfor' ] = transformMoneyString(budg[ 12 ].slice(0, -1));

        // this date needs to be assigned in first place !important
        const dateString = budg[ 0 ].slice(0, -1).split('/').map((s) => parseInt(s));
        stats.war.date = new Date(dateString[ 0 ], dateString[ 1 ] - 1, dateString[ 2 ]);
      } else if (line.includes('Endbudget')) {
        stats.war[ 'endBudgetBlufor' ] = transformMoneyString(budg[ 9 ]);
        stats.war[ 'endBudgetOpfor' ] = transformMoneyString(budg[ 12 ].slice(0, -2));
        stats.war.endDate = getFullTimeDate(war.date, budg[ 5 ]);
      } else {
        if (line.includes('Respawn von ')) {
          /**
           * RESPAWN
           */
          const playerName = line.substring(line.lastIndexOf('Respawn von ') + 12, line.lastIndexOf('"'));
          stats.respawn.push(getRespawnEntry(budg, playerName, war._id, war.date));
        }
        stats.budget.push(getBudgetEntry(budg, war._id, war.date));
      }
    } else if (line.includes('(Fahne)') && !line.includes('Dominator')) {
      /**
       * FLAG
       */
      stats.clean.push(line);
      const playerName = line.substring(line.lastIndexOf('rt von ') + 7).slice(0, -2);
      const flagFraction = line.includes('NATO Flagge') ? 'BLUFOR' : 'OPFOR';
      const capture = !!line.includes('Flagge erobert');

      stats.flag.push({
        war: war._id,
        time: getFullTimeDate(war.date, line.split(WHITESPACE)[ 5 ]),
        player: playerName,
        flagFraction: flagFraction,
        capture: capture,
      });
    } else if (line.includes('(Punkte)')) {
      /**
       * POINTS
       */
      stats.clean.push(line);
      const pt = line.split(WHITESPACE);

      if (line.includes('Endpunktestand')) {
        stats.war[ 'ptBlufor' ] = parseInt(pt[ 9 ]);
        stats.war[ 'ptOpfor' ] = parseInt(pt[ 12 ].slice(0, -1));
        // EXIT LOOP
        return true;
      } else {
        stats.points.push(getPointsEntry(pt, line, war._id, war.date));
      }
    } else if (line.includes('(Revive)')) {
      /**
       * REVIVE
       */
      stats.clean.push(line);
      const stabilized = !!line.includes('stabilisiert."');
      const medicName = line.substring(line.lastIndexOf('wurde von ') + 10,
        line.lastIndexOf(stabilized ? ' stabilisiert' : ' wiederbelebt'));
      const medic = getPlayerAndFractionFromString(medicName);
      const patientName = line.substring(line.lastIndexOf('--- ') + 4, line.lastIndexOf(' wurde von'));
      const patient = getPlayerAndFractionFromString(patientName);

      stats.revive.push({
        war: war._id,
        time: getFullTimeDate(war.date, line.split(WHITESPACE)[ 5 ]),
        stabilized: stabilized,
        medic: medic.name,
        patient: patient.name,
        fraction: medic.fraction,
      });
    } else if (line.includes('(Transport)')) {
      /**
       * TRANSPORT
       */
      stats.clean.push(line);
      const driverString = line.substring(line.lastIndexOf('wurde von ') + 10, line.lastIndexOf(' eingeflogen'));
      const driver = getPlayerAndFractionFromString(driverString);
      const passengerString = line.substring(line.lastIndexOf('--- ') + 3, line.lastIndexOf(' wurde von'));
      const passenger = getPlayerAndFractionFromString(passengerString);
      const distance = parseInt(line.substring(line.lastIndexOf('eingeflogen (') + 13, line.lastIndexOf('m)') - 1));

      stats.transport.push({
        war: war._id,
        time: getFullTimeDate(war.date, line.split(WHITESPACE)[ 5 ]),
        driver: driver ? driver.name : null,
        passenger: passenger ? passenger.name : null,
        fraction: driver ? driver.fraction : 'NONE',
        distance: distance,
      });
    } else if (line.includes('(Fraktionsuebersicht)')) {
      /**
       * PLAYERS
       */
      const playerString = line.substring(line.lastIndexOf('--- ') + 4, line.lastIndexOf(', PUID'));
      const playerUUID = line.substring(line.lastIndexOf('PUID ') + 5, line.lastIndexOf('"'));
      addPlayerIfNotExists(playerString, playerUUID);
    }
  });

  for (let i = 0; i < stats.players.length; i++) {
    const playerName = stats.players[ i ].name;
    stats.players[ i ][ 'respawn' ] = stats.respawn.filter((res) => res.player === playerName).length;

    stats.players[ i ][ 'kill' ] = stats.kills.filter(
      (kill) => kill.shooter === playerName && !kill.friendlyFire).length;

    // TODO: use vehicle class description from enum
    stats.players[ i ][ 'vehicleLight' ] = stats.vehicles.filter(
      (vehicle) => vehicle.shooter === playerName && vehicle.vehicleClass === 'LIGHT' &&
        VEHICLE_BLACKLIST.indexOf(vehicle.target) < 0).length;

    stats.players[ i ][ 'vehicleHeavy' ] = stats.vehicles.filter(
      (vehicle) => vehicle.shooter === playerName && vehicle.vehicleClass === 'HEAVY' &&
        VEHICLE_BLACKLIST.indexOf(vehicle.target) < 0).length;

    stats.players[ i ][ 'vehicleAir' ] = stats.vehicles.filter(
      (vehicle) => vehicle.shooter === playerName && vehicle.vehicleClass === 'AIR' &&
        VEHICLE_BLACKLIST.indexOf(vehicle.target) < 0).length;

    stats.players[ i ][ 'friendlyFire' ] = stats.kills.filter(
      (kill) => kill.shooter === playerName && kill.friendlyFire).length;

    stats.players[ i ][ 'death' ] = stats.kills.filter((kill) => kill.target === playerName).length;

    stats.players[ i ][ 'revive' ] = stats.revive.filter((rev) => rev.medic === playerName && !rev.stabilized).length;

    stats.players[ i ][ 'flagTouch' ] = stats.flag.filter((flag) => flag.player === playerName).length;

    stats.players[ i ][ 'sort' ] = stats.players[ i ][ 'kill' ] + stats.players[ i ][ 'revive' ] +
      stats.players[ i ][ 'flagTouch' ]
      - stats.players[ i ][ 'friendlyFire' ] - stats.players[ i ][ 'death' ] - stats.players[ i ][ 'respawn' ];
  }

  stats.war.playersBlufor = stats.players.filter((player) => player.fraction === 'BLUFOR').length;
  stats.war.playersOpfor = stats.players.filter((player) => player.fraction === 'OPFOR').length;

  return stats;
};

const getRespawnEntry = (respawn, playerName, warId, warDate) => {
  return {
    war: warId,
    time: getFullTimeDate(warDate, respawn[ 5 ]),
    player: playerName,
  };
};

const getPointsEntry = (pt, line, warId, warDate) => {
  return {
    war: warId,
    time: getFullTimeDate(warDate, pt[ 5 ]),
    ptBlufor: parseInt(pt[ 10 ]),
    ptOpfor: parseInt(pt[ 13 ].slice(0, -3)),
    fraction: line.includes('Kein Dominator') ? 'NONE' : line.includes('NATO +1') ? 'BLUFOR' : 'OPFOR',
  };
};

const getBudgetEntry = (budg, warId, warDate) => {
  return {
    war: warId,
    time: getFullTimeDate(warDate, budg[ 5 ]),
    fraction: budg[ 7 ] === 'NATO' ? 'BLUFOR' : 'OPFOR',
    oldBudget: transformMoneyString(budg[ 9 ]),
    newBudget: transformMoneyString(budg[ 12 ]),
  };
};

const getPlayerAndFractionFromString = (inputString) => {
  const playerNameRegexMatch = playerNameRegex.exec(inputString);
  const sideMatch = sideRegex.exec(inputString);
  const magazineMatch = magazineRegex.exec(inputString);
  const vehicleMatch = vehicleRegex.exec(inputString);

  let name;
  if (playerNameRegexMatch && playerNameRegexMatch.length >= 2) {
    // NAME
    name = playerNameRegexMatch[ 1 ];
  }

  let side
  if (sideMatch && sideMatch.length >= 3) {
    // SIDE
    side = sideMatch[ 2 ];
  } else {
    const inputArray = inputString.split(WHITESPACE)
    if (inputArray && inputArray.length === 2) {
      side = inputArray[ 1 ].replace('(', '').replace(')', '');
    }
  }

  if (magazineMatch && magazineMatch.length >= 3) {
    // MAGAZINE
    // console.log(magazineMatch[2])
  }

  if (vehicleMatch && vehicleMatch.length >= 3 && vehicleMatch[ 2 ]) {
    let vehicle = vehicleMatch[ 2 ];
    if (new RegExp("\\(.*$").test(vehicle)) {
      vehicle = vehicle.concat(")");
    }
    // VEHICLE
    // console.log(vehicle)
  }

  let fraction;
  if (side) {
    fraction = side !== 'ENEMY' ? side === 'WEST' ?
      'BLUFOR' : 'OPFOR' :
      undefined;
  }

  // do not return player for 'Error: No unit'
  if (name && name !== 'Error: No unit') {
    return {name: name.trim(), fraction: fraction};
  }
};

const getVehicleAndFractionFromString = (nameClassFractionString) => {
  const nameArray = nameClassFractionString.trim().split(WHITESPACE);
  const vehicleFraction = nameArray[ nameArray.length - 1 ].slice(0, -1);
  nameArray.pop();
  nameArray.pop();
  const vehicleClassString = nameArray[ nameArray.length - 1 ].replace('(', '').replace(')', '');
  nameArray.pop();
  nameArray.pop();
  const vehicleName = nameArray.join(WHITESPACE);

  // skip logging here - this is some basic equipment identifier (i.e. parachute)
  if (vehicleFraction === 'OPF_F' || vehicleFraction === 'BLU_F' || vehicleClassString === VehicleClasses.UNKNOWN) {
    return;
  }

  const fraction = vehicleFraction === '(OPT_NATO)' || vehicleFraction === '(OPT_NATO_T)' ? 'BLUFOR' : 'OPFOR';

  let vehicleClass;
  for (const key in VehicleClasses) {
    if (VehicleClasses.hasOwnProperty(key) && VehicleClasses[ key ] === vehicleClassString) {
      vehicleClass = key;
    }
  }

  return {
    name: vehicleName,
    fraction: fraction,
    vehicleClass: vehicleClass,
  };
};

const transformMoneyString = (budgetString) => {
  if (!budgetString.includes('e+')) {
    return parseInt(budgetString);
  }
  const budget = budgetString.split('e+');
  return Math.round(parseFloat(budget[ 0 ]) * Math.pow(10, parseInt(budget[ 1 ])));
};

const getFullTimeDate = (date, timeString) => {
  const returnDate = new Date(date);
  const time = timeString.split(':');
  returnDate.setHours(time[ 0 ]);
  returnDate.setMinutes(time[ 1 ]);
  return returnDate;
};

module.exports = parseWarLog;