scenario.h

Go to the documentation of this file.

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


#pragma once

#include "vrfutil/vrfutilDefines.h"
#include <readerWriter/readerWriter.h>
#include <vlutil/vlString.h>
#include <vlutil/vlFilename.h>
#include <readerWriter/rwString.h>
#include <readerWriter/rwBoolean.h>
#include <readerWriter/rwReal.h>
#include "vrfutil/rwUnsigned.h"
#include <readerWriter/rwObjectType.h>
#include "vrfutil/rwUUID.h"
#include <readerWriter/rwInt.h>
#include "vrfutil/simClock.h"
#include "vrfutil/stringIntMapper.h"
#include "vrfutil/rwNLengthStringVector.h"
#include "vrfutil/rwKeyValueList.h"
#include <vlpi/simulationAddress.h>

#include <boost/unordered_map.hpp>

#include <vrfmsgs/messageTypes.h>

class DtlInoutStream;



typedef bool (*DtPreserveMappingsFcn)(void* usr);

class DT_DLL_vrfutil DtScenario : public DtReaderWriter
{
public:
   struct ScenarioData
   {
      std::string markingText;
      DtObjectType objectType;
      std::string label;
      DtUUID parentUuid;
   };

   typedef boost::unordered_map<DtUUID, ScenarioData> ScenarioDataMap;

public:

   DtScenario();

   DtScenario(const DtString & name,
      DtReaderWriterRegistry * const parentRegistry = 0);

   virtual ~DtScenario();

   DtScenario(const DtScenario& orig);

   DtScenario& operator=(const DtScenario& orig);

   virtual bool init();

   virtual bool readScenarioFile(const DtFilename& filename);

   bool saveAsZipFile() const;
   virtual void setSaveAsZipFile(bool);

   virtual bool save();

   static bool saveBufferToScenarioZipFile(const DtFilename& scenanarioZipFile, const DtFilename& zipContentsFile,
      const DtString& buffer);
   static bool saveBufferToScenarioZipFile(const DtFilename& scenanarioZipFile, const DtFilename& zipContentsFile,
      const char* buffer, int length);

   static bool readBufferFromScenarioZipFile(const DtFilename& scenanarioZipFile, const DtFilename& zipContentsFile,
      DtString& buffer, bool onlyNeedsExtensionMatch = true);

   static bool fileExistsInZipFile(const DtFilename& scenanarioZipFile, const DtFilename& zipContentsFile,
      bool onlyNeedsExtensionMatch = true);

