diguyImpact.h

Go to the documentation of this file.

/*********************************************************************
 ** Copyright (c) 1992-2019 VT MAK
 ** All rights reserved. 
 *********************************************************************/

/*********************************************************************
 **
 *t  diguyImpact
 **
 *b    Link against: libdiguy
 */

#ifndef __diguyImpact_H
#define __diguyImpact_H

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

#ifdef CPLUSPLUS_ONLY
#include <stdio.h> // for NULL
class diguyCharacter;
class diguyScenario;
class diguySceneObject;
#endif

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

/****************************************************************************/
class BDI_DECLSPEC_diguy diguyImpact
{

public:

/****************************************************************************/
        /*l
         *b  Description:
         **
         **    Returns the type of impact; this is based on how the collision was
         **    generated.  Possible values are:
         **
         *-     - DIGUY_IMPACT_DIRECT_HIT
         *-     - DIGUY_IMPACT_NEARBY_DETONATION
         *-     - DIGUY_IMPACT_VEHICLE_COLLISION
         *-     - DIGUY_IMPACT_NO_IMPACT
         *-     - DIGUY_IMPACT_USER_GENERATED
         **
         **     Note: NO_IMPACT is generated when a character fires but fails the
         **     hit ratio test.  The location of the impact is then set to the
         **     attacker's position, or if that is unavailable to:
         **     (DIGUY_DEFAULT_FLOAT, DIGUY_DEFAULT_FLOAT, DIGUY_DEFAULT_FLOAT).
         **
         *b  Returns:
         **
         **    the type of impact
         */
        diguyImpactType get_impact_type();

        /*l
         *b  Returns:
         **
         **    the string version of the type of impact.  This is based
         **    on how the collision was generated.  Possible values are:
         **
         *-     - "direct_hit"
         *-     - "nearby_detonation"
         *-     - "vehicle_collision"
         *-     - "no_impact"
         *-     - "user_generated"
         */
        const char* get_impact_type_string();

        /*l
         *b  Returns:
         **
         **    the number of hits made by this impact.  This includes hits
         **    against characters and scene objects.
         */
        int get_num_hits();

        /*l
         *b  Returns:
         **
         **    the name of the attacker.  This pointer may be NULL if
         **    there is no attacker character.
         */
        const char* get_attacker_name();

        /*l
         *b  Returns:
         **
         **    Returns a pointer to the attacker.  This pointer may be NULL.
         */
        diguyCharacter* get_attacker();

        /*l
         *b  Returns:
         **
         **    the name of the target.  This pointer may be NULL if there
         **    is no impact target character (e.g., impact is against a scene
         **    object).
         */
        const char* get_target_name();

        /*l
         *b  Returns:
         **
         **    the diguyCharacter impact target.  This pointer may be NULL if there is no
         **    impact target character (e.g., impact is against a scene object).
         */
        diguyCharacter* get_target();

        /*l
         *b  Returns:
         **
         **    name of the target character link that was hit; may be NULL if
         **    there is no hit target character
        */
        const char* get_hit_link_name();

        /*l
         *b  Returns:
         **
         **    index of the target character link that was hit
        */
        int get_hit_link_index();

        /*l
         *b  Returns:
         **
         **    name of the target character shape that was hit; may be NULL if
         **    there is no hit target character
         */
        const char* get_hit_shape_name();

        /*l
         *b  Returns:
         **
         **    the number of impacts the target character has taken
         */
        int get_impact_number();

        /*l
         *b  Description:
         **
         **    Sets the impact number.
         */
        void set_impact_number(int val);

        /*l
         *b  Description:
         **
         **    Sets that the impact has been processed.
         */
        void set_impact_been_processed();

        /*l
         *b  Returns:
         **
         **    1 if the impact has been processed, 0 if not
         */
        int get_impact_been_processed();

        /*l
         *b  Returns:
         **
         **    the approximate world x coordinate of the impact
         */
        float get_x();

        /*l
         *b  Returns:
         **
         **    the approximate world y coordinate of the impact
         */
        float get_y();

        /*l
         *b  Returns:
         **
         **    the approximate world z coordinate of the impact
         */
        float get_z();

        /*l
         *b  Description:
         **
         **    Alternative method for getting the location of the impact.
         */
        void get_location(float* x, float* y, float* z);

        /*l
         *b  Returns:
         **
         **    the radius of the impact
         */
        float get_impact_radius();

        /*l
         *b  Returns:
         **
         **    the speed of the impact
         */
        float get_impact_speed();

