influenceManager.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/influenceInteractionInterface.h>
#include <vrfGuiCore/vrfObjectDataState.h>

#include <vrvUtil/signalslib.h>
#include <vrvCore/DtDe.h>
#include <vrvCore/Dt2DAreaFacade.h>
#include <vrvCore/DtEntityState.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <vrfutil/rwUUID.h>
#include <boost/unordered_map.hpp>

namespace makVrv
{
   class DtSceneObject;
   class DtAttachableUpdaterAgent;
   class DtSimObjectEntry;
   class DtLineFacadeBase;
};

namespace makVrf
{
   class DtNetworkMessageInterface;
   class DtAttackLineAttachableUpdaterAgent;
   class DtVrfStateViewCollectionManager;
   class DtVrfSimBackendManager;


   class DT_DLL_VRFGUICORE DtAttackLine : public makVrv::Dt2DAreaFacade
   {
   public:
      DtAttackLine(makVrv::DtDe& de, int modelSet, makVrv::DtElementID sourceId, makVrv::DtElementID targetId,
         double wedgeSize);

      virtual ~DtAttackLine();

      virtual void setWedgeSize(double);

      DtAttackLineAttachableUpdaterAgent* updater()
      {
         return myUpdater;
      };

   protected:
      DtAttackLineAttachableUpdaterAgent* myUpdater;
      double myWedgeSize;
      makVrv::DtDe& myDe;
   };

   class DT_DLL_VRFGUICORE DtSupplyLine
   {
   public:
      DtSupplyLine(makVrv::DtDe& de, makVrv::DtElementID sourceId, makVrv::DtElementID targetId);
      virtual ~DtSupplyLine();

      virtual void setColor(float r, float g, float b, float a);
      virtual void setVisible(bool);

   protected:
      struct Supply
      {
         makVrv::DtLineFacadeBase* supplyLine;
         DtAttackLineAttachableUpdaterAgent* updater;
      };

      typedef std::map<int, Supply> SupplyLines;
      SupplyLines mySupplyLines;
      makVrv::DtDe& myDe;
   };

   class DT_DLL_VRFGUICORE DtInfluenceManager : public makVrv::DtVirtualBaseClass
   {
   public:
      DtInfluenceManager(makVrv::DtDe&);
      virtual ~DtInfluenceManager();

      static DtInfluenceManager& instance(makVrv::DtDe& de);

      virtual void registerInstance(makVrv::DtDe&, DtInfluenceManager*);

      virtual void setDisplayAttackLines(bool);
      virtual bool displayAttackLines() const;

      virtual void setDisplayAttackAnimation(bool);
      virtual bool displayAttackAnimation() const;

      virtual void setDisplaySupplyLines(bool);
      virtual bool displaySupplyLines() const;

      virtual int animationColor(int baseColor) const;

      virtual bool isAttacking(makVrv::DtElementID) const;

      virtual bool underAttack(makVrv::DtElementID) const;

      virtual void setSupplyLineColor(int r, int g, int b, int a);
      virtual void getSupplyLineColor(int& r, int& g, int& b, int& a);

      virtual void setAnimationLength(double);

      virtual std::set<int> sectorsAttacked(makVrv::DtElementID) const;

      virtual void setWedgeSize(double);
      virtual double wedgeSize() const;

      typedef std::map<int, DtAttackLine*> AttackLines;
      typedef std::map<std::string, DtInfluenceInteractionInterface> AttackTypes;

      struct AttackLineInformation
      {
         AttackLines attackLines;      
         AttackTypes attackTypes;      
      };

      struct AttackIdentifier
      {
         makVrv::DtElementID attackerId;
         makVrv::DtElementID targetId;
         std::string attackType;

         bool operator<(const AttackIdentifier& rhs) const
         {
            return (attackerId < rhs.attackerId ||
               (attackerId == rhs.attackerId && targetId < rhs.targetId) ||
               (attackerId == rhs.attackerId && targetId == rhs.targetId && attackType < rhs.attackType));
         }
      };
      
      typedef std::set<makVrv::DtElementID> Supplying;
      typedef std::map<makVrv::DtElementID, Supplying> Suppliers;
      
