luaScriptInterfaceImpl.h

Go to the documentation of this file.

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

#include <vrfLua/vrfLuaDefines.h>
#include <vrfLua/luaFeatureSet.h>
#include <vrfLua/luaPathJob.h>

#include "vrfobjcore/scriptInterface.h"
#include "vrfobjcore/translatableStream.h"
#include "vrfutil/scriptGeometry.h"
#include "vrfobjcore/scriptVrfObject.h"
#include <luabind/luabind.hpp>
#include <vrfobjcore/luaScriptInterfaceExtension.h>
#include <vrfExtObjects/influenceInteractionHLA.h>
#include <vrfutil/objectCounter.h>
//TMP
#include <vrfcore/simManager.h>
#include <vrfcore/exerciseClock.h>

#include <lua.hpp>
#include <lauxlib.h>
#include <lualib.h>

typedef luabind::object (*ReaderWriterToLuaTableFcn)(lua_State* LS, const DtReaderWriter* rwString,
   DtVrfObjectManager* mgr, const DtString& parameterType);

class DT_DLL_vrfLua DtLuaScriptInterfaceImpl
   : public DtScriptInterface
   , public DtObjectDebugger<DtLuaScriptInterfaceImpl>
{
protected:
   DtLuaScriptInterfaceImpl();

   DtLuaScriptInterfaceImpl(const DtLuaScriptInterfaceImpl& other);
   DtLuaScriptInterfaceImpl& operator=(const DtLuaScriptInterfaceImpl& other);

public:
   virtual ~DtLuaScriptInterfaceImpl();

   static DtScriptInterface* creator();

   virtual void init();

   virtual DtString type() const;

   virtual bool invokeInit();
   virtual void invokeSuspend();
   virtual bool invokeResume();
   virtual void invokeTick();
   virtual bool invokeCheck();
   virtual void invokeCheckInit();
   virtual void invokeShutdown();

   virtual void invokeDisable();

   virtual bool loadScript(bool reload);

   virtual void setLuaState(lua_State* L);
   virtual lua_State* getLuaState();

   virtual std::string dumpLuaStack() const;
   virtual int luaStackSize() const;
   virtual void collectGarbage();

   virtual DtReaderWriter* saveState();
   virtual bool loadState(const DtReaderWriter* loadState);
   virtual void processClearForReuse();

   static void addLuaScriptInterfaceExtension(DtLuaScriptInterfaceExtension::CreatorFcn extension, void* usr);

   static void addLuaScriptInterfaceExtension(DtLuaScriptInterfaceExtension::CreatorFcn extension,
      const DtVrfObject* onlyForEntity, void* usr);

   static void removeLuaScriptInterfaceExtension(DtLuaScriptInterfaceExtension::CreatorFcn extension, void* usr);

   static void removeLuaScriptInterfaceExtension(DtLuaScriptInterfaceExtension::CreatorFcn extension,
      const DtVrfObject* onlyForEntity, void* usr);

   virtual bool initializeVRFLuaExtensions(lua_State* L);
   virtual bool importTaskParams(lua_State* L);

   virtual bool importSetParams(lua_State* L);

   virtual luabind::object createLuaTableFromRegistry(lua_State* L, const DtReaderWriterRegistry& rwRegistry, bool requireMetadata = true);

   static void addKeyToIgnore(const std::string&);

   static void removeKeyToIgnore(const std::string&);

   void luaEndTask(bool success);
   void luaEndSet();



   virtual void luaPlayScenarioEvent(DtScriptVrfObject eventName);
   virtual void luaStopScenarioEvent(DtScriptVrfObject eventName);
   virtual void luaStopScenarioEventWithRewind(DtScriptVrfObject eventName, bool rewind);
   virtual bool luaIsScenarioEventPlaying(DtScriptVrfObject eventName);
   virtual void luaSetScenarioEventEnabled(DtScriptVrfObject eventName, bool);
   virtual bool luaIsScenarioEventEnabled(DtScriptVrfObject eventName);



   virtual int luaSendEmbeddedEntityTask(std::string eeName, std::string taskName, luabind::object const& parms);
   virtual int luaSendEmbeddedEntityTaskActAsSubtask(std::string eeName, std::string taskName,
      luabind::object const& parms, bool actAsSubtask);
   virtual int luaSendEmbeddedEntitySet(std::string eeName, std::string setName, luabind::object const& parms);



   int luaStartSubtask(const std::string taskName, luabind::object const& parameters);
   void luaStopSubtask(int subtaskId);
   void luaStopAllSubtasks();
   bool luaIsSubtaskRunning(int subtaskId);
   bool luaIsSubtaskComplete(int subtaskId);
   bool luaIsSubtaskCanceled(int subtaskId);
   bool luaSubtaskResult(int subtaskId);
   void luaCleanupInactiveSubtaskStatus();

   void luaSendReportWithoutRecipients(const::std::string reportType,
      luabind::object const& parameters);
   void luaSendReport(const::std::string reportType,
      luabind::object const& reciptients,
      luabind::object const& parameters);

   int luaSendTask(DtScriptVrfObject& object, const::std::string taskName,
      luabind::object const& parameters);
   int luaSendTaskActAsSubtask(DtScriptVrfObject& object, const::std::string taskName,
      luabind::object const& parameters, bool actAsSubtask);
   int luaSendRadioTask(DtScriptVrfObject& object, const::std::string taskName,
      luabind::object const& parameters);
   int luaSendRadioTaskActAsSubtask(DtScriptVrfObject& object, const::std::string taskName,
      luabind::object const& parameters, bool actAsSubtask);
   int luaSendTaskActAsSubtaskWithRadio(DtScriptVrfObject& object, const::std::string taskName,
      luabind::object const& parameters, bool actAsSubtask, bool sendWithRadio);

   void luaStopAllTasks();

   void luaSendSetDataToSelf(const::std::string setName,
      luabind::object const& parameters);

   void luaSendSetData(DtScriptVrfObject& object, const::std::string setName,
      luabind::object const& parameters);
   void luaSendRadioSetData(DtScriptVrfObject& object, const::std::string setName,
      luabind::object const& parameters);
   void sendSetDataWithRadio(DtScriptVrfObject& object, const::std::string setName,
      luabind::object const& parameters, bool useRadio);
   
   bool luaIsTaskAvailable(const::std::string taskName);
   bool luaIsSetAvailable(const::std::string setName);

   luabind::object luaGetReactionStatus();

   luabind::object luaGetOrbatList();

   std::string luaGetScriptId();

   std::string luaGetSystemName();

   luabind::object luaGetObjectsNear(const DtLocation3D& loc, double distance);
   luabind::object luaGetObjectsNearWithFilter(const DtLocation3D& loc, double distance, luabind::object const& parameters);

   luabind::object luaGetScriptAttribute(const std::string& attributeName, bool& error);

   luabind::object luaGetVrfObjects();



   DtLuaFeatureSet luaGetFeaturesWithinArea(luabind::object const& points, luabind::object const& attributes);
   DtLuaFeatureSet luaGetFeaturesWithinAreaNoAttributes(luabind::object const& points);

   DtLuaFeatureSet luaGetFeaturesWithinRange(const DtLocation3D&, double range, luabind::object const& attributes);
   DtLuaFeatureSet luaGetFeaturesWithinRangeNoAttributes(const DtLocation3D&, double range);

   DtLuaFeatureSet luaGetFeaturesType(const std::string& type);
   DtLuaFeatureSet luaGetFeatures();



   DtLuaFeatureGeometry luaMakePointGeometry(const DtLocation3D&);
   DtLuaFeatureGeometry luaMakePathGeometry(const std::vector<DtLocation3D>&);
   DtLuaFeatureGeometry luaMakeAreaGeometry(const std::vector<DtLocation3D>&);

   boost::shared_ptr<DtLuaAsyncJob> generateRandomPoints(const luabind::object& parameters);

   boost::shared_ptr<DtLuaAsyncJob> findNearbyPointOfInterest(const int type);

   boost::shared_ptr<DtLuaAsyncJob> findCoverPoint(
      const DtLocation3D& startLocation, const DtLocation3D& threatLocation,
      double threatRadius, double distanceFromThreat, double range, unsigned numberOfPoints);

   boost::shared_ptr<DtLuaAsyncJob> findPathToLocation(
      const DtLocation3D& startLocation, const DtLocation3D& destinationLocation, 
      bool useAbstractGraphs, const DtLocation3D& avoidLocation, double avoidanceRadius);

   DtTranslatableStream translateStringFromScript(const std::string& format);

   boost::shared_ptr<DtLuaAsyncJob> luaNavigateThroughFeatures(const luabind::object& parameters);

   void luaSendMessage(const DtScriptVrfObject& receiver, const std::string& message);
   void luaSendRadioMessage(const DtScriptVrfObject& receiver, const std::string& message);
   void luaDeleteObject(std::string const& receiver);
   void luaDeleteScriptObject(const DtScriptVrfObject& receiver);

   static void textReportCallback(const DtVrfObjectMessage* m, void* usr);
   virtual void processTextReport(const DtVrfObjectMessage* m);

   void luaSendInfluence(const DtScriptVrfObject& target, 
      const std::string& influenceName, luabind::object const& influenceParams);

   static void addReaderWriterToLuaTableFunction(const DtString&, ReaderWriterToLuaTableFcn);

#ifdef DtHLA
   static void influenceCallback(DtInfluenceInteraction* m, void* usr);
   virtual void processInfluence(DtInfluenceInteraction* m);
#endif

   virtual void processEntityDestroyed();

   virtual void luaSetPrecipitationIntensity(DtScriptVrfObject& object, double intensity);   
   virtual void luaSetPrecipitationType(DtScriptVrfObject& object, int type);
   virtual void luaSetCloudCover(DtScriptVrfObject& object, int state);         
   virtual void luaSetVisibilityDistance(DtScriptVrfObject& object, double distance);
   virtual void luaSetWindDirection(DtScriptVrfObject& object, double);
   virtual void luaSetWindSpeed(DtScriptVrfObject& object, double);
   virtual void luaSetUnderwaterVisibility(DtScriptVrfObject& object, double visibility);
   virtual void luaSetSurfaceTransparency(DtScriptVrfObject& object, double transparency);
   virtual void luaSetSwellState(DtScriptVrfObject& object, unsigned int state);
   virtual void luaSetSwellStateDirection(DtScriptVrfObject& object, double direction);
   virtual void luaSetSeaState(DtScriptVrfObject& object, unsigned int state);
   virtual void luaSetSeaStateDirection(DtScriptVrfObject& object, double direction);
   virtual void luaSetWindDrivenSeaStateEnabled(DtScriptVrfObject& object, bool enabled);
   virtual void luaSetChoppiness(DtScriptVrfObject& object, double choppiness);
   virtual void luaSetSurgeDepth(DtScriptVrfObject& object, double depth);
   virtual void luaSetFogHeight(DtScriptVrfObject& object, double depth);
   virtual void luaSetFogColor(DtScriptVrfObject& object, double red, double green, double blue);
   virtual void luaSetPriority(DtScriptVrfObject& object, int);

   virtual bool isWeatherObject(DtScriptVrfObject&) const;


   virtual double luaGetAirTemperature(DtScriptVrfObject& object);
   virtual unsigned int luaGetPrecipitation(DtScriptVrfObject& object, double*);
   virtual double luaGetPrecipitationIntensity(DtScriptVrfObject& object);
   virtual unsigned int luaGetPrecipitationType(DtScriptVrfObject& object);
   virtual int luaGetCloudCover(DtScriptVrfObject& object);      
   virtual double luaGetVisibilityDistance(DtScriptVrfObject& object);
   virtual double luaGetWindDirection(DtScriptVrfObject& object);
   virtual double luaGetWindSpeed(DtScriptVrfObject& object);
   virtual double luaGetUnderwaterVisibility(DtScriptVrfObject& object);
   virtual double luaGetSurfaceTransparency(DtScriptVrfObject& object);
   virtual unsigned int luaGetSwellState(DtScriptVrfObject& object);
   virtual double luaGetSwellStateDirection(DtScriptVrfObject& object);
   virtual unsigned int luaGetSeaState(DtScriptVrfObject& object);
   virtual double luaGetSeaStateDirection(DtScriptVrfObject& object);
   virtual bool luaGetWindDrivenSeaStateEnabled(DtScriptVrfObject& object);
   virtual double luaGetChoppiness(DtScriptVrfObject& object);
   virtual double luaGetSurgeDepth(DtScriptVrfObject& object);
   virtual double luaGetFogHeight(DtScriptVrfObject& object);
   virtual double luaGetFogHeightByLocation(const DtLocation3D& object);
   virtual void luaGetFogColor(DtScriptVrfObject& object, double* red, double* green, double* blue);
   virtual void luaGetFogColorByLocation(const DtLocation3D& object, double* red, double* green, double* blue);
   virtual int luaGetPriority(DtScriptVrfObject& object);
   virtual double luaGetIllumination(DtScriptVrfObject& object);

   virtual double luaGetAirTemperatureByLocation(const DtLocation3D& object);
   virtual unsigned int luaGetPrecipitationByLocation(const DtLocation3D& location, double*);
   virtual double luaGetPrecipitationIntensityByLocation(const DtLocation3D& object);
   virtual unsigned int luaGetPrecipitationTypeByLocation(const DtLocation3D& object);
   virtual int luaGetCloudCoverByLocation(const DtLocation3D& object);      
   virtual double luaGetVisibilityDistanceByLocation(const DtLocation3D& object);
   virtual double luaGetWindDirectionByLocation(const DtLocation3D& object);
   virtual double luaGetWindSpeedByLocation(const DtLocation3D& object);
   virtual double luaGetUnderwaterVisibilityByLocation(const DtLocation3D& object);
   virtual double luaGetSurfaceTransparencyByLocation(const DtLocation3D& object);
   virtual unsigned int luaGetSwellStateByLocation(const DtLocation3D& object);
   virtual double luaGetSwellStateDirectionByLocation(const DtLocation3D& object);
   virtual unsigned int luaGetSeaStateByLocation(const DtLocation3D& object);
   virtual double luaGetSeaStateDirectionByLocation(const DtLocation3D& object);
   virtual bool luaGetWindDrivenSeaStateEnabledByLocation(const DtLocation3D& object);
   virtual double luaGetChoppinessByLocation(const DtLocation3D& object);
   virtual double luaGetSurgeDepthByLocation(const DtLocation3D& object);
   virtual int luaGetPriorityByLocation(const DtLocation3D& object);
   virtual double luaGetIlluminationByLocation(const DtLocation3D& object);

   virtual double luaRunDurationTime();
   virtual void luaRunForDuration(double);
   virtual void luaStopSimulationDurationTimer();

   virtual void luaSetCheckpointMode(bool);
   virtual void initializeCheckpointStateTable(lua_State* L);

   virtual int luaAskUserQuestion(const DtTranslatableStream& title, const DtTranslatableStream& message,
      luabind::object const& options, int displayFlags);
   virtual int luaAskUserQuestionST(const std::string& title, const DtTranslatableStream& message,
      luabind::object const& options, int displayFlags);
   virtual int luaAskUserQuestionTS(const DtTranslatableStream& title, const std::string& message,
      luabind::object const& options, int displayFlags);
   virtual int luaAskUserQuestionSS(const std::string& title, const std::string& message,
      luabind::object const& options, int displayFlags);

   virtual int luaStatusOfUserQuestion(int questionId);

   virtual void luaCancelUserQuestion(int questionId);


   DtScriptVrfObject luaCreateEntity(luabind::object const& parameters);

   DtScriptVrfObject luaCreateFromOrbat(std::string orbatItem, const DtLocation3D& loc);

   DtScriptVrfObject luaGetGlobalWeather();

   DtScriptVrfObject luaCreateTacticalGraphic(luabind::object const& parameters);

   DtScriptVrfObject luaCreateObstacle(luabind::object const& parameters);

   DtScriptVrfObject luaCreateRoute(luabind::object const& parameters);

   DtScriptVrfObject luaCreateArea(luabind::object const& parameters);

   DtScriptVrfObject luaCreateWaypoint(luabind::object const& parameters);

   DtScriptVrfObject luaCreatePhaseLine(luabind::object const& parameters);

   void luaCreateSelectionGroup(const std::string& name, luabind::object const& parameters);

   bool luaUpdateTaskVisualization(const std::string& visualizationName, 
      const std::string& visualizationType, luabind::object const& parameters);

   void luaDeleteTaskVisualization(const std::string& visualizationName);

   void luaRequire(lua_State* L, const std::string& filename);

   unsigned luaBitwiseOr(unsigned val1, unsigned val2);
   unsigned luaBitwiseAnd(unsigned val1, unsigned val2);
   unsigned luaBitwiseXor(unsigned val1, unsigned val2);
   unsigned luaBitwiseNot(unsigned val);
   unsigned luaBitwiseLeftShift(unsigned val, unsigned shift);
   unsigned luaBitwiseRightShift(unsigned val, unsigned shift);

   bool luaIntersectSegments2D(const DtLocation3D& p1, const DtLocation3D& p2, const DtLocation3D& p3, const DtLocation3D& p4,
      DtLocation3D& intersectPoint);

   class DtLuaScriptFunctionReference : public DtScriptFunctionReference
   {
   public:
      DtLuaScriptFunctionReference(const std::string& functionName)
      : DtScriptFunctionReference()
      , myFunctionName(functionName)
      {

      }

      virtual ~DtLuaScriptFunctionReference()
      {

      }

      std::string functionName() const
      {
         return myFunctionName;
      }

      virtual bool operator<(const DtScriptFunctionReference& other) const
      {
         try
         {
            const DtLuaScriptFunctionReference& rhs = 
               dynamic_cast<const DtLuaScriptFunctionReference&>(other);
            return myFunctionName.compare(rhs.myFunctionName) < 0;
         }
         catch(...)
         {
            DtInfo << "DtLuaScriptFunctionReference::operator< attempt to compare with wrong type.\n";
            return false;
         }
      }

   protected:
      std::string myFunctionName;
   };

   virtual void addPostSetDataCallback(const std::string& setDataType,
      const std::string& functionName);
   virtual void removePostSetDataCallback(const std::string& setDataType,
      const std::string& functionName);

   virtual void invokePostSetDataCallback(
      DtScriptFunctionReferencePtr functionReference, 
      DtSetDataRequestMessage* setDatRequest);

   virtual void putObjectsFromTableIntoGlobalTable(lua_State* state, luabind::object& table);
   virtual void putObjectsFromGlobalTableIntoTable(lua_State* state, luabind::object& table);

protected:
   virtual bool callLuaNoArgFunction(const std::string& functionName, bool* functionExists = 0);

   virtual void updateFuncCallCount();

   lua_State* myLState;
   unsigned myFuncCallCount;
   bool myLuaScriptWarningShown;

   typedef std::vector<DtLuaScriptInterfaceExtension*> LocalInterfaceExtensions;
   LocalInterfaceExtensions myInterfaceExtensions;

   struct LuaExtension
   {
      LuaExtension() : creator(0), onlyForEntity(0), usr(0) {};
      LuaExtension(const LuaExtension& orig) : creator(orig.creator), onlyForEntity(orig.onlyForEntity),
         usr(orig.usr) {};

      DtLuaScriptInterfaceExtension::CreatorFcn creator;
      const DtVrfObject* onlyForEntity;
      void* usr;
   };

   typedef std::vector<LuaExtension> GlobalInterfaceExtensions;

   static GlobalInterfaceExtensions theLuaInterfaceExtensions;

   luabind::object* myCheckpointStateTable;

   typedef std::map<DtString, ReaderWriterToLuaTableFcn> ReaderWriterToLuaTableMap;
   static ReaderWriterToLuaTableMap theReaderWriterToLuaTableMap;
};

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtLuaScriptInterfaceImpl);

