Lucas de Vries
695 lines
16 KiB
ActionScript
695 lines
16 KiB
ActionScript
import empire_ai.weasel.WeaselAI;
|
|
import empire_ai.weasel.ImportData;
|
|
|
|
import resources;
|
|
import planet_levels;
|
|
import system_pathing;
|
|
import systems;
|
|
|
|
interface RaceResources {
|
|
void levelRequirements(Object& obj, int targetLevel, array<ResourceSpec@>& specs);
|
|
};
|
|
|
|
final class Resources : AIComponent {
|
|
RaceResources@ race;
|
|
|
|
array<ImportData@> requested;
|
|
array<ImportData@> active;
|
|
int nextImportId = 0;
|
|
|
|
array<ExportData@> available;
|
|
array<ExportData@> used;
|
|
int nextExportId = 0;
|
|
|
|
void create() {
|
|
@race = cast<RaceResources>(ai.race);
|
|
}
|
|
|
|
void save(SaveFile& file) {
|
|
file << nextImportId;
|
|
file << nextExportId;
|
|
|
|
uint cnt = 0;
|
|
|
|
cnt = requested.length;
|
|
file << cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
saveImport(file, requested[i]);
|
|
file << requested[i];
|
|
}
|
|
|
|
cnt = active.length;
|
|
file << cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
saveImport(file, active[i]);
|
|
file << active[i];
|
|
}
|
|
|
|
cnt = available.length;
|
|
file << cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
saveExport(file, available[i]);
|
|
file << available[i];
|
|
saveImport(file, available[i].request);
|
|
}
|
|
|
|
cnt = used.length;
|
|
file << cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
saveExport(file, used[i]);
|
|
file << used[i];
|
|
saveImport(file, used[i].request);
|
|
}
|
|
}
|
|
|
|
void load(SaveFile& file) {
|
|
file >> nextImportId;
|
|
file >> nextExportId;
|
|
|
|
uint cnt = 0;
|
|
|
|
file >> cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
auto@ data = loadImport(file);
|
|
file >> data;
|
|
requested.insertLast(data);
|
|
}
|
|
|
|
file >> cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
auto@ data = loadImport(file);
|
|
file >> data;
|
|
active.insertLast(data);
|
|
}
|
|
|
|
file >> cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
auto@ data = loadExport(file);
|
|
file >> data;
|
|
@data.request = loadImport(file);
|
|
available.insertLast(data);
|
|
}
|
|
|
|
file >> cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
auto@ data = loadExport(file);
|
|
file >> data;
|
|
@data.request = loadImport(file);
|
|
used.insertLast(data);
|
|
}
|
|
}
|
|
|
|
array<ImportData@> importIds;
|
|
ImportData@ loadImport(int id) {
|
|
if(id == -1)
|
|
return null;
|
|
for(uint i = 0, cnt = importIds.length; i < cnt; ++i) {
|
|
if(importIds[i].id == id)
|
|
return importIds[i];
|
|
}
|
|
ImportData data;
|
|
data.id = id;
|
|
importIds.insertLast(data);
|
|
return data;
|
|
}
|
|
ImportData@ loadImport(SaveFile& file) {
|
|
int id = -1;
|
|
file >> id;
|
|
if(id == -1)
|
|
return null;
|
|
else
|
|
return loadImport(id);
|
|
}
|
|
void saveImport(SaveFile& file, ImportData@ data) {
|
|
int id = -1;
|
|
if(data !is null)
|
|
id = data.id;
|
|
file << id;
|
|
}
|
|
array<ExportData@> exportIds;
|
|
ExportData@ loadExport(int id) {
|
|
if(id == -1)
|
|
return null;
|
|
for(uint i = 0, cnt = exportIds.length; i < cnt; ++i) {
|
|
if(exportIds[i].id == id)
|
|
return exportIds[i];
|
|
}
|
|
ExportData data;
|
|
data.id = id;
|
|
exportIds.insertLast(data);
|
|
return data;
|
|
}
|
|
ExportData@ loadExport(SaveFile& file) {
|
|
int id = -1;
|
|
file >> id;
|
|
if(id == -1)
|
|
return null;
|
|
else
|
|
return loadExport(id);
|
|
}
|
|
void saveExport(SaveFile& file, ExportData@ data) {
|
|
int id = -1;
|
|
if(data !is null)
|
|
id = data.id;
|
|
file << id;
|
|
}
|
|
void postLoad(AI& ai) {
|
|
importIds.length = 0;
|
|
exportIds.length = 0;
|
|
}
|
|
|
|
void start() {
|
|
focusTick(0);
|
|
}
|
|
|
|
void tick(double time) {
|
|
}
|
|
|
|
uint checkIdx = 0;
|
|
void focusTick(double time) {
|
|
//Do a check to make sure our resource export setup is still correct
|
|
if(used.length != 0) {
|
|
checkIdx = (checkIdx+1) % used.length;
|
|
ExportData@ res = used[checkIdx];
|
|
if(res.request !is null && res.request.obj !is null && !res.isExportedTo(res.request.obj)) {
|
|
if(log)
|
|
ai.print("Break export to "+res.request.obj.name+": link changed underfoot", res.obj);
|
|
breakImport(res);
|
|
}
|
|
else {
|
|
bool valid = true;
|
|
if(res.obj is null || res.obj.owner !is ai.empire || !res.obj.valid)
|
|
valid = false;
|
|
//Don't break these imports, we want to wait for the decay to happen
|
|
else if((res.request is null || !res.request.obj.hasSurfaceComponent || res.request.obj.decayTime <= 0) && !res.obj.isAsteroid && !res.usable) {
|
|
valid = false;
|
|
}
|
|
else if(res.request !is null) {
|
|
if(res.request.obj.owner !is ai.empire || !res.request.obj.valid)
|
|
valid = false;
|
|
}
|
|
if(!valid)
|
|
breakImport(res);
|
|
}
|
|
|
|
}
|
|
|
|
//TODO: Make sure universal unique only applies once per planet
|
|
|
|
//Match requested with available
|
|
for(uint i = 0, cnt = requested.length; i < cnt; ++i) {
|
|
auto@ req = requested[i];
|
|
req.cycled = true;
|
|
|
|
if(req.obj is null)
|
|
continue;
|
|
if(req.beingMet) {
|
|
ai.print("Error: Requested is being met", req.obj);
|
|
continue;
|
|
}
|
|
|
|
ExportData@ source;
|
|
double sourceWeight = 0.0;
|
|
|
|
for(uint j = 0, jcnt = available.length; j < jcnt; ++j) {
|
|
auto@ av = available[j];
|
|
if(av.request !is null) {
|
|
ai.print("Error: Available is being used", av.obj);
|
|
continue;
|
|
}
|
|
|
|
if(!req.spec.meets(av.resource, av.obj, req.obj))
|
|
continue;
|
|
if(!av.usable || av.obj is null || !av.obj.valid || av.obj.owner !is ai.empire)
|
|
continue;
|
|
if(!canTradeBetween(av.obj, req.obj))
|
|
continue;
|
|
if(av.localOnly && av.obj !is req.obj)
|
|
continue;
|
|
|
|
double weight = 1.0;
|
|
if(req.obj is av.obj)
|
|
weight = INFINITY;
|
|
|
|
if(weight > sourceWeight) {
|
|
sourceWeight = weight;
|
|
@source = av;
|
|
}
|
|
}
|
|
|
|
if(source !is null) {
|
|
link(req, source);
|
|
--i; --cnt;
|
|
}
|
|
}
|
|
}
|
|
|
|
void turn() {
|
|
}
|
|
|
|
bool get_hasOpenRequests() {
|
|
for(uint i = 0, cnt = requested.length; i < cnt; ++i) {
|
|
auto@ req = requested[i];
|
|
if(req.isOpen)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
TradePath tradePather;
|
|
int tradeDistance(Region& fromRegion, Region& toRegion) {
|
|
@tradePather.forEmpire = ai.empire;
|
|
tradePather.generate(getSystem(fromRegion), getSystem(toRegion), keepCache=true);
|
|
if(!tradePather.valid)
|
|
return -1;
|
|
return tradePather.pathSize - 1;
|
|
}
|
|
|
|
bool canTradeBetween(Object& fromObj, Object& toObj) {
|
|
Region@ fromRegion = fromObj.region;
|
|
if(fromRegion is null)
|
|
return false;
|
|
Region@ toRegion = toObj.region;
|
|
if(toRegion is null)
|
|
return false;
|
|
return canTradeBetween(fromRegion, toRegion);
|
|
}
|
|
|
|
bool canTradeBetween(Region& fromRegion, Region& toRegion) {
|
|
if(fromRegion.sharesTerritory(ai.empire, toRegion))
|
|
return true;
|
|
int dist = tradeDistance(fromRegion, toRegion);
|
|
if(dist < 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void link(ImportData@ req, ExportData@ source) {
|
|
//Manage the data
|
|
@source.request = req;
|
|
@source.developUse = null;
|
|
req.set(source);
|
|
|
|
requested.remove(req);
|
|
active.insertLast(req);
|
|
|
|
req.beingMet = true;
|
|
|
|
available.remove(source);
|
|
used.insertLast(source);
|
|
|
|
if(log)
|
|
ai.print("link "+source.resource.name+" from "+source.obj.name+" to "+req.obj.name);
|
|
|
|
//Perform the actual export
|
|
if(source.obj !is req.obj)
|
|
source.obj.exportResourceByID(source.resourceId, req.obj);
|
|
else
|
|
source.obj.exportResourceByID(source.resourceId, null);
|
|
}
|
|
|
|
ImportData@ requestResource(Object& toObject, ResourceSpec& spec, bool forLevel = false, bool activate = true, bool prioritize = false) {
|
|
ImportData data;
|
|
data.idleSince = gameTime;
|
|
data.id = nextImportId++;
|
|
@data.obj = toObject;
|
|
@data.spec = spec;
|
|
data.forLevel = forLevel;
|
|
|
|
if(log)
|
|
ai.print("requested resource: "+spec.dump(), toObject);
|
|
|
|
if(activate) {
|
|
if(prioritize)
|
|
requested.insertAt(0, data);
|
|
else
|
|
requested.insertLast(data);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
ExportData@ availableResource(Object& fromObject, const ResourceType& resource, int id) {
|
|
ExportData data;
|
|
data.id = nextExportId++;
|
|
@data.obj = fromObject;
|
|
@data.resource = resource;
|
|
data.resourceId = id;
|
|
|
|
if(log)
|
|
ai.print("available resource: "+resource.name, fromObject);
|
|
|
|
available.insertLast(data);
|
|
return data;
|
|
}
|
|
|
|
void checkReplaceCurrent(ExportData@ res) {
|
|
//If the planet that this resource is on is currently importing this same resource, switch it around
|
|
if(res.request !is null)
|
|
return;
|
|
|
|
for(uint i = 0, cnt = used.length; i < cnt; ++i) {
|
|
auto@ other = used[i];
|
|
auto@ request = other.request;
|
|
if(request is null)
|
|
continue;
|
|
if(request.obj !is res.obj)
|
|
continue;
|
|
|
|
if(request.spec.meets(res.resource, res.obj, res.obj)) {
|
|
//Swap the import with using the local resource
|
|
if(other.resource.exportable) {
|
|
breakImport(other);
|
|
link(request, res);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
array<Resource> checkResources;
|
|
array<ExportData@>@ availableResource(Object& fromObject) {
|
|
array<ExportData@> list;
|
|
|
|
checkResources.syncFrom(fromObject.getNativeResources());
|
|
|
|
uint nativeCount = checkResources.length;
|
|
for(uint i = 0; i < nativeCount; ++i) {
|
|
auto@ r = checkResources[i].type;
|
|
if(r !is null)
|
|
list.insertLast(availableResource(fromObject, r, checkResources[i].id));
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
ExportData@ findResource(Object@ obj, int resourceId) {
|
|
for(uint i = 0, cnt = available.length; i < cnt; ++i) {
|
|
if(available[i].obj is obj && available[i].resourceId == resourceId)
|
|
return available[i];
|
|
}
|
|
for(uint i = 0, cnt = used.length; i < cnt; ++i) {
|
|
if(used[i].obj is obj && used[i].resourceId == resourceId)
|
|
return used[i];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
ImportData@ findUnclaimed(ExportData@ forResource) {
|
|
for(uint i = 0, cnt = requested.length; i < cnt; ++i) {
|
|
auto@ req = requested[i];
|
|
if(req.claimedFor)
|
|
continue;
|
|
if(req.beingMet)
|
|
continue;
|
|
|
|
if(!req.spec.meets(forResource.resource, forResource.obj, req.obj))
|
|
continue;
|
|
if(!canTradeBetween(req.obj, forResource.obj))
|
|
continue;
|
|
|
|
return req;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
void breakImport(ImportData@ data) {
|
|
if(data.fromObject !is null) {
|
|
auto@ source = findResource(data.fromObject, data.resourceId);
|
|
if(source !is null) {
|
|
breakImport(source);
|
|
return;
|
|
}
|
|
}
|
|
|
|
@data.fromObject = null;
|
|
data.resourceId = -1;
|
|
data.beingMet = false;
|
|
data.idleSince = gameTime;
|
|
|
|
active.remove(data);
|
|
requested.insertAt(0, data);
|
|
}
|
|
|
|
void breakImport(ExportData@ data) {
|
|
if(data.request !is null) {
|
|
if(data.request.obj !is data.obj)
|
|
data.obj.exportResource(data.resourceId, null);
|
|
|
|
data.request.beingMet = false;
|
|
@data.request.fromObject = null;
|
|
data.request.resourceId = -1;
|
|
data.request.idleSince = gameTime;
|
|
|
|
active.remove(data.request);
|
|
requested.insertAt(0, data.request);
|
|
|
|
@data.request = null;
|
|
}
|
|
|
|
used.remove(data);
|
|
available.insertLast(data);
|
|
}
|
|
|
|
void cancelRequest(ImportData@ data) {
|
|
if(data.beingMet) {
|
|
breakImport(data);
|
|
active.remove(data);
|
|
}
|
|
else {
|
|
requested.remove(data);
|
|
}
|
|
}
|
|
|
|
void removeResource(ExportData@ data) {
|
|
if(data.request !is null) {
|
|
breakImport(data);
|
|
used.remove(data);
|
|
@data.obj = null;
|
|
}
|
|
else {
|
|
available.remove(data);
|
|
@data.obj = null;
|
|
}
|
|
}
|
|
|
|
ImportData@ claimImport(ImportData@ data) {
|
|
data.beingMet = true;
|
|
requested.remove(data);
|
|
active.insertLast(data);
|
|
return data;
|
|
}
|
|
|
|
void relinquishImport(ImportData@ data) {
|
|
data.beingMet = false;
|
|
active.remove(data);
|
|
requested.insertLast(data);
|
|
}
|
|
|
|
void organizeImports(Object& obj, int targetLevel, ImportData@ before = null) {
|
|
//Organize any imports for this object so it tries to get to a particular target level
|
|
if(log)
|
|
ai.print("Organizing imports for level", obj, targetLevel);
|
|
|
|
//Get the requirement list
|
|
const PlanetLevel@ lvl = getPlanetLevel(obj, targetLevel);
|
|
if(lvl is null) {
|
|
ai.print("Error: could not find planet level", obj, targetLevel);
|
|
return; //Welp, can't do nothing here
|
|
}
|
|
|
|
//Collect all the requests this planet currently has outstanding
|
|
array<ImportData@> activeRequests;
|
|
for(uint i = 0, cnt = requested.length; i < cnt; ++i) {
|
|
auto@ req = requested[i];
|
|
if(req.obj !is obj)
|
|
continue;
|
|
if(!req.forLevel)
|
|
continue;
|
|
|
|
activeRequests.insertLast(req);
|
|
}
|
|
for(uint i = 0, cnt = active.length; i < cnt; ++i) {
|
|
auto@ req = active[i];
|
|
if(req.obj !is obj)
|
|
continue;
|
|
if(!req.forLevel)
|
|
continue;
|
|
|
|
activeRequests.insertLast(req);
|
|
}
|
|
|
|
//TODO: This needs to be able to deal with dummy resources
|
|
|
|
//Match import requests with level requirements
|
|
array<ResourceSpec@> addSpecs;
|
|
const ResourceRequirements@ reqs = lvl.reqs;
|
|
|
|
for(uint i = 0, cnt = reqs.reqs.length; i < cnt; ++i) {
|
|
auto@ need = reqs.reqs[i];
|
|
for(uint n = 0; n < need.amount; ++n)
|
|
addSpecs.insertLast(implementSpec(need));
|
|
}
|
|
|
|
if(race !is null)
|
|
race.levelRequirements(obj, targetLevel, addSpecs);
|
|
|
|
for(uint i = 0, cnt = addSpecs.length; i < cnt; ++i) {
|
|
auto@ spec = addSpecs[i];
|
|
|
|
bool foundMatch = false;
|
|
for(uint j = 0, jcnt = activeRequests.length; j < jcnt; ++j) {
|
|
if(activeRequests[j].spec == spec) {
|
|
foundMatch = true;
|
|
activeRequests.removeAt(j);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(foundMatch) {
|
|
addSpecs.removeAt(i);
|
|
--i; --cnt;
|
|
}
|
|
}
|
|
|
|
//Cancel any import requests that we don't need anymore
|
|
for(uint i = 0, cnt = activeRequests.length; i < cnt; ++i)
|
|
cancelRequest(activeRequests[i]);
|
|
|
|
//Insert any imports above any imports of the planet we're exporting to
|
|
int place = -1;
|
|
if(before !is null) {
|
|
for(uint i = 0, cnt = requested.length; i < cnt; ++i) {
|
|
if(requested[i] is before) {
|
|
place = int(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Insert everything we need to add
|
|
addSpecs.sortDesc();
|
|
for(uint i = 0, cnt = addSpecs.length; i < cnt; ++i) {
|
|
ImportData@ req = requestResource(obj, addSpecs[i], forLevel=true, activate=false);
|
|
if(place == -1) {
|
|
requested.insertLast(req);
|
|
}
|
|
else {
|
|
requested.insertAt(place, req);
|
|
place += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void killImportsTo(Object& obj) {
|
|
for(uint i = 0, cnt = requested.length; i < cnt; ++i) {
|
|
if(requested[i].obj is obj) {
|
|
cancelRequest(requested[i]);
|
|
--i; --cnt;
|
|
}
|
|
}
|
|
for(uint i = 0, cnt = active.length; i < cnt; ++i) {
|
|
if(active[i].obj is obj) {
|
|
cancelRequest(active[i]);
|
|
--i; --cnt;
|
|
}
|
|
}
|
|
}
|
|
|
|
void killResourcesFrom(Object& obj) {
|
|
for(uint i = 0, cnt = available.length; i < cnt; ++i) {
|
|
if(available[i].obj is obj) {
|
|
removeResource(available[i]);
|
|
--i; --cnt;
|
|
}
|
|
}
|
|
for(uint i = 0, cnt = used.length; i < cnt; ++i) {
|
|
if(used[i].obj is obj) {
|
|
removeResource(used[i]);
|
|
--i; --cnt;
|
|
}
|
|
}
|
|
}
|
|
|
|
ImportData@ getImport(const string& fromName, uint index = 0) {
|
|
for(uint i = 0, cnt = requested.length; i < cnt; ++i) {
|
|
if(requested[i].obj.name.equals_nocase(fromName)) {
|
|
if(index == 0)
|
|
return requested[i];
|
|
else
|
|
index -= 1;
|
|
}
|
|
}
|
|
for(uint i = 0, cnt = active.length; i < cnt; ++i) {
|
|
if(active[i].obj.name.equals_nocase(fromName)) {
|
|
if(index == 0)
|
|
return active[i];
|
|
else
|
|
index -= 1;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
ExportData@ getExport(const string& fromName, uint index = 0) {
|
|
for(uint i = 0, cnt = available.length; i < cnt; ++i) {
|
|
if(available[i].obj.name.equals_nocase(fromName)) {
|
|
if(index == 0)
|
|
return available[i];
|
|
else
|
|
index -= 1;
|
|
}
|
|
}
|
|
for(uint i = 0, cnt = used.length; i < cnt; ++i) {
|
|
if(used[i].obj.name.equals_nocase(fromName)) {
|
|
if(index == 0)
|
|
return used[i];
|
|
else
|
|
index -= 1;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
void getImportsOf(array<ImportData@>& output, uint resType, Planet@ toPlanet = null) {
|
|
for(uint i = 0, cnt = active.length; i < cnt; ++i) {
|
|
auto@ req = active[i];
|
|
if(req.spec.type != RST_Specific)
|
|
continue;
|
|
if(req.spec.resource.id != resType)
|
|
continue;
|
|
if(toPlanet !is null && req.obj !is toPlanet)
|
|
continue;
|
|
output.insertLast(req);
|
|
}
|
|
for(uint i = 0, cnt = requested.length; i < cnt; ++i) {
|
|
auto@ req = requested[i];
|
|
if(req.spec.type != RST_Specific)
|
|
continue;
|
|
if(req.spec.resource.id != resType)
|
|
continue;
|
|
if(toPlanet !is null && req.obj !is toPlanet)
|
|
continue;
|
|
output.insertLast(req);
|
|
}
|
|
}
|
|
|
|
void dumpRequests(Object@ forObject = null) {
|
|
for(uint i = 0, cnt = requested.length; i < cnt; ++i) {
|
|
if(forObject !is null && requested[i].obj !is forObject)
|
|
continue;
|
|
print(requested[i].obj.name+" requests "+requested[i].spec.dump());
|
|
}
|
|
if(forObject !is null) {
|
|
for(uint i = 0, cnt = used.length; i < cnt; ++i) {
|
|
if(used[i].request is null || used[i].request.obj !is forObject)
|
|
continue;
|
|
print(used[i].request.obj.name+" is getting "+used[i].request.spec.dump()+" from "+used[i].obj.name);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
AIComponent@ createResources() {
|
|
return Resources();
|
|
}
|