sc2_unit.h

Go to the documentation of this file.

#pragma once

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

namespace sc2 {

class ObservationInterface;

struct UnitOrder {
    AbilityID ability_id;
    Tag target_unit_tag;
    Point2D target_pos;
    float progress;

    UnitOrder() :
        ability_id(0),
        target_unit_tag(NullTag),
        progress(0.0f) {
    }
};

struct PassengerUnit {
    Tag tag;
    float health;
    float health_max;
    float shield;
    float shield_max;
    float energy;
    float energy_max;
    UnitTypeID unit_type;

    PassengerUnit() :
        tag(NullTag),
        health(0.0f),
        health_max(0.0f),
        shield(0.0f),
        shield_max(0.0f),
        energy(0.0f),
        energy_max(0.0f),
        unit_type(0) {
    }
};

class Unit {
public:
    enum DisplayType {
        Visible = 1,
        Snapshot = 2,
        Hidden = 3,
    };

    enum Alliance {
        Self = 1,
        Ally = 2,
        Neutral = 3,
        Enemy = 4
    };

    enum CloakState {
        Cloaked = 1,
        CloakedDetected = 2,
        NotCloaked = 3,
        Unknown = 4
    };

    DisplayType display_type;
    Alliance alliance;

    Tag tag;
    UnitTypeID unit_type;
    int owner;

    Point3D pos;
    float facing;
    float radius;
    float build_progress;

    CloakState cloak;

    float detect_range;
    float radar_range;

    bool is_selected;
    bool is_on_screen;
    bool is_blip;

    // Not populated for snapshots

    float health;
    float health_max;
    float shield;
    float shield_max;
    float energy;
    float energy_max;
    int mineral_contents;
    int vespene_contents;
    bool is_flying;
    bool is_burrowed;
    float weapon_cooldown;

    // Not populated for enemies/snapshots

    std::vector<UnitOrder> orders;
    Tag add_on_tag;
    std::vector<PassengerUnit> passengers;
    int cargo_space_taken;
    int cargo_space_max;
    int assigned_harvesters;
    int ideal_harvesters;
    Tag engaged_target_tag;
    std::vector<BuffID> buffs;
    bool is_powered;

    bool is_alive;
    uint32_t last_seen_game_loop;

    Unit();
};

typedef std::vector<const Unit*> Units;
typedef std::unordered_map<Tag, size_t> UnitIdxMap;

class UnitPool {
public:
    Unit* CreateUnit(Tag tag);
    Unit* GetUnit(Tag tag) const;
    Unit* GetExistingUnit(Tag tag) const;
    void MarkDead(Tag tag);

    //TODO: Change alive -> Exist
    void ForEachExistingUnit(const std::function<void(Unit& unit)>& functor) const;
    void ClearExisting();
    bool UnitExists(Tag tag);

private:
    void IncrementIndex();

    static const size_t ENTRY_SIZE = 1000;
    typedef std::pair<size_t, size_t> PoolIndex;
    // std::array<Unit, ENTRY_SIZE>
    std::vector<std::vector<Unit> > unit_pool_;
    PoolIndex available_index_;
    std::unordered_map<Tag, Unit*> tag_to_unit_;
    std::unordered_map<Tag, Unit*> tag_to_existing_unit_;
};

struct IsUnit {
    IsUnit(UNIT_TYPEID type) : type_(type) {};
    UNIT_TYPEID type_;
    bool operator()(const Unit& unit) { return unit.unit_type == type_; };
};

struct IsUnits {
    IsUnits(std::vector<UNIT_TYPEID> types) : types_(types) {};
    std::vector<UNIT_TYPEID> types_;
    bool operator()(const Unit& unit) {
        bool included = false;
        for (const auto& type : types_) {
            included = included || (unit.unit_type == type);
        }
        return included;
    };
};

}