namespace luaScriptInterface
{
   typedef luabind::object (*rwToLuaBindObjectFcn)(
      DtReaderWriter* rw, lua_State* L);

   luabind::object luaGetEntityParam(lua_State* L, 
      const DtScriptVrfObject& entity, std::string const& paramName);

   luabind::object luaGetSystemAttribute(
      const DtScriptComponentSystem& system, const std::string& attributeName
      , bool *error
      , lua_State *L
      );

   luabind::object luaGetContactInfo(lua_State* L, const DtScriptVrfObject& thisEntity,
      const DtScriptVrfObject& otherEntity);

   std::list<DtScriptVrfObject> luaGetContactsWithFilter(
      lua_State* L, const DtScriptVrfObject& entity,
      luabind::object const& typeFilters, bool observedOnly);

   bool luaSetStateProperty(lua_State* L, const DtScriptVrfObject& entity,
      const std::string& propertyName, luabind::object const& prop);

   bool luaSetOrAddStateProperty(lua_State* L, const DtScriptVrfObject& entity,
      const std::string& propertyName, luabind::object const& prop, bool addIfNotFound);

   bool luaSetStatePropertyListItem(lua_State* L,
      const DtScriptVrfObject& entity, const std::string& propertyName,
      luabind::object const& keyValues, luabind::object const& itemValue);

