metaRoleControlLogic.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file metaRoleControlLogic.h
//! \brief Component for managing multiple sub-roles within a single player station
//! \ingroup vreCommonComponents
 
#pragma once
 
#include "vreCommonComponents/export.h"
 
#include "vrePlayerStation/playerComponent.h"
#include "vrePlayerStation/inputLogic.h"
 
#include <map>
 
namespace makVre
{
class DtPlayerStation;
 
namespace MetaRoleControlLogicConfig
{
//! \ingroup RoleConfigParams
//! \defgroup MetaRoleControlLogicRoleParams Meta Role Control Logic Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for meta role control logic role.
//! @{
 
//! \vreRoleParamRequired{inputConfigFile,string,metaRoleControlLogic,"input/metaRole.lua",Path to the input configuration file for meta role bindings.}
constexpr const char* inputConfigFile = "inputConfigFile";
 
//! \vreRoleParam{inputConfigGroup,string,"meta",metaRoleControlLogic,Input configuration group name within the input config file.}
constexpr const char* inputConfigGroup = "inputConfigGroup";
 
//! \vreRoleParam{nextSubRoleBinding,string,"next-sub-role",metaRoleControlLogic,Input action binding name for switching to the next sub-role.}
constexpr const char* nextSubRoleBinding = "nextSubRoleBinding";
 
//! \vreRoleParamRequired{subRoles,table,metaRoleControlLogic,{"role1","role2","role3"},Array of sub-role names that this meta role can switch between.}
constexpr const char* subRoles = "subRoles";
 
//! @}
} // namespace MetaRoleControlLogicConfig
 
//! \brief Type identifier for DtMetaRoleControlLogic component
constexpr const char* DtMetaRoleControlLogicType = "DtMetaRoleControlLogic";
 
//! \brief Player component that manages multiple sub-roles as a single unified role
//!
//! DtMetaRoleControlLogic instantiates and owns multiple sub-role PlayerStation instances,
//! with input bindings to switch between them. This component creates a role that combines
//! several role definitions into one group that behaves like a single role with multiple
//! views or positions. For example, a tank crew member could switch between different
//! stations within the vehicle.
class VRECOMMONCOMPONENTS_DLL DtMetaRoleControlLogic : public DtPlayerComponent
{
public:
   //! \brief Constructor for DtMetaRoleControlLogic
   //!
   //! Initializes component state with default values
   DtMetaRoleControlLogic();
 
   //! \brief Virtual destructor for DtMetaRoleControlLogic
   virtual ~DtMetaRoleControlLogic() override;
 
   //! \brief Initializes the meta-role control component
   //! \param player Pointer to the player station this component belongs to
   //! \param config Configuration table containing meta-role settings
   //! \return True if initialization succeeded, false otherwise
   //!
   //! Loads input configuration, creates sub-role player stations based on the
   //! provided configurations, and prepares them for activation
   virtual bool initialize(DtPlayerStation* player, DtInitTable& config) override;
 
   //! \brief Performs post-initialization after all components are initialized
   //! \return True if post-initialization succeeded, false otherwise
   //!
   //! Activates the first sub-role and checks that it initialized successfully
   virtual bool postInitialize() override;
 
   //! \brief Called every frame to update the meta-role and its sub-roles
   //! \param dt Delta time since the last frame in seconds
   //!
   //! Updates all sub-role player stations, regardless of which one is active
   virtual void tick(double dt) override;
 
   //! \brief Shuts down the meta-role control component
   //!
   //! Shuts down all sub-role player stations and performs cleanup operations
   virtual void shutdown() override;
 
   //! \brief Returns the component type identifier
   //! \return The component type string
   virtual const char* type() const override;
 
   //! \brief Activates a specific sub-role by name
   //! \param station Name of the sub-role to activate
   //!
   //! Looks up the sub-role by name and activates it if found
   virtual void activateSubRole(const std::string& station);
 
   //! \brief Activates a specific sub-role by index
   //! \param index Zero-based index of the sub-role to activate
   //!
   //! Shuts down the currently active sub-role and initializes the specified one
   virtual void activateSubRole(int index);
 
   //! \brief Input handler function to switch to the next sub-role
   //! \param keyState Input value (> 0.5 to trigger the action)
   //!
   //! Cycles to the next sub-role in the list, wrapping around to the first
   //! if the current role is the last one
   virtual void nextSubRole(double keyState);
 
   //! \brief Input handler function to switch to the previous sub-role
   //! \param keyState Input value (> 0.5 to trigger the action)
   //!
   //! Cycles to the previous sub-role in the list, wrapping around to the last
   //! if the current role is the first one
   virtual void previousSubRole(double keyState);
 
protected:
   //! \brief Input logic that handles mapping of input actions to functions
   DtInputLogic myInputLogic;
 
   //! \brief Collection of all sub-role player station instances
   std::vector<DtPlayerStation*> mySubStations;
 
   //! \brief Mapping from sub-role names to their indices in mySubStations
   std::map<std::string, int> mySubStationIndex;
 
   //! \brief Index of the currently active sub-role
   int myCurrentSubStation;
 
   double myActivateDelay;
};
 
} // namespace makVre