qt-migration-legatus/qt5-before/dlbo/Lts/Proxies/HighLevelArchitecture/Apache/damage_model.cpp

/**
  * @RDE_HEADER@
  * Damage state transaformation from/to HLA <-> Excon, see ICD, 4.4.3.5.6 - Damage Model
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "damage_model.h"

#include <QTimer>
#include <QDateTime>

namespace HighLevelArchitecture
{

// ICD, 4.4.3.5.6 - Damage Model
// es sind dort nich alle definiert, die Reihenfolge ist DamageState - FirePower - Immobilized
DamageModel::DamageModel(const IdentifierStruct &is,
                         const ProjectDataManagement::VulnerabilityState &state)
  : m_is(is)
{
  initTimer();
  setVulnerabilityState(state, QDateTime::currentMSecsSinceEpoch());
}

DamageModel::DamageModel(const ProjectDataManagement::VulnerabilityState &state)
{
  setVulnerabilityState(state, QDateTime::currentMSecsSinceEpoch());
}

ProjectDataManagement::VulnerabilityState DamageModel::vulnerabilityStateFromDamageStatus(const rpr2::DamageStatusEnum32::ET &status)
{
  ProjectDataManagement::VulnerabilityState vs;
  switch(status)
  {
  case rpr2::DamageStatusEnum32::NoDamage:
    vs = ProjectDataManagement::VulnerabilityState_def::CombatReady;
    break;
  case rpr2::DamageStatusEnum32::SlightDamage:
    vs = ProjectDataManagement::VulnerabilityState_def::LightDamage;
    break;
  case rpr2::DamageStatusEnum32::ModerateDamage:
    vs = ProjectDataManagement::VulnerabilityState_def::HeavyDamage;
    break;
  case rpr2::DamageStatusEnum32::Destroyed:
    vs = ProjectDataManagement::VulnerabilityState_def::CatastrophicKill;
    break;
  }

  return vs;
}

DamageModel::DamageModel(const IdentifierStruct &is, const rpr2::DamageStatusEnum32::ET &status)
  : m_is(is)
{
  ProjectDataManagement::VulnerabilityState vs = vulnerabilityStateFromDamageStatus(status);
  setVulnerabilityState(vs, QDateTime::currentMSecsSinceEpoch());

}

rpr2::DamageStatusEnum32::ET DamageModel::damageState(qint64 simTimeMSec) const
{
  int idx = indexForTime(simTimeMSec);
  if (idx < 0)
    return rpr2::DamageStatusEnum32::NoDamage;

  // Todo: Correct?!?
  switch (m_vulnerabilityStates.at(idx).vulnerabilityState.underlying())
  {
  case ProjectDataManagement::VulnerabilityState_def::CombatReady:
    return rpr2::DamageStatusEnum32::NoDamage;
  case ProjectDataManagement::VulnerabilityState_def::LightDamage:
    return rpr2::DamageStatusEnum32::SlightDamage;
  case ProjectDataManagement::VulnerabilityState_def::MediumDamage:
  case ProjectDataManagement::VulnerabilityState_def::HeavyDamage:
  case ProjectDataManagement::VulnerabilityState_def::MobilityKill:
  case ProjectDataManagement::VulnerabilityState_def::VisibleMobilityKill:
  case ProjectDataManagement::VulnerabilityState_def::WeaponSystemDamage:
  case ProjectDataManagement::VulnerabilityState_def::VisibleWeaponSystemDamage:
    return rpr2::DamageStatusEnum32::ModerateDamage;
  case ProjectDataManagement::VulnerabilityState_def::CatastrophicKill:
    return rpr2::DamageStatusEnum32::Destroyed;
  case ProjectDataManagement::VulnerabilityState_def::TemporarySeverance:
  case ProjectDataManagement::VulnerabilityState_def::NearMiss:
  case ProjectDataManagement::VulnerabilityState_def::HitWithNoEffect:
    return rpr2::DamageStatusEnum32::NoDamage;
  case ProjectDataManagement::VulnerabilityState_def::VulnerabilityBitsChanged:
  case ProjectDataManagement::VulnerabilityState_def::Reserved:
    return rpr2::DamageStatusEnum32::NoDamage;
  case ProjectDataManagement::VulnerabilityState_def::NContamination:
  case ProjectDataManagement::VulnerabilityState_def::BContamination:
  case ProjectDataManagement::VulnerabilityState_def::CContamination:
    return rpr2::DamageStatusEnum32::SlightDamage;
  case ProjectDataManagement::VulnerabilityState_def::NotReady:
    return rpr2::DamageStatusEnum32::NoDamage;
  }
  return rpr2::DamageStatusEnum32::NoDamage;
}

bool DamageModel::immobilized(qint64 simTimeMSec) const
{
  int idx = indexForTime(simTimeMSec);
  if (idx < 0)
    return false;
  if (m_vulnerabilityStates.at(idx).vulnerabilityState == ProjectDataManagement::VulnerabilityState_def::MobilityKill ||
      m_vulnerabilityStates.at(idx).vulnerabilityState == ProjectDataManagement::VulnerabilityState_def::VisibleMobilityKill ||
      m_vulnerabilityStates.at(idx).vulnerabilityState == ProjectDataManagement::VulnerabilityState_def::CatastrophicKill)
    return true;
  return false;
}

bool DamageModel::firePowerDisabled(qint64 simTimeMSec) const
{
  int idx = indexForTime(simTimeMSec);
  if (idx < 0)
    return false;
  if (m_vulnerabilityStates.at(idx).vulnerabilityState == ProjectDataManagement::VulnerabilityState_def::WeaponSystemDamage ||
      m_vulnerabilityStates.at(idx).vulnerabilityState == ProjectDataManagement::VulnerabilityState_def::VisibleWeaponSystemDamage ||
      m_vulnerabilityStates.at(idx).vulnerabilityState == ProjectDataManagement::VulnerabilityState_def::CatastrophicKill)
    return true;
  return false;
}

void DamageModel::setVulnerabilityState(const ProjectDataManagement::VulnerabilityState &state, qint64 simTimeMSec)
{
  const int idx = indexForTime(simTimeMSec);
  if (idx > 0 && m_vulnerabilityStates.at(idx).timeStamp == simTimeMSec)
  {
    // already there...
    if (state == m_vulnerabilityStates.at(idx).vulnerabilityState)
      return;
    m_vulnerabilityStates[idx].vulnerabilityState = state;
  }
  else
  {
    VulnerabilityStateStructWithTimeStamp vssTs;
    vssTs.vulnerabilityState = state;
    vssTs.timeStamp = simTimeMSec;
    m_vulnerabilityStates.insert(idx + 1, std::move(vssTs)); // idx = -1 -> oldest, will become index 0
  }

  while (m_vulnerabilityStates.size() > 10)
    m_vulnerabilityStates.pop_front();
}

void DamageModel::setDamageState(const rpr2::DamageStatusEnum32::ET state, qint64 simTimeMSec)
{
  ProjectDataManagement::VulnerabilityState vs = vulnerabilityStateFromDamageStatus(state);
  setVulnerabilityState(vs, simTimeMSec);
}

ProjectDataManagement::VulnerabilityState DamageModel::vulnerabilityState(qint64 simTimeMSec) const
{
  int idx = indexForTime(simTimeMSec);
  if (idx < 0)
    return ProjectDataManagement::VulnerabilityState_def::CombatReady;
  return m_vulnerabilityStates.at(idx).vulnerabilityState;
}

int DamageModel::indexForTime(qint64 simTimeMSec) const
{
  const int s = m_vulnerabilityStates.size();
  if (simTimeMSec < 0 && s != 0)  // = use current
    return s - 1;

  for (int i = s - 1; i >= 0; --i)
  {
    const auto &tss = m_vulnerabilityStates.at(i);
    if (tss.timeStamp <= simTimeMSec)
      return i;
  }
  return -1;
}

void DamageModel::initTimer()
{
  delete m_timer;
  m_timer = new QTimer(this);
  m_timer->setSingleShot(true);
  m_timer->start(s_waitInterval);
  connect(m_timer, &QTimer::timeout,
          this, [this]()
  {
    emit damageStateChanged();
    m_timer->deleteLater();
    m_timer = nullptr;
  });
}

} // namespace HighLevelArchitecture