scriptedMovementObject.h

Go to the documentation of this file.

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


#pragma once

#include "vrfutil/vrfutilDefines.h"
#include "vrfutil/movementFile.h"

#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/string.hpp>

#include <vlutil/vlFilename.h>
#include <vlpi/entityType.h>

#include <set>
#include <vector>



class DT_DLL_vrfutil DtScriptedMovementPhase
{
public:
   enum CompletionRule
   {
      Detonate = 1,
      DetonateAndRemove,
      Remove,
      StayAroundAtCurrentSpeed,
      StayAroundAndStop
   };

   enum ClampType
   {
      PhaseGroundClampHighFidelity = 1,
      PhaseGroundClampLowFidelity = 2,
      PhaseAltitudeIsAboveTerrain = 3,
      PhaseGroundClampGeodeticNone = 4,
      PhaseClampWhileAltitudeChangeIsZero = 5,
      PhasePhasedArrayRadarFaceCartesian = 6,
      PhaseGroundClampTopographicNone = 7
   };

   DtScriptedMovementPhase();

   virtual ~DtScriptedMovementPhase();

   DtScriptedMovementPhase(const DtScriptedMovementPhase&);

   DtScriptedMovementPhase& operator=(const DtScriptedMovementPhase&);

   virtual void setMovementFile(const std::string&);
   virtual const std::string& movementFile() const;

   virtual void setFileConfiguration(const std::string&);
   virtual const std::string& fileConfiguration() const;

   virtual void setCompletionRule(CompletionRule);
   virtual CompletionRule completionRule() const;

   virtual void setClampType(ClampType);
   virtual ClampType clampType() const;

   virtual void setEntityType(const DtEntityType&);
   virtual DtEntityType entityType() const;

   virtual bool canBePerformed(double deltaTime) const;

   virtual bool canStillBePerformed(double deltatTime) const;

   virtual bool loadMovementFile(const DtFilename& rootPath, const std::string&, int rowsToLoad = -1);

   virtual bool isLoaded() const;

   virtual double simTime(int row) const;

   virtual DtVector bodyOffsetVector(int row) const;

   virtual DtTaitBryan orientationOffset(int row) const;

   virtual void setSimulationStartTimeOffset(double t);

   virtual double simulationStartTimeOffset() const;

   virtual void setFileConfiguration(const DtString&);

   const DtMovementFile& movementFileData() const { return myMovementFileData; };
   DtMovementFile& movementFileData() { return myMovementFileData; };

protected:

   friend class boost::serialization::access;

   template<class Archive>
      void serialize(Archive & ar, const unsigned int version)
   {
      ar & BOOST_SERIALIZATION_NVP(myMovementFile);
      ar & BOOST_SERIALIZATION_NVP(myCompletionRule);
      if (version >= 2)
      {
         ar & BOOST_SERIALIZATION_NVP(myClampType);

         if (version >= 3)
         {
            ar & BOOST_SERIALIZATION_NVP(myFileConfiguration);
         }
      }
      else if (Archive::is_loading::value)
      {
         bool myGroundClamp;

         ar & BOOST_SERIALIZATION_NVP(myGroundClamp);

         if (myGroundClamp)
         {
            myClampType = PhaseGroundClampHighFidelity;
         }
      }

      ar & BOOST_SERIALIZATION_NVP(mySimulationStartTimeOffset);
      ar & BOOST_SERIALIZATION_NVP(myEntityType);
   }

protected:
   std::string myMovementFile;
   CompletionRule myCompletionRule;
   ClampType myClampType;
   std::string myEntityType;
   std::string myFileConfiguration;
   DtMovementFile myMovementFileData;
   DtScriptedMovementFileConfiguration myScriptedMovementFileConfiguration;
   double mySimulationStartTimeOffset;
};

const int DtBallisticMissileMovementScript = 1;
const int DtPrecisionMovementScript = 2;

class DT_DLL_vrfutil DtScriptedMovementObject
{
public:
   typedef std::vector<DtScriptedMovementPhase> Phases;

public:

   DtScriptedMovementObject();

   DtScriptedMovementObject(int type);

   virtual ~DtScriptedMovementObject();

   DtScriptedMovementObject(const DtScriptedMovementObject& orig);

   DtScriptedMovementObject& operator=(const DtScriptedMovementObject& orig);

   virtual void setName(const std::string&);
   virtual const std::string& name() const;

   virtual const DtScriptedMovementFileConfiguration& scriptedMovementFileConfiguration() const;
   virtual DtScriptedMovementFileConfiguration& scriptedMovementFileConfiguration();

   virtual void addPhase(const DtScriptedMovementPhase&);

   virtual void removePhase(int);

   virtual const Phases& phases() const;

   virtual DtScriptedMovementPhase& phase(int);
   virtual const DtScriptedMovementPhase& phase(int) const;

   virtual void setPhases(const Phases&);

   virtual bool setPhase(int p, const DtScriptedMovementPhase& phase);

   virtual bool load(const DtFilename&);

   virtual void setLoadedPath(const DtFilename&);

   virtual DtFilename loadedPath() const;

   const DtFilename& loadedFile() const
   {
      return myFilename;
   }

   virtual bool save(const DtFilename&);

   virtual bool save();

   virtual bool hasValidPhases(double simTimeDelta, const std::set<int>& phasesPerformed);

   virtual std::set<int> availablePhases(double simTimeDelta, const std::set<int>& phasesPerformed);

   virtual void setFilename(const DtFilename&);

   virtual bool remove();

   virtual int scriptType() const;

   virtual void setDescription(const std::string&);
   virtual const std::string& description() const;

   virtual void setCategories(const std::string&);
   virtual void setCategories(const std::vector<std::string>&);
   virtual std::vector<std::string> categories() const;
   virtual void addCategory(const std::string&);
   virtual void removeCategory(const std::string&);
   virtual const std::string& categoriesAsString() const;
   virtual bool hasCategory(const std::string&) const;
   virtual void renameCategory(const std::string& oldName, const std::string& newName);

protected:

   friend class boost::serialization::access;

   template<class Archive>
      void serialize(Archive & ar, const unsigned int version)
   {
      ar & BOOST_SERIALIZATION_NVP(myName);

      if (version <= 2)
      {
         DtScriptedMovementFileConfiguration myMovementFileConfiguration;
         ar & BOOST_SERIALIZATION_NVP(myMovementFileConfiguration);

         myPreviousConfiguration = myMovementFileConfiguration;
      }

      ar & BOOST_SERIALIZATION_NVP(myPhases);
      
      if (version >= 2)
      {
         ar & BOOST_SERIALIZATION_NVP(myScriptType);

         if (version >= 3)
         {
            ar & BOOST_SERIALIZATION_NVP(myDescription);
            ar & BOOST_SERIALIZATION_NVP(myCategories);
         }
      }
      else if (Archive::is_loading::value)
      {
         myScriptType = DtBallisticMissileMovementScript;
      }
   }

protected:
   int myScriptType;
   std::string myName;
   Phases myPhases;
   DtFilename myFilename;
   std::string myCategories;
   std::string myDescription;
   DtScriptedMovementFileConfiguration myPreviousConfiguration;
};

BOOST_CLASS_VERSION(DtScriptedMovementObject, 3)
BOOST_CLASS_VERSION(DtScriptedMovementPhase, 3);