        /*l
         *b  Description:
         **
         **    This function returns the location of the impact in link-relative
         **    coordinates.  The function may fail and return -1 if a link was not
         **    hit by the impact.
         **
         *b  Arguments:
         **
         *a    link_x, link_y, link_z - link-relative coordinates are
         **                             returned in these variables
         **
         *b  Returns:
         **
         **    0 on success, -1 on failure
         */
        int get_location_in_link_coordinates(float* link_x,
                float* link_y,
                float* link_z);

        /*l
         *b  Description:
         **
         **    This function resets all of the impact data to default values.
         */
        void reset();

        /*l
         *b  Description:
         **
         **    This function returns the name of the munition that was fired. This
         **    is useful for creating impact callbacks that respond differently to
         **    different weapons.
         **
         *b  Returns:
         **
         **    the munition type of the impact; may be NULL
         */
        const char* get_munition_type();

        /*l
         *b  Description:
         **
         **    Returns the hit diguySceneObject.
         **
         **    This pointer may be NULL if there is no impact scene object (e.g.,
         **    impact is against a character).
         **
         **    If the octtree was used to generate the impact, this pointer will
         **    be NULL.
         **
         *b  Returns:
         **
         **    pointer of type diguySceneObject
         */
        diguySceneObject* get_hit_scene_object();

        /*l
         *b  Returns:
         **
         **    approximate normal x coordinate of the impact; may not be valid
         */
        float get_normal_x();

        /*l
         *b  Returns:
         **
         **    approximate normal y coordinate of the impact; may not be valid
         */
        float get_normal_y();

        /*l
         *b  Returns:
         **
         **    approximate normal z coordinate of the impact; may not be valid
         */
        float get_normal_z();

        /*l
         *b  Description:
         **
         **    Alternative method for getting the normal of the impact.
         */
        void get_impact_normal(float* x, float* y, float* z);


/*****************************************************************************/
        /*l
         *b  Description:
         **
         **    Velocity of projectile at impact.  May be 0 if no velocity
         **    information is available.
         */
        void get_impact_velocity(float* x, float* y, float* z);

        /*l
         *b  Returns:
         **
         **    1 if impact was generated as a result of a network detonation (e.g.
         **    a DIS detonation PDU), else 0
         */
        int get_is_from_net_detonation();

        /*l
         *b  Description:
         **
         **    This function returns the specified part of the DIS septet of the
         **    detonation's munition septet.
         **
         *b  Arguments:
         **
         *a    septet_index - which part of the septet to return; must be between
         *a                   0 (for 'kind') and 6 (for 'extra')
         **
         **    Returns -1 if septet isn't specified, or on error.
         */
        int get_DIS_munition_septet_value(int septet_index);

        /*l
         *b  Returns:
         **
         **    the site id part of the detonation PDU event id; -1 if not set
         */
        int get_DIS_site();

        /*l
         *b  Returns:
         **
         **    the host id part of the detonation PDU event id; -1 if not set
         */
        int get_DIS_host();

        /*l
         *b  Returns:
         **
         **    the event number part of the detonation PDU event id; -1 if not set
         */
        int get_DIS_event_number();

        /*l
         *b  Returns:
         **
         **    the event number part of the detonation PDU *munition* event id;
         **    -1 if not set
         */
        int get_DIS_munition_number();

        /*l
         *b  Returns:
         **
         **    the detonation result of the detonation PDU; -1 if not set
         */
        int get_DIS_detonation_result();

        /*l
         *b  Returns:
         **
         **    the warhead type enumeration of the detonation PDU's burst
         **    descriptor; -1 if not set
         */
        int get_DIS_burst_warhead_type();

        /*l
         *b  Returns:
         **
         **    the fuze enumeration of the detonation PDU's burst descriptor; -1
         **    if not set
         */
        int get_DIS_burst_fuze();

        /*l
         *b  Returns:
         **
         **    the burst quantity of the detonation PDU's burst descriptor; -1 if
         **    not set
         */
        int get_DIS_burst_quantity();

        /*l
         *b  Returns:
         **
         **    the burst rate of the detonation PDU's burst descriptor; -1 if not
         **    set
         */
        int get_DIS_burst_rate();


#ifdef CPLUSPLUS_ONLY

/*****************************************************************************/
        /*l
         *b  Description:
         **
         **    This function sets the impact to be valid.  It must be called if
         **    the impact hits a character.
         */
        void set_valid_impact();

        /*l
         *b  Description:
         **
         **    This function allows for explicitly setting the target character of
         **    this impact object.
         **
         *b  Arguments:
         **
         *a    x, y, z - override target of impact
         **
         *b  Callable From:
         **
         *-    - C++
         */
        void set_target(diguyCharacter* target);

