SPAR/AIModule/SparAIModule/DecisionMaking/Layer2Actions/Managers/Layer2Managers.h

Go to the documentation of this file.

#pragma once
#include "../../../PerceptualState/Common.h"
#include "../../../SituationAnalysis/Layer1GameState/Layer1GameState.h"
#include "../../../SituationAnalysis/Layer2Cueing/Layer2Cueing.h"
#include "../../Layer1Reactive/FSM/Layer1FSM.h"
#include "../Layer2Actions.h"
#include "ActionsImplementation/Common.h"
#include "Locations/Common.h"
#include "Layer2ManagersBase.h"
#include "Layer2ManagersUnitData.h"
#include <BWAPI.h>
#include <boost/iterator/transform_iterator.hpp>

class Layer2Managers : public Layer2ManagersBase, public Layer2Actions<Layer2Cueing<Layer1GameState>, Layer1FSM>
{
public:
  static bool includedIn(Resources r1, Resources r2);

  Layer2Managers(Layer2Cueing<Layer1GameState>& layer2Cueing, Layer1FSM& layer1FSM);
  ~Layer2Managers();
  void onStart();
  void onFrame();
  void onEnd();
  void onSendText(std::string text);

  //void onActionExecuted(L2TacticalAction* action);
  //void onActionEnded(void* data);

  void requestResources(unsigned int priority, const ActionResources& resources, ResourcesRequestID& id);
  void releaseResources(const Resources& resources);
  void cancelResourcesRequest(ResourcesRequestID& id);
  void changeResourcesRequestPriority(ResourcesRequestID& id, unsigned int newPriority);

  // Requests //
  Resources getAvailableResources(unsigned int priority) const;
  Resources getLowestPriorityAvailableResources() const;
  Resources getHighestPriorityAvailableResources() const;
  size_t getNbAvailableBuildings(const BWAPI::UnitType buildingType, const StaticLocation& location) const;

  static Layer2Managers& getInstance()
  {
    return *s_instance;
  }

  DECLARE_EVENT(OnResourcesAllocated);

  // GUI //
  //typedef std::list<L2TacticalAction*>::const_iterator ActionIterator;
  //std::pair<ActionIterator, ActionIterator> getCurrentActions() const
  //{
  //  return std::make_pair(m_currentActions.begin(), m_currentActions.end());
  //}


#pragma region Types_Matching
  //
  // Tactical action types matching
  //
  template <class DerivedTacticalActionType>
  struct TacticalActionTypes {
  };
  template <>
  struct TacticalActionTypes<layer2::TacticalAction> {
    typedef L2TacticalAction Type;
  };
  template <>
  struct TacticalActionTypes<layer2::GroupTacticalAction> {
    typedef L2GroupTacticalAction Type;
  };
  template <>
  struct TacticalActionTypes<layer2::Attack> {
    typedef L2Attack Type;
  };
  template <>
  struct TacticalActionTypes<layer2::AttackMove> {
    typedef L2AttackMove Type;
  };
  template <>
  struct TacticalActionTypes<layer2::Build> {
    typedef L2Build Type;
  };
  template <>
  struct TacticalActionTypes<layer2::CollectMinerals> {
    typedef L2CollectMinerals Type;
  };
  template <>
  struct TacticalActionTypes<layer2::CollectGas> {
    typedef L2CollectGas Type;
  };
  template <>
  struct TacticalActionTypes<layer2::Defend> {
    typedef L2Defend Type;
  };
  template <>
  struct TacticalActionTypes<layer2::Expand> {
    typedef L2Expand Type;
  };
  template <>
  struct TacticalActionTypes<layer2::Harass> {
    typedef L2Harass Type;
  };
  template <>
  struct TacticalActionTypes<layer2::Move> {
    typedef L2Move Type;
  };
  //template <>
  //struct TacticalActionTypes<layer2::OffensiveBuild> {
  //  typedef L2OffensiveBuild Type;
  //};
  template <>
  struct TacticalActionTypes<layer2::Recruit> {
    typedef L2Recruit Type;
  };
  template <>
  struct TacticalActionTypes<layer2::UpgradeResearch> {
    typedef L2UpgradeResearch Type;
  };
  template <>
  struct TacticalActionTypes<layer2::TechResearch> {
    typedef L2TechResearch Type;
  };
  template <>
  struct TacticalActionTypes<layer2::Scout> {
    typedef L2Scout Type;
  };

  //
  // Location types matching
  //
  template <class LocationType>
  struct LocationTypes {};
  template <>
  struct LocationTypes<AirLocation> {
    typedef L2AirLocation Type;
  };
  template <>
  struct LocationTypes<BaseLocation> {
    typedef L2BaseLocation Type;
  };
  template <>
  struct LocationTypes<Chokepoint> {
    typedef L2Chokepoint Type;
  };
  template <>
  struct LocationTypes<Region> {
    typedef L2Region Type;
  };
  template <>
  struct LocationTypes<RegionLocation> {
    typedef L2RegionLocation Type;
  };
  template <>
  struct LocationTypes<Map> {
    typedef L2Map Type;
  };
#pragma endregion Types_Matching

