indirectFireWeaponController.h

Go to the documentation of this file.

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


#pragma once

#include "vrfmodel/vrfmodelDefines.h"
#include "vrfmodel/baseWeaponController.h"
#include "vrfutil/simMunition.h"

class DtVectorOutputPort;
class DtAnalogOutputPort;
class DtBooleanOutputPort;
class DtVectorInputPort;
class DtVrfIndirectFirePSR;
class DtIndirectWeaponComponentInterface;
class DtIndirectFireControllerDescriptor;
class DtMunitionResource;
class DtMountingController;
class DtGenericWeaponInfo;
class DtFireForEffectTask;
class DtFireForEffectOnTargetTask;
class DtFireForEffectOnLocationTask;
class DtFireForEffectOnEntityTask;
class DtRwLocationReference;

class DT_DLL_vrfmodel DtIndirectFireWeaponController : public DtBaseWeaponController
{

public:

   DtIndirectFireWeaponController(const DtString& name, 
      DtLocalObject* owner,
      DtSimulationServices* simManager, 
      DtComponentDescriptor* desc = nullptr,
      DtReaderWriterRegistry* parentRegistry = nullptr);

   virtual ~DtIndirectFireWeaponController();

   virtual const char* type() const override;

   virtual bool init() override;

   virtual bool createMountingController() override;

   virtual void preFirstTickInit() override;

   virtual void tick() override;

   virtual bool createTargetPointPort();
   virtual DtVectorOutputPort * targetPointPort() const;

   virtual bool createMuzzleSpeedPort();
   virtual DtAnalogOutputPort * muzzleSpeedPort() const;

   virtual bool createAngleOfFirePort();
   virtual DtAnalogOutputPort * angleOfFirePort() const;

   virtual bool createAlignedDirectlyPort();
   virtual DtBooleanOutputPort * alignedDirectlyPort() const;

   virtual bool createMuzzleOffsetPort();
   virtual DtVectorInputPort * muzzleOffsetPort() const;

   static DtSimComponent * creator(const DtString& name, 
      DtLocalObject* owner,
      DtSimulationServices* simManager, 
      DtComponentDescriptor* desc = nullptr,
      DtReaderWriterRegistry* parentRegistry = nullptr);

   virtual DtVrfIndirectFirePSR* indirectFireProcessState();
   virtual const DtVrfIndirectFirePSR* indirectFireProcessState() const;

   virtual void registerAttributeFunctions() override;

   static DtReaderWriter* provideWeaponName(void* controller);

   virtual bool haveAmmo(const DtString & ammoName) const;

   virtual int ammoAmount(const DtString & ammoName) const;

   virtual const DtString & findDefaultAmmo() const;

   virtual void getMunitionFromResourceName(const DtString & resourceName,  
            DtSimMunition& munition) const;

   virtual DtMunitionResource * lookupMunitionResource(const DtString & 
      resource) const;
   virtual void setMyFuzeToUse(DtDetonatorFuze fuzeToUse);
   virtual DtDetonatorFuze fuzeToUse() const;

   virtual void setCurrentMuzzleSpeed(DtReal speed);

   virtual DtReal currentMuzzleSpeed() const;

   virtual void addRangeItems();

   virtual bool initializeController(const DtString& ammoType,
      DtReal heightAboveTerrain, const DtUUID & targetName, DtVector targetLocation,
      bool& waitingForTerrain, DtDetonatorFuze fuseType,
      bool generateKnownTargetPoint = false, const DtString& knownTargetPointName = "");

protected:
   
   virtual bool createPorts() override;

   virtual void lookupAndCacheProcessSR() override;

   virtual bool calculateTrajectory(const DtVector& shooterLoc, const DtVector& detonationLoc,
      const double maxRange);

   virtual void calculateTrajectoryWithHeight(double horizontalDist, double verticalDist,
      double maxHeight, double& muzzleSpeed, double& launchAngle, double& flightTime);

