1 #ifndef KAIK_UNITTABLE_HDR 2 #define KAIK_UNITTABLE_HDR 3 4 #include <string> 5 #include <vector> 6 7 #include "Defines.h" 8 9 struct AIClasses; 10 struct UnitType; 11 namespace springLegacyAI { 12 struct MoveData; 13 struct UnitDef; 14 } // namespace springLegacyAI 15 16 struct CategoryData { CR_DECLARE_STRUCTCategoryData17 CR_DECLARE_STRUCT(CategoryData) 18 19 bool CanBuild(UnitDefCategory c) const { 20 switch (c) { 21 case CAT_GROUND_FACTORY: { return (!groundFactories.empty()); } break; 22 case CAT_GROUND_BUILDER: { return (!groundBuilders.empty()); } break; 23 case CAT_GROUND_ATTACKER: { return (!groundAttackers.empty()); } break; 24 case CAT_METAL_EXTRACTOR: { return (!metalExtractors.empty()); } break; 25 case CAT_METAL_MAKER: { return (!metalMakers.empty()); } break; 26 case CAT_METAL_STORAGE: { return (!metalStorages.empty()); } break; 27 case CAT_ENERGY_STORAGE: { return (!energyStorages.empty()); } break; 28 case CAT_GROUND_ENERGY: { return (!groundEnergy.empty()); } break; 29 case CAT_GROUND_DEFENSE: { return (!groundDefenses.empty()); } break; 30 case CAT_NUKE_SILO: { return (!nukeSilos.empty()); } break; 31 default: { return false; } break; 32 } 33 } 34 35 // maps UnitCategory to UnitDefCategory GetDefsForUnitCatCategoryData36 std::vector<int>& GetDefsForUnitCat(UnitCategory c) { 37 switch (c) { 38 case CAT_COMM: { return groundFactories; } break; // ?? 39 case CAT_ENERGY: { return groundEnergy; } break; 40 case CAT_MEX: { return metalExtractors; } break; 41 case CAT_MMAKER: { return metalMakers; } break; 42 case CAT_BUILDER: { return groundBuilders; } break; 43 case CAT_ESTOR: { return energyStorages; } break; 44 case CAT_MSTOR: { return metalStorages; } break; 45 case CAT_FACTORY: { return groundFactories; } break; 46 case CAT_DEFENCE: { return groundDefenses; } break; 47 case CAT_G_ATTACK: { return groundAttackers; } break; 48 case CAT_NUKE: { return nukeSilos; } break; 49 default: { return dummy; } break; 50 } 51 } 52 GetDefsForUnitDefCatCategoryData53 std::vector<int>& GetDefsForUnitDefCat(UnitDefCategory c) { 54 switch (c) { 55 case CAT_GROUND_FACTORY: { return groundFactories; } break; 56 case CAT_GROUND_BUILDER: { return groundBuilders; } break; 57 case CAT_GROUND_ATTACKER: { return groundAttackers; } break; 58 case CAT_METAL_EXTRACTOR: { return metalExtractors; } break; 59 case CAT_METAL_MAKER: { return metalMakers; } break; 60 case CAT_METAL_STORAGE: { return metalStorages; } break; 61 case CAT_ENERGY_STORAGE: { return energyStorages; } break; 62 case CAT_GROUND_ENERGY: { return groundEnergy; } break; 63 case CAT_GROUND_DEFENSE: { return groundDefenses; } break; 64 case CAT_NUKE_SILO: { return nukeSilos; } break; 65 default: { return dummy; } break; 66 } 67 } 68 69 std::vector<int> groundFactories; 70 std::vector<int> groundBuilders; 71 std::vector<int> groundAttackers; 72 std::vector<int> metalExtractors; 73 std::vector<int> metalMakers; 74 std::vector<int> metalStorages; 75 std::vector<int> energyStorages; 76 std::vector<int> groundEnergy; 77 std::vector<int> groundDefenses; 78 std::vector<int> nukeSilos; 79 std::vector<int> dummy; 80 }; 81 82 class CUnitTable { 83 public: CR_DECLARE(CUnitTable)84 CR_DECLARE(CUnitTable) 85 86 CUnitTable() {} 87 CUnitTable(AIClasses* ai); 88 ~CUnitTable(); 89 90 void PostLoad(); 91 // initialize all unit lists, categories etc 92 void Init(); 93 94 // not implemented 95 const UnitDef* GetBestEconomyBuilding(int builder, float minUsefulness); 96 97 98 // true if a builder can build a certain unit (use UnitDef.id) 99 bool CanBuildUnit(int id_builder, int id_unit); 100 101 // gets the average Damage Per second a unit can cause (provided all weapons are in range) 102 float GetDPS(const UnitDef* unit); 103 // finds the actual DPS versus a specific enemy unit 104 float GetDPSvsUnit(const UnitDef* unit, const UnitDef* victim); 105 // checks the combat potential of this unit vs all active enemy units 106 float GetCurrentDamageScore(const UnitDef* unit); 107 108 void UpdateChokePointArray(); 109 110 // gets the category for a particular unit 111 UnitCategory GetCategory(const UnitDef*) const; 112 UnitCategory GetCategory(int) const; 113 114 // returns the ID of the best possible Unit of a given category 115 const UnitDef* GetUnitByScore(int, UnitCategory); 116 117 // finds the general score of any given unit 118 float GetScore(const UnitDef*, UnitCategory); 119 120 // returns max range of all weapons (or 0) 121 float GetMaxRange(const UnitDef*); 122 // returns min range for all weapons (or FLT_MAX) 123 float GetMinRange(const UnitDef*); 124 125 CategoryData categoryData; 126 std::map<int, MoveData*> moveDefs; 127 128 std::vector<const UnitDef*> unitDefs; 129 std::vector<UnitType> unitTypes; 130 int numDefs; 131 132 private: 133 void ReadModConfig(); 134 void DebugPrint(); 135 136 std::string GetDbgLogName() const; 137 std::string GetModCfgName() const; 138 139 AIClasses* ai; 140 }; 141 142 #endif 143