sc2_data.h

#pragma once

#include "sc2_proto_interface.h"
#include "sc2_gametypes.h"
#include "sc2_typeenums.h"
#include <vector>
#include <string>
#include <stdint.h>

namespace sc2 {

class ObservationInterface;

typedef MessageResponsePtr<SC2APIProtocol::ResponseData> ResponseDataPtr;

struct AvailableAbility {
    AvailableAbility() = default;
    AvailableAbility(AbilityID ability_id, bool requires_point) :
        ability_id(ability_id),
        requires_point(requires_point) {};

    AbilityID ability_id = 0;
    bool requires_point = false;
};

struct AbilityData {
    enum class Target {
        None = 1,
        Point = 2,
        Unit = 3,
        PointOrUnit = 4,
        PointOrNone = 5
    };

    bool available;
    AbilityID ability_id;
    std::string link_name;
    uint32_t link_index;
    std::string button_name;
    std::string friendly_name;
    std::string hotkey;
    uint32_t remaps_to_ability_id;
    std::vector<uint32_t> remaps_from_ability_id;
    Target target;
    bool allow_minimap;
    bool allow_autocast;
    bool is_building;
    float footprint_radius;
    bool is_instant_placement;
    float cast_range;

    AbilityData();

    void ReadFromProto(const SC2APIProtocol::AbilityData& ability_data);
    std::string Log() const;
};

typedef std::vector<AbilityData> Abilities;

struct AvailableAbilities {
    std::vector<AvailableAbility> abilities;
    Tag unit_tag;
    UnitTypeID unit_type_id;

    bool IsValid() const {
        return unit_tag && unit_type_id;
    }
};

enum class Attribute {
    Light = 1,
    Armored = 2,
    Biological = 3,
    Mechanical = 4,
    Robotic = 5,
    Psionic = 6,
    Massive = 7,
    Structure = 8,
    Hover = 9,
    Heroic = 10,
    Summoned = 11,
    Invalid = 12
};

struct DamageBonus {
    Attribute attribute;
    float bonus;

    DamageBonus();

    void ReadFromProto(const SC2APIProtocol::DamageBonus& damage_bonus);
};

struct Weapon {
    enum class TargetType {
        Ground = 1,
        Air = 2,
        Any = 3,
        Invalid = 4
    };
    TargetType type;
    float damage_;
    std::vector<DamageBonus> damage_bonus;              // Extra damage when attacking a unit of a certain attribute
    uint32_t attacks;                                   // Number of hits per attack. (eg. Colossus has 2 beams)
    float range;
    float speed;                                        // Time between attacks

    Weapon();

    void ReadFromProto(const SC2APIProtocol::Weapon& weapon);
};

struct UnitTypeData {
    UnitTypeID unit_type_id;
    std::string name;
    bool available;
    uint32_t cargo_size;
    int mineral_cost;
    int vespene_cost;

    std::vector<Attribute> attributes;
    float movement_speed;
    float armor;
    std::vector<Weapon> weapons;
    float food_required;
    float food_provided;
    AbilityID ability_id;
    Race race;
    float build_time;
    bool has_minerals;
    bool has_vespene;
    float sight_range;

    std::vector<UnitTypeID> tech_alias;
    UnitTypeID unit_alias;
    UnitTypeID tech_requirement;
    bool require_attached;

    UnitTypeData();

    void ReadFromProto(const SC2APIProtocol::UnitTypeData& unit_data);
    std::string Log() const;
};

typedef std::vector<UnitTypeData> UnitTypes;

struct UpgradeData {
    uint32_t upgrade_id;
    std::string name;
    uint32_t mineral_cost;
    uint32_t vespene_cost;
    AbilityID ability_id;
    float research_time;

    UpgradeData();

    void ReadFromProto(const SC2APIProtocol::UpgradeData& upgrade_data);
    std::string Log() const;
};

typedef std::vector<UpgradeData> Upgrades;

struct BuffData {
    uint32_t buff_id;
    std::string name;

    BuffData();

    void ReadFromProto(const SC2APIProtocol::BuffData& buff_data);
    std::string Log() const;
};

typedef std::vector<BuffData> Buffs;

struct EffectData {
    uint32_t effect_id;
    std::string name;
    std::string friendly_name;
    float radius;

    void ReadFromProto(const SC2APIProtocol::EffectData& effect_data);
    std::string Log() const;
};

typedef std::vector<EffectData> Effects;

struct PowerSource {
    PowerSource(const Point2D in_position, float in_radius, Tag in_tag) :
        position(in_position),
        radius(in_radius),
        tag(in_tag) {};

    Point2D position;
    float radius;
    Tag tag;
};

struct Effect {
    uint32_t effect_id;
    std::vector<Point2D> positions;

    void ReadFromProto(const SC2APIProtocol::Effect& effect);
};

AbilityID GetGeneralizedAbilityID(uint32_t ability_id, const ObservationInterface& observation);

}