Display AggregateLevel State Data (displayStateData)

Table of Contents

• Overview
• How to Run the Example
• Plugin Entry Points

The Display AggregateLevel State Data example does the following.

• Installs a new sim console command
• Looks up an object by name in the object manager
• Creates plans from tasks and sets
• Creates, sets, finds, and accesses values of state properties
• Creates a global plan

Overview

This example shows how to create a VR-Forces sim engine plugin that will install new console commands that can be issued to both print out various data to the console associated with objects in the system and issue plans to the entities in the scenario.

This plugin is designed to be used with the AggregateLevel SMS. Many of the concepts and techniques on display here are also relevant EntityLevel simulation, however the specific state properties and tasks used are specific to AggregateLevel simulation.

This example currently adds the following console commands.

• print-airbase <name> - prints airbase specific data. If the object is not an airbase a warning will be issued.
• start-movement-mission <name> - Starts a move to waypoint mission using F-16C aircraft at the supplied air base. If the object is not an airbase a warning will be issued.
• start-escort-mission <name> - Starts an escort mission using F-16C aircraft at the supplied air base. If the object is not an airbase a warning will be issued. You will need to add more F16 aircraft to the airbase in order to use this feature.
• print-status <name | ALL> - prints various status (health, fuel, equipment, weapon stores). If the object is not an airbase a warning will be issued. Use ALL to print out all aggregates.
• help-display - prints this list.

Since this example is loaded as a plugin, it can be used in conjunction with the released VR-Forces application.

How to Run the Example

In the Launcher, click the Plug-ins button to bring up the Plug-ins Selection dialog. Enable the plugin.

To view the new behavior:

1. Launch VR-Forces GUI and SIM for HLA1516 Evolved only. This example, while it will build in multiple protocols, will only work in the 1516 Evolved protocol.
2. Load the userData\scenarios\Sample\developer_toolkit_examples\displayStateData\displayStateData.scnx in order to use this example.
3. The vrfSim console will print out information that the plugin is loaded and what commands are available.
4. If the list with the commands is not printed - type the help-display command in the VRF SIM console window. The available commands will be printed out.

5. Type a command from the list in the vrfSim console window. For instance, this will cause data to be printed out about "AB 1".

   print-airbase AB 1

6. To witness the movement-mission and escort-mission you will need to run at 15X (it takes time for the base to launch the assets). Open the air base's information/FlightStatus tab to see this.

  Note: In Linux - you should not use the Launcher to start the SIM and the GUI. 
  You need to start the vrfSim and vrfGui, manually - from two separate terminal windows.
  The necessary GUI and sim engine command line arguments can be copied from the Launcher UI.

Plugin Entry Points

The plugin.cxx file contains all the code necessary to run this example

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

#include "vrfcgf/vrfPluginExtension.h"
#include <vlpi/entityType.h>
#include "vrfcgf/defaultVrfCreator.h"
#include "vrfcgf/vrfCreator.h"
#include "vrfcore/simulationServices.h"
#include "vrfobjcore/simInternalCommunicationManager.h"
#include "vrfobjcore/vrfObjectStateRepository.h"
#include "vrfobjcore/vrfSimulatedSimObjectFacade.h"
#include "vrfobjcore/physicalWorld.h"
#include "vrfobjcore/vrfObjectPlanManager.h"
#include "vrfobjcore/localObjectManager.h"
#include "vrfobjcore/simObjectManager.h"
#include "vrfobjcore/localObject.h"
#include "vrftasks/scriptedTaskSet.h"
#include "vrftasks/scriptedTaskTask.h"
#include "vrftasks/waitDurationTask.h"
#include "vrftasks/setStateProperties.h"
#include "vrfplan/issuePlanCommand.h"
#include "vrfplan/planBuilder.h"
#include "vrftasks/setIffRequest.h"
#include "vrftasks/moveToTask.h"
#include "vrftasks/setEngagementRulesRequest.h"
#include <vrfplanmgr/globalPlanManager.h>

#include "vrfutil/consoleCommandManager.h"
#include "vrfutil/ceEntityCreated.h"
#include "readerWriter/rwPropertiesMap.h"
#include "readerWriter/rwPropertiesStructure.h"
#include <readerWriter/rwReal.h>
#include <readerWriter/propertyUtils.h>

#include <terrainCS/coordSystem.h>

#include "vrfcgf/cgf.h"