        /*l
         *b  Description:
         **
         **    This function allows for explicitly setting the position of this
         **    impact object.
         **
         *b  Arguments:
         **
         *a    x, y, z - override position of impact
         **
         *b  Callable From:
         **
         *-    - C++
         */
        void set_location(float x, float y, float z);

        /*l
         *b  Description:
         **
         **    This function allows for explicitly setting the normal of this
         **    impact object.
         **
         *b  Arguments:
         **
         *a    nx, ny, nz - override normal of impact
         **
         *b  Callable From:
         **
         *-    - C++
         */
        void set_normal(float nx, float ny, float nz);

        /*l
         *b  Description:
         **
         **    Returns the hit scene object.
         **
         **    This function allows for explicitly setting the scene_object that
         **    the impact object hit.
         **
         **    If the octtree was used to generate the impact, this pointer will
         **    be NULL.
         **
         *b  Arguments:
         **
         *a    scene_object - pointer to scene object hit
         **
         *b  Callable From:
         **
         *-    - C++
         */
        void set_hit_scene_object(diguySceneObject* scene_object);

        /*l
         *b  Description:
         **
         **    This function allows for explicitly setting the link index of this
         **    impact object.
         **
         *b  Callable From:
         **
         *-    - C++
         */
        void set_hit_link_index(int index);

        /*l
         *b  Description:
         **
         **    This function allows for explicitly setting the shape index of this
         **    impact object.
         **
         *b  Callable From:
         **
         *-    - C++
         */
        void set_hit_shape_index(int index);


/****************************************************************************/
/****************************************************************************/

private:

        friend class bdiScenarioEditorDIGS;
        friend class bdiPublishedCharacter;
        friend class bdiScenario;
        friend class bdiScenarioCharacter;
        friend class bdiScenarioCrowdWorkManager;
        friend class diguyCharacter;
        friend class bdiQGLWidgetDIGS;

        void set_munition_type(const char* munition_type);

        /*l
         **    Private constructors.
         */
        diguyImpact();

        diguyImpact(diguyScenario* scenario,
                diguyImpactType   impact_type = DIGUY_IMPACT_DIRECT_HIT,
                int               num_hits = 0,
                diguyCharacter*   attacker = NULL,
                diguyCharacter*   target = NULL,
                diguySceneObject* hit_scene_object = NULL,
                int               link_index = -1,
                int               shape_index = -1,
                float*            location = NULL,
                float*            normal = NULL,
                float             impact_speed = 0.0f,
                float             radius = 0.0f,
                const char*       munition_type = NULL);

        /*
         *  Private data members.
         */
        diguyScenario*    m_scenario;
        diguyImpactType   m_impact_type;
        int               m_num_hits;
        diguyCharacter*   m_attacker;
        diguyCharacter*   m_target;
        diguySceneObject* m_hit_scene_object;
        int               m_link_index;
        int               m_shape_index;
        int               m_impact_number;
        int               m_impact_processed;
        float             m_location[3];
        float             m_normal[3];
        float             m_impact_speed;
        float             m_impact_radius;
        char              m_munition_type[128];

public:
        /*
         *  FOR INTERNAL DI-GUY USE ONLY
         */
        int               m_is_from_net_detonation;
        int               m_DIS_munition_septet[7];
        int               m_DIS_site;
        int               m_DIS_host;
        int               m_DIS_event_number;
        int               m_DIS_munition_number;
        int               m_DIS_detonation_result;
        int               m_DIS_burst_warhead_type;
        int               m_DIS_burst_fuze;
        int               m_DIS_burst_quantity;
        int               m_DIS_burst_rate;
        float             m_impact_velocity[3];
private:

#endif

};


/****************************************************************************/
class BDI_DECLSPEC_diguy diguyIntersectionResult
{
public:
        diguyIntersectionResult() : m_impact_character(NULL), m_impact_scene_object(NULL), m_valid_impact(0)
        {;}
        ~diguyIntersectionResult(){;}

        diguyCharacter *get_impact_character(); 
        diguySceneObject *get_impact_scene_object();

        int get_impact_point(float *ret_x, float *ret_y, float *ret_z);
        int get_valid_impact();

        diguyCharacter   * m_impact_character;
        diguySceneObject * m_impact_scene_object;
        diguyVec3f m_impact_point;
        diguyVec3f m_impact_normal;
        int m_valid_impact;
};

#endif /* __diguyImpact_H */