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 <unordered_set>
#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,
        // Building that hasn't started construction.
        Placeholder = 4,
    };

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

    enum CloakState {
        CloakedUnknown = 0,
        Cloaked = 1,
        CloakedDetected = 2,
        NotCloaked = 3,
        CloakedAllied = 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;

    int32_t attack_upgrade_level;

    int32_t armor_upgrade_level;

    int32_t shield_upgrade_level;

    Unit();
};

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

struct UnitDamage {
    const Unit* unit;
    float health;
    float shields;
};

typedef std::vector<UnitDamage> UnitsDamaged;

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);

    const Units& GetNewUnits() const noexcept { return units_newly_created_; };
    const Units& GetUnitsEnteringVision() const noexcept { return units_entering_vision_; };
    const Units& GetCompletedBuildings() const noexcept { return buildings_constructed_; };
    const UnitsDamaged& GetDamagedUnits() const noexcept { return units_damaged_; };
    const std::unordered_set<const Unit*>& GetIdledUnits() const noexcept { return units_idled_; };

    void AddNewUnit(const Unit* u) { units_newly_created_.push_back(u); };
    void AddUnitEnteredVision(const Unit* u) { units_entering_vision_.push_back(u); }
    void AddCompletedBuilding(const Unit* u) { buildings_constructed_.push_back(u); }
    void AddUnitIdled(const Unit* u) {
        if (u->alliance == Unit::Alliance::Self) units_idled_.insert(u);
    }
    void AddUnitDamaged(const Unit* u, float health, float shield) { units_damaged_.push_back({u, health, shield}); }

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_;
    Units units_newly_created_;
    Units units_entering_vision_;
    Units buildings_constructed_;
    UnitsDamaged units_damaged_;
    std::unordered_set<const Unit*> units_idled_;
};

}