diguyAgentParams.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2024 MAK Technologies, Inc.
 * All rights reserved.
 ****************************************************************************/

/*********************************************************************
 **
 *t  diguyAgentParams
 **
 */

#pragma once

#ifdef SWIG
%module diguyAgentParams
#else
#define CPLUSPLUS_ONLY
#endif

#ifdef CPLUSPLUS_ONLY
#include <diguyMotionPosture.h>
#include <diguyMotionSpeedType.h>
#include <diguyMotionVariant.h>

class bdiScenarioAgentParams;
class bdiScenarioAgent;
class diguyPathShape;
#endif

#include <declspec_diguy.h>
#include <diguy_constants.h>

class BDI_DECLSPEC_diguy diguyAgentParams
{

/*****************************************************************************/
public:

   /*l
    *b  Description:
    **
    **    Sets the desired posture of agent actions.
    */
   void set_posture(diguyMotionPosture posture);

   /*l
    *b  Description:
    **
    **    Returns the desired posture of agent actions.
    */
   diguyMotionPosture get_posture();

   /*l
    *b  Description:
    **
    **    Sets the desired variant of agent actions.
    */
   void set_variant( diguyMotionVariant variant );

   /*l
    *b  Description:
    **
    **    Returns the desired variant of agent actions.
    */
   diguyMotionVariant get_variant();


   /*****************************************************************************/
    /*l
     *b  Description:
     **
     **    Sets the desired behavior of the agent.
     **
     **    For information on agent behaviors see the documentation for the
     **    enumeration diguyAgentBehavior, or the DI-Guy AI User Manual.
     */
   void set_behavior( diguyAgentBehavior behavior );

   /*l
    *b  Description:
    **
    **    Returns the desired behavior of the agent.
    */
   diguyAgentBehavior get_behavior();

   /*l
    *b  Description:
    **
    **    Sets the behavior path shape of the agent.
    **
    **    Pass the name of an existing path shape in the scenario,
    **    or pass "" to un-set the behavior path shape.
    */
   void set_behavior_path_shape( const char* behavior_path_shape_name );

   /*l
    *b  Description:
    **
    **    Returns the name of the behavior path shape of the agent.
    **    If there is no behavior path shape, the string "" will be
    **    returned.
    */
   const char* get_behavior_path_shape();

   /*l
    *b  Description:
    **
    **    Sets the behavior region of the agent.
    **
    **    Pass the name of an existing region in the scenario,
    **    "(crowd region)" to specify the region associated with the
    **    agent's crowd if it has one, or "" to un-set the behavior
    **    region.
    */
   void set_behavior_region(const char* behavior_region_name);

   /*l
    *b  Description:
    **
    **    Returns the name of the behavior region of the agent.
    **    If there is no behavior region, the string "" will be
    **    returned.
    */
   const char* get_behavior_region();

   /*l
    *b  Description:
    **
    **    Sets the behavior subregion of the agent.
    */
   void set_behavior_subregion(diguySubregionIndex area);

   /*l
    *b  Description:
    **
    **    Returns the behavior subregion of the agent.
    */
   diguySubregionIndex get_behavior_subregion();

   /*l
    *b  Description:
    **
    **    Sets whether the walls of the region the agent is in
    **    are solid.  If they are, the agent will treat the walls
    **    as if they are solid walls in the environment.  If not,
    **    the agent is free to walk through them.
    **
    **    Pass 1 to make border walls solid, 0 to make them
    **    freely passable.
    */
   void set_behavior_region_border_is_solid(int is_solid);

   /*l
    *b  Description:
    **
    **    Returns whether the walls of the region the agent is in
    **    are solid.
    */
   int get_behavior_region_border_is_solid();

   /*l
    *b  Description:
    **
    **    Sets the focus character of this agent.  What this means
    **    depends on which behavior the agent is doing.  For example,
    **    when in the wander behavior, when the agent is still it
    **    will turn to face the focus character.
    **
    **    Pass the name of an existing scenario character to set
    **    a new focus character.  Pass "" to un-set the focus
    **    character.
    */
   void set_focus_character(const char* focus_character_name);

