SPAR/AIModule/SparAIModule/PerceptualState/Techs/Techs.h

Go to the documentation of this file.

#pragma once
#include "Tech.h"
#include "../Locations/Static/Map.h"
#include "../../Utils/Component.h"
#include "../../Utils/Event.h"
#include <list>
#include <sstream>
#include <hash_map>
#include <boost/iterator/transform_iterator.hpp>

class Techs
{
private:
  struct UpgradeCompare
  {
    bool operator()(const std::pair<BWAPI::UpgradeType, int>& upgrade1, const std::pair<BWAPI::UpgradeType, int>& upgrade2) const
    {
      if (upgrade1.first < upgrade2.first)
        return true;
      else if (upgrade1.first > upgrade2.first)
        return false;
      else
        return upgrade1.second < upgrade2.second;
    }
  };
  struct UpgradeHashCompare : public stdext::hash_compare<std::pair<BWAPI::UpgradeType, int>, UpgradeCompare>
  {
    size_t operator()(const std::pair<BWAPI::UpgradeType, int>& upgrade) const
    {
      return 17 * upgrade.first.getID() + 47 * upgrade.second;
    }
    bool operator()(const std::pair<BWAPI::UpgradeType, int>& upgrade1, const std::pair<BWAPI::UpgradeType, int>& upgrade2) const
    {
      return UpgradeCompare()(upgrade1, upgrade2);
    }
  };
public:
  static UnitTypeTech* NexusTech;
  static UnitTypeTech* PylonTech;
  static UnitTypeTech* AssimilatorTech;
  static UnitTypeTech* GatewayTech;
  static UnitTypeTech* ShieldBatteryTech;
  static UnitTypeTech* ForgeTech;
  static UnitTypeTech* PhotonCannonTech;
  static UnitTypeTech* CyberneticsCoreTech;
  static UnitTypeTech* RoboticsFacilityTech;
  static UnitTypeTech* RoboticsSupportBayTech;
  static UnitTypeTech* ObservatoryTech;
  static UnitTypeTech* StargateTech;
  static UnitTypeTech* FleetBeaconTech;
  static UnitTypeTech* ArbiterTribunalTech;
  static UnitTypeTech* CitadelOfAdunTech;
  static UnitTypeTech* TemplarArchivesTech;

  static UnitTypeTech* ProbeTech;
  static UnitTypeTech* ZealotTech;
  static UnitTypeTech* DragoonTech;
  static UnitTypeTech* HighTemplarTech;
  static UnitTypeTech* DarkTemplarTech;
  static UnitTypeTech* ArchonTech;
  static UnitTypeTech* DarkArchonTech;
  static UnitTypeTech* ReaverTech;
  static UnitTypeTech* ShuttleTech;
  static UnitTypeTech* ObserverTech;
  static UnitTypeTech* CorsairTech;
  static UnitTypeTech* ScoutTech;
  static UnitTypeTech* CarrierTech;
  static UnitTypeTech* ArbiterTech;

  static TechTypeTech* DisruptionWebTech;
  static TechTypeTech* FeedbackTech;
  static TechTypeTech* HallucinationTech;
  static TechTypeTech* MaelstromTech;
  static TechTypeTech* MindControlTech;
  static TechTypeTech* PsionicStormTech;
  static TechTypeTech* RecallTech;
  static TechTypeTech* StasisFieldTech;

  static UpgradeTypeTech* GroundWeapons[3];    // upgrade ground weapons level 1-2-3
  static UpgradeTypeTech* GroundArmor[3];      // upgrade ground armor level 1-2-3
  static UpgradeTypeTech* AirWeapons[3];       // upgrade air weapons level 1-2-3
  static UpgradeTypeTech* AirArmor[3];         // upgrade air armor level 1-2-3
  static UpgradeTypeTech* PlasmaShields[3];    // upgrade plasma shields 1-2-3
  static UpgradeTypeTech* SingularityCharge;   // increase Dragoon attack range
  static UpgradeTypeTech* LegEnhancements;     // faster Zealot movement
  static UpgradeTypeTech* GraviticDrive;       // faster Shuttle movement
  static UpgradeTypeTech* CarrierCapacity;     // max 8 interceptors (instead of 4)
  static UpgradeTypeTech* ReaverCapacity;      // max 10 Scarabs (instead of 5)
  static UpgradeTypeTech* ScarabDamage;        // upgrade Scarab damage (125 instead of 100)
  static UpgradeTypeTech* GraviticBoosters;    // faster Observer movement
  static UpgradeTypeTech* SensorArray;         // increase Observer sight range
  static UpgradeTypeTech* ApialSensors;        // increase Scout sight range
  static UpgradeTypeTech* GraviticThrusters;   // faster Scout movement
  static UpgradeTypeTech* ArgusJewel;          // +50 Corsair energy
  static UpgradeTypeTech* ArgusTalisman;       // +50 Dark Archon energy
  static UpgradeTypeTech* KhaydarinAmulet;     // +50 Templar energy
  static UpgradeTypeTech* KhaydarinCore;       // +50 Arbiter energy