   static bool extractScenarioFileFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& zipContentsFile,
      bool onlyNeedsExtensionMatch = true);

   static bool readScenarioFromZipFile(const DtFilename& f, DtScenario& scenario);

   static bool saveFileToScenarioZipFile(const DtFilename& scenanarioZipFile, const DtFilename& zipContentsFile);

   static bool isScenarioZipFile(const DtFilename&);

   virtual DtString toXml(const DtFilename& scenarioFilename);

   virtual void setupScenarioFilenames(const DtFilename& scenarioFilename,
      bool saveObjectMap = true);

   virtual bool save(const DtFilename& filename, 
      bool saveObjectMap = true);

   virtual DtScenario* clone() const;

   virtual void setComponentAttachmentRule(int rule);
   virtual int componentAttachmentRule() const;

   virtual void setComponentAttachmentTableFilename(const DtFilename& filename);
   virtual const DtFilename& componentAttachmentTableFilename() const;
   virtual void setTerrainDatabaseFilename(const DtFilename& filename);
   virtual const DtFilename& terrainDatabaseFilename() const;

   virtual void setGuiTerrainDatabaseFilename(const DtFilename& filename);
   virtual const DtFilename& guiTerrainDatabaseFilename() const;

   virtual void setOrderOfBattleFilename(const DtFilename& filename);
   virtual DtFilename orderOfBattleFilename() const;

   virtual void setScenarioScriptsFilename(const DtFilename& filename);
   virtual DtFilename scenarioScriptsFilename() const;

   virtual void setOrbatFilename(const DtFilename& filename);
   virtual DtFilename orbatFilename() const;

   virtual void setPlanFilename(const DtFilename& filename);
   virtual DtFilename planFilename() const;


   virtual void setGlobalPlanFilename(const DtFilename& filename);
   virtual DtFilename globalPlanFilename() const;

   virtual void setParameterDatabaseFilename(const DtFilename& filename);
   virtual const DtFilename& parameterDatabaseFilename() const;

   virtual void setPhysicalWorldFilename(const DtFilename& filename);
   virtual const DtFilename& physicalWorldFilename() const;

   virtual void setObjectMapFilename(const DtFilename& filename);
   virtual DtFilename objectMapFilename() const;

   virtual void setOverlayFilename(const DtFilename& filename);
   virtual DtFilename overlayFilename() const;

   virtual void setSelectionGroupsFilename(const DtFilename& filename);
   virtual DtFilename selectionGroupsFilename() const;

   virtual void setSymbolMapFilename(const DtFilename& filename);
   virtual const DtFilename& symbolMapFilename() const;

   virtual void setCreateMenuFilename(const DtFilename& filename);
   virtual const DtFilename& createMenuFilename() const;

   virtual void setForceHostilityFilename(const DtFilename& filename);
   virtual DtFilename forceHostilityFilename() const;

   virtual void setScenarioExtrasFilename(const DtFilename& f);
   virtual DtFilename scenarioExtrasFilename() const;

   virtual void setUseDayNightIlluminationModel(bool);
   virtual bool useDayNightIlluminationModel() const;

   virtual void setTimeMultiplier(DtReal multiplier);
   virtual DtReal timeMultiplier() const;

   virtual void setAutoReorganize(const bool& flag);
   virtual const bool& autoReorganize() const;

   virtual void setRandomNumberSeed(long int numberSeed);
   virtual long int randomNumberSeed() const;

   virtual DtString frameRateModeString() const;
   virtual DtFrameMode frameRateMode() const;
   virtual void setFrameRateModeString(DtString value);
   virtual void setFrameRateMode(DtFrameMode value);

   virtual DtReal frameDeltaTime() const;
   virtual void setFrameDeltaTime(DtReal value);

   virtual DtTime runDurationTime() const;
   virtual void setRunDurationTime(DtTime time);

   virtual void setSimTime(DtTime time);
   virtual DtTime simTime() const;

   virtual void setExerciseStartDateAndTime(int year, int month, int day, int hour, int minute, int second);

   virtual void setExerciseStartDateAndTime(DtTime time);

   virtual void setExerciseStartTime(DtTime time);

   virtual DtTime exerciseStartTime() const;

   virtual void setSetScenarioStartTimeAtSpecifiedLocalTimeOnFirstObjectCreation(bool, int i = 10 * 3600);
   virtual int setScenarioStartTimeAtSpecifiedLocalTimeOnFirstObjectCreation() const;
   virtual bool shouldSetScenarioStartTimeAtSpecifiedLocalTimeOnFirstObjectCreation() const;

   virtual void setCreateGlobalEnvironment(bool b);
   virtual bool createGlobalEnvironment() const;

   virtual void setCreateGlobalDynamicTerrain(bool b);
   virtual bool createGlobalDynamicTerrain() const;

   virtual DtRwNLengthStringVector& additionalOpdFilenames();
   virtual const DtRwNLengthStringVector& additionalOpdFilenames() const;
   virtual void addAdditionalOpdFilename(const DtString&);
   virtual void removeAdditonalOpdFilename(int iIndex);
   virtual void setAdditionalOpdFilenames(const DtRwNLengthStringVector&);

   virtual void setScenarioDescription(const DtString&);
   virtual DtString scenarioDescription() const;

   virtual DtRwNLengthStringVector& simulationModelSetFilenames();
   virtual const DtRwNLengthStringVector& simulationModelSetFilenames() const;
   virtual DtRwNLengthStringVector& unresolvedSimulationModelSetFilenames();
   virtual const DtRwNLengthStringVector& unresolvedSimulationModelSetFilenames() const;
   virtual void addSimulationModelSetFilename(const DtString&);
   virtual void removeSimulationModelSetFilename(int iIndex);
   virtual void setSimulationModelSetFilenames(const DtRwNLengthStringVector&);
   virtual void setSimulationModelSetFilenames(const std::vector<DtFilename>&);
   virtual void setSimulationModelSetFilenames(const std::vector<std::string>&);


   virtual DtRwKeyValueList& scenarioData();
   virtual const DtRwKeyValueList& scenarioData() const;


   virtual DtString scenarioName() const;
   virtual void setScenarioName(const DtString& name);
   virtual bool scenarioNameSpecified() const;

   static DtFilename validTerrainFile(const DtFilename&);

   virtual bool isParameterDatabaseRwStringSpecified();
   virtual bool isPhysicalWorldRwStringSpecified();
   virtual bool isOrderOfBattleRwStringSpecified();
   virtual bool isScenarioScriptsRwStringSpecified();
   virtual bool isOrbatRwStringSpecified();
   virtual bool isOverlayRwStringSpecified();
   virtual bool isSelectionGroupsRwStringSpecified();
   virtual bool isSymbolMapRwStringSpecified();
   virtual bool isCreateMenuRwStringSpecified();
   virtual bool isPlanRwStringSpecified();
   virtual bool isObjectMapRwStringSpecified();
   virtual bool isTimeMultiplierSpecified();
   virtual bool isAutoReorganizeRwStringSpecified();
   virtual bool isRandomNumberSeedSpecified();
   virtual bool isFrameRateModeSpecified();
   virtual bool isRunDurationTimeSpecified();
   virtual bool isFrameDeltaTimeSpecified();
   virtual bool isSimTimeSpecified();
   virtual bool isExerciseStartTimeSpecified();
   virtual bool isForceHostilityRWStringSpecified();
   virtual bool isScenarioExtrasRWStringSpecified();

   virtual void setFilename(const DtFilename&);
   virtual const DtFilename& filename() const;

   virtual bool writeScenarioFile(const DtFilename & filename);

   virtual void putSelf(std::string& fp, int indentLevel = 0, bool writeUnspecified = false,
      const DtFilename& path = DtReaderWriter::appPath());

   virtual void putSelf(DtEnvironmentSP env, DtEnvValueSP parent) const;

   virtual void getSelf(DtlObjPtr args, const DtReaderWriter::SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings);  
   virtual void getSelf(const DtEnvironmentSP env, const DtEnvValueSP root,
      const DtReaderWriter::SearchPaths& searchPaths, const DtVariableBindingsList& varBindings);

   virtual void finalizeGetSelf();

   virtual bool isValid(bool allowEmptyFilenames = true, DtString* retMessage = 0) const;

   virtual double version() const;

   virtual bool relativeToScenarioFile() const;

   virtual void setToCurrentVersion();

   static double currentScenarioVersion();

   virtual bool mapUUIDToScenarioDataFromOobInScenario(const DtFilename& scenarioFile,
            ScenarioDataMap& scenarioDataMap, bool mapUUIDOnly = true);
   virtual bool mapUUIDToScenarioDataFromOobInScenario(DtlInputStream*, ScenarioDataMap& scenarioDataMap, bool mapUUIDOnly = true);

   virtual bool mapUUIDToScenarioDataFromOobInScenario(ScenarioDataMap& scenarioDataMap, bool mapUUIDOnly = true);

   virtual void updateSimulationModelSetFilenames();

   static DtFilename reworkDataDirectory(const DtFilename&);

   static DtFilename replaceDirectoryWithAppropriateVariable(const DtFilename&);
   static DtString replaceDirectoryWithAppropriateVariable(const DtString&);

   virtual void resolveSimulationModelSetPaths();

   virtual void resolveDataPaths();