   /*l
    *b  Description:
    **
    **    Returns the name of the focus character of this agent,
    **    "" if there is none.
    */
   const char* get_focus_character();

   /*l
    *b  Description:
    **
    **    Sets the focus group of this agent.  The focus group is
    **    similar to the focus character, except that characters the
    **    agent will focus on are selected from the focus group
    **    instead of being a single character.
    **
    **    Pass the name of an existing scenario group to set
    **    a new focus group.  Pass "" to un-set the focus
    **    group.
    */
   void set_focus_group(const char* focus_group_name);

   /*l
    *b  Description:
    **
    **    Returns the name of the focus group of this agent,
    **    "" if there is none.
    */
   const char* get_focus_group();

   /*l
    *b  Description:
    **
    **    Sets the whether the agent will gaze at its focus character, or
    **    whether setting the focus leaves gaze settings alone.
    */
   void set_focus_affects_gaze(int focus_affects_gaze);

   /*l
    *b  Description:
    **
    **    Returns whether agent changes gaze settings to gaze at focus
    **    character or group.
    */
   int get_focus_affects_gaze();

   /*l
    *b  Description:
    **
    **    Sets the how far away characters in the focus group can be
    **    and still be considered as a focus character.
    */
   void set_max_focus_distance(float distance);

   /*l
    *b  Description:
    **
    **    Returns the maximum focus distance for focus groups.
    */
   float get_max_focus_distance();

   /*l
    *b  Description:
    **
    **    Sets the minimum amount of time this agent will stay in one
    **    place before moving on to a new location.  This applies to
    **    the wander and mingle behaviors.
    */
   void set_move_on_t_min(float t_min);

   /*l
    *b  Description:
    **
    **    Returns the minimum amount of time before an agent will move on
    **    to a new location in certain behaviors.
    */
   float get_move_on_t_min();

   /*l
    *b  Description:
    **
    **    Similar to set_move_on_t_min(), but sets the maximum amount of
    **    time.
    */
   void set_move_on_t_max(float t_max);

   /*l
    *b  Description:
    **
    **    Similar to get_move_on_t_min(), but returns the maximum amount of
    **    time.
    */
   float get_move_on_t_max();


/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    Sets the distance at which an attacking agent will stop and
    **    fire at its target.
    */
   void set_attack_distance(float distance);

   /*l
    *b  Description:
    **
    **    Returns the distance at which an attacking agent will stop and
    **    fire at its target.
    */
   float get_attack_distance();

   /*l
    *b  Description:
    **
    **    Sets the interval in seconds at which an attacking agent will
    **    fire its weapon when its target is in range.
    */
   void set_attack_fire_interval(float time_interval);

   /*l
    *b  Description:
    **
    **    Returns the interval in seconds at which an attacking agent will
    **    fire its weapon when its target is in range.
    */
   float get_attack_fire_interval();

   /*l
    *b  Description:
    **
    **    Sets whether agents in attack behavior will stay where they are and
    **    fire at targets of oppurtunity, or pursue targets.
    **
    **    If an agent is not told to stand its ground it can pursue its
    **    current target.  The functions set_attack_zone_enabled() and
    **    set_attack_zone() might limit the extent that the agent can pursue.
    **
    **    Set to 1 for agents to stand their ground, 0 to allow them to
    **    pursue targets.  Defaults to 0.
    */
   void set_attack_stands_ground(int value);

   /*l
    *b  Description:
    **
    **    Returns the most recent setting made by set_attack_stands_ground().
    */
   int get_attack_stands_ground();

   /*l
    *b  Description:
    **
    **    If an agent is not designated to stand its ground (see
    **    set_attack_stands_ground()), and an attack zone is enabled (see
    **    set_attack_zone_enabled()), this function sets where and how far an
    **    agent can pursue its target.
    */
   void set_attack_zone(float x, float y, float z, float radius);

   /*l
    *b  Description:
    **
    **    Returns position and radius of agent's attack zone.
    */
   int get_attack_zone(float* x, float* y, float* z, float* radius);

