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 <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 DtScriptedMovementFileConfiguration
{
public:
   struct Column
   {
      int myColumnInFile;
      std::string myColumnType;
      std::string myColumnUnits;

      template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(myColumnInFile);
         ar & BOOST_SERIALIZATION_NVP(myColumnType);
         ar & BOOST_SERIALIZATION_NVP(myColumnUnits);
      }
   };

   typedef std::vector<Column> Columns;

   enum TimeConversion
   {
      Milliseconds = 0,
      Seconds,
      Minutes,
      Hours
   };

   enum DistanceConversion
   {
      Feet = 0,
      Meters,
      Miles,
      Kilometers,
      NauticalMiles
   };

public:
   DtScriptedMovementFileConfiguration();

   virtual ~DtScriptedMovementFileConfiguration();

   DtScriptedMovementFileConfiguration(const DtScriptedMovementFileConfiguration&);

   DtScriptedMovementFileConfiguration& operator=(const DtScriptedMovementFileConfiguration&);

   //
   virtual void addColumn(const std::string& type, const std::string& units, int columnInFile = -1);
   
   virtual void removeColumn(int);

   virtual const Columns& columns() const;
   virtual void setColumns(const Columns&);

   virtual void setRowStart(int);

   virtual int rowStart() const;

   virtual int timeColumn() const;

   virtual int altitudeColumn() const;
   virtual DistanceConversion altitudeUnits() const;

   virtual int rangeColumn() const;
   virtual DistanceConversion rangeUnits() const;

   virtual int lateralDistanceColumn() const;
   virtual DistanceConversion lateralDistanceUnits() const;

   virtual double convertTimeToSeconds(double time) const;

   virtual void updateCache();

   virtual TimeConversion mapTimeToInternalValue(const std::string&) const;
   virtual DistanceConversion mapDistanceToInternalValue(const std::string&) const;

   virtual double convertDistanceToMeters(double d, DistanceConversion conv) const;

   virtual DtString toString() const;

   virtual void fromString(const DtString&);

   static DtScriptedMovementFileConfiguration defaultConfiguration();

   virtual bool setColumn(int col, const std::string& type, const std::string& unit, int columnInFile = -1);

   virtual void column(int col, int& columnInFile, std::string& type, std::string& unit) const;

protected:

   friend class boost::serialization::access;

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

      if (Archive::is_loading::value)
      {
         updateCache();
      }
   }

protected:
   int myRowStart;
   Columns myColumns;
   
   int myCachedColumns[4][2];
};

class DT_DLL_vrfutil DtMovementFile
{
public:
   DtMovementFile();

   virtual ~DtMovementFile();

   DtMovementFile(const DtMovementFile&);

   DtMovementFile& operator=(const DtMovementFile&);

   virtual double simTime(int) const;

   virtual int numRows() const;

   virtual DtVector bodyOffsetVector(int row) const;

   virtual bool isLoaded() const;

   virtual bool load(const DtFilename& file, const DtScriptedMovementFileConfiguration& configuration, int rowsToLoad = -1);

   virtual int movementRow(double) const;

protected:
   DtScriptedMovementFileConfiguration myConfiguration;
   typedef std::vector<double> MovementRow;
   typedef std::vector<MovementRow> MovementFileData;
   MovementFileData myMovementFileData;
};

class DT_DLL_vrfutil DtScriptedMovementPhase
{
public:
   enum CompletionRule
   {
      Detonate = 0,
      DetonateAndRemove,
      Remove,
      StayAround
   };

   DtScriptedMovementPhase();

   virtual ~DtScriptedMovementPhase();

   DtScriptedMovementPhase(const DtScriptedMovementPhase&);

   DtScriptedMovementPhase& operator=(const DtScriptedMovementPhase&);

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

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

   virtual void setGroundClamp(bool);
   virtual bool groundClamp() 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 DtScriptedMovementFileConfiguration&, int rowsToLoad = -1);

   virtual bool isLoaded() const;

   virtual double simTime(int row) const;

   virtual DtVector bodyOffsetVector(int row) const;

   virtual void setSimulationStartTimeOffset(double t);

   virtual double simulationStartTimeOffset() const;

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);
      ar & BOOST_SERIALIZATION_NVP(myGroundClamp);
      ar & BOOST_SERIALIZATION_NVP(mySimulationStartTimeOffset);
      ar & BOOST_SERIALIZATION_NVP(myEntityType);
   }

protected:
   std::string myMovementFile;
   CompletionRule myCompletionRule;
   bool myGroundClamp;
   std::string myEntityType;
   DtMovementFile myMovementFileData;
   double mySimulationStartTimeOffset;
};

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

public:

   DtScriptedMovementObject();

   virtual ~DtScriptedMovementObject();

   DtScriptedMovementObject(const DtScriptedMovementObject& orig);

   DtScriptedMovementObject& operator=(const DtScriptedMovementObject& orig);

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

   virtual void setScriptedMovementFileConfiguration(const DtScriptedMovementFileConfiguration&);
   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) const;

   virtual void setPhases(const Phases&);

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

   virtual bool load(const DtFilename&);

   virtual DtFilename loadedPath() const;

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

protected:

   friend class boost::serialization::access;

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

protected:
   std::string myName;
   DtScriptedMovementFileConfiguration myMovementFileConfiguration;
   Phases myPhases;
   DtFilename myFilename;
};