  template <class TechTypes>
  static void onStart(const Map* map);

  static void onEnd();

  static UnitTypeTech* getUnitTypeTech(BWAPI::UnitType unitType)
  {
    stdext::hash_map<BWAPI::UnitType, UnitTypeTech*>::const_iterator it = UnitTypeTechs.find(unitType);
    if (it == UnitTypeTechs.end())
    {
      return NULL;
    }
    else
    {
      return it->second;
    }
  }
  static TechTypeTech* getTechTypeTech(BWAPI::TechType techType)
  {
    stdext::hash_map<BWAPI::TechType, TechTypeTech*>::const_iterator it = TechTypeTechs.find(techType);
    if (it == TechTypeTechs.end())
    {
      return NULL;
    }
    else
    {
      return it->second;
    }
  }
  static UpgradeTypeTech* getUpgradeTypeTech(BWAPI::UpgradeType upgradeType, int level = 1)
  {
    stdext::hash_map<std::pair<BWAPI::UpgradeType, int>, UpgradeTypeTech*>::const_iterator it = UpgradeTypeTechs.find(std::make_pair(upgradeType, level));
    if (it == UpgradeTypeTechs.end())
    {
      return NULL;
    }
    else
    {
      return it->second;
    }
  }

  DECLARE_EVENT1(OnTechAcquired, Tech*);
  static OnTechAcquired& getTechAcquiredEvent() { return s_techAcquiredEvent; }

  DECLARE_EVENT1(OnTechLost, Tech*);
  static OnTechLost& getTechLostEvent() { return s_techLostEvent; }

  typedef boost::transform_iterator<extract_pair_second_const<stdext::hash_map<BWAPI::UnitType, UnitTypeTech*>::const_iterator::value_type>, 
                                    stdext::hash_map<BWAPI::UnitType, UnitTypeTech*>::const_iterator> 
          unit_type_tech_const_iterator;
  static std::pair<unit_type_tech_const_iterator, unit_type_tech_const_iterator> getUnitTypeTechs()
  {
    return std::make_pair(unit_type_tech_const_iterator(UnitTypeTechs.begin()), unit_type_tech_const_iterator(UnitTypeTechs.end()));
  }

  typedef boost::transform_iterator<extract_pair_second_const<stdext::hash_map<BWAPI::TechType, TechTypeTech*>::const_iterator::value_type>, 
                                    stdext::hash_map<BWAPI::TechType, TechTypeTech*>::const_iterator> 
          tech_type_tech_const_iterator;
  static std::pair<tech_type_tech_const_iterator, tech_type_tech_const_iterator> getTechTypeTechs()
  {
    return std::make_pair(tech_type_tech_const_iterator(TechTypeTechs.begin()), tech_type_tech_const_iterator(TechTypeTechs.end()));
  }

  typedef boost::transform_iterator<extract_pair_second_const<stdext::hash_map<std::pair<BWAPI::UpgradeType, int>, UpgradeTypeTech*, UpgradeHashCompare>::const_iterator::value_type>, 
                                    stdext::hash_map<std::pair<BWAPI::UpgradeType, int>, UpgradeTypeTech*, UpgradeHashCompare>::const_iterator> 
          upgrade_type_tech_const_iterator;
  static std::pair<upgrade_type_tech_const_iterator, upgrade_type_tech_const_iterator> getUpgradeTypeTechs()
  {
    return std::make_pair(upgrade_type_tech_const_iterator(UpgradeTypeTechs.begin()), upgrade_type_tech_const_iterator(UpgradeTypeTechs.end()));
  }