   /*l
    *b  Description:
    **
    **    If an attacking agent is not designated to stand its ground (see
    **    set_attack_stands_ground()) and is therefore free to pursue its
    **    target, the attack zone can limit how far it will go in pursuit.
    **
    **    Pass 1 to enable the attack zone, 0 to disable.
    */
   void set_attack_zone_enabled(int use_attack_zone);

   /*l
    *b  Description:
    **
    **    Returns 0 if zone is disabled and agents can pursue indefinitely.
    */
   int get_attack_zone_enabled();


/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    Sets the maximum distance an agent will wander from its previous
    **    waiting point.
    */
   void set_wander_max_wander_dist(float distance);

   /*l
    *b  Description:
    **
    **    Sets whether the wander behavior can change the desired
    **    orientation.
    */
   void set_wander_sets_desired_orientation(int sets_desired_orientation);


/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    Sets whether the speed match functionality is enabled.
    */
   void set_pursue_speed_match_enabled(int enabled);

   /*l
    *b  Description:
    **
    **    Returns whether speed match functionality is enabled.  If it is,
    **    agents are able to speed up their fastest animation to match
    **    their pursuit target.
    */
   int get_pursue_speed_match_enabled();

   /*l
    *b  Description:
    **
    **    Sets how often the speed match speed is reevaluated.  The default
    **    is every two seconds.
    */
   void set_pursue_speed_match_update_dt(float dt);

   /*l
    *b  Description:
    **
    **    Returns the frequency that the speed match speed is updated.
    */
   float get_pursue_speed_match_update_dt();

   /*l
    *b  Description:
    **
    **    Sets the maximum multiplier that can be applied to the fastest
    **    motion when pursuing in order to match speeds with the pursued
    **    target.
    **
    **    Example:  If an agent's fastest action moves at 3 m/s, the pursue
    **    speed match functionality will allow the character to move up
    **    to 6 m/s.
    **
    **    The default is 2x.  This allows a character with a fast
    **    movement motion to keep up with another individual that is moving
    **    faster then them, but not a fast moving vehicle.
    */
   void set_pursue_speed_match_max_factor(float factor);

   /*l
    *b  Description:
    **
    **    Returns the maximum speed multiplier the speed match code will
    **    use.
    */
   float get_pursue_speed_match_max_factor();

   /*l
    *b  Description:
    **
    **    Building block for setting up AI formations.  Sets an offset that
    **    is used by the AI to modify the pursue location.  This offset is
    **    considered to be in local space of the target and then is
    **    periodically bread-crumbed as the pursue target moves.  This avoids
    **    small movements wildly confusing the pursuer.  Often this is used
    **    with the diguyFormation class to data drive this info.
    **
    **    The z argument is currently ignored.
    */
   void set_pursue_offset(float x, float y, float z);

   /*l
    *b  Description:
    **
    **    Accessor for current values of set_pursue_offset.
    */
   int get_pursue_offset(float* x, float* y, float* z);


/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    Sets whether time advancement on the path being followed should
    **    occur when the agent is in a different behavior.
    */
   void set_path_follow_pause_t_when_off_path(int pause_t);

   /*l
    *b  Description:
    **
    **    Returns the path follow pause t flag.
    */
   int get_path_follow_pause_t_when_off_path();

   /*l
    *b  Description:
    **
    **    Sets how close the agent must be before a paused path follow will
    **    resume.
    */
   void set_path_follow_unpause_t_at_radius(float radius);

   /*l
    *b  Description:
    **
    **    Returns the resume distance of a paused path follow.
    */
   float get_path_follow_unpause_t_at_radius();

   /*l
    *b  Description:
    **
    **    Sets how far ahead on the path being followed the agent will look
    **    ahead for its desired orientation.  A value of 1.0 usually
    **    provides good results.
    */
   void set_path_follow_position_lookahead_distance(float distance);

   /*l
    *b  Description:
    **
    **    Returns the lookahead distance of a path follow.
    */
   float get_path_follow_position_lookahead_distance();


/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    Sets the untrap method used when an agent becomes wedged in a
    **    corner.
    **
    **    For information on untrap methods see the documentation
    **    for the enumeration diguyAgentUntrapMethod, or the
    **    DI-Guy AI User Manual.
    */
   void set_wedged_untrap_method(diguyAgentUntrapMethod untrap_method);

