diguyImpact.h

Go to the documentation of this file.

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

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

#pragma once

#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:
    **
    **    index of the target character shape that was hit
    */
   int get_hit_shape_index();

   /*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();

public:

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

};