1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
/* This file is part of the Spring engine (GPL v2 or later), see LICENSE.html */
#ifndef _BUILDER_CAI_H_
#define _BUILDER_CAI_H_
#include "MobileCAI.h"
#include "Sim/Units/BuildInfo.h"
#include "System/Misc/BitwiseEnum.h"
#include "System/UnorderedSet.hpp"
#include <vector>
class CUnit;
class CBuilder;
class CFeature;
class CSolidObject;
class CWorldObject;
struct Command;
struct UnitDef;
class CBuilderCAI : public CMobileCAI
{
public:
CR_DECLARE_DERIVED(CBuilderCAI)
CBuilderCAI(CUnit* owner);
CBuilderCAI();
~CBuilderCAI();
static void InitStatic();
void PostLoad();
int GetDefaultCmd(const CUnit* unit, const CFeature* feature) override;
void SlowUpdate() override;
void FinishCommand() override;
void GiveCommandReal(const Command& c, bool fromSynced = true) override;
void BuggerOff(const float3& pos, float radius) override;
bool TargetInterceptable(const CUnit* unit, float uspeed);
void ExecuteBuildCmd(Command& c);
void ExecutePatrol(Command& c) override;
void ExecuteFight(Command& c) override;
void ExecuteGuard(Command& c) override;
void ExecuteStop(Command& c) override;
virtual void ExecuteRepair(Command& c);
virtual void ExecuteCapture(Command& c);
virtual void ExecuteReclaim(Command& c);
virtual void ExecuteResurrect(Command& c);
virtual void ExecuteRestore(Command& c);
bool ReclaimObject(CSolidObject* o);
bool ResurrectObject(CFeature* feature);
/**
* Checks if a unit is being reclaimed by a friendly con.
*/
static bool IsUnitBeingReclaimed(const CUnit* unit, const CUnit* friendUnit = nullptr);
static bool IsFeatureBeingReclaimed(int featureId, const CUnit* friendUnit = nullptr);
static bool IsFeatureBeingResurrected(int featureId, const CUnit* friendUnit = nullptr);
bool IsInBuildRange(const CWorldObject* obj) const;
bool IsInBuildRange(const float3& pos, const float radius) const;
public:
spring::unordered_set<int> buildOptions;
static spring::unordered_set<int> reclaimers;
static spring::unordered_set<int> featureReclaimers;
static spring::unordered_set<int> resurrecters;
static std::vector<int> removees;
private:
enum ReclaimOptions {
REC_NORESCHECK = 1<<0,
REC_UNITS = 1<<1,
REC_NONREZ = 1<<2,
REC_ENEMY = 1<<3,
REC_ENEMYONLY = 1<<4,
REC_SPECIAL = 1<<5
};
typedef Bitwise::BitwiseEnum<ReclaimOptions> ReclaimOption;
private:
/**
* @param pos position where to reclaim
* @param radius radius to search for objects to reclaim
* @param cmdopts command options
* @param recoptions reclaim optioons
*/
bool FindReclaimTargetAndReclaim(const float3& pos, float radius, unsigned char cmdopt, ReclaimOption recoptions);
/**
* @param freshOnly reclaims only corpses that have rez progress or all the metal left
*/
bool FindResurrectableFeatureAndResurrect(const float3& pos, float radius, unsigned char options, bool freshOnly);
/**
* @param builtOnly skips units that are under construction
*/
bool FindRepairTargetAndRepair(const float3& pos, float radius, unsigned char options, bool attackEnemy, bool builtOnly);
/**
* @param pos position where to search for units to capture
* @param radius radius in which are searched units to capture
* @param options command options
* @param healthyOnly only capture units with capture progress or 100% health remaining
*/
bool FindCaptureTargetAndCapture(const float3& pos, float radius, unsigned char options, bool healthyOnly);
int FindReclaimTarget(const float3& pos, float radius, unsigned char cmdopt, ReclaimOption recoptions, float bestStartDist = 1.0e30f) const;
float GetBuildRange(const float targetRadius) const;
bool MoveInBuildRange(const CWorldObject* obj, const bool checkMoveTypeForFailed = false);
bool MoveInBuildRange(const float3& pos, float radius, const bool checkMoveTypeForFailed = false);
bool IsBuildPosBlocked(const BuildInfo& bi, const CUnit** nanoFrame) const;
bool IsBuildPosBlocked(const BuildInfo& bi) const {
const CUnit* u = nullptr;
return IsBuildPosBlocked(build, &u);
}
void CancelRestrictedUnit();
bool OutOfImmobileRange(const Command& cmd) const;
/// add a command to reclaim a feature that is blocking our build-site
void ReclaimFeature(CFeature* f);
/// fix for patrolling cons repairing/resurrecting stuff that's being reclaimed
static void AddUnitToReclaimers(CUnit*);
static void RemoveUnitFromReclaimers(CUnit*);
/// fix for cons wandering away from their target circle
static void AddUnitToFeatureReclaimers(CUnit*);
static void RemoveUnitFromFeatureReclaimers(CUnit*);
/// fix for patrolling cons reclaiming stuff that is being resurrected
static void AddUnitToResurrecters(CUnit*);
static void RemoveUnitFromResurrecters(CUnit*);
inline float f3Dist(const float3& a, const float3& b) const {
return range3D ? a.distance(b) : a.distance2D(b);
}
inline float f3SqDist(const float3& a, const float3& b) const {
return range3D ? a.SqDistance(b) : a.SqDistance2D(b);
}
//inline float f3Len(const float3& a) const {
// return range3D ? a.Length() : a.Length2D();
//}
//inline float f3SqLen(const float3& a) const {
// return range3D ? a.SqLength() : a.SqLength2D();
//}
float GetBuildOptionRadius(const UnitDef* unitdef, int cmdId);
private:
CBuilder* ownerBuilder;
bool building;
BuildInfo build;
int cachedRadiusId;
float cachedRadius;
int buildRetries;
int randomCounter; ///< used to balance intervals of time intensive ai optimizations
int lastPC1; ///< helps avoid infinite loops
int lastPC2;
int lastPC3;
bool range3D;
};
#endif // _BUILDER_CAI_H_
|