   /*l
    *b  Description:
    **
    **    Returns the wedged untrap method.
    */
   diguyAgentUntrapMethod get_wedged_untrap_method();

   /*l
    *b  Description:
    **
    **    Sets the how long, in seconds, the agent will walk into a
    **    corner before it decides it is wedged and applies the
    **    wedged untrap method.
    */
   void set_wedged_trap_time_threshold(float threshold);

   /*l
    *b  Description:
    **
    **    Returns the how long the agent will walk into a corner before
    **    it decides it is wedged.
    */
   float get_wedged_trap_time_threshold();

   /*l
    *b  Description:
    **
    **    Sets the untrap method used when an agent has not made progress
    **    toward its desired position.
    **
    **    For information on untrap methods see the documentation
    **    for the enumeration diguyAgentUntrapMethod, or the
    **    DI-Guy AI User Manual.
    */
   void set_first_no_progress_untrap_method(diguyAgentUntrapMethod untrap_method);

   /*l
    *b  Description:
    **
    **    Returns the first no progress untrap method.
    */
   diguyAgentUntrapMethod get_first_no_progress_untrap_method();

   /*l
    *b  Description:
    **
    **    Sets the how long, in seconds, the agent is willing to make
    **    no progress toward its desired position before it applies
    **    the first no progress untrap method.
    */
   void set_first_no_progress_trap_time_threshold(float threshold);

   /*l
    *b  Description:
    **
    **    Returns the how long the agent can make no progress toward
    **    its desired position before it decides to apply an untrap
    **    method.
    */
   float get_first_no_progress_trap_time_threshold();

   /*l
    *b  Description:
    **
    **    Similar to set_first_no_progress_untrap_method(), but the
    **    time threshold is longer before the second no progress
    **    untrap method is applied.
    */
   void set_second_no_progress_untrap_method(diguyAgentUntrapMethod untrap_method);

   /*l
    *b  Description:
    **
    **    Similar to get_first_no_progress_untrap_method(), but
    **    applied to the second no progress untrap method.
    */
   diguyAgentUntrapMethod get_second_no_progress_untrap_method();

   /*l
    *b  Description:
    **
    **    Sets the how long, in seconds, the agent is willing to make
    **    no progress toward its desired position before it applies
    **    the second no progress untrap method.
    */
   void set_second_no_progress_trap_time_threshold(float threshold);

   /*l
    *b  Description:
    **
    **    Returns the how long the agent can make no progress toward
    **    its desired position before it decides to apply the
    **    second no progress untrap method.
    */
   float get_second_no_progress_trap_time_threshold();

   /*l
    *b  Description:
    **
    **    Sets how many times the agent is willing to try applying
    **    the random turn untrap method before it gives up and
    **    moves on to the next untrap method.
    */
   void set_untrap_method_random_turn_max_tries(int max_tries);

   /*l
    *b  Description:
    **
    **    Returns how many times the agent is willing to try applying
    **    the random turn untrap method.
    */
   int get_untrap_method_random_turn_max_tries();

   /*l
    *b  Description:
    **
    **    Sets how many seconds the agent will be intangible when
    **    it is applying the ghost untrap method.
    */
   void set_untrap_method_ghost_duration(float duration);

   /*l
    *b  Description:
    **
    **    Returns how many seconds the agent will be intangible when
    **    it is applying the ghost untrap method.
    */
   float get_untrap_method_ghost_duration();


/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    Sets whether the agent will make use of actions that have the
    **    specified speed type.
    **
    **    For information on speed types see the documentation
    **    for the enumeration diguyMotionSpeedType. or the
    **    DI-Guy AI User Manual.
    */
   int set_speed_type_enabled(diguyMotionSpeedType motion_speed_type,
      int enabled);

   /*l
    *b  Description:
    **
    **    Returns whether the agent will make use of actions that have the
    **    specified speed type.
    **
    **    If the speed type is enabled, the character must be outside the
    **    the associated radius for the action to apply. If the character
    **    enters that radius, then the next radius down is considered. If
    **    all enabled speed types have been exhausted, then the character
    **    should stop
    **
    */
   int get_speed_type_enabled(diguyMotionSpeedType motion_speed_type);

