Lucas de Vries
1551 lines
37 KiB
ActionScript
1551 lines
37 KiB
ActionScript
// Construction
|
|
// ------------
|
|
// Manages factories and allows build requests for flagships, orbitals, and
|
|
// anything else that requires labor.
|
|
//
|
|
|
|
import empire_ai.weasel.WeaselAI;
|
|
import empire_ai.weasel.Budget;
|
|
import empire_ai.weasel.Planets;
|
|
import empire_ai.weasel.Designs;
|
|
import empire_ai.weasel.Resources;
|
|
import empire_ai.weasel.Systems;
|
|
import empire_ai.weasel.Orbitals;
|
|
|
|
import orbitals;
|
|
import saving;
|
|
|
|
import systems;
|
|
import regions.regions;
|
|
|
|
from constructible import ConstructibleType;
|
|
from constructions import ConstructionType, getConstructionType;
|
|
|
|
class AllocateConstruction {
|
|
int id = -1;
|
|
uint moneyType = BT_Development;
|
|
Factory@ tryFactory;
|
|
double maxTime = INFINITY;
|
|
bool completed = false;
|
|
bool started = false;
|
|
double completedAt = 0;
|
|
AllocateBudget@ alloc;
|
|
int cost = 0;
|
|
int maintenance = 0;
|
|
double priority = 1.0;
|
|
|
|
AllocateConstruction() {
|
|
}
|
|
|
|
void _save(Construction& construction, SaveFile& file) {
|
|
file << moneyType;
|
|
construction.saveFactory(file, tryFactory);
|
|
file << maxTime;
|
|
file << completed;
|
|
file << started;
|
|
file << completedAt;
|
|
construction.budget.saveAlloc(file, alloc);
|
|
file << cost;
|
|
file << maintenance;
|
|
file << priority;
|
|
save(construction, file);
|
|
}
|
|
|
|
void save(Construction& construction, SaveFile& file) {
|
|
}
|
|
|
|
void _load(Construction& construction, SaveFile& file) {
|
|
file >> moneyType;
|
|
@tryFactory = construction.loadFactory(file);
|
|
file >> maxTime;
|
|
file >> completed;
|
|
file >> started;
|
|
file >> completedAt;
|
|
@alloc = construction.budget.loadAlloc(file);
|
|
file >> cost;
|
|
file >> maintenance;
|
|
file >> priority;
|
|
load(construction, file);
|
|
}
|
|
|
|
void load(Construction& construction, SaveFile& file) {
|
|
}
|
|
|
|
bool tick(AI& ai, Construction& construction, double time) {
|
|
if(tryFactory !is null && alloc.allocated) {
|
|
construction.start(tryFactory, this);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void update(AI& ai, Factory@ f) {
|
|
@alloc = cast<Budget>(ai.budget).allocate(moneyType, cost, maintenance, priority);
|
|
}
|
|
|
|
double laborCost(AI& ai, Object@ obj) {
|
|
return 0.0;
|
|
}
|
|
|
|
bool canBuild(AI& ai, Factory@ f) {
|
|
return true;
|
|
}
|
|
|
|
void construct(AI& ai, Factory@ f) {
|
|
started = true;
|
|
}
|
|
|
|
string toString() {
|
|
return "construction";
|
|
}
|
|
};
|
|
|
|
class BuildFlagship : AllocateConstruction {
|
|
double baseLabor = 0.0;
|
|
const Design@ design;
|
|
DesignTarget@ target;
|
|
|
|
BuildFlagship() {
|
|
}
|
|
|
|
BuildFlagship(const Design@ dsg) {
|
|
set(dsg);
|
|
}
|
|
|
|
BuildFlagship(DesignTarget@ target) {
|
|
@this.target = target;
|
|
}
|
|
|
|
void save(Construction& construction, SaveFile& file) {
|
|
file << baseLabor;
|
|
if(design !is null) {
|
|
file.write1();
|
|
file << design;
|
|
}
|
|
else {
|
|
file.write0();
|
|
}
|
|
construction.designs.saveDesign(file, target);
|
|
}
|
|
|
|
void load(Construction& construction, SaveFile& file) {
|
|
file >> baseLabor;
|
|
if(file.readBit())
|
|
file >> design;
|
|
@target = construction.designs.loadDesign(file);
|
|
}
|
|
|
|
void set(const Design& dsg) {
|
|
@design = dsg.mostUpdated();
|
|
baseLabor = design.total(HV_LaborCost);
|
|
}
|
|
|
|
double laborCost(AI& ai, Object@ obj) {
|
|
return baseLabor;
|
|
}
|
|
|
|
bool tick(AI& ai, Construction& construction, double time) override {
|
|
if(target !is null) {
|
|
if(target.active !is null) {
|
|
set(target.active);
|
|
@target = null;
|
|
}
|
|
}
|
|
return AllocateConstruction::tick(ai, construction, time);
|
|
}
|
|
|
|
bool canBuild(AI& ai, Factory@ f) override {
|
|
if(!f.obj.canBuildShips)
|
|
return false;
|
|
return design !is null;
|
|
}
|
|
|
|
void update(AI& ai, Factory@ f) {
|
|
double c = design.total(HV_BuildCost);
|
|
c *= double(f.obj.shipBuildCost) / 100.0;
|
|
c *= f.obj.constructionCostMod;
|
|
|
|
cost = ceil(c);
|
|
maintenance = ceil(design.total(HV_MaintainCost));
|
|
|
|
AllocateConstruction::update(ai, f);
|
|
}
|
|
|
|
void construct(AI& ai, Factory@ f) {
|
|
f.obj.buildFlagship(design);
|
|
AllocateConstruction::construct(ai, f);
|
|
}
|
|
|
|
string toString() {
|
|
if(design is null)
|
|
return "flagship (design in progress)";
|
|
return "flagship "+design.name;
|
|
}
|
|
};
|
|
|
|
class BuildFlagshipSourced : BuildFlagship {
|
|
Object@ buildAt;
|
|
Object@ buildFrom;
|
|
|
|
BuildFlagshipSourced() {
|
|
}
|
|
|
|
BuildFlagshipSourced(const Design@ dsg) {
|
|
set(dsg);
|
|
}
|
|
|
|
BuildFlagshipSourced(DesignTarget@ target) {
|
|
@this.target = target;
|
|
}
|
|
|
|
void save(Construction& construction, SaveFile& file) override {
|
|
BuildFlagship::save(construction, file);
|
|
file << buildAt;
|
|
file << buildFrom;
|
|
}
|
|
|
|
void load(Construction& construction, SaveFile& file) override {
|
|
BuildFlagship::load(construction, file);
|
|
file >> buildAt;
|
|
file >> buildFrom;
|
|
}
|
|
|
|
bool canBuild(AI& ai, Factory@ f) override {
|
|
if(buildAt !is null && f.obj !is buildAt)
|
|
return false;
|
|
return BuildFlagship::canBuild(ai, f);
|
|
}
|
|
|
|
void construct(AI& ai, Factory@ f) override {
|
|
f.obj.buildFlagship(design, constructFrom=buildFrom);
|
|
AllocateConstruction::construct(ai, f);
|
|
}
|
|
};
|
|
|
|
class BuildStation : AllocateConstruction {
|
|
double baseLabor = 0.0;
|
|
const Design@ design;
|
|
DesignTarget@ target;
|
|
vec3d position;
|
|
bool local = false;
|
|
|
|
BuildStation() {
|
|
}
|
|
|
|
BuildStation(const Design@ dsg, const vec3d& position) {
|
|
this.position = position;
|
|
set(dsg);
|
|
}
|
|
|
|
BuildStation(DesignTarget@ target, const vec3d& position) {
|
|
this.position = position;
|
|
@this.target = target;
|
|
}
|
|
|
|
BuildStation(const Design@ dsg, bool local) {
|
|
this.local = true;
|
|
set(dsg);
|
|
}
|
|
|
|
BuildStation(DesignTarget@ target, bool local) {
|
|
@this.target = target;
|
|
this.local = true;
|
|
}
|
|
|
|
void save(Construction& construction, SaveFile& file) {
|
|
file << baseLabor;
|
|
file << position;
|
|
file << local;
|
|
if(design !is null) {
|
|
file.write1();
|
|
file << design;
|
|
}
|
|
else {
|
|
file.write0();
|
|
}
|
|
construction.designs.saveDesign(file, target);
|
|
}
|
|
|
|
void load(Construction& construction, SaveFile& file) {
|
|
file >> baseLabor;
|
|
file >> position;
|
|
file >> local;
|
|
if(file.readBit())
|
|
file >> design;
|
|
@target = construction.designs.loadDesign(file);
|
|
}
|
|
|
|
void set(const Design& dsg) {
|
|
@design = dsg.mostUpdated();
|
|
baseLabor = design.total(HV_LaborCost);
|
|
}
|
|
|
|
double laborCost(AI& ai, Object@ obj) {
|
|
double labor = baseLabor;
|
|
|
|
labor *= obj.owner.OrbitalLaborCostFactor;
|
|
|
|
if(!local) {
|
|
Region@ reg = getRegion(position);
|
|
Region@ targReg = obj.region;
|
|
if(reg !is null && targReg !is null) {
|
|
int hops = cast<Systems>(ai.systems).tradeDistance(targReg, reg);
|
|
if(hops > 0) {
|
|
double penalty = 1.0 + config::ORBITAL_LABOR_COST_STEP * double(hops);
|
|
baseLabor *= penalty;
|
|
}
|
|
}
|
|
}
|
|
return labor;
|
|
}
|
|
|
|
bool tick(AI& ai, Construction& construction, double time) override {
|
|
if(target !is null) {
|
|
if(target.active !is null) {
|
|
set(target.active);
|
|
@target = null;
|
|
}
|
|
}
|
|
return AllocateConstruction::tick(ai, construction, time);
|
|
}
|
|
|
|
bool canBuild(AI& ai, Factory@ f) override {
|
|
if(design is null)
|
|
return false;
|
|
if(!f.obj.canBuildOrbitals)
|
|
return false;
|
|
Region@ targReg = f.obj.region;
|
|
if(targReg is null)
|
|
return false;
|
|
if(!local) {
|
|
Region@ reg = getRegion(position);
|
|
if(reg is null)
|
|
return false;
|
|
if(!cast<Systems>(ai.systems).canTrade(targReg, reg))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void update(AI& ai, Factory@ f) {
|
|
double c = design.total(HV_BuildCost);
|
|
c *= f.obj.owner.OrbitalBuildCostFactor;
|
|
c *= f.obj.constructionCostMod;
|
|
|
|
cost = ceil(c);
|
|
maintenance = ceil(design.total(HV_MaintainCost));
|
|
|
|
AllocateConstruction::update(ai, f);
|
|
}
|
|
|
|
void construct(AI& ai, Factory@ f) {
|
|
if(local) {
|
|
position = f.obj.position;
|
|
vec2d offset = random2d(f.obj.radius + 10.0, f.obj.radius + 100.0);
|
|
position.x += offset.x;
|
|
position.z += offset.y;
|
|
}
|
|
f.obj.buildStation(design, position);
|
|
AllocateConstruction::construct(ai, f);
|
|
}
|
|
|
|
string toString() {
|
|
if(design is null)
|
|
return "station (design in progress)";
|
|
return "station "+design.name;
|
|
}
|
|
};
|
|
|
|
class BuildOrbital : AllocateConstruction {
|
|
double baseLabor = 0.0;
|
|
const OrbitalModule@ module;
|
|
bool local = false;
|
|
vec3d position;
|
|
|
|
BuildOrbital() {
|
|
}
|
|
|
|
BuildOrbital(const OrbitalModule@ module, const vec3d& position) {
|
|
this.position = position;
|
|
@this.module = module;
|
|
baseLabor = module.laborCost;
|
|
}
|
|
|
|
BuildOrbital(const OrbitalModule@ module, bool local) {
|
|
this.local = true;
|
|
@this.module = module;
|
|
baseLabor = module.laborCost;
|
|
}
|
|
|
|
void save(Construction& construction, SaveFile& file) {
|
|
file << baseLabor;
|
|
file << position;
|
|
file << local;
|
|
file.writeIdentifier(SI_Orbital, module.id);
|
|
}
|
|
|
|
void load(Construction& construction, SaveFile& file) {
|
|
file >> baseLabor;
|
|
file >> position;
|
|
file >> local;
|
|
@module = getOrbitalModule(file.readIdentifier(SI_Orbital));
|
|
}
|
|
|
|
double laborCost(AI& ai, Object@ obj) {
|
|
double labor = baseLabor;
|
|
|
|
labor *= obj.owner.OrbitalLaborCostFactor;
|
|
|
|
if(!local) {
|
|
Region@ reg = getRegion(position);
|
|
Region@ targReg = obj.region;
|
|
if(reg !is null && targReg !is null) {
|
|
int hops = cast<Systems>(ai.systems).tradeDistance(targReg, reg);
|
|
if(hops > 0) {
|
|
double penalty = 1.0 + config::ORBITAL_LABOR_COST_STEP * double(hops);
|
|
baseLabor *= penalty;
|
|
}
|
|
}
|
|
}
|
|
return labor;
|
|
}
|
|
|
|
bool tick(AI& ai, Construction& construction, double time) override {
|
|
return AllocateConstruction::tick(ai, construction, time);
|
|
}
|
|
|
|
bool canBuild(AI& ai, Factory@ f) override {
|
|
if(module is null)
|
|
return false;
|
|
if(!f.obj.canBuildOrbitals)
|
|
return false;
|
|
Region@ targReg = f.obj.region;
|
|
if(targReg is null)
|
|
return false;
|
|
if(!local) {
|
|
Region@ reg = getRegion(position);
|
|
if(reg is null)
|
|
return false;
|
|
if(!cast<Systems>(ai.systems).canTrade(targReg, reg))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void update(AI& ai, Factory@ f) {
|
|
double c = module.buildCost;
|
|
c *= f.obj.owner.OrbitalBuildCostFactor;
|
|
c *= f.obj.constructionCostMod;
|
|
|
|
cost = ceil(c);
|
|
maintenance = module.maintenance;
|
|
|
|
AllocateConstruction::update(ai, f);
|
|
}
|
|
|
|
void construct(AI& ai, Factory@ f) {
|
|
if(local) {
|
|
position = f.obj.position;
|
|
vec2d offset = random2d(f.obj.radius + 10.0, f.obj.radius + 100.0);
|
|
position.x += offset.x;
|
|
position.z += offset.y;
|
|
}
|
|
f.obj.buildOrbital(module.id, position);
|
|
AllocateConstruction::construct(ai, f);
|
|
}
|
|
|
|
string toString() {
|
|
return "orbital "+module.name;
|
|
}
|
|
};
|
|
|
|
class RetrofitShip : AllocateConstruction {
|
|
Ship@ ship;
|
|
double labor;
|
|
|
|
RetrofitShip() {
|
|
}
|
|
|
|
RetrofitShip(Ship@ ship) {
|
|
@this.ship = ship;
|
|
labor = ship.getRetrofitLabor();
|
|
cost = ship.getRetrofitCost();
|
|
}
|
|
|
|
void save(Construction& construction, SaveFile& file) {
|
|
file << ship;
|
|
file << labor;
|
|
}
|
|
|
|
void load(Construction& construction, SaveFile& file) {
|
|
file >> ship;
|
|
file >> labor;
|
|
}
|
|
|
|
double laborCost(AI& ai, Object@ obj) {
|
|
return labor;
|
|
}
|
|
|
|
bool canBuild(AI& ai, Factory@ f) override {
|
|
if(!f.obj.canBuildShips)
|
|
return false;
|
|
Region@ reg = ship.region;
|
|
return reg !is null && reg is f.obj.region;
|
|
}
|
|
|
|
void construct(AI& ai, Factory@ f) {
|
|
ship.retrofitFleetAt(f.obj);
|
|
AllocateConstruction::construct(ai, f);
|
|
}
|
|
|
|
string toString() {
|
|
return "retrofit "+ship.name;
|
|
}
|
|
};
|
|
|
|
class BuildConstruction : AllocateConstruction {
|
|
const ConstructionType@ consType;
|
|
|
|
BuildConstruction() {
|
|
}
|
|
|
|
BuildConstruction(const ConstructionType@ consType) {
|
|
@this.consType = consType;
|
|
}
|
|
|
|
void save(Construction& construction, SaveFile& file) {
|
|
file.writeIdentifier(SI_ConstructionType, consType.id);
|
|
}
|
|
|
|
void load(Construction& construction, SaveFile& file) {
|
|
@consType = getConstructionType(file.readIdentifier(SI_ConstructionType));
|
|
}
|
|
|
|
double laborCost(AI& ai, Object@ obj) {
|
|
if(obj is null)
|
|
return consType.laborCost;
|
|
return consType.getLaborCost(obj);
|
|
}
|
|
|
|
bool canBuild(AI& ai, Factory@ f) override {
|
|
return consType.canBuild(f.obj, ignoreCost=true);
|
|
}
|
|
|
|
void update(AI& ai, Factory@ f) {
|
|
cost = consType.getBuildCost(f.obj);
|
|
maintenance = consType.getMaintainCost(f.obj);
|
|
|
|
AllocateConstruction::update(ai, f);
|
|
}
|
|
|
|
void construct(AI& ai, Factory@ f) {
|
|
f.obj.buildConstruction(consType.id);
|
|
AllocateConstruction::construct(ai, f);
|
|
}
|
|
|
|
string toString() {
|
|
return "construction "+consType.name;
|
|
}
|
|
};
|
|
|
|
class Factory {
|
|
Object@ obj;
|
|
PlanetAI@ plAI;
|
|
|
|
Factory@ exportingTo;
|
|
|
|
AllocateConstruction@ active;
|
|
double laborAim = 0.0;
|
|
double laborIncome = 0.0;
|
|
|
|
double idleSince = 0.0;
|
|
double storedLabor = 0.0;
|
|
double laborMaxStorage = 0.0;
|
|
double buildingPenalty = 0.0;
|
|
|
|
bool needsSupportLabor = false;
|
|
double waitingSupportLabor = 0.0;
|
|
uint curConstructionType = 0;
|
|
bool valid = true;
|
|
bool significantLabor = true;
|
|
|
|
uint backgrounded = 0;
|
|
Asteroid@ bgAsteroid;
|
|
|
|
BuildingRequest@ curBuilding;
|
|
ImportData@ curImport;
|
|
|
|
void save(Construction& construction, SaveFile& file) {
|
|
construction.planets.saveAI(file, plAI);
|
|
construction.saveConstruction(file, active);
|
|
file << laborAim;
|
|
file << laborIncome;
|
|
file << idleSince;
|
|
file << storedLabor;
|
|
file << laborMaxStorage;
|
|
file << buildingPenalty;
|
|
construction.planets.saveBuildingRequest(file, curBuilding);
|
|
construction.resources.saveImport(file, curImport);
|
|
file << backgrounded;
|
|
file << bgAsteroid;
|
|
file << curConstructionType;
|
|
file << valid;
|
|
file << needsSupportLabor;
|
|
file << waitingSupportLabor;
|
|
construction.saveFactory(file, exportingTo);
|
|
}
|
|
|
|
void load(Construction& construction, SaveFile& file) {
|
|
@plAI = construction.planets.loadAI(file);
|
|
@active = construction.loadConstruction(file);
|
|
file >> laborAim;
|
|
file >> laborIncome;
|
|
file >> idleSince;
|
|
file >> storedLabor;
|
|
file >> laborMaxStorage;
|
|
file >> buildingPenalty;
|
|
@curBuilding = construction.planets.loadBuildingRequest(file);
|
|
@curImport = construction.resources.loadImport(file);
|
|
file >> backgrounded;
|
|
file >> bgAsteroid;
|
|
file >> curConstructionType;
|
|
file >> valid;
|
|
file >> needsSupportLabor;
|
|
file >> waitingSupportLabor;
|
|
@exportingTo = construction.loadFactory(file);
|
|
}
|
|
|
|
bool get_busy() {
|
|
return active !is null;
|
|
}
|
|
|
|
bool get_needsLabor() {
|
|
if(!valid)
|
|
return false;
|
|
if(obj.hasOrderedSupports)
|
|
return true;
|
|
if(active !is null)
|
|
return true;
|
|
if(needsSupportLabor)
|
|
return true;
|
|
if(obj.constructionCount > 0 && curConstructionType != CT_Export)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
double laborToBear(AI& ai) {
|
|
return laborIncome * ai.behavior.constructionMaxTime + storedLabor;
|
|
}
|
|
|
|
bool viable(AI& ai, AllocateConstruction@ alloc) {
|
|
double labor = obj.laborIncome;
|
|
double estTime = (alloc.laborCost(ai, obj) - storedLabor) / labor;
|
|
if(estTime > alloc.maxTime)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool tick(AI& ai, Construction& construction, double time) {
|
|
if(obj is null || !obj.valid || obj.owner !is ai.empire) {
|
|
valid = false;
|
|
return false;
|
|
}
|
|
|
|
uint curCount = obj.constructionCount;
|
|
curConstructionType = 0;
|
|
bool isBackground = false;
|
|
if(curCount != 0) {
|
|
curConstructionType = obj.constructionType;
|
|
isBackground = curConstructionType == CT_Asteroid || curConstructionType == CT_Export;
|
|
}
|
|
if(active !is null) {
|
|
if(curCount <= backgrounded || (curCount == 1 && isBackground)) {
|
|
if(construction.log)
|
|
ai.print("Completed construction of "+active.toString()+" "+backgrounded+" / "+curCount, obj);
|
|
active.completed = true;
|
|
active.completedAt = gameTime;
|
|
@active = null;
|
|
idleSince = gameTime;
|
|
backgrounded = 0;
|
|
}
|
|
}
|
|
else {
|
|
if(curCount < backgrounded) {
|
|
backgrounded = curCount;
|
|
}
|
|
}
|
|
|
|
//Background constructibles we don't need to do right now
|
|
if(curCount > 1 && curConstructionType == CT_Asteroid && bgAsteroid !is null) {
|
|
obj.moveConstruction(obj.constructionID[0], -1);
|
|
backgrounded += 1;
|
|
}
|
|
if(curCount > 1 && curConstructionType == CT_Export && exportingTo !is null) {
|
|
obj.cancelConstruction(obj.constructionID[0]);
|
|
@exportingTo = null;
|
|
}
|
|
if(bgAsteroid !is null && (bgAsteroid.owner.valid || curCount == 0)) {
|
|
if(bgAsteroid.owner is ai.empire)
|
|
construction.planets.register(bgAsteroid);
|
|
@bgAsteroid = null;
|
|
}
|
|
|
|
//Build warehouse(s) if we've been idle
|
|
laborIncome = obj.laborIncome;
|
|
storedLabor = obj.currentLaborStored;
|
|
laborMaxStorage = obj.laborStorageCapacity;
|
|
significantLabor = laborIncome >= 0.4 * construction.bestLabor && obj.baseLaborIncome > 4.0/60.0;
|
|
if(storedLabor < laborMaxStorage)
|
|
idleSince = gameTime;
|
|
if(active is null && curBuilding is null && plAI !is null && gameTime - idleSince > ai.behavior.laborStoreIdleTimer && ai.behavior.buildLaborStorage && (laborMaxStorage+50) < ai.behavior.laborStoreMaxFillTime * max(obj.baseLaborIncome, laborAim) && significantLabor) {
|
|
auto@ bld = ai.defs.LaborStorage;
|
|
if(bld !is null && buildingPenalty < gameTime) {
|
|
if(construction.log)
|
|
ai.print("Build building "+bld.name+" for labor storage", obj);
|
|
|
|
@curBuilding = construction.planets.requestBuilding(plAI, bld);
|
|
}
|
|
}
|
|
|
|
//Remove waits on completed labor gains
|
|
if(curBuilding !is null) {
|
|
if(curBuilding.canceled || (curBuilding.built && curBuilding.getProgress() >= 1.0)) {
|
|
if(construction.log)
|
|
ai.print("Building construction for labor finished", obj);
|
|
if(curBuilding.canceled)
|
|
buildingPenalty = gameTime + 60.0;
|
|
@curBuilding = null;
|
|
}
|
|
}
|
|
if(curImport !is null) {
|
|
if(curImport.beingMet) {
|
|
if(construction.log)
|
|
ai.print("Resource import for labor finished", obj);
|
|
@curImport = null;
|
|
}
|
|
}
|
|
|
|
//See if we need a new labor gain
|
|
if(laborIncome < laborAim) {
|
|
if(curImport is null && plAI !is null && obj.isPressureSaturated(TR_Labor) && obj.pressureCap < uint(obj.totalPressure) && gameTime > 6.0 * 60.0 && ai.behavior.buildFactoryForLabor) {
|
|
ResourceSpec spec;
|
|
spec.type = RST_Pressure_Level0;
|
|
spec.pressureType = TR_Labor;
|
|
|
|
if(construction.log)
|
|
ai.print("Queue resource import for labor", obj);
|
|
|
|
@curImport = construction.resources.requestResource(obj, spec, prioritize=true);
|
|
}
|
|
if(curBuilding is null && plAI !is null && ai.behavior.buildLaborStorage) {
|
|
auto@ bld = ai.defs.Factory;
|
|
if(bld !is null && buildingPenalty < gameTime) {
|
|
if(construction.log)
|
|
ai.print("Build building "+bld.name+" for labor", obj);
|
|
|
|
@curBuilding = construction.planets.requestBuilding(plAI, bld);
|
|
}
|
|
}
|
|
}
|
|
|
|
//See if we should spend our labor on a labor export somewhere else
|
|
if(exportingTo !is null && curConstructionType == CT_Export) {
|
|
if(!exportingTo.valid || (!exportingTo.needsLabor && exportingTo !is construction.primaryFactory)) {
|
|
obj.cancelConstruction(obj.constructionID[0]);
|
|
@exportingTo = null;
|
|
}
|
|
}
|
|
if(ai.behavior.distributeLaborExports) {
|
|
if(curCount == 0 && obj.canExportLabor) {
|
|
uint offset = randomi(0, construction.factories.length-1);
|
|
for(uint i = 0, cnt = construction.factories.length; i < cnt; ++i) {
|
|
auto@ other = construction.factories[(i+offset) % cnt];
|
|
if(other is this)
|
|
continue;
|
|
if(!other.obj.canImportLabor)
|
|
continue;
|
|
|
|
//Check if this is currently busy
|
|
if(other !is construction.primaryFactory) {
|
|
if(!other.needsLabor)
|
|
continue;
|
|
}
|
|
|
|
obj.exportLaborTo(other.obj);
|
|
@exportingTo = other;
|
|
}
|
|
}
|
|
}
|
|
|
|
//See if we should spend our labor trying to build an asteroid
|
|
if(ai.behavior.backgroundBuildAsteroids) {
|
|
if((curCount == 0 || (curConstructionType == CT_Export && curCount == 1)) && storedLabor >= laborMaxStorage * 0.5 && obj.canBuildAsteroids) {
|
|
Asteroid@ roid = construction.getBackgroundAsteroid(this);
|
|
if(roid !is null) {
|
|
uint resCount = roid.getAvailableCount();
|
|
if(resCount != 0) {
|
|
uint bestIndex = 0;
|
|
int bestId = -1;
|
|
double bestWeight = 0.0;
|
|
|
|
if(ai.behavior.chooseAsteroidResource) {
|
|
for(uint i = 0; i < resCount; ++i) {
|
|
int resourceId = roid.getAvailable(i);
|
|
double w = asteroidResourceValue(getResource(resourceId));
|
|
if(w > bestWeight) {
|
|
bestWeight = w;
|
|
bestId = resourceId;
|
|
bestIndex = i;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
bestIndex = randomi(0, resCount-1);
|
|
bestId = roid.getAvailable(bestIndex);
|
|
}
|
|
|
|
double laborCost = roid.getAvailableCost(bestIndex);
|
|
|
|
Region@ fromReg = obj.region;
|
|
Region@ toReg = roid.region;
|
|
if(fromReg !is null && toReg !is null)
|
|
laborCost *= 1.0 + config::ASTEROID_COST_STEP * double(construction.systems.hopDistance(fromReg, toReg));
|
|
|
|
double timeTaken = laborIncome / laborCost;
|
|
if(timeTaken < ai.behavior.constructionMaxTime || storedLabor >= laborMaxStorage * 0.95) {
|
|
@bgAsteroid = roid;
|
|
obj.buildAsteroid(roid, bestId);
|
|
|
|
if(construction.log)
|
|
ai.print("Use background labor to mine "+roid.name+" in "+roid.region.name, obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void aimForLabor(double labor) {
|
|
if(labor > laborAim)
|
|
laborAim = labor;
|
|
}
|
|
};
|
|
|
|
class Construction : AIComponent {
|
|
array<Factory@> factories;
|
|
Factory@ primaryFactory;
|
|
double noFactoryTimer = 0.0;
|
|
|
|
int nextAllocId = 0;
|
|
array<AllocateConstruction@> allocations;
|
|
|
|
double totalLabor = 0.0;
|
|
double bestLabor = 0.0;
|
|
|
|
BuildOrbital@ buildConsolidate;
|
|
|
|
Budget@ budget;
|
|
Planets@ planets;
|
|
Orbitals@ orbitals;
|
|
Resources@ resources;
|
|
Designs@ designs;
|
|
Systems@ systems;
|
|
|
|
void create() {
|
|
@budget = cast<Budget>(ai.budget);
|
|
@planets = cast<Planets>(ai.planets);
|
|
@resources = cast<Resources>(ai.resources);
|
|
@designs = cast<Designs>(ai.designs);
|
|
@systems = cast<Systems>(ai.systems);
|
|
@orbitals = cast<Orbitals>(ai.orbitals);
|
|
}
|
|
|
|
void save(SaveFile& file) {
|
|
file << nextAllocId;
|
|
|
|
uint cnt = allocations.length;
|
|
file << cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
saveConstruction(file, allocations[i]);
|
|
|
|
cnt = factories.length;
|
|
file << cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
saveFactory(file, factories[i]);
|
|
factories[i].save(this, file);
|
|
}
|
|
|
|
saveFactory(file, primaryFactory);
|
|
file << noFactoryTimer;
|
|
|
|
saveConstruction(file, buildConsolidate);
|
|
}
|
|
|
|
void load(SaveFile& file) {
|
|
file >> nextAllocId;
|
|
|
|
uint cnt = 0;
|
|
file >> cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
auto@ alloc = loadConstruction(file);
|
|
if(alloc !is null)
|
|
allocations.insertLast(alloc);
|
|
}
|
|
|
|
file >> cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
Factory@ f = loadFactory(file);
|
|
if(f !is null)
|
|
f.load(this, file);
|
|
else
|
|
Factory().load(this, file);
|
|
}
|
|
|
|
@primaryFactory = loadFactory(file);
|
|
file >> noFactoryTimer;
|
|
|
|
@buildConsolidate = cast<BuildOrbital>(loadConstruction(file));
|
|
}
|
|
|
|
void saveFactory(SaveFile& file, Factory@ f) {
|
|
if(f !is null) {
|
|
file.write1();
|
|
file << f.obj;
|
|
}
|
|
else {
|
|
file.write0();
|
|
}
|
|
}
|
|
|
|
Factory@ loadFactory(SaveFile& file) {
|
|
if(!file.readBit())
|
|
return null;
|
|
|
|
Object@ obj;
|
|
file >> obj;
|
|
|
|
if(obj is null)
|
|
return null;
|
|
|
|
for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
|
|
if(factories[i].obj is obj)
|
|
return factories[i];
|
|
}
|
|
|
|
Factory f;
|
|
@f.obj = obj;
|
|
factories.insertLast(f);
|
|
return f;
|
|
}
|
|
|
|
array<AllocateConstruction@> savedConstructions;
|
|
array<AllocateConstruction@> loadedConstructions;
|
|
void postSave(AI& ai) {
|
|
savedConstructions.length = 0;
|
|
}
|
|
void postLoad(AI& ai) {
|
|
loadedConstructions.length = 0;
|
|
}
|
|
|
|
void saveConstruction(SaveFile& file, AllocateConstruction@ alloc) {
|
|
if(alloc is null) {
|
|
file.write0();
|
|
return;
|
|
}
|
|
|
|
file.write1();
|
|
file << alloc.id;
|
|
if(alloc.id == -1) {
|
|
storeConstruction(file, alloc);
|
|
}
|
|
else {
|
|
bool found = false;
|
|
for(uint i = 0, cnt = savedConstructions.length; i < cnt; ++i) {
|
|
if(savedConstructions[i] is alloc) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!found) {
|
|
storeConstruction(file, alloc);
|
|
savedConstructions.insertLast(alloc);
|
|
}
|
|
}
|
|
}
|
|
|
|
AllocateConstruction@ loadConstruction(SaveFile& file) {
|
|
if(!file.readBit())
|
|
return null;
|
|
|
|
int id = 0;
|
|
file >> id;
|
|
if(id == -1) {
|
|
AllocateConstruction@ alloc = createConstruction(file);
|
|
alloc.id = id;
|
|
return alloc;
|
|
}
|
|
else {
|
|
for(uint i = 0, cnt = loadedConstructions.length; i < cnt; ++i) {
|
|
if(loadedConstructions[i].id == id)
|
|
return loadedConstructions[i];
|
|
}
|
|
|
|
AllocateConstruction@ alloc = createConstruction(file);
|
|
alloc.id = id;
|
|
loadedConstructions.insertLast(alloc);
|
|
return alloc;
|
|
}
|
|
}
|
|
|
|
void storeConstruction(SaveFile& file, AllocateConstruction@ alloc) {
|
|
auto@ cls = getClass(alloc);
|
|
auto@ mod = cls.module;
|
|
|
|
file << mod.name;
|
|
file << cls.name;
|
|
alloc._save(this, file);
|
|
}
|
|
|
|
AllocateConstruction@ createConstruction(SaveFile& file) {
|
|
string modName;
|
|
string clsName;
|
|
|
|
file >> modName;
|
|
file >> clsName;
|
|
|
|
auto@ mod = getScriptModule(modName);
|
|
if(mod is null) {
|
|
error("ERROR: AI Load could not find module for alloc "+modName+"::"+clsName);
|
|
return null;
|
|
}
|
|
|
|
auto@ cls = mod.getClass(clsName);
|
|
if(cls is null) {
|
|
error("ERROR: AI Load could not find class for alloc "+modName+"::"+clsName);
|
|
return null;
|
|
}
|
|
|
|
auto@ alloc = cast<AllocateConstruction>(cls.create());
|
|
if(alloc is null) {
|
|
error("ERROR: AI Load could not create class instance for alloc "+modName+"::"+clsName);
|
|
return null;
|
|
}
|
|
|
|
alloc._load(this, file);
|
|
return alloc;
|
|
}
|
|
|
|
void start() {
|
|
Object@ hw = ai.empire.Homeworld;
|
|
if(hw !is null) {
|
|
Factory f;
|
|
@f.obj = hw;
|
|
@f.plAI = planets.getAI(cast<Planet>(hw));
|
|
|
|
factories.insertLast(f);
|
|
}
|
|
}
|
|
|
|
Factory@ get(Object@ obj) {
|
|
for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
|
|
if(factories[i].obj is obj)
|
|
return factories[i];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
Factory@ registerFactory(Object@ obj) {
|
|
for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
|
|
if(factories[i].obj is obj)
|
|
return factories[i];
|
|
}
|
|
Factory f;
|
|
@f.obj = obj;
|
|
factories.insertLast(f);
|
|
return f;
|
|
}
|
|
|
|
Factory@ getFactory(Region@ region) {
|
|
Factory@ best;
|
|
double bestLabor = 0;
|
|
for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
|
|
if(factories[i].obj.region !is region)
|
|
continue;
|
|
double l = factories[i].obj.laborIncome;
|
|
if(l > bestLabor) {
|
|
bestLabor = l;
|
|
@best = factories[i];
|
|
}
|
|
}
|
|
return best;
|
|
}
|
|
|
|
BuildConstruction@ buildConstruction(const ConstructionType@ type, double priority = 1.0, bool force = false, uint moneyType = BT_Development) {
|
|
//Potentially build a flagship
|
|
BuildConstruction f(type);
|
|
f.moneyType = moneyType;
|
|
f.priority = priority;
|
|
build(f, force=force);
|
|
return f;
|
|
}
|
|
|
|
BuildFlagship@ buildFlagship(const Design@ dsg, double priority = 1.0, bool force = false) {
|
|
//Potentially build a flagship
|
|
BuildFlagship f(dsg);
|
|
f.moneyType = BT_Military;
|
|
f.priority = priority;
|
|
build(f, force=force);
|
|
return f;
|
|
}
|
|
|
|
BuildFlagship@ buildFlagship(DesignTarget@ target, double priority = 1.0, bool force = false) {
|
|
//Potentially build a flagship
|
|
BuildFlagship f(target);
|
|
f.moneyType = BT_Military;
|
|
f.priority = priority;
|
|
build(f, force=force);
|
|
return f;
|
|
}
|
|
|
|
BuildStation@ buildStation(const Design@ dsg, const vec3d& position, double priority = 1.0, bool force = false) {
|
|
//Potentially build a flagship
|
|
BuildStation f(dsg, position);
|
|
f.moneyType = BT_Military;
|
|
f.priority = priority;
|
|
build(f, force=force);
|
|
return f;
|
|
}
|
|
|
|
BuildStation@ buildStation(DesignTarget@ target, const vec3d& position, double priority = 1.0, bool force = false) {
|
|
//Potentially build a flagship
|
|
BuildStation f(target, position);
|
|
f.moneyType = BT_Military;
|
|
f.priority = priority;
|
|
build(f, force=force);
|
|
return f;
|
|
}
|
|
|
|
BuildOrbital@ buildOrbital(const OrbitalModule@ module, const vec3d& position, double priority = 1.0, bool force = false) {
|
|
//Potentially build a flagship
|
|
BuildOrbital f(module, position);
|
|
f.moneyType = BT_Military;
|
|
f.priority = priority;
|
|
build(f, force=force);
|
|
return f;
|
|
}
|
|
|
|
BuildStation@ buildLocalStation(const Design@ dsg, double priority = 1.0, bool force = false) {
|
|
//Potentially build a flagship
|
|
BuildStation f(dsg, local=true);
|
|
f.moneyType = BT_Military;
|
|
f.priority = priority;
|
|
build(f, force=force);
|
|
return f;
|
|
}
|
|
|
|
BuildStation@ buildLocalStation(DesignTarget@ target, double priority = 1.0, bool force = false) {
|
|
//Potentially build a flagship
|
|
BuildStation f(target, local=true);
|
|
f.moneyType = BT_Military;
|
|
f.priority = priority;
|
|
build(f, force=force);
|
|
return f;
|
|
}
|
|
|
|
BuildOrbital@ buildLocalOrbital(const OrbitalModule@ module, double priority = 1.0, bool force = false) {
|
|
//Potentially build a flagship
|
|
BuildOrbital f(module, local=true);
|
|
f.moneyType = BT_Military;
|
|
f.priority = priority;
|
|
build(f, force=force);
|
|
return f;
|
|
}
|
|
|
|
RetrofitShip@ retrofit(Ship@ ship, double priority = 1.0, bool force = false) {
|
|
//Potentially build a flagship
|
|
RetrofitShip f(ship);
|
|
f.moneyType = BT_Military;
|
|
f.priority = priority;
|
|
build(f, force=force);
|
|
return f;
|
|
}
|
|
|
|
AllocateConstruction@ build(AllocateConstruction@ alloc, bool force = false) {
|
|
//Add a construction into the potential constructions queue
|
|
if(!force)
|
|
alloc.maxTime = ai.behavior.constructionMaxTime;
|
|
alloc.id = nextAllocId++;
|
|
allocations.insertLast(alloc);
|
|
|
|
if(log)
|
|
ai.print("Queue construction: "+alloc.toString());
|
|
|
|
return alloc;
|
|
}
|
|
|
|
AllocateConstruction@ buildNow(AllocateConstruction@ alloc, Factory@ f) {
|
|
if(f.busy)
|
|
return null;
|
|
if(alloc.alloc !is null)
|
|
budget.applyNow(alloc.alloc);
|
|
start(f, alloc);
|
|
allocations.remove(alloc);
|
|
return alloc;
|
|
}
|
|
|
|
void cancel(AllocateConstruction@ alloc) {
|
|
if(alloc.started || (alloc.alloc !is null && alloc.alloc.allocated))
|
|
return; //TODO
|
|
|
|
allocations.remove(alloc);
|
|
for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
|
|
if(factories[i].active is alloc)
|
|
@factories[i].active = null;
|
|
}
|
|
|
|
if(alloc.alloc !is null)
|
|
budget.remove(alloc.alloc);
|
|
}
|
|
|
|
uint factInd = 0;
|
|
void tick(double time) {
|
|
//Manage factories
|
|
if(factories.length != 0) {
|
|
factInd = (factInd+1) % factories.length;
|
|
auto@ f = factories[factInd];
|
|
if(!f.tick(ai, this, time))
|
|
factories.removeAt(factInd);
|
|
}
|
|
}
|
|
|
|
void start(Factory@ f, AllocateConstruction@ c) {
|
|
//Actually construct something we've allocated budget for
|
|
@f.active = c;
|
|
@c.tryFactory = null;
|
|
|
|
c.construct(ai, f);
|
|
|
|
if(log)
|
|
ai.print("Construct: "+c.toString(), f.obj);
|
|
|
|
for(uint i = 0, cnt = allocations.length; i < cnt; ++i) {
|
|
if(allocations[i].tryFactory is f)
|
|
@allocations[i].tryFactory = null;
|
|
}
|
|
}
|
|
|
|
uint plCheck = 0;
|
|
uint orbCheck = 0;
|
|
double consTimer = 0.0;
|
|
void focusTick(double time) {
|
|
//Progress the allocations
|
|
for(uint n = 0, ncnt = allocations.length; n < ncnt; ++n) {
|
|
if(!allocations[n].tick(ai, this, time)) {
|
|
allocations.removeAt(n);
|
|
--n; --ncnt;
|
|
}
|
|
}
|
|
|
|
//See if anything we can potentially construct is constructible
|
|
totalLabor = 0.0;
|
|
bestLabor = 0.0;
|
|
for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
|
|
auto@ f = factories[i];
|
|
totalLabor += f.laborIncome;
|
|
if(f.laborIncome > bestLabor)
|
|
bestLabor = f.laborIncome;
|
|
}
|
|
|
|
for(uint n = 0, ncnt = allocations.length; n < ncnt; ++n) {
|
|
auto@ alloc = allocations[n];
|
|
if(alloc.tryFactory !is null)
|
|
continue;
|
|
|
|
Factory@ bestFact;
|
|
double bestCur = 0.0;
|
|
|
|
for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
|
|
auto@ f = factories[i];
|
|
if(f.busy)
|
|
continue;
|
|
if(!alloc.canBuild(ai, f))
|
|
continue;
|
|
if(!f.viable(ai, alloc))
|
|
continue;
|
|
|
|
double w = f.laborIncome;
|
|
if(f is primaryFactory)
|
|
w *= 1.5;
|
|
if(f.exportingTo !is null)
|
|
w /= 0.75;
|
|
|
|
if(w > bestCur) {
|
|
bestCur = w;
|
|
@bestFact = f;
|
|
}
|
|
}
|
|
|
|
if(bestFact !is null) {
|
|
@alloc.tryFactory = bestFact;
|
|
alloc.update(ai, bestFact);
|
|
}
|
|
}
|
|
|
|
//Classify our primary factory
|
|
if(primaryFactory is null) {
|
|
//Find our best factory
|
|
Factory@ best;
|
|
double bestWeight = 0.0;
|
|
for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
|
|
auto@ f = factories[i];
|
|
|
|
double w = f.laborIncome;
|
|
w += 0.1 * f.laborAim;
|
|
if(f.obj.isPlanet)
|
|
w *= 100.0;
|
|
if(f.obj.isShip)
|
|
w *= 0.1;
|
|
|
|
if(w > bestWeight) {
|
|
bestWeight = w;
|
|
@best = f;
|
|
}
|
|
}
|
|
|
|
if(best !is null) {
|
|
@primaryFactory = best;
|
|
}
|
|
else {
|
|
noFactoryTimer += time;
|
|
if(noFactoryTimer > 3.0 * 60.0 && ai.defs.Factory !is null) {
|
|
//Just pick our highest level planet and hope for the best
|
|
PlanetAI@ best;
|
|
double bestWeight = 0.0;
|
|
|
|
for(uint i = 0, cnt = planets.planets.length; i < cnt; ++i) {
|
|
auto@ plAI = planets.planets[i];
|
|
double w = plAI.obj.level;
|
|
w += 0.5 * plAI.obj.resourceLevel;
|
|
|
|
if(w > bestWeight) {
|
|
bestWeight = w;
|
|
@best = plAI;
|
|
}
|
|
}
|
|
|
|
if(best !is null) {
|
|
Factory f;
|
|
@f.obj = best.obj;
|
|
@f.plAI = best;
|
|
|
|
factories.insertLast(f);
|
|
@primaryFactory = f;
|
|
}
|
|
|
|
noFactoryTimer = 0.0;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
noFactoryTimer = 0.0;
|
|
}
|
|
|
|
//Find new factories
|
|
if(planets.planets.length != 0) {
|
|
plCheck = (plCheck+1) % planets.planets.length;
|
|
PlanetAI@ plAI = planets.planets[plCheck];
|
|
if(plAI.obj.laborIncome > 0 && plAI.obj.canBuildShips) {
|
|
if(get(plAI.obj) is null) {
|
|
Factory f;
|
|
@f.obj = plAI.obj;
|
|
@f.plAI = plAI;
|
|
|
|
factories.insertLast(f);
|
|
}
|
|
}
|
|
}
|
|
if(orbitals.orbitals.length != 0) {
|
|
orbCheck = (orbCheck+1) % orbitals.orbitals.length;
|
|
OrbitalAI@ orbAI = orbitals.orbitals[orbCheck];
|
|
if(orbAI.obj.hasConstruction && orbAI.obj.laborIncome > 0
|
|
&& !cast<Orbital>(orbAI.obj).hasMaster()) {
|
|
if(get(orbAI.obj) is null) {
|
|
Factory f;
|
|
@f.obj = orbAI.obj;
|
|
|
|
factories.insertLast(f);
|
|
}
|
|
}
|
|
}
|
|
|
|
//See if we should switch our primary factory
|
|
if(primaryFactory !is null) {
|
|
if(!primaryFactory.valid) {
|
|
@primaryFactory = null;
|
|
}
|
|
else {
|
|
Factory@ best;
|
|
double bestLabor = 0.0;
|
|
double primaryLabor = primaryFactory.laborIncome;
|
|
bool canImport = primaryFactory.obj.canImportLabor;
|
|
for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
|
|
auto@ f = factories[i];
|
|
double checkLabor = f.laborIncome;
|
|
if(f.obj.isShip)
|
|
checkLabor *= 0.1;
|
|
if(f.exportingTo !is primaryFactory && canImport)
|
|
primaryLabor += checkLabor * 0.75;
|
|
if(checkLabor > bestLabor) {
|
|
bestLabor = checkLabor;
|
|
@best = f;
|
|
}
|
|
}
|
|
|
|
if(best !is null && bestLabor > 1.5 * primaryLabor)
|
|
@primaryFactory = best;
|
|
}
|
|
}
|
|
|
|
//See if we should consolidate at a shipyard
|
|
if(buildConsolidate !is null && buildConsolidate.completed) {
|
|
@buildConsolidate = null;
|
|
consTimer = gameTime + 60.0;
|
|
}
|
|
else if(ai.behavior.consolidateLaborExports && primaryFactory !is null && ai.defs.Shipyard !is null && buildConsolidate is null && !primaryFactory.obj.canImportLabor && consTimer < gameTime) {
|
|
double totalLabor = 0.0, bestLabor = 0.0;
|
|
for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
|
|
double inc = factories[i].obj.baseLaborIncome;
|
|
if(factories[i].obj.canExportLabor)
|
|
totalLabor += inc;
|
|
if(factories[i].laborIncome > bestLabor)
|
|
bestLabor = factories[i].laborIncome;
|
|
}
|
|
|
|
if(bestLabor < totalLabor * 0.6) {
|
|
Factory@ bestConsolidate;
|
|
double bestWeight = 0.0;
|
|
for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
|
|
auto@ f = factories[i];
|
|
if(!f.obj.canImportLabor)
|
|
continue;
|
|
|
|
double w = f.obj.baseLaborIncome;
|
|
w /= f.obj.position.distanceTo(primaryFactory.obj.position);
|
|
|
|
if(w > bestWeight) {
|
|
bestWeight = w;
|
|
@bestConsolidate = f;
|
|
}
|
|
}
|
|
|
|
if(bestConsolidate !is null) {
|
|
if(log)
|
|
ai.print("Set shipyard for consolidate.", bestConsolidate.obj.region);
|
|
@primaryFactory = bestConsolidate;
|
|
}
|
|
else {
|
|
Region@ reg = primaryFactory.obj.region;
|
|
if(reg !is null) {
|
|
vec3d pos = reg.position;
|
|
vec2d offset = random2d(reg.radius * 0.4, reg.radius * 0.8);
|
|
pos.x += offset.x;
|
|
pos.z += offset.y;
|
|
|
|
if(log)
|
|
ai.print("Build shipyard for consolidate.", reg);
|
|
|
|
@buildConsolidate = buildOrbital(ai.defs.Shipyard, pos);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool isGettingAsteroid(Asteroid@ asteroid) {
|
|
for(uint i = 0, cnt = factories.length; i < cnt; ++i) {
|
|
if(factories[i].bgAsteroid is asteroid)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Asteroid@ getBackgroundAsteroid(Factory& f) {
|
|
double closest = INFINITY;
|
|
Asteroid@ best;
|
|
Region@ reg = f.obj.region;
|
|
if(reg is null)
|
|
return null;
|
|
|
|
uint cnt = systems.owned.length;
|
|
uint offset = randomi(0, cnt-1);
|
|
for(uint i = 0, check = min(3, cnt); i < check; ++i) {
|
|
auto@ sys = systems.owned[(i+offset)%cnt];
|
|
double dist = sys.obj.position.distanceToSQ(f.obj.position);
|
|
if(dist > closest)
|
|
continue;
|
|
if(!sys.obj.sharesTerritory(ai.empire, reg))
|
|
continue;
|
|
|
|
for(uint n = 0, ncnt = sys.asteroids.length; n < ncnt; ++n) {
|
|
Asteroid@ roid = sys.asteroids[n];
|
|
if(roid.owner.valid)
|
|
continue;
|
|
if(roid.getAvailableCount() == 0)
|
|
continue;
|
|
if(isGettingAsteroid(roid))
|
|
continue;
|
|
|
|
closest = dist;
|
|
@best = roid;
|
|
break;
|
|
}
|
|
}
|
|
|
|
cnt = systems.outsideBorder.length;
|
|
offset = randomi(0, cnt-1);
|
|
for(uint i = 0, check = min(3, cnt); i < check; ++i) {
|
|
auto@ sys = systems.outsideBorder[(i+offset)%cnt];
|
|
double dist = sys.obj.position.distanceToSQ(f.obj.position);
|
|
if(dist > closest)
|
|
continue;
|
|
if(!sys.obj.sharesTerritory(ai.empire, reg))
|
|
continue;
|
|
|
|
for(uint n = 0, ncnt = sys.asteroids.length; n < ncnt; ++n) {
|
|
Asteroid@ roid = sys.asteroids[n];
|
|
if(roid.owner.valid)
|
|
continue;
|
|
if(roid.getAvailableCount() == 0)
|
|
continue;
|
|
if(isGettingAsteroid(roid))
|
|
continue;
|
|
|
|
closest = dist;
|
|
@best = roid;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return best;
|
|
}
|
|
};
|
|
|
|
double asteroidResourceValue(const ResourceType@ type) {
|
|
if(type is null)
|
|
return 0.0;
|
|
double w = 1.0;
|
|
w += type.level * 10.0;
|
|
w += type.totalPressure;
|
|
if(type.cls !is null)
|
|
w += 5.0;
|
|
return w;
|
|
}
|
|
|
|
AIComponent@ createConstruction() {
|
|
return Construction();
|
|
}
|
|
|