vreLauncherController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
 
//! \file vreLauncherController.h
//! \ingroup vreVrfmodel
//! \brief Controller for missile launcher systems
//!
//! This file defines the DtVreLauncherController class which extends
//! the base launcher controller to add VR-Engage specific functionality,
//! including equipment status tracking and resource management.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include "vreVrfmodel/vreSimComponent.h"
 
#include <vrfmodel/launcherController.h>
 
class DtSimResource;
 
namespace makVre
{
//! \brief Type identifier for the VRE launcher controller component
const char* DtVreLauncherControllerType = "vre-missile-launcher-controller";
 
class DtVreWeaponControllerDescriptor;
 
//! \brief Controller for missile launcher systems with equipment status tracking
//!
//! DtVreLauncherController extends the base launcher controller to add
//! equipment status monitoring functionality. It tracks the state of
//! associated equipment resources and updates weapon availability based
//! on the equipment status. This allows for disabling missile systems
//! when the associated equipment is damaged or unavailable.
class VREVRFMODEL_DLL DtVreLauncherController : public DtVreSimComponent<DtLauncherController>
{
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 launcher controller component with the specified parameters.
   DtVreLauncherController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the launcher controller component.
   virtual ~DtVreLauncherController() override;
 
   //! \brief Default constructor (deleted)
   //!
   //! Default constructor is deleted to prevent creation of instances
   //! without proper initialization.
   DtVreLauncherController() = delete;
 
   //! \brief Copy constructor (deleted)
   //!
   //! Copy constructor is deleted to prevent copy construction.
   DtVreLauncherController(const DtVreLauncherController& orig) = delete;
 
   //! \brief Assignment operator (deleted)
   //! \return Reference to this object
   //!
   //! Assignment operator is deleted to prevent assignment.
   const DtVreLauncherController& operator=(const DtVreLauncherController& orig) = delete;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreLauncherControllerType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Updates the controller state each simulation frame
   //!
   //! Checks myEquipmentResource. If it's null, attempts to look it up and cache it,
   //! which will happen after a reset. If myEquipmentResource is non-null, updates
   //! the DtWeaponComponentInterface::DT_WEAPON_DISABLED flag based on whether or not
   //! the value of this resource is non-zero. This allows the weapon system to be
   //! disabled when the associated equipment is damaged or unavailable.
   virtual void tick() 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 Optional component descriptor
   //! \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 = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Handles component restoration
   //!
   //! Called whenever a component is restored from a saved state.
   //! Sets myEquipmentResource to null, forcing it to be looked up
   //! again on the next tick. This ensures proper initialization
   //! after scenario restoration.
   virtual void onRestore() override;
 
protected:
   //! \brief Performs initialization before the first simulation tick
   //!
   //! Initializes the myMissileSimObjectFacadeMap and performs other
   //! one-time initialization tasks that must be completed before the
   //! first simulation tick occurs.
   virtual void preFirstTickInit() override;
 
protected:
   //! \brief Pointer to the equipment resource being monitored
   //!
   //! Stores a reference to the equipment resource that affects the availability
   //! of this launcher system. When this resource value becomes zero (indicating
   //! damaged or unavailable equipment), the launcher is disabled.
   DtSimResource* myEquipmentResource;
 
private:
   //! \brief Looks up the appropriate equipment resource
   //! \return Pointer to the equipment resource, or nullptr if not found
   //!
   //! Searches for and returns a pointer to the equipment resource that
   //! affects this launcher's availability. This method is called when
   //! the resource pointer is null, typically after initialization or reset.
   virtual DtSimResource* lookupEquipmentResource();
};
} // namespace makVre