Initial commit

Lts/Services/CentralEffectSimulation/Plugins/Buildings/handler_contamination.cpp

@@ -0,0 +1,519 @@
+/**
+  * Handler for player data
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by hjl, SLSE, 2017-02-20
+  */
+
+#include "handler_contamination.h"
+
+#include <CentralEffectSimulation/handler_participant.h>
+#include <CentralEffectSimulation/handler_building_data.h>
+
+#include <QPainterPath>
+#include <QPolygonF>
+
+namespace CesBuildings
+{
+
+HandlerContamination::HandlerContamination(const std::shared_ptr<CentralEffectSimulation::DdsHandler> &ddsHandler,
+                                           QObject *parent)
+
+  : QObject(parent)
+  , m_ddsHandler(ddsHandler)
+  , m_logger(CentralEffectSimulation::getLogger("Plugin.Buildings.Buildings"))
+{
+} // end of ctor()
+//-----------------------------------------------------------------------------
+
+HandlerContamination::~HandlerContamination()
+{
+} // end of dtor()
+//-----------------------------------------------------------------------------
+bool HandlerContamination::init()
+{
+  auto dtcAes = m_ddsHandler->dtcAes();
+  auto ftcBld = m_ddsHandler->ftcBld();
+  auto dtcBld = m_ddsHandler->dtcBld();
+  ftcBld->enableSetBuildingContaminationState();
+
+  ////////////////////////////
+  /// \brief Get 'static' data for all BCContaminations
+  ///
+  dtcAes->waitForHistoricalDataBCContamination(1000);
+  connect(dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::bCContaminationChanged,
+          this, &HandlerContamination::onBCContaminationChanged);
+
+  // Get 'static' data for all BCContaminations
+  {
+    auto cb = [this](const AreaEffectSimulation::BCContamination & bcc)
+    {
+      onBCContaminationChanged(bcc, DataModification::eAdded);
+    };
+    if (!dtcAes->bCContaminations(cb))
+      return false;
+  }
+  ////////////////////////////
+  /// \brief Get 'static' data for all AesItemView
+  ///
+  dtcAes->waitForHistoricalDataAesItemView(1000);
+  connect(dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::aesItemViewChanged,
+          this, &HandlerContamination::onAesItemViewChanged);
+
+  // Get 'static' data for all AesItemView
+  {
+    auto cb = [this](const AreaEffectSimulation::AesItemView & aiv)
+    {
+      onAesItemViewChanged(aiv, DataModification::eAdded);
+    };
+    if (!dtcAes->aesItemViews(cb))
+      return false;
+  }
+
+  ////////////////////////////
+  /// \brief Get data for all Building States
+  ///
+  dtcBld->waitForHistoricalDataBuildingState(1000);
+  connect(dtcBld.get(), &Buildings::Interface::Dtc::buildingStateChanged,
+          this, &HandlerContamination::onBuildingStateChanged);
+
+  // Get 'static' data for all buildingStates
+  {
+    auto cb = [this](const Buildings::BuildingState & bs)
+    {
+      onBuildingStateChanged(bs, DataModification::eAdded);
+    };
+    if (!dtcBld->buildingStates(cb))
+      return false;
+  }
+
+  return true;
+} // end of init()
+//-----------------------------------------------------------------------------
+// ///////////////////////////////////
+// A E S (AreaEffectSimulation)
+// ///////////////////////////////////
+
+void HandlerContamination::onAesItemViewChanged(const AreaEffectSimulation::AesItemView &data, DataModification modType)
+{
+  if (modType != DataModification::eAdded &&
+      modType != DataModification::eModified)
+    return;
+
+  DEBUG_LOG(m_logger) << "Got AesItemView: " << data.effectStateId()
+                      << " data.aesItemId()" << data.aesItemId()
+                      << " data.aesTypeId()" << data.aesTypeId();
+  switch (data.effectStateId().underlying())
+  {
+  case AreaEffectSimulation::AesEffectState_def::EsActivated:
+  {
+    double chargeHeight; // Alle Stockwerke beruecksichtigen
+    double chargeDepression; // Alle Kellerraeume beruecksichtigen
+
+    if (data.aesTypeId() == AreaEffectSimulation::AesType_def::AtNContamination)
+    {
+      chargeHeight = 500.0; // Alle Stockwerke beruecksichtigen
+      chargeDepression = -1000.0; // Alle Kellerraeume beruecksichtigen
+      DEBUG_LOG(m_logger) << "AtNContamination: chargeHeight=" << chargeHeight
+                          << " chargeDepression=" << chargeDepression;
+    }
+    else
+    {
+      chargeHeight = m_aesBCContaminations.value(data.aesItemId()).upperOffset();
+      chargeDepression = m_aesBCContaminations.value(data.aesItemId()).lowerOffset();
+      DEBUG_LOG(m_logger) << "BCContaminations: chargeHeight=" << chargeHeight
+                          << " chargeDepression=" << chargeDepression;
+    }
+
+    if (data.aesTypeId() != AreaEffectSimulation::AesType_def::AtBCContamination
+        && data.aesTypeId() != AreaEffectSimulation::AesType_def::AtNContamination)
+    {
+      DEBUG_LOG(m_logger) << "return1: AesItemView: " << data.effectStateId();
+      return;
+    }
+
+    // Gebaeude die von einem sesshaften Kampfstoff betroffen sind, müssen als kontaminiert gelten.
+    const ProjectDataManagement::VolatilityType volatilityType = m_ddsHandler->volatilityTypeId(data.chargeStruct());
+    if (volatilityType != ProjectDataManagement::VolatilityType_def::Resident
+        && data.aesTypeId() != AreaEffectSimulation::AesType_def::AtNContamination)
+    {
+      DEBUG_LOG(m_logger) << "return2: AesItemView: " << data.effectStateId();
+      return;
+    }
+
+    DEBUG_LOG(m_logger) << "HandlerContamination::onAesItemViewChanged data.aesItemId=" << data.aesItemId();
+    auto dtcIsm = m_ddsHandler->dtcIsm();
+    // Form in UTM-Polygon wandeln
+    int exerciseId = m_ddsHandler->getExerciseId();
+    QPolygonF polygonGeo;
+
+    // Convert Form to UTM
+    for (unsigned int i = 0; i < data.form().size(); i++)
+      polygonGeo.append(QPointF(data.form()[i].lon(), data.form()[i].lat()));
+
+    bool completeEnclosed = true;
+    bool isGroundLevel = false;
+    const QVector<int> &buildingIds = dtcIsm.get()->getBuildingByPolygon(exerciseId, polygonGeo, completeEnclosed, isGroundLevel);
+    DEBUG_LOG(m_logger) << "buildingIds.size=" << buildingIds.size();
+    for (int buildingId : qAsConst(buildingIds))
+    {
+      calculateBuilding(buildingId, data,  chargeHeight, chargeDepression);
+    }
+    //
+    break;
+  }
+  default:
+    break;
+  }
+}
+
+void HandlerContamination::calculateBuilding(int buildingId,
+                                             const AreaEffectSimulation::AesItemView &data,
+                                             double chargeHeight,
+                                             double chargeDepression)
+{
+  auto dtcIsm = m_ddsHandler->dtcIsm();
+  QVector<int> effectedRooms;
+  QVector<int> effectedFloors;
+
+  if (data.aesTypeId() != AreaEffectSimulation::AesType_def::AtBCContamination
+      && data.aesTypeId() != AreaEffectSimulation::AesType_def::AtNContamination)
+  {
+    DEBUG_LOG(m_logger) << "return: NO BC-Contamination AesItemView: " << data.effectStateId();
+    return;
+  }
+
+  const ProjectDataManagement::VolatilityType volatilityType = m_ddsHandler->volatilityTypeId(data.chargeStruct());
+  if (   volatilityType != ProjectDataManagement::VolatilityType_def::Resident
+      && data.aesTypeId() != AreaEffectSimulation::AesType_def::AtNContamination)
+      return;
+
+  DEBUG_LOG(m_logger) << "buildingId=" << buildingId;
+  effectedRooms.clear();
+  effectedFloors = getEffectedFloors(buildingId, chargeHeight, chargeDepression);
+  for (int effectedFloor : qAsConst(effectedFloors))
+    effectedRooms += dtcIsm.get()->getRoomIdsFromFloorId(buildingId, effectedFloor);
+  if (!effectedRooms.empty())
+  {
+    DEBUG_LOG(m_logger) << "effectedRooms.size=" << effectedRooms.size();
+    ProjectDataManagement::VulnerabilityState vulnerabilityState = ProjectDataManagement::VulnerabilityState::CombatReady;
+
+    // [GUEZE-2752] N-Contamination: Only Contamionation inside Range1
+    if (data.aesTypeId() == AreaEffectSimulation::AesType_def::AtNContamination
+        && !isInsideRange1(buildingId,  data.aesItemId()))
+    {
+      DEBUG_LOG(m_logger) << "!isInsideRange1 buildingId=" << buildingId;
+      return;
+    }
+    if (data.aesTypeId() == AreaEffectSimulation::AesType_def::AtBCContamination
+        && !isInsideBCContamination(buildingId,  data.aesItemId()))
+    {
+      DEBUG_LOG(m_logger) << "AtBCContamination !isInsideRange buildingId=" << buildingId << "return";
+      return;
+    }
+    if (data.aesTypeId() == AreaEffectSimulation::AesType_def::AtNContamination
+            && isInsideInnerCircle(buildingId,  data.aesItemId()))
+    {
+        constexpr int TIME_2_SECONDS = 2000;
+        // Only actual explosion not old N-Fields
+        if ( m_ddsHandler->dtcCore()->partitionTime().timeStamp() < (data.effectStart() + TIME_2_SECONDS))
+        {
+            DEBUG_LOG(m_logger) << "VulnerabilityState=CatastrophicKill";
+            vulnerabilityState = ProjectDataManagement::VulnerabilityState::CatastrophicKill;
+        }
+    }
+    DEBUG_LOG(m_logger) << "setBuildingContaminationStateRequest buildingId=" << buildingId
+                        << " data.aesTypeId()=" << data.aesTypeId()
+                        << " isInsideInnerCircle(buildingId,  data.aesItemId()=" << isInsideInnerCircle(buildingId,  data.aesItemId());
+    {
+      DEBUG_LOG(m_logger) << "isInsideInnerCircle buildingId=" << buildingId;
+      setBuildingContaminationStateRequest(buildingId, data.aesItemId(), vulnerabilityState, effectedRooms);
+    }
+  }
+}
+
+// ///////////////////////////////////
+// B L D (Buildings)
+// ///////////////////////////////////
+void HandlerContamination::onBuildingStateChanged(const Buildings::BuildingState &data, DataModification modType)
+{
+
+  if (modType != DataModification::eAdded
+      && modType != DataModification::eModified)
+    return;
+
+  INFO_LOG(m_logger) << "onBuildingStateChanged"
+                     << " id=" << data.id()
+                     << " aesId=" << data.aesId()
+                     << " contaminationStates().size=" << data.contaminationStates().size();
+  // Reset:
+  if (data.contaminationStates().empty())
+    m_contaminationState.remove(data.id());
+  // If a building is reset in an area where there is an active nuclear weapon, it will not be recontaminated -> in this case,
+  // regular checks should be carried out to see if the building needs to be contaminated
+  // Buildings that have been reset or decontaminated will be recontaminated as long as the nuclear weapon is still present
+
+  const auto  aesItemViews  = m_ddsHandler->dtcAes()->aesItemViews();
+  for (const auto &aesItemView : qAsConst(aesItemViews))
+  {
+    if (aesItemView.effectStateId() == AreaEffectSimulation::AesEffectState::EsActivated)
+    {
+      DEBUG_LOG(m_logger) << "Wirkfeld aesItemView.id()=" << aesItemView.id()
+                          << " aesItemView.aesItemId()=" << aesItemView.aesItemId()
+                          << " fuer Gebaeude " << data.id() << " neu berechnen";
+
+      double chargeHeight = 0.0;
+      double chargeDepression = 0.0;
+
+      if (aesItemView.aesTypeId() == AreaEffectSimulation::AesType_def::AtNContamination)
+      {
+        chargeHeight = 500.0; // Alle Stockwerke beruecksichtigen
+        chargeDepression = -1000.0; // Alle Kellerraeume beruecksichtigen
+        DEBUG_LOG(m_logger) << "AtNContamination: chargeHeight=" << chargeHeight
+                            << " chargeDepression=" << chargeDepression;
+      }
+      else
+      {
+        if ( m_aesBCContaminations.contains(aesItemView.aesItemId()))
+        {
+          chargeHeight = m_aesBCContaminations.value(aesItemView.aesItemId()).upperOffset();
+          chargeDepression = m_aesBCContaminations.value(aesItemView.aesItemId()).lowerOffset();
+          DEBUG_LOG(m_logger) << "BCContaminations: chargeHeight=" << chargeHeight
+                              << " chargeDepression=" << chargeDepression;
+        }
+        else
+        {
+          DEBUG_LOG(m_logger) << "BCContaminations: m_aesBCContaminations not contains:"<< aesItemView.aesItemId();
+        }
+      }
+
+      // [GUEZE-2527] Fehler bei A-Waffen und Dekontaminierung
+      auto dtcIsm = m_ddsHandler->dtcIsm();
+      int exerciseId = m_ddsHandler->getExerciseId();
+      QPolygonF polygonGeo;
+      polygonGeo.reserve(aesItemView.form().size());
+      // Convert Form to UTM
+      for (const auto point : aesItemView.form())
+          polygonGeo.append(QPointF(point.lon(), point.lat()));
+      bool completeEnclosed = true;
+      bool isGroundLevel = false;
+
+      const QVector<int> &buildingIds = dtcIsm.get()->getBuildingByPolygon(exerciseId, polygonGeo, completeEnclosed, isGroundLevel);
+      if (buildingIds.contains(data.id() ))
+          calculateBuilding(data.id(), aesItemView, chargeHeight, chargeDepression);
+      else
+          DEBUG_LOG(m_logger) << "Building not in Area BuildingId="  << data.id();
+    }
+  }
+}
+
+
+void HandlerContamination::setBuildingContaminationStateRequest(int buildingId,
+                                                                int aesId,
+                                                                ProjectDataManagement::VulnerabilityState vulnerabilityState,
+                                                                QVector<int> rooms)
+{
+  Buildings::ContaminationState contaminationState;
+
+  contaminationState.aesId(aesId);
+  contaminationState.vulnerabilityState(vulnerabilityState);
+//  contaminationState.vulne
+
+  DEBUG_LOG(m_logger) << "setBuildingContaminationStateRequest"
+                      << " buildingId=" << buildingId
+                      << " aesId=" << aesId
+                      << " vulnerabilityState=" << vulnerabilityState
+                      << " rooms.size=" << rooms.size();
+  contaminationState.rooms().resize(rooms.size());
+  for (int i = 0; i < rooms.size(); i++)
+  {
+    contaminationState.rooms()[i] = rooms[i];
+    contaminationState.vulnerabilityState(vulnerabilityState);
+    DEBUG_LOG(m_logger) << "    room[" << i << "]=" << rooms[i];
+  }
+
+  Buildings::SetBuildingContaminationStateRequest requestContamination(
+    buildingId,
+    contaminationState
+  );
+  // Senden, wenn fuer das Gebaeude noch keine Contamination vorhanden ist.
+  if (!m_contaminationState.contains(buildingId))
+  {
+    DEBUG_LOG(m_logger) << "Neue Kontamination BuildingId=" << buildingId
+                        << " requestContamination aesId=" << requestContamination.contaminationState().aesId();
+
+    m_ddsHandler->ftcBld()->setBuildingContaminationStateRequest(requestContamination, this);
+    m_contaminationState.insert(buildingId, requestContamination);
+    return;
+  }
+  // Senden, wenn sich die Kontamination geaendert hat.
+  Buildings::SetBuildingContaminationStateRequest lastRequestContamination = m_contaminationState.value(buildingId);
+  if (lastRequestContamination != requestContamination)
+  {
+    DEBUG_LOG(m_logger) << "Änderung der Kontamination BuildingId=" << buildingId
+                        << " aesId=" << requestContamination.contaminationState().aesId();
+    m_ddsHandler->ftcBld()->setBuildingContaminationStateRequest(requestContamination, this);
+    m_contaminationState.insert(buildingId, requestContamination);
+    return;
+  }
+  DEBUG_LOG(m_logger) << "Keine Änderung der Kontamination BuildingId=" << buildingId;
+}
+
+QVector<int> HandlerContamination::getEffectedFloors(const int buildingId, const int chargeHeight, const int depression)
+{
+  auto dtcIsm = m_ddsHandler->dtcIsm();
+  DEBUG_LOG(m_logger) << "Contaminated-Building=" << buildingId
+                      << " chargeHeight=" << chargeHeight
+                      << " depression=" << depression;
+
+  const QVector<int> &floorIds = dtcIsm->getFloorIdsFromBuilding(buildingId);
+  QVector<int> effectedFloorIds;
+  effectedFloorIds.reserve(floorIds.size());
+  for (int floorId : qAsConst(floorIds))
+  {
+    double halfFloorHeight = dtcIsm->getHalfFloorHeight(buildingId, floorId);
+    DEBUG_LOG(m_logger) << " floorId=" << floorId
+                        << " halfFloorHeight=" << halfFloorHeight
+                        << " chargeHeight=" << chargeHeight
+                        << " depression=" << depression;
+    if (depression < 0) // Kellerraeme beruecksichtigen
+    {
+      if (halfFloorHeight > depression)
+        DEBUG_LOG(m_logger) << "Checke Obergrenze";
+      else
+      {
+        DEBUG_LOG(m_logger) << "halfFloorHeight > depression floorId=" << floorId << " continue";
+        continue;
+      }
+    }
+    else
+    {
+      if (halfFloorHeight < 0)  // Kellerraeume nicht beruecksichtigen
+      {
+        DEBUG_LOG(m_logger) << "depression ist nicht < 0"
+                            << " Kelleretagen nicht beruecksichtigen floorId=" << floorId << " continue";
+        continue;
+      }
+    }
+
+    if (halfFloorHeight < chargeHeight)
+      effectedFloorIds.append(floorId);
+  }
+  return effectedFloorIds;
+}
+
+void HandlerContamination::onSetBuildingContaminationStateReply(const Core::FunctionReplyObject &replyObject)
+{
+  if (replyObject.error())
+    WARNING_LOG(m_logger) << "Can not send ContaminationStates on building to building service: " << replyObject();
+  else
+    DEBUG_LOG(m_logger) << "onSetBuildingContaminationStateReply for id " << replyObject.id() << " success\n"
+                        << " replyObject.str() = " << replyObject.str();
+}
+
+void HandlerContamination::onBCContaminationChanged(const AreaEffectSimulation::BCContamination &data, DataModification modType)
+{
+  if ((modType == DataModification::eRemoved)
+      || data.isDeleted())
+    m_aesBCContaminations.remove(data.id());
+  else
+    m_aesBCContaminations.insert(data.id(), data);
+}
+
+// Returns true if the building is in the inner circle at the time of impact and should fail as a result.
+// Liefert true, wenn sich das Gebaeude beim Einschlag im inneren Kreis befindet und daraufhin ausfallen soll.
+bool HandlerContamination::isInsideInnerCircle(int buildingId, int aesId)
+{
+  InfrastructureManagement::MainStructureElement mse  = m_ddsHandler->dtcIsm()->mainStructureElement(buildingId);
+  AreaEffectSimulation::NContamination nContamination = m_ddsHandler->dtcAes()->nContamination(aesId);
+
+  DEBUG_LOG(m_logger) << "isInsideInnerCircle borderLengthInner=" << nContamination.borderLengthInner()
+                      << " borderLengthOuter=" << nContamination.borderLengthOuter()
+                      << " impactRadius=" << nContamination.impactRadius();
+
+  int zone = -1;
+  const QPointF impactPositionUtm = CentralEffectSimulation::geographic2Utm(nContamination.impactPosition(), zone);
+  DEBUG_LOG(m_logger) << "impactPositionUtm=" << impactPositionUtm.x() << "/" << impactPositionUtm.y()
+                      << " zone=" << zone;
+  const QPointF buildingPositionUtm = CentralEffectSimulation::geographic2Utm(mse.geoPosition(), zone);
+  DEBUG_LOG(m_logger) << "buildingPositionUtm=" << buildingPositionUtm.x() << "/" << buildingPositionUtm.y();
+
+  double squareDistance = CentralEffectSimulation::getSquareDistance(impactPositionUtm, buildingPositionUtm);
+
+  if (squareDistance < nContamination.impactRadius() * nContamination.impactRadius())
+  {
+    DEBUG_LOG(m_logger) << "isInsideInnerCircle return true";
+    return true;
+  }
+  else
+  {
+    DEBUG_LOG(m_logger) << "isInsideInnerCircle return false";
+    return false;
+  }
+}
+
+// Returns true if the building is in the inner circle at the time of impact and should fail as a result.
+// Liefert true, wenn sich das Gebaeude beim Einschlag im inneren Kreis befindet und daraufhin ausfallen soll.
+bool HandlerContamination::isInsideBCContamination(int buildingId, int aesId)
+{
+  InfrastructureManagement::MainStructureElement mse  = m_ddsHandler->dtcIsm()->mainStructureElement(buildingId);
+  //AreaEffectSimulation::NContamination nContamination = m_ddsHandler->dtcAes()->nContamination(aesId);
+  AreaEffectSimulation::BCContamination bcContamination = m_ddsHandler->dtcAes()->bCContamination(aesId);
+
+  DEBUG_LOG(m_logger) << " impactRadius=" << bcContamination.impactRadius();
+
+  int zone = -1;
+  const QPointF impactPositionUtm = CentralEffectSimulation::geographic2Utm(bcContamination.impactPosition(), zone);
+  DEBUG_LOG(m_logger) << "impactPositionUtm=" << impactPositionUtm.x() << "/" << impactPositionUtm.y()
+                      << " zone=" << zone;
+  const QPointF buildingPositionUtm = CentralEffectSimulation::geographic2Utm(mse.geoPosition(), zone);
+  DEBUG_LOG(m_logger) << "buildingPositionUtm=" << buildingPositionUtm.x() << "/" << buildingPositionUtm.y();
+
+  double squareDistance = CentralEffectSimulation::getSquareDistance(impactPositionUtm, buildingPositionUtm);
+
+  if (squareDistance < bcContamination.impactRadius() * bcContamination.impactRadius())
+  {
+    DEBUG_LOG(m_logger) << "isInsideInnerCircle return true";
+    return true;
+  }
+  else
+  {
+    DEBUG_LOG(m_logger) << "isInsideInnerCircle return false";
+    return false;
+  }
+}
+
+// Returns true if the building is located in range 1 at the time of impact and is to be contaminated as a result.
+// Liefert true, wenn sich das Gebaeude beim Einschlag im Bereich 1 befindet und daraufhin kontaminiert werden soll.
+bool HandlerContamination::isInsideRange1(int buildingId, int aesId)
+{
+  InfrastructureManagement::MainStructureElement mse  = m_ddsHandler->dtcIsm()->mainStructureElement(buildingId);
+  AreaEffectSimulation::NContamination nContamination = m_ddsHandler->dtcAes()->nContamination(aesId);
+
+  DEBUG_LOG(m_logger) << "isInsideRange1 borderLengthInner=" << nContamination.borderLengthInner()
+                      << " borderLengthOuter=" << nContamination.borderLengthOuter()
+                      << " impactRadius=" << nContamination.impactRadius();
+
+  int zone = -1;
+  const QPointF impactPositionUtm = CentralEffectSimulation::geographic2Utm(nContamination.impactPosition(), zone);
+  DEBUG_LOG(m_logger) << "impactPositionUtm=" << impactPositionUtm.x() << "/" << impactPositionUtm.y()
+                      << " zone=" << zone;
+  const QPointF buildingPositionUtm = CentralEffectSimulation::geographic2Utm(mse.geoPosition(), zone);
+  DEBUG_LOG(m_logger) << "buildingPositionUtm=" << buildingPositionUtm.x() << "/" << buildingPositionUtm.y();
+
+  double squareDistance = CentralEffectSimulation::getSquareDistance(impactPositionUtm, buildingPositionUtm);
+
+  if (squareDistance < nContamination.borderLengthInner() * nContamination.borderLengthInner())
+  {
+    DEBUG_LOG(m_logger) << "isInsideRange1 return true";
+    return true;
+  }
+  else
+  {
+    DEBUG_LOG(m_logger) << "isInsideRange1 return false";
+    return false;
+  }
+}
+
+} // namespace CesBuildings