detonationManager.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2004 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: detonationManager.h,v $ $Revision: 1.22 $ $State: Exp $
*******************************************************************************/
#ifndef detonationManager_H_
#define detonationManager_H_


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

#include <vl/detonateInter.h>
#include "vrfobjcore/vrfObjMgr.h"
#include "vrfobjcore/vrfObject.h"
#include "vrfobjcore/vrfKinState.h"
#include "vrftasks/radioMsgTypes.h"
#include "vrfobjcore/baseRadio.h"
#include "vrfobjcore/vrfObjSR.h"

#include "vrfcore/simMgr.h"
#include "vrfutil/kinTools.h"
#include "vrfobjparam/dmgCompDesc.h"
#include "vrfobjcore/compTypes.h"
#include "vrfobjcore/objectGeometricModel.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<std::string, DtDirectDetonationTargetInfoPtr> DtDirectDetonationTargetMap;

   typedef DtBoost::shared_ptr<DtCollateralDetonationTargetInfo> DtCollateralDetonationTargetInfoPtr;

   typedef std::list<DtCollateralDetonationTargetInfoPtr> DtCollateralDetonationTargetList;
   typedef std::map<std::string, 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 nameChangeCallback(const DtVrfObjectNameChangedCallbackInfo& change, void * usr);

   virtual void processNameChange(const DtVrfObjectNameChangedCallbackInfo& 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<std::string>           myEntitiesQueuedToBeRemovedList;
   DtSimManager& mySimManager;
};


#endif