extern "C" {

   DT_VRF_DLL_PLUGIN void DtPluginInformation(DtVrfPluginInformation& info)
   {
      info.pluginName = "displayStateData";
      info.pluginDescription = "Adds console commands to allow for the dislpay of state data.  Type help-display to get a list of commands.";
      info.pluginVersion = "1.00";
      info.pluginCreator = "MAK Technologies";
      info.pluginCreatorEmail = "sales@mak.com";
      info.pluginContactWebPage = "www.mak.com";
      info.pluginContactMailingAddress = "10 Fawcett Street, Suite 204, Cambridge, MA 02138 USA";
      info.pluginContactPhone = "(617) 876 8085";
   }

   // When looking how to create a code task around a scripted task, you will need to know the scripted task script id you want to
   // create the code around, and then inspect that script in the VR-Forces GUI to determine which variables are in that task to determine what
   // reader writer variables need to be created and added to the scripted task.  For example, in the script below, the launch_flight_mission
   // scripted task is used.  If you look at the Launch Flight Mission script, you can see the variables in the code mentioned below.
   //
   // The important parts to notice are the Variable Name and Type.  The myVariableName is the reader/writer name you will use when creating your
   // scripted task variable.  The myType is the type of variable you will create.  There are some common types you can see in the scripted tasks:
   //
   // string - DtRwString
   // integer - DtRwInt
   // double - DtRwReal
   // simulationobject - DtRwObjectName
   // datetime - DtRwReal
   //
   // When creating these reader/writer variables to add to the scripted task, you need to create the variable with the appropriate name and assign the value you want.
   // For example, if you need to assign the AirBase, you would do:
   //
   // createFlightTask.setValue("Airbase", obj->uuid());
   //
   //
   // The code saying you are adding an Airbase variable to the scripted task, and, for printing out on the screen in a plan, the variable type it is (this part is optional).
   //
   // For something like a double you would do:
   //
   // createFlightTask.setDateTime("LaunchTime", 0.);
   //
   // And so on, for the variables you want to add to the scripted task.
   class DtStartMovementMissionCommand : public DtConsoleCommand
   {
   public:
      DtStartMovementMissionCommand(DtCgf* c) : myCgf(c) {};
      virtual ~DtStartMovementMissionCommand() override {};

      virtual bool execute(const DtString& parameters) override
      {
         DtSimObjectReference obj = myCgf->simObjectManager()->lookup(DtUUID(parameters));
         DtSimObjectReference waypoint = myCgf->simObjectManager()->lookup(DtUUID("Patrol Point"));

         if (!obj.isValid())
         {
            DtWarn << "Could not find object named " << parameters << std::endl;
            return true;
         }
         else if (!waypoint.isValid())
         {
            DtWarn << "Waypoint 1 does not exist.  Please create a waypoint called Patrol Point as this example requires a waypoint to move to.";
            return true;
         }
         else
         {
            DtVrfSimulatedSimObjectFacade vrfSimulatedSimObjectFacade(obj);
            // Look up the state data for runways in the state data parameters.  If it does not exist then this is not an airbase
            const DtRwPropertiesMap* runways = 
               vrfSimulatedSimObjectFacade.stateProperties().findProperty<DtRwPropertiesMap>("Runways");

            if (!runways)
            {
               DtWarn << parameters << " is not an airbase.\n";
               return true;
            }

            // Create the global plan.  This will be used to add the tasks to for launching the mission from the airbase and
            // then assigning that launched mission to move to the waypoint.
            DtPlanBuilder globalPlanBuilder(DtUUID("Example Movement Mission Plan"));

            // Assign the mission to the airbase
            DtScriptedTaskTask createFlightTask;

            createFlightTask.setScriptId("launch_flight_mission");   // Script id to launch a mission flight

            createFlightTask.setValue("Airbase", obj->uuid());

            // Assign loadout
            createFlightTask.setValue("Loadout", "Intercept");

            // Assign the name to the aircraft unit
            createFlightTask.setValue("CallSign", "MovementExample");

            // Assign the aircraft unit type to create
            createFlightTask.setValue("AircraftUnitType", DtEntityType(11, 2, 225, 35, 1, 3, 3));

            // Wait for the launch to finish the task
            createFlightTask.setValue("WaitForLaunch", true);

            createFlightTask.setDateTime("LaunchTime", 0.);

            globalPlanBuilder.addStatement(createFlightTask);

            DtMoveToTask moveToWaypointTask;
            moveToWaypointTask.setControlPoint(waypoint->uuid());

            globalPlanBuilder.addTaskCommand(moveToWaypointTask, DtUUID("MovementExample", 0, true));

            myCgf->globalPlanManager()->addOrUpdatePlan(globalPlanBuilder.planCopy());

            DtWarn << "New movement mission plan assigned to " << obj->markingText() << std::endl;
         }

         return true;
      }

   protected:
      DtCgf* myCgf;
   };

   // For this to work, you will need to click onto the AB  1 and add more aircraft to it to support the creation of an F16-C air aggregate
   class DtStartEscortMissionCommand : public DtConsoleCommand
   {
   public:
      DtStartEscortMissionCommand(DtCgf* c) : myCgf(c) {};
      virtual ~DtStartEscortMissionCommand() override {};

      virtual void createAttackPlan(const DtSimObject* obj, const DtSimObject* waypoint)
      {
         // Create the global plan.  This will be used to add the tasks to for launching the mission from the airbase and
         // then assigning that launched mission to move to escort the attack mission
         DtPlanBuilder globalPlanBuilder(DtUUID("Example Attack Mission Plan"));

         // Add a wait task to have tha attack be created a little after the escort
         DtWaitDurationTask waitDuration;
         waitDuration.setSecondsToWait(5);

         globalPlanBuilder.addStatement(waitDuration);

         // Assign the mission to the airbase
         DtScriptedTaskTask createFlightTask;

         createFlightTask.setScriptId("launch_flight_mission");   // Script id to launch a mission flight

         // The name of the base to launch the mission
         createFlightTask.setValue("Airbase", obj->uuid());

         // Assign the necessary variables to create the launch script
         // Assign loadout
         createFlightTask.setValue("Loadout", "Attack");

         // Assign the name to the aircraft unit
         createFlightTask.setValue("CallSign", "AttackExample");

         // Assign the aircraft unit type to create
         createFlightTask.setValue("AircraftUnitType", DtEntityType(11, 2, 225, 35, 1, 3, 3));

         // Wait for the launch to finish the task
         createFlightTask.setValue("WaitForLaunch", true);

         createFlightTask.setDateTime("LaunchTime", 0.);

         globalPlanBuilder.addStatement(createFlightTask);

         DtIssuePlanCommand issuePlan;
         DtPlanBuilder attackPlan;

         // Set the rule to hold fire
         DtSetEngagementRulesRequest setEngagementRules;
         setEngagementRules.setEngagementRules("hold-fire");

         attackPlan.addStatement(setEngagementRules);

         // Turn on IFF to avoid friendly fire
         DtSetIffRequest setIff;
         setIff.setModeSTcasI(true);
         setIff.setModeSOn(true);
         setIff.setMode5LevelSelection(true);

         attackPlan.addStatement(setIff);

         const DtLocalObject* targetPoint = myCgf->localObjectManager()->lookup(DtUUID("Attack Point"));

         // Attack target point does not exist, so create it
         if (!targetPoint)
         {
            DtSimObjectReference ab2 = myCgf->simObjectManager()->lookup(DtUUID("AB  2"));

            if (ab2)
            {
               // First create the new pseudo aggregrate to carry out this plan
               DtEntityType target(16, 0, 0, 2, 0, 0, 0);
               DtVector initialPosition(ab2->worldPosition());

               // Create the aggregate above the air base
               targetPoint = myCgf->localObjectManager()->createAndInitVrfObject(
                  target,
                  true, 
                  "Attack Point",
                  DtString::nullString(), 
                  obj->forceType(), 
                  initialPosition,
                  0, 
                  false, 
                  false, 
                  DtAppearance::nullAppearance(),
                  "local-vrf-object");
            }
         }

         // Add a task to wait for our escort to escort us
         DtScriptedTaskTask waitForEscort;

         waitForEscort.setScriptId("wait_for_escort");

         // Where to meet
         waitForEscort.setValue("WaitLocation", waypoint->uuid());

         attackPlan.addStatement(waitForEscort);

         DtSimObjectReference attackRoute = myCgf->simObjectManager()->lookup(DtUUID("Attack Route"));
         if (targetPoint && attackRoute.isValid())
         {
            // And now, land back at the originating air base
            DtScriptedTaskTask attackAirbase;

            attackAirbase.setScriptId("Ground_Attack");

            // Where to meet
            attackAirbase.setValue("targetPoint", targetPoint->uuid());
            attackAirbase.setValue("ingressRoute", attackRoute->uuid());
            attackAirbase.setValue("egressRoute", attackRoute->uuid());

            attackPlan.addStatement(attackAirbase);
         }

         // And now, land back at the originating air base
         DtScriptedTaskTask landAtAirbase;

         landAtAirbase.setScriptId("land_at_air_base");

         // Where to meet
         landAtAirbase.setValue("airBase", obj->uuid());

         attackPlan.addStatement(landAtAirbase);

         issuePlan.init();
         issuePlan.setIssueTo(DtUUID("AttackExample", 0, true));
         issuePlan.setPlan(attackPlan);

         globalPlanBuilder.addStatement(issuePlan);

         myCgf->globalPlanManager()->addOrUpdatePlan(globalPlanBuilder.planCopy());
      }

      virtual void createResourcePlan(const DtSimObject* obj)
      {
         // If this plan exists, then, don't create it again
         if (myCgf->localObjectManager()->lookup(DtUUID("Example Resource Assignment Plan")))
         {
            return;
         }

         // Create the global plan.  This will be used to add the sets for setting up the resources for the airbase
         DtPlanBuilder globalPlanBuilder(DtUUID("Example Resource Assignment Plan"));

         // Assign the mission to the airbase
         DtScriptedTaskSet setAssignAircraft;

         setAssignAircraft.setScriptId("set_assign_aircraft");

         std::map<DtString, int> aircraftMap;
         aircraftMap["F-16C"] = 12;

         setAssignAircraft.setValue("aircraft", aircraftMap);
         setAssignAircraft.setValue("setAsCurrent", false);

         globalPlanBuilder.addSetDataCommand(setAssignAircraft, obj->uuid());

         DtSetStateProperties setPersonnel;
         DtRwProperties modProps("modified-state-properties");

         modProps.addProperty(new DtRwPropertyInt("Initial-Ground-Crew-Size", 100));
         modProps.addProperty(new DtRwPropertyInt("Initial-Air-Crew-Size", 100));

         setPersonnel.init();
         setPersonnel.setStateProperties(modProps);
         setPersonnel.setProperties("Initial-Ground-Crew-Size;Initial-Air-Crew-Size"); // Hint to the front-end so it know what dialog to bring up to edit properties
         setPersonnel.setReplace(true);
         setPersonnel.setValuesArePercentages(false);

         globalPlanBuilder.addSetDataCommand(setPersonnel, obj->uuid());

         DtSetStateProperties setSupplies;

         modProps.clearVariables();

         modProps.addProperty(new DtRwPropertyInt("Munitions", 1000));
         modProps.addProperty(new DtRwPropertyReal("Aviation-Fuel", 1000000));

         setSupplies.init();
         setSupplies.setStateProperties(modProps);
         setSupplies.setProperties("Munitions;Aviation-Fuel"); // Hint to the front-end so it know what dialog to bring up to edit properties
         setSupplies.setReplace(true);
         setSupplies.setValuesArePercentages(false);

         globalPlanBuilder.addSetDataCommand(setSupplies, obj->uuid());

         DtSetStateProperties setFacilities;
         modProps.clearVariables();

         modProps.addProperty(new DtRwPropertyBoolean("Has-Night-Support", true));
         modProps.addProperty(new DtRwPropertyInt("ORP-Aircraft-Capacity",100));
         modProps.addProperty(new DtRwPropertyInt("Apron-Aircraft-Capacity",100));
         modProps.addProperty(new DtRwPropertyInt("Repair-Hangar-Aircraft-Capacity", 10));
         modProps.addProperty(new DtRwPropertyReal("Aviation-Fuel-Capacity", 10000000));
         modProps.addProperty(new DtRwPropertyInt("Munition-Storage-Capacity", 10000));
         modProps.addProperty(new DtRwPropertyInt("Barracks-Capacity", 300));

         DtRwPropertiesMap* runways = new DtRwPropertiesMap("Runways");

         runways->setKeyType(DtRwStringType); // The map key is a string

         // The prototype is a structure that has the Length, Width and Direction
         DtRwPropertiesStructure prototype("Runway-Item");

         prototype.addProperty(new DtRwPropertyReal("Length"));
         prototype.addProperty(new DtRwPropertyReal("Width"));
         prototype.addProperty(new DtRwPropertyReal("Main-Direction"));
         prototype.addProperty(new DtRwPropertyReal("Usable-Length"));

         // Set the prototype into the map -- it will be cloned
         runways->setPrototype(&prototype);

         // Now, create a map of the key of the runway name and the prototype value and assign it
         std::map<DtRwString, DtRwPropertiesStructure> runwaysToAssign;

         // Set the values into the prototype so that it can be reused for setting up the runways map
         prototype.findAndSetPropertyValue("Length", 1000.0);
         prototype.findAndSetPropertyValue("Usable-Length", 1000.0);
         prototype.findAndSetPropertyValue("Width", 55.0);
         prototype.findAndSetPropertyValue("Main-Direction", 45.0);

         DtRwString key("Runway");

         key = "Test Runway";
         runwaysToAssign[key] = prototype;

         setMapProperty(runways, runwaysToAssign);
         addProperty(modProps, runways);

         setFacilities.init();
         setFacilities.setStateProperties(modProps);
         setFacilities.setProperties("Runways;Has-Night-Support;ORP-Aircraft-Capacity;Apron-Aircraft-Capacity;Repair-Hangar-Aircraft-Capacity;Aviation-Fuel-Capacity;Munition-Storage-Capacity;Barracks-Capacity"); // Hint to the front-end so it know what dialog to bring up to edit properties
         setFacilities.setReplace(true);
         setFacilities.setValuesArePercentages(false);

         globalPlanBuilder.addSetDataCommand(setFacilities, obj->uuid());

         myCgf->globalPlanManager()->addOrUpdatePlan(globalPlanBuilder.planCopy());
      }

      virtual void createEscortPlan(const DtSimObject* obj, const DtSimObject* waypoint)
      {
         // Create the global plan.  This will be used to add the tasks to for launching the mission from the airbase and
         // then assigning that launched mission to move to escort the attack mission
         DtPlanBuilder globalPlanBuilder(DtUUID("Example Escort Mission Plan"));

         // Assign the mission to the airbase
         DtScriptedTaskTask createFlightTask;

         createFlightTask.setScriptId("launch_flight_mission");   // Script id to launch a mission flight

         // The name of the base to launch the mission
         createFlightTask.setValue("Airbase",  obj->uuid());

         // Assign the necessary variables to create the launch script
         // Assign loadout
         createFlightTask.setValue("Loadout",  "Intercept");

         // Assign the name to the aircraft unit
         createFlightTask.setValue("CallSign",  "EscortExample");

         // Assign the aircraft unit type to create
         createFlightTask.setValue("AircraftUnitType",  DtEntityType(11, 2, 225, 35, 1, 9, 10));

         // Wait for the launch to finish the task
         createFlightTask.setValue("WaitForLaunch",  true);

         createFlightTask.setDateTime("LaunchTime",  0.);

         globalPlanBuilder.addStatement(createFlightTask);

         DtIssuePlanCommand issuePlan;
         DtPlanBuilder escortPlan;

         // Set the rule to only fire when an enemy is in an engagement zone
         DtSetEngagementRulesRequest setEngagementRules;
         setEngagementRules.setEngagementRules("fire-when-in-engagement-zone");

         escortPlan.addStatement(setEngagementRules);

         // Set the engagement zone that the escort will be looking at

         // Also check to see if the engagement zone is there.  If not, do not add this statement
         DtSimObjectReference zone = myCgf->simObjectManager()->lookup(DtUUID("Blue JEZ"));

         if (zone.isValid())
         {
            DtScriptedTaskSet setEngagementZone;

            setEngagementZone.setScriptId("set-engagement-zones");   // Script id to launch a mission flight

            // The name of the base to launch the mission
            std::vector<DtUUID> zones;

            zones.push_back(zone->uuid());
            setEngagementZone.setValue("engagementZones", zones);

            escortPlan.addStatement(setEngagementZone);
         }

         // Turn on IFF to avoid friendly fire
         DtSetIffRequest setIff;
         setIff.setModeSTcasI(true);
         setIff.setModeSOn(true);
         setIff.setMode5LevelSelection(true);

         escortPlan.addStatement(setIff);

         // Wait until our escort is created to escort them
         DtCeEntityCreated entityCreated;
         entityCreated.setEntityName("AttackExample");

         escortPlan.addWaitUntilCondition(entityCreated);

         // Set up the escort task to escort the to be created attack flight
         DtScriptedTaskTask escortFlightTask;

         escortFlightTask.setScriptId("escort_air_unit");   // Script id to launch a mission flight

         // Where to meet
         escortFlightTask.setValue("LocationToMeet", waypoint->uuid());
         escortFlightTask.setValue("UnitToEscort", DtUUID("AttackExample", 0, true));

         escortPlan.addStatement(escortFlightTask);

         // And now, land back at the originating air base
         DtScriptedTaskTask landAtAirbase;

         landAtAirbase.setScriptId("land_at_air_base");

         // Where to meet
         landAtAirbase.setValue("airBase", obj->uuid());
         escortPlan.addStatement(landAtAirbase);

         issuePlan.init();
         issuePlan.setIssueTo(DtUUID("EscortExample", 0, true));
         issuePlan.setPlan(escortPlan);

         globalPlanBuilder.addStatement(issuePlan);
         myCgf->globalPlanManager()->addOrUpdatePlan(globalPlanBuilder.planCopy());
      }

      virtual bool execute(const DtString& parameters) override
      {
         DtSimObjectReference obj = myCgf->simObjectManager()->lookup(DtUUID(parameters));
         DtSimObjectReference waypoint = myCgf->simObjectManager()->lookup(DtUUID("Patrol Point"));

         if (!obj.isValid())
         {
            DtWarn << "Could not find object named " << parameters << std::endl;
            return true;
         }
         else if (!waypoint.isValid())
         {
            DtWarn << "Waypoint 1 does not exist.  Please create a waypoint called Patrol Point as this example requires a waypoint to move to.";
            return true;
         }
         else
         {
            // Look up the state data for runways in the state data parameters.  If it does not exist then this is not an airbase
            DtVrfSimulatedSimObjectFacade vrfSimulatedSimObjectFacade(obj);
            const DtRwPropertiesMap* runways = 
               vrfSimulatedSimObjectFacade.stateProperties().findProperty<DtRwPropertiesMap>("Runways");

            if (!runways)
            {
               DtWarn << parameters << " is not an airbase.\n";
               return true;
            }

            createResourcePlan(obj);
            createAttackPlan(obj, waypoint);
            createEscortPlan(obj, waypoint);

            DtWarn << "New escort mission plans assigned to " << obj->markingText() << std::endl;
         }

         return true;
      }

   protected:
      DtCgf* myCgf;
   };

   class DtPrintAirbaseCommand : public DtConsoleCommand
   {
   public:
      DtPrintAirbaseCommand(DtCgf* c) : myCgf(c) {};
      virtual ~DtPrintAirbaseCommand() override {};

      virtual bool execute(const DtString& parameters) override
      {
         DtSimObjectReference obj = myCgf->simObjectManager()->lookup(DtUUID(parameters));

         if (!obj.isValid())
         {
            DtWarn << "Could not find object named " << parameters << std::endl;
            return true;
         }
         else
         {
            // Look up the state data for runways in the state data parameters.  If it does not exist then this is not an airbase
            DtVrfSimulatedSimObjectFacade vrfSimulatedSimObjectFacade(obj);
            const DtRwPropertiesMap* runways = 
               vrfSimulatedSimObjectFacade.stateProperties().findProperty<DtRwPropertiesMap>("Runways");

            if (!runways)
            {
               DtWarn << parameters << " is not an airbase.\n";
               return true;
            }

            // Each runway item in the map is a structure that contains the following items:
            // (DtRwStructure Runway-Item
            //    (DtRwReal Length)
            //    (DtRwReal Width)
            //    (DtRwReal Main-Direction) ; heading in degrees
            // )
            //
            // To read each item you must iterate over all the reader/writer items in the map, dynamically casting them to a DtRwPropertiesStructure.
            // Then, you can find each name within that structure to print out the actual value
            DtWarn << "Runways:\n";

            auto iter = runways->begin();
            auto end = runways->end();
            while (iter != end)
            {
               const DtRwPropertiesStructure* str = static_cast<const DtRwPropertiesStructure*>(iter.property());

               if (str)
               {
                  boost::optional<double> length = str->findPropertyValue<double>("Length");
                  boost::optional<double> width = str->findPropertyValue<double>("Width");
                  boost::optional<double> mainDirection = str->findPropertyValue<double>("Main-Direction");

                  DtWarn << "   " << str->name().c_str() << " is " << *length << " meters in length, " << *width << " meters in width and a direction of " << *mainDirection << " degrees.\n";
               }

               ++iter;
            }
         }

         return true;
      }

   protected:
      DtCgf* myCgf;
   };

   class DtPrintStatusCommand : public DtConsoleCommand
   {
   public:
      DtPrintStatusCommand(DtCgf* c) : myCgf(c) {};
      virtual ~DtPrintStatusCommand() override {};

      virtual void printFuelIfExists(const DtSimObject* obj, const DtString& val)
      {
         DtVrfSimulatedSimObjectFacade vrfSimulatedSimObjectFacade(obj);
         const DtRwPropertiesStructure* baseStructure = 
            vrfSimulatedSimObjectFacade.parameterProperties().findProperty<DtRwPropertiesStructure>("Base-" + val);
         const DtRwPropertiesStructure* currentStructure = 
            vrfSimulatedSimObjectFacade.stateProperties().findProperty<DtRwPropertiesStructure>(val);

         if (baseStructure && currentStructure)
         {
            boost::optional<double> amount = baseStructure->findPropertyValue<double>("Amount");

            if (amount && (*amount != 0))
            {
               const DtRwReal* current = findProperty<DtRwReal>(*currentStructure, "Amount");

               if (current)
               {
                  DtString title = DtReplaceAllSubstrings(val, "-", " ");

                  DtWarn << "   " << title << ": " << *current << "/" << *amount << std::endl;
               }
            }
         }
         else
         {
            DtWarn << "   No " << val << "\n";
         }
      }

      virtual void printAmmunition(const DtSimObject* obj)
      {
         DtVrfSimulatedSimObjectFacade vrfSimulatedSimObjectFacade(obj);
         const DtRwPropertiesMap* ammoRw = 
            vrfSimulatedSimObjectFacade.stateProperties().findProperty<DtRwPropertiesMap>("Ammunition");

         if(ammoRw)
         {
            auto iter = ammoRw->begin();
            auto end = ammoRw->end();
            for (; iter != end; ++iter)
            {
               boost::optional<int> count = iter->findPropertyValue<int>("Count");
               boost::optional<DtString> type = iter->findPropertyValue<DtString>("Type");

               if (count && type)
               {
                  DtWarn << "   Ammunition: " << *type << " has " << *count << " units remaining.\n";
               }
            }
         }
         else
         {
            DtWarn << "   No Ammunition\n";
         }
      }

      virtual void printPrimaryEquipment(const DtSimObject* obj)
      {
         DtVrfSimulatedSimObjectFacade vrfSimulatedSimObjectFacade(obj);
         const DtRwPropertiesStructure* currentStructure = findProperty<DtRwPropertiesStructure>(vrfSimulatedSimObjectFacade.stateProperties(), "Primary-Equipment");

         // Base-Primary-Equipment is a parameter property because it does not change at run time.
         const DtRwPropertiesStructure* baseStructure = findProperty<DtRwPropertiesStructure>(obj->parameterProperties(), "Base-Primary-Equipment");

         if (currentStructure && baseStructure)
         {
            boost::optional<DtString> type = currentStructure->findPropertyValue<DtString>("Type");
            boost::optional<int> count = currentStructure->findPropertyValue<int>("Count");
            boost::optional<int> baseCount = currentStructure->findPropertyValue<int>("Count");

            if (type && count && baseCount && type->length())
            {
               DtWarn << "   Primary Equipment: " << *type << " has " << *count << " units remaining out of " << *baseCount << "\n";
            }
         }
         else
         {
            DtWarn << "   No Primary Equipment\n";
         }
      }

      virtual void printEquipment(const DtSimObject* obj)
      {
         DtVrfSimulatedSimObjectFacade vrfSimulatedSimObjectFacade(obj);
         const DtRwPropertiesMap* equipment = 
            vrfSimulatedSimObjectFacade.stateProperties().findProperty<DtRwPropertiesMap>("Equipment");

         // Base-Equipment is a parameter property because it does not change at run time.
         const DtRwPropertiesMap* baseEquipment = 
            obj->parameterProperties().findProperty<DtRwPropertiesMap>("Base-Equipment");

         // Base-Loadout-Equipment, on the other hand, is a state property because it does change at run time when the loadout changes.
         const DtRwPropertiesMap* baseLoadoutEquipment = 
            vrfSimulatedSimObjectFacade.stateProperties().findProperty<DtRwPropertiesMap>("Base-Loadout-Equipment");

         if (equipment && baseEquipment && baseLoadoutEquipment)
         {
            DtWarn << "   Equipment: " << std::endl;
            auto iter = equipment->begin();
            auto end = equipment->end();
            while (iter != end)
            {
               const DtRwPropertiesStructure* currEquip =
                  static_cast<const DtRwPropertiesStructure*>(iter.property());

               boost::optional<int> currCount = currEquip->findPropertyValue<int>("Count");
               boost::optional<int> baseCount;
               boost::optional<int> baseLoadoutCount;

               if (currCount)
               {
                  // See if this equipment type is part of the base equipment
                  const DtRwPropertiesStructure* baseEquip = static_cast<const DtRwPropertiesStructure*>(
                     baseEquipment->findItem(currEquip->name().c_str()));
                  if (baseEquip)
                  {
                     baseCount = baseEquip->findPropertyValue<int>("Count");
                  }

                  // See if this equipment type is part of the base loadout equipment
                  const DtRwPropertiesStructure* baseLoadoutEquip = static_cast<const DtRwPropertiesStructure*>(
                     baseLoadoutEquipment->findItem(currEquip->name().c_str()));
                  if (baseLoadoutEquip)
                  {
                     baseLoadoutCount = baseLoadoutEquip->findPropertyValue<int>("Count");
                  }

                  // Add up base count totals from base and loadout
                  int totalBaseCount = 0;
                  if (baseCount)
                  {
                     totalBaseCount += *baseCount;
                  }
                  if (baseLoadoutCount)
                  {
                     totalBaseCount += *baseLoadoutCount;
                  }

                  DtWarn << "      " << currEquip->name() << ": " << *currCount << " out of " << totalBaseCount << std::endl;
               }

               ++iter;
            }
         }
         else
         {
            DtWarn << "   No Equipment\n";
         }
      }

      virtual void printEngagementHistory(const DtSimObject* obj)
      {
         DtVrfSimulatedSimObjectFacade vrfSimulatedSimObjectFacade(obj);
         const DtRwPropertiesMap* engagementHistory = findProperty<DtRwPropertiesMap>(vrfSimulatedSimObjectFacade.stateProperties(), "Engagement-History");
         if (engagementHistory)
         {
            std::vector<DtReaderWriterRegistryData *>::const_iterator iter = engagementHistory->registry().registryData().begin();
            std::vector<DtReaderWriterRegistryData *>::const_iterator end = engagementHistory->registry().registryData().end();

            DtWarn << "   Engagement History: " << std::endl;

            while (iter != end)
            {
               const DtRwPropertiesStructure* engagementEvent =
                  static_cast<const DtRwPropertiesStructure*>((*iter)->readerWriter());

               boost::optional<bool> isAttack = engagementEvent->findPropertyValue<bool>("IsAttack");
               boost::optional<DtString> enemy = engagementEvent->findPropertyValue<DtString>("Enemy");
               boost::optional<DtString> weaponType = engagementEvent->findPropertyValue<DtString>("Type");
               boost::optional<double> hitFactor = engagementEvent->findPropertyValue<double>("HitFactor");
               boost::optional<double> defenseFactor = engagementEvent->findPropertyValue<double>("DefenseFactor");
               boost::optional<double> timeStarted = engagementEvent->findPropertyValue<double>("TimeStarted");
               boost::optional<double> timeCompleted = engagementEvent->findPropertyValue<double>("TimeComplete");
               boost::optional<int> damageTaken = engagementEvent->findPropertyValue<int>("DamageTaken");
               boost::optional<double> pHit = engagementEvent->findPropertyValue<double>("ProbabilityHit");
               boost::optional<double> draw = engagementEvent->findPropertyValue<double>("RandomDraw");
               if (enemy && weaponType && isAttack && hitFactor && defenseFactor && timeStarted &&
                  timeCompleted && damageTaken && pHit && draw)
               {
                  DtSimObjectReference enemyObj = myCgf->simObjectManager()->lookup(DtUUID(*enemy));
                  DtString enemyName("Unknown");
                  if (enemyObj.isValid())
                  {
                     enemyName = enemyObj->markingText();
                  }

                  if (*isAttack)
                  {
                     DtWarn << "      Fired at " << enemyName << " with " << *weaponType << "." << std::endl;
                     DtWarn << "         Hit Factor: " << *hitFactor << std::endl;
                  }
                  else
                  {
                     DtWarn << "      Shot at by " << enemyName << " with " << *weaponType << ". ";

                     // Check if this event hit us and caused damage
                     if (*damageTaken > 0)
                     {
                        DtWarn << "Hit! Took " << *damageTaken << " damage." << std::endl;
                     }
                     else
                     {
                        DtWarn << "Miss!" << std::endl;
                     }

                     DtWarn << "         Hit Factor: " << *hitFactor << ", Defense Factor: "
                        << *defenseFactor << ", P(hit): " << *pHit << ", Draw: " << *draw
                        << std::endl;
                  }

                  DtWarn << "         Time: " << *timeStarted << " to " << *timeCompleted << std::endl;

                  const DtRwPropertiesList* details = engagementEvent->findProperty<DtRwPropertiesList>("Details");
                  if (details)
                  {
                     DtWarn << "         Details: " << std::endl;
                     DtPropertiesConstIterator iter = details->begin();
                     DtPropertiesConstIterator end = details->end();
                     for (; iter != end; ++iter)
                     {
                        boost::optional<DtString> detailText = iter->propertyValue<DtString>();
                        if (detailText)
                        {
                           DtWarn << "            " << *detailText << std::endl;
                        }
                     }
                  }
               }

               ++iter;
            }
         }
         else
         {
            DtWarn << "   No Engagement History\n";
         }
      }

      virtual bool execute(const DtString& parameters) override
      {
         if (parameters == "ALL")
         {
            DtManagedObjectList list(myCgf->simulationServices());
            DtManagedObjectList::const_iterator iter = list.begin();
            DtManagedObjectList::const_iterator end = list.end();

            while (iter != end)
            {
               // Only print out objects that have health
               DtVrfSimulatedSimObjectFacade vrfSimulatedSimObjectFacade(*iter);
               boost::optional<int> health = 
                  vrfSimulatedSimObjectFacade.stateProperties().findPropertyValue<int>("Health");

               if (health)
               {
                  printStatus(*iter);
                  DtWarn << std::endl;
               }

               ++iter;
            }
         }
         else
         {
            DtSimObjectReference obj = myCgf->simObjectManager()->lookup(DtUUID(parameters));
            if (!obj.isValid())
            {
               DtWarn << "Could not find object named " << parameters << std::endl;
               return true;
            }
            else
            {
               printStatus(obj);
            }
         }

         return true;
      }

      virtual void printStatus(const DtSimObject* obj)
      {
         DtWarn << "Current status for " << obj->markingText() << std::endl;

         // Look up the state data for runways in the state data parameters.  If it does not exist then this is not an airbase
         DtVrfSimulatedSimObjectFacade vrfSimulatedSimObjectFacade(obj);
         boost::optional<int> health = 
            vrfSimulatedSimObjectFacade.stateProperties().findPropertyValue<int>("Health");
         boost::optional<int> baseHealth = 
            vrfSimulatedSimObjectFacade.parameterProperties().findPropertyValue<int>("Base-Health");

         if (health && baseHealth)
         {
            DtWarn << "   Health: " << *health << "/" << *baseHealth << std::endl;
         }

         printFuelIfExists(obj, "Aviation-Fuel");
         printFuelIfExists(obj, "Diesel-Fuel");

         printPrimaryEquipment(obj);
         printEquipment(obj);
         printAmmunition(obj);
         printEngagementHistory(obj);
      }

   protected:
      DtCgf* myCgf;
   };

   class DtHelpDisplayCommand : public DtConsoleCommand
   {
   public:
      virtual ~DtHelpDisplayCommand() override {};

      virtual bool execute(const DtString& parameters) override
      {
         DtWarn << "print-airbase <name> - prints airbase specific data.  If the object is not an airbase a warning will be issued.\n";
         DtWarn << "start-movement-mission <name> - Starts a move to waypoint mission using F-16C aircraft at the supplied air base.  If the object is not an airbase a warning will be issued.\n";
         DtWarn << "start-escort-mission <name> - Starts an escort mission using F-16C aircraft at the supplied air base.  If the object is not an airbase a warning will be issued.  You will need to add more F16 aircraft to the airbase in order to use this feature.\n";
         DtWarn << "print-status <name | ALL> - prints various status (health, fuel, equipment, weapon stores).  If the object is not an airbase a warning will be issued.  Use ALL to print out all aggregates.\n";
         DtWarn << "help-display - prints this list.\n";
         return true;
      }
   };

   // This command provides an example of how to set scriptedTask parameters that are not available
   // in setValue functions. It also shows how to send a single task to an entity.
   // The task parameters are not complete, so the task will probably not execute correctly.
   // Note-- to enable this command, add the following line to DtPostInitializeVrfPlugin:
   // DtConsoleCommandManager::globalConsoleCommandManager()->addCommand("dt-surface-attack", new
   // DtSurfaceAttackCommand(cgf));
   // Also add a static variable to hold the command so it can be deleted in DtUnloadVrfPlugin:
   // static DtSurfaceAttackCommand* theSurfaceAttackCommand = 0;
   // And in DtUnloadVrfPlugin:
   // DtConsoleCommandManager::globalConsoleCommandManager()->removeCommand(theSurfaceAttackCommand);
   class DtSurfaceAttackCommand : public DtConsoleCommand
   {
   public:
      DtSurfaceAttackCommand(DtCgf* c)
         : myCgf(c) {};
      virtual ~DtSurfaceAttackCommand() {};

      virtual DtSimTask* createAttackTask(const DtSimObject* obj, const DtSimObject* waypoint)
      {
         DtScriptedTaskTask* attackTask = new DtScriptedTaskTask();

         attackTask->setScriptId("execute_surface_attack");

         // Most of the parameters of the execute_surface_attack script are set using the setValue function.
         attackTask->setValue("initialPointEnabled", false);
         // ... etc.

         // The weapons parameter is a table, ie array of strings. [As of VRF 5.1.1] there is no setValue
         // function that will handle a std::vector<std::string>, so we have to use the more primitive
         // addVariable function with the scriptedTask variables and variableDataTypes.
         // The parameter type for this parameter is "strings".
         DtRwNLengthStringVector* weaponsVec = new DtRwNLengthStringVector("weapons");
         weaponsVec->setSize(1);
         (*weaponsVec)[0] = "gunA";
         attackTask->variables().addVariable(weaponsVec);
         attackTask->variableDataTypes().addVariable(new DtRwString("weapons", "strings"));

         // Similarly, targetTypes and other parameters take an array of integers.
         // The parameter type is "integers".
         DtRwIntegerList* laserCodes = new DtRwIntegerList("laserCodes");
         laserCodes->addInteger(new DtRwInt("item", 42));
         attackTask->variables().addVariable(laserCodes);
         attackTask->variableDataTypes().addVariable(new DtRwString("laserCodes", "integers"));

         // A qualified heading is a special structure with isMagnetic and heading fields.
         DtRwHeading* egressHeading = new DtRwHeading("egressHeading");
         egressHeading->setHeading(1.57); // East
         egressHeading->setIsMagnetic(true);
         attackTask->variables().addVariable(egressHeading);

         DtRwString* egressHeadingDataType = new DtRwString("egressHeading");
         *egressHeadingDataType = DtScriptedTaskMagneticNorthHeadingVariable;
         attackTask->variableDataTypes().addVariable(egressHeadingDataType);

         return attackTask;
      }

      virtual bool execute(const DtString& parameters)
      {
         DtSimObjectReference obj = myCgf->simObjectManager()->lookup(DtUUID(parameters));
         DtSimObjectReference waypoint = myCgf->simObjectManager()->lookup(DtUUID("Waypoint 1"));

         if (!obj.isValid())
         {
            DtWarn << "Could not find object named " << parameters << std::endl;
            return true;
         }
         else if (!waypoint.isValid())
         {
            DtWarn << "Waypoint 1 does not exist.";
            return true;
         }

         DtSimTask* attackTask = createAttackTask(obj, waypoint);
         // To send a single task to an entity, wrap it in a DtTaskMessage and deliver it
         // using the internal communication manager accessed through the simulation services.
         DtTaskMessage taskMessage;
         taskMessage.setTask(attackTask);
         taskMessage.setReceiver(obj->uuid());
         myCgf->simulationServices()->simInternalCommunicationManager()->deliverMessage(
            dynamic_cast<DtVrfObjectMessage*>(&taskMessage));
         delete taskMessage.task();
         return true;
      }

   protected:
      DtCgf* myCgf;
   };

   static DtHelpDisplayCommand* theHelpDisplayCommand = 0;
   static DtPrintAirbaseCommand* thePrintAirbaseCommand = 0;
   static DtPrintStatusCommand* thePrintStatusCommand = 0;
   static DtStartMovementMissionCommand* theStartMovementMissionCommand = 0;
   static DtStartEscortMissionCommand* theStartEscortMissionCommand = 0;

   DT_VRF_DLL_PLUGIN bool DtInitializeVrfPlugin(DtCgf* cgf)
   {
      return true;
   }

   DT_VRF_DLL_PLUGIN void DtUnloadVrfPlugin(DtCgf* cgf)
   {
      // Since the command console manager is cleaned up, and the console manager takes ownership of
      // the memory, need to remove the console command else it will crash on exit during cleanup of DtCgf
      DtConsoleCommandManager::globalConsoleCommandManager()->removeCommand(theHelpDisplayCommand);
      delete theHelpDisplayCommand;
      theHelpDisplayCommand = nullptr;

      DtConsoleCommandManager::globalConsoleCommandManager()->removeCommand(thePrintAirbaseCommand);
      delete thePrintAirbaseCommand;
      thePrintAirbaseCommand = nullptr;

      DtConsoleCommandManager::globalConsoleCommandManager()->removeCommand(thePrintStatusCommand);
      delete thePrintStatusCommand;
      thePrintStatusCommand = nullptr;

      DtConsoleCommandManager::globalConsoleCommandManager()->removeCommand(theStartMovementMissionCommand);
      delete theStartMovementMissionCommand;
      theStartMovementMissionCommand = nullptr;

      DtConsoleCommandManager::globalConsoleCommandManager()->removeCommand(theStartEscortMissionCommand);
      delete theStartEscortMissionCommand;
      theStartEscortMissionCommand = nullptr;
   }

   DT_VRF_DLL_PLUGIN void DtPostInitializeVrfPlugin(DtCgf* cgf)
   {
      theHelpDisplayCommand = new DtHelpDisplayCommand;
      thePrintAirbaseCommand = new DtPrintAirbaseCommand(cgf);
      thePrintStatusCommand = new DtPrintStatusCommand(cgf);
      theStartMovementMissionCommand = new DtStartMovementMissionCommand(cgf);
      theStartEscortMissionCommand = new DtStartEscortMissionCommand(cgf);

      DtConsoleCommandManager::globalConsoleCommandManager()->addCommand("help-display",
         theHelpDisplayCommand);
      DtConsoleCommandManager::globalConsoleCommandManager()->addCommand("print-airbase",
         thePrintAirbaseCommand);
      DtConsoleCommandManager::globalConsoleCommandManager()->addCommand("print-status",
         thePrintStatusCommand);
      DtConsoleCommandManager::globalConsoleCommandManager()->addCommand("start-movement-mission",
         theStartMovementMissionCommand);
      DtConsoleCommandManager::globalConsoleCommandManager()->addCommand("start-escort-mission",
         theStartEscortMissionCommand);
   }
}