Lucas de Vries
1332 lines
34 KiB
ActionScript
1332 lines
34 KiB
ActionScript
import resources;
|
|
import constructions;
|
|
import artifacts;
|
|
import int getOrbitalModuleID(const string&) from "orbitals";
|
|
|
|
//TODO: This doesn't represent the import request well
|
|
// Relies on how a given planet will tend to request imports
|
|
int64 importResHash(Planet@ pl, array<int>@ res) {
|
|
int64 Hash = (int64(ACT_Trade) << ACT_BIT_OFFSET) | int64(pl.id);
|
|
Hash |= int64(res[0]) << 32;
|
|
Hash |= int64(res.length) << 48;
|
|
return Hash;
|
|
}
|
|
|
|
class ImportResource : Action {
|
|
Planet@ dest; Object@ source;
|
|
uint nextType = 0;
|
|
int foundRes = -1;
|
|
int[]@ resources;
|
|
bool attemptExpand = false;
|
|
int64 Hash;
|
|
const ResourceType@ water = getResource("Water");
|
|
double attemptStart = gameTime;
|
|
|
|
ImportResource(Planet@ to, int[]@ Resources) {
|
|
@dest = to;
|
|
@resources = Resources;
|
|
|
|
Hash = importResHash(to, Resources);
|
|
}
|
|
|
|
ImportResource(BasicAI@ ai, SaveFile& msg) {
|
|
msg >> dest >> source;
|
|
msg >> foundRes >> attemptExpand >> nextType;
|
|
|
|
uint cnt = 0;
|
|
msg >> cnt;
|
|
@resources = array<int>(cnt);
|
|
for(uint i = 0; i < cnt; ++i)
|
|
resources[i] = msg.readIdentifier(SI_Resource);
|
|
|
|
Hash = importResHash(dest, resources);
|
|
}
|
|
|
|
~ImportResource() {
|
|
if(source !is null)
|
|
error("ImportResource ended without proper resolution");
|
|
}
|
|
|
|
double get_age() const {
|
|
return gameTime - attemptStart;
|
|
}
|
|
|
|
void postLoad(BasicAI@ ai) {
|
|
}
|
|
|
|
void save(BasicAI@ ai, SaveFile& msg) {
|
|
msg << dest << source;
|
|
msg << foundRes << attemptExpand << nextType;
|
|
|
|
uint cnt = resources.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg.writeIdentifier(SI_Resource, resources[i]);
|
|
}
|
|
|
|
int64 get_hash() const {
|
|
return Hash;
|
|
}
|
|
|
|
ActionType get_actionType() const {
|
|
return ACT_Trade;
|
|
}
|
|
|
|
string get_state() const {
|
|
if(source is null)
|
|
return format("Looking for $1 (+$2 others) for $3", getResource(resources[0]).name, resources.length-1, dest.name);
|
|
else
|
|
return format("Importing $1 from $2 to $3", getResource(foundRes).name, source.name, dest.name);
|
|
}
|
|
|
|
void clear(BasicAI@ ai) {
|
|
if(source !is null) {
|
|
ai.markIdleGeneric(source);
|
|
@source = null;
|
|
}
|
|
ai.removeIdle(this);
|
|
}
|
|
|
|
bool hasWater(BasicAI@ ai) {
|
|
if(ai.planets[water.id].idle.length == 0 && ai.skillEconomy >= DIFF_Medium) {
|
|
auto@ hydro = getBuildingType("Hydrogenator");
|
|
if((ai.usesMotherships ||ai.empire.RemainingBudget < hydro.baseBuildCost) || gameTime < 3.0 * 60.0) {
|
|
const auto@ comet = getArtifactType("Comet");
|
|
if(ai.empire.EnergyStored < comet.abilities[0].energyCost || ai.getArtifact(comet, dest.region) is null) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool hasFood(BasicAI@ ai) {
|
|
const ResourceClass@ cls = getResourceClass("Food");
|
|
for(uint i = 0, cnt = cls.types.length; i < cnt; ++i)
|
|
if(ai.planets[cls.types[i].id].idle.length != 0)
|
|
return true;
|
|
|
|
if(!ai.usesMotherships && gameTime > 3.0 * 60.0) {
|
|
auto@ farm = getBuildingType("Farm");
|
|
if(ai.empire.RemainingBudget >= farm.baseBuildCost)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool canLevelPlanet(BasicAI@ ai) const {
|
|
if(ai.isMachineRace)
|
|
return true;
|
|
return hasWater(ai) && hasFood(ai);
|
|
}
|
|
|
|
Planet@ findViablePlanet(BasicAI@ ai) {
|
|
uint tryCount = 1;
|
|
if(ai.skillEconomy >= DIFF_Hard)
|
|
tryCount = resources.length;
|
|
else if(ai.skillEconomy >= DIFF_Medium)
|
|
tryCount = min(2, resources.length);
|
|
|
|
uint checkType = randomi(0, resources.length-1);
|
|
Empire@ owner = ai.empire;
|
|
|
|
auto@ reg = dest.region;
|
|
auto@ destTerr = reg !is null ? dest.region.getTerritory(owner) : null;
|
|
if(destTerr is null)
|
|
return null;
|
|
|
|
//Look through a few resources for idle planets of the resources we need
|
|
for(uint tries = 0; tries < tryCount; ++tries) {
|
|
uint resID = resources[checkType % resources.length];
|
|
PlanetList@ planets = ai.planets[resID];
|
|
|
|
const ResourceType@ type = getResource(resID);
|
|
|
|
uint cnt = planets.idle.length;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
Planet@ pl = planets.idle[i];
|
|
if(pl.owner !is owner || !pl.valid)
|
|
continue;
|
|
auto@ r = pl.region;
|
|
if(r is null || r.getTerritory(owner) !is destTerr)
|
|
continue;
|
|
|
|
uint plLevel = pl.level;
|
|
if(pl.level < type.level)
|
|
continue;
|
|
|
|
return pl;
|
|
}
|
|
|
|
checkType += 1;
|
|
if(cnt != 0)
|
|
break;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
bool perform(BasicAI@ ai) {
|
|
if(source !is null) {
|
|
uint resLevel = getResource(foundRes).level;
|
|
if(source.owner !is ai.empire) {
|
|
foundRes = -1;
|
|
@source = null;
|
|
ai.removeIdle(this);
|
|
}
|
|
else if(!source.isPlanet || source.resourceLevel >= resLevel) {
|
|
//Attempt to export
|
|
if(source is dest) {
|
|
//When the homeworld moves, it can end up using its own resource - this looks a bit weird but works for this purpose
|
|
source.exportResource(0, null);
|
|
ai.markUsedGeneric(source, source);
|
|
@source = null;
|
|
return true;
|
|
}
|
|
else {
|
|
source.exportResource(0, dest);
|
|
source.wait();
|
|
if(!source.isPrimaryDestination(dest)) {
|
|
ai.markIdleGeneric(source);
|
|
@source = null;
|
|
foundRes = -1;
|
|
ai.removeIdle(this);
|
|
}
|
|
else {
|
|
ai.markUsedGeneric(source, dest);
|
|
@source = null;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
//See if any other planets are available instead
|
|
Planet@ other = findViablePlanet(ai);
|
|
if(other !is null) {
|
|
ai.markIdleGeneric(source);
|
|
@source = other;
|
|
foundRes = other.primaryResourceType;
|
|
ai.markUsedGeneric(source, source);
|
|
}
|
|
else if(source.isPlanet && source.population >= 1.0) {
|
|
//Request the planet be upgraded
|
|
ai.requestPlanetImprovement(cast<Planet>(source), resLevel);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
//Already found the resource and ordered the export
|
|
if(foundRes != -1)
|
|
return true;
|
|
|
|
if(nextType >= resources.length)
|
|
attemptExpand = true;
|
|
|
|
Empire@ owner = ai.empire;
|
|
Territory@ destTerr = null;
|
|
{
|
|
auto@ reg = dest.region;
|
|
if(reg !is null)
|
|
@destTerr = reg.getTerritory(owner);
|
|
if(destTerr is null)
|
|
return true;
|
|
}
|
|
|
|
Object@ farMatch;
|
|
|
|
Object@ best = null;
|
|
double bestScore = 0;
|
|
uint resID;
|
|
|
|
bool tryBuildWater = false, tryBuildFood = false;
|
|
|
|
int aiHasBaseNeeds = -1;
|
|
|
|
uint tryCount = 1;
|
|
if(ai.skillEconomy >= DIFF_Hard)
|
|
tryCount = resources.length;
|
|
else if(ai.skillEconomy >= DIFF_Medium)
|
|
tryCount = min(2, resources.length);
|
|
|
|
ai.focus = dest.position;
|
|
|
|
//Look through a few resources for idle planets of the resources we need
|
|
for(uint tries = 0; tries < tryCount; ++tries) {
|
|
resID = resources[nextType % resources.length];
|
|
if(resID == water.id) {
|
|
const auto@ comet = getArtifactType("Comet");
|
|
if(owner.EnergyStored >= comet.abilities[0].energyCost) {
|
|
auto@ artifact = ai.getArtifact(comet, dest.region);
|
|
if(artifact !is null) {
|
|
artifact.activateAbilityFor(owner, 0, dest);
|
|
dest.wait();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if(!ai.usesMotherships && ai.skillEconomy >= DIFF_Medium && age > 180.0 && ai.empire.RemainingBudget >= 300)
|
|
tryBuildWater = true;
|
|
}
|
|
|
|
PlanetList@ planets = ai.planets[resID];
|
|
|
|
const ResourceType@ type = getResource(resID);
|
|
|
|
uint cnt = planets.idle.length;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
Planet@ pl = planets.idle[i];
|
|
if(pl.owner !is owner || !pl.valid)
|
|
continue;
|
|
auto@ reg = pl.region;
|
|
if(reg is null)
|
|
continue;
|
|
if(reg.getTerritory(owner) !is destTerr) {
|
|
@farMatch = pl;
|
|
continue;
|
|
}
|
|
|
|
uint plLevel = pl.level;
|
|
if(type.level > 0 && plLevel == 0 && aiHasBaseNeeds == 0)
|
|
continue;
|
|
|
|
double score = 1.0;
|
|
if(plLevel >= type.level)
|
|
score = 2.0;
|
|
else if(pl.resourceLevel >= type.level)
|
|
score = 1.5;
|
|
|
|
if(score > bestScore) {
|
|
@best = pl;
|
|
bestScore = score;
|
|
}
|
|
}
|
|
|
|
//TODO: This could probably be sorted into resources as well
|
|
if(best is null) {
|
|
for(uint i = 0, cnt = ai.idleAsteroids.length; i < cnt; ++i) {
|
|
Asteroid@ roid = ai.idleAsteroids[i];
|
|
if(roid.primaryResourceType != resID)
|
|
continue;
|
|
|
|
auto@ reg = roid.region;
|
|
if(reg is null)
|
|
continue;
|
|
if(reg.getTerritory(owner) !is destTerr) {
|
|
@farMatch = roid;
|
|
continue;
|
|
}
|
|
|
|
@best = roid;
|
|
bestScore = 3.0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Check that the AI has enough spare planets to bother aquiring the planet
|
|
// Only check for Medium or harder AI early in the game
|
|
// TODO: Skip check based on colonization capacity, rather than a time heuristic
|
|
if(type.level >= 1 && gameTime < 30.0 * 60.0 && ai.skillEconomy >= DIFF_Medium) {
|
|
if(aiHasBaseNeeds == -1)
|
|
aiHasBaseNeeds = canLevelPlanet(ai) ? 1 : 0;
|
|
}
|
|
else if(type.level == 0 && ai.skillEconomy >= DIFF_Medium && (best is null || cnt <= 2) && age > 180.0 && type.cls is getResourceClass("Food")) {
|
|
if(!ai.usesMotherships && ai.empire.RemainingBudget >= 300)
|
|
tryBuildFood = true;
|
|
}
|
|
else if(resID == water.id && best !is null && cnt > 2) {
|
|
tryBuildWater = false;
|
|
}
|
|
|
|
nextType += 1;
|
|
if(cnt != 0)
|
|
break;
|
|
}
|
|
|
|
if(best !is null) {
|
|
foundRes = resID;
|
|
@source = best;
|
|
ai.markUsedGeneric(source, source);
|
|
ai.addIdle(this);
|
|
//We found a useful planet.
|
|
//Hard AIs will go on to try to use their free money to build up food and water
|
|
if(ai.skillEconomy < DIFF_Hard)
|
|
return false;
|
|
}
|
|
else if(farMatch !is null) {
|
|
//TODO: Request the connection of two territories
|
|
}
|
|
|
|
if(tryBuildFood) {
|
|
ai.requestBuilding(dest, getBuildingType("Farm"));
|
|
if(source is null)
|
|
return true;
|
|
}
|
|
else if(tryBuildWater) {
|
|
ai.requestBuilding(dest, getBuildingType("Hydrogenator"));
|
|
if(source is null)
|
|
return true;
|
|
}
|
|
else if(attemptExpand && source is null && aiHasBaseNeeds != 0) {
|
|
//Request colonization of planet with a resource we need
|
|
ai.colonizeByResource(resources);
|
|
}
|
|
else if(aiHasBaseNeeds == 0 && !ai.isMachineRace) {
|
|
if(!hasWater(ai))
|
|
ai.addIdle(ai.colonizeByResource(ai.getResourceList(RT_Water, onlyExportable=true), execute=false));
|
|
if(!hasFood(ai))
|
|
ai.addIdle(ai.colonizeByResource(ai.getResourceList(RT_Food, onlyExportable=true), execute=false));
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int64 buildBuildingHash(Planet@ pl, const BuildingType@ bldg) {
|
|
return (int64(ACT_Building) << ACT_BIT_OFFSET) | (int64(bldg.id) << 32) | int64(pl.id);
|
|
}
|
|
|
|
class BuildBuilding : Action {
|
|
Planet@ planet;
|
|
const BuildingType@ type;
|
|
int64 Hash;
|
|
uint tries = 0;
|
|
vec2i inProgress = vec2i(-1,-1);
|
|
bool force = false;
|
|
|
|
BuildBuilding(Planet@ pl, const BuildingType@ bldg, bool force = false) {
|
|
@planet = pl;
|
|
@type = bldg;
|
|
this.force = force;
|
|
Hash = buildBuildingHash(pl, bldg);
|
|
}
|
|
|
|
int64 get_hash() const {
|
|
return Hash;
|
|
}
|
|
|
|
ActionType get_actionType() const {
|
|
return ACT_Building;
|
|
}
|
|
|
|
string get_state() const {
|
|
return "Building " + type.name + " on " + planet.name;
|
|
}
|
|
|
|
BuildBuilding(BasicAI@ ai, SaveFile& msg) {
|
|
uint typeID = 0;
|
|
msg >> planet >> typeID >> inProgress;
|
|
@type = getBuildingType(typeID);
|
|
Hash = buildBuildingHash(planet, type);
|
|
if(msg >= SV_0130)
|
|
msg >> force;
|
|
}
|
|
|
|
void postLoad(BasicAI@ ai) {
|
|
}
|
|
|
|
void save(BasicAI@ ai, SaveFile& msg) {
|
|
msg << planet << type.id << inProgress;
|
|
msg << force;
|
|
}
|
|
|
|
bool perform(BasicAI@ ai) {
|
|
if(planet is null || !planet.valid || planet.owner !is ai.empire)
|
|
return true;
|
|
if(ai.usesMotherships)
|
|
return true;
|
|
|
|
ai.focus = planet.position;
|
|
|
|
if(inProgress.x >= 0) {
|
|
int at = planet.getBuildingAt(inProgress.x, inProgress.y);
|
|
if(at != int(type.id)) {
|
|
//error(type.name + " on " + planet.name + " expected at " + inProgress + " got " + at);
|
|
inProgress = vec2i(-1,-1);
|
|
}
|
|
else if(planet.getBuildingProgressAt(inProgress.x, inProgress.y) >= 0.999f) {
|
|
@planet = null;
|
|
return true;
|
|
}
|
|
else {
|
|
//Await completion
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if(force) {
|
|
if(!ai.empire.canPay(type.baseBuildCost)) {
|
|
if(tries++ > 20)
|
|
return true;
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
if(ai.empire.RemainingBudget < type.baseBuildCost)
|
|
return true;
|
|
}
|
|
|
|
//Try to plop it on a random tile
|
|
if(tries++ < 20) {
|
|
vec2i off = vec2i(type.getCenter());
|
|
|
|
bool validPos = true;
|
|
vec2i pos = vec2i(randomi(0,10), randomi(0,8));
|
|
for(int x = pos.x, endx = pos.x + type.size.width; x < endx; ++x) {
|
|
for(int y = pos.y, endy = pos.y + type.size.height; y < endy; ++y) {
|
|
if(x < 0 || y < 0) {
|
|
validPos = false;
|
|
break;
|
|
}
|
|
|
|
int bType = planet.getBuildingAt(x - off.x,y - off.y);
|
|
if(bType >= 0) {
|
|
auto@ b = getBuildingType(bType);
|
|
if(b !is null && !b.civilian) {
|
|
validPos = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!validPos)
|
|
break;
|
|
}
|
|
|
|
if(validPos) {
|
|
planet.buildBuilding(type.id, pos);
|
|
planet.wait();
|
|
inProgress = pos;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
else {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
int64 improvePlanetHash(Planet@ pl, uint toLevel) {
|
|
return (int64(ACT_Improve) << ACT_BIT_OFFSET) | (int64(toLevel) << 48) | int64(pl.id);
|
|
}
|
|
|
|
class ImprovePlanet : Action {
|
|
Planet@ planet;
|
|
uint level = 1;
|
|
bool requested = false;
|
|
int64 Hash;
|
|
Action@[] requests;
|
|
int64[]@ reqHashes;
|
|
uint lastResState = 0xffffffff;
|
|
|
|
ImprovePlanet(Planet@ pl, uint toLevel) {
|
|
@planet = pl;
|
|
level = toLevel;
|
|
Hash = improvePlanetHash(pl, toLevel);
|
|
}
|
|
|
|
ImprovePlanet(BasicAI@ ai, SaveFile& msg) {
|
|
msg >> planet >> level;
|
|
msg >> requested >> Hash;
|
|
|
|
uint cnt = 0;
|
|
msg >> cnt;
|
|
@reqHashes = int64[](cnt);
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg >> reqHashes[i];
|
|
}
|
|
|
|
void postLoad(BasicAI@ ai) {
|
|
for(uint i = 0, cnt = reqHashes.length; i < cnt; ++i) {
|
|
Action@ act = ai.locateAction(reqHashes[i]);
|
|
if(act !is null)
|
|
requests.insertLast(act);
|
|
}
|
|
@reqHashes = null;
|
|
}
|
|
|
|
void save(BasicAI@ ai, SaveFile& msg) {
|
|
msg << planet << level;
|
|
msg << requested << Hash;
|
|
|
|
uint cnt = requests.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg << requests[i].hash;
|
|
}
|
|
|
|
int64 get_hash() const {
|
|
return Hash;
|
|
}
|
|
|
|
ActionType get_actionType() const {
|
|
return ACT_Improve;
|
|
}
|
|
|
|
string get_state() const {
|
|
return "Improving " + planet.name + " to level " + level;
|
|
}
|
|
|
|
bool hasFoods(array<Resource>& avail, uint count) {
|
|
if(count == 0)
|
|
return true;
|
|
|
|
const ResourceClass@ cls = getResourceClass("Food");
|
|
uint levelCount = count;
|
|
|
|
for(uint i = 0, cnt = avail.length; i < cnt; ++i) {
|
|
auto@ type = avail[i].type;
|
|
if(type.cls is cls)
|
|
if(--count == 0)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool hasRequirement(array<Resource>& avail, uint level, uint count) {
|
|
if(count == 0)
|
|
return true;
|
|
|
|
uint levelCount = count;
|
|
|
|
for(uint i = 0, cnt = avail.length; i < cnt; ++i) {
|
|
auto@ type = avail[i].type;
|
|
if(type.level == level)
|
|
if(--count == 0)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool perform(BasicAI@ ai) {
|
|
//TODO: Doesn't this leak into the action map?
|
|
// Looks like it should be killing the actions in requests
|
|
// if it exits prematurely from here.
|
|
if(!planet.valid || planet.owner !is ai.empire)
|
|
return true;
|
|
|
|
if(ai.usesMotherships && planet.Population < double(planet.maxPopulation)) {
|
|
ai.requestPopulate(planet);
|
|
return false;
|
|
}
|
|
|
|
uint plLevel = planet.resourceLevel;
|
|
if(plLevel >= level)
|
|
return true;
|
|
|
|
ai.focus = planet.position;
|
|
|
|
if(requests.length > 0 && lastResState == planet.resourceModID) {
|
|
int index = randomi(0, int(requests.length)-1);
|
|
if(ai.performAction(requests[index]))
|
|
requests.length = 0;
|
|
}
|
|
else {
|
|
lastResState = planet.resourceModID;
|
|
//We only check against the needs for the next level, not our ultimate goal
|
|
uint goingTo = plLevel + 1;
|
|
requests.length = 0;
|
|
|
|
auto@ reg = planet.region;
|
|
auto@ destTerr = reg is null ? null : reg.getTerritory(ai.empire);
|
|
|
|
array<Resource> avail;
|
|
avail.syncFrom(planet.getAllResources());
|
|
|
|
//Remove all resources that aren't usable or won't be soon
|
|
for(int i = int(avail.length) - 1; i > 0; --i) {
|
|
auto@ res = avail[i];
|
|
if(!res.usable) {
|
|
auto@ src = res.origin;
|
|
auto@ srcReg = src.region;
|
|
if(src !is planet && (src.owner !is ai.empire || srcReg is null || srcReg.getTerritory(ai.empire) !is destTerr || (src.isPlanet && src.resourceLevel < res.type.level))) {
|
|
Planet@ source = cast<Planet>(src);
|
|
if(source !is null) {
|
|
source.exportResource(ai.empire, 0, null);
|
|
ai.markPlanetIdle(source);
|
|
}
|
|
avail.removeAt(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Look for all the resources we still need, and queue up a series of requests that can be completed simultaneously
|
|
bool needWater = true;
|
|
if(!ai.isMachineRace) {
|
|
array<int>@ waterNeed = ai.getResourceList(RT_Water);
|
|
for(uint i = 0, cnt = avail.length; i < cnt; ++i) {
|
|
if(waterNeed.find(avail[i].type.id) > 0) {
|
|
needWater = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(goingTo > 2) {
|
|
uint need = 0;
|
|
switch(goingTo) {
|
|
case 3: need = 1; break;
|
|
case 4: need = 2; break;
|
|
case 5: need = 4; break;
|
|
}
|
|
|
|
if(!hasRequirement(avail, 2, need)) {
|
|
requests.insertLast(ai.requestImport(planet, ai.getResourceList(RT_LevelTwo, true), execute=false));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool requestLowerResources = gameTime > 15.0 * 60.0;
|
|
|
|
if(goingTo > 1) {
|
|
uint need = 0;
|
|
switch(goingTo) {
|
|
case 2: need = 1; break;
|
|
case 3: need = ai.isFrugal ? 1 : 2; break;
|
|
case 4: need = ai.isFrugal ? 2 : 4; break;
|
|
case 5: need = ai.isFrugal ? 4 : 6; break;
|
|
}
|
|
|
|
if(!hasRequirement(avail, 1, need)) {
|
|
requests.insertLast(ai.requestImport(planet, ai.getResourceList(RT_LevelOne, true), execute=false));
|
|
if(!requestLowerResources)
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if(!ai.isMachineRace) {
|
|
if(needWater)
|
|
requests.insertLast(ai.requestImport(planet, ai.getResourceList(RT_Water, true), execute=false));
|
|
|
|
if(!hasFoods(avail, goingTo))
|
|
requests.insertLast(ai.requestImport(planet, ai.getResourceList(RT_Food, true), execute=false));
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int64 budgetHash() {
|
|
return int64(ACT_Budget) << ACT_BIT_OFFSET;
|
|
}
|
|
|
|
class GatherBudget : Action {
|
|
Planet@ hw;
|
|
|
|
GatherBudget() {
|
|
}
|
|
|
|
GatherBudget(BasicAI@ ai, SaveFile& msg) {
|
|
if(msg < SV_0024) {
|
|
int64 dummy = 0;
|
|
msg >> dummy;
|
|
}
|
|
if(msg >= SV_0114) {
|
|
msg >> hw;
|
|
}
|
|
}
|
|
|
|
void postLoad(BasicAI@ ai) {
|
|
}
|
|
|
|
void save(BasicAI@ ai, SaveFile& msg) {
|
|
msg << hw;
|
|
}
|
|
|
|
int64 get_hash() const {
|
|
return budgetHash();
|
|
}
|
|
|
|
ActionType get_actionType() const {
|
|
return ACT_Budget;
|
|
}
|
|
|
|
string get_state() const {
|
|
return "Increasing available budget";
|
|
}
|
|
|
|
Planet@ getHomeworld(BasicAI@ ai) {
|
|
Planet@ hw = ai.homeworld;
|
|
if(hw !is null && hw.owner is ai.empire && hw.valid)
|
|
return hw;
|
|
|
|
for(int t = 3; t >= 0; --t) {
|
|
AIResourceType type;
|
|
switch(t) {
|
|
case 3: type = RT_LevelThree; break;
|
|
case 2: type = RT_LevelTwo; break;
|
|
case 1: type = RT_LevelOne; break;
|
|
case 0: type = RT_Food; break;
|
|
}
|
|
auto@ resources = ai.getResourceList(type, onlyExportable = false);
|
|
|
|
uint base = randomi(0, 250);
|
|
for(uint r = 0, rcnt = resources.length; r < rcnt; ++r) {
|
|
auto@ planets = ai.planets[resources[(r+base) % rcnt]].idle;
|
|
for(uint i = 0, cnt = planets.length; i < cnt; ++i) {
|
|
auto@ pl = planets[i];
|
|
if(pl.valid && pl.owner is ai.empire)
|
|
return pl;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
bool perform(BasicAI@ ai) {
|
|
if(hw is null)
|
|
@hw = getHomeworld(ai);
|
|
|
|
if(hw !is null) {
|
|
uint plLevel = hw.level;
|
|
if(plLevel < 5) {
|
|
ai.requestPlanetImprovement(hw, plLevel+1);
|
|
}
|
|
else {
|
|
ai.requestImport(hw, ai.getResourceList(RT_LevelThree, true));
|
|
}
|
|
}
|
|
else {
|
|
ai.colonizeByResource(ai.getResourceList(RT_LevelOne, onlyExportable = false));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
enum OrbitalType {
|
|
OT_Shipyard = 0,
|
|
OT_TradeOutpost = 1,
|
|
OT_FlingBeacon = 2,
|
|
OT_Mainframe = 3,
|
|
OT_Gate,
|
|
};
|
|
|
|
int64 buildOrbitalHash(Region@ at, OrbitalType type) {
|
|
return (int64(ACT_BuildOrbital) << ACT_BIT_OFFSET) | (int64(type) << 32) | at.id;
|
|
}
|
|
|
|
class BuildOrbital : Action {
|
|
uint type;
|
|
Region@ sys;
|
|
Object@ builder;
|
|
int64 Hash;
|
|
|
|
BuildOrbital(Region& at, OrbitalType Type) {
|
|
type = Type;
|
|
@sys = at;
|
|
Hash = buildOrbitalHash(sys, Type);
|
|
}
|
|
|
|
BuildOrbital(BasicAI@ ai, SaveFile& msg) {
|
|
msg >> type;
|
|
msg >> sys;
|
|
msg >> builder;
|
|
Hash = buildOrbitalHash(sys, OrbitalType(type));
|
|
}
|
|
|
|
void postLoad(BasicAI@ ai) {
|
|
}
|
|
|
|
void save(BasicAI@ ai, SaveFile& msg) {
|
|
msg << type;
|
|
msg << sys;
|
|
msg << builder;
|
|
}
|
|
|
|
int64 get_hash() const {
|
|
return Hash;
|
|
}
|
|
|
|
ActionType get_actionType() const {
|
|
return ACT_BuildOrbital;
|
|
}
|
|
|
|
string get_state() const {
|
|
if(builder is null)
|
|
return "Planning orbital construction in " + sys.name;
|
|
else
|
|
return "Building Orbital in " + sys.name;
|
|
}
|
|
|
|
bool isTradeable(Region@ region, Empire@ emp, const Territory@ territory) {
|
|
if(territory is region.getTerritory(emp))
|
|
return true;
|
|
|
|
const SystemDesc@ system = getSystem(region);
|
|
for(uint i = 0, cnt = system.adjacent.length; i < cnt; ++i) {
|
|
Region@ other = getSystem(system.adjacent[i]).object;
|
|
if(territory is other.getTerritory(emp))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool perform(BasicAI@ ai) {
|
|
if(builder !is null) {
|
|
//Look for the orbital
|
|
auto@ reg = ai.findSystem(sys);
|
|
if(reg is null)
|
|
return true;
|
|
|
|
if(type == OT_Gate) {
|
|
auto@ gate = ai.empire.getStargate(sys.position);
|
|
if(gate !is null && gate.region is sys)
|
|
return true;
|
|
}
|
|
else {
|
|
reg.scout(ai);
|
|
for(uint i = 0, cnt = reg.orbitals.length; i < cnt; ++i) {
|
|
auto@ orb = reg.orbitals[i];
|
|
if(orb.owner is ai.empire && ai.orbitals.find(orb) < 0) {
|
|
int orbID = -1;
|
|
switch(type) {
|
|
case OT_Shipyard:
|
|
orbID = getOrbitalModuleID("Shipyard");
|
|
break;
|
|
case OT_TradeOutpost:
|
|
orbID = getOrbitalModuleID("TradeOutpost");
|
|
break;
|
|
case OT_FlingBeacon:
|
|
orbID = getOrbitalModuleID("FlingCore");
|
|
break;
|
|
case OT_Mainframe:
|
|
orbID = getOrbitalModuleID("Mainframe");
|
|
break;
|
|
}
|
|
|
|
if(orbID < -1)
|
|
return true;
|
|
|
|
if(orb.hasModule(orbID)) {
|
|
ai.orbitals.insertLast(reg.orbitals[i]);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!builder.valid || builder.owner !is ai.empire || ai.isBuildIdle(builder))
|
|
@builder = null;
|
|
}
|
|
else {
|
|
for(uint i = 0, cnt = ai.factories.length; i < cnt; ++i) {
|
|
Object@ buildAt = ai.factories[i];
|
|
|
|
if(buildAt.owner is ai.empire && buildAt.hasConstruction && buildAt.canBuildOrbitals &&
|
|
ai.isBuildIdle(buildAt) && buildAt.laborIncome > 0.05)
|
|
{
|
|
auto@ reg = buildAt.region;
|
|
if(reg is null || !isTradeable(sys, ai.empire, reg.getTerritory(ai.empire)))
|
|
continue;
|
|
|
|
int orbID = -1;
|
|
const Design@ station;
|
|
|
|
switch(type) {
|
|
case OT_Shipyard:
|
|
orbID = getOrbitalModuleID("Shipyard");
|
|
break;
|
|
case OT_TradeOutpost:
|
|
orbID = getOrbitalModuleID("TradeOutpost");
|
|
break;
|
|
case OT_FlingBeacon:
|
|
orbID = getOrbitalModuleID("FlingCore");
|
|
break;
|
|
case OT_Mainframe:
|
|
orbID = getOrbitalModuleID("Mainframe");
|
|
break;
|
|
case OT_Gate:
|
|
@station = ai.empire.getDesign("Gate");
|
|
break;
|
|
}
|
|
|
|
if(orbID < 0 && station is null)
|
|
return true;
|
|
|
|
vec2d off = random2d(200.0, sys.radius - 200.0);
|
|
|
|
if(orbID >= 0)
|
|
buildAt.buildOrbital(orbID, sys.position + vec3d(off.x, 0.0, off.y));
|
|
else
|
|
buildAt.buildStation(station, sys.position + vec3d(off.x, 0.0, off.y));
|
|
@builder = buildAt;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int64 manageFactoriesHash() {
|
|
return int64(ACT_ManageFactories) << ACT_BIT_OFFSET;
|
|
}
|
|
|
|
class ManageFactories : Action {
|
|
ManageFactories(BasicAI@ ai, SaveFile& file) {
|
|
}
|
|
|
|
ManageFactories() {
|
|
}
|
|
|
|
int64 get_hash() const {
|
|
return manageFactoriesHash();
|
|
}
|
|
|
|
ActionType get_actionType() const {
|
|
return ACT_ManageFactories;
|
|
}
|
|
|
|
string get_state() const {
|
|
return "Managing factories";
|
|
}
|
|
|
|
void save(BasicAI@, SaveFile& msg) {}
|
|
void postLoad(BasicAI@) {}
|
|
|
|
set_int checked;
|
|
AsteroidCache@ findAsteroid(BasicAI@ ai, PlanRegion@ region, bool recurse = true, bool original = true, int maxHops = -1) {
|
|
if(original)
|
|
checked.clear();
|
|
if(checked.contains(region.region.id))
|
|
return null;
|
|
checked.insert(region.region.id);
|
|
|
|
if(region.resourceAsteroids.length != 0)
|
|
return region.resourceAsteroids[randomi(0, region.resourceAsteroids.length-1)];
|
|
|
|
if(recurse && region.region.TradeMask & ai.empire.TradeMask.value != 0 && maxHops != 0) {
|
|
uint cnt = region.system.adjacent.length;
|
|
uint off = randomi(0, cnt-1);
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
auto@ other = getSystem(region.system.adjacent[(i+off)%cnt]);
|
|
if(other !is null) {
|
|
PlanRegion@ otherRegion = ai.findSystem(other.object);
|
|
if(otherRegion !is null) {
|
|
AsteroidCache@ cache = findAsteroid(ai, otherRegion, recurse=false, original=false, maxHops=maxHops-1);
|
|
if(cache !is null)
|
|
return cache;
|
|
}
|
|
}
|
|
}
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
auto@ other = getSystem(region.system.adjacent[(i+off)%cnt]);
|
|
if(other !is null) {
|
|
PlanRegion@ otherRegion = ai.findSystem(other.object);
|
|
if(otherRegion !is null) {
|
|
AsteroidCache@ cache = findAsteroid(ai, otherRegion, recurse=true, original=false, maxHops=maxHops-1);
|
|
if(cache !is null)
|
|
return cache;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
bool perform(BasicAI@ ai) {
|
|
//Check for idle factories, and make them build nearby asteroids
|
|
if(ai.factories.length == 0)
|
|
return false;
|
|
|
|
Object@ fact = ai.factories[randomi(0, ai.factories.length-1)];
|
|
uint consCount = fact.constructionCount;
|
|
uint consType = fact.constructionType;
|
|
|
|
//Deal with mechanoid population construction
|
|
if(ai.isMachineRace && fact.isPlanet) {
|
|
bool buildPop = false;
|
|
if(fact.population < int(fact.maxPopulation + 1 + fact.owner.autoColonizeCount)) {
|
|
buildPop = true;
|
|
}
|
|
|
|
if(consCount != 0) {
|
|
if(consType == CT_Construction)
|
|
buildPop = false;
|
|
if(consType == CT_Flagship && ai.factories.length > 1 && int(fact.population) >= int(fact.maxPopulation))
|
|
buildPop = false;
|
|
}
|
|
|
|
if(buildPop) {
|
|
auto@ constr = getConstructionType("MechanoidPopulation");
|
|
if(constr !is null) {
|
|
fact.buildConstruction(constr.id);
|
|
if(consCount != 0)
|
|
fact.moveConstruction(fact.constructionID[0], -1);
|
|
consCount += 1;
|
|
|
|
if(constr.getLaborCost(fact) > fact.laborIncome * 60.0) {
|
|
ai.addIdle( ai.requestImport(cast<Planet>(fact), ai.getResourceList(RT_LaborZero, onlyExportable=true), execute=false) );
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Move asteroid constructibles to the end
|
|
if(consCount != 0) {
|
|
if(consCount > 1 && consType == CT_Asteroid)
|
|
fact.moveConstruction(fact.constructionID[0], -1);
|
|
return false;
|
|
}
|
|
|
|
//Find a nearby asteroid to build
|
|
if(fact.canBuildAsteroids) {
|
|
Region@ regObj = fact.region;
|
|
if(regObj is null)
|
|
return false;
|
|
int hops = randomi(0,ai.skillEconomy * 2);
|
|
|
|
auto@ region = ai.findSystem(regObj);
|
|
AsteroidCache@ roid = findAsteroid(ai, region, maxHops=hops);
|
|
if(roid is null || roid.asteroid.owner !is defaultEmpire || !roid.asteroid.valid)
|
|
return false;
|
|
|
|
roid.cache();
|
|
if(roid.resources.length == 0)
|
|
return false;
|
|
|
|
int resourceId = roid.resources[randomi(0, roid.resources.length-1)];
|
|
fact.buildAsteroid(roid.asteroid, resourceId);
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
int64 managePressureResourcesHash() {
|
|
return int64(ACT_ManagePressureResources) << ACT_BIT_OFFSET;
|
|
}
|
|
|
|
class ManagePressureResources : Action {
|
|
Object@ destination;
|
|
int destFree = 0;
|
|
float destPct = 1.f;
|
|
Object@ secondary;
|
|
int secondaryFree = 0;
|
|
|
|
const ResourceType@ asteroidLabor = getResource("AsteroidLabor");
|
|
const ResourceType@ morphics = getResource("AsteroidAffinity");
|
|
const ResourceType@ growth = getResource("AsteroidGrowth");
|
|
|
|
ManagePressureResources(BasicAI@ ai, SaveFile& file) {
|
|
file >> destination;
|
|
file >> destFree;
|
|
file >> destPct;
|
|
file >> secondary;
|
|
file >> secondaryFree;
|
|
}
|
|
|
|
ManagePressureResources() {
|
|
}
|
|
|
|
int64 get_hash() const {
|
|
return managePressureResourcesHash();
|
|
}
|
|
|
|
ActionType get_actionType() const {
|
|
return ACT_ManagePressureResources;
|
|
}
|
|
|
|
string get_state() const {
|
|
return "Managing pressure resources.";
|
|
}
|
|
|
|
void save(BasicAI@, SaveFile& file) {
|
|
file << destination;
|
|
file << destFree;
|
|
file << destPct;
|
|
file << secondary;
|
|
file << secondaryFree;
|
|
}
|
|
|
|
void postLoad(BasicAI@) {}
|
|
|
|
void checkDestination(Object@ dest) {
|
|
int pTotal = dest.pressureCap;
|
|
int pUsed = dest.totalPressure;
|
|
int free = max(pTotal - pUsed, 0);
|
|
float pct = float(pUsed) / float(pTotal);
|
|
|
|
if(free > destFree) {
|
|
@destination = dest;
|
|
destFree = free;
|
|
destPct = pct;
|
|
}
|
|
if(free > secondaryFree) {
|
|
auto@ res = getResource(dest.primaryResourceType);
|
|
if(res.totalPressure > 0 && res.tilePressure[TR_Labor] == 0) {
|
|
secondaryFree = free;
|
|
@secondary = dest;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool checkResource(BasicAI@ ai, Object@ obj, Object@ curDest = null) {
|
|
const ResourceType@ res = getResource(obj.primaryResourceType);
|
|
if(res !is null) {
|
|
uint resCls = ai.classifyResource(res);
|
|
if(resCls == RT_PressureResource) {
|
|
if(destination !is null && destPct < 1.5f) {
|
|
if(!obj.primaryResourceExported) {
|
|
obj.exportResource(0, destination);
|
|
ai.markUsedGeneric(obj, destination);
|
|
return true;
|
|
}
|
|
else if(ai.skillEconomy >= DIFF_Medium) {
|
|
if(curDest is null)
|
|
@curDest = obj.nativeResourceDestination[0];
|
|
if(curDest !is null && curDest.isPlanet) {
|
|
if(destFree >= res.totalPressure - 0.001f && uint(curDest.totalPressure) > curDest.pressureCap) {
|
|
obj.exportResource(0, destination);
|
|
ai.markUsedGeneric(obj, destination);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(res is asteroidLabor) {
|
|
//Send this to one of our factories
|
|
if(ai.factories.length != 0 && !obj.primaryResourceExported) {
|
|
Object@ fact = ai.factories[randomi(0, ai.factories.length-1)];
|
|
if(fact.isPlanet) {
|
|
obj.exportResource(0, fact);
|
|
ai.markUsedGeneric(obj, fact);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
else if(res is morphics) {
|
|
//Send this to a planet that can use pressure and has a native resource with non-labor pressure
|
|
if(secondary !is null) {
|
|
if(!obj.primaryResourceExported) {
|
|
obj.exportResource(0, secondary);
|
|
ai.markUsedGeneric(obj, secondary);
|
|
return true;
|
|
}
|
|
else if(secondaryFree >= 2) {
|
|
if(curDest is null)
|
|
@curDest = obj.nativeResourceDestination[0];
|
|
if(curDest !is null && curDest.isPlanet) {
|
|
if(uint(curDest.totalPressure) > curDest.pressureCap) {
|
|
obj.exportResource(0, secondary);
|
|
ai.markUsedGeneric(obj, secondary);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(res is growth) {
|
|
//Send this whereever
|
|
if(destination !is null && !obj.primaryResourceExported) {
|
|
obj.exportResource(0, destination);
|
|
ai.markUsedGeneric(obj, destination);
|
|
return true;
|
|
}
|
|
}
|
|
else if(ai.isMachineRace && (resCls == RT_Food || resCls == RT_Water) && obj.isPlanet && !obj.isContested) {
|
|
//Abandon food and water planets we captured or no longer need to have to keep the system.
|
|
Region@ reg = obj.region;
|
|
if(reg !is null && reg.getPlanetCount(ai.empire) >= 2) {
|
|
obj.abandon();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if(ai.needsStalks && obj.isPlanet && obj.resourceLevel >= 2 && obj.pressureCap < 1 && obj.totalPressure > 0)
|
|
ai.addIdle(ai.requestBuilding(cast<Planet>(obj), getBuildingType("Stalk")));
|
|
return false;
|
|
}
|
|
|
|
uint nextCheckRes = 0;
|
|
bool perform(BasicAI@ ai) {
|
|
//check our cached destinations
|
|
if(destination is null)
|
|
@destination = ai.homeworld;
|
|
if(destination !is null && (!destination.valid || destination.owner !is ai.empire))
|
|
@destination = null;
|
|
if(secondary !is null && (!secondary.valid || secondary.owner !is ai.empire))
|
|
@secondary = null;
|
|
if(destination !is null) {
|
|
int pTotal = destination.pressureCap;
|
|
int pUsed = destination.totalPressure;
|
|
destFree = max(pTotal - pUsed, 0);
|
|
destPct = float(pUsed) / float(pTotal);
|
|
}
|
|
if(secondary !is null) {
|
|
secondaryFree = secondary.pressureCap - secondary.totalPressure;
|
|
if(secondaryFree <= 0) {
|
|
@secondary = null;
|
|
secondaryFree = 0;
|
|
}
|
|
}
|
|
|
|
//Find a planet we have that has significant pressure cap free
|
|
PlanetList@ list;
|
|
|
|
for(uint n = 0; n < 30; ++n) {
|
|
@list = ai.planetsByResource[nextCheckRes++ % ai.planetsByResource.length];
|
|
if(list.idle.length == 0 && list.used.length == 0)
|
|
continue;
|
|
|
|
for(uint j = 0; j < 2; ++j) {
|
|
auto@ planets = j == 0 ? list.idle : list.used;
|
|
uint plCnt = planets.length;
|
|
if(plCnt == 0)
|
|
continue;
|
|
uint check = min(ai.skillEconomy * 2, plCnt);
|
|
|
|
for(uint i = 0, cnt = check, base = randomi(0,plCnt-1); i < cnt; ++i) {
|
|
Planet@ pl = planets[(i+base) % plCnt];
|
|
if(pl.valid && pl.owner is ai.empire)
|
|
checkDestination(pl);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
if(destination is null || destPct > 1.5f)
|
|
return false;
|
|
|
|
//Handle pressure-providing resources from asteroids
|
|
if(ai.idleAsteroids.length > 0) {
|
|
uint index = randomi(0, ai.idleAsteroids.length-1);
|
|
Asteroid@ roid = ai.idleAsteroids[index];
|
|
if(checkResource(ai, roid))
|
|
return false;
|
|
}
|
|
if(ai.usedAsteroids.length > 0) {
|
|
uint index = randomi(0, ai.usedAsteroids.length-1);
|
|
Asteroid@ roid = ai.usedAsteroids[index];
|
|
if(checkResource(ai, roid))
|
|
return false;
|
|
}
|
|
|
|
//Handle pressure-providing resources on planets
|
|
for(uint j = 0; j < 2; ++j) {
|
|
auto@ planets = j == 0 ? list.idle : list.used;
|
|
for(uint i = 0, cnt = planets.length; i < cnt; ++i) {
|
|
Planet@ pl = planets[i];
|
|
Object@ curDest;
|
|
if(j == 1)
|
|
@curDest = list.purpose[i];
|
|
if(checkResource(ai, pl, curDest))
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
};
|