  typedef concatenate_iterators<boost::tuple<std::pair<unit_type_tech_const_iterator, unit_type_tech_const_iterator>, 
                                             std::pair<tech_type_tech_const_iterator, tech_type_tech_const_iterator>,
                                             std::pair<upgrade_type_tech_const_iterator, upgrade_type_tech_const_iterator>>, 
                                const Tech*> 
    tech_const_iterator;
  static std::pair<tech_const_iterator, tech_const_iterator> getAllTechs()
  {
    return std::make_pair(tech_const_iterator(boost::make_tuple(std::make_pair(unit_type_tech_const_iterator(UnitTypeTechs.begin()), unit_type_tech_const_iterator(UnitTypeTechs.end())),
                                                                std::make_pair(tech_type_tech_const_iterator(TechTypeTechs.begin()), tech_type_tech_const_iterator(TechTypeTechs.end())),
                                                                std::make_pair(upgrade_type_tech_const_iterator(UpgradeTypeTechs.begin()), upgrade_type_tech_const_iterator(UpgradeTypeTechs.end())))),
                          tech_const_iterator(boost::make_tuple(std::make_pair(unit_type_tech_const_iterator(UnitTypeTechs.end()), unit_type_tech_const_iterator(UnitTypeTechs.end())),
                                                                std::make_pair(tech_type_tech_const_iterator(TechTypeTechs.end()), tech_type_tech_const_iterator(TechTypeTechs.end())),
                                                                std::make_pair(upgrade_type_tech_const_iterator(UpgradeTypeTechs.end()), upgrade_type_tech_const_iterator(UpgradeTypeTechs.end())))));
  }

private:
  friend class Tech;
  friend class UnitTypeTech;
  friend class TechTypeTech;
  friend class UpgradeTypeTech;

  static void addUnitTypeTech(UnitTypeTech* tech)
  {
    std::pair<stdext::hash_map<BWAPI::UnitType, UnitTypeTech*>::iterator, bool> result =
      UnitTypeTechs.insert(std::make_pair(tech->getType(), tech));
    if (!result.second)
    {
      const std::string name = tech->getType().getName();
      throw std::runtime_error(std::string("Unit type tech duplicates \"") + name + "\"");
    }
  }

  static void addTechTypeTech(TechTypeTech* tech)
  {
    std::pair<stdext::hash_map<BWAPI::TechType, TechTypeTech*>::iterator, bool> result =
      TechTypeTechs.insert(std::make_pair(tech->getTech(), tech));
    if (!result.second)
    {
      const std::string name = tech->getTech().getName();
      throw std::runtime_error(std::string("Tech type duplicates \"") + name + "\"");
    }
  }

  static void addUpgradeTypeTech(UpgradeTypeTech* tech)
  {
    std::pair<stdext::hash_map<std::pair<BWAPI::UpgradeType, int>, UpgradeTypeTech*>::iterator, bool> result =
      UpgradeTypeTechs.insert(std::make_pair(std::make_pair(tech->getUpgrade(), tech->getLevel()), tech));
    if (!result.second)
    {
      const std::string name = tech->getUpgrade().getName();
      std::stringstream ss;
      ss << "Upgrade type tech duplicates \"" << name << " level " << tech->getLevel() << "\"";
      throw std::runtime_error(ss.str());
    }
  }

  static OnTechAcquired s_techAcquiredEvent;
  static OnTechLost s_techLostEvent;

  static stdext::hash_map<BWAPI::UnitType, UnitTypeTech*> UnitTypeTechs;
  static stdext::hash_map<BWAPI::TechType, TechTypeTech*> TechTypeTechs;
  static stdext::hash_map<std::pair<BWAPI::UpgradeType, int>, UpgradeTypeTech*, UpgradeHashCompare> UpgradeTypeTechs;

  static const Map* s_map;

  class TechEvents : public Component
  {
  public:
    static void onStart(const Map* map)
    {
      s_techEvents.m_onOwnUnitCompletedId = map->getUnitCompletedEvent().subscribe(&s_techEvents.m_onOwnUnitCompletedEventHandler, NULL);
      s_techEvents.m_onOwnUnitRemovedId = map->getOwnUnitRemovedEvent().subscribe(&s_techEvents.m_onOwnUnitRemovedEventHandler, NULL);
    }
    static void onEnd(const Map* map)
    {
      map->getUnitCompletedEvent().unsubscribe(s_techEvents.m_onOwnUnitCompletedId);
      map->getOwnUnitRemovedEvent().unsubscribe(s_techEvents.m_onOwnUnitRemovedId);
    }
    void onOwnUnitCompleted(void* data, BWAPI::Unit* unit);
    void onOwnUnitRemoved(void* data, OwnUnit* ownUnit);
  private:
    static TechEvents s_techEvents;
    TechEvents()
      : m_onOwnUnitCompletedEventHandler(*this)
      , m_onOwnUnitRemovedEventHandler(*this)
    {}
    Map::OnUnitCompleted::SubscriberID m_onOwnUnitCompletedId;
    Map::OnOwnUnitRemoved::SubscriberID m_onOwnUnitRemovedId;
    EVENT_HANDLER1(TechEvents, onOwnUnitCompleted, BWAPI::Unit*) m_onOwnUnitCompletedEventHandler;
    EVENT_HANDLER1(TechEvents, onOwnUnitRemoved, OwnUnit*) m_onOwnUnitRemovedEventHandler;
  };
  friend class TechEvents;
};

