Open source Star Ruler 2 source code!
This commit is contained in:
Lucas de Vries
@@ -0,0 +1,712 @@
|
||||
import settings.game_settings;
|
||||
from empire_ai.EmpireAI import AIController;
|
||||
|
||||
import AIComponent@ createColonization() from "empire_ai.weasel.Colonization";
|
||||
import AIComponent@ createResources() from "empire_ai.weasel.Resources";
|
||||
import AIComponent@ createPlanets() from "empire_ai.weasel.Planets";
|
||||
import AIComponent@ createSystems() from "empire_ai.weasel.Systems";
|
||||
import AIComponent@ createFleets() from "empire_ai.weasel.Fleets";
|
||||
import AIComponent@ createScouting() from "empire_ai.weasel.Scouting";
|
||||
import AIComponent@ createDevelopment() from "empire_ai.weasel.Development";
|
||||
import AIComponent@ createDesigns() from "empire_ai.weasel.Designs";
|
||||
import AIComponent@ createBudget() from "empire_ai.weasel.Budget";
|
||||
import AIComponent@ createConstruction() from "empire_ai.weasel.Construction";
|
||||
import AIComponent@ createMilitary() from "empire_ai.weasel.Military";
|
||||
import AIComponent@ createMovement() from "empire_ai.weasel.Movement";
|
||||
import AIComponent@ createCreeping() from "empire_ai.weasel.Creeping";
|
||||
import AIComponent@ createRelations() from "empire_ai.weasel.Relations";
|
||||
import AIComponent@ createIntelligence() from "empire_ai.weasel.Intelligence";
|
||||
import AIComponent@ createWar() from "empire_ai.weasel.War";
|
||||
import AIComponent@ createResearch() from "empire_ai.weasel.Research";
|
||||
import AIComponent@ createEnergy() from "empire_ai.weasel.Energy";
|
||||
import IAIComponent@ createDiplomacy() from "empire_ai.weasel.Diplomacy";
|
||||
import AIComponent@ createConsider() from "empire_ai.weasel.Consider";
|
||||
import AIComponent@ createOrbitals() from "empire_ai.weasel.Orbitals";
|
||||
|
||||
import AIComponent@ createHyperdrive() from "empire_ai.weasel.ftl.Hyperdrive";
|
||||
import AIComponent@ createGate() from "empire_ai.weasel.ftl.Gate";
|
||||
import AIComponent@ createFling() from "empire_ai.weasel.ftl.Fling";
|
||||
import AIComponent@ createSlipstream() from "empire_ai.weasel.ftl.Slipstream";
|
||||
import AIComponent@ createJumpdrive() from "empire_ai.weasel.ftl.Jumpdrive";
|
||||
|
||||
import AIComponent@ createVerdant() from "empire_ai.weasel.race.Verdant";
|
||||
import AIComponent@ createMechanoid() from "empire_ai.weasel.race.Mechanoid";
|
||||
import AIComponent@ createStarChildren() from "empire_ai.weasel.race.StarChildren";
|
||||
import AIComponent@ createExtragalactic() from "empire_ai.weasel.race.Extragalactic";
|
||||
import AIComponent@ createLinked() from "empire_ai.weasel.race.Linked";
|
||||
import AIComponent@ createDevout() from "empire_ai.weasel.race.Devout";
|
||||
import AIComponent@ createAncient() from "empire_ai.weasel.race.Ancient";
|
||||
|
||||
import AIComponent@ createInvasion() from "empire_ai.weasel.misc.Invasion";
|
||||
import bool hasInvasionMap() from "Invasion.InvasionMap";
|
||||
|
||||
from buildings import BuildingType;
|
||||
from orbitals import OrbitalModule;
|
||||
import util.formatting;
|
||||
|
||||
from empire import ai_full_speed;
|
||||
|
||||
from traits import getTraitID;
|
||||
|
||||
export IAIComponent, AIComponent, AI;
|
||||
uint GUARD = 0xDEADBEEF;
|
||||
|
||||
enum AddedComponent {
|
||||
AC_Invasion = 0x1,
|
||||
};
|
||||
|
||||
interface IAIComponent : Savable {
|
||||
void set(AI& ai);
|
||||
void setLog();
|
||||
void setLogCritical();
|
||||
|
||||
double getPrevFocus();
|
||||
void setPrevFocus(double value);
|
||||
|
||||
void create();
|
||||
void start();
|
||||
|
||||
void tick(double time);
|
||||
void focusTick(double time);
|
||||
void turn();
|
||||
|
||||
void save(SaveFile& file);
|
||||
void load(SaveFile& file);
|
||||
void postLoad(AI& ai);
|
||||
void postSave(AI& ai);
|
||||
void loadFinalize(AI& ai);
|
||||
};
|
||||
|
||||
class AIComponent : IAIComponent, Savable {
|
||||
AI@ ai;
|
||||
double prevFocus = 0;
|
||||
bool log = false;
|
||||
bool logCritical = false;
|
||||
bool logErrors = true;
|
||||
|
||||
double getPrevFocus() { return prevFocus; }
|
||||
void setPrevFocus(double value) { prevFocus = value; }
|
||||
|
||||
void setLog() { log = true; }
|
||||
void setLogCritical() { logCritical = true; }
|
||||
|
||||
void set(AI& ai) { @this.ai = ai; }
|
||||
void create() {}
|
||||
void start() {}
|
||||
|
||||
void tick(double time) {}
|
||||
void focusTick(double time) {}
|
||||
void turn() {}
|
||||
|
||||
void save(SaveFile& file) {}
|
||||
void load(SaveFile& file) {}
|
||||
void postLoad(AI& ai) {}
|
||||
void postSave(AI& ai) {}
|
||||
void loadFinalize(AI& ai) {}
|
||||
};
|
||||
|
||||
class ProfileData {
|
||||
double tickPeak = 0.0;
|
||||
double tickAvg = 0.0;
|
||||
double tickCount = 0.0;
|
||||
|
||||
double focusPeak = 0.0;
|
||||
double focusAvg = 0.0;
|
||||
double focusCount = 0.0;
|
||||
};
|
||||
|
||||
final class AIBehavior {
|
||||
//How many focuses we can manage in a tick
|
||||
uint focusPerTick = 2;
|
||||
|
||||
//The maximum colonizations this AI can do in one turn
|
||||
uint maxColonizations = UINT_MAX;
|
||||
//How many colonizations we're guaranteed to be able to do in one turn regardless of finances
|
||||
uint guaranteeColonizations = 2;
|
||||
//How many colonizations at most we can be doing at once
|
||||
uint maxConcurrentColonizations = UINT_MAX;
|
||||
//Whether this AI will colonize planets in systems owned by someone else
|
||||
// TODO: This should be partially ignored for border systems, so it can try to aggressively expand into the border
|
||||
bool colonizeEnemySystems = false;
|
||||
bool colonizeNeutralOwnedSystems = false;
|
||||
bool colonizeAllySystems = false;
|
||||
//How much this AI values claiming new systems instead of colonizing stuff in its existing ones
|
||||
double weightOutwardExpand = 2.0;
|
||||
//How much money this AI considers a colonization event to cost out of the budget
|
||||
int colonizeBudgetCost = 80;
|
||||
//Whether to do any generic expansion beyond any requests
|
||||
bool colonizeGenericExpand = true;
|
||||
//Latest percentage into a budget cycle that we still allow colonization
|
||||
double colonizeMaxBudgetProgress = 0.66;
|
||||
//Time after initial ownership change that an incomplete colonization is canceled
|
||||
double colonizeFailGraceTime = 100.0;
|
||||
//Time a planet that we failed to colonize is disregarded for colonization
|
||||
double colonizePenalizeTime = 9.0 * 60.0;
|
||||
|
||||
//Maximum amount of scouting missions that can be performed simultaneously
|
||||
uint maxScoutingMissions = UINT_MAX;
|
||||
//Minimum time after losing vision over a system that we can scout it again
|
||||
double minScoutingInterval = 3.0 * 60.0;
|
||||
//Weight that it gives to exploring things near our empire instead of greedily exploring nearby things
|
||||
double exploreBorderWeight = 2.0;
|
||||
//How long we consider all fleets viable for scouting with
|
||||
double scoutAllTimer = 3.0 * 60.0;
|
||||
//How many scouts we want to have active
|
||||
uint scoutsActive = 2;
|
||||
//How many scanning missions we can do at once
|
||||
uint maxScanningMissions = 1;
|
||||
//Whether to prioritize scouting over scanning if we only have one scout
|
||||
bool prioritizeScoutOverScan = true;
|
||||
|
||||
//Weights for what to do in generic planet development
|
||||
// Leveling up an existing development focus
|
||||
double focusDevelopWeight = 1.0;
|
||||
// Colonizing a new scalable or high tier to focus on
|
||||
double focusColonizeNewWeight = 4.0;
|
||||
// Colonizing a new high tier resource to import to one of our focuses
|
||||
double focusColonizeHighTierWeight = 1.0;
|
||||
|
||||
//How many potential designs are evaluated before choosing the best one
|
||||
uint designEvaluateCount = 10;
|
||||
//How long a fleet has to be fully idle before it returns to its stationed system
|
||||
double fleetIdleReturnStationedTime = 60.0;
|
||||
//How long we try to have a fleet be capable of firing before running out of supplies
|
||||
double fleetAimSupplyDuration = 2.0 * 60.0;
|
||||
|
||||
//How long a potential construction can take at most before we consider it unreasonable
|
||||
double constructionMaxTime = 10.0 * 60.0;
|
||||
//How long a factory has to have been idle for us to consider constructing labor storage
|
||||
double laborStoreIdleTimer = 60.0;
|
||||
//Maximum amount of time worth of labor we want to store in our warehouses
|
||||
double laborStoreMaxFillTime = 60.0 * 10.0;
|
||||
//Whether to use labor to build asteroids in the background
|
||||
bool backgroundBuildAsteroids = true;
|
||||
//Whether to choose the best resource on an asteroid, instead of doing it randomly
|
||||
bool chooseAsteroidResource = true;
|
||||
//Whether to distribute labor to shipyards when planets are idle
|
||||
bool distributeLaborExports = true;
|
||||
//Whether to build a shipyard to consolidate multiple planets of labor where possible
|
||||
bool consolidateLaborExports = true;
|
||||
//Estimate amount of labor spent per point of support ship size
|
||||
double estSizeSupportLabor = 0.25;
|
||||
|
||||
//Maximum combat fleets we can have in service at once (counts starting fleet(s))
|
||||
uint maxActiveFleets = UINT_MAX;
|
||||
//How much flagship size we try to make per available money
|
||||
double shipSizePerMoney = 1.0 / 3.5;
|
||||
//How much flagship size we try to make per available labor
|
||||
double shipSizePerLabor = 1.0 / 0.33;
|
||||
//How much maintenance we expect per ship size
|
||||
double maintenancePerShipSize = 2.0;
|
||||
//Minimum percentage increase in size before we decide to retrofit a flagship to be bigger
|
||||
double shipRetrofitThreshold = 0.5;
|
||||
//Whether to retrofit our free starting fleet if appropriate
|
||||
bool retrofitFreeFleets = false;
|
||||
//Minimum percentage of average current flagship size new fleets should be
|
||||
double flagshipBuildMinAvgSize = 1.00;
|
||||
//Minimum game time before we consider constructing new flagships
|
||||
double flagshipBuildMinGameTime = 4.0 * 60.0;
|
||||
//Whether to build factories when we need labor
|
||||
bool buildFactoryForLabor = true;
|
||||
//Whether to build warehouses when we're not using labor
|
||||
bool buildLaborStorage = true;
|
||||
//Whether factories can queue labor resource imports when needed
|
||||
bool allowRequestLaborImports = true;
|
||||
//Whether fleets with ghosted supports attempt to rebuild the ghosts or just clear them
|
||||
bool fleetsRebuildGhosts = true;
|
||||
//When trying to order supports on a fleet, wait for the planet to construct its supports so we can claim them
|
||||
bool supportOrderWaitOnFactory = true;
|
||||
|
||||
//How much stronger we need to be than a remnant fleet to clear it
|
||||
double remnantOverkillFactor = 1.5;
|
||||
//Whether to allow idle fleets to be sent to clear remnants
|
||||
// Modified by Relations
|
||||
bool remnantAllowArbitraryClear = true;
|
||||
|
||||
//Whether we should aggressively try to take out enemies
|
||||
bool aggressive = false;
|
||||
//Whether to become aggressive after we get boxed in and can no longer expand anywhere
|
||||
bool aggressiveWhenBoxedIn = false;
|
||||
//Whether we should never declare war ourselves
|
||||
bool passive = false;
|
||||
//Whether to hate human players the most
|
||||
bool biased = false;
|
||||
//How much stronger we need to be than someone to declare war out of hatred
|
||||
double hatredWarOverkill = 0.5;
|
||||
//How much stronger we need to be than someone to try to take them out in an aggressive war
|
||||
double aggressiveWarOverkill = 1.5;
|
||||
//How much stronger we want to be before we attack a system
|
||||
double attackStrengthOverkill = 1.5;
|
||||
//How many battles we can be performing at once
|
||||
uint maxBattles = UINT_MAX;
|
||||
//How much we try to overkill while fighting
|
||||
double battleStrengthOverkill = 1.5;
|
||||
//How many fleets we don't commit to attacks when we're already currently fighting
|
||||
uint battleReserveFleets = 1;
|
||||
//How much extra supply we try to have before starting a capture, to make sure we can actually do it
|
||||
double captureSupplyEstimate = 1.5;
|
||||
//Maximum hop distance we use as staging areas for our attacks
|
||||
int stagingMaxHops = 5;
|
||||
//If our fleet fill is less than this, immediately move back to factory from staging
|
||||
double stagingToFactoryFill = 0.6;
|
||||
|
||||
//How much ftl is reserved for critical applications
|
||||
double ftlReservePctCritical = 0.25;
|
||||
//How much ftl is reserved to not be used for background applications
|
||||
double ftlReservePctNormal = 0.25;
|
||||
|
||||
//How many artifacts we consider where to use per focus turn
|
||||
uint artifactFocusConsiderCount = 2;
|
||||
|
||||
//How long after trying to build a generically requested building we give up
|
||||
double genericBuildExpire = 3.0 * 60.0;
|
||||
|
||||
//How much the hate in a relationship decays to every minute
|
||||
double hateDecayRate = 0.9;
|
||||
//How much weaker we need to be to even consider surrender
|
||||
double surrenderMinStrength = 0.5;
|
||||
//How many of our total war points have to be taken by an empire for us to surrender
|
||||
double acceptSurrenderRatio = 0.75;
|
||||
double offerSurrenderRatio = 0.5;
|
||||
|
||||
void setDifficulty(int diff, uint flags) {
|
||||
//This changes the behavior values based on difficulty and flags
|
||||
if(flags & AIF_Aggressive != 0)
|
||||
aggressive = true;
|
||||
if(flags & AIF_Passive != 0)
|
||||
passive = true;
|
||||
if(flags & AIF_Biased != 0)
|
||||
biased = true;
|
||||
|
||||
//Low difficulties can't colonize as many things at once
|
||||
if(diff <= 0) {
|
||||
maxConcurrentColonizations = 1;
|
||||
guaranteeColonizations = 1;
|
||||
weightOutwardExpand = 0.5;
|
||||
}
|
||||
else if(diff <= 1) {
|
||||
maxConcurrentColonizations = 2;
|
||||
weightOutwardExpand = 1.0;
|
||||
}
|
||||
|
||||
//Hard AI becomes aggressive when it gets boxed in
|
||||
aggressiveWhenBoxedIn = diff >= 2;
|
||||
|
||||
//Easy difficulty can't attack and defend at the same time
|
||||
if(diff <= 0)
|
||||
maxBattles = 1;
|
||||
|
||||
//Low difficulties aren't as good at managing labor
|
||||
if(diff <= 0) {
|
||||
distributeLaborExports = false;
|
||||
consolidateLaborExports = false;
|
||||
buildLaborStorage = false;
|
||||
}
|
||||
else if(diff <= 1) {
|
||||
consolidateLaborExports = false;
|
||||
}
|
||||
|
||||
//Low difficulties aren't as good at managing fleets
|
||||
if(diff <= 0) {
|
||||
maxActiveFleets = 2;
|
||||
retrofitFreeFleets = true;
|
||||
}
|
||||
|
||||
//Low difficulties aren't as good at scouting
|
||||
if(diff <= 1)
|
||||
scoutAllTimer = 0.0;
|
||||
|
||||
//Low difficulties are worse at designing
|
||||
if(diff <= 0)
|
||||
designEvaluateCount = 3;
|
||||
else if(diff <= 1)
|
||||
designEvaluateCount = 8;
|
||||
else
|
||||
designEvaluateCount = 12;
|
||||
|
||||
//Easy is a bit slow
|
||||
if(diff <= 0)
|
||||
focusPerTick = 1;
|
||||
else if(diff >= 2)
|
||||
focusPerTick = 3;
|
||||
}
|
||||
};
|
||||
|
||||
final class AIDefs {
|
||||
const BuildingType@ Factory;
|
||||
const BuildingType@ LaborStorage;
|
||||
const OrbitalModule@ Shipyard;
|
||||
};
|
||||
|
||||
final class AI : AIController, Savable {
|
||||
Empire@ empire;
|
||||
AIBehavior behavior;
|
||||
AIDefs defs;
|
||||
|
||||
int cycleId = -1;
|
||||
uint componentCycle = 0;
|
||||
uint addedComponents = 0;
|
||||
|
||||
uint majorMask = 0;
|
||||
uint difficulty = 0;
|
||||
uint flags = 0;
|
||||
bool isLoading = false;
|
||||
|
||||
array<IAIComponent@> components;
|
||||
array<ProfileData> profileData;
|
||||
IAIComponent@ fleets;
|
||||
IAIComponent@ budget;
|
||||
IAIComponent@ colonization;
|
||||
IAIComponent@ resources;
|
||||
IAIComponent@ planets;
|
||||
IAIComponent@ systems;
|
||||
IAIComponent@ scouting;
|
||||
IAIComponent@ development;
|
||||
IAIComponent@ designs;
|
||||
IAIComponent@ construction;
|
||||
IAIComponent@ military;
|
||||
IAIComponent@ movement;
|
||||
IAIComponent@ creeping;
|
||||
IAIComponent@ relations;
|
||||
IAIComponent@ intelligence;
|
||||
IAIComponent@ war;
|
||||
IAIComponent@ research;
|
||||
IAIComponent@ energy;
|
||||
IAIComponent@ diplomacy;
|
||||
IAIComponent@ consider;
|
||||
IAIComponent@ orbitals;
|
||||
|
||||
IAIComponent@ ftl;
|
||||
IAIComponent@ race;
|
||||
|
||||
IAIComponent@ invasion;
|
||||
|
||||
void createComponents() {
|
||||
//NOTE: This is also save/load order, so
|
||||
//make sure to add loading logic when changing this list
|
||||
@budget = add(createBudget());
|
||||
@planets = add(createPlanets());
|
||||
@resources = add(createResources());
|
||||
@colonization = add(createColonization());
|
||||
@systems = add(createSystems());
|
||||
@fleets = add(createFleets());
|
||||
@scouting = add(createScouting());
|
||||
@development = add(createDevelopment());
|
||||
@designs = add(createDesigns());
|
||||
@construction = add(createConstruction());
|
||||
@military = add(createMilitary());
|
||||
@movement = add(createMovement());
|
||||
@creeping = add(createCreeping());
|
||||
@relations = add(createRelations());
|
||||
@intelligence = add(createIntelligence());
|
||||
@war = add(createWar());
|
||||
@research = add(createResearch());
|
||||
@energy = add(createEnergy());
|
||||
@diplomacy = add(createDiplomacy());
|
||||
@consider = add(createConsider());
|
||||
@orbitals = add(createOrbitals());
|
||||
|
||||
//Make FTL component
|
||||
if(empire.hasTrait(getTraitID("Hyperdrive")))
|
||||
@ftl = add(createHyperdrive());
|
||||
else if(empire.hasTrait(getTraitID("Gate")))
|
||||
@ftl = add(createGate());
|
||||
else if(empire.hasTrait(getTraitID("Fling")))
|
||||
@ftl = add(createFling());
|
||||
else if(empire.hasTrait(getTraitID("Slipstream")))
|
||||
@ftl = add(createSlipstream());
|
||||
else if(empire.hasTrait(getTraitID("Jumpdrive")))
|
||||
@ftl = add(createJumpdrive());
|
||||
|
||||
//Make racial component
|
||||
if(empire.hasTrait(getTraitID("Verdant")))
|
||||
@race = add(createVerdant());
|
||||
else if(empire.hasTrait(getTraitID("Mechanoid")))
|
||||
@race = add(createMechanoid());
|
||||
else if(empire.hasTrait(getTraitID("StarChildren")))
|
||||
@race = add(createStarChildren());
|
||||
else if(empire.hasTrait(getTraitID("Extragalactic")))
|
||||
@race = add(createExtragalactic());
|
||||
else if(empire.hasTrait(getTraitID("Linked")))
|
||||
@race = add(createLinked());
|
||||
else if(empire.hasTrait(getTraitID("Devout")))
|
||||
@race = add(createDevout());
|
||||
else if(empire.hasTrait(getTraitID("Ancient")))
|
||||
@race = add(createAncient());
|
||||
|
||||
//Misc components
|
||||
if(hasInvasionMap() || addedComponents & AC_Invasion != 0) {
|
||||
@invasion = add(createInvasion());
|
||||
addedComponents |= AC_Invasion;
|
||||
}
|
||||
|
||||
//if(empire is playerEmpire) {
|
||||
//log(race);
|
||||
// log(colonization);
|
||||
// log(resources);
|
||||
// log(construction);
|
||||
//}
|
||||
//log(intelligence);
|
||||
//logAll();
|
||||
logCritical();
|
||||
|
||||
profileData.length = components.length;
|
||||
for(uint i = 0, cnt = components.length; i < cnt; ++i)
|
||||
components[i].create();
|
||||
}
|
||||
|
||||
void createGeneral() {
|
||||
}
|
||||
|
||||
void init(Empire& emp, EmpireSettings& settings) {
|
||||
@this.empire = emp;
|
||||
flags = settings.aiFlags;
|
||||
difficulty = settings.difficulty;
|
||||
behavior.setDifficulty(difficulty, flags);
|
||||
|
||||
createComponents();
|
||||
}
|
||||
|
||||
int getDifficultyLevel() {
|
||||
return difficulty;
|
||||
}
|
||||
|
||||
void load(SaveFile& file) {
|
||||
file >> empire;
|
||||
file >> cycleId;
|
||||
file >> majorMask;
|
||||
file >> difficulty;
|
||||
file >> flags;
|
||||
if(file >= SV_0153)
|
||||
file >> addedComponents;
|
||||
behavior.setDifficulty(difficulty, flags);
|
||||
createComponents();
|
||||
createGeneral();
|
||||
|
||||
uint loadCnt = 0;
|
||||
file >> loadCnt;
|
||||
loadCnt = loadCnt;
|
||||
for(uint i = 0; i < loadCnt; ++i) {
|
||||
double prevFocus = 0;
|
||||
file >> prevFocus;
|
||||
components[i].setPrevFocus(prevFocus);
|
||||
file >> components[i];
|
||||
|
||||
uint check = 0;
|
||||
file >> check;
|
||||
if(check != GUARD)
|
||||
error("ERROR: AI Load error detected in component "+addrstr(components[i])+" of "+empire.name);
|
||||
}
|
||||
for(uint i = 0, cnt = components.length; i < cnt; ++i)
|
||||
components[i].postLoad(this);
|
||||
isLoading = true;
|
||||
}
|
||||
|
||||
void save(SaveFile& file) {
|
||||
file << empire;
|
||||
file << cycleId;
|
||||
file << majorMask;
|
||||
file << difficulty;
|
||||
file << flags;
|
||||
file << addedComponents;
|
||||
uint saveCnt = components.length;
|
||||
file << saveCnt;
|
||||
for(uint i = 0; i < saveCnt; ++i) {
|
||||
file << components[i].getPrevFocus();
|
||||
file << components[i];
|
||||
file << GUARD;
|
||||
}
|
||||
for(uint i = 0, cnt = components.length; i < cnt; ++i)
|
||||
components[i].postSave(this);
|
||||
}
|
||||
|
||||
void log(IAIComponent@ comp) {
|
||||
if(comp is null)
|
||||
return;
|
||||
comp.setLog();
|
||||
comp.setLogCritical();
|
||||
}
|
||||
|
||||
void logCritical() {
|
||||
for(uint i = 0, cnt = components.length; i < cnt; ++i)
|
||||
components[i].setLogCritical();
|
||||
}
|
||||
|
||||
void logAll() {
|
||||
for(uint i = 0, cnt = components.length; i < cnt; ++i) {
|
||||
components[i].setLog();
|
||||
components[i].setLogCritical();
|
||||
}
|
||||
}
|
||||
|
||||
IAIComponent@ add(IAIComponent& component) {
|
||||
component.set(this);
|
||||
components.insertLast(component);
|
||||
return component;
|
||||
}
|
||||
|
||||
void init(Empire& emp) {
|
||||
majorMask = 0;
|
||||
for(uint i = 0, cnt = getEmpireCount(); i < cnt; ++i) {
|
||||
Empire@ emp = getEmpire(i);
|
||||
if(emp.major)
|
||||
majorMask |= emp.mask;
|
||||
}
|
||||
|
||||
createGeneral();
|
||||
}
|
||||
|
||||
bool hasStarted = false;
|
||||
void tick(Empire& emp, double time) {
|
||||
if(isLoading) {
|
||||
for(uint i = 0, cnt = components.length; i < cnt; ++i)
|
||||
components[i].loadFinalize(this);
|
||||
isLoading = false;
|
||||
hasStarted = true;
|
||||
}
|
||||
else if(!hasStarted) {
|
||||
for(uint i = 0, cnt = components.length; i < cnt; ++i)
|
||||
components[i].start();
|
||||
hasStarted = true;
|
||||
}
|
||||
else if(emp.Victory == -1) {
|
||||
//Don't do anything when actually defeated
|
||||
return;
|
||||
}
|
||||
|
||||
//Manage gametime-specific behaviors
|
||||
behavior.colonizeGenericExpand = gameTime >= 6.0 * 60.0;
|
||||
|
||||
//Find cycled turns
|
||||
int curCycle = emp.BudgetCycleId;
|
||||
if(curCycle != cycleId) {
|
||||
for(uint i = 0, cnt = components.length; i < cnt; ++i)
|
||||
components[i].turn();
|
||||
cycleId = curCycle;
|
||||
}
|
||||
|
||||
//Generic ticks
|
||||
double startTime = getExactTime();
|
||||
for(uint i = 0, cnt = components.length; i < cnt; ++i) {
|
||||
auto@ comp = components[i];
|
||||
comp.tick(time);
|
||||
|
||||
double endTime = getExactTime();
|
||||
//double ms = 1000.0 * (endTime - startTime);
|
||||
startTime = endTime;
|
||||
|
||||
//auto@ dat = profileData[i];
|
||||
//dat.tickPeak = max(dat.tickPeak, ms);
|
||||
//dat.tickAvg += ms;
|
||||
//dat.tickCount += 1.0;
|
||||
}
|
||||
|
||||
//Do focuseds tick on components
|
||||
uint focusCount = behavior.focusPerTick;
|
||||
if(ai_full_speed.value == 1.0)
|
||||
focusCount = max(uint(round((time / 0.25) * behavior.focusPerTick)), behavior.focusPerTick);
|
||||
double allocStart = startTime;
|
||||
|
||||
for(uint n = 0; n < focusCount; ++n) {
|
||||
componentCycle = (componentCycle+1) % components.length;
|
||||
auto@ focusComp = components[componentCycle];
|
||||
focusComp.focusTick(gameTime - focusComp.getPrevFocus());
|
||||
focusComp.setPrevFocus(gameTime);
|
||||
|
||||
double endTime = getExactTime();
|
||||
//double ms = 1000.0 * (endTime - startTime);
|
||||
startTime = endTime;
|
||||
if(endTime - allocStart > 4000.0)
|
||||
break;
|
||||
|
||||
//auto@ dat = profileData[componentCycle];
|
||||
//dat.focusPeak = max(dat.focusPeak, ms);
|
||||
//dat.focusAvg += ms;
|
||||
//dat.focusCount += 1.0;
|
||||
}
|
||||
}
|
||||
|
||||
void dumpProfile() {
|
||||
for(uint i = 0, cnt = components.length; i < cnt; ++i) {
|
||||
auto@ c = profileData[i];
|
||||
print(pad(addrstr(components[i]), 40)+" tick peak "+toString(c.tickPeak,2)+" tick avg "+toString(c.tickAvg/c.tickCount, 2)
|
||||
+" focus peak "+toString(c.focusPeak,2)+" focus avg "+toString(c.focusAvg/c.focusCount, 2));
|
||||
}
|
||||
}
|
||||
|
||||
void resetProfile() {
|
||||
for(uint i = 0, cnt = profileData.length; i < cnt; ++i) {
|
||||
auto@ c = profileData[i];
|
||||
c.tickPeak = 0.0;
|
||||
c.tickAvg = 0.0;
|
||||
c.tickCount = 0.0;
|
||||
c.focusPeak = 0.0;
|
||||
c.focusAvg = 0.0;
|
||||
c.focusCount = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
uint get_mask() {
|
||||
return empire.mask;
|
||||
}
|
||||
|
||||
uint get_teamMask() {
|
||||
//TODO
|
||||
return empire.mask;
|
||||
}
|
||||
|
||||
uint get_visionMask() {
|
||||
return majorMask & empire.visionMask;
|
||||
}
|
||||
|
||||
uint get_allyMask() {
|
||||
return empire.mutualDefenseMask | empire.ForcedPeaceMask.value;
|
||||
}
|
||||
|
||||
uint get_enemyMask() {
|
||||
return empire.hostileMask & majorMask;
|
||||
}
|
||||
|
||||
uint get_neutralMask() {
|
||||
return majorMask & ~allyMask & ~mask & ~enemyMask;
|
||||
}
|
||||
|
||||
uint get_otherMask() {
|
||||
return majorMask & ~mask;
|
||||
}
|
||||
|
||||
string pad(const string& input, uint width) {
|
||||
string str = input;
|
||||
while(str.length < width)
|
||||
str += " ";
|
||||
return str;
|
||||
}
|
||||
|
||||
void print(const string& info, Object@ related = null, double value = INFINITY, bool flag = false, Empire@ emp = null) {
|
||||
string str = info;
|
||||
if(related !is null)
|
||||
str = pad(related.name, 16)+" | "+str;
|
||||
str = pad("["+empire.index+": "+empire.name+" AI] ", 20)+str;
|
||||
str = formatGameTime(gameTime) + " " + str;
|
||||
if(value != INFINITY)
|
||||
str += " | Value = "+standardize(value, true);
|
||||
if(flag)
|
||||
str += " | FLAGGED On";
|
||||
if(emp !is null)
|
||||
str += " | Target = "+emp.name;
|
||||
::print(str);
|
||||
}
|
||||
|
||||
void debugAI() {}
|
||||
void commandAI(string cmd) {}
|
||||
void aiPing(Empire@ fromEmpire, vec3d position, uint type) {}
|
||||
void pause(Empire& emp) {}
|
||||
void resume(Empire& emp) {}
|
||||
vec3d get_aiFocus() { return vec3d(); }
|
||||
string getOpinionOf(Empire& emp, Empire@ other) { return ""; }
|
||||
int getStandingTo(Empire& emp, Empire@ other) { return 0; }
|
||||
};
|
||||
|
||||
AIController@ createWeaselAI() {
|
||||
return AI();
|
||||
}
|
||||
Reference in New Issue
Block a user