   /*l
    *b  Description:
    **
    **    Sets at what radius, in meters, the agent will begin to play
    **    actions with the specified speed type, if that type is enabled.
    **
    **    See set_speed_type_radius_hysteresis() for how a hysteresis value
    **    can affect the final radius.
    */
   int set_speed_type_radius(diguyMotionSpeedType motion_speed_type,
      float radius);

   /*l
    *b  Description:
    **
    **    Returns the radius of the specified speed type.
    */
   float get_speed_type_radius(diguyMotionSpeedType motion_speed_type);

   /*l
    *b  Description:
    **
    **    Sets the hysteresis of when the speed type changes based on how far
    **    the agent is from its desired position.  A hysteresis value can
    **    help prevent constant switching back and forth of actions if an
    **    agent is moving right along the radius separating two speed type
    **    zones.
    **
    **    Example: a hysteresis of 2.0 means that if an agent switches from
    **    speed type fast to speed type medium at 2 meters, it won't switch
    **    back to fast unless it goes back out to 4 meters.
    **/
   void  set_speed_type_radius_hysteresis(float hysteresis_distance);

   /*l
    *b  Description:
    **
    **    Returns the radius hysteresis as described in
    **    set_speed_type_radius_hysteresis().
    **/
   float get_speed_type_radius_hysteresis();

   /*l
    *b  Description:
    **
    **    Sets the exact action the agent will use if it is to use
    **    the specified speed type.  This is useful if a specific
    **    stand action is desired, for example, for the still speed
    **    type.
    **
    **    To use the default action, pass "".
    */
   int set_speed_type_exact_action(diguyMotionSpeedType motion_speed_type,
      const char* action);

   /*l
    *b  Description:
    **
    **    Returns the exact action the agent will use if it is to use
    **    the specified speed type.
    **
    **    If the default action is to be used, returns "".
    */
   const char* get_speed_type_exact_action(diguyMotionSpeedType motion_speed_type);

   /*l
    *b  Description:
    **
    **    Sets the radius variation that will be applied to speed type radii
    **    as set by set_speed_type_radius().  Each agent will have a
    **    different amount of variation added to its radii.
    **
    **    Value is in meters.
    */
   void set_radius_variation(float distance);

   /*l
    *b  Description:
    **
    **    Returns the radius variation for this agent as set by
    **    set_radius_variation().
    */
   float get_radius_variation();


   /*l
    *b  Description:
    **
    **    Sets if the character should use turning motions when changing desired orientation.
    **    As of diguy-12 defaults to true.
    */
   int set_turning_motions_enabled(int enabled);

   /*l
    *b  Description:
    **
    **    Returns if the character is using turning motions when changing desired orientation.
    **    As of diguy-12 defaults to true.
    */
   int get_turning_motions_enabled();

/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    Sets the radius, in meters, of the specified repulsion zone.
    */
   void set_repulsion_radius(diguyAgentRepulsionZone repulsion_zone,
      float radius);

   /*l
    *b  Description:
    **
    **    Returns the radius, in meters, of the specified repulsion zone.
    */
   float get_repulsion_radius(diguyAgentRepulsionZone repulsion_zone);

   /*l
    *b  Description:
    **
    **    Sets the repulsion factor of the specified repulsion zone.
    **    Higher repulsion factors will result in agents in the
    **    specified zone being pushed away harder.
    */
   void set_repulsion_factor(diguyAgentRepulsionZone repulsion_zone,
      float factor);

   /*l
    *b  Description:
    **
    **    Returns the repulsion factor of the specified repulsion zone.
    */
   float get_repulsion_factor(diguyAgentRepulsionZone repulsion_zone);

   /*l
    *b  Description:
    **
    **    Sets whether the specified repulsion zone is enabled.
    **    Zones that are not enabled will have no effect on agents
    **    in them.
    */
   void set_repulsion_zone_enabled(diguyAgentRepulsionZone repulsion_zone,
      int enabled);

   /*l
    *b  Description:
    **
    **    Returns whether the specified repulsion zone is enabled.
    */
   int get_repulsion_zone_enabled(diguyAgentRepulsionZone repulsion_zone);

