vreLaunchExpendableResourceController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreLaunchExpendableResourceController.h
//! \ingroup vreVrfmodel
//! \brief Controller for launching expendable resources
//!
//! This file defines the DtVreLaunchExpendableResourceController class which extends
//! the base launch expendable resource controller to publish auto-launch state information
//! and provide additional countermeasure management capabilities.
 
#pragma once
 
#include <vreVrfmodel/export.h>
#include <vreVrfModel/vreSimComponent.h>
 
#include <vreMessageManager/vreMessage.h>
 
#include <vrfmodel/launchExpendableResourceController.h>
 
namespace makVre
{
//! \brief Type identifier for the VRE launch expendable resource controller component
const char DtVreLaunchExpendableResourceControllerType[] = "vre-launch-expendable-resource-controller";
 
//! \brief Controller for managing and deploying expendable resources
//!
//! DtVreLaunchExpendableResourceController extends the base launch controller to publish
//! whether auto-launch capability is enabled. It manages countermeasures such as chaff
//! and flares, tracks their counts, and handles deployment logic based on threats and
//! configuration settings. This controller provides additional state information for
//! VR-Engage user interfaces.
//!
//! Uses Descriptor Type: DtLaunchExpendableResourceControllerDescriptor
class VREVRFMODEL_DLL DtVreLaunchExpendableResourceController
   : public DtVreSimComponent<DtLaunchExpendableResourceController>
{
public:
   //! \brief Constructor
   //! \param name The name of this component
   //! \param owner The local object that owns this component
   //! \param simManager The simulation services manager
   //! \param desc Component descriptor with configuration parameters
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new launch expendable resource controller with the specified parameters.
   DtVreLaunchExpendableResourceController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = NULL, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the launch expendable resource controller.
   virtual ~DtVreLaunchExpendableResourceController() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreLaunchExpendableResourceControllerType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Copy constructor
   //! \param orig The source object to copy from
   //!
   //! Creates a new controller as a copy of an existing one.
   DtVreLaunchExpendableResourceController(const DtVreLaunchExpendableResourceController& orig);
 
   //! \brief Assignment operator
   //! \param orig The source object to assign from
   //! \return Reference to this object after assignment
   //!
   //! Assigns the state of another controller to this one.
   DtVreLaunchExpendableResourceController& operator=(const DtVreLaunchExpendableResourceController& orig);
 
   //! \brief Handles countermeasure configuration request messages
   //! \param msg The message containing configuration parameters
   //! \return Message processing result indicating success or failure
   //!
   //! Processes countermeasure configuration request messages, which can
   //! include settings for auto-launch capability and other countermeasure
   //! deployment parameters.
   virtual DtVreMessageResult handleCmConfigRequest(DtVreMessage* msg);
 
   //! \brief Performs initialization before the first simulation tick
   //!
   //! Overridden to set auto-launch on/off state as extended data.
   //! This ensures that the auto-launch capability state is properly
   //! initialized and published before simulation begins.
   virtual void preFirstTickInit() override;
   //! \brief Updates the controller state each simulation frame
   //!
   //! Processes expendable resource management operations during each simulation frame.
   //! This includes checking for threats that might trigger automatic countermeasure
   //! deployment and updating counters for available countermeasures.
   virtual void tick() override;
 
   //! \brief Initializes the launch expendable resource controller
   //! \return True if initialization is successful, false otherwise
   //!
   //! Performs initial setup of the controller, including setting up
   //! initial countermeasure counts and auto-launch state. This method
   //! is called during component initialization.
   virtual bool init() override;
 
   //! \brief Factory method to create a new instance of this component
   //! \param name The name for the new component
   //! \param owner The local object that will own this component
   //! \param simManager The simulation services manager
   //! \param desc Component descriptor with configuration parameters
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //! \return Pointer to the newly created component
   //!
   //! Static factory method used by the component creation system to instantiate
   //! new instances of this component type.
   static DtSimComponent* creator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc, DtReaderWriterRegistry* parentRegistry);
 
protected:
   //! \brief Sends countermeasure state update to clients
   //!
   //! Updates relevant systems with the current countermeasure configuration
   //! and state information. This includes auto-launch status and available
   //! countermeasure counts, allowing user interfaces and other components
   //! to display accurate information.
   virtual void sendCmUpdate();
 
   //! \brief Looks up resources by old resource style name string and converts to entity type
   virtual DtSimResource* lookupExpendableResource(const DtString& resourceName, int& quantity);
 
protected:
   //! \brief Flag indicating whether automatic countermeasure launch is enabled
   //!
   //! When true, indicates that the system will automatically deploy countermeasures
   //! in response to detected threats without requiring explicit user action.
   bool myAutoLaunchEnabled;
 
   //! \brief Current count of available chaff countermeasures
   //!
   //! Tracks the number of chaff countermeasures available for deployment.
   //! Chaff is typically used to counter radar-guided threats.
   int myChaffCount;
 
   //! \brief Current count of available flare countermeasures
   //!
   //! Tracks the number of flare countermeasures available for deployment.
   //! Flares are typically used to counter infrared-guided threats.
   int myFlareCount;
};
 
} // namespace makVre