public:

   static DtString getFrameModeNameFromFrameModeType(DtFrameMode);

   static DtFrameMode getFrameModeTypeFromFrameModeName(
      const DtString& frameModeName);

protected:
   virtual DtFilename absoluteFilename(const DtFilename&) const;

protected:

   DtRwInt    myComponentAttachmentRule;

   DtFilename myComponentAttachmentTableFilename;
   mutable DtRwString myComponentAttachmentTableRwString;
   DtFilename myFilename;

   DtFilename myTerrainDatabaseFilename;
   mutable DtRwString myTerrainDatabaseRwString;

   DtFilename myPhysicalWorldFilename;
   mutable DtRwString myPhysicalWorldRwString;

   DtFilename myGuiTerrainDatabaseFilename;
   mutable DtRwString myGuiTerrainDatabaseRwString;

   DtFilename myOrderOfBattleFilename;
   mutable DtRwString myOrderOfBattleRwString;

   DtFilename myScenarioScriptsFilename;
   mutable DtRwString myScenarioScriptsRwString;

   DtFilename myOrbatFilename;
   mutable DtRwString myOrbatRwString;

   DtFilename myPlanFilename;
   mutable DtRwString myPlanRwString;

   DtFilename myGlobalPlanFilename;
   mutable DtRwString myGlobalPlanRwString;

   DtFilename myParameterDatabaseFilename;
   mutable DtRwString myParameterDatabaseRwString;

   DtFilename myOverlayFilename;
   mutable DtRwString myOverlayRwString;

   DtFilename mySelectionGroupsFilename;
   mutable DtRwString mySelectionGroupsRwString;

   DtFilename mySymbolMapFilename;
   mutable DtRwString mySymbolMapRwString;

   DtFilename myCreateMenuFilename;
   mutable DtRwString myCreateMenuRwString;

   DtFilename myObjectMapFilename;
   mutable DtRwString myObjectMapRwString;

   DtFilename myForceHostilityFilename;
   mutable DtRwString myForceHostilityRwString;

   DtFilename myScenarioExtrasFilename;
   mutable DtRwString myScenarioExtrasRWString;

   mutable DtRwReal myTimeMultiplier;

   bool myAutoReorganize;
   mutable DtRwBoolean myAutoReorganizeRW;

   mutable DtRwInt myRandomNumberSeed;

   mutable DtRwString myFrameRateModeString;
   DtFrameMode myFrameRateMode;
   mutable DtRwReal myFrameDeltaTime;

   mutable DtRwReal myRunDurationTime;

   mutable DtRwReal mySimTime;
   mutable DtRwReal myExerciseStartTime;

   DtRwNLengthStringVector myAdditionalOpdFilenames;
   DtRwNLengthStringVector mySimulationModelSetFilenames;
   DtRwNLengthStringVector myResolvedSimulationModelSetFilenames;

   DtRwString myScenarioName;

   DtRwKeyValueList myScenarioData;

   mutable DtRwReal  myVersion;

   bool mySaveAsZipFile;