  typedef Layer2ManagersUnitData L2UnitData;

protected:
  static Layer2Managers* s_instance;

  void reserveResource(const Resources& resources);

  Resources m_reservedResources;

  ResourcesRequestsType m_resourcesRequests;

  unsigned int m_requestCounter;

  //std::list<L2TacticalAction*> m_currentActions;

  //EVENT_HANDLER(Layer2Managers, onActionEnded) m_actionEndedEventHandler;

  struct UseResources
  {
    ResourcesRequestsType& m_resourcesRequests;
    Resources m_remainingResources;
    Layer2Managers* m_layer2;
    UseResources(ResourcesRequestsType& resourcesRequests, Resources remainingResource, Layer2Managers* layer2) 
      : m_resourcesRequests(resourcesRequests)
      , m_remainingResources(remainingResource)
      , m_layer2(layer2)
    {}
    ResourcesRequestsType::FunctionReturn operator()(ResourcesRequest& request)
    {
      SafeMultisetBase::FunctionReturn result;

      bool haveMineral = (request.actionResources.getMinerals() == 0 || request.actionResources.getMinerals() <= m_remainingResources.getMinerals()) &&
        (request.actionResources.getGas() == 0 || request.actionResources.getGas() <= m_remainingResources.getGas()) && 
        (request.actionResources.getSupply() == 0 || request.actionResources.getSupply() <= m_remainingResources.getSupply());
      m_remainingResources -= request.actionResources.getResources();

      if(request.actionResources.getBuildingLocation() == NULL)
      {
        if(haveMineral)
        {
          m_layer2->reserveResource(request.actionResources.getResources());
          request.resourcesId.eventHandler.onEvent(NULL, boost::tuples::tuple<BWAPI::Unit*>(NULL));
          request.resourcesId.isValid = false;
          result.deleteCurrent = true;
        }
      } else {
        std::pair<StaticLocation::own_unit_type_const_iterator, StaticLocation::own_unit_type_const_iterator> buildingList = 
          request.actionResources.getBuildingLocation()->getOwnUnits(request.actionResources.getBuildingType());
        StaticLocation::own_unit_const_iterator buildingIt = buildingList.first;
        bool done = false;
        while(!done && buildingIt != buildingList.second)
        {
          BWAPI::Unit* unit = (*buildingIt)->getUnit();
          Layer2ManagersUnitData& unitData = dynamic_cast<Layer2ManagersUnitData&>(Spar->getUnitManager().getUnitData(unit));
          if(!unitData.isInUse() && 
            (unitData.getLastRequestedFrame() < BWAPI::Broodwar->getFrameCount() || unitData.getLastRequestedPriority() <= request.priority) 
            && unit->isCompleted() && !unit->isUnpowered())
          {
            if(haveMineral)
            {
              done = true;
              unitData.setInUseFlag(true);
              m_layer2->reserveResource(request.actionResources.getResources());
              request.resourcesId.eventHandler.onEvent(NULL, boost::tuples::make_tuple(unit));
              request.resourcesId.isValid = false;
              result.deleteCurrent = true;
            } else {
              unitData.setLastRequestedFrame(BWAPI::Broodwar->getFrameCount());
              unitData.setLastRequestedPriority(request.priority);
            }
          }
          ++buildingIt;
        }
        //TODO: 
        // if(!done)
        // Notify Layer3 Action delayed no building available (+ Resources?)
      }

      if(!haveMineral) {
        //TODO: Notify layer 3, Delayed action
      }
      return result;
    }
  };

  struct AvailableResourcesFunctor
  {
    unsigned int m_priority;
    Resources m_resources;
    AvailableResourcesFunctor(Resources baseResources, unsigned int priority) 
      : m_resources(baseResources)
      , m_priority(priority)
    {}
    ResourcesRequestsType::ConstFunctionReturn AvailableResourcesFunctor::operator()(const ResourcesRequest& request)
    {
      ResourcesRequestsType::ConstFunctionReturn result = ResourcesRequestsType::ConstFunctionReturn();
      if(m_priority > request.priority)
        result.breakIteration = true;
      else
        m_resources -= request.actionResources.getResources();

      return result;
    }
  };

  struct ClearResourcesRequestsFunctor
  {
    ResourcesRequestsType::FunctionReturn ClearResourcesRequestsFunctor::operator()(const ResourcesRequest& request)
    {
      unused(request);
      return ResourcesRequestsType::FunctionReturn(true,false);
    }
  };
  
};