scriptInterface.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2012 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#pragma once

#include <vrfmodel/vrfmodelDefines.h>

#include "vlutil/vlString.h"
#include "vrfobjcore/scriptedTaskManager.h"
#include "vrfobjcore/vrfObject.h"
#include "vrfobjcore/scriptVrfObject.h"
#include "vrfutil/rwVariableBindings.h"
#include <deque>

class DtScriptMultiTaskController;


class DT_DLL_vrfmodel DtScriptInterface
{
protected:
   DtScriptInterface();
   DtScriptInterface(const DtScriptInterface& other);
   DtScriptInterface& operator=(const DtScriptInterface& other);

public:
   virtual ~DtScriptInterface();

   virtual bool invokeInit() = 0;

   virtual void invokeTick() = 0;

   virtual bool loadScript() = 0;


   virtual DtString type() const = 0;

   virtual void setTaskId(int taskId) { myTaskId = taskId; }
   virtual int taskId() const { return myTaskId; }

   virtual void setScriptId(const DtString& scriptId) { myScriptId = scriptId; }
   virtual const DtString& scriptId() const { return myScriptId; }

   virtual void setScriptPath(const DtFilename& scriptPath) { myScriptPath = scriptPath; }
   virtual const DtFilename& scriptPath() const { return myScriptPath; }

   virtual void setParent(DtScriptMultiTaskController* parent) { myParent = parent; }
   virtual DtScriptMultiTaskController* parent() const { return myParent; }

   virtual void setEntity(DtVrfObject* entity) { myEntity = entity; }
   virtual DtVrfObject* entity() const { return myEntity; }

   virtual void init() {};

   virtual void setTaskVariables(const DtRwVariableBindings& variables) { myTaskVariables = variables; }
   virtual const DtRwVariableBindings& taskVariables() const { return myTaskVariables; }
   virtual bool updateTaskVariables();

   virtual void processScenarioSave(DtRwVariableBindings* saveState) = 0;

   virtual bool processScenarioLoad(const DtRwVariableBindings* loadState) = 0;

   virtual void processClearForReuse();

   virtual void setTaskStarting(bool v);
   virtual bool taskStarting() const;

   double scriptGetExerciseTime();

   double scriptGetTimeOfDay();

   double       scriptGetWindSpeed();

   double       scriptGetWindDirection();

   DtScriptVrfObject scriptGetVrfObjectByName(const std::string name);
   void         printError(const std::string message);
   void         printWarn(const std::string message);
   void         printInfo(const std::string message);
   void         printVerbose(const std::string message);
   void         printDebug(const std::string message);
   bool         entityTypeMatches(const std::string&, const std::string&);

   void setTickPeriod(double);

   double getTerrainAltitude(const double lat, const double lon,
      bool& dataAvailable, std::string &surface) const;


   bool doesChordHitTerrain(const DtLocation3D &pt1, 
      const DtLocation3D & pt2, 
      bool& dataAvailableart
      ) const;

   virtual DtLocation3D findClosestPointToRoad(const DtLocation3D& point, double searchRadius, bool& dataAvailable, bool& success) const;

   std::string getForceName(int forceType);
   bool forcesHostile(std::string force1, std::string force2);


protected:
   virtual void scriptTaskComplete(bool success);

   virtual bool scriptText(std::string& text);

   virtual const DtReaderWriter* getTaskParam(const DtString& paramName);

   virtual bool getParamMetaDataType(const DtString& paramName, DtString& typeName);

   int myTaskId;
   DtString myScriptId;
   DtFilename myScriptPath;
   DtVrfObject* myEntity;
   DtRwVariableBindings myTaskVariables;
   DtScriptMultiTaskController* myParent;
   bool myTaskStarting;
};

typedef DtScriptInterface* (*DtScriptInterfaceCreatorFunc)();

class DT_DLL_vrfmodel DtScriptInterfaceFactory
{
protected:
   DtScriptInterfaceFactory();
   DtScriptInterfaceFactory(const DtScriptInterfaceFactory& other);
   DtScriptInterfaceFactory& operator=(const DtScriptInterfaceFactory& other);
   
public:
   virtual ~DtScriptInterfaceFactory();

   static DtScriptInterfaceFactory* instance();

   virtual DtScriptInterface* createInstance(const std::string& type);
   virtual void destroyInstance(DtScriptInterface* iFace);

   virtual void registerCreator(const std::string& type, DtScriptInterfaceCreatorFunc func);

   virtual void setMaxInterfaceReuse(unsigned int count);
   virtual unsigned int maxInterfaceReuse() const { return myMaxInterfaceReuse; }

   static void setFactory(DtScriptInterfaceFactory* factory);
   static DtScriptInterfaceFactory* create();

protected:
   unsigned int myMaxInterfaceReuse;
   std::map<std::string, DtScriptInterfaceCreatorFunc> myCreators;
   std::deque<DtScriptInterface*> myScriptInterfaceReuse;
   static DtScriptInterfaceFactory* theFactoryInstance;
};