weaponsStatusController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file weaponsStatusController.h
//! \ingroup vreVrfmodel
//! \brief Controller for managing weapon systems status and selection
//!
//! This file defines the DtWeaponsStatusController class which manages
//! weapon systems status information, weapon selection, and handling of
//! weapon-related commands. It maintains state properties for weapon status
//! and provides interfaces for cycling through available weapons.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include "vreVrfmodel/vreSimComponent.h"
 
#include <vrfmodel/joystickControllerInterface.h>
#include <vreMessages/WeaponConfigResponse.h>
 
namespace makVre
{
//! \brief Type identifier for the weapon status controller component
const char* DtWeaponStatusControllerType = "weapon-status-controller";
 
//! \brief Controller for managing weapon systems status and selection
//!
//! DtWeaponsStatusController monitors and updates weapon systems status information
//! for an entity. It manages the SelectedWeapon and WeaponsStatus state properties,
//! and handles "CycleWeapon" commands to change the currently selected weapon system.
//! The controller maintains a map of weapon configurations, tracks ammunition levels,
//! and publishes this information for use by the VR-Engage interface.
//!
//! This component is responsible for determining valid weapon selections based on
//! the availability of ammunition and updating state properties to reflect current
//! weapon status for the entity.
//!
//! Uses Descriptor Type: DtWeaponsStatusControllerDescriptor
class VREVRFMODEL_DLL DtWeaponsStatusController : public DtVreSimComponent<DtSimComponent>,
                                                  public DtJoystickControllerInterface
{
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 weapon status controller component with the specified parameters.
   //! Initializes the weapon status tracking system.
   DtWeaponsStatusController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the weapon status controller component.
   virtual ~DtWeaponsStatusController() override;
 
   //! \brief Initializes the controller before the first tick
   //! \return None
   //!
   //! Sets up state properties for weapon status tracking. This initialization
   //! relies on other systems already being initialized, so it can't be done
   //! in the init() method itself. Initializes weapon configurations and
   //! establishes initial weapon selection state.
   virtual void preFirstTickInit() override;
 
   //! \brief Initializes the controller
   //! \return True if initialization was successful, false otherwise
   //!
   //! Initializes the weapon status controller, adding a setRestore callback
   //! for reinitializing state properties when the entity is restored.
   //! Also registers message handlers for weapon configuration requests.
   virtual bool init() override;
 
   //! \brief Updates the controller state each simulation frame
   //!
   //! Updates weapon status properties each frame, tracking ammunition levels
   //! and selected weapon state. Handles both player-controlled and non-player
   //! controlled states, with different update behaviors for each.
   virtual void tick() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtWeaponStatusControllerType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const 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 Processes joystick input for weapon cycling
   //! \param functionGroup The function group identifier for the input
   //! \param function The specific function name for the input
   //! \param value The input value (typically in range [-1.0, 1.0])
   //! \param repeat Flag indicating whether the function should repeat
   //!
   //! Handles the "CycleWeapon" joystick function by selecting the next
   //! weapon that has ammunition, or "None" if no weapons with ammunition are available.
   //! This allows players to quickly cycle through available weapons using joystick inputs.
   virtual void calcAndSetPortValues(
      const DtString& functionGroup, const DtString& function, double value, bool repeat) override;
 
   //! \brief Gets the count of a specific munition resource
   //! \param munitionName The name of the munition resource to count
   //! \return The number of units of the specified munition available
   //!
   //! Retrieves the current count of a specific munition resource by name.
   //! Returns 0 if the resource is not found or depleted.
   virtual int munitionResourceCount(const DtEntityType& munitionName) const;
 
protected:
   //! \brief Initializes weapon configurations from entity's weapon systems
   //! \return True if weapon configurations were successfully initialized, false otherwise
   //!
   //! Sets up the weapon configuration map from the entity's weapon systems.
   //! Identifies and catalogs all weapon systems on the entity, setting up
   //! the data structures needed to track their status.
   virtual void initWeaponConfigs();
 
   //! \brief Adds a weapon configuration for a specific weapon system
   //! \param system The component system representing a weapon system
   //! \param postfix The suffix to add to the weapon category name
   //!
   //! Adds a weapon configuration for the specified weapon system to the
   //! weapon configuration map. The postfix parameter is used to distinguish
   //! between multiple weapon systems of the same category.
   virtual void addWeaponConfig(DtComponentSystem* system, const std::string& postfix);
 
   virtual void updateAmmo();
 
   //! \brief Sends a weapon configuration response message
   //!
   //! Constructs and sends a response message containing detailed information
   //! about all weapon configurations on the entity. This includes weapon categories,
   //! ammunition types, ranges, and other properties.
   virtual void sendWeaponConfig();
 
   virtual void sendAmmoUpdate(const std::string& weapon, const DtEntityType& munition, int count);
 
   //! \brief Handles weapon configuration request messages
   //! \param msg The message containing the weapon configuration request
   //! \return Message processing result indicating success or failure
   //!
   //! Processes messages requesting information about the entity's weapon
   //! configurations. Triggers the sending of a weapon configuration response.
   virtual DtVreMessageResult handleWeaponConfigRequestMessage(DtVreMessage* msg);
 
   //! \brief Handles weapon selection messages
   //! \param msg The message containing the weapon selection request
   //! \return Message processing result indicating success or failure
   //!
   //! Processes messages requesting the selection of a specific weapon category.
   //! Updates the selected weapon state property and related weapon status information.
   virtual DtVreMessageResult handleWeaponConfigSelectWeapon(DtVreMessage* msg);
 
   //! \brief Static callback function for set restore messages
   //! \param msg The simulation message containing restore information
   //! \param usrData User data pointer, typically pointing to an instance of this class
   //!
   //! Static function registered as a callback to handle set restore messages.
   //! Forwards the message to the appropriate instance's processSetRestore method.
   static void setRestoreCallback(DtSimMessage* msg, void* usrData);
 
   //! \brief Reinitializes state properties during entity restoration
   //! \param msg The simulation message containing restore information
   //!
   //! Reinitializes weapon status state properties when a set restore operation
   //! is executed. Ensures that weapon configurations and status information
   //! are properly restored after entity restoration.
   virtual void processSetRestore(DtSimMessage* msg);
 
   //! \brief Finds the next weapon system category to select
   //! \return String containing the category name of the next weapon system
   //!
   //! Finds the category for the next weapon system to select, using the order
   //! defined in the descriptor if it exists, or falling back on the order of
   //! elements in the state property. Only considers weapon systems that have
   //! ammunition available.
   virtual bool selectNextWeapon();
 
   virtual bool selectWeapon(const DtString& selection);
 
   //! \brief Updates range information for the selected weapon system
   //!
   //! Clears the existing range items in state properties, then adds minimum,
   //! optimal, and maximum range values for the selected weapon system.
   //! This information is used by the UI to display weapon range indicators.
   virtual void updateRangeItems();
 
   //! \brief Handles joystick connection events
   //!
   //! Required by the DtJoystickControllerInterface but implemented as a no-op
   //! since no special handling is needed when a joystick is connected.
   virtual void joystickConnected() override;
 
   //! \brief Handles joystick disconnection events
   //!
   //! Required by the DtJoystickControllerInterface but implemented as a no-op
   //! since no special handling is needed when a joystick is disconnected.
   virtual void joystickDisconnected() override;
 
   DtRwPropertiesMap& getWeaponsStatusMap();
 
   DtRwPropertyString& getCurrentWeapon();
 
   //! \brief Replenishes fuel and ammunition resources
   //!
   //! Restores all fuel and ammunition resources to their maximum levels.
   //! Used during entity restoration or for gameplay mechanics that
   //! provide resource replenishment.
   virtual void replenishFuelAndAmmo();
 
protected:
   //! \brief Flag tracking player control state
   //!
   //! Used to track when a player first takes control of the entity, in order
   //! to trigger a full update of weapon status property values. Helps ensure
   //! that the interface shows current values when a player first engages control.
   bool myWasPlayerControlled;
 
   //! \brief Flag indicating if entity has weapon systems
   //!
   //! True if the ownship entity has weapon systems that need to be updated.
   //! Used to optimize performance by skipping weapon updates for entities
   //! that don't have weapons.
   bool myHasWeaponSystems;
 
   //! \brief Ordered list of weapon categories for cycling
   //!
   //! Defines the order to cycle through weapon categories. Either specified in
   //! the descriptor or determined by the order the weapon systems are defined
   //! in the entity file. Used when cycling through weapons with joystick inputs.
   std::vector<std::string> myWeaponCycleOrder;
 
   std::vector<WeaponConfigResponseMessage::WeaponConfig> myWeaponConfigCache;
   std::map<DtEntityType, unsigned int> myAmmoCache;
 
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtWeaponsStatusController();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtWeaponsStatusController(const DtWeaponsStatusController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtWeaponsStatusController& operator=(const DtWeaponsStatusController& orig);
};
 
} // namespace makVre