include/vrfmodel/lasingCtlr.h

Go to the documentation of this file.

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


#pragma once

#include "vrfobjcore/singleTaskControllerComponent.h"
#include "vrfmodel/vrfmodelDefines.h"

class DtString;
class DtSimManager;
class DtSimMessage;
class DtLasingControllerDescriptor;
class DtLasingPSR;
class DtBooleanOutputPort;
class DtOutputPortGroup;
class DtSetTargetRequest;
class DtDesignatorPublisher;
class DtEntityListInputPort;
class DtWeaponComponentInterface;

class DT_DLL_vrfmodel DtLasingController : public DtSingleTaskControllerComponent
{
protected:
   DtLasingController();

   DtLasingController(const DtLasingController & 
      orig);

   const DtLasingController & operator=(const DtLasingController & orig);

public:

   DtLasingController(const DtString& name, 
      DtVrfObject* owner,
      DtSimManager* simManager, 
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   virtual ~DtLasingController();

   //Initializes the laser controller
   virtual bool init();

   virtual DtString type() const;

   virtual void tick();

   virtual void setDesignatorCode(const int code);
   virtual const int designatorCode() const;

   virtual void clearTask();

   virtual bool createProcessSR();

   virtual void startLasing();
   virtual void stopLasing();

   virtual void laseTarget(DtVrfObject* targetObject);

   virtual bool lasing();

   //static creator
   static DtSimComponent * creator(const DtString& name, 
      DtVrfObject* owner,
      DtSimManager* simManager, 
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   virtual void registerTaskMsgCallbacks();
   virtual void registerSetLaseAutonomousMsgCallbacks();
   virtual void registerSetLaserCodeRequestMsgCallbacks();

   //static callbacks to register with the radio for commands to lase a target
   static void laseTargetTaskCallback(DtSimMessage *msg, void * usrData);
   static void setLaseAutonomousRequestCallback(DtSimMessage* msg, void* usrData);
   static void setLaserCodeRequestCallback(DtSimMessage* msg, void* usrData);

   //functions to do the work for the static function.
   virtual void processLaseTargetTaskMessage(DtSimMessage *msg);
   virtual void processSetLaseAutonomousRequestMessage(DtSimMessage* msg);
   virtual void processSetLaserCodeRequestMessage(DtSimMessage* msg);

   static void requestLaserCodeCallback(const DtVrfObjectMessage* msg, void* usr);
   virtual void processRequestLaserCode(const DtVrfObjectMessage* msg);

protected:
   virtual bool lineOfSight(DtVrfObject* target);

   //updates the designator state and publishes it on the
   //network
   virtual void tickLaser();

   virtual void setRadio(DtSimBaseRadio * radio);

   virtual bool createPublisher();

   virtual bool createTargetInput();

   virtual double laserPower() const;

   virtual double laserWavelength() const;

   virtual bool laseTargetValid(DtVrfObject* target, DtString& invalidReason);

   virtual DtVrfObject* chooseAutonomousLaseTarget();

   virtual int defaultLaserCode() const;

   static void objectAboutToBeRemovedCallback(DtVrfObject* vrfObject, 
      void* usr);

   virtual void processObjectAboutToBeRemovedCallback(DtVrfObject* vrfObject);

   class DtLasingControllerInput
   {
   private:

      DtLasingControllerInput();
      DtLasingControllerInput(const DtLasingControllerInput& orig);
      const DtLasingControllerInput& operator=(const DtLasingControllerInput& rhs);
   public:
      DtLasingControllerInput(DtLasingController*);
      ~DtLasingControllerInput();
      virtual bool init();
      virtual DtVrfObject* getTarget() = 0;
   protected:
      DtLasingController* myController;
   };

   class DtLasingControllerPortInput : public DtLasingControllerInput
   {
   private:

      DtLasingControllerPortInput();
      DtLasingControllerPortInput(const DtLasingControllerPortInput& orig);
      const DtLasingControllerPortInput& operator=(const DtLasingControllerPortInput& rhs);

   public:
      DtLasingControllerPortInput(DtLasingController*);
      ~DtLasingControllerPortInput();
      virtual bool init();
      virtual DtVrfObject* getTarget();

   protected:
      DtEntityListInputPort* myTargetListPort;
   };

   class DtLasingControllerWeaponInterfaceInput : public DtLasingControllerInput
   {
   private:

      DtLasingControllerWeaponInterfaceInput();
      DtLasingControllerWeaponInterfaceInput(const DtLasingControllerWeaponInterfaceInput& orig);
      const DtLasingControllerWeaponInterfaceInput& operator=(const DtLasingControllerWeaponInterfaceInput& rhs);
   public:
      DtLasingControllerWeaponInterfaceInput(DtLasingController*);
      ~DtLasingControllerWeaponInterfaceInput();
      virtual bool init();
      virtual DtVrfObject* getTarget();

   protected:
      DtWeaponComponentInterface* myInterface;
   };

protected:
   DtVrfObject*                    myCurrentLasedTarget;  

   DtLasingPSR*                    myProcessState;

   const DtLasingControllerDescriptor*   myComponentDescriptor;
   DtBoolean                       myFirstTick;
   DtDesignatorPublisher*          myDesPublisher;

   DtLasingControllerInput* myLasingInput;
};

int generateLaserCodeFromName(const DtString& objectName);