protected:

   static DtString thePhysicalWorldFilenameExtension;
   static DtString theOrderOfBattleExtension;
   static DtString theScenarioScriptsExtension;
   static DtString theOrbatExtension;
   static DtString theOverlayExtension;
   static DtString theSelectionGroupsExtension;
   static DtString theSymbolMapExtension;
   static DtString theCreateMenuExtension;
   static DtString thePlanExtension;
   static DtString theGlobalPlanExtension;
   static DtString theObjectMapExtension;
   static DtString theParameterDatabaseExtension;
   static DtString theFileExtension;
   static DtString theForceHostilityExtension;
   static DtString theScenarioDataExtension;

   static double   theScenarioVersion;
};

class DtAddressMap;
class DtList;
class DtBackendMap;

typedef bool (*DtLoadBalancingFcn)(DtAddressMap* map, const DtList* backends,
   bool& remapped, void* usr);

typedef bool (*DtRemappingFcn)(DtBackendMap* map, const std::set<DtSimulationAddress>& expectedBackends, void* usr);

class DT_DLL_vrfutil DtLoadBalancingFcnInfo
{
public:
   DtLoadBalancingFcnInfo();
   DtLoadBalancingFcnInfo(const std::string&, DtLoadBalancingFcn fcn, void*);
   DtLoadBalancingFcnInfo(const DtLoadBalancingFcnInfo&);

   DtLoadBalancingFcnInfo& operator=(const DtLoadBalancingFcnInfo&);

