qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Services/EffectShowClient/handler_vehicle.cpp

/**
  * Handler for player data
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by hjl, SLSE, 2017-02-20
  */

#include "handler_vehicle.h"
#include "main_handler.h"
#include "esc_helper.h"
#include "control_unit_handler.h"

#include <QCoreApplication>
#include <NGLLogger/NGLLoggerBootstrap.h>
#include <QTimer>

namespace EffectShowClient
{
//=============================================================================
HandlerVehicle::HandlerVehicle(MainHandler *mainHandler,
                               QObject     *parent)

  : QObject(parent)
  , m_mainHandler(mainHandler)
  , m_volleyTimer(new QTimer(this))
  , m_remainingTimer(new QTimer(this))
{
  DEBUG_LOG() << "HandlerVehicle ctor";
  m_volleyTimer->setSingleShot(true);
  m_remainingTimer->setInterval(1000);
  m_statusExplosionFiring.remainingTime_s = -1;
  m_statusSmokeFiring.remainingTime_s     = -1;

}
//=============================================================================
HandlerVehicle::~HandlerVehicle()
{
  //delete m_mainHandler;
}
//=============================================================================
bool HandlerVehicle::init()
{
  DEBUG_LOG() << "HandlerVehicle::init()";
  connect(m_mainHandler->handlerControlUnit().get(), &ControlUnitHandler::vehicleBattery, this, &HandlerVehicle::vehicleBattery);
  connect(m_mainHandler->handlerControlUnit().get(), &ControlUnitHandler::vehicleFinshedVolley, this, &HandlerVehicle::onVolleyFinished);
  //connect(m_mainHandler->handlerControlUnit().get(), &ControlUnitHandler::vehicleShutDown, this, &HandlerVehicle::vehicleShutDown);
  connect(m_mainHandler->handlerControlUnit().get(), &ControlUnitHandler::vehicleSmokeCardridgesFireStatus, this, &HandlerVehicle::vehicleSmokeCardridgesFireStatus);
  connect(m_mainHandler->handlerControlUnit().get(), &ControlUnitHandler::vehicleSmokeCardridgesStatus, this, &HandlerVehicle::vehicleSmokeCardridgesStatus);
  connect(m_mainHandler->handlerControlUnit().get(), &ControlUnitHandler::vehicleFireUnits, this, &HandlerVehicle::vehicleFireUnits);
  connect(m_mainHandler->handlerControlUnit().get(), &ControlUnitHandler::vehicleStoppedVolley, this, &HandlerVehicle::onVolleyStopped);
  connect(m_mainHandler->handlerControlUnit().get(), &ControlUnitHandler::vehicleType, this, &HandlerVehicle::vehicleType);

  connect(m_volleyTimer, &QTimer::timeout, this, &HandlerVehicle::onStartVolley);
  connect(m_remainingTimer, &QTimer::timeout, this, &HandlerVehicle::onRemainingTimerTimeOut);

  return true;
}
//=============================================================================
bool HandlerVehicle::isOperational() const
{
  return true; // TODO: Decision for operational !!!!!
}
//=============================================================================
void HandlerVehicle::setAmmunitionParameter(int numberOfShotsMagazine)
{
  //we send the ammunition and wait for return
  m_mainHandler->handlerControlUnit()->send(CommandSignal::FT_SE_CB_WERFER_MUNITION, numberOfShotsMagazine);
}
//=============================================================================
int HandlerVehicle::burningTimeSmokeCartridge_s() const
{
  return 80 * 1000; // TODO:
}
//=============================================================================
void HandlerVehicle::setExplosionParameter(int numberOfVolley, int numberOfShot, qint64 duration)
{
  DEBUG_LOG() << "Duration: " << duration << " number of shots: " << numberOfShot << " number of volles" << numberOfVolley;
  m_statusExplosionFiring.remainingShots  = numberOfShot;
  m_statusExplosionFiring.remainingTime_s = duration;
  m_statusExplosionFiring.remainingVolley = numberOfVolley;
  m_oldTime = duration;
  //spread shots
  spreadShotsInVolleys(numberOfShot, numberOfVolley);
  m_currentVolley = 0;
  m_statusExplosionFiring.shotsPerVolley = m_shotsInVolley.value(m_currentVolley);

  // duration is 60sec
  // 10 volley
  // 6 shots per volley
  emit readyForExplosionFiring(true);
}


void HandlerVehicle::recalcEverything()
{
  spreadShotsInVolleys(m_statusExplosionFiring.remainingShots, m_statusExplosionFiring.remainingVolley);
  m_currentVolley = 0;
}
//=============================================================================
void HandlerVehicle::setSmokeParameter(int lengthOfFogZone, int directionOfFogZone)
{
  Q_UNUSED(directionOfFogZone);
  m_statusSmokeFiring.remainingDistance_m = lengthOfFogZone;
  m_statusSmokeFiring.remainingTime_s     = burningTimeSmokeCartridge_s();

  EffectShowClient::SafetyConfirmation_e sc = EffectShowClient::SafetyConfirmation_e_def::SafetyConfirmed;
  emit safetyConfirmation(sc);

  emit readyForSmokeFiring(true);

  effectShowControl(EffectShowControl_e::Start);
}
//=============================================================================
void HandlerVehicle::effectShowControl(EffectShowControl_e effectShowControl)
{
  m_remainingTimer->stop();
  switch (effectShowControl)
  {
  case EffectShowControl_e::Start:
  {
    emit statusExplosionFiring(m_statusExplosionFiring);
    onStartVolley();
    return;
  }
  case EffectShowControl_e::Stop:
  {
    emit statusExplosionFiring(m_statusExplosionFiring);
    //stop volley

    m_mainHandler->handlerControlUnit()->send(CommandSignal::FT_SE_CB_SALVE_UNTERBRECHEN);
    break;
  }
  case EffectShowControl_e::Continue:
  {
    emit statusExplosionFiring(m_statusExplosionFiring);
    onStartVolley();
    break;
  }
  case EffectShowControl_e::Abort:
  {
    m_mainHandler->handlerControlUnit()->send(CommandSignal::FT_SE_CB_SALVE_UNTERBRECHEN);
    m_statusExplosionFiring.remainingTime_s = 0;
    m_statusExplosionFiring.remainingShots = 0;
    m_statusExplosionFiring.remainingVolley = 0;

    EffectShowClient::SafetyConfirmation_e sc = EffectShowClient::SafetyConfirmation_e_def::SafetyNotConfirmed;
    emit safetyConfirmation(sc);
    break;
  }
  case EffectShowControl_e::StopTimer:
  {
    m_oldTime = m_statusExplosionFiring.remainingTime_s;
    break;
  }

  }
}
//========================================================m_statusExplosionFiring=====================
void HandlerVehicle::spreadShotsInVolleys(int shots, int volleys)
{
  m_shotsInVolley.clear();
  m_pauseAfterVolley.clear();
  qint64 pauseTime = m_statusExplosionFiring.remainingTime_s - (shots * m_timeBetweenShots);

  if (volleys == 1)
  {
    m_shotsInVolley.insert(0, shots);
    m_pauseAfterVolley.insert(0, 0);
  }
  else
  {
    while (shots > 0)
    {
      for (int volley = 0; volley < volleys; volley++)
      {
        m_shotsInVolley.insert(volley, m_shotsInVolley.value(volley) + 1);
        shots--;
        if (shots <= 0)
          break;
      }
    }

    while (pauseTime > 0)
    {
      for (int volley = 0; volley < (volleys - 1); volley++)
      {
        m_pauseAfterVolley.insert(volley, m_pauseAfterVolley.value(volley) + 1);
        pauseTime--;
        if (pauseTime <= 0)
          break;
      }
    }
  }
}

void HandlerVehicle::onVolleyStopped(int shots)
{
  DEBUG_LOG() << "Volles Stopped after " << shots << " rounds";
  //m_statusExplosionFiring.remainingTime_s = 0;
  //stopp timer and take current seconds
  m_remainingTimer->stop();
  m_volleyTimer->stop();
  m_statusExplosionFiring.remainingShots = m_statusExplosionFiring.remainingShots - shots;

  if (m_statusExplosionFiring.remainingVolley > 0 && shots > 0)
  {
    m_oldTime = m_statusExplosionFiring.remainingTime_s;

    m_currentVolley++;
    m_statusExplosionFiring.remainingVolley--;
    if (m_statusExplosionFiring.remainingShots > 0 && m_statusExplosionFiring.remainingVolley <= 0)
    {
      m_statusExplosionFiring.remainingVolley = 1;
      m_currentVolley--;
    }
  }
  emit statusExplosionFiring(m_statusExplosionFiring);
}

void HandlerVehicle::onVolleyFinished(int shots)
{
  DEBUG_LOG() << "Volley finished after shots: " <<  shots;
  m_remainingTimer->stop();
  if (m_volleyTimer->isActive())
    m_volleyTimer->stop();

  m_statusExplosionFiring.remainingShots = m_statusExplosionFiring.remainingShots - shots;

  //calc remaining time
  qint64 pauseTime = 0;
  if (m_currentVolley > 0)
    pauseTime = m_pauseAfterVolley.value(m_currentVolley - 1);

  //m_statusExplosionFiring.remainingTime_s = m_statusExplosionFiring.remainingTime_s - (m_timeBetweenShots * (shots - 1)) - pauseTime;
  m_statusExplosionFiring.remainingTime_s = m_oldTime - (m_timeBetweenShots * shots) - pauseTime;
  DEBUG_LOG() << "Remaining time: " << m_statusExplosionFiring.remainingTime_s;
  m_oldTime = m_statusExplosionFiring.remainingTime_s;
  if (m_statusExplosionFiring.remainingTime_s < 0 || m_statusExplosionFiring.remainingShots == 0)
    m_statusExplosionFiring.remainingTime_s = 0;
  if (m_statusExplosionFiring.remainingShots < 0)
    m_statusExplosionFiring.remainingShots = 0;

  if (m_statusExplosionFiring.remainingVolley > 0)
    m_statusExplosionFiring.remainingVolley--;

  emit statusExplosionFiring(m_statusExplosionFiring);

  if (m_statusExplosionFiring.remainingShots > 0 && m_statusExplosionFiring.remainingTime_s > 0)
  {
    m_volleyTimer->start(m_pauseAfterVolley.value(m_currentVolley));
    m_remainingTimer->start();
  }
  else
  {
    //finished now so revoke
    m_mainHandler->handlerControlUnit()->send(CommandSignal::FT_SE_CB_SICHERHEIT_WIDERRUFEN);
  }
  m_currentVolley++;
}

void HandlerVehicle::onStartVolley()
{
  DEBUG_LOG() << "Send Start Volley";
  if (!m_remainingTimer->isActive())
    m_remainingTimer->start();
  if (m_volleyTimer->isActive())
    m_volleyTimer->stop();
  m_mainHandler->handlerControlUnit()->send(CommandSignal::FT_SE_CB_WERFER_STATUS, m_shotsInVolley.value(m_currentVolley));
}

void HandlerVehicle::onRemainingTimerTimeOut()
{
  m_statusExplosionFiring.remainingTime_s -= 1000;
  if (m_statusExplosionFiring.remainingTime_s < 0)
    m_statusExplosionFiring.remainingTime_s = 0;
  if (m_statusExplosionFiring.remainingTime_s == 0)
  {
    m_remainingTimer->stop();
    if (m_volleyTimer->isActive())
      m_volleyTimer->stop();
  }
  emit statusExplosionFiring(m_statusExplosionFiring);
}

} // namespace EffectShowClient