   /*l
    *b  Description:
    **
    **    Sets the fastest the agent can turn, in degrees per second,
    **    in response to being repulsed by another agent.
    */
   void set_max_orientation_change_rate(float max_orientation_change_rate);

   /*l
    *b  Description:
    **
    **    Returns the fastest the agent can turn, in degrees per second,
    **    in response to being repulsed by another agent.
    */
   float get_max_orientation_change_rate();

   /*l
    *b  Description:
    **
    **    Sets the offset, in meters, that the low, medium, and high
    **    repulsion zones should have from the agent's position.
    **    The solid zone is not affected.  Sometimes it is desirable
    **    for the repulsion zones to be moved slightly forward, to
    **    make it so that other agents approaching this agent from the
    **    side will prefer to move behind this agent rather than in front.
    */
   void set_influence_center_shift(float x, float y, float z);


/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    Sets the base influence box, in meters, of a vehicle agent.
    **    The default influence box is the vehicle's axis-aligned bounding
    **    box.
    */
   void set_vehicle_base_influence_box(float min_x, float min_y, float min_z,
      float max_x, float max_y, float max_z);

   /*l
    *b  Description:
    **
    **    Returns the vehicle's base influence box.
    */
   void get_vehicle_base_influence_box(float* min_x, float* min_y, float* min_z,
      float* max_x, float* max_y, float* max_z);

   /*l
    *b  Description:
    **
    **    Sets whether or not the influence box is active (true by default).
    */
   void set_influence_box_enabled(int enabled = 1);

   /*l
    *b  Description:
    **
    **    Returns whether or not the influence box is active
    */
   int get_influence_box_enabled();

   // defaults to 4.0
   void set_influence_box_forward_multiplier(float value);
   float get_influence_box_forward_multiplier();

   // defaults to .30
   void set_influence_box_sideways_multiplier(float value);
   float get_influence_box_sideways_multiplier();

   // defaults to .10
   void set_influence_box_angular_multiplier(float value);
   float get_influence_box_angular_multiplier();

/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    Sets whether the specified feeler is enabled.  Feelers that
    **    are not enabled will have no effect on the agent.
    */
   void set_feeler_enabled(int feeler_index,
      int feeler_enabled);

   /*l
    *b  Description:
    **
    **    Returns whether the specified feeler is enabled.
    */
   int get_feeler_enabled(int feeler_index);

   /*l
    *b  Description:
    **
    **    Sets, in degrees, how far counter-clockwise from forward
    **    the feeler is.  Zero degrees is straight forward, 90 is to the
    **    left, etc.  By default the eight feelers are located at 45
    **    degree intervals around the agent.
    */
   void set_feeler_rz_offset(int feeler_index,
      float feeler_rz_offset);

   /*l
    *b  Description:
    **
    **    Returns, in degrees, how far counter-clockwise from forward
    **    the feeler is.
    */
   float get_feeler_rz_offset(int feeler_index);

   /*l
    *b  Description:
    **
    **    Sets, in meters, how high the feeler is from the ground.
    **    In general feelers should be at about waist level for human
    **    characters.
    */
   void set_feeler_height(int feeler_index,
      float feeler_height);

   /*l
    *b  Description:
    **
    **    Returns, in meters, how high the feeler is from the ground.
    */
   float get_feeler_height(int feeler_index);

   /*l
    *b  Description:
    **
    **    Sets, in meters, how far away from the agent the feeler will
    **    return collision results.  Agents will be pushed away from
    **    the object collided with until they are not colliding
    **    anymore.
    */
   void set_feeler_collision_distance(int feeler_index,
      float collision_distance);

   /*l
    *b  Description:
    **
    **    Returns, in meters, how far away from the agent the feeler will
    **    return collision results.
    */
   float get_feeler_collision_distance(int feeler_index);

   /*l
    *b  Description:
    **
    **    Sets, in meters, how far away from the agent the feeler will
    **    return turn results.  Agents will turn left or right to try
    **    to move along the face of a felt obstacle, instead of walking
    **    straight into it.
    */
   void set_feeler_turn_distance(int feeler_index,
      float turn_distance);

