SPAR/AIModule/SparAIModule/PerceptualState/InfluenceMap/Threat.h

Go to the documentation of this file.

#pragma once
#include "InfluenceMap.h"
#include "../../Utils/BresenhamCircle.h"
#include <BWAPI.h>
#include <cassert>
#include <functional>
#include <set>

struct Threat
{
  int ground;
  int air;

  Threat() { reset(); }
  void reset() { ground = air = 0; }

  bool isNull() const
  {
    return ground == 0 && air == 0;
  }

  void display(int x, int y, int w, int h, BWAPI::Player* player) const
  {
    if (ground > 0)
    {
      int val = std::min<int>(ground + 50, 0xff);

      BWAPI::Color colour(val, 0, 0);
      if (player == BWAPI::Broodwar->self())
      {
        colour = BWAPI::Color(0, val, 0);
        x++;
        y++;
        w-=2;
        h-=2;
      }

      BWAPI::Broodwar->drawBox(BWAPI::CoordinateType::Map, x, y, x+w, y+h, colour, false);
    }
  }

  static void update(InfluenceMap<Threat>& map);

private:
  template <class Iterator>
  static void update(InfluenceMap<Threat>& map, Iterator begin, Iterator end)
  {
    for (; begin != end; ++begin)
    {
      update(map, *begin);
    }
  }

  static void update(InfluenceMap<Threat>& map, BWAPI::Unit* unit);
  static void update(InfluenceMap<Threat>& map, const EnemyUnit* unit);

  static void updateInfluence(InfluenceMap<Threat>& map, BWAPI::Position position, int groundRange, int groundDamage, int airRange, int airDamage, double topSpeed)
  {  
    // Top speed in pixel per frame: zealot = 4; for dragoon = 5
    int speedFactor = static_cast<int>(topSpeed/2.0 + 0.5);

    // Update the influence of all tiles within range
    if (groundDamage > 0)
        {
                BresenhamCircle(Functor(map, position, (groundDamage % 2 ? groundDamage/2 : groundDamage/2 +1), 0), groundRange, true);
                BresenhamCircle(Functor(map, position, groundDamage/2, 0), groundRange + speedFactor, true);
        }
    if (airDamage > 0)
        {
      BresenhamCircle(Functor(map, position, 0, (airDamage % 2 ? airDamage/2 : airDamage/2 +1)),    airRange,    true);
      BresenhamCircle(Functor(map, position, 0, airDamage/2), airRange + speedFactor,    true);
        }
  }

  struct Functor : std::binary_function<int,int,void>
  {
    Functor(InfluenceMap<Threat>& map, const BWAPI::Position& position, int groundDamage, int airDamage)
      : m_map(map)
      , m_x(position.x() / TILE_SIZE), m_y(position.y() / TILE_SIZE)
      , m_ground(groundDamage)
      , m_air(airDamage)
    {
      // FIXME
      assert(map.getWidth()  == BWAPI::Broodwar->mapWidth()
          && map.getHeight() == BWAPI::Broodwar->mapHeight());
    }

    result_type operator()(first_argument_type x, second_argument_type y);

  private:
    InfluenceMap<Threat>& m_map;
    int m_x, m_y;
    int m_ground, m_air;
  };
};