Open source Star Ruler 2 source code!
This commit is contained in:
Lucas de Vries
@@ -0,0 +1,755 @@
|
||||
import empire_ai.weasel.WeaselAI;
|
||||
import empire_ai.weasel.Resources;
|
||||
import empire_ai.weasel.Budget;
|
||||
import empire_ai.weasel.Systems;
|
||||
|
||||
import planets.PlanetSurface;
|
||||
|
||||
import void relationRecordLost(AI& ai, Empire& emp, Object@ obj) from "empire_ai.weasel.Relations";
|
||||
|
||||
import buildings;
|
||||
import saving;
|
||||
|
||||
final class BuildingRequest {
|
||||
int id = -1;
|
||||
PlanetAI@ plAI;
|
||||
AllocateBudget@ alloc;
|
||||
const BuildingType@ type;
|
||||
double expires = INFINITY;
|
||||
bool built = false;
|
||||
bool canceled = false;
|
||||
bool scatter = false;
|
||||
vec2i builtAt;
|
||||
|
||||
BuildingRequest(Budget& budget, const BuildingType@ type, double priority, uint moneyType) {
|
||||
@this.type = type;
|
||||
@alloc = budget.allocate(moneyType, type.buildCostEst, type.maintainCostEst, priority=priority);
|
||||
}
|
||||
|
||||
BuildingRequest() {
|
||||
}
|
||||
|
||||
void save(Planets& planets, SaveFile& file) {
|
||||
planets.saveAI(file, plAI);
|
||||
planets.budget.saveAlloc(file, alloc);
|
||||
file.writeIdentifier(SI_Building, type.id);
|
||||
file << expires;
|
||||
file << built;
|
||||
file << canceled;
|
||||
file << builtAt;
|
||||
file << scatter;
|
||||
}
|
||||
|
||||
void load(Planets& planets, SaveFile& file) {
|
||||
@plAI = planets.loadAI(file);
|
||||
@alloc = planets.budget.loadAlloc(file);
|
||||
@type = getBuildingType(file.readIdentifier(SI_Building));
|
||||
file >> expires;
|
||||
file >> built;
|
||||
file >> canceled;
|
||||
file >> builtAt;
|
||||
if(file >= SV_0153)
|
||||
file >> scatter;
|
||||
}
|
||||
|
||||
double cachedProgress = 0.0;
|
||||
double nextProgressCache = 0.0;
|
||||
double getProgress() {
|
||||
if(!built)
|
||||
return 0.0;
|
||||
if(gameTime < nextProgressCache)
|
||||
return cachedProgress;
|
||||
|
||||
cachedProgress = plAI.obj.getBuildingProgressAt(builtAt.x, builtAt.y);
|
||||
if(cachedProgress > 0.95)
|
||||
nextProgressCache = gameTime + 1.0;
|
||||
else if(cachedProgress < 0.5)
|
||||
nextProgressCache = gameTime + 30.0;
|
||||
else
|
||||
nextProgressCache = gameTime + 10.0;
|
||||
|
||||
return cachedProgress;
|
||||
}
|
||||
|
||||
bool tick(AI& ai, Planets& planets, double time) {
|
||||
if(expires < gameTime) {
|
||||
if(planets.log)
|
||||
ai.print(type.name+" build request expired", plAI.obj);
|
||||
canceled = true;
|
||||
return false;
|
||||
}
|
||||
|
||||
if(alloc is null || alloc.allocated) {
|
||||
builtAt = plAI.buildBuilding(ai, planets, type, scatter=scatter);
|
||||
if(builtAt == vec2i(-1,-1)) {
|
||||
planets.budget.remove(alloc);
|
||||
canceled = true;
|
||||
}
|
||||
else
|
||||
built = true;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
final class PlanetAI {
|
||||
Planet@ obj;
|
||||
int targetLevel = 0;
|
||||
int requestedLevel = 0;
|
||||
double prevTick = 0;
|
||||
array<ExportData@>@ resources;
|
||||
ImportData@ claimedChain;
|
||||
|
||||
void init(AI& ai, Planets& planets) {
|
||||
@resources = planets.resources.availableResource(obj);
|
||||
}
|
||||
|
||||
void save(Planets& planets, SaveFile& file) {
|
||||
file << obj;
|
||||
file << targetLevel;
|
||||
file << requestedLevel;
|
||||
file << prevTick;
|
||||
|
||||
uint cnt = 0;
|
||||
if(resources !is null)
|
||||
cnt = resources.length;
|
||||
file << cnt;
|
||||
for(uint i = 0; i < cnt; ++i)
|
||||
planets.resources.saveExport(file, resources[i]);
|
||||
planets.resources.saveImport(file, claimedChain);
|
||||
}
|
||||
|
||||
void load(Planets& planets, SaveFile& file) {
|
||||
file >> obj;
|
||||
file >> targetLevel;
|
||||
file >> requestedLevel;
|
||||
file >> prevTick;
|
||||
uint cnt = 0;
|
||||
file >> cnt;
|
||||
@resources = array<ExportData@>();
|
||||
for(uint i = 0; i < cnt; ++i) {
|
||||
auto@ data = planets.resources.loadExport(file);
|
||||
if(data !is null)
|
||||
resources.insertLast(data);
|
||||
}
|
||||
@claimedChain = planets.resources.loadImport(file);
|
||||
}
|
||||
|
||||
void remove(AI& ai, Planets& planets) {
|
||||
if(claimedChain !is null) {
|
||||
claimedChain.claimedFor = false;
|
||||
@claimedChain = null;
|
||||
}
|
||||
@resources = null;
|
||||
}
|
||||
|
||||
void tick(AI& ai, Planets& planets, double time) {
|
||||
//Deal with losing planet ownership
|
||||
if(obj is null || !obj.valid || obj.owner !is ai.empire) {
|
||||
if(obj.owner !is ai.empire)
|
||||
relationRecordLost(ai, obj.owner, obj);
|
||||
planets.remove(this);
|
||||
return;
|
||||
}
|
||||
|
||||
//Handle when the planet's native resources change
|
||||
if(obj.nativeResourceCount != resources.length || (resources.length != 0 && obj.primaryResourceId != resources[0].resourceId))
|
||||
planets.updateResourceList(obj, resources);
|
||||
|
||||
//Level up resources if we need them
|
||||
if(resources.length != 0 && claimedChain is null) {
|
||||
int resLevel = resources[0].resource.level;
|
||||
if(resLevel > 0 && !resources[0].resource.exportable)
|
||||
resLevel += 1;
|
||||
if(targetLevel < resLevel) {
|
||||
//See if we need it for anything first
|
||||
@claimedChain = planets.resources.findUnclaimed(resources[0]);
|
||||
if(claimedChain !is null)
|
||||
claimedChain.claimedFor = true;
|
||||
|
||||
//Chain the levelup before what needs it
|
||||
planets.requestLevel(this, resLevel, before=claimedChain);
|
||||
}
|
||||
}
|
||||
|
||||
//Request imports if the planet needs to level up
|
||||
if(targetLevel > requestedLevel) {
|
||||
int nextLevel = min(targetLevel, min(obj.resourceLevel, requestedLevel)+1);
|
||||
if(nextLevel != requestedLevel) {
|
||||
planets.resources.organizeImports(obj, nextLevel);
|
||||
requestedLevel = nextLevel;
|
||||
}
|
||||
}
|
||||
else if(targetLevel < requestedLevel) {
|
||||
planets.resources.organizeImports(obj, targetLevel);
|
||||
requestedLevel = targetLevel;
|
||||
}
|
||||
}
|
||||
|
||||
double get_colonizeWeight() {
|
||||
if(obj.isColonizing)
|
||||
return 0.0;
|
||||
if(obj.level == 0)
|
||||
return 0.0;
|
||||
if(!obj.canSafelyColonize)
|
||||
return 0.0;
|
||||
double w = 1.0;
|
||||
double pop = obj.population;
|
||||
double maxPop = obj.maxPopulation;
|
||||
if(pop < maxPop-0.1) {
|
||||
if(obj.resourceLevel > 1 && pop/maxPop < 0.9)
|
||||
return 0.0;
|
||||
w *= 0.01 * (pop / maxPop);
|
||||
}
|
||||
return w;
|
||||
}
|
||||
|
||||
vec2i buildBuilding(AI& ai, Planets& planets, const BuildingType@ type, bool scatter = true) {
|
||||
if(type is null || !type.canBuildOn(obj))
|
||||
return vec2i(-1,-1);
|
||||
|
||||
if(planets.log)
|
||||
ai.print("Attempt to construct "+type.name, obj);
|
||||
|
||||
PlanetSurface@ surface = planets.surface;
|
||||
receive(obj.getPlanetSurface(), surface);
|
||||
|
||||
//Find the best place to build this building
|
||||
int bestPenalty = INT_MAX;
|
||||
int possibs = 0;
|
||||
vec2i best;
|
||||
vec2i center = vec2i(type.getCenter());
|
||||
|
||||
for(int x = 0, w = surface.size.x; x < w; ++x) {
|
||||
for(int y = 0, h = surface.size.y; y < h; ++y) {
|
||||
vec2i pos(x, y);
|
||||
|
||||
bool valid = true;
|
||||
int penalty = 0;
|
||||
|
||||
for(int xoff = 0; xoff < int(type.size.x); ++xoff) {
|
||||
for(int yoff = 0; yoff < int(type.size.y); ++yoff) {
|
||||
vec2i rpos = pos - center + vec2i(xoff, yoff);
|
||||
|
||||
if(rpos.x < 0 || rpos.y < 0 || rpos.x >= w || rpos.y >= h) {
|
||||
valid = false;
|
||||
break;
|
||||
}
|
||||
|
||||
auto@ biome = surface.getBiome(rpos.x, rpos.y);
|
||||
if(biome is null || !biome.buildable) {
|
||||
valid = false;
|
||||
break;
|
||||
}
|
||||
|
||||
uint flags = surface.getFlags(rpos.x, rpos.y);
|
||||
if(flags & SuF_Usable == 0) {
|
||||
bool affinity = false;
|
||||
if(type.buildAffinities.length != 0) {
|
||||
for(uint i = 0, cnt = type.buildAffinities.length; i < cnt; ++i) {
|
||||
if(biome is type.buildAffinities[i].biome) {
|
||||
affinity = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(!affinity && type.tileBuildCost > 0) {
|
||||
penalty += 1;
|
||||
|
||||
if(biome.buildCost > 1.0)
|
||||
penalty += ceil((biome.buildCost - 1.0) / 0.1);
|
||||
}
|
||||
affinity = false;
|
||||
if(type.maintainAffinities.length != 0) {
|
||||
for(uint i = 0, cnt = type.maintainAffinities.length; i < cnt; ++i) {
|
||||
if(biome is type.maintainAffinities[i].biome) {
|
||||
affinity = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(!affinity && type.tileMaintainCost > 0)
|
||||
penalty += 2;
|
||||
}
|
||||
|
||||
auto@ bld = surface.getBuilding(rpos.x, rpos.y);
|
||||
if(bld !is null) {
|
||||
if(bld.type.civilian) {
|
||||
penalty += 2;
|
||||
}
|
||||
else {
|
||||
valid = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(!valid)
|
||||
break;
|
||||
}
|
||||
|
||||
if(valid) {
|
||||
if(penalty < bestPenalty) {
|
||||
possibs = 1;
|
||||
bestPenalty = penalty;
|
||||
best = pos;
|
||||
}
|
||||
else if(penalty == bestPenalty && scatter) {
|
||||
possibs += 1;
|
||||
if(randomd() < 1.0 / double(possibs))
|
||||
best = pos;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(bestPenalty != INT_MAX) {
|
||||
if(planets.log)
|
||||
ai.print("Construct "+type.name+" at "+best+" with penalty "+bestPenalty, obj);
|
||||
obj.buildBuilding(type.id, best);
|
||||
return best;
|
||||
}
|
||||
|
||||
if(planets.log)
|
||||
ai.print("Could not find place to construct "+type.name, obj);
|
||||
return vec2i(-1,-1);
|
||||
}
|
||||
}
|
||||
|
||||
final class PotentialSource {
|
||||
Planet@ pl;
|
||||
double weight = 0;
|
||||
};
|
||||
|
||||
final class AsteroidData {
|
||||
Asteroid@ asteroid;
|
||||
array<ExportData@>@ resources;
|
||||
|
||||
void save(Planets& planets, SaveFile& file) {
|
||||
file << asteroid;
|
||||
|
||||
uint cnt = 0;
|
||||
if(resources !is null)
|
||||
cnt = resources.length;
|
||||
|
||||
file << cnt;
|
||||
for(uint i = 0; i < cnt; ++i)
|
||||
planets.resources.saveExport(file, resources[i]);
|
||||
}
|
||||
|
||||
void load(Planets& planets, SaveFile& file) {
|
||||
file >> asteroid;
|
||||
|
||||
uint cnt = 0;
|
||||
file >> cnt;
|
||||
if(cnt != 0)
|
||||
@resources = array<ExportData@>();
|
||||
for(uint i = 0; i < cnt; ++i) {
|
||||
auto@ res = planets.resources.loadExport(file);
|
||||
if(res !is null)
|
||||
resources.insertLast(res);
|
||||
}
|
||||
}
|
||||
|
||||
bool tick(AI& ai, Planets& planets) {
|
||||
if(asteroid is null || !asteroid.valid || asteroid.owner !is ai.empire) {
|
||||
planets.resources.killImportsTo(asteroid);
|
||||
planets.resources.killResourcesFrom(asteroid);
|
||||
return false;
|
||||
}
|
||||
if(resources is null) {
|
||||
@resources = planets.resources.availableResource(asteroid);
|
||||
}
|
||||
else {
|
||||
if(asteroid.nativeResourceCount != resources.length || (resources.length != 0 && asteroid.primaryResourceId != resources[0].resourceId))
|
||||
planets.updateResourceList(asteroid, resources);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
class Planets : AIComponent {
|
||||
Resources@ resources;
|
||||
Budget@ budget;
|
||||
Systems@ systems;
|
||||
|
||||
PlanetSurface surface;
|
||||
|
||||
array<AsteroidData@> ownedAsteroids;
|
||||
array<PlanetAI@> planets;
|
||||
array<PlanetAI@> bumped;
|
||||
uint planetIdx = 0;
|
||||
|
||||
array<BuildingRequest@> building;
|
||||
int nextBuildingRequestId = 0;
|
||||
|
||||
void create() {
|
||||
@resources = cast<Resources>(ai.resources);
|
||||
@budget = cast<Budget>(ai.budget);
|
||||
@systems = cast<Systems>(ai.systems);
|
||||
}
|
||||
|
||||
void save(SaveFile& file) {
|
||||
file << nextBuildingRequestId;
|
||||
|
||||
uint cnt = planets.length;
|
||||
file << cnt;
|
||||
for(uint i = 0; i < cnt; ++i) {
|
||||
auto@ plAI = planets[i];
|
||||
saveAI(file, plAI);
|
||||
plAI.save(this, file);
|
||||
}
|
||||
|
||||
cnt = building.length;
|
||||
file << cnt;
|
||||
for(uint i = 0; i < cnt; ++i) {
|
||||
saveBuildingRequest(file, building[i]);
|
||||
building[i].save(this, file);
|
||||
}
|
||||
|
||||
cnt = ownedAsteroids.length;
|
||||
file << cnt;
|
||||
for(uint i = 0; i < cnt; ++i)
|
||||
ownedAsteroids[i].save(this, file);
|
||||
}
|
||||
|
||||
void load(SaveFile& file) {
|
||||
file >> nextBuildingRequestId;
|
||||
|
||||
uint cnt = 0;
|
||||
file >> cnt;
|
||||
for(uint i = 0; i < cnt; ++i) {
|
||||
auto@ plAI = loadAI(file);
|
||||
if(plAI !is null)
|
||||
plAI.load(this, file);
|
||||
else
|
||||
PlanetAI().load(this, file);
|
||||
}
|
||||
|
||||
file >> cnt;
|
||||
for(uint i = 0; i < cnt; ++i) {
|
||||
auto@ req = loadBuildingRequest(file);
|
||||
if(req !is null) {
|
||||
req.load(this, file);
|
||||
building.insertLast(req);
|
||||
}
|
||||
}
|
||||
|
||||
file >> cnt;
|
||||
for(uint i = 0; i < cnt; ++i) {
|
||||
AsteroidData data;
|
||||
data.load(this, file);
|
||||
if(data.asteroid !is null)
|
||||
ownedAsteroids.insertLast(data);
|
||||
}
|
||||
}
|
||||
|
||||
PlanetAI@ loadAI(SaveFile& file) {
|
||||
Planet@ obj;
|
||||
file >> obj;
|
||||
|
||||
if(obj is null)
|
||||
return null;
|
||||
|
||||
PlanetAI@ plAI = getAI(obj);
|
||||
if(plAI is null) {
|
||||
@plAI = PlanetAI();
|
||||
@plAI.obj = obj;
|
||||
plAI.prevTick = gameTime;
|
||||
planets.insertLast(plAI);
|
||||
}
|
||||
return plAI;
|
||||
}
|
||||
|
||||
void saveAI(SaveFile& file, PlanetAI@ ai) {
|
||||
Planet@ pl;
|
||||
if(ai !is null)
|
||||
@pl = ai.obj;
|
||||
file << pl;
|
||||
}
|
||||
|
||||
array<BuildingRequest@> loadIds;
|
||||
BuildingRequest@ loadBuildingRequest(int id) {
|
||||
if(id == -1)
|
||||
return null;
|
||||
for(uint i = 0, cnt = loadIds.length; i < cnt; ++i) {
|
||||
if(loadIds[i].id == id)
|
||||
return loadIds[i];
|
||||
}
|
||||
BuildingRequest data;
|
||||
data.id = id;
|
||||
loadIds.insertLast(data);
|
||||
return data;
|
||||
}
|
||||
BuildingRequest@ loadBuildingRequest(SaveFile& file) {
|
||||
int id = -1;
|
||||
file >> id;
|
||||
if(id == -1)
|
||||
return null;
|
||||
else
|
||||
return loadBuildingRequest(id);
|
||||
}
|
||||
void saveBuildingRequest(SaveFile& file, BuildingRequest@ data) {
|
||||
int id = -1;
|
||||
if(data !is null)
|
||||
id = data.id;
|
||||
file << id;
|
||||
}
|
||||
void postLoad(AI& ai) {
|
||||
loadIds.length = 0;
|
||||
}
|
||||
|
||||
void start() {
|
||||
checkForPlanets();
|
||||
}
|
||||
|
||||
void checkForPlanets() {
|
||||
auto@ data = ai.empire.getPlanets();
|
||||
Object@ obj;
|
||||
while(receive(data, obj)) {
|
||||
Planet@ pl = cast<Planet>(obj);
|
||||
if(pl !is null)
|
||||
register(cast<Planet>(obj));
|
||||
}
|
||||
}
|
||||
|
||||
uint roidIdx = 0;
|
||||
void tick(double time) {
|
||||
double curTime = gameTime;
|
||||
|
||||
if(planets.length != 0) {
|
||||
planetIdx = (planetIdx+1) % planets.length;
|
||||
|
||||
auto@ plAI = planets[planetIdx];
|
||||
plAI.tick(ai, this, curTime - plAI.prevTick);
|
||||
plAI.prevTick = curTime;
|
||||
}
|
||||
|
||||
for(int i = bumped.length-1; i >= 0; --i) {
|
||||
auto@ plAI = bumped[i];
|
||||
double tickTime = curTime - plAI.prevTick;
|
||||
if(tickTime != 0) {
|
||||
plAI.tick(ai, this, tickTime);
|
||||
plAI.prevTick = curTime;
|
||||
}
|
||||
}
|
||||
bumped.length = 0;
|
||||
|
||||
if(ownedAsteroids.length != 0) {
|
||||
roidIdx = (roidIdx+1) % ownedAsteroids.length;
|
||||
if(!ownedAsteroids[roidIdx].tick(ai, this))
|
||||
ownedAsteroids.removeAt(roidIdx);
|
||||
}
|
||||
|
||||
//Construct any buildings we are waiting on
|
||||
for(uint i = 0, cnt = building.length; i < cnt; ++i) {
|
||||
if(!building[i].tick(ai, this, time)) {
|
||||
building.removeAt(i);
|
||||
--i; --cnt;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
uint prevCount = 0;
|
||||
double checkTimer = 0;
|
||||
uint sysIdx = 0, ownedIdx = 0;
|
||||
void focusTick(double time) override {
|
||||
//Check for any newly obtained planets
|
||||
uint curCount = ai.empire.planetCount;
|
||||
checkTimer += time;
|
||||
if(curCount != prevCount || checkTimer > 60.0) {
|
||||
checkForPlanets();
|
||||
prevCount = curCount;
|
||||
checkTimer = 0;
|
||||
}
|
||||
|
||||
//Find any asteroids we've gained
|
||||
if(systems.all.length != 0) {
|
||||
sysIdx = (sysIdx+1) % systems.all.length;
|
||||
auto@ sys = systems.all[sysIdx];
|
||||
for(uint i = 0, cnt = sys.asteroids.length; i < cnt; ++i)
|
||||
register(sys.asteroids[i]);
|
||||
}
|
||||
if(systems.owned.length != 0) {
|
||||
ownedIdx = (ownedIdx+1) % systems.owned.length;
|
||||
auto@ sys = systems.owned[ownedIdx];
|
||||
for(uint i = 0, cnt = sys.asteroids.length; i < cnt; ++i)
|
||||
register(sys.asteroids[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void bump(Planet@ pl) {
|
||||
if(pl !is null)
|
||||
bump(getAI(pl));
|
||||
}
|
||||
|
||||
void bump(PlanetAI@ plAI) {
|
||||
if(plAI !is null)
|
||||
bumped.insertLast(plAI);
|
||||
}
|
||||
|
||||
PlanetAI@ getAI(Planet& obj) {
|
||||
for(uint i = 0, cnt = planets.length; i < cnt; ++i) {
|
||||
if(planets[i].obj is obj)
|
||||
return planets[i];
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
PlanetAI@ register(Planet& obj) {
|
||||
PlanetAI@ plAI = getAI(obj);
|
||||
if(plAI is null) {
|
||||
@plAI = PlanetAI();
|
||||
@plAI.obj = obj;
|
||||
plAI.prevTick = gameTime;
|
||||
planets.insertLast(plAI);
|
||||
plAI.init(ai, this);
|
||||
}
|
||||
return plAI;
|
||||
}
|
||||
|
||||
AsteroidData@ register(Asteroid@ obj) {
|
||||
if(obj is null || !obj.valid || obj.owner !is ai.empire)
|
||||
return null;
|
||||
for(uint i = 0, cnt = ownedAsteroids.length; i < cnt; ++i) {
|
||||
if(ownedAsteroids[i].asteroid is obj)
|
||||
return ownedAsteroids[i];
|
||||
}
|
||||
|
||||
AsteroidData data;
|
||||
@data.asteroid = obj;
|
||||
ownedAsteroids.insertLast(data);
|
||||
|
||||
if(log)
|
||||
ai.print("Detected asteroid: "+obj.name, obj.region);
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
void remove(PlanetAI@ plAI) {
|
||||
resources.killImportsTo(plAI.obj);
|
||||
resources.killResourcesFrom(plAI.obj);
|
||||
plAI.remove(ai, this);
|
||||
planets.remove(plAI);
|
||||
bumped.remove(plAI);
|
||||
}
|
||||
|
||||
void requestLevel(PlanetAI@ plAI, int toLevel, ImportData@ before = null) {
|
||||
if(plAI is null)
|
||||
return;
|
||||
plAI.targetLevel = toLevel;
|
||||
if(before !is null) {
|
||||
for(int lv = max(plAI.requestedLevel, 1); lv <= toLevel; ++lv)
|
||||
resources.organizeImports(plAI.obj, lv, before);
|
||||
plAI.requestedLevel = toLevel;
|
||||
}
|
||||
else {
|
||||
bump(plAI);
|
||||
}
|
||||
}
|
||||
|
||||
BuildingRequest@ requestBuilding(PlanetAI@ plAI, const BuildingType@ type, double priority = 1.0, double expire = INFINITY, bool scatter = true, uint moneyType = BT_Development) {
|
||||
if(plAI is null)
|
||||
return null;
|
||||
|
||||
if(log)
|
||||
ai.print("Requested building of type "+type.name, plAI.obj);
|
||||
|
||||
BuildingRequest req(budget, type, priority, moneyType);
|
||||
req.scatter = scatter;
|
||||
req.id = nextBuildingRequestId++;
|
||||
req.expires = gameTime + expire;
|
||||
@req.plAI = plAI;
|
||||
|
||||
building.insertLast(req);
|
||||
return req;
|
||||
}
|
||||
|
||||
bool isBuilding(Planet@ planet, const BuildingType@ type) {
|
||||
for(uint i = 0, cnt = building.length; i < cnt; ++i) {
|
||||
if(building[i].type is type && building[i].plAI.obj is planet)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void getColonizeSources(array<PotentialSource@>& sources) {
|
||||
sources.length = 0;
|
||||
for(uint i = 0, cnt = planets.length; i < cnt; ++i) {
|
||||
auto@ plAI = planets[i];
|
||||
if(!plAI.obj.valid)
|
||||
continue;
|
||||
|
||||
double w = plAI.colonizeWeight;
|
||||
if(w == 0)
|
||||
continue;
|
||||
if(plAI.obj.owner !is ai.empire)
|
||||
continue;
|
||||
|
||||
PotentialSource src;
|
||||
@src.pl = planets[i].obj;
|
||||
src.weight = w;
|
||||
sources.insertLast(src);
|
||||
}
|
||||
}
|
||||
|
||||
array<ExportData@> newResources;
|
||||
array<ExportData@> removedResources;
|
||||
array<Resource> checkResources;
|
||||
void updateResourceList(Object@ obj, array<ExportData@>& resList) {
|
||||
newResources.length = 0;
|
||||
removedResources = resList;
|
||||
|
||||
checkResources.syncFrom(obj.getNativeResources());
|
||||
|
||||
uint nativeCnt = checkResources.length;
|
||||
for(uint i = 0; i < nativeCnt; ++i) {
|
||||
int id = checkResources[i].id;
|
||||
|
||||
bool found = false;
|
||||
for(uint n = 0, ncnt = removedResources.length; n < ncnt; ++n) {
|
||||
if(removedResources[n].resourceId == id) {
|
||||
removedResources.removeAt(n);
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(!found) {
|
||||
auto@ type = checkResources[i].type;
|
||||
auto@ res = resources.availableResource(obj, type, id);
|
||||
|
||||
if(i == 0)
|
||||
resList.insertAt(0, res);
|
||||
else
|
||||
resList.insertLast(res);
|
||||
newResources.insertLast(res);
|
||||
}
|
||||
else if(i == 0 && resList.length > 1 && resList[0].resourceId != id) {
|
||||
for(uint n = 0, ncnt = resList.length; n < ncnt; ++n) {
|
||||
if(resList[n].resourceId == id) {
|
||||
auto@ res = resList[n];
|
||||
resList.removeAt(n);
|
||||
resList.insertAt(0, res);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Get rid of resources we no longer have
|
||||
for(uint i = 0, cnt = removedResources.length; i < cnt; ++i) {
|
||||
resources.removeResource(removedResources[i]);
|
||||
resList.remove(removedResources[i]);
|
||||
}
|
||||
|
||||
//Tell the resources component to try to immediately use the new resources
|
||||
for(uint i = 0, cnt = newResources.length; i < cnt; ++i)
|
||||
resources.checkReplaceCurrent(newResources[i]);
|
||||
}
|
||||
};
|
||||
|
||||
AIComponent@ createPlanets() {
|
||||
return Planets();
|
||||
}
|
||||
Reference in New Issue
Block a user