   /*l
    *b  Description:
    **
    **    Returns, in meters, how far away from the agent the feeler will
    **    return turn results.
    */
   float get_feeler_turn_distance(int feeler_index);

   /*l
    *b  Description:
    **
    **    Sets which direction the feeler will turn the agent when
    **    it touches something within the turn distance.
    */
   void set_feeler_turn_direction(int feeler_index,
      diguyCharacterFeelerTurnDirection turn_direction);

   /*l
    *b  Description:
    **
    **    Returns which direction the feeler will turn the agent when
    **    it touches something within the turn distance.
    */
   diguyCharacterFeelerTurnDirection get_feeler_turn_direction(int feeler_index);


/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    Sets the preferred traveling region mask.
    **
    **    When an agent plans a path, the preferred areas will be considered
    **    the easiest to cross and the path should gravitate to them.
    **
    **    The mask argument should be an or'ed together list of
    **    diguySubregionMasks.  In C++ or Perl masks can be combined with
    **    the '|' operator, in Lua the bit library can be used:
    **    bit.bor(MASK_A, MASK_B, ...)
    **/
   void set_path_planner_preferred_region_mask(int mask);

   /*l
    *b  Description:
    **
    *b  Returns:
    **
    **    the preferred region mask; see
    **    set_path_planner_preferred_region_mask() and
    **    set_path_planner_neutral_cost_bias()
    */
   int get_path_planner_preferred_region_mask();

   /*l
    *b  Description:
    **
    **    Sets how much less expensive it is to cross spaces that are
    **    in the desired subregion.  (Repulsive and neutral regions have
    **    their own cost bias; see set_path_planner_repulsed_cost_bias().)
    **
    **    This value should be < 1.  The default value is 0.25.
    **/
   void set_path_planner_preferred_cost_bias(float value);

   /*l
    *b  Returns:
    **
    **    the cost bias of preferred regions during A* searches;
    **    see set_path_planner_preferred_cost_bias()
    */
   float get_path_planner_preferred_cost_bias();

   /*l
    *b  Description:
    **
    **    Sets how much more expensive it is to cross spaces that are
    **    not in a desired subregion.  (Repulsive regions have their own
    **    cost bias; see set_path_planner_repulsed_cost_bias().)
    **
    **    Defaults to 1.1,  A value < 1 will cause the planner to run faster
    **    but explore fewer points, posibly missing preferred regions.
    **    Values greater then 1 will explore more points but will take more
    **    time to run.
    **
    **    Pass DIGUY_DEFAULT_FLOAT for the value to specify that neutral
    **    regions should be avoided completely.  This can, however, cause
    **    path planning to fail more often.
    **/
   void set_path_planner_neutral_cost_bias(float value);

   /*l
    *b  Returns:
    **
    **    the cost bias of neutral regions during A* searches;
    **    see set_path_planner_neutral_cost_bias()
    **/
   float get_path_planner_neutral_cost_bias();

   /*l
    *b  Description:
    **
    **    Sets the repulsive traveling region mask.
    **
    **    When an agent plans a path the repulsive areas will be considered
    **    the hardest to cross and the planner will try to avoid them.
    **
    **    The mask argument should be an or'ed together list of
    **    diguySubregionMasks.  In C++ or Perl masks can be combined with
    **    the '|' operator, in Lua the bit library can be used:
    **    bit.bor(MASK_A, MASK_B, ...)
    **/
   void set_path_planner_repulsed_region_mask(int mask);

   /*l
    *b  Returns:
    **
    **    the repulsed region mask; see
    **    set_path_planner_repulsed_region_mask()
    */
   int get_path_planner_repulsed_region_mask();

   /*l
    *b  Description:
    **
    **    Sets how much more expensive it will be to cross spaces that are
    **    marked as repulsive.
    **
    **    This value should generally be much larger then 1.  The default
    **    value is 100.
    **
    **    Pass DIGUY_DEFAULT_FLOAT for the value to specify that repulsive
    **    regions should be avoided completely.  This can, however, cause
    **    path planning to fail more often.
    **/
   void set_path_planner_repulsed_cost_bias(float value);