      typedef std::map<makVrv::DtElementID, AttackLineInformation> AttackTarget;
      typedef std::map<makVrv::DtElementID, AttackTarget> Attacks;
      typedef std::map<AttackIdentifier, double> AttackExpirations;

      virtual Attacks attackLinesFor(makVrv::DtElementID) const;

      virtual Attacks attackLinesTo(makVrv::DtElementID) const;

      virtual void clear();

      virtual void setMinimumInfluenceDuration(double);
      virtual double minimumInfluenceDuration() const;

      virtual Supplying suppliersTo(makVrv::DtElementID) const;

      virtual Supplying supplies(makVrv::DtElementID) const;

      boost::signal<void (makVrv::DtElementID, makVrv::DtElementID, std::string)> signal_attackAdded;
      boost::signal<void (makVrv::DtElementID, makVrv::DtElementID, std::string)> signal_attackRemoved;

      boost::signal<void (makVrv::DtElementID, makVrv::DtElementID)> signal_supplyAdded;
      boost::signal<void (makVrv::DtElementID, makVrv::DtElementID)> signal_supplyRemoved;

   protected:
      virtual void processInfluenceMessageCallback(DtNetworkMessageInterface* i);

      virtual void createAttackLine(DtInfluenceInteractionInterface*);

      virtual void removeAttackLine(DtInfluenceInteractionInterface*);

      virtual void createSupplyLine(DtInfluenceInteractionInterface*);
      virtual void removeSupplyLine(DtInfluenceInteractionInterface*);
      virtual void removeSupplyLine(makVrv::DtElementID supplier, makVrv::DtElementID target);
      virtual void removeSupplyLines(makVrv::DtElementID);
      virtual void onStateAdded(const makVrv::DtStateView<makVrv::DtVrlinkSimulatedBaseState>*);

      virtual void removeAttackLine(makVrv::DtElementID attacker, makVrv::DtElementID target, 
         const std::string& attackType);

      virtual void slot_extendedEntityOptionsChanged();

      virtual void slot_simObjectEntryAboutToBeRemoved(makVrv::DtSimObjectEntry& e);

      virtual void setupSceneObject(makVrv::DtElementID);

      virtual void slot_sceneObjectToBeDeleted( const makVrv::DtUniqueID& id );

      virtual void slot_removeExpiredAttacks();
      virtual void slot_removeExpiredSupplies();

      virtual void processRangeRingsUpdated(DtNetworkMessageInterface* i);
      virtual void addPendingInfluence(DtInfluenceInteractionInterface*, const DtUUID& uuid);

   protected:
      makVrv::DtDe& myDe;
      bool myDisplayAttackLines;
      bool myDisplayAttackAnimation;

      Attacks myAttacks;

      AttackExpirations myAttackExpirations;

      makVrv::DtSignalConnectionManager myConnectionManager;

      struct UnderAttackInformation
      {
         std::set<makVrv::DtElementID> underAttackBy;
      };

      typedef std::map<makVrv::DtElementID,  UnderAttackInformation> UnderAttack;
      UnderAttack myUnderAttack;

      double myAnimationStart;
      double myAnimationLength;

      DtVrfStateViewCollectionManager& myCollectionManager;
      DtVrfSimBackendManager& myBackendManager;

      typedef std::map<makVrv::DtElementID, makVrv::DtSceneObject*> SceneObjects;
      SceneObjects mySceneObjects;

      double myWedgeSize;
      double myMinimumInfluenceDuration;

      typedef std::map<makVrv::DtElementID, DtSupplyLine*> SupplyLine;
      typedef std::map<makVrv::DtElementID, SupplyLine> SupplyLines;

      SupplyLines mySupplyLines;

      Suppliers mySuppliers;
      Suppliers mySupplied;

      typedef std::map<makVrv::DtElementID, double> SupplierExpiration;
      typedef std::map<makVrv::DtElementID, SupplierExpiration> SupplyExpirations;
      SupplyExpirations mySupplyExpirations;

      float mySupplyLineColor[4];

      bool myDisplaySupplyLines;

      typedef boost::unordered_map<DtUUID, DtInfluenceInteractionInterface*> PendingInfluenceInteractions;
      PendingInfluenceInteractions myPendingInfluenceInteractions;
   };
}