diguyAgentParams.h

Go to the documentation of this file.

/*********************************************************************
 ** Copyright (c) 1992-2020 MAK Technologies, Inc.
 ** All rights reserved. 
 *********************************************************************/


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

#ifndef __diguyAgentParams_H
#define __diguyAgentParams_H


#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>

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

};


#endif /* __diguyAgentParams_H */