   bool luaSetStatePropertyListItemByIndex(
      lua_State* L, const DtScriptVrfObject& entity, const std::string& propertyName,
      int index, luabind::object const& itemValue);

   bool luaSetStatePropertyMapItem(lua_State* L,
      const DtScriptVrfObject& entity, const std::string& propertyName,
      luabind::object const& keyValue, luabind::object const& itemValue);

   luabind::object luaGetStateProperty(lua_State* L,
      const DtScriptVrfObject& entity, const std::string& propertyName);

   luabind::object luaGetStatePropertyListItem(lua_State* L,
      const DtScriptVrfObject& entity, const std::string& propertyName,
      luabind::object const& keyValues, int& index);

   luabind::object luaGetStatePropertyListItemByIndex(lua_State* L,
      const DtScriptVrfObject& entity, const std::string& propertyName,
      int index);

   luabind::object luaGetStatePropertyMapItem(lua_State* L,
      const DtScriptVrfObject& entity, const std::string& propertyName,
      luabind::object const& keyValue);

   luabind::object luaGetParamProperty(lua_State* L, 
      const DtScriptVrfObject& entity, std::string const& paramName);

   luabind::object luaGetParameterPropertyListItem(lua_State* L,
      const DtScriptVrfObject& entity, const std::string& propertyName,
      luabind::object const& keyValues, int& index);

   luabind::object luaGetParameterPropertyListItemByIndex(lua_State* L,
      const DtScriptVrfObject& entity, const std::string& propertyName,
      int index);

   luabind::object luaGetParameterPropertyMapItem(lua_State* L,
      const DtScriptVrfObject& entity, const std::string& propertyName,
      luabind::object const& keyValue);

   bool luaSetSystemAttribute(
      DtScriptComponentSystem& system, const std::string& attributeName,
      const luabind::object & value,
      lua_State *L);

   static const std::map<DtString, rwToLuaBindObjectFcn>& rwToLuaBindObjectMap();
};