Initial commit

Lts/Services/CentralEffectSimulation/Plugins/Jamming/handler_jamming.cpp

@@ -0,0 +1,235 @@
+/**
+  * Handler for player data
+  * $Id: handler_functional_area.cpp 64453 2025-01-31 12:06:15Z fritsche_h $
+  * $HeadURL: svn://slssvn/TDS/branches/product/features/25_03_etb_uas/Lts/Services/CentralEffectSimulation/Plugins/FunctionalAreas/handler_functional_area.cpp $
+  * $Author: fritsche_h $
+  * Created by gr, SLSE, 2017-02-20
+  */
+
+#include "handler_jamming.h"
+
+#include <QTimer>
+#include <QDateTime>
+#include <QRandomGenerator>
+
+#include <LtsUtilsCore/dds_bitarray.h>
+#include <LtsCoordTrans/lts_coord_trans.h>
+#include <ProjectDataManagement/pdm_enums.hpp>
+
+#include "LtsUtils/LtsUtilsCore/outdated_position.h"
+
+namespace dds
+{
+namespace core
+{
+inline uint qHash(ProjectDataManagement::EventType et)
+{
+  return ::qHash(et.underlying());
+}
+}
+}
+
+namespace CES_JAMMING
+{
+
+
+HandlerJamming::HandlerJamming(const std::shared_ptr<CentralEffectSimulation::DdsHandler> &ddsHandler,
+                                               const std::shared_ptr<CentralEffectSimulation::HandlerParticipant> &participantHandler,
+                                               const std::shared_ptr<CentralEffectSimulation::HandlerBuildingData> &handlerBuildingData,
+                                               QObject *parent)
+  : QObject(parent)
+  , m_ddsHandler(ddsHandler)
+  , m_handlerParticipant(participantHandler)
+  , m_handlerBuildingData(handlerBuildingData)
+  , m_logger(CentralEffectSimulation::getLogger("Plugin.Jamming.HandlerJamming"))
+{
+} // end of ctor()
+//-----------------------------------------------------------------------------
+
+HandlerJamming::~HandlerJamming()
+{
+} // end of dtor()
+//-----------------------------------------------------------------------------
+
+bool HandlerJamming::init()
+{
+
+
+  // TAB FTC
+  m_ddsHandler->ftcTab()->enableDemandInit();
+
+
+//  m_ddsHandler->dtcAes()->enableJammingArea();
+//  connect (m_ddsHandler->dtcAes().get(), &AreaEffectSimulation::Interface::Dtc::jammingAreaChanged,
+//           this, &HandlerJamming::onJammingChanged);
+  // m_ddsHandler->dtcAes()->enableAesItemView();
+  // connect (m_ddsHandler->dtcAes().get(), &AreaEffectSimulation::Interface::Dtc::aesItemViewChanged,
+  //          this, &HandlerJamming::onAesItemViewChanged);
+
+  m_ddsHandler->dtcPpm()->enableParticipantGearEvent();
+  connect (m_ddsHandler->dtcPpm().get(), &ParticipantManagement::Interface::Dtc::participantGearEventChanged,
+           this, &HandlerJamming::onParticipantGearEventChanged);
+
+
+  DEBUG_LOG(m_logger) << "HandlerJamming::init() finished.";
+  return true;
+} // end of init()
+//-----------------------------------------------------------------------------
+
+void HandlerJamming::onParticipantGearEventChanged(const ParticipantManagement::ParticipantGearEvent &data, DataModification modType)
+{
+  ERROR_LOG(m_logger) << "onParticipantGearEventChanged << modType=" << modType
+                       << " originatorId=" << data.participantId()
+                       << " chargeTypeId=" << data.charge().chargeTypeId()
+                       << " gearTypeId=" << data.charge().gearTypeId()
+                       << " isJamming=" << m_ddsHandler->isJamming({data.charge().chargeTypeId(),0,0});
+  // Check, if Munition isJamming
+  // NOTE: igniterType/IgniterFunciton = 0 as long as ParticipantGearEvent does not contain values
+  if (!m_ddsHandler->isJamming({data.charge().chargeTypeId(),0,0}))
+    return;
+  QVector<int> uasIds = m_ddsHandler->dtcPpm()->getUasIds();
+  QVector<int> jammedUasIds;
+  int jammedUasId = 0;
+
+  double radius = m_ddsHandler->dtcPdm()->getMaxRange(data.charge().chargeTypeId(), data.charge().gearTypeId());
+
+  // int radius = 15;
+  DEBUG_LOG(m_logger) << "Radius=" << radius;
+  for ( int uasId : uasIds)
+  {
+    DEBUG_LOG(m_logger) << "uasId=" << uasId;
+    CentralEffectSimulation::HandlerParticipant::CesParticipantData cesParticipantData = m_handlerParticipant->position(uasId);
+    if (!cesParticipantData.positionValid)
+    {
+      DEBUG_LOG(m_logger) << "continue !positionValid participantId=" << uasId;
+      continue;
+    }
+
+    if (LtsUtils::isPositionTimeOutdated(QDateTime::currentMSecsSinceEpoch(), cesParticipantData.sampleTime()))
+    {
+      DEBUG_LOG(m_logger) << "continue positionTime outdated participantId=" << uasId;
+      continue;
+    }
+
+    long distance = m_handlerParticipant->getDistance(data.participantId(), uasId);
+    DEBUG_LOG(m_logger) << "distance = " << distance;
+    if ( distance < radius)
+    {
+      DEBUG_LOG(m_logger) << " Send Jamming to TAB and destroy uasId";
+      //sendCesHitRequest(data.charge().chargeTypeId(), data.participantId(),cesParticipantData);
+      if (cesParticipantData.vulnerabilityState != ProjectDataManagement::VulnerabilityState_def::CatastrophicKill)
+        jammedUasIds.append(uasId);
+    }
+    else
+      DEBUG_LOG(m_logger) << "Not in Radius distance=" << distance
+                           << " radius=" << radius;
+  }
+  // [ETB UASETBUAS-33] Equal distribution of jamming failures
+  // Extension of the CES plugin for jamming to randomly drop out exactly one random drone per shot.
+  // the equal distribution refers to the participant ID of the drone
+  if ( jammedUasIds.size() == 0)
+    return;
+  else
+  {
+    // search for an id from the list with an algorithm that contains an equal distribution
+    jammedUasId = jammedUasIds.at(QRandomGenerator::global()->bounded(jammedUasIds.size() - 1));
+    DEBUG_LOG(m_logger) << "jammedUasId=" << jammedUasId
+                         << " jammedUasIds.size()=" << jammedUasIds.size();
+  }
+
+  CentralEffectSimulation::HandlerParticipant::CesParticipantData cesParticipantData = m_handlerParticipant->position(jammedUasId);
+  sendCesHitRequest(data.charge().chargeTypeId(), data.participantId(),cesParticipantData);
+
+}
+
+
+void HandlerJamming::onSendCesHitReply(const Core::FunctionReplyObject &replyObject)
+{
+  DEBUG_LOG(m_logger) << "onSendCesHitReply for id " << replyObject.id() << " success= " << replyObject.error();
+
+  if (replyObject.error())
+    WARNING_LOG(m_logger) << "Can not send enter/leave Area to participant in training area: " << replyObject();
+
+  // Send next Request, if available
+  if (!m_sendCesHitRequestQueue.isEmpty())
+  {
+    DEBUG_LOG(m_logger) << "m_sendCesAreaActionRequestQueue.size()=" << m_sendCesHitRequestQueue.size();
+    m_sendCesHitRequestQueue.dequeue();
+    // Send next Message
+    if (!m_sendCesHitRequestQueue.isEmpty())
+    {
+      const auto &hr = m_sendCesHitRequestQueue.head();
+      DEBUG_LOG(m_logger) << "sendCesHitRequest: " << hr;
+      m_ddsHandler->ftcTab()->sendCesHitRequest(hr, this);
+    }
+  }
+}
+
+
+
+
+
+// Send via TAB-Proxy to UAS-Proxy
+void HandlerJamming::sendCesHitRequest(const int chargeTypeId,
+                                       const int originatorId,
+                                       const CentralEffectSimulation::HandlerParticipant::CesParticipantData &participantData)
+{
+  qint64 effectTime = m_ddsHandler->currentPartitionTime();
+
+  int remaining = 0;
+
+
+  if (remaining < 0)
+    return;
+
+  DEBUG_LOG(m_logger) << "sendCesHitRequest Settings::calculateCentralAes="
+                      << " insideWlsArea=" << std::boolalpha << participantData.insideWlsArea()
+                      << " participantId=" << participantData.participantId();
+
+  const int equipNo = m_ddsHandler->participantId2EquipNo(participantData.participantId());
+  const int originatorEquimentNumber = m_ddsHandler->participantId2EquipNo(originatorId);
+  const int originatorPartyId = m_handlerParticipant->getParticipantPosition(originatorId).partyId();
+  DEBUG_LOG(m_logger) << " ftc sendCESHit to Participant participantId = " << participantData.participantId()
+                      << " equipNo = " << equipNo
+                      << " chargeTypeId =" << chargeTypeId;
+
+  if (participantData.vulnerabilityState == ProjectDataManagement::VulnerabilityState_def::CatastrophicKill)
+  {
+    DEBUG_LOG(m_logger) << "participantPosition.participantId == 0 CatastrophicKill)";
+    return;
+  }
+
+  const TrainingAreaBase::TabPosition pos(participantData.pos(),
+                                          Core::PositionReportingSource_def::Gps, // irrelevant
+                                          participantData.buildingId(),
+                                          participantData.roomId());
+
+  const int aesId = 0; // not used
+  const int mineId = 0; // not used
+
+  TrainingAreaBase::SendCesHitRequest requestTab(
+    equipNo,                         // equipmentNumber
+    participantData.participantId(), // participantId
+    chargeTypeId,                    // chargeTypeId
+    aesId,                           // aesId
+    originatorEquimentNumber,        // originatorEquipmentNumber
+    remaining,                       // remainEffectPercent ( no protection outside Building )
+    pos,
+    effectTime,                      // effectTime
+    ProjectDataManagement::EventType::Jamming, // EventType
+    originatorPartyId,               // originPartyId
+    mineId
+  );
+  DEBUG_LOG(m_logger) << " participantId=" << participantData.participantId()
+                      << " chargeTypeId=" << chargeTypeId;
+
+  m_sendCesHitRequestQueue.enqueue(requestTab);
+  if (m_sendCesHitRequestQueue.size() == 1)
+  {
+    DEBUG_LOG(m_logger) << "SendCesHitRequest: " << requestTab;
+    m_ddsHandler->ftcTab()->sendCesHitRequest(requestTab, this);
+  }
+} // sendCesHitRequest
+
+
+} // namespace CES_JAMMING