1373 lines
45 KiB
C++
Executable File
1373 lines
45 KiB
C++
Executable File
|
|
|
|
|
|
#include "recv_from_dds_aes.h"
|
|
#include <utility>
|
|
#include "main_handler.h"
|
|
#include "settings.h"
|
|
#include <AreaEffectSimulation/Utils/polygons.h>
|
|
#include <AreaEffectSimulation/aes_translation.h>
|
|
#include <ngldb/db_service_handler.h>
|
|
#include <TrainingAreaBase/tab_fts.h>
|
|
#include <QtGui/QTransform>
|
|
|
|
namespace TrainingAreaBase
|
|
{
|
|
|
|
|
|
|
|
|
|
AesStateHandler::AesStateHandler(MainHandler *mainHandler) : m_dbInterface(mainHandler->dbHandler()->db())
|
|
, m_exerciseId(mainHandler->exerciseId()),
|
|
m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger()) {}
|
|
|
|
|
|
template<>
|
|
void RecvFromDdsAes::txData(const TrainingAreaBase::TetraIcd::DusMineReactivation &tele)
|
|
{
|
|
m_txCallback->txData(tele);
|
|
m_sentAesTelegrams.push_back(new TrainingAreaBase::TetraIcd::DusMineReactivation(tele));
|
|
m_sentAesTelegramsAesIds.push_back(-1);
|
|
m_checkOutdatedTelegramsTimer->start();
|
|
DEBUG_LOG(m_logger) << "Appending " << tele.type() << " to m_sentAesTelegrams";
|
|
}
|
|
|
|
bool AesStateHandler::init()
|
|
{
|
|
const auto cb = [this](const Database::AesId2TaId & item)
|
|
{
|
|
|
|
|
|
m_tetraId2ddsId[item.aesTetraId] = item.aesDdsId;
|
|
m_ddsId2TetraId[item.aesDdsId] = item.aesTetraId;
|
|
DEBUG_LOG(m_logger) << "AES internal DDS id: " << item.aesDdsId << " - tetra id: " << item.aesTetraId;
|
|
if (item.isAvailableInTetra)
|
|
m_aesInTetraAvailable += item.aesTetraId;
|
|
};
|
|
|
|
if (!m_dbInterface->selectByExerciseId(cb, m_exerciseId))
|
|
{
|
|
ERROR_LOG(m_logger) << "Error retrieving data from database!";
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int AesStateHandler::createAesTetraId(int aesDdsId, bool &alreadyExists)
|
|
{
|
|
alreadyExists = false;
|
|
|
|
Database::AesId2TaId aes2Ta;
|
|
aes2Ta.aesTetraId = getAesTetraId(aesDdsId);
|
|
if (aes2Ta.aesTetraId != 0)
|
|
{
|
|
alreadyExists = true;
|
|
return aes2Ta.aesTetraId;
|
|
}
|
|
|
|
aes2Ta.aesDdsId = aesDdsId;
|
|
aes2Ta.isAvailableInTetra = false;
|
|
aes2Ta.exerciseId = m_exerciseId;
|
|
if (!m_dbInterface->insert(aes2Ta))
|
|
{
|
|
WARNING_LOG(m_logger) << "Unable to create a valid area effect simulation id for tetra!";
|
|
return -1;
|
|
}
|
|
|
|
m_tetraId2ddsId[aes2Ta.aesTetraId] = aes2Ta.aesDdsId;
|
|
m_ddsId2TetraId[aes2Ta.aesDdsId] = aes2Ta.aesTetraId;
|
|
|
|
return aes2Ta.aesTetraId;
|
|
}
|
|
|
|
bool AesStateHandler::update(int aesDdsId, int aesTetraId, bool bSentToTetra)
|
|
{
|
|
if (aesTetraId <= 0)
|
|
return false;
|
|
|
|
Database::AesId2TaId aes2Ta;
|
|
aes2Ta.aesTetraId = aesTetraId;
|
|
aes2Ta.aesDdsId = aesDdsId;
|
|
aes2Ta.isAvailableInTetra = bSentToTetra;
|
|
aes2Ta.exerciseId = m_exerciseId;
|
|
if (!m_dbInterface->update(aes2Ta))
|
|
{
|
|
WARNING_LOG(m_logger) << "Unable to update area effect simulation id for tetra in database!";
|
|
return false;
|
|
}
|
|
|
|
if (bSentToTetra)
|
|
m_aesInTetraAvailable += aesTetraId;
|
|
else
|
|
m_aesInTetraAvailable -= aesTetraId;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
RecvFromDdsAes::RecvFromDdsAes(MainHandler *mainHandler,
|
|
const std::shared_ptr<SendToTab> &txCallback,
|
|
QObject *parent)
|
|
: QObject(parent)
|
|
, m_ddsConnector(mainHandler->ddsHandler()->ddsConnector())
|
|
, m_txCallback(txCallback)
|
|
, m_aesStateHandler(new AesStateHandler(mainHandler))
|
|
, m_posHandler(mainHandler->posHandler())
|
|
, m_mainHandler(mainHandler)
|
|
, m_checkOutdatedTelegramsTimer(new QTimer(this))
|
|
, m_sendDusMineReactivtionTimer(new QTimer(this))
|
|
{
|
|
m_checkOutdatedTelegramsTimer->setSingleShot(true);
|
|
m_checkOutdatedTelegramsTimer->setInterval(5000);
|
|
connect(m_checkOutdatedTelegramsTimer, &QTimer::timeout,
|
|
this, &RecvFromDdsAes::onCheckOutdatedTelegrams);
|
|
|
|
|
|
m_sendDusMineReactivtionTimer->setSingleShot(true);
|
|
m_sendDusMineReactivtionTimer->setInterval(200);
|
|
connect(m_sendDusMineReactivtionTimer, &QTimer::timeout,
|
|
this, &RecvFromDdsAes::onSendDusMineReactivationTimeout);
|
|
}
|
|
|
|
RecvFromDdsAes::~RecvFromDdsAes()
|
|
{
|
|
qDeleteAll(m_sentAesTelegrams);
|
|
m_sentAesTelegrams.clear();
|
|
m_dtcAes.reset();
|
|
m_aesStateHandler.reset();
|
|
}
|
|
|
|
bool RecvFromDdsAes::init()
|
|
{
|
|
|
|
if (!m_aesStateHandler->init())
|
|
return false;
|
|
|
|
m_dtcAes = AreaEffectSimulation::Interface::Dtc::create(m_ddsConnector);
|
|
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::airSupportImpactChanged,
|
|
this, &RecvFromDdsAes::onAirSupportImpactChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::bCContaminationChanged,
|
|
this, &RecvFromDdsAes::onBcContaminationChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::explosionAreaChanged,
|
|
this, &RecvFromDdsAes::onExplosionAreaChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::explosionSingleChanged,
|
|
this, &RecvFromDdsAes::onExplosionSingleChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::mineAreaChanged,
|
|
this, &RecvFromDdsAes::onMineAreaChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::nContaminationChanged,
|
|
this, &RecvFromDdsAes::onNContaminationChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::triggeredImpactsChanged,
|
|
this, &RecvFromDdsAes::onTriggeredImpactsChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::dusMineStateChanged,
|
|
this, &RecvFromDdsAes::onDusMineStateChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::functionalAreaChanged,
|
|
this, &RecvFromDdsAes::onFunctionalAreaChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::technicalAreaChanged,
|
|
this, &RecvFromDdsAes::onTechnicalAreaChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::dusSingleMineChanged,
|
|
this, &RecvFromDdsAes::onDusSingleMineChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::gasPipeChanged,
|
|
this, &RecvFromDdsAes::onGasPipeChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::boobyTrapChanged,
|
|
this, &RecvFromDdsAes::onBoobyTrapChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::offRouteMineChanged,
|
|
this, &RecvFromDdsAes::onOffRouteMineChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::explosionClusterChanged,
|
|
this, &RecvFromDdsAes::onExplosionClusterChanged);
|
|
connect(m_dtcAes.get(), &AreaEffectSimulation::Interface::Dtc::effectsChanged,
|
|
this, &RecvFromDdsAes::onEffectsChanged);
|
|
|
|
if (!m_dtcAes->enableAirSupportImpact() ||
|
|
!m_dtcAes->enableBCContamination() ||
|
|
!m_dtcAes->enableExplosionArea() ||
|
|
!m_dtcAes->enableExplosionCluster() ||
|
|
!m_dtcAes->enableEffects() ||
|
|
!m_dtcAes->enableExplosionSingle() ||
|
|
!m_dtcAes->enableMineArea() ||
|
|
!m_dtcAes->enableNContamination() ||
|
|
!m_dtcAes->enableTriggeredImpacts() ||
|
|
!m_dtcAes->enableDusMineState() ||
|
|
!m_dtcAes->enableFunctionalArea() ||
|
|
!m_dtcAes->enableTechnicalArea() ||
|
|
!m_dtcAes->enableDusSingleMine() ||
|
|
!m_dtcAes->enableGasPipe() ||
|
|
!m_dtcAes->enableBoobyTrap() ||
|
|
!m_dtcAes->enableOffRouteMine())
|
|
{
|
|
m_dtcAes.reset();
|
|
return false;
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::init() successful";
|
|
return true;
|
|
}
|
|
|
|
int RecvFromDdsAes::aesChargeId(int aesId) const
|
|
{
|
|
{
|
|
auto it = m_currentBCContaminations.find(aesId);
|
|
if (it != m_currentBCContaminations.end())
|
|
return it->second.chargeStruct().chargeTypeId();
|
|
}
|
|
{
|
|
auto it = m_currentExplosionArea.find(aesId);
|
|
if (it != m_currentExplosionArea.end())
|
|
return it->second.chargeStruct().chargeTypeId();
|
|
}
|
|
{
|
|
auto it = m_currentExplosionCluster.find(aesId);
|
|
if (it != m_currentExplosionCluster.end())
|
|
return it->second.chargeStruct().chargeTypeId();
|
|
}
|
|
{
|
|
auto it = m_currentExplosionSingle.find(aesId);
|
|
if (it != m_currentExplosionSingle.end())
|
|
return it->second.chargeStruct().chargeTypeId();
|
|
}
|
|
{
|
|
auto it = m_currentMineArea.find(aesId);
|
|
if (it != m_currentMineArea.end())
|
|
return it->second.chargeStruct().chargeTypeId();
|
|
}
|
|
{
|
|
auto it = m_currentNContamination.find(aesId);
|
|
if (it != m_currentNContamination.end())
|
|
return it->second.chargeStruct().chargeTypeId();
|
|
}
|
|
{
|
|
auto it = m_currentDusSingleMine.find(aesId);
|
|
if (it != m_currentDusSingleMine.end())
|
|
return it->second.chargeStruct().chargeTypeId();
|
|
}
|
|
{
|
|
auto it = m_currentGasPipes.find(aesId);
|
|
if (it != m_currentGasPipes.end())
|
|
return it->second.chargeStruct().chargeTypeId();
|
|
}
|
|
{
|
|
auto it = m_currentFunctionalArea.find(aesId);
|
|
if (it != m_currentFunctionalArea.end())
|
|
return it->second.chargeStruct().chargeTypeId();
|
|
}
|
|
{
|
|
auto it = m_currentBoobyTraps.find(aesId);
|
|
if (it != m_currentBoobyTraps.end())
|
|
return it->second.chargeStruct().chargeTypeId();
|
|
}
|
|
{
|
|
auto it = m_currentOffRouteMines.find(aesId);
|
|
if (it != m_currentOffRouteMines.end())
|
|
return it->second.chargeStruct().chargeTypeId();
|
|
}
|
|
{
|
|
auto it = m_currentTechnicalArea.find(aesId);
|
|
if (it != m_currentTechnicalArea.end())
|
|
return it->second.chargeStruct().chargeTypeId();
|
|
}
|
|
{
|
|
auto it = m_currentAirSupportImpacts.find(aesId);
|
|
if (it != m_currentAirSupportImpacts.end())
|
|
return it->second.chargeStruct().chargeTypeId();
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
TetraIcd::AreaEffectSimulationType RecvFromDdsAes::aesTypeFromId(int aesId) const
|
|
{
|
|
{
|
|
auto it = m_currentBCContaminations.find(aesId);
|
|
if (it != m_currentBCContaminations.end())
|
|
return TetraIcd::AreaEffectSimulationType::CContamination;
|
|
}
|
|
{
|
|
auto it = m_currentExplosionArea.find(aesId);
|
|
if (it != m_currentExplosionArea.end())
|
|
return TetraIcd::AreaEffectSimulationType::ExplosionArea;
|
|
}
|
|
{
|
|
auto it = m_currentExplosionCluster.find(aesId);
|
|
if (it != m_currentExplosionCluster.end())
|
|
return TetraIcd::AreaEffectSimulationType::ExplosionArea;
|
|
}
|
|
{
|
|
auto it = m_currentExplosionSingle.find(aesId);
|
|
if (it != m_currentExplosionSingle.end())
|
|
return TetraIcd::AreaEffectSimulationType::ExplosionSingle;
|
|
}
|
|
{
|
|
auto it = m_currentMineArea.find(aesId);
|
|
if (it != m_currentMineArea.end())
|
|
return TetraIcd::AreaEffectSimulationType::MineArea;
|
|
}
|
|
{
|
|
auto it = m_currentNContamination.find(aesId);
|
|
if (it != m_currentNContamination.end())
|
|
return TetraIcd::AreaEffectSimulationType::NContamination;
|
|
}
|
|
{
|
|
auto it = m_currentDusSingleMine.find(aesId);
|
|
if (it != m_currentDusSingleMine.end())
|
|
return TetraIcd::AreaEffectSimulationType::DusSingleMineSimulator;
|
|
}
|
|
{
|
|
auto it = m_currentGasPipes.find(aesId);
|
|
if (it != m_currentGasPipes.end())
|
|
return TetraIcd::AreaEffectSimulationType::GasPipeDetonation;
|
|
}
|
|
{
|
|
auto it = m_currentFunctionalArea.find(aesId);
|
|
if (it != m_currentFunctionalArea.end())
|
|
return TetraIcd::AreaEffectSimulationType::FunctionalArea;
|
|
}
|
|
{
|
|
auto it = m_currentOffRouteMines.find(aesId);
|
|
if (it != m_currentOffRouteMines.end())
|
|
return TetraIcd::AreaEffectSimulationType::MineArea;
|
|
}
|
|
{
|
|
auto it = m_currentBoobyTraps.find(aesId);
|
|
if (it != m_currentBoobyTraps.end())
|
|
return TetraIcd::AreaEffectSimulationType::MineArea;
|
|
}
|
|
{
|
|
auto it = m_currentTechnicalArea.find(aesId);
|
|
if (it != m_currentTechnicalArea.end())
|
|
return TetraIcd::AreaEffectSimulationType::TechnicalArea;
|
|
}
|
|
return TetraIcd::AreaEffectSimulationType::Unknown;
|
|
}
|
|
|
|
bool RecvFromDdsAes::sendSingleFireSMArt(const SendCesHitRequest &request)
|
|
{
|
|
AreaEffectSimulation::ExplosionSingle data;
|
|
data.chargeStruct().chargeTypeId(request.chargeTypeId());
|
|
data.effectDuration(1);
|
|
data.effectStart(request.effectTime());
|
|
data.id(request.aesId());
|
|
data.impactPosition(request.position().position());
|
|
data.isDeleted(false);
|
|
data.participantId(request.participantId());
|
|
data.partyId(request.partyId());
|
|
|
|
|
|
bool bAlreadyExists = false;
|
|
const int aesTetraId = m_aesStateHandler->createAesTetraId(request.aesId(), bAlreadyExists);
|
|
|
|
if (!bAlreadyExists)
|
|
{
|
|
WARNING_LOG(m_logger) << "Trying to send a SMArt single fire to training area but it was not created until now... !?";
|
|
bool bOnlyNameChanged;
|
|
dataChanged(data, bOnlyNameChanged);
|
|
}
|
|
|
|
sendCreateEffectSimulation(data, aesTetraId, request.equipmentNumber());
|
|
m_aesStateHandler->update(request.aesId(), aesTetraId, true);
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
template <typename T>
|
|
void RecvFromDdsAes::handleEffectSimulation(const T &data, DataModification modType, TetraIcd::AreaEffectSimulationType aesType)
|
|
{
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::handleEffectSimulation(id=" << data.id()
|
|
<< ", modType: " << static_cast<int>(modType)
|
|
<< ", type=" << static_cast<int>(aesType)
|
|
<< ", name: " << data.name()
|
|
<< ", state: " << data.effectStateId()
|
|
<< ", old state: " << m_currentEffectState.value(data.id()) << ")";
|
|
|
|
if (std::is_same<T, AreaEffectSimulation::ExplosionSingle>::value ||
|
|
std::is_same<T, AreaEffectSimulation::ExplosionArea>::value ||
|
|
std::is_same<T, AreaEffectSimulation::ExplosionCluster>::value
|
|
)
|
|
{
|
|
if (m_mainHandler->pdmHandler()->isSmartChargeType(data.chargeStruct()))
|
|
{
|
|
DEBUG_LOG(m_logger) << "Do not send SMART Single/AreaFire to Tetra as broadcast, hits are send directly.";
|
|
return;
|
|
}
|
|
}
|
|
|
|
switch (modType)
|
|
{
|
|
case DataModification::eAdded:
|
|
case DataModification::eModified:
|
|
case DataModification::eRemoved:
|
|
{
|
|
|
|
if (data.effectStateId() == AreaEffectSimulation::AesEffectState::EsPaused &&
|
|
m_currentEffectState.value(data.id()) != AreaEffectSimulation::AesEffectState::EsPaused)
|
|
{
|
|
const int aesTetraId = m_aesStateHandler->getAesTetraId(data.id());
|
|
if (aesTetraId <= 0)
|
|
{
|
|
|
|
handleSendToTetra(data, aesType);
|
|
}
|
|
|
|
sendPauseEffectSimulation(data.id());
|
|
}
|
|
else if (data.effectStateId() == AreaEffectSimulation::AesEffectState::EsActivated &&
|
|
m_currentEffectState.value(data.id()) == AreaEffectSimulation::AesEffectState::EsPaused)
|
|
{
|
|
|
|
sendResumeEffectSimulation(data);
|
|
}
|
|
else if (!data.effectStart().is_set() ||
|
|
data.effectStart().get() == 0 ||
|
|
data.effectStateId() == AreaEffectSimulation::AesEffectState::EsRemoved ||
|
|
data.effectStateId() == AreaEffectSimulation::AesEffectState::EsExpired)
|
|
{
|
|
|
|
if (modType == DataModification::eAdded)
|
|
{
|
|
bool placeHolder;
|
|
|
|
dataChanged(data, placeHolder);
|
|
}
|
|
|
|
|
|
|
|
sendRemoveEffectSimulation(aesType, data.id());
|
|
resetStartTime(data);
|
|
}
|
|
else
|
|
{
|
|
|
|
|
|
if (!(std::is_same<T, AreaEffectSimulation::FunctionalArea>::value) ||
|
|
(data.effectStateId() == AreaEffectSimulation::AesEffectState::EsActivated))
|
|
handleSendToTetra(data, aesType);
|
|
}
|
|
m_currentEffectState[data.id()] = data.effectStateId();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void RecvFromDdsAes::handleSendToTetra(const T &data, TetraIcd::AreaEffectSimulationType aesType)
|
|
{
|
|
|
|
bool bAlreadyExists = false;
|
|
const int aesTetraId = m_aesStateHandler->createAesTetraId(data.id(), bAlreadyExists);
|
|
|
|
bool bOnlyNameChanged = false;
|
|
|
|
bool bSomethingChanged = false;;
|
|
if (!bAlreadyExists)
|
|
{
|
|
dataChanged(data, bOnlyNameChanged);
|
|
bSomethingChanged = true;
|
|
}
|
|
else
|
|
bSomethingChanged = dataChanged(data, bOnlyNameChanged);
|
|
|
|
|
|
if (bOnlyNameChanged &&
|
|
!std::is_same<T, AreaEffectSimulation::GasPipe>::value &&
|
|
!std::is_same<T, AreaEffectSimulation::TechnicalArea>::value)
|
|
{
|
|
sendModifyEffectSimulationName(aesType,
|
|
m_aesStateHandler->getAesTetraId(data.id()),
|
|
data.name(),
|
|
data.id());
|
|
m_aesStateHandler->update(data.id(), aesTetraId, true);
|
|
}
|
|
else if (bSomethingChanged)
|
|
{
|
|
sendCreateEffectSimulation(data, aesTetraId);
|
|
m_aesStateHandler->update(data.id(), aesTetraId, true);
|
|
}
|
|
}
|
|
|
|
void RecvFromDdsAes::onAirSupportImpactChanged(const AreaEffectSimulation::AirSupportImpact &data, DataModification modType)
|
|
{
|
|
|
|
handleEffectSimulation(data, modType, TetraIcd::AreaEffectSimulationType::ExplosionSingle);
|
|
}
|
|
|
|
void RecvFromDdsAes::onBcContaminationChanged(const AreaEffectSimulation::BCContamination &data, DataModification modType)
|
|
{
|
|
handleEffectSimulation(data, modType, TetraIcd::AreaEffectSimulationType::CContamination);
|
|
}
|
|
|
|
void RecvFromDdsAes::onExplosionAreaChanged(const AreaEffectSimulation::ExplosionArea &data, DataModification modType)
|
|
{
|
|
handleEffectSimulation(data, modType, TetraIcd::AreaEffectSimulationType::ExplosionArea);
|
|
}
|
|
|
|
void RecvFromDdsAes::onExplosionSingleChanged(const AreaEffectSimulation::ExplosionSingle &data, DataModification modType)
|
|
{
|
|
handleEffectSimulation(data, modType, TetraIcd::AreaEffectSimulationType::ExplosionSingle);
|
|
}
|
|
|
|
void RecvFromDdsAes::onMineAreaChanged(const AreaEffectSimulation::MineArea &data, DataModification modType)
|
|
{
|
|
handleEffectSimulation(data, modType, TetraIcd::AreaEffectSimulationType::MineArea);
|
|
|
|
|
|
auto it = m_temporarySingleMineState.find(data.id());
|
|
if (it != m_temporarySingleMineState.end())
|
|
{
|
|
onTriggeredImpactsChanged(it->second, DataModification::eModified);
|
|
m_temporarySingleMineState.erase(data.id());
|
|
}
|
|
}
|
|
|
|
void RecvFromDdsAes::onNContaminationChanged(const AreaEffectSimulation::NContamination &data, DataModification modType)
|
|
{
|
|
handleEffectSimulation(data, modType, TetraIcd::AreaEffectSimulationType::NContamination);
|
|
}
|
|
|
|
void RecvFromDdsAes::onFunctionalAreaChanged(const AreaEffectSimulation::FunctionalArea &data, DataModification modType)
|
|
{
|
|
handleEffectSimulation(data, modType, TetraIcd::AreaEffectSimulationType::FunctionalArea);
|
|
}
|
|
|
|
void RecvFromDdsAes::onTechnicalAreaChanged(const AreaEffectSimulation::TechnicalArea &data, DataModification modType)
|
|
{
|
|
handleEffectSimulation(data, modType, TetraIcd::AreaEffectSimulationType::TechnicalArea);
|
|
}
|
|
|
|
void RecvFromDdsAes::onTriggeredImpactsChanged(const AreaEffectSimulation::TriggeredImpacts &data, DataModification modType)
|
|
{
|
|
if (modType == DataModification::eRemoved)
|
|
return;
|
|
if (data.aesTypeId() != AreaEffectSimulation::AesType::AtMineAreaSingleMines)
|
|
return;
|
|
|
|
|
|
if (data.aesItemId() == 0)
|
|
return;
|
|
|
|
|
|
bool completeUntriggered = true;
|
|
for (size_t i = 0; i < data.bitfield().size() && completeUntriggered; ++i)
|
|
{
|
|
if ((i + 1) * 8 <= static_cast<unsigned long>(data.impactCount()))
|
|
{
|
|
if (data.bitfield().at(i) != 0xFF)
|
|
completeUntriggered = false;
|
|
}
|
|
else
|
|
{
|
|
uint8_t endMask = 0;
|
|
for (uint32_t j = 0; j < (static_cast<unsigned long>(data.impactCount()) - i * 8); ++j)
|
|
endMask |= 0x80 >> j;
|
|
|
|
if (data.bitfield().at(i) != endMask)
|
|
completeUntriggered = false;
|
|
}
|
|
}
|
|
if (completeUntriggered)
|
|
return;
|
|
|
|
|
|
auto it = m_currentMineArea.find(data.aesItemId());
|
|
if (it != m_currentMineArea.end())
|
|
{
|
|
const auto &mineArea = it->second;
|
|
if (mineArea.isDus() || mineArea.isConcrete())
|
|
{
|
|
INFO_LOG(m_logger) << "Not publishing mineArea single state for " << data.aesItemId() << " - is a DUS mineArea";
|
|
return;
|
|
}
|
|
|
|
switch (mineArea.effectStateId().underlying())
|
|
{
|
|
case AreaEffectSimulation::AesEffectState::EsError:
|
|
case AreaEffectSimulation::AesEffectState::EsExpired:
|
|
case AreaEffectSimulation::AesEffectState::EsRemoved:
|
|
case AreaEffectSimulation::AesEffectState::EsUnknown:
|
|
{
|
|
INFO_LOG(m_logger) << "Not publishing mineArea single state for " << data.aesItemId() << " - with state " << AreaEffectSimulation::toString(mineArea.effectStateId());
|
|
return;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
INFO_LOG(m_logger) << "Storing mineArea single state, as we dont have the corresponding mineArea yet aesId" << data.aesItemId();
|
|
m_temporarySingleMineState[data.aesItemId()] = data;
|
|
return;
|
|
}
|
|
|
|
TetraIcd::MineAreaSingleMineState out;
|
|
|
|
out.aesDdsId = data.aesItemId();
|
|
|
|
out.mineCount = data.impactCount();
|
|
out.mineState.reserve(data.bitfield().size());
|
|
for (const auto &c : data.bitfield())
|
|
out.mineState.push_back(c);
|
|
|
|
txData(out);
|
|
}
|
|
|
|
void RecvFromDdsAes::onDusMineStateChanged(const AreaEffectSimulation::DusMineState &data, DataModification modType)
|
|
{
|
|
if (modType == DataModification::eRemoved)
|
|
return;
|
|
|
|
const auto &vec = data.mines();
|
|
if (vec.size() == 0)
|
|
return;
|
|
|
|
|
|
for (const auto &mine : vec)
|
|
{
|
|
|
|
|
|
if (!m_mainHandler->pdmHandler()->isReactivatableChargeType({mine.chargeTypeId(), 0,0}))
|
|
continue;
|
|
|
|
|
|
if (mine != m_allReactivatableDusMines.value(mine.eqId()))
|
|
{
|
|
|
|
if (!mine.triggered() &&
|
|
m_allReactivatableDusMines.contains(mine.eqId()) && m_allReactivatableDusMines.value(mine.eqId()).triggered()
|
|
)
|
|
m_minesToSend << mine.eqId();
|
|
|
|
m_allReactivatableDusMines.insert(mine.eqId(), mine);
|
|
}
|
|
}
|
|
|
|
if (!m_minesToSend.isEmpty())
|
|
m_sendDusMineReactivtionTimer->start();
|
|
else
|
|
INFO_LOG(m_logger) << "Nothing changed in DusMineState of MineArea: " << data.id();
|
|
}
|
|
|
|
void RecvFromDdsAes::onSendDusMineReactivationTimeout()
|
|
{
|
|
TetraIcd::DusMineReactivation out;
|
|
out.dusSerialNumbers.reserve(m_minesToSend.size());
|
|
for (const auto &mineId : std::as_const(m_minesToSend))
|
|
{
|
|
m_allReactivatableDusMines[mineId].triggered(false);
|
|
out.dusSerialNumbers.push_back(mineId);
|
|
}
|
|
m_minesToSend.clear();
|
|
INFO_LOG(m_logger) << "Reactivating " << out.dusSerialNumbers.size() << " mines";
|
|
txData(out);
|
|
}
|
|
|
|
void RecvFromDdsAes::onDusSingleMineChanged(const AreaEffectSimulation::DusSingleMine &data, DataModification modType)
|
|
{
|
|
handleEffectSimulation(data, modType, TetraIcd::AreaEffectSimulationType::DusSingleMineSimulator);
|
|
}
|
|
|
|
void RecvFromDdsAes::onGasPipeChanged(const AreaEffectSimulation::GasPipe &data, DataModification modType)
|
|
{
|
|
handleEffectSimulation(data, modType, TetraIcd::AreaEffectSimulationType::DusSingleMineSimulator);
|
|
}
|
|
|
|
void RecvFromDdsAes::onBoobyTrapChanged(const AreaEffectSimulation::BoobyTrap &data, DataModification modType)
|
|
{
|
|
Q_UNUSED(modType);
|
|
fillCentralChangesTable(data);
|
|
}
|
|
|
|
void RecvFromDdsAes::onOffRouteMineChanged(const AreaEffectSimulation::OffRouteMine &data, DataModification modType)
|
|
{
|
|
Q_UNUSED(modType);
|
|
fillCentralChangesTable(data);
|
|
}
|
|
|
|
void RecvFromDdsAes::onExplosionClusterChanged(const AreaEffectSimulation::ExplosionCluster &data, DataModification modType)
|
|
{
|
|
handleEffectSimulation(data, modType, TetraIcd::AreaEffectSimulationType::ExplosionArea);
|
|
}
|
|
|
|
template<typename T, typename S>
|
|
void setCommonParams(T &out, const S &in, const int aesTetraId)
|
|
{
|
|
out.aesDdsId = in.id();
|
|
Q_UNUSED(aesTetraId);
|
|
|
|
out.name = in.name();
|
|
out.partyId = in.partyId().is_set() ? in.partyId().get() : 0;
|
|
}
|
|
|
|
template<typename T, typename S>
|
|
void setCommonCombatParams(T &out, const S &in, const int aesTetraId)
|
|
{
|
|
setCommonParams(out, in, aesTetraId);
|
|
out.effectStart = in.effectStart().is_set() ? in.effectStart().get() : 0;
|
|
out.effectDuration = in.effectDuration();
|
|
}
|
|
|
|
|
|
void RecvFromDdsAes::onEffectsChanged(const AreaEffectSimulation::Effects &data, DataModification modType)
|
|
{
|
|
if (modType == DataModification::eRemoved)
|
|
return;
|
|
|
|
|
|
|
|
|
|
|
|
if (data.aesTypeId().underlying() != AreaEffectSimulation::AesType_def::AtExplosionClusterSingleExplosions)
|
|
return;
|
|
|
|
const int aesItemId = data.aesItemId();
|
|
if (aesItemId <= 0)
|
|
return;
|
|
|
|
|
|
const AreaEffectSimulation::ExplosionCluster &aes = m_dtcAes->explosionCluster(aesItemId);
|
|
if (aes.id() != aesItemId)
|
|
return;
|
|
|
|
|
|
const bool bIsLaserGuidable = m_mainHandler->pdmHandler()->isLaserGuidable(aes.chargeStruct());
|
|
if (!bIsLaserGuidable)
|
|
return;
|
|
|
|
|
|
|
|
|
|
const std::vector<AreaEffectSimulation::SingleEffect> &singleEffectsRef = data.singleEffects();
|
|
|
|
if (!singleEffectsRef.empty())
|
|
{
|
|
|
|
bool bAlreadyExists = false;
|
|
const int aesTetraId = m_aesStateHandler->createAesTetraId(aesItemId, bAlreadyExists);
|
|
|
|
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::onEffectsChanged(Effects, "
|
|
<< aesTetraId << ")";
|
|
TetraIcd::CreateAreaExplosion cAes;
|
|
|
|
setCommonCombatParams(cAes, aes, aesTetraId);
|
|
if(cAes.effectStart > 0)
|
|
{
|
|
qint64 delayMSec = Settings::explosionToEffectDelayInMSec();
|
|
if (delayMSec < 0)
|
|
delayMSec = 3000;
|
|
cAes.effectStart += (delayMSec);
|
|
}
|
|
|
|
|
|
const AreaEffectSimulation::SingleEffect &firstSingleEffect = singleEffectsRef.front();
|
|
const Core::GeoPosition &fsePosition = firstSingleEffect.position();
|
|
cAes.relCorner = m_posHandler->geographicToRelative(fsePosition);
|
|
|
|
cAes.width = qRound(aes.area().width());
|
|
cAes.height = qRound(aes.area().height());
|
|
cAes.rotationAngle = aes.area().rotation();
|
|
cAes.mhpRotation = aes.mhpRotation();
|
|
cAes.mhpWidth = aes.mhpWidth();
|
|
cAes.mhpLength = aes.mhpLength();
|
|
cAes.impactCount = aes.impactCount();
|
|
cAes.impactEdgeLength = qRound(pdm()->impactEdgeLength(aes.chargeStruct()));
|
|
cAes.hazardDistance = m_mainHandler->pdmHandler()->hazardDistance(aes.chargeStruct());
|
|
|
|
std::vector<TetraIcd::RelativePosition> &mhPointsRef = cAes.mhPoints;
|
|
mhPointsRef.clear();
|
|
mhPointsRef.reserve(aes.mhPoints().size());
|
|
for (const Core::GeoPosition2D &pos : std::as_const(aes.mhPoints()))
|
|
mhPointsRef.emplace_back(m_posHandler->geographicToRelative(pos, 0));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cAes.chargeTypeId = 254;
|
|
|
|
txData(cAes);
|
|
}
|
|
}
|
|
|
|
void RecvFromDdsAes::sendCreateEffectSimulation(const AreaEffectSimulation::AirSupportImpact &aes, int aesTetraId)
|
|
{
|
|
if (aes.isCentral())
|
|
{
|
|
sendRemoveEffectSimulation(TetraIcd::AreaEffectSimulationType::ExplosionSingle, aes.id());
|
|
return;
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendCreateEffectSimulation(AirSupportImpact, "
|
|
<< aesTetraId << ")";
|
|
TetraIcd::CreateSingleExplosion cAes;
|
|
|
|
setCommonCombatParams(cAes, aes, aesTetraId);
|
|
|
|
cAes.header.equipmentNumber = 0;
|
|
cAes.relEffectPosition = m_posHandler->geographicToRelative(aes.impactPosition(), 0);
|
|
|
|
|
|
const auto chargeType(pdm()->chargeTypeFromId(aes.chargeStruct().chargeTypeId()));
|
|
cAes.chargeTypeId = chargeType.legacyId() > 0 ? chargeType.legacyId() : chargeType.id();
|
|
|
|
cAes.effectDiameter = qRound(2 * pdm()->impactRadius(aes.chargeStruct()));
|
|
|
|
if (cAes.chargeTypeId <= 0)
|
|
return;
|
|
|
|
txData(cAes);
|
|
}
|
|
|
|
void RecvFromDdsAes::sendCreateEffectSimulation(const AreaEffectSimulation::BCContamination &aes, int aesTetraId)
|
|
{
|
|
if (aes.isCentral())
|
|
{
|
|
sendRemoveEffectSimulation(TetraIcd::AreaEffectSimulationType::CContamination, aes.id());
|
|
return;
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendCreateEffectSimulation(BCContamination, "
|
|
<< aesTetraId << ")";
|
|
TetraIcd::CreateCContamination cAes;
|
|
cAes.expansionFactor = pdm()->dtc()->expansionFactor(aes.chargeStruct().chargeTypeId(),
|
|
aes.chargeStruct().igniterTypeId(),
|
|
aes.chargeStruct().igniterFunctionId());
|
|
|
|
setCommonCombatParams(cAes, aes, aesTetraId);
|
|
cAes.relEffectPosition = m_posHandler->geographicToRelative(aes.impactPosition(), 0);
|
|
cAes.effectRadius = qRound(aes.impactRadius());
|
|
cAes.propagationDirection = aes.propagationDirection();
|
|
cAes.windSpeed = qRound(aes.windSpeed());
|
|
cAes.validityTimeWind = aes.weatherTimestamp();
|
|
cAes.relPositionValidityTimeWind = m_posHandler->geographicToRelative(aes.weatherPosition(), 0);
|
|
|
|
|
|
const auto chargeType(pdm()->chargeTypeFromId(aes.chargeStruct().chargeTypeId()));
|
|
cAes.chargeTypeId = chargeType.legacyId() > 0 ? chargeType.legacyId() : chargeType.id();
|
|
|
|
switch (pdm()->dtc()->volatilityTypeId(aes.chargeStruct().chargeTypeId(),
|
|
aes.chargeStruct().igniterTypeId(),
|
|
aes.chargeStruct().igniterFunctionId()).underlying())
|
|
{
|
|
case ProjectDataManagement::VolatilityType::Floating:
|
|
cAes.volatility = TetraIcd::CreateCContamination::Volatiliy::Floating;
|
|
break;
|
|
case ProjectDataManagement::VolatilityType::Resident:
|
|
cAes.volatility = TetraIcd::CreateCContamination::Volatiliy::Resident;
|
|
break;
|
|
default:
|
|
cAes.volatility = TetraIcd::CreateCContamination::Volatiliy::Resident;
|
|
break;
|
|
}
|
|
|
|
if (cAes.chargeTypeId <= 0)
|
|
return;
|
|
|
|
txData(cAes);
|
|
}
|
|
|
|
void RecvFromDdsAes::sendCreateEffectSimulation(const AreaEffectSimulation::ExplosionArea &aes, int aesTetraId)
|
|
{
|
|
if (aes.isCentral())
|
|
{
|
|
sendRemoveEffectSimulation(TetraIcd::AreaEffectSimulationType::ExplosionArea, aes.id());
|
|
return;
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendCreateEffectSimulation(ExplosionArea, "
|
|
<< aesTetraId << ")";
|
|
TetraIcd::CreateAreaExplosion cAes;
|
|
|
|
setCommonCombatParams(cAes, aes, aesTetraId);
|
|
cAes.relCorner = m_posHandler->geographicToRelative(aes.area().cornerBottomLeft(), 0);
|
|
cAes.width = qRound(aes.area().width());
|
|
cAes.height = qRound(aes.area().height());
|
|
cAes.rotationAngle = aes.area().rotation();
|
|
cAes.impactCount = aes.cannonCount() * aes.cannonRounds();
|
|
cAes.impactEdgeLength = qRound(pdm()->impactEdgeLength(aes.chargeStruct()));
|
|
cAes.hazardDistance = m_mainHandler->pdmHandler()->hazardDistance(aes.chargeStruct());
|
|
|
|
|
|
const auto chargeType(pdm()->chargeTypeFromId(aes.chargeStruct().chargeTypeId()));
|
|
cAes.chargeTypeId = chargeType.legacyId() > 0 ? chargeType.legacyId() : chargeType.id();
|
|
|
|
if (cAes.chargeTypeId <= 0)
|
|
return;
|
|
|
|
txData(cAes);
|
|
}
|
|
|
|
void RecvFromDdsAes::sendCreateEffectSimulation(const AreaEffectSimulation::ExplosionCluster &aes, int aesTetraId)
|
|
{
|
|
|
|
const bool bIsLaserGuidable = m_mainHandler->pdmHandler()->isLaserGuidable(aes.chargeStruct());
|
|
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendCreateEffectSimulation "
|
|
<< ", aes " << aes
|
|
<< ", bIsLaserGuidable " << bIsLaserGuidable;
|
|
|
|
if (bIsLaserGuidable)
|
|
{
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
if (aes.isCentral())
|
|
{
|
|
sendRemoveEffectSimulation(TetraIcd::AreaEffectSimulationType::ExplosionArea, aes.id());
|
|
return;
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendCreateEffectSimulation(ExplosionArea, "
|
|
<< aesTetraId << ")";
|
|
TetraIcd::CreateAreaExplosion cAes;
|
|
|
|
setCommonCombatParams(cAes, aes, aesTetraId);
|
|
|
|
|
|
cAes.relCorner = m_posHandler->geographicToRelative(aes.area().cornerBottomLeft(), 0);
|
|
cAes.width = qRound(aes.area().width());
|
|
cAes.height = qRound(aes.area().height());
|
|
cAes.rotationAngle = aes.area().rotation();
|
|
cAes.mhpRotation = aes.mhpRotation();
|
|
cAes.mhpWidth = aes.mhpWidth();
|
|
cAes.mhpLength = aes.mhpLength();
|
|
cAes.impactCount = aes.impactCount();
|
|
cAes.impactEdgeLength = qRound(pdm()->impactEdgeLength(aes.chargeStruct()));
|
|
cAes.impactRadius = m_mainHandler->pdmHandler()->impactRadius(aes.chargeStruct());
|
|
std::vector<TetraIcd::RelativePosition> &mhPointsRef = cAes.mhPoints;
|
|
mhPointsRef.clear();
|
|
mhPointsRef.reserve(aes.mhPoints().size());
|
|
for (const Core::GeoPosition2D &pos : std::as_const(aes.mhPoints()))
|
|
mhPointsRef.emplace_back(m_posHandler->geographicToRelative(pos, 0));
|
|
|
|
int chargeTypeId = 0;
|
|
const auto chargeType(pdm()->chargeTypeFromId(aes.chargeStruct().chargeTypeId()));
|
|
chargeTypeId = pdm()->legacyChargeTypeIgniterType(aes.chargeStruct().chargeTypeId(), aes.chargeStruct().igniterTypeId(), aes.chargeStruct().igniterFunctionId());
|
|
|
|
|
|
|
|
if (chargeTypeId > 0)
|
|
cAes.chargeTypeId = chargeTypeId;
|
|
else
|
|
{
|
|
cAes.chargeTypeId = chargeType.legacyId() > 0 ? chargeType.legacyId() : chargeType.id();
|
|
}
|
|
|
|
if (cAes.chargeTypeId <= 0)
|
|
return;
|
|
|
|
txData(cAes);
|
|
}
|
|
|
|
void RecvFromDdsAes::sendCreateEffectSimulation(const AreaEffectSimulation::ExplosionSingle &aes, int aesTetraId, int equipmentNumber)
|
|
{
|
|
if (aes.isCentral())
|
|
{
|
|
sendRemoveEffectSimulation(TetraIcd::AreaEffectSimulationType::ExplosionSingle, aes.id());
|
|
return;
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendCreateEffectSimulation(ExplosionSingle, "
|
|
<< aesTetraId << ")";
|
|
TetraIcd::CreateSingleExplosion cAes;
|
|
|
|
setCommonCombatParams(cAes, aes, aesTetraId);
|
|
cAes.header.equipmentNumber = equipmentNumber;
|
|
cAes.relEffectPosition = m_posHandler->geographicToRelative(aes.impactPosition(), 0);
|
|
cAes.effectDiameter = qRound(2 * pdm()->impactRadius(aes.chargeStruct()));
|
|
|
|
|
|
const auto chargeType(pdm()->chargeTypeFromId(aes.chargeStruct().chargeTypeId()));
|
|
cAes.chargeTypeId = chargeType.legacyId() > 0 ? chargeType.legacyId() : chargeType.id();
|
|
|
|
if (cAes.chargeTypeId <= 0)
|
|
return;
|
|
|
|
txData(cAes);
|
|
}
|
|
|
|
void RecvFromDdsAes::sendCreateEffectSimulation(const AreaEffectSimulation::MineArea &aes, int aesTetraId)
|
|
{
|
|
if (aes.isCentral())
|
|
{
|
|
sendRemoveEffectSimulation(TetraIcd::AreaEffectSimulationType::MineArea, aes.id());
|
|
return;
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendCreateEffectSimulation(MineArea, "
|
|
<< aesTetraId << ")";
|
|
TetraIcd::CreateMineArea cAes;
|
|
|
|
setCommonCombatParams(cAes, aes, aesTetraId);
|
|
|
|
|
|
|
|
cAes.layingDepth = aes.width();
|
|
cAes.layingDensity = aes.density();
|
|
|
|
|
|
const auto chargeType(pdm()->chargeTypeFromId(aes.chargeStruct().chargeTypeId()));
|
|
cAes.chargeTypeId = chargeType.legacyId() > 0 ? chargeType.legacyId() : chargeType.id();
|
|
|
|
TetraIcd::MineAreaSegment segment;
|
|
cAes.segments.reserve(aes.segments().size());
|
|
for (size_t i = 0; i < aes.segments().size(); ++i)
|
|
{
|
|
const AreaEffectSimulation::MineSegment &s = aes.segments().at(i);
|
|
if (aes.isCenterLine())
|
|
{
|
|
segment.relStart = m_posHandler->geographicToRelative(s.positionStart(), 0);
|
|
segment.relEnd = m_posHandler->geographicToRelative(s.positionEnd(), 0);
|
|
}
|
|
else
|
|
{
|
|
const QPointF relStart = m_posHandler->geographicToRelativePointF(s.positionStart());
|
|
const QPointF relEnd = m_posHandler->geographicToRelativePointF(s.positionEnd());
|
|
const QLineF line({relStart.x(), relStart.y()}, {relEnd.x(), relEnd.y()});
|
|
DEBUG_LOG(m_logger) << "relStart: x: " << relStart.x() << ", y: " << relStart.y();
|
|
DEBUG_LOG(m_logger) << "relEnd: x: " << relEnd.x() << ", y: " << relEnd.y();
|
|
QTransform trans;
|
|
trans.rotate(0-line.angle());
|
|
const QPointF ofs = trans.map(QPointF(aes.width() / 2, 0));
|
|
DEBUG_LOG(m_logger) << "ofs: x: " << ofs.x() << ", y: " << ofs.y();
|
|
|
|
segment.relStart.offsetX = qRound(relStart.x() + ofs.y());
|
|
segment.relStart.offsetY = qRound(relStart.y() - ofs.x());
|
|
segment.relEnd.offsetX = qRound(relEnd.x() + ofs.y());
|
|
segment.relEnd.offsetY = qRound(relEnd.y() - ofs.x());
|
|
|
|
DEBUG_LOG(m_logger) << "start offset: x: " << segment.relStart.offsetX << ", y: " << segment.relStart.offsetY;
|
|
DEBUG_LOG(m_logger) << "end offset: x: " << segment.relEnd.offsetX << ", y: " << segment.relEnd.offsetY;
|
|
}
|
|
cAes.segments.push_back(segment);
|
|
}
|
|
|
|
if (cAes.chargeTypeId <= 0)
|
|
return;
|
|
|
|
txData(cAes);
|
|
}
|
|
|
|
void RecvFromDdsAes::sendCreateEffectSimulation(const AreaEffectSimulation::NContamination &aes, int aesTetraId)
|
|
{
|
|
if (aes.isCentral())
|
|
{
|
|
sendRemoveEffectSimulation(TetraIcd::AreaEffectSimulationType::NContamination, aes.id());
|
|
return;
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendCreateEffectSimulation(NContamination, "
|
|
<< aesTetraId << ")";
|
|
TetraIcd::CreateNContamination cAes;
|
|
|
|
setCommonCombatParams(cAes, aes, aesTetraId);
|
|
cAes.relEffectPosition = m_posHandler->geographicToRelative(aes.impactPosition(), 0);
|
|
cAes.innerRadius = qRound(aes.impactRadius());
|
|
cAes.borderLengthInner = qRound(aes.borderLengthInner());
|
|
cAes.borderLengthOuter = qRound(aes.borderLengthOuter());
|
|
cAes.spanAngle = aes.spanAngle();
|
|
cAes.rotationAngle = aes.rotationAngle();
|
|
|
|
cAes.chargeTypeId = aes.chargeStruct().chargeTypeId();
|
|
|
|
txData(cAes);
|
|
}
|
|
|
|
void RecvFromDdsAes::sendCreateEffectSimulation(const AreaEffectSimulation::FunctionalArea &aes, int aesTetraId)
|
|
{
|
|
if (aes.isCentral())
|
|
{
|
|
sendRemoveEffectSimulation(TetraIcd::AreaEffectSimulationType::FunctionalArea, aes.id());
|
|
return;
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendCreateEffectSimulation(FunctionalArea, "
|
|
<< aesTetraId << ")";
|
|
TetraIcd::CreateFunctionalArea fAes;
|
|
|
|
setCommonParams(fAes, aes, aesTetraId);
|
|
fAes.relEffectPosition = m_posHandler->geographicToRelative(aes.area().cornerBottomLeft(), 0);
|
|
fAes.width = qRound(aes.area().width());
|
|
fAes.height = qRound(aes.area().height());
|
|
fAes.deconMode = static_cast<TetraIcd::FunctionalAreaOperatingMode>(aes.deconMode().underlying());
|
|
fAes.deconTimeout = aes.deconTime();
|
|
fAes.maintenanceMode = static_cast<TetraIcd::FunctionalAreaOperatingMode>(aes.maintMode().underlying());
|
|
fAes.maintenanceTimeout = aes.maintTime();
|
|
fAes.medicalMode = static_cast<TetraIcd::FunctionalAreaOperatingMode>(aes.medicMode().underlying());
|
|
fAes.medicalTimeout = aes.medicTime();
|
|
|
|
txData(fAes);
|
|
}
|
|
|
|
void RecvFromDdsAes::sendCreateEffectSimulation(const AreaEffectSimulation::TechnicalArea &aes, int aesTetraId)
|
|
{
|
|
if (aes.isCentral())
|
|
{
|
|
sendRemoveEffectSimulation(TetraIcd::AreaEffectSimulationType::TechnicalArea, aes.id());
|
|
return;
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendCreateEffectSimulation(TechnicalArea, "
|
|
<< aesTetraId << ")";
|
|
TetraIcd::TechnicalArea fAes;
|
|
|
|
fAes.aesDdsId = aes.id();
|
|
|
|
fAes.name = aes.name();
|
|
fAes.taType = static_cast<TetraIcd::TechnicalArea::Type>(aes.type().underlying());
|
|
fAes.relCorner = m_posHandler->geographicToRelative(aes.area().cornerBottomLeft(), 0);
|
|
fAes.width = qRound(aes.area().width());
|
|
fAes.height = qRound(aes.area().height());
|
|
|
|
txData(fAes);
|
|
}
|
|
|
|
void RecvFromDdsAes::sendCreateEffectSimulation(const AreaEffectSimulation::DusSingleMine &aes, int aesTetraId)
|
|
{
|
|
if (aes.isCentral())
|
|
{
|
|
sendRemoveEffectSimulation(TetraIcd::AreaEffectSimulationType::DusSingleMineSimulator, aes.id());
|
|
return;
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendCreateEffectSimulation(DusSingleMine, "
|
|
<< aesTetraId << ")";
|
|
TetraIcd::CreateDusSingleMine dAes;
|
|
|
|
setCommonParams(dAes, aes, aesTetraId);
|
|
dAes.relEffectPosition = m_posHandler->geographicToRelative(aes.position(), 0);
|
|
dAes.effectStart = aes.effectStart().get();
|
|
dAes.effectDuration = aes.effectDuration();
|
|
dAes.mineId = aes.mineId();
|
|
|
|
const auto chargeType(pdm()->chargeTypeFromId(aes.chargeStruct().chargeTypeId()));
|
|
dAes.chargeTypeId = chargeType.legacyId() > 0 ? chargeType.legacyId() : chargeType.id();
|
|
|
|
txData(dAes);
|
|
}
|
|
|
|
void RecvFromDdsAes::sendCreateEffectSimulation(const AreaEffectSimulation::GasPipe &aes, int aesTetraId)
|
|
{
|
|
|
|
Q_UNUSED(aes);
|
|
Q_UNUSED(aesTetraId);
|
|
}
|
|
|
|
|
|
void RecvFromDdsAes::sendModifyEffectSimulationName(TetraIcd::AreaEffectSimulationType aesType, int aesTetraId, const std::string &name, int aesId)
|
|
{
|
|
|
|
if (aesTetraId == 0)
|
|
{
|
|
WARNING_LOG(m_logger) << "Trying to modify an effect simulation name but have no aes identification: " << name;
|
|
return;
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendModifyEffectSimulationName(" << static_cast<int>(aesType)
|
|
<< ", " << aesTetraId << ", " << name << ")";
|
|
|
|
TetraIcd::ModifyAreaEffectSimulationName mAes;
|
|
mAes.aesType = aesType;
|
|
mAes.aesDdsId = aesId;
|
|
|
|
mAes.name = name;
|
|
|
|
txData(mAes);
|
|
}
|
|
|
|
void RecvFromDdsAes::sendRemoveEffectSimulation(TetraIcd::AreaEffectSimulationType aesType, int aesDdsId)
|
|
{
|
|
if (aesDdsId == 0)
|
|
return;
|
|
if (aesType == TetraIcd::AreaEffectSimulationType::GasPipeDetonation)
|
|
return;
|
|
|
|
|
|
|
|
const int aesTetraId = m_aesStateHandler->getAesTetraId(aesDdsId);
|
|
if (aesTetraId == 0)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Could not find a valid tetra id for aes dds id " << aesDdsId;
|
|
return;
|
|
}
|
|
|
|
if (!m_aesStateHandler->update(aesDdsId, aesTetraId, false))
|
|
{
|
|
WARNING_LOG(m_logger) << "Could not update Aes state handler (" << aesDdsId
|
|
<< ", " << aesTetraId << ")";
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendRemoveEffectSimulation(id=" << aesDdsId
|
|
<< ", type=" << static_cast<int>(aesType)
|
|
<< ", tetraId=" << aesTetraId << ")";
|
|
|
|
if (aesType == TetraIcd::AreaEffectSimulationType::TechnicalArea)
|
|
{
|
|
TetraIcd::TechnicalArea fAes;
|
|
fAes.taType = TetraIcd::TechnicalArea::RemoveArea;
|
|
fAes.aesDdsId = aesDdsId;
|
|
|
|
txData(fAes);
|
|
}
|
|
else
|
|
{
|
|
TetraIcd::DeactivateEffectSimulation dAes;
|
|
dAes.aesType = aesType;
|
|
dAes.aesDdsId = aesDdsId;
|
|
|
|
txData(dAes);
|
|
}
|
|
}
|
|
|
|
void RecvFromDdsAes::sendPauseEffectSimulation(int aesDdsId)
|
|
{
|
|
if (aesDdsId == 0)
|
|
return;
|
|
const int aesTetraId = m_aesStateHandler->getAesTetraId(aesDdsId);
|
|
if (aesTetraId == 0)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Could not find a valid tetra id for aes dds id " << aesDdsId ;
|
|
return;
|
|
}
|
|
if (!m_aesStateHandler->update(aesDdsId, aesTetraId, true))
|
|
{
|
|
WARNING_LOG(m_logger) << "Could not update Aes state handler (" << aesDdsId
|
|
<< ", " << aesTetraId << ")";
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendPauseEffectSimulation(id=" << aesDdsId
|
|
<< ", tetraId=" << aesTetraId << ")";
|
|
|
|
TetraIcd::PauseEffectSimulation dAes;
|
|
dAes.aesDdsId = aesDdsId;
|
|
|
|
|
|
txData(dAes);
|
|
}
|
|
|
|
template<>
|
|
void RecvFromDdsAes::sendResumeEffectSimulation(const AreaEffectSimulation::ExplosionArea &aes)
|
|
{
|
|
if (aes.isCentral())
|
|
{
|
|
sendRemoveEffectSimulation(TetraIcd::AreaEffectSimulationType::ExplosionArea, aes.id());
|
|
return;
|
|
}
|
|
const int aesDdsId = aes.id();
|
|
if (aesDdsId == 0)
|
|
return;
|
|
const int aesTetraId = m_aesStateHandler->getAesTetraId(aes.id());
|
|
if (aesTetraId == 0)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Could not find a valid tetra id for aes dds id " << aesDdsId ;
|
|
return;
|
|
}
|
|
if (!m_aesStateHandler->update(aesDdsId, aesTetraId, true))
|
|
{
|
|
WARNING_LOG(m_logger) << "Could not update Aes state handler (" << aesDdsId
|
|
<< ", " << aesTetraId << ")";
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendPauseEffectSimulation(id=" << aesDdsId
|
|
<< ", tetraId=" << aesTetraId << ")";
|
|
|
|
TetraIcd::ResumeEffectSimulation dAes;
|
|
dAes.aesDdsId = aes.id();
|
|
|
|
dAes.sequelNumber = AreaEffectSimulation::Polygons::getSequelNumber(aes.id(),
|
|
aes.cannonCount() * aes.cannonRounds(),
|
|
aes.originalEffectDuration(),
|
|
aes.effectDuration());
|
|
dAes.nextImpact = aes.remainExplosionNumber();
|
|
dAes.resumeTime = aes.effectStart().is_set() ? aes.effectStart().get() : 0;
|
|
dAes.remainDuration = aes.effectDuration();
|
|
|
|
txData(dAes);
|
|
}
|
|
|
|
|
|
template<>
|
|
void RecvFromDdsAes::sendResumeEffectSimulation(const AreaEffectSimulation::ExplosionCluster &aes)
|
|
{
|
|
if (aes.isCentral())
|
|
{
|
|
sendRemoveEffectSimulation(TetraIcd::AreaEffectSimulationType::ExplosionArea, aes.id());
|
|
return;
|
|
}
|
|
const int aesDdsId = aes.id();
|
|
if (aesDdsId == 0)
|
|
return;
|
|
const int aesTetraId = m_aesStateHandler->getAesTetraId(aes.id());
|
|
if (aesTetraId == 0)
|
|
{
|
|
WARNING_LOG(m_logger) << "Could not find a valid tetra id for aes dds id " << aesDdsId ;
|
|
return;
|
|
}
|
|
if (!m_aesStateHandler->update(aesDdsId, aesTetraId, true))
|
|
{
|
|
WARNING_LOG(m_logger) << "Could not update Aes state handler (" << aesDdsId
|
|
<< ", " << aesTetraId << ")";
|
|
}
|
|
DEBUG_LOG(m_logger) << "RecvFromDdsAes::sendPauseEffectSimulation(id=" << aesDdsId
|
|
<< ", tetraId=" << aesTetraId << ")";
|
|
|
|
TetraIcd::ResumeEffectSimulation dAes;
|
|
dAes.aesDdsId = aes.id();
|
|
|
|
dAes.sequelNumber = AreaEffectSimulation::Polygons::getSequelNumber(aes.id(),
|
|
aes.impactCount(),
|
|
aes.originalEffectDuration(),
|
|
aes.effectDuration());
|
|
dAes.nextImpact = aes.remainExplosionNumber();
|
|
dAes.resumeTime = aes.effectStart().is_set() ? aes.effectStart().get() : 0;
|
|
dAes.remainDuration = aes.effectDuration();
|
|
|
|
txData(dAes);
|
|
}
|
|
|
|
std::shared_ptr<PdmHandler> RecvFromDdsAes::pdm()
|
|
{
|
|
return m_mainHandler->pdmHandler();
|
|
}
|
|
|
|
void RecvFromDdsAes::onCheckOutdatedTelegrams()
|
|
{
|
|
QSet<int> deactivatedAesIds;
|
|
deactivatedAesIds.reserve(m_sentAesTelegrams.size());
|
|
for (int i = m_sentAesTelegrams.size() - 1; i >= 0; --i)
|
|
{
|
|
TetraIcd::TrainingAreaTelegram *tele = m_sentAesTelegrams.at(i);
|
|
const int aesId = m_sentAesTelegramsAesIds.at(i);
|
|
if (tele->id() == TrainingAreaBase::TetraIcd::DEAKTIVIEREN_FUNKTIONSRAUM ||
|
|
tele->id() == TrainingAreaBase::TetraIcd::DEAKTIVIERUNG_WIRKFELD)
|
|
{
|
|
deactivatedAesIds += aesId;
|
|
continue;
|
|
}
|
|
if (!deactivatedAesIds.contains(aesId))
|
|
continue;
|
|
INFO_LOG(m_logger) << "Removing tele " << tele->type() << " from aes tele stack";
|
|
delete tele;
|
|
m_sentAesTelegrams.removeAt(i);
|
|
m_sentAesTelegramsAesIds.removeAt(i);
|
|
}
|
|
}
|
|
|
|
void RecvFromDdsAes::resetAllDusMines()
|
|
{
|
|
if (m_sendDusMineReactivtionTimer->isActive())
|
|
m_sendDusMineReactivtionTimer->stop();
|
|
disconnect(m_sendDusMineReactivtionTimer, &QTimer::timeout,
|
|
this, &RecvFromDdsAes::onSendDusMineReactivationTimeout);
|
|
QTimer::singleShot(300, this, [this]()
|
|
{
|
|
for (AreaEffectSimulation::DusMine &mine : m_allReactivatableDusMines)
|
|
mine.triggered(false);
|
|
m_minesToSend.clear();
|
|
connect(m_sendDusMineReactivtionTimer, &QTimer::timeout,
|
|
this, &RecvFromDdsAes::onSendDusMineReactivationTimeout);
|
|
});
|
|
}
|
|
|
|
template<typename T>
|
|
void RecvFromDdsAes::fillCentralChangesTable(const T &data)
|
|
{
|
|
dataChanged(data);
|
|
}
|
|
|
|
}
|
|
|