fireManager.h

Go to the documentation of this file.

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

#pragma once


#include <matrix/vlVector.h>

#include <vrfMsgTransport/fireEvent.h>
#include "vrfobjcore/fireContext.h"

#include "vrftasks/radioMessageTypes.h"
#include "vrfobjcore/simRadio.h"
#include "vrfobjcore/simObjectReference.h"

#include "vrfutil/kinematicTools.h"
#include "vrfobjcore/simComponentTypes.h"

#include <map>

#include <mutex>

namespace makVrfEvents
{
   class DtEvent;
}

#include "vrfobjcore/vrfobjcoreDefines.h"

class DT_DLL_vrfobjcore DtFireManager
{
public:
   
   typedef bool (*DtFireProcessingFunction)(const DtFireContext& fireContext, void* usr);
   typedef std::map<DtUUID, DtSimObjectReference> DtRegisteredVrfObjects;
   typedef std::map<DtUUID, std::pair<DtFireProcessingFunction, void*> > DtFireCallbackFuncs;

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

   struct DtFireRangeCallbackInfo
   {
      DtFireProcessingFunction callbackFcn;
      void* callbackUserData;
      DtFireRangeMap munitionMap;
   };

   typedef std::list<DtFireRangeCallbackInfo> DtFireRangeCallbackInfoList;

   struct DtFireRangeInfo
   {
      DtSimObjectReference vrfObject;
      DtFireRangeCallbackInfoList callbacks;
   };

   typedef std::shared_ptr<DtFireRangeInfo> DtFireRangeInfoPtr;

   typedef std::map<DtUUID, DtFireRangeInfoPtr> DtFireRangeInfoMap;

   DtFireManager(DtSimulationServices* simManager);

   virtual ~DtFireManager();

   virtual bool init();

   virtual bool reinitialize();

   virtual void tick();

   virtual bool registerFireTarget(const DtUUID& entityId, double distance,
      void* callbackObject, DtFireProcessingFunction func);

   virtual bool registerFireTargetForRemoval(const DtUUID& entity);

   virtual bool unRegisterFireTarget(const DtUUID& entity);

   virtual void sendFireInteraction(const makVrfEvents::DtFireEvent& fire);

   virtual bool registerFireInArea(const DtUUID& entityId, DtSimMunition munition, double maxRadius, void* callbackObject,
      DtFireProcessingFunction func);

   virtual bool unRegisterFireInAreaCallback(const DtUUID& entity, void* callbackObject,
      DtFireProcessingFunction func);

   virtual bool isTargetInterestedInFire(const DtFireRangeCallbackInfo& target,
      double range, DtFireContext& fireContext) const;

   virtual double lookupMunitionInFireRangeMap(
      const DtFireRangeCallbackInfo& target, const DtSimMunition & munition) const;

protected:

   virtual void processDetonation(const makVrfEvents::DtDetonationEvent& fire);

   virtual void processFire(const makVrfEvents::DtFireEvent& fire);

   virtual void processUUIDChanged(const DtUUID& oldUUID, const DtUUID& newUUID);

   virtual void determineUnderFire(const makVrfEvents::DtDetonationEvent& detonation);

   virtual void determineUnderFire(const makVrfEvents::DtFireEvent& fireInter);

   virtual void removeQueuedFireTargets();

   virtual void fireEvent(const makVrfEvents::DtEvent&);
   virtual void detonationEvent(const makVrfEvents::DtEvent&);
   virtual void processFireForEntitiesInRange(const makVrfEvents::DtFireEvent& fireInter);
protected:

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

protected:
   DtRegisteredVrfObjects myFireTargets;

   DtFireCallbackFuncs myFireCallbacks;

   std::vector<DtUUID> myFireTargetsToBeRemoved;
   
   DtSimulationServices* mySimulationServices;
   std::recursive_mutex myMutex;
   DtFireRangeInfoMap myFireRangeInfoMap;

   bool myConnectionsMade = false;

   double myMaxDistance;
};