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 "vrfobjparam/detonationParams.h"
#include "vrfobjparam/detonationDeformationParams.h"

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

class DtPowerRangeDeterminantFactory;
class DtMunitionDispersalDeterminantFactory;
class DtEvent;

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

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

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

   struct DtDetonationCallbackInfo
   {
      DtDamageAdjudicationFunction callbackFcn;
      void* callbackUserData;
      DtMunitionDamageMap damageByMunitionMap;
      DtPowerDamageMap damageByPowerMap;
   };

   typedef std::list<DtDetonationCallbackInfo> DtDetonationCallbackInfoList;

   struct DtCollateralDetonationTargetInfo
   {
      const 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(const DtVrfObject& entity,
      DtGlobalObjectDesignator entityId, void* callbackObject, DtDamageAdjudicationFunction func);


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

   virtual bool registerCollateralDetonationByPower(const DtVrfObject& entity,
      DtGlobalObjectDesignator entityId, const DtString& powerType, double minDamagePower, void* callbackObject,
      DtDamageAdjudicationFunction func);

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

   virtual bool unRegisterCollateralDetonationCallback(const DtVrfObject& entity, void* callbackObject, 
      DtDamageAdjudicationFunction func);

   virtual bool isTargetInterestedInCollateralDetonation(const DtDetonationCallbackInfo& target,
      double impactRange, double shooterRange, DtDetonationContext& detonationContext) const;
   
   virtual double lookupMunitionInCollateralDetonationMap(
      const DtDetonationCallbackInfo& target, const DtSimMunition & munition) const;

   virtual void sendDetonationInteraction(DtDetonationInteraction& detonation);

   virtual bool loadParametersFromFile(const DtFilename& filename);

   virtual bool loadDeformationParametersFromFile(const DtFilename & filename);

   virtual double detonationPower(const DtSimMunition & munition, double rangeFromShooter,
      double rangeFromImpact, const DtString& powerType) const;


   virtual DtDetonationResult detonationResult(const DtSimMunition& munition, const DtEntityType& targetEntityType, const DtVector& localPosition) const;

   virtual DtDetonationResult detonationResult(const DtSimMunition& munition, const DtSurface& terrainSurface, const DtVector& localPosition) const;

   virtual DtDetonationResult detonationResultMidAir(const DtSimMunition& munition, const DtVector& localPosition) const;

   virtual DtDetonationParams* parameters();
   virtual const DtDetonationParams* parameters() const;

   virtual DtTerrainDeformationParams * terrainDeformationParameters();
   virtual const DtTerrainDeformationParams * terrainDeformationParameters() const;

   virtual void resetParameters();

   virtual bool parametersLoaded() const;

   virtual const DtFilename& parametersFile() const;

   virtual const DtFilename& deformationParametersFile() const;

protected:

   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);

   virtual DtDetonationResult defaultDetonationResult() const;

   void cleanOutDeadEntities();

   virtual DtDetonationParams* createParameters();

   virtual DtTerrainDeformationParams* createDeformationParameters();

   virtual void detonationEvent(const DtEvent&);

private:

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

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

   DtFilename myParametersFile;
   DtFilename myDeformationParamsFile;

   DtDetonationParams* myParameters;

   DtTerrainDeformationParams * myDeformationParams;

   tbb::recursive_mutex myMutex;
};