   std::string          myLoadBalancer;
   DtLoadBalancingFcn   myLoadBalancingFcn;
   void*                myLoadBalancingUserData;
};

const int DtImportScenarioCreateUniqueNamesOnImport = 0x00000001;
const int DtImportScenarioImportScenarioEvents = 0x00000002;
const int DtImportScenarioCreateSelectionGroup = 0x00000004;
const int DtSimulationObjectGroupPreserveForceInformation = 0x00000008;
const int DtSimulationObjectGroupUseGroupNameToDisambiguate = 0x00000010;
const int DtSimulationObjectGroupAltitudesAreAboveTerrain = 0x00000020;
const int DtSimulationObjectGroupCreationMode = 0x00000040;
const int DtSimulationObjectGroupAllowAltitudePlacement = 0x00000080;
const int DtImportScenarioKeepOnlyOriginalSimulationObjects = 0x00000100;

const int DtImportScenarioDefaultFlags = DtImportScenarioCreateUniqueNamesOnImport | DtImportScenarioImportScenarioEvents |
   DtImportScenarioCreateSelectionGroup;
const int DtSimulationObjectGroupDefaultFlags = DtImportScenarioCreateUniqueNamesOnImport | DtImportScenarioImportScenarioEvents |
   DtImportScenarioCreateSelectionGroup | DtSimulationObjectGroupPreserveForceInformation | DtSimulationObjectGroupAltitudesAreAboveTerrain;

class DT_DLL_vrfutil DtScenarioLoadInformation
{
public:
   DtScenarioLoadInformation();
   DtScenarioLoadInformation(bool createAsNew, DtScenario*, DtLoadBalancingFcnInfo, DtRemappingFcn fcn = 0, void* remappingUsrData = 0,
      time_t startTimeOfDay = 0, bool import = false, const DtSimulationAddress& address = DtSimSendToAll);
   DtScenarioLoadInformation(const DtScenarioLoadInformation&);

   DtScenarioLoadInformation& operator=(const DtScenarioLoadInformation&);

public:
   bool                    myCreateAsNew;
   DtScenario*             myScenario;
   DtLoadBalancingFcnInfo  myInfo;
   DtRemappingFcn          myRemappingFcn;
   void*                   myRemappingUserData;
   time_t                  myStartTimeOfDay;
   bool                    myImport;
   DtSimulationAddress     myImportLoadAddress;
};

struct DtSimulationObjectGroupSaveInformation
{
   DtSimulationObjectGroupSaveInformation() : groupCreationFlags(DtSimulationObjectGroupDefaultFlags),
      storedInZipFile(true)
   {
   };

   DtSimulationObjectGroupSaveInformation(const DtSimulationObjectGroupSaveInformation& orig) :
      groupName(orig.groupName), groupDescription(orig.groupDescription), label(orig.label),
      groupCreationFlags(orig.groupCreationFlags), categories(orig.categories), palette(orig.palette),
      additionalInformation(orig.additionalInformation), menuIcon(orig.menuIcon), rootDirectory(orig.rootDirectory),
      storedInZipFile(orig.storedInZipFile) {};

   bool operator==(const DtSimulationObjectGroupSaveInformation& rhs) const
   {
      return ((rootDirectory == rhs.rootDirectory) &&
         (groupName == rhs.groupName) &&
         (groupDescription == rhs.groupDescription) &&
         (label == rhs.label) &&
         (palette == rhs.palette) &&
         (menuIcon == rhs.menuIcon) &&
         (groupCreationFlags == rhs.groupCreationFlags) &&
         (categories == rhs.categories) &&
         (storedInZipFile == rhs.storedInZipFile) &&
         (additionalInformation == rhs.additionalInformation));
   }

   bool operator!=(const DtSimulationObjectGroupSaveInformation& rhs) const { return !(*this == rhs); };

   DtFilename rootDirectory;
   std::string groupName;
   std::string groupDescription;
   std::string palette;
   std::string menuIcon;
   std::string label;
   int groupCreationFlags;
   std::vector<DtString> categories;
   std::map<DtString, DtString> additionalInformation;
   bool storedInZipFile;
};