Initial commit

Lts/Services/ParticipantManagement/ParticipantHandling/firing_unit_validator.cpp

@@ -0,0 +1,147 @@
+/**
+  * @RDE_HEADER@
+  * The FiringUnitValidator regulates the rules for firing units
+  * $Id: participant_dis_helper.h 37747 2017-12-08 08:07:01Z ehrlicher $
+  * $HeadURL: svn://10.196.0.54/TDS/branches/product/features/24_vulcano/Lts/Plugins/ParticipantManagement/Gui/Common/participant_dis_helper.h $
+  * $Author: ehrlicher $
+  * Created by Hannes Fritsche, ESZS, 2024-03-07
+  */
+
+#include "firing_unit_validator.h"
+
+#include <LtsUtilsSettings/settings.h>
+#include <ParticipantManagement/ppm.hpp>
+#include "ParticipantManagement/settings.h"
+#include "TypeHandling/type_handler.h"
+#include "participant_handler.h"
+#include "participant.h"
+
+namespace ParticipantManagement
+{
+namespace ParticipantHandling
+{
+
+FiringUnitValidator::FiringUnitValidator(const std::shared_ptr<ParticipantHandler> &participantHandler,
+                                         const std::shared_ptr<TypeHandling::TypeHandler> &typeHandler,
+                                         QObject *parent)
+  : QObject(parent)
+  , m_participantHandler(participantHandler)
+  , m_typeHandler(typeHandler)
+{
+}
+
+Core::FunctionReplyObject FiringUnitValidator::firingUnitError(const QHash<int, int> &modIdToParticipantId, const QVector<ParticipantData> &participantData)
+{
+  QString error;
+
+  for (const ParticipantData &currentData : participantData)
+  {
+    if (!m_typeHandler->isFiringUnitType(currentData.typeId()))
+      continue;
+
+    int unitModId = currentData.modId();
+
+    error = getError(modIdToParticipantId, participantData, unitModId);
+
+    if (!error.isEmpty())
+      break;
+  }
+
+  return Core::FunctionReplyObject(error.toStdString().c_str());
+}
+
+QString FiringUnitValidator::getError(const QHash<int, int> &modIdToParticipantId, const QVector<ParticipantData> &participantData, int unitModId) const
+{
+  bool hasCapacityError = false;
+  bool hasFalseTypeError = false;
+  bool hasMixedTypeError = false;
+  uint maxParticipantsPerFiringUnit = Settings::maxParticipantsPerFiringUnit();
+  uint participantsInFiringUnit = nonModdedInferiorsCount(unitModId, modIdToParticipantId);
+  int typeId = participantTypeInFiringUnit(unitModId, modIdToParticipantId);
+
+  for (const ParticipantData &currentData : participantData)
+  {
+    if (currentData.superiorModId() != unitModId)
+      continue;
+
+    // capacity error
+    hasCapacityError = ++participantsInFiringUnit > maxParticipantsPerFiringUnit;
+
+    if (hasCapacityError)
+      return tr("There are only %1 participants allowed per firing unit.").arg(maxParticipantsPerFiringUnit);
+
+    // false type error
+    hasFalseTypeError = !m_typeHandler->isArtilleryParticipantType(currentData.typeId());
+
+    if (hasFalseTypeError)
+      return tr("There are only artillery participants allowed in firing units.");
+
+    // mixed type error
+    if (typeId == -1)
+      typeId = currentData.typeId();
+
+    hasMixedTypeError = currentData.typeId() != typeId;
+
+    if (hasMixedTypeError)
+      return tr("There are no mixed types allowed in firing units.");
+  }
+
+  return QString();
+}
+
+int FiringUnitValidator::nonModdedInferiorsCount(int unitModId, const QHash<int, int> &modIdToParticipantId) const
+{
+  if (!modIdToParticipantId.contains(unitModId))
+    return 0;
+
+  const int unitParticipantId = modIdToParticipantId.value(unitModId);
+  const Participant *unitParticipant = m_participantHandler->participantById(unitParticipantId);
+
+  if (!unitParticipant)
+    return 0;
+
+  const QList<int> moddedParticipantIds = modIdToParticipantId.keys();
+  int nonModdedInferiorsCountRet = 0;
+
+  for (int inferiorId : unitParticipant->inferiors())
+  {
+    if (moddedParticipantIds.contains(inferiorId)) // only non modded participants
+      continue;
+
+    ++nonModdedInferiorsCountRet;
+  }
+
+  return nonModdedInferiorsCountRet;
+}
+
+int FiringUnitValidator::participantTypeInFiringUnit(int unitModId, const QHash<int, int> &modIdToParticipantId) const
+{
+  if (!modIdToParticipantId.contains(unitModId))
+    return -1;
+
+  const int unitParticipantId = modIdToParticipantId.value(unitModId);
+  const Participant *unitParticipant = m_participantHandler->participantById(unitParticipantId);
+
+  if (!unitParticipant)
+    return -1;
+
+  const QList<int> moddedParticipantIds = modIdToParticipantId.keys();
+
+  for (int inferiorId : unitParticipant->inferiors())
+  {
+    if (moddedParticipantIds.contains(inferiorId)) // only non modded participants
+      continue;
+
+    const Participant *inferior = m_participantHandler->participantById(inferiorId);
+
+    if (!inferior)
+      continue;
+
+    return inferior->typeId();
+  }
+
+  return -1;
+}
+
+} // namespace ParticipantHandling
+} // namespace ParticipantManagement