template <class TechTypes>
void Techs::onStart(const Map* map)
{
  s_map = map;
  TechEvents::onStart(map);

  // Techs must be ordered in correct dependency order... else you must add each tech to the maps before setting up the dependencies
  NexusTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Nexus);
  PylonTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Pylon);
  AssimilatorTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Assimilator);
  GatewayTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Gateway);
  ShieldBatteryTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Shield_Battery);
  ForgeTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Forge);
  PhotonCannonTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Photon_Cannon);
  CyberneticsCoreTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Cybernetics_Core);
  RoboticsFacilityTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Robotics_Facility);
  RoboticsSupportBayTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Robotics_Support_Bay);
  ObservatoryTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Observatory);
  CitadelOfAdunTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Citadel_of_Adun);
  TemplarArchivesTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Templar_Archives);
  StargateTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Stargate);
  FleetBeaconTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Fleet_Beacon);
  ArbiterTribunalTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Arbiter_Tribunal);

  ProbeTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Probe);
  ZealotTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Zealot);
  DragoonTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Dragoon);
  HighTemplarTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_High_Templar);
  DarkTemplarTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Dark_Templar);
  ArchonTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Archon);
  DarkArchonTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Dark_Archon);
  ReaverTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Reaver);
  ShuttleTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Shuttle);
  ObserverTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Observer);
  CorsairTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Corsair);
  ScoutTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Scout);
  CarrierTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Carrier);
  ArbiterTech = TechTypes::instantiateUnitTypeTech(BWAPI::UnitTypes::Protoss_Arbiter);

  DisruptionWebTech = TechTypes::instantiateTechTypeTech(BWAPI::TechTypes::Disruption_Web);
  FeedbackTech = TechTypes::instantiateTechTypeTech(BWAPI::TechTypes::Feedback);
  HallucinationTech = TechTypes::instantiateTechTypeTech(BWAPI::TechTypes::Hallucination);
  MaelstromTech = TechTypes::instantiateTechTypeTech(BWAPI::TechTypes::Maelstrom);
  MindControlTech = TechTypes::instantiateTechTypeTech(BWAPI::TechTypes::Mind_Control);
  PsionicStormTech = TechTypes::instantiateTechTypeTech(BWAPI::TechTypes::Psionic_Storm);
  RecallTech = TechTypes::instantiateTechTypeTech(BWAPI::TechTypes::Recall);
  StasisFieldTech = TechTypes::instantiateTechTypeTech(BWAPI::TechTypes::Stasis_Field);

  GroundWeapons[0] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Ground_Weapons, 1);
  GroundWeapons[1] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Ground_Weapons, 2);
  GroundWeapons[2] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Ground_Weapons, 3);
  GroundArmor[0] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Ground_Armor, 1);
  GroundArmor[1] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Ground_Armor, 2);
  GroundArmor[2] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Ground_Armor, 3);
  AirWeapons[0] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Air_Weapons, 1);
  AirWeapons[1] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Air_Weapons, 2);
  AirWeapons[2] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Air_Weapons, 3);
  AirArmor[0] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Air_Armor, 1);
  AirArmor[1] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Air_Armor, 2);
  AirArmor[2] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Air_Armor, 3);
  PlasmaShields[0] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Plasma_Shields, 1);
  PlasmaShields[1] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Plasma_Shields, 2);
  PlasmaShields[2] = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Protoss_Plasma_Shields, 3);
  SingularityCharge = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Singularity_Charge);
  LegEnhancements = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Leg_Enhancements);
  GraviticDrive = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Gravitic_Drive);
  CarrierCapacity = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Carrier_Capacity);
  ReaverCapacity = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Reaver_Capacity);
  ScarabDamage = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Scarab_Damage);
  GraviticBoosters = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Gravitic_Boosters);
  SensorArray = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Sensor_Array);
  ApialSensors = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Apial_Sensors);
  GraviticThrusters = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Gravitic_Thrusters);
  ArgusJewel = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Argus_Jewel);
  ArgusTalisman = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Argus_Talisman);
  KhaydarinAmulet = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Khaydarin_Amulet);
  KhaydarinCore = TechTypes::instantiateUpgradeTypeTech(BWAPI::UpgradeTypes::Khaydarin_Core);
}