   /*l
    *b  Returns:
    **
    **    the cost bias of repulsive regions during A* searches;
    **    see set_path_planner_repulsed_cost_bias()
    **/
   float get_path_planner_repulsed_cost_bias();

    /*l
     *b  Description:
     **
     **    Sets the name of the region to try to use if the path planner
     **    fails to work on the current behavior region.  This is often the
     **    name of a global navmesh.
     **/
   void set_path_planner_fallback_region(const char* fallback_region_name);

    /*l
     *b  Returns:
     **
     **    The name of the fallback region that the path planner will
     **    fall back to if a search on the behavior region fails.
     **/
   const char* get_path_planner_fallback_region();

   /*l
    *b  Description:
    **
    **    Sets whether the wander behavior will try to use the path planner
    **    when the agent can't see it's target location with a viability
    **    check.
    **/
   void set_wander_uses_path_planner(int wander_uses_path_planner);

   /*l
    *b  Returns:
    **
    **    whether the wander behavior uses the path planner; see
    **    set_wander_uses_path_planner()
    **/
   int get_wander_uses_path_planner();

   /*l
    *b  Description:
    **
    **    Sets whether the pursue behavior will try to use the path planner
    **    when the agent can't see it's target with a viability check.
    **
    **    The agent will do a new visibility check at each waypoint in
    **    the navigation path.
    **/
   void set_pursue_uses_path_planner(int pursue_uses_path_planner);

   /*l
    *b  Returns:
    **
    **    whether the pursue behavior uses the path planner; see
    **    set_wander_uses_path_planner()
    **/
   int get_pursue_uses_path_planner();

   /*l
    *b  Description:
    **
    **    Sets the maximum distance the wander behavior will travel without
    **    using the path planner, when the agent can see it's target location
    **    with a Line-Of-Sight viability check.
    **
    **    This value defaults to 1000 meters.
    **
    **    Adjusting it lower is meant for users that have an environment
    **    that is well tagged with preferred and repulsed regions.
    **
    **    For example, just because an agent can see the store across an
    **    eight lane highway doesn't mean it should run straight there.
    **/
   void set_max_LOS_travel_distance(float distance);

   /*l
    *b  Returns:
    **
    **    the Line-Of-Sight travel distance threshold; see
    **    set_max_LOS_travel_distance().
    **/
   float get_max_LOS_travel_distance();

   /*l
    *b  Description:
    **
    **    Sets the distance from the final point on a navpath that the guide
    **    algorithm will attempt to achieve before declaring that its
    **    destination has been reached.
    **
    **    The default distance is 0.31 meters.
    **
    **    In general this value should only be changed if agent ends up
    **    "orbiting" the final desired position.
    */
   void set_desired_navpath_distance_threshold(float threshold);

   /*l
    *b  Returns:
    **
    **    distance from final point in navpath at which the desired
    **    position is considered acquired; see
    **    set_desired_navpath_distance_threshold()
    */
   float get_desired_navpath_distance_threshold();




/*****************************************************************************/
   /*l
    **  see diguyNavMeshPathPlannerCostMask for acceptable values.
    */
   void set_path_planner_cost_rule(int mask);
   int get_path_planner_cost_rule();

   float get_near_destination_distance();
   void set_near_destination_distance(float dist);

   int get_navpath_current_waypoint_index();
   int get_navpath_num_waypoints();

   diguyPathShape * get_navpath_path();
   diguyNavPathDirection get_navpath_travel_direction();

   float get_navpath_offset_y();
   void set_navpath_offset_y(float y);

#ifdef CPLUSPLUS_ONLY

   bdiScenarioAgentParams* get_scripted_object() {return m_scripted_object;}

private:

   /*l
    **    A private constructor.
    */
   diguyAgentParams(bdiScenarioAgentParams* scripted_object);

   /*l
    **    A private destructor.
    */
   virtual ~diguyAgentParams();

   /*l
    **    A pointer to internal data.
    */
   bdiScenarioAgentParams* m_scripted_object;
   bdiScenarioAgent* m_agent_object;

   friend class bdiScenarioAgentParams;
   friend class bdiScenarioAgent;

#endif

};