552 lines
21 KiB
C++
Executable File
552 lines
21 KiB
C++
Executable File
/**
|
|
* Handler for player data
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by gr, SLSE, 2017-02-20
|
|
*/
|
|
|
|
#include "handler_target_areas.h"
|
|
#include <CentralEffectSimulation/point_helpers.h>
|
|
#include <ParticipantManagement/ppm_common.h>
|
|
|
|
#include <LtsCoordTrans/lts_coord_trans.h>
|
|
#include <QLineF>
|
|
#include <QDateTime>
|
|
|
|
|
|
namespace TargetAreas
|
|
{
|
|
|
|
HandlerTargetAreas::HandlerTargetAreas(const std::shared_ptr<DdsHandlerTargetAreas> &ddsHandler,
|
|
QObject *parent)
|
|
: QObject(parent)
|
|
, m_ddsHandler(ddsHandler)
|
|
, m_logger(getLogger("HandlerTargetAreas"))
|
|
{
|
|
} // end of ctor()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
HandlerTargetAreas::~HandlerTargetAreas()
|
|
{
|
|
} // end of dtor()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool HandlerTargetAreas::init()
|
|
{
|
|
auto dtcPpm = m_ddsHandler->dtcPpm();
|
|
|
|
connect(dtcPpm.get(), &ParticipantManagement::Interface::Dtc::participantPositionChanged,
|
|
this, &HandlerTargetAreas::onParticipantPositionChanged);
|
|
connect(dtcPpm.get(), &ParticipantManagement::Interface::Dtc::participantChanged,
|
|
this, &HandlerTargetAreas::onParticipantChanged);
|
|
connect(dtcPpm.get(), &ParticipantManagement::Interface::Dtc::typeChanged,
|
|
this, &HandlerTargetAreas::onTypeChanged);
|
|
connect(dtcPpm.get(), &ParticipantManagement::Interface::Dtc::targetInformationChanged,
|
|
this, &HandlerTargetAreas::onTargetInformationChanged);
|
|
|
|
{
|
|
auto cb = [this](const ParticipantManagement::Type & data)
|
|
{
|
|
onTypeChanged(data, DataModification::eAdded);
|
|
};
|
|
dtcPpm->types(cb);
|
|
}
|
|
|
|
{
|
|
auto cb = [this](const ParticipantManagement::Participant & data)
|
|
{
|
|
onParticipantChanged(data, DataModification::eAdded);
|
|
};
|
|
dtcPpm->participants(cb);
|
|
}
|
|
|
|
{
|
|
auto cb = [this](const ParticipantManagement::ParticipantPosition & data)
|
|
{
|
|
onParticipantPositionChanged(data, DataModification::eAdded);
|
|
};
|
|
dtcPpm->participantPositions(cb);
|
|
}
|
|
|
|
{
|
|
auto cb = [this](const ParticipantManagement::TargetInformation & data)
|
|
{
|
|
onTargetInformationChanged(data, DataModification::eAdded);
|
|
};
|
|
dtcPpm->targetInformations(cb);
|
|
}
|
|
INFO_LOG(m_logger) << "HandlerTargetAreas::init() finished. "
|
|
<< " m_positionsMap.size(): " << m_positionsMap.size();
|
|
return true;
|
|
} // end of init()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void HandlerTargetAreas::onParticipantPositionChanged(const ParticipantManagement::ParticipantPosition &data, DataModification modType)
|
|
{
|
|
DEBUG_LOG(m_logger) << "onParticipantPositionChanged: " << data;
|
|
if (modType == DataModification::eRemoved)
|
|
{
|
|
DEBUG_LOG(m_logger) << "m_participantsOutsideMap.remove participantId: " << data.participantId();
|
|
//m_participantsOutsideMap.remove(data.participantId());
|
|
}
|
|
else
|
|
{
|
|
ParticipantPosition partPos(data);
|
|
auto it = m_positionsMap.find(partPos.participantId());
|
|
if (it != m_positionsMap.end())
|
|
{
|
|
const ParticipantPosition &partPosOld = *it;
|
|
|
|
partPos.vulnerabilityState = partPosOld.vulnerabilityState;
|
|
partPos.lastGeoPosition = partPosOld.pos(); // save previous position
|
|
// replace
|
|
*it = partPos;
|
|
DEBUG_LOG(m_logger) << "m_positionsMap.replace=" << data.participantId();
|
|
}
|
|
else
|
|
{
|
|
DEBUG_LOG(m_logger) << "m_positionsMap.insert=" << data.participantId();
|
|
m_positionsMap.insert(data.participantId(), partPos);
|
|
}
|
|
|
|
int equipmentNumber = m_ddsHandler->participantId2EquipNo(data.participantId());
|
|
if (equipmentNumber > 0)
|
|
checkShootbackAreaPosition(data);
|
|
else
|
|
INFO_LOG(m_logger) << "Teilnehmer hat keine Ausstattungsnummer";
|
|
|
|
INFO_LOG(m_logger) << "onParticipantPositionChanged()"
|
|
<< " participantId; " << data.participantId()
|
|
<< " participantTypeId: " << data.participantTypeId()
|
|
<< " partyId: " << data.partyId()
|
|
<< " vulnerabilityState: " << partPos.vulnerabilityState;
|
|
}
|
|
} // end of onParticipantPositionChanged()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
void HandlerTargetAreas::onParticipantChanged(const ParticipantManagement::Participant &data, DataModification modType)
|
|
{
|
|
// Remove Participant:
|
|
if (modType == DataModification::eRemoved || data.isDeleted())
|
|
{
|
|
DEBUG_LOG(m_logger) << "onParticipantChanged m_positionsMap.remove id=" << data.id();
|
|
m_participantData.remove(data.id());
|
|
m_positionsMap.remove(data.id());
|
|
return;
|
|
}
|
|
|
|
// No OC in CES
|
|
ParticipantManagement::TypeClass typeClass = typeClassFromTypeId(data.typeId());
|
|
if (typeClass == ParticipantManagement::TypeClass_def::SupportEntity
|
|
|| typeClass == ParticipantManagement::TypeClass_def::SupportUnit
|
|
|| typeClass == ParticipantManagement::TypeClass_def::Unit)
|
|
return;
|
|
m_participantData[data.id()] = data;
|
|
|
|
ParticipantPosition &pos = m_positionsMap[data.id()];
|
|
pos.partyId(data.partyId());
|
|
pos.participantId(data.id());
|
|
pos.participantTypeId(data.typeId());
|
|
DEBUG_LOG(m_logger) << "onParticipantChanged"
|
|
<< " id=" << data.id()
|
|
<< " typeId=" << data.typeId()
|
|
<< " designator=" << data.designator();
|
|
if (typeClass == ParticipantManagement::TypeClass_def::Target)
|
|
DEBUG_LOG(m_logger) << "Typeclass = Target";
|
|
}
|
|
|
|
void HandlerTargetAreas::onTypeChanged(const ParticipantManagement::Type &data, DataModification modType)
|
|
{
|
|
if (modType == DataModification::eRemoved)
|
|
return;
|
|
m_typeMap.insert(data.id(), data.typeClass());
|
|
DEBUG_LOG(m_logger) << "m_typeMap.size()" << m_typeMap.size()
|
|
<< " equipmentTypeId=" << data.id()
|
|
<< " typeClass=" << data.typeClass();
|
|
}
|
|
|
|
void HandlerTargetAreas::onTargetInformationChanged(const ParticipantManagement::TargetInformation &data, DataModification modType)
|
|
{
|
|
DEBUG_LOG(m_logger) << "onTargetInformationChanged"
|
|
<< " participantId=" << data.participantId()
|
|
<< " data.shootbackAreas().size()=" << data.shootbackAreas().size();
|
|
|
|
if (modType == DataModification::eRemoved)
|
|
{
|
|
DEBUG_LOG(m_logger) << "m_participantsOutsideMap.remove participantId: " << data.participantId();
|
|
m_shootbackTargets.remove(data.participantId());
|
|
return;
|
|
}
|
|
ShootbackTarget shootbackTarget;
|
|
shootbackTarget.participantId = data.participantId();
|
|
if (m_shootbackTargets.contains(data.participantId()))
|
|
{
|
|
shootbackTarget = m_shootbackTargets[data.participantId()];
|
|
shootbackTarget.shootbackAreasUtm.clear();
|
|
}
|
|
shootbackTarget.targetInformation = data;
|
|
// assign shootbackAreasUtm
|
|
for (unsigned int i = 0; i < data.shootbackAreas().size(); i++)
|
|
{
|
|
DEBUG_LOG(m_logger) << " shootbackAreas i=" << i;
|
|
ParticipantManagement::ShootbackArea shootbackArea = data.shootbackAreas().at(i);
|
|
QPolygonF shootbackAreaUtm;
|
|
|
|
for (unsigned int i = 0; i < shootbackArea.area().size(); i++)
|
|
{
|
|
QPointF pointfUtm1;
|
|
pointfUtm1 = CentralEffectSimulation::geographic2Utm(shootbackArea.area().at(i), &m_zone);
|
|
shootbackAreaUtm.push_back(pointfUtm1);
|
|
}
|
|
|
|
for (int i = 0; i < shootbackAreaUtm.size(); i++)
|
|
{
|
|
DEBUG_LOG(m_logger) << "i=" << i
|
|
<< " x=" << shootbackAreaUtm[i].x()
|
|
<< " y=" << shootbackAreaUtm[i].y()
|
|
<< " zone=" << m_zone;
|
|
}
|
|
shootbackTarget.shootbackAreasUtm.append(shootbackAreaUtm);
|
|
}
|
|
|
|
m_shootbackTargets.insert(data.participantId(), shootbackTarget);
|
|
DEBUG_LOG(m_logger) << "newShootbackTarget participantId=" << data.participantId()
|
|
<< " shootbackTarget.participantId=" << shootbackTarget.participantId
|
|
<< " shootbackTarget.targetInformation.participantId()=" << shootbackTarget.targetInformation.participantId()
|
|
<< " shootbackTarget.targetInformation.prewarningInterval()=" << shootbackTarget.targetInformation.prewarningInterval()
|
|
<< " data.shootbackAreas().size()=" << data.shootbackAreas().size()
|
|
<< " prewarningEffect=" << shootbackTarget.targetInformation.prewarningEffect()
|
|
<< " takedownEffect=" << shootbackTarget.targetInformation.takedownEffect();
|
|
printShootbackAreas();
|
|
}
|
|
|
|
int HandlerTargetAreas::getParticipantId(int equipentNumber)
|
|
{
|
|
// QHash<int, ParticipantManagement::Participant> m_participantData;
|
|
|
|
QHashIterator<int, ParticipantManagement::Participant> i(m_participantData);
|
|
while (i.hasNext())
|
|
{
|
|
i.next();
|
|
if (i.value().equipmentNumber() == equipentNumber)
|
|
return i.value().id();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void HandlerTargetAreas::printQPolygon(const QPolygonF polygon)
|
|
{
|
|
DEBUG_LOG(m_logger) << "printQPolygon polygon.size()=" << polygon.size();
|
|
for (int i = 0; i < polygon.size(); i++)
|
|
{
|
|
DEBUG_LOG(m_logger) << "printQPolygon i=" << i
|
|
<< " x=" << polygon[i].x()
|
|
<< " y=" << polygon[i].y();
|
|
}
|
|
}
|
|
|
|
void HandlerTargetAreas::printShootbackTarget(const ShootbackTarget &shootbackTarget)
|
|
{
|
|
DEBUG_LOG(m_logger) << "ShootbackTarget "
|
|
<< ", targetParticipantId=" << shootbackTarget.participantId
|
|
<< ", shootbackAreasUtm.size=" << shootbackTarget.shootbackAreasUtm.size();
|
|
for (int i = 0; i < shootbackTarget.shootbackAreasUtm.size(); i++)
|
|
{
|
|
// Punkte des Poygons ausgeben
|
|
printQPolygon(shootbackTarget.shootbackAreasUtm.at(i));
|
|
}
|
|
|
|
}
|
|
|
|
void HandlerTargetAreas::printShootbackAreas()
|
|
{
|
|
DEBUG_LOG(m_logger) << "printShootbackAreas--------------------";
|
|
QHashIterator<int, ShootbackTarget> it(m_shootbackTargets);
|
|
while (it.hasNext())
|
|
{
|
|
it.next();
|
|
ShootbackTarget shootbackTarget = it.value();
|
|
printShootbackTarget(shootbackTarget);
|
|
}
|
|
DEBUG_LOG(m_logger) << "ENDE printShootbackAreas--------------------";
|
|
}
|
|
|
|
bool HandlerTargetAreas::checkPosInShootbackTarget(const ShootbackTarget &shootbackTarget,
|
|
const QPointF &participantPosUtm)
|
|
{
|
|
bool inside = false;
|
|
DEBUG_LOG(m_logger) << "checkPosInShootbackTarget ShootbackTarget "
|
|
<< ", targetParticipantId=" << shootbackTarget.participantId
|
|
<< ", shootbackAreasUtm.size=" << shootbackTarget.shootbackAreasUtm.size();
|
|
for (int i = 0; i < shootbackTarget.shootbackAreasUtm.size(); i++)
|
|
{
|
|
// Punkte des Poygons ausgeben
|
|
printQPolygon(shootbackTarget.shootbackAreasUtm.at(i));
|
|
if (shootbackTarget.shootbackAreasUtm.at(i).containsPoint(participantPosUtm, Qt::OddEvenFill))
|
|
{
|
|
DEBUG_LOG(m_logger) << "inside = true";
|
|
inside = true;
|
|
}
|
|
}
|
|
return inside;
|
|
}
|
|
|
|
void HandlerTargetAreas::checkShootbackAreaPosition(const ParticipantManagement::ParticipantPosition &data)
|
|
{
|
|
int participantId = data.participantId();
|
|
int equipmentNumber = m_ddsHandler->participantId2EquipNo(data.participantId());
|
|
DEBUG_LOG(m_logger) << "checkShootbackAreaPosition id= " << data.participantId()
|
|
<< ", equipmentNumber=" << equipmentNumber
|
|
<< ", sampleTime=" << data.sampleTime()
|
|
<< ", time difference = " << QDateTime::currentMSecsSinceEpoch() - data.sampleTime();
|
|
ParticipantPosition posActual = m_positionsMap[data.participantId()];
|
|
// ParticipantManagement::TypeClass typeClass = m_typeMap[data.participantId()];
|
|
|
|
QPointF participantPosUtm;
|
|
participantPosUtm = CentralEffectSimulation::geographic2Utm(posActual.pos(), &m_zone);
|
|
|
|
printShootbackAreas();
|
|
|
|
DEBUG_LOG(m_logger) << "Participant pos=" << posActual.pos().lat() << "/" << posActual.pos().lon()
|
|
<< ", Utm=" << participantPosUtm.x() << "/" << participantPosUtm.y()
|
|
<< " m_zone=" << m_zone;
|
|
|
|
QHashIterator<int, ShootbackTarget> it(m_shootbackTargets);
|
|
while (it.hasNext())
|
|
{
|
|
it.next();
|
|
ShootbackTarget shootbackTarget = it.value();
|
|
if (data.participantId() == shootbackTarget.participantId)
|
|
continue;
|
|
int targetPreWarningInterval = shootbackTarget.targetInformation.prewarningInterval() * 1000;
|
|
int targetTimeToEffectInterval = shootbackTarget.targetInformation.takedownInterval() * 1000;
|
|
|
|
DEBUG_LOG(m_logger) << "ShootbackArea ParticipantID=" << shootbackTarget.participantId
|
|
<< " shootbackTarget.shootbackAreasUtm.size()=" << shootbackTarget.shootbackAreasUtm.size()
|
|
<< " size= " << it.value().shootbackAreasUtm.size();
|
|
printShootbackTarget(shootbackTarget);
|
|
if (checkPosInShootbackTarget(shootbackTarget, participantPosUtm))
|
|
{
|
|
// START TARGET TIMER
|
|
DEBUG_LOG(m_logger) << "Participant ist in ShootbackArea"
|
|
<< ", ParticipantId= " << participantId
|
|
<< ", ShootbackTargetId=" << shootbackTarget.participantId;
|
|
if (m_targetTimers.contains(participantId))
|
|
if (m_targetTimers.value(participantId)->getTimerState() != TargetTimer::TimerState::NOT_ACTIVE)
|
|
return;
|
|
DEBUG_LOG(m_logger) << "START TIMER PARTICIPANT_ID=" << participantId
|
|
<< " targetPreWarningInterval=" << targetPreWarningInterval
|
|
<< " targetTimeToEffectInterval=" << targetTimeToEffectInterval
|
|
<< " m_targetTimers.insert(" << participantId << ")";
|
|
TargetTimer *targetTimer = new TargetTimer(participantId,
|
|
shootbackTarget.participantId,
|
|
targetPreWarningInterval,
|
|
targetTimeToEffectInterval);
|
|
targetTimer->startTimer();
|
|
m_targetTimers.insert(participantId, targetTimer);
|
|
QObject::connect(targetTimer, &TargetTimer::preWarningTimeout,
|
|
this, &HandlerTargetAreas::on_preWarningIntervalFinished);
|
|
QObject::connect(targetTimer, &TargetTimer::timeToEffectTimeout,
|
|
this, &HandlerTargetAreas::on_TimeToEffectFinished);
|
|
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// STOP TARGET TIMER
|
|
DEBUG_LOG(m_logger) << "Participant ist nicht in ShootbackArea"
|
|
<< ", ParticipantId= " << data.participantId()
|
|
<< ", ShootbackTargetId=" << shootbackTarget.participantId
|
|
<< ", m_targetTimers.size=" << m_targetTimers.size()
|
|
<< ", m_targetTimers.contains(participantId)=" << m_targetTimers.contains(participantId);
|
|
if (!m_targetTimers.contains(participantId))
|
|
{
|
|
DEBUG_LOG(m_logger) << "continue";
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
TargetTimer *targetTimer = m_targetTimers.value(participantId);
|
|
if (targetTimer->getTargetParticipantId() == shootbackTarget.participantId)
|
|
{
|
|
targetTimer->deleteLater();
|
|
m_targetTimers.remove(participantId);
|
|
DEBUG_LOG(m_logger) << "STOP TIMER PARTICIPANT_ID=" << participantId
|
|
<< " m_targetTimers.remove(" << participantId << ")";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void HandlerTargetAreas::onSendControlDataReply(const Core::FunctionReplyObject &replyObject)
|
|
{
|
|
//if (replyObject.error())
|
|
// WARNING_LOG(m_logger) << "Can not send hit on participant to training area: " << replyObject();
|
|
//else
|
|
DEBUG_LOG(m_logger) << "onSendControlDataReply for id " << replyObject.id() << " success";
|
|
}
|
|
|
|
void HandlerTargetAreas::onSendCesHitInformationReply(const Core::FunctionReplyObject &replyObject)
|
|
{
|
|
//if (replyObject.error())
|
|
// WARNING_LOG(m_logger) << "Can not send hit on participant to training area: " << replyObject();
|
|
//else
|
|
DEBUG_LOG(m_logger) << "onSendCesHitInformationReply for id " << replyObject.id() << " success";
|
|
}
|
|
|
|
|
|
void HandlerTargetAreas::sendRequestsToTab(int participantId,
|
|
int targetParticipantId,
|
|
int countBlink,
|
|
int effectPercent)
|
|
{
|
|
DEBUG_LOG(m_logger) << "MainWindow::on_Timer1finished participantId=" << participantId
|
|
<< " targetParticipantId =" << targetParticipantId;
|
|
ParticipantManagement::Participant participant = m_participantData.value(participantId);
|
|
//ShootbackTarget shootbackTarget = m_shootbackTargets.value(participantId);
|
|
auto ftcTab = m_ddsHandler->ftcTab();
|
|
|
|
|
|
// SEND ControlDataRequest TO TARGET
|
|
|
|
int32_t participantIdFt = participantId;
|
|
int32_t equipmentNumberFt = m_ddsHandler->participantId2EquipNo(participantId);
|
|
int32_t targetParticipantIdFt = targetParticipantId;
|
|
int32_t targetEquipmentNumberFt = m_ddsHandler->participantId2EquipNo(targetParticipantId);
|
|
int32_t chargeTypeIdFt = 1;
|
|
int32_t directionDegreeFt = 0;
|
|
int32_t distanceToOrignatorFt = 0;
|
|
int32_t countBlinkFt = countBlink;
|
|
int32_t effectPercentFt = effectPercent;
|
|
rti::core::int64 effectTimeFt = m_ddsHandler->currentPartitionTime();
|
|
|
|
TrainingAreaBase::ControlDataCode controlCodeFt = TrainingAreaBase::ControlDataCode_def::Flashing;
|
|
std::vector< uint8_t > controlDataFt;
|
|
|
|
|
|
controlDataFt.resize(1);
|
|
controlDataFt[0] = countBlinkFt;
|
|
|
|
TrainingAreaBase::SendControlDataRequest sendControlDataRequest(
|
|
targetEquipmentNumberFt,
|
|
targetParticipantIdFt,
|
|
controlCodeFt,
|
|
controlDataFt
|
|
);
|
|
ftcTab->sendControlDataRequest(sendControlDataRequest, this);
|
|
|
|
// SEND HitInformation to participant
|
|
TrainingAreaBase::SendCesHitInformation sendCesHitInformationRequest(
|
|
equipmentNumberFt,
|
|
participantIdFt,
|
|
targetEquipmentNumberFt,
|
|
targetParticipantIdFt,
|
|
chargeTypeIdFt,
|
|
directionDegreeFt,
|
|
distanceToOrignatorFt,
|
|
effectPercentFt,
|
|
effectTimeFt
|
|
);
|
|
ftcTab->sendCesHitInformationRequest(sendCesHitInformationRequest, this);
|
|
|
|
TrainingAreaBase::SendCesHitRequest hr;
|
|
hr.aesId(1);
|
|
|
|
INFO_LOG(m_logger) << "sendCesHitRequest: " << hr;
|
|
ftcTab->sendCesHitRequest(hr, this);
|
|
|
|
}
|
|
|
|
void HandlerTargetAreas::on_preWarningIntervalFinished(int participantId, int targetParticipantId)
|
|
{
|
|
DEBUG_LOG(m_logger) << "MainWindow::on_Timer1finished participantId=" << participantId
|
|
<< " targetParticipantId =" << targetParticipantId;
|
|
ParticipantManagement::Participant participant = m_participantData.value(participantId);
|
|
ShootbackTarget shootbackTarget = m_shootbackTargets.value(targetParticipantId);
|
|
uint8_t countBlink = 1;
|
|
int32_t effectPercent = 0;
|
|
|
|
switch (shootbackTarget.targetInformation.prewarningEffect().underlying())
|
|
{
|
|
case ProjectDataManagement::VulnerabilityState_def::NoChange:
|
|
countBlink = 1;
|
|
effectPercent = 0;
|
|
break;
|
|
case ProjectDataManagement::VulnerabilityState_def::MobilityKill:
|
|
effectPercent = 30;
|
|
countBlink = 2;
|
|
break;
|
|
case ProjectDataManagement::VulnerabilityState_def::NearMiss:
|
|
countBlink = 3;
|
|
effectPercent = 60;
|
|
break;
|
|
case ProjectDataManagement::VulnerabilityState_def::CatastrophicKill:
|
|
countBlink = 4;
|
|
effectPercent = 100;
|
|
break;
|
|
default:
|
|
effectPercent = 11;
|
|
countBlink = 0;
|
|
}
|
|
|
|
sendRequestsToTab(participantId,
|
|
targetParticipantId,
|
|
countBlink,
|
|
effectPercent);
|
|
}
|
|
|
|
|
|
void HandlerTargetAreas::on_TimeToEffectFinished(int participantId, int targetParticipantId)
|
|
{
|
|
DEBUG_LOG(m_logger) << "HandlerTargetAreas::on_TimeToEffectFinished participantId=" << participantId
|
|
<< " targetParticipantId=" << targetParticipantId;
|
|
|
|
DEBUG_LOG(m_logger) << "MainWindow::on_Timer1finished participantId=" << participantId
|
|
<< " targetParticipantId =" << targetParticipantId;
|
|
ParticipantManagement::Participant participant = m_participantData.value(participantId);
|
|
ShootbackTarget shootbackTarget = m_shootbackTargets.value(targetParticipantId);
|
|
uint8_t countBlink = 1;
|
|
int32_t effectPercent = 0;
|
|
|
|
DEBUG_LOG(m_logger) << " shootbackTarget.participantId=" << shootbackTarget.participantId
|
|
<< " shootbackTarget.targetInformation.participantId()=" << shootbackTarget.targetInformation.participantId()
|
|
<< " shootbackTarget.targetInformation.prewarningInterval()=" << shootbackTarget.targetInformation.prewarningInterval()
|
|
<< " prewarningEffect=" << shootbackTarget.targetInformation.prewarningEffect()
|
|
<< " takedownEffect=" << shootbackTarget.targetInformation.takedownEffect();
|
|
|
|
|
|
switch (shootbackTarget.targetInformation.takedownEffect().underlying())
|
|
{
|
|
case ProjectDataManagement::VulnerabilityState_def::MobilityKill:
|
|
effectPercent = 50;
|
|
countBlink = 5;
|
|
break;
|
|
case ProjectDataManagement::VulnerabilityState_def::CatastrophicKill:
|
|
countBlink = 6;
|
|
effectPercent = 100;
|
|
break;
|
|
default:
|
|
effectPercent = 12;
|
|
countBlink = 0;
|
|
}
|
|
|
|
sendRequestsToTab(participantId,
|
|
targetParticipantId,
|
|
countBlink,
|
|
effectPercent);
|
|
}
|
|
|
|
void HandlerTargetAreas::onSendCesHitReply(const Core::FunctionReplyObject &replyObject)
|
|
{
|
|
INFO_LOG(m_logger) << "HandlerTargetAreas::onSendCesHitReply";
|
|
//if (replyObject.error())
|
|
// WARNING_LOG(m_logger) << "Can not send hit on participant to training area: " << replyObject();
|
|
//else
|
|
DEBUG_LOG(m_logger) << "onSendCesHitReply for id " << replyObject.id() << " success";
|
|
}
|
|
|
|
} // namespace TargetAreas
|