humanMenuLogic.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file humanMenuLogic.h
//! \brief Defines DtHumanMenuLogic for managing human-specific menu interactions
//! \ingroup vreHumanFrontend
 
#pragma once
 
#include "vreHumanFrontend/export.h"
 
#include "vrePlayerStation/playerComponent.h"
#include "vreMessageManager/vreMessage.h"
 
#include <string>
 
namespace makVre
{
//! \brief Forward declaration of the action menu logic class
class DtActionMenuLogic;
 
//! \brief Forward declaration of the human control logic class
class DtHumanControlLogic;
 
namespace HumanMenuLogicConfig
{
//! \ingroup RoleConfigParams
//! \defgroup HumanMenuLogicRoleParams Human Menu Logic Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for humanMenuLogic role.
//! @{
 
//! \vreRoleParam{shooteeName,string,"target",humanMenuLogic,Default name for entities to be used as shooting targets.}
constexpr const char* shooteeName = "shooteeName";
 
//! \vreRoleParam{taskeeName,string,"shooter",humanMenuLogic,Default name for entities to be assigned tasks.}
constexpr const char* taskeeName = "taskeeName";
 
//! \vreRoleParam{waypointName,string,"Waypoint 1",humanMenuLogic,Default name for waypoints in movement tasks.}
constexpr const char* waypointName = "waypointName";
 
//! @}
} // namespace HumanMenuLogicConfig
 
//! \brief Type identifier constant for DtHumanMenuLogic components
//!
//! This constant defines the string identifier used to identify DtHumanMenuLogic
//! component types within the VR-Engage framework. It is used for component
//! registration, type checking, and serialization operations.
constexpr const char* DtHumanMenuLogicType = "DtHumanMenuLogic";
 
//! \brief Menu logic component for the human role
//!
//! DtHumanMenuLogic manages context-sensitive menus and commands for the human
//! entity, handling interactions with other entities, task selections, and special
//! actions. It processes menu selections and converts them into appropriate
//! simulation commands.
class HUMAN_DLL DtHumanMenuLogic : public DtPlayerComponent
{
public:
   //! \brief Default constructor
   DtHumanMenuLogic();
 
   //! \brief Virtual destructor
   virtual ~DtHumanMenuLogic() override;
 
   //! \brief Initializes the menu logic component
   //! \param player Pointer to the player station
   //! \param config Configuration settings for initialization
   //! \return True if initialization was successful, false otherwise
   virtual bool initialize(DtPlayerStation* player, DtInitTable& config) override;
 
   //! \brief Performs post-initialization setup
   //! \return True if post-initialization was successful, false otherwise
   virtual bool postInitialize() override;
 
   //! \brief Updates menu logic for the current frame
   //! \param dt Delta time since the last frame in seconds
   virtual void tick(double dt) override;
 
   //! \brief Cleans up resources when the component is being shut down
   virtual void shutdown() override;
 
   //! \brief Returns the component type identifier
   //! \return String identifier for this component type
   //!
   //! Returns the type identifier string for this component, which is used
   //! by the VR-Engage framework for component identification and management.
   //! The returned value matches DtHumanMenuLogicType.
   virtual const char* type() const override;
 
   //! \brief Handles menu-related messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   virtual makVre::DtVreMessageResult handleMenuMessage(makVre::DtVreMessage* msg);
 
protected:
   //! \brief Handles entity realized messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   virtual makVre::DtVreMessageResult handleEntityRealized(makVre::DtVreMessage* msg);
 
   //! \brief Handles entity removed messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   virtual makVre::DtVreMessageResult handleEntityRemoved(makVre::DtVreMessage* msg);
 
   //! \brief Initializes the list of available sensor views
   virtual void initSensorViewsList();
 
   //! \brief Checks if an entity is a sensor-capable aircraft
   //! \param type Type of the entity to check
   //! \return True if the entity is a sensor-capable aircraft, false otherwise
   virtual bool isSensorCapableAircraft(const DtEntityType& type) const;
 
   //! \brief Tasks an entity to move to the current view location
   virtual void taskMoveToViewLocation();
 
   //! \brief Tasks an entity to move to the player's location
   virtual void taskMoveToMyLocation();
 
   //! \brief Tasks an entity to move to a specific waypoint
   virtual void taskMoveToWaypoint();
 
   //! \brief Tasks an entity to fire at a target
   virtual void taskFireTarget();
 
   //! \brief Tasks an entity to suppress fire
   virtual void taskSupressFire();
 
   //! \brief Tasks an entity to follow the player
   virtual void taskFollowMe();
 
   //! \brief Disembarks the player from the current vehicle
   virtual void disembarkEntity();
 
   //! \brief Tasks an entity to execute a DI-Guy animated gesture
   //! \param gestureName Name of the gesture to execute
   //!
   //! Names of available gestures can be found in data\Lifeforms\diguy\gestures.cgf.
   virtual void taskDiGuyGesture(const std::string& gestureName);
 
   //! \brief Tasks an entity to execute a DI-Guy animated action
   //! \param actionName Name of the action to execute
   //!
   //! Names of available actions can be found in the action table for
   //! a given DI-Guy character, in data\Lifeforms\diguy.
   virtual void taskDiGuyAction(const std::string& actionName);
 
protected:
   //! \brief Entity ID of the current taskee
   std::string myTaskee;
 
   //! \brief Entity ID of the current target
   std::string myShootee;
 
   //! \brief Current waypoint identifier
   std::string myWaypoint;
 
   //! \brief Pointer to the action menu logic component
   DtActionMenuLogic* myMenuLogic;
 
   //! \brief Pointer to the human control logic component
   DtHumanControlLogic* mySimLogic;
 
   //! \brief Current task location in the world
   DtVector myTaskLocation;
};
 
} // namespace makVre