weaponResourceLogic.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file weaponResourceLogic.h
//! \brief Component for managing weapon resources and related state attributes
//! \ingroup vreCommonComponents
 
#pragma once
 
#include "vreCommonComponents/export.h"
 
#include "vrePlayerStation/playerComponent.h"
 
#include "vreMessageManager/vreMessage.h"
 
namespace makVre
{
 
namespace WeaponResourceLogicConfig
{
//! \ingroup RoleConfigParams
//! \defgroup WeaponResourceLogicRoleParams Weapon Resource Logic Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for weaponResourceLogic role.
//! @{
 
//! \vreRoleParam{resourceMappings,table,{},weaponResourceLogic,Configuration table mapping resource names to display names and properties.}
constexpr const char* resourceMappings = "resourceMappings";
 
//! @}
} // namespace WeaponResourceLogicConfig
 
//! \brief Type identifier for DtWeaponResourceLogic component
constexpr const char* DtWeaponResourceLogicType = "DtWeaponResourceLogic";
 
//! \brief Component for managing weapon resources, equipment, and related state attributes
//!
//! DtWeaponResourceLogic tracks available weapon systems and munitions, processes
//! resource list updates from simulation state messages, and maintains weapon-related
//! state attributes. It maps between internal system names and human-readable names,
//! handles resource dependencies, and enables weapons based on equipment availability.
class VRECOMMONCOMPONENTS_DLL DtWeaponResourceLogic : public DtPlayerComponent
{
public:
   //! \brief Constructor for DtWeaponResourceLogic
   //!
   //! Initializes the component with default settings
   DtWeaponResourceLogic();
 
   //! \brief Virtual destructor for DtWeaponResourceLogic
   virtual ~DtWeaponResourceLogic() override;
 
   //! \brief Initializes the weapon resource logic component
   //! \param player Pointer to the player station this component belongs to
   //! \param config Configuration table containing resource mappings
   //! \return True if initialization succeeded, false otherwise
   //!
   //! Reads resource mappings configuration, initializes state attributes,
   //! and sets up message handlers for simulation state updates
   virtual bool initialize(makVre::DtPlayerStation* player, makVre::DtInitTable& config) override;
   //! \brief Performs post-initialization after all components are initialized
   //! \return True if post-initialization succeeded, false otherwise
   //!
   //! Updates the weapon list based on the current resource list
   virtual bool postInitialize() override;
 
   //! \brief Called every frame to update component state
   //! \param dt Delta time since the last frame in seconds
   //!
   //! Current implementation is empty as updates occur through message handlers
   virtual void tick(double dt) override;
   //! \brief Shuts down the weapon resource logic component
   //!
   //! Removes message handlers and attribute change callbacks
   virtual void shutdown() override;
 
   //! \brief Returns the type identifier for this component
   //! \return The type string for DtWeaponResourceLogic
   virtual const char* type() const override;
 
   //! \brief Gets a list of all resource mappings keys
   //! \return Vector of strings containing all resource mapping keys
   //!
   //! Returns the list of all keys in the resource mappings table
   virtual std::vector<std::string> resourceMappingKeys();
 
   //! \brief Looks up the human-readable short name for a resource
   //! \param vrfResourceName Resource name in VRF format (possibly with system prefix)
   //! \return Short name for the resource or the original name if not found
   //!
   //! Retrieves the human-readable short name for a given resource
   virtual std::string lookUpShortName(const std::string& vrfResourceName);
 
   //! \brief Looks up the diguy hand item for a resource
   //! \param vrfResourceName Resource name in VRF format
   //! \return Hand item name or "default" if not found
   //!
   //! Retrieves the diguy hand item corresponding to a resource
   virtual std::string lookUpDiguyHandItem(const std::string& vrfResourceName);
 
   //! \brief Finds a resource name by matching against an entity type
   //! \param equipmentType Entity type to match against patterns
   //! \return Resource name if a match is found, empty string otherwise
   //!
   //! Finds the resource name (table key) by checking a deployed equipment type against the
   //! patterns in the "deployedEquipmentTypes" table. The pattern represents the external entity
   //! the ownship entity is currently using (such as a tripod-mounted launcher).
   virtual std::string lookUpResourceByDeployedEquipment(const DtEntityType& equipmentType);
 
   //! \brief Checks if a hand item matches a resource
   //! \param vrfResourceName Resource name in VRF format
   //! \param handItem Hand item to check for a match
   //! \return True if the hand item matches this resource, false otherwise
   //!
   //! Determines if a hand item matches either the primary diguy hand item
   //! or one of the alternative items in the itemMatches list
   virtual bool doesHandItemMatch(const std::string& vrfResourceName, const std::string& handItem);
 
   //! \brief Looks up a field value for a resource in the resource mappings table
   //! \tparam T Type of the field value to retrieve
   //! \param resource Resource name in VRF format (possibly with system prefix)
   //! \param field Name of the field to look up
   //! \param defaultValue Default value to return if the field is not found
   //! \return Value of the field or defaultValue if not found
   //!
   //! Retrieves a field value from the resource mappings table, handling cases where
   //! the resource name may include system prefixes or contain special characters
   template <typename T>
   T lookUpField(std::string resource, const std::string& field, T defaultValue);
 
protected:
   //! \brief Handles resource update
   //! \param msg Resource update
   //! \return Message handling result indicating if the message was handled
   //!
   //! Processes resource updates to update resource and equipment information
   virtual makVre::DtVreMessageResult handleResourceUpdate(makVre::DtVreMessage* msg);
 
   virtual void resourceChanged(const DtAttributeHandle& changed);
 
   virtual void addWeaponToList(const std::string& resource);
 
   virtual void removeWeaponFromList(const std::string& resource);
 
   //! \brief Configuration table containing resource mappings
   DtInitTable myResourceMappings;
 
   DtAttributeHandleType<std::vector<std::string>> myResourceStore;
 
   DtAttributeChangeCallback myResourceCallback;
};
} // namespace makVre
 
 
template <typename T>
T makVre::DtWeaponResourceLogic::lookUpField(std::string resource, const std::string& field, T defaultValue)
{
   if (myResourceMappings.isValid())
   {
      // Note the use of "false" when looking for the resource config item in the resourceMappings table.
      // This is necessary because the keys in resourceMappings are munition names, and munition names
      // can have dots in them, which would by default be interpreted as a lua sub-object delimiter, and
      // the lookup would fail. The optional "false" parameter skips the dot resolution and treats the
      // entire string as a single lua object name.
 
      // Find the config table for the given resource/munition
      if (myResourceMappings.hasField(resource, false))
      {
         DtInitTable resourceEntry = myResourceMappings.findData<DtInitTable>(resource, false);
 
         // And return the requested field for this resource
         if (resourceEntry.hasField(field))
         {
            return resourceEntry.findData<T>(field);
         }
      }
   }
 
   LOG_DEBUG("Resource monitor") << "Could not find " << field << " for VRF resource: " << resource << std::endl;
 
   return defaultValue;
}