vreScriptReactiveTaskController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreScriptReactiveTaskController.h
//! \ingroup vreVrfmodel
//! \brief Controller for managing role-based reactive task scripts
//!
//! This file defines the DtVreScriptReactiveTaskController class which extends
//! the script reactive task controller to provide role-based filtering of
//! reactive tasks. It enables or disables reactive task scripts based on the
//! currently engaged roles on an entity.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include "vreVrfmodel/vreSimComponent.h"
 
#include <vrfobjcore/scriptReactiveTaskController.h>
 
namespace makVre
{
class DtVreScriptReactiveTaskControllerDescriptor;
 
//! \brief Type identifier for the VRE script reactive task controller component
const char DtVreScriptReactiveTaskControllerType[] = "vre-script-reactive-task-controller";
 
//! \brief Controller for managing role-based reactive task scripts
//!
//! DtVreScriptReactiveTaskController extends the script reactive task controller
//! to provide role-based filtering of reactive tasks. It tracks which roles are
//! currently engaged on an entity and enables or disables reactive task scripts
//! based on role permissions defined in the component's descriptor. This allows
//! for dynamic adjustment of entity behavior based on current role assignments.
class VREVRFMODEL_DLL DtVreScriptReactiveTaskController : public DtVreSimComponent<DtScriptReactiveTaskController>
{
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 script reactive task controller component with the specified parameters.
   //! Initializes the role-based reactive task management system.
   DtVreScriptReactiveTaskController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc, DtReaderWriterRegistry* parentRegistry);
 
   //! \brief Updates the controller state each simulation frame
   //!
   //! Overridden to check if any reactive tasks should be enabled or disabled
   //! based on what roles are currently engaged on the entity. If the engaged
   //! roles have changed since the last tick, updates the reactive tasks accordingly.
   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, DtReaderWriterRegistry* parentRegistry);
 
   //! \brief Determines if a reactive task script should be enabled
   //! \param scriptName The name of the script to check
   //! \param currentRoles The set of roles currently engaged on the entity
   //! \return True if the script should be enabled, false otherwise
   //!
   //! Determines whether a reactive task script should be enabled or disabled
   //! based on the allowed scripts configuration passed in through the descriptor
   //! and the currently engaged roles. A script is enabled if any of the current
   //! roles match the roles allowed for that script.
   virtual bool shouldScriptBeEnabled(const DtString& scriptName, const std::set<std::string>& currentRoles) const;
 
protected:
   //! \brief Updates all reactive tasks based on current roles
   //! \param currentRoles The set of roles currently engaged on the entity
   //!
   //! Updates all the reactive tasks for the current entity by iterating through
   //! each task and calling shouldScriptBeEnabled() to determine if it should be
   //! enabled or disabled. Then applies those settings to the reactive tasks.
   virtual void updateReactiveTasks(const std::set<std::string>& currentRoles);
 
   //! \brief Retrieves the set of roles currently engaged on the entity
   //! \param roles Output parameter to be populated with the current roles
   //!
   //! Populates the provided set with the names of all roles currently
   //! engaged on the entity. This information is used to determine which
   //! reactive tasks should be enabled.
   virtual void getRolesEngagedOnEntity(std::set<std::string>& roles);
 
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtVreScriptReactiveTaskController();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreScriptReactiveTaskController(const DtVreScriptReactiveTaskController& other);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   DtVreScriptReactiveTaskController& operator=(const DtVreScriptReactiveTaskController& other);
 
protected:
   //! \brief Pointer to the component's descriptor
   //!
   //! Contains the configuration parameters for this component, including
   //! the mapping of scripts to their allowed roles.
   DtVreScriptReactiveTaskControllerDescriptor* myDescriptor;
 
   //! \brief Set of roles that were engaged during the last tick
   //!
   //! Stores the set of role names that were engaged on the entity during
   //! the previous simulation frame. Used to detect changes in engaged roles.
   std::set<std::string> myLastTickRolesEngaged;
 
   //! \brief Mapping of script IDs to their allowed roles
   //!
   //! Maps each script ID to a vector of role names that are allowed to
   //! enable that script. A script is enabled if any of the current roles
   //! match any of the allowed roles for that script.
   std::map<DtString, std::vector<std::string>> myScriptIdsWithRolesToAllow;
};
 
} // namespace makVre