detonationManager.h

Go to the documentation of this file.

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

#pragma once


#include <matrix/vlVector.h>
#include "vrfobjcore/detonationContext.h"

#include <vl/detonationInteraction.h>
#include "vrfobjcore/vrfObjectManager.h"
#include "vrfobjcore/vrfObject.h"
#include "vrfobjcore/vrfKinematicState.h"
#include "vrftasks/radioMessageTypes.h"
#include "vrfobjcore/simRadio.h"
#include "vrfobjcore/vrfObjectStateRepository.h"
#include "vrfutil/rwUUID.h"

#include "vrfcore/simManager.h"
#include "vrfutil/kinematicTools.h"
#include "vrfobjcore/simComponentTypes.h"
#include <vlutil/vlConfig.h>
#include <map>
#include <vlutil/vlSmartPointers.h>


#include "vrfobjcore/vrfobjcoreDefines.h"
class DT_DLL_vrfobjcore DtDetonationManager
{
public:
   
   typedef bool (*DtDamageAdjudicationFunction)(const DtDetonationContext& detonationContext, void* usr);

   struct DtDirectDetonationTargetInfo
   {
      DtVrfObject* vrfObject;
      DtGlobalObjectDesignator globalId;
      DtDamageAdjudicationFunction callbackFcn;
      void* callbackUserData;
   };

   typedef std::map<DtSimMunition,double> DtMunitionDamageMap;

   struct DtDetonationCallbackInfo
   {
      DtDamageAdjudicationFunction callbackFcn;
      void* callbackUserData;
      DtMunitionDamageMap damageMap;
   };

   typedef std::list<DtDetonationCallbackInfo> DtDetonationCallbackInfoList;

   struct DtCollateralDetonationTargetInfo
   {
      DtVrfObject* vrfObject;
      DtGlobalObjectDesignator globalId;
      DtDetonationCallbackInfoList callbacks;
   };

   typedef DtBoost::shared_ptr<DtDirectDetonationTargetInfo> DtDirectDetonationTargetInfoPtr;

   typedef std::list<DtDirectDetonationTargetInfoPtr> DtDirectDetonationTargetList;
   typedef std::map<DtUUID, DtDirectDetonationTargetInfoPtr> DtDirectDetonationTargetMap;

   typedef DtBoost::shared_ptr<DtCollateralDetonationTargetInfo> DtCollateralDetonationTargetInfoPtr;

   typedef std::list<DtCollateralDetonationTargetInfoPtr> DtCollateralDetonationTargetList;
   typedef std::map<DtUUID, DtCollateralDetonationTargetInfoPtr> DtCollateralDetonationTargetMap;

   DtDetonationManager(DtSimManager& simManager);
   
   virtual ~DtDetonationManager();

   virtual bool init();

   virtual bool reinitialize();
   
   
   virtual bool registerDirectDetonation(DtVrfObject& entity,
      DtGlobalObjectDesignator entityId, void* callbackObject, DtDamageAdjudicationFunction func);


   virtual bool registerCollateralDetonation(DtVrfObject& entity,
      DtGlobalObjectDesignator entityId, DtSimMunition munition, double maxDamageRadius,void* callbackObject, 
      DtDamageAdjudicationFunction func);

   virtual bool unRegisterDirectDetonationTarget(DtVrfObject& entity);
   virtual bool unRegisterCollateralDetonationTarget(DtVrfObject& entity);

   virtual bool unRegisterCollateralDetonationCallback(DtVrfObject& entity, void* callbackObject, 
      DtDamageAdjudicationFunction func);
   
   virtual double lookupMunitionInCollateralDetonationMap(
      const DtDetonationCallbackInfo& target, const DtSimMunition & munition);

   virtual void sendDetonationInteraction(DtDetonationInteraction& detonation);

protected:

   static void detonationCallback(DtDetonationInteraction* detInter, void* usr);

   static void uuidChangeCallback(const DtVrfObjectUUIDChangedCallbackInfo& change, void * usr);

   virtual void processUUIDChange(const DtVrfObjectUUIDChangedCallbackInfo& change);

   virtual void processDetonation(const DtDetonationInteraction& detonation);

   virtual const DtPhysicalWorld* physicalWorld() const;
   virtual DtPhysicalWorld* physicalWorld();
   
   virtual Coordinate_System* coordinateSystem();
   virtual const Coordinate_System* coordinateSystem() const;

   virtual void processCollateralDetonationForEntitiesInRange(DtDetonationContext& detonationContext);

   bool testInvariant() const;

   void cleanOutDeadEntities();

private:

   DtDetonationManager(const DtDetonationManager& orig);
   DtDetonationManager& operator=(const DtDetonationManager& other);

protected:

   DtDirectDetonationTargetMap      myDirectDetonationTargetMap;
   DtCollateralDetonationTargetMap  myCollateralDetonationTargetMap;
   bool                             myQueueEntitiesToBeRemoved;
   std::list<DtUUID>                myEntitiesQueuedToBeRemovedList;
   DtSimManager& mySimManager;
};