   virtual bool calculateElevationAngle(double lateralDist, double verticalDist, double muzzleSpeed,
      double& angle, double& flightTime, double& maxHeight) const;
   
   virtual bool checkMuzzleSpeedAndAngle(double lateralDist, double verticalDist,
      double speed, double angle, double& flightTime, double& maxHeight) const;

   virtual void getMunitionResources(std::list<DtString>& resourceList);

   virtual void updateResourceList();

   static void setResourceCallback(DtSimMessage * msg, void * usrData);
   virtual void processSetResource(DtSimMessage * msg);

   static void setRestoreCallback(DtSimMessage * msg, void * usrData);
   virtual void processSetRestore(DtSimMessage * msg);

   static void setPreferredAltitudeCallback(DtSimMessage * msg, void * usrData);
   virtual void processSetPreferredAltitude(DtSimMessage * msg);

   virtual AcceptLevel acceptTask(const DtTaskMessage& task) override;


   //static void indirectFireAtLocationTaskCallback(DtSimMessage* msg, void* usr);
   //virtual void processIndirectFireAtLocationTask(DtSimMessage* msg);


   //static void indirectFireAtTargetTaskCallback(DtSimMessage* msg, void* usr);
   //virtual void processIndirectFireAtTargetTask(DtSimMessage* msg);

   static void FFEOnTargetCallback(DtSimMessage * msg, void * usr);
   static void FFEOnEntityCallback(DtSimMessage * msg, void * usr);
   static void FFEOnLocationCallback(DtSimMessage * msg, void * usr);

   virtual bool processFFEOnTargetTask(DtSimMessage * msg);
   virtual bool processFFEOnLocationTask(DtSimMessage * msg);
   virtual bool processFFEOnEntityTask(DtSimMessage * msg);


   static void indirectFireAtLocationTaskCallback(DtSimMessage* msg, void* usr);
   virtual void processIndirectFireAtLocationTask(DtSimMessage* msg);


   static void indirectFireAtTargetTaskCallback(DtSimMessage* msg, void* usr);
   virtual void processIndirectFireAtTargetTask(DtSimMessage* msg);

   virtual void processFFETask(DtFireForEffectTask * task, const DtUUID& targetObj, const DtVector& targetLoc);

   virtual DtVector computeLeadPosition(const DtVector& position,
      const DtVector& velocity);

   virtual const DtVector& muzzleLocalPosition();

   virtual DtReaderWriter* processProvideWeaponName();

   virtual double preferredAltitude() const;

   DtIndirectFireWeaponController();

   DtIndirectFireWeaponController(const DtIndirectFireWeaponController & orig);

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

   virtual void enable() override;

   virtual void disable() override;

   virtual void clearTask() override;

   virtual void restartTask();

   virtual void getOrientation(DtRwString *orientString, DtRwTaitBryan & orientation) const;

   virtual bool positionWithinTargetRegion(const DtVector& localPos);
   virtual DtSimTask* createFireTask(const DtRwLocationReference& locRef);

   virtual void parseWeaponParams(const DtRwString* weaponToUse, 
                                  DtString& weapId, DtString& weapName, DtString& ammoType);

protected:
   DtIndirectWeaponComponentInterface* myWeaponComponentInterface;

   DtDetonatorFuze myFuzeToUse;
  
   DtReal myCurrentMuzzleSpeed;

   DtReal myCurrentMunitionFlightTime;

   DtReal myCurrentElevationAngle;

   bool myWeaponIsAimed;

   DtSimMunition myMunitionToUse;

   DtIndirectFireControllerDescriptor * myIndFireDescriptor;


   DtVectorOutputPort* myTargetPointPort;

   DtAnalogOutputPort* myMuzzleSpeedPort;

   DtAnalogOutputPort* myAngleOfFirePort;

   DtBooleanOutputPort* myAlignedDirectlyPort;

   DtVectorInputPort* myMuzzleOffsetPort;

   DtMountingController* myMountingController;

   bool myIsDirectFire;

   DtGenericWeaponInfo* myWeaponInfo;
};