Lucas de Vries
2417 lines
60 KiB
ActionScript
2417 lines
60 KiB
ActionScript
import systems;
|
|
import planet_loyalty;
|
|
import region_effects;
|
|
import saving;
|
|
import region_effects.ZealotRegion;
|
|
import notifications;
|
|
import statuses;
|
|
from resources import getLaborCost;
|
|
from cargo import hasDesignCosts;
|
|
from settings.game_settings import gameSettings;
|
|
from region_effects.GrantVision import GrantVision;
|
|
import constructions;
|
|
import hooks;
|
|
|
|
#section server
|
|
import object_creation;
|
|
import resources;
|
|
import civilians;
|
|
import achievements;
|
|
#section all
|
|
|
|
const uint ZealotMask = 0;
|
|
const double CIV_TIMER = 3.0 * 60.0;
|
|
const double TRADE_TIMER = 3.0 * 60.0;
|
|
const double STATION_TRADES = 6.0;
|
|
const double CIVILIAN_LIMIT_POW = 0.85;
|
|
|
|
tidy class RegionObjects : Component_RegionObjects, Savable {
|
|
SystemDesc@ system;
|
|
Star@[] starList;
|
|
Object@[] objectList;
|
|
Object@[] shipyardList;
|
|
Planet@[] planetList;
|
|
Orbital@[] orbitalList;
|
|
Asteroid@[] asteroidList;
|
|
Anomaly@[] anomalyList;
|
|
Pickup@[] pickupList;
|
|
Artifact@[] artifactList;
|
|
Object@[] resourceHolders;
|
|
RegionEffect@[] effects;
|
|
int nextEffectId = 1;
|
|
SystemPlaneNode@ plane;
|
|
bool planeParented = false;
|
|
TradeLinesNode@ tradeLines;
|
|
array<IconRing@> icons;
|
|
float combatTimer = 60.0;
|
|
double StarTemperature = 0;
|
|
double StarRadius = 0;
|
|
|
|
PlanetBucket planetBucket;
|
|
PickupBucket pickupBucket;
|
|
AsteroidBucket asteroidBucket;
|
|
ArtifactBucket artifactBucket;
|
|
AnomalyBucket anomalyBucket;
|
|
StarBucket starBucket;
|
|
|
|
double PeriodicUpdate = 0.0;
|
|
double PeriodicTime = 0.0;
|
|
|
|
double regionDPS = 0.0;
|
|
double starDPS = 0.0;
|
|
|
|
int[] strengths(getEmpireCount(), 0);
|
|
int[] planetCounts(getEmpireCount(), 0);
|
|
int[] objectCounts(getEmpireCount(), 0);
|
|
int[] visionGrants(getEmpireCount(), 0);
|
|
int[] tradeGrants(getEmpireCount(), 0);
|
|
Empire@[] primaryVision(getEmpireCount(), defaultEmpire);
|
|
Empire@ primaryEmpire;
|
|
|
|
double[] empLoyaltyBonus(getEmpireCount(), 0);
|
|
double[] neighbourLoyalty(getEmpireCount(), 0);
|
|
double[] localLoyalty(getEmpireCount(), 0);
|
|
uint HasMilitaryMask = 0;
|
|
uint HasPlanetsMask = 0;
|
|
uint visibleContested = CM_None;
|
|
|
|
uint TradeRequestMask = 0;
|
|
array<int> tradeCounter(getEmpireCount(), 0);
|
|
double tradeTimer = 0.0;
|
|
array<Civilian@> tradeStations;
|
|
uint HaveStationsMask = 0;
|
|
|
|
array<uint> regionStatusTypes;
|
|
array<double> regionStatusTimers;
|
|
array<Empire@> regionStatusEmps;
|
|
|
|
array<locked_Territory> territories(getEmpireCount());
|
|
|
|
RegionObjects() {
|
|
}
|
|
|
|
#section server
|
|
void load(SaveFile& msg) {
|
|
PeriodicUpdate = randomd();
|
|
|
|
uint cnt = 0;
|
|
msg >> cnt;
|
|
starList.length = cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
msg >> starList[i];
|
|
if(starList[i] !is null)
|
|
starBucket.add(starList[i]);
|
|
}
|
|
|
|
msg >> cnt;
|
|
objectList.length = cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg >> objectList[i];
|
|
|
|
msg >> cnt;
|
|
planetList.length = cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
msg >> planetList[i];
|
|
if(planetList[i] !is null)
|
|
planetBucket.add(planetList[i]);
|
|
}
|
|
|
|
msg >> cnt;
|
|
orbitalList.length = cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg >> orbitalList[i];
|
|
|
|
msg >> cnt;
|
|
asteroidList.length = cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
msg >> asteroidList[i];
|
|
if(asteroidList[i] !is null)
|
|
asteroidBucket.add(asteroidList[i]);
|
|
}
|
|
|
|
if(msg >= SV_0039) {
|
|
msg >> cnt;
|
|
anomalyList.length = cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
msg >> anomalyList[i];
|
|
if(anomalyList[i] !is null)
|
|
anomalyBucket.add(anomalyList[i]);
|
|
}
|
|
}
|
|
|
|
if(msg >= SV_0163) {
|
|
msg >> cnt;
|
|
artifactList.length = cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
msg >> artifactList[i];
|
|
if(artifactList[i] !is null)
|
|
artifactBucket.add(artifactList[i]);
|
|
}
|
|
|
|
msg >> cnt;
|
|
pickupList.length = cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
msg >> pickupList[i];
|
|
if(pickupList[i] !is null)
|
|
pickupBucket.add(pickupList[i]);
|
|
}
|
|
}
|
|
|
|
msg >> cnt;
|
|
shipyardList.length = cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg >> shipyardList[i];
|
|
|
|
msg >> cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
uint id = msg.readIdentifier(SI_RegionEffect);
|
|
const RegionEffectType@ type = getRegionEffect(id);
|
|
|
|
RegionEffect@ eff = type.create();
|
|
msg >> eff.id;
|
|
msg >> eff.forEmpire;
|
|
eff.load(msg);
|
|
effects.insertLast(eff);
|
|
}
|
|
|
|
msg >> cnt;
|
|
regionStatusTypes.length = cnt;
|
|
regionStatusTimers.length = cnt;
|
|
regionStatusEmps.length = cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
regionStatusTypes[i] = msg.readIdentifier(SI_Status);
|
|
msg >> regionStatusTimers[i];
|
|
msg >> regionStatusEmps[i];
|
|
}
|
|
|
|
msg >> nextEffectId;
|
|
msg >> primaryEmpire;
|
|
|
|
uint statCnt = getEmpireCount();
|
|
for(uint i = 0; i < statCnt; ++i) {
|
|
msg >> strengths[i];
|
|
msg >> objectCounts[i];
|
|
msg >> primaryVision[i];
|
|
msg >> planetCounts[i];
|
|
msg >> empLoyaltyBonus[i];
|
|
msg >> neighbourLoyalty[i];
|
|
msg >> localLoyalty[i];
|
|
msg >> visionGrants[i];
|
|
if(msg >= SV_0059)
|
|
msg >> tradeGrants[i];
|
|
territories[i].set(cast<Territory>(msg.readObject()));
|
|
if(msg >= SV_0048)
|
|
msg >> tradeCounter[i];
|
|
}
|
|
|
|
msg >> HasMilitaryMask;
|
|
msg >> HasPlanetsMask;
|
|
msg >> visibleContested;
|
|
msg >> combatTimer;
|
|
|
|
if(msg >= SV_0048) {
|
|
msg >> TradeRequestMask;
|
|
msg >> HaveStationsMask;
|
|
msg >> tradeTimer;
|
|
uint tCount = 0;
|
|
msg >> tCount;
|
|
tradeStations.length = tCount;
|
|
for(uint i = 0; i < tCount; ++i)
|
|
@tradeStations[i] = cast<Civilian>(msg.readObject());
|
|
}
|
|
|
|
if(msg >= SV_0103) {
|
|
msg >> regionDPS;
|
|
if(msg >= SV_0123)
|
|
msg >> starDPS;
|
|
}
|
|
}
|
|
|
|
void save(SaveFile& msg) {
|
|
uint cnt = starList.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg << starList[i];
|
|
|
|
cnt = objectList.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg << objectList[i];
|
|
|
|
cnt = planetList.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg << planetList[i];
|
|
|
|
cnt = orbitalList.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg << orbitalList[i];
|
|
|
|
cnt = asteroidList.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg << asteroidList[i];
|
|
|
|
cnt = anomalyList.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg << anomalyList[i];
|
|
|
|
cnt = artifactList.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg << artifactList[i];
|
|
|
|
cnt = pickupList.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg << pickupList[i];
|
|
|
|
cnt = shipyardList.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg << shipyardList[i];
|
|
|
|
cnt = effects.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
msg.writeIdentifier(SI_RegionEffect, effects[i].type.id);
|
|
msg << effects[i].id;
|
|
msg << effects[i].forEmpire;
|
|
effects[i].save(msg);
|
|
}
|
|
|
|
cnt = regionStatusTypes.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
msg << regionStatusTypes[i];
|
|
msg << regionStatusTimers[i];
|
|
msg << regionStatusEmps[i];
|
|
}
|
|
|
|
msg << nextEffectId;
|
|
msg << primaryEmpire;
|
|
|
|
uint statCnt = getEmpireCount();
|
|
for(uint i = 0; i < statCnt; ++i) {
|
|
msg << strengths[i];
|
|
msg << objectCounts[i];
|
|
msg << primaryVision[i];
|
|
msg << planetCounts[i];
|
|
msg << empLoyaltyBonus[i];
|
|
msg << neighbourLoyalty[i];
|
|
msg << localLoyalty[i];
|
|
msg << visionGrants[i];
|
|
msg << tradeGrants[i];
|
|
msg << territories[i].get();
|
|
msg << tradeCounter[i];
|
|
}
|
|
|
|
msg << HasMilitaryMask;
|
|
msg << HasPlanetsMask;
|
|
msg << visibleContested;
|
|
msg << combatTimer;
|
|
|
|
msg << TradeRequestMask;
|
|
msg << HaveStationsMask;
|
|
msg << tradeTimer;
|
|
uint tCount = tradeStations.length;
|
|
msg << tCount;
|
|
for(uint i = 0; i < tCount; ++i)
|
|
msg << tradeStations[i];
|
|
|
|
msg << regionDPS;
|
|
msg << starDPS;
|
|
}
|
|
|
|
void regionPostLoad(Object& obj) {
|
|
Region@ region = cast<Region>(obj);
|
|
@system = getSystem(region);
|
|
|
|
@plane = SystemPlaneNode();
|
|
plane.establish(region);
|
|
plane.setPrimaryEmpire(primaryEmpire);
|
|
plane.setContested(visibleContested);
|
|
plane.hintParentObject(obj, false);
|
|
|
|
StarTemperature = 0;
|
|
for(uint i = 0, cnt = starList.length; i < cnt; ++i)
|
|
StarTemperature += starList[i].temperature;
|
|
if(starList.length != 0)
|
|
StarRadius = starList[0].radius;
|
|
else
|
|
StarRadius = 0;
|
|
}
|
|
#section all
|
|
void addShipDebris(vec3d position, uint count = 1) {
|
|
if(plane !is null)
|
|
plane.addMetalDebris(position, count);
|
|
}
|
|
|
|
#section shadow
|
|
void save(SaveFile&){}
|
|
void load(SaveFile&){}
|
|
#section all
|
|
|
|
void registerShipyard(Object& region, Object& obj) {
|
|
shipyardList.insertLast(obj);
|
|
calculateShipyards(region);
|
|
}
|
|
|
|
void unregisterShipyard(Object& region, Object& obj) {
|
|
shipyardList.remove(obj);
|
|
calculateShipyards(region);
|
|
}
|
|
|
|
void regionBuildSupport(Object& obj, uint id, Object& forLeader, const Design@ design) {
|
|
if(shipyardList.length == 0)
|
|
return;
|
|
bool hasCosts = hasDesignCosts(design);
|
|
double laborCost = getLaborCost(design);
|
|
Object@ secondary;
|
|
bool havePrimary = false;
|
|
for(uint i = 0, cnt = shipyardList.length; i < cnt; ++i) {
|
|
Object@ yard = shipyardList[i];
|
|
if(yard.owner !is forLeader.owner)
|
|
continue;
|
|
if(!yard.canBuildSupports)
|
|
continue;
|
|
if(hasCosts && (!yard.hasCargo || yard.cargoTypes == 0))
|
|
continue;
|
|
double laborIncome = yard.laborIncome;
|
|
bool efficient = laborIncome > 0 && (laborCost / laborIncome) < 3.0 * 60.0;
|
|
if(yard.constructingSupport) {
|
|
if(efficient)
|
|
havePrimary = true;
|
|
continue;
|
|
}
|
|
if(!efficient) {
|
|
if(secondary is null)
|
|
@secondary = yard;
|
|
continue;
|
|
}
|
|
yard.buildSupport(id, design, forLeader);
|
|
return;
|
|
}
|
|
if(secondary !is null && !havePrimary) {
|
|
secondary.buildSupport(id, design, forLeader);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void requestConstructionOn(Object& onObj, uint constrId) {
|
|
auto@ constr = getConstructionType(constrId);
|
|
if(constr is null)
|
|
return;
|
|
if(shipyardList.length == 0)
|
|
return;
|
|
|
|
Targets targs(constr.targets);
|
|
if(targs.length != 0) {
|
|
targs[0].filled = true;
|
|
@targs[0].obj = onObj;
|
|
}
|
|
|
|
bool havePrimary = false;
|
|
Object@ primary;
|
|
Object@ secondary;
|
|
for(uint i = 0, cnt = shipyardList.length; i < cnt; ++i) {
|
|
auto@ yard = shipyardList[i];
|
|
if(yard is null || !constr.canBuild(yard, targs))
|
|
continue;
|
|
if(yard.owner !is onObj.owner)
|
|
continue;
|
|
|
|
double laborCost = constr.getLaborCost(yard, targs);
|
|
double laborIncome = yard.laborIncome;
|
|
bool efficient = laborIncome > 0 && (laborCost / laborIncome) < 3.0 * 60.0;
|
|
|
|
if(efficient) {
|
|
if(yard.constructionCount > 0) {
|
|
havePrimary = true;
|
|
continue;
|
|
}
|
|
@primary = yard;
|
|
}
|
|
else
|
|
@secondary = yard;
|
|
}
|
|
|
|
if(primary !is null)
|
|
primary.buildConstruction(constrId, objTarg=onObj);
|
|
else if(secondary !is null && !havePrimary)
|
|
secondary.buildConstruction(constrId, objTarg=onObj);
|
|
}
|
|
|
|
void initRegion(Object& obj) {
|
|
//Randomize vision check moment
|
|
PeriodicTime = PeriodicUpdate = double(uint8(obj.id)) / 255.0;
|
|
|
|
Region@ region = cast<Region>(obj);
|
|
region.AngleOffset = randomd(0, twopi);
|
|
|
|
//Create the plane
|
|
@plane = SystemPlaneNode();
|
|
plane.establish(region);
|
|
plane.hintParentObject(obj, false);
|
|
|
|
//Find system
|
|
@system = getSystem(cast<Region>(region));
|
|
}
|
|
|
|
double longTimer = 0.0;
|
|
void tickRegion(Object& region, double time) {
|
|
if(system is null) {
|
|
@system = getSystem(cast<Region>(region));
|
|
return;
|
|
}
|
|
|
|
if(plane !is null && !planeParented) {
|
|
planeParented = true;
|
|
plane.hintParentObject(region, false);
|
|
}
|
|
|
|
//Update contested flags
|
|
updateContested(region);
|
|
|
|
//Check vision periodically
|
|
if(PeriodicUpdate <= 0.0) {
|
|
//Update total interior vision
|
|
calculateVision(region);
|
|
#section server
|
|
//Update neighbouring loyalty
|
|
updateEmpLoyalty(region);
|
|
//Update effects of zealotry
|
|
updateZealotry(region);
|
|
//Update status effects
|
|
updateStatuses(region, PeriodicTime + (-PeriodicUpdate));
|
|
//Update civilian trade
|
|
updateCivilianTrade(region);
|
|
//Area damage
|
|
if(regionDPS > 0.0)
|
|
processDamage(region, PeriodicTime + (-PeriodicUpdate));
|
|
if(starDPS > 0.0) {
|
|
double time = PeriodicTime + (-PeriodicUpdate);
|
|
for(uint i = 0, cnt = starList.length; i < cnt; ++i)
|
|
starList[i].dealStarDamage(time * starDPS);
|
|
starDPS *= pow(0.75, time);
|
|
starDPS -= time;
|
|
}
|
|
#section all
|
|
|
|
PeriodicTime = PeriodicUpdate = randomd(0.9,1.1);
|
|
}
|
|
else {
|
|
PeriodicUpdate -= time;
|
|
}
|
|
|
|
longTimer -= time;
|
|
if(longTimer <= 0.0) {
|
|
Region@ reg = cast<Region>(region);
|
|
reg.SiegedMask = 0;
|
|
reg.SiegingMask = 0;
|
|
longTimer = 15.0;
|
|
}
|
|
|
|
#section server
|
|
//Update region effects
|
|
Region@ reg = cast<Region>(region);
|
|
for(uint i = 0, cnt = effects.length; i < cnt; ++i) {
|
|
if(!effects[i].tick(reg, time)) {
|
|
effects[i].end(reg);
|
|
effects.removeAt(i);
|
|
--i;
|
|
--cnt;
|
|
}
|
|
}
|
|
|
|
//Update the combat state
|
|
updateCombatState(reg, time);
|
|
|
|
#section shadow
|
|
if(prevMask != playerEmpire.visionMask) {
|
|
updatePlane(cast<Region>(region));
|
|
prevMask = playerEmpire.visionMask;
|
|
}
|
|
#section all
|
|
}
|
|
|
|
double getNeighbourLoyalty(Empire@ emp) {
|
|
if(emp is null || !emp.valid)
|
|
return 0;
|
|
return neighbourLoyalty[emp.index];
|
|
}
|
|
|
|
void modNeighbourLoyalty(Object& region, Empire@ emp, double mod) {
|
|
if(emp is null || !emp.valid)
|
|
return;
|
|
neighbourLoyalty[emp.index] += mod;
|
|
}
|
|
|
|
double getLocalLoyalty(Empire@ emp) {
|
|
if(emp is null || !emp.valid)
|
|
return 0;
|
|
return localLoyalty[emp.index];
|
|
}
|
|
|
|
void modLocalLoyalty(Object& region, Empire@ emp, double mod) {
|
|
if(emp is null || !emp.valid)
|
|
return;
|
|
localLoyalty[emp.index] += mod;
|
|
}
|
|
|
|
void updateStatuses(Object& obj, double time) {
|
|
for(int i = regionStatusTypes.length - 1; i >= 0; --i) {
|
|
if(regionStatusTimers[i] >= 0) {
|
|
regionStatusTimers[i] -= time;
|
|
if(regionStatusTimers[i] <= 0) {
|
|
regionStatusTypes.removeAt(i);
|
|
regionStatusTimers.removeAt(i);
|
|
regionStatusEmps.removeAt(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void applyStatuses(Region& reg, Object& obj, bool isOwnerChange = false) {
|
|
for(uint i = 0, cnt = regionStatusTypes.length; i < cnt; ++i) {
|
|
auto@ status = getStatusType(regionStatusTypes[i]);
|
|
Empire@ emp = regionStatusEmps[i];
|
|
if((emp is null && !isOwnerChange) || obj.owner is emp) {
|
|
if(status.shouldApply(emp, reg, obj))
|
|
obj.addStatus(status.id, regionStatusTimers[i], boundEmpire=emp, boundRegion=reg);
|
|
}
|
|
}
|
|
}
|
|
|
|
void addRegionStatus(Object& obj, Empire@ emp, uint statusId, double timer = -1.0) {
|
|
auto@ status = getStatusType(statusId);
|
|
if(status is null)
|
|
return;
|
|
|
|
Region@ reg = cast<Region>(obj);
|
|
regionStatusTypes.insertLast(statusId);
|
|
regionStatusTimers.insertLast(timer);
|
|
regionStatusEmps.insertLast(emp);
|
|
|
|
for(uint i = 0, cnt = objectList.length; i < cnt; ++i) {
|
|
auto@ obj = objectList[i];
|
|
if(emp is null || obj.owner is emp) {
|
|
if(status.shouldApply(emp, reg, obj))
|
|
obj.addStatus(statusId, timer, boundEmpire=emp, boundRegion=reg);
|
|
}
|
|
}
|
|
}
|
|
|
|
void removeRegionStatus(Object& obj, Empire@ emp, uint statusId) {
|
|
auto@ status = getStatusType(statusId);
|
|
if(status is null)
|
|
return;
|
|
|
|
Region@ reg = cast<Region>(obj);
|
|
for(uint i = 0, cnt = objectList.length; i < cnt; ++i) {
|
|
auto@ obj = objectList[i];
|
|
if(emp is null || obj.owner is emp) {
|
|
if(status.shouldApply(emp, reg, obj))
|
|
obj.removeRegionBoundStatus(reg, statusId);
|
|
}
|
|
}
|
|
|
|
for(int i = regionStatusTypes.length - 1; i >= 0; --i) {
|
|
if(regionStatusTypes[i] == statusId && regionStatusEmps[i] is emp
|
|
&& regionStatusTimers[i] == -1.0) {
|
|
regionStatusTypes.removeAt(i);
|
|
regionStatusTimers.removeAt(i);
|
|
regionStatusEmps.removeAt(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void mirrorRegionStatusTo(Region& otherRegion) {
|
|
for(uint i = 0, cnt = regionStatusTypes.length; i < cnt; ++i)
|
|
otherRegion.addRegionStatus(regionStatusEmps[i], regionStatusTypes[i], regionStatusTimers[i]);
|
|
}
|
|
|
|
void addSystemDPS(double amount) {
|
|
regionDPS += amount;
|
|
}
|
|
|
|
void addStarDPS(double amount) {
|
|
starDPS += amount;
|
|
}
|
|
|
|
void dealStarDamage(double amount) {
|
|
for(uint i = 0, cnt = starList.length; i < cnt; ++i)
|
|
starList[i].dealStarDamage(amount);
|
|
}
|
|
|
|
void processDamage(Object& reg, double time) {
|
|
DamageEvent dmg;
|
|
|
|
if(regionDPS <= 0.0)
|
|
return;
|
|
|
|
double baseDamage = regionDPS * time / 100.0;
|
|
|
|
for(uint i = 0, cnt = time * 15.0; i < cnt; ++i) {
|
|
auto@ obj = trace(line3dd(reg.position, reg.position + random3d(reg.radius * 1.5)));
|
|
if(obj is null)
|
|
continue;
|
|
|
|
double deal = randomd(0.5,1.5) * baseDamage;
|
|
|
|
if(obj.isStar) {
|
|
cast<Star>(obj).dealStarDamage(deal);
|
|
}
|
|
else if(obj.isPlanet) {
|
|
cast<Planet>(obj).dealPlanetDamage(deal);
|
|
}
|
|
else {
|
|
@dmg.obj = obj;
|
|
@dmg.target = obj;
|
|
dmg.spillable = false;
|
|
dmg.damage = deal;
|
|
|
|
vec3d off = obj.position - reg.position;
|
|
vec2d dir = vec2d(off.x, off.z).normalized();
|
|
obj.damage(dmg, -1.0, dir);
|
|
}
|
|
}
|
|
|
|
uint objCount = objectList.length;
|
|
if(objCount > 0) {
|
|
uint traces = max(min(uint(time * 85.0), objCount * 10), 1);
|
|
|
|
for(uint i = 0; i < traces; ++i) {
|
|
auto@ obj = objectList[randomi(0,objCount-1)];
|
|
if(obj is null)
|
|
continue;
|
|
|
|
line3dd line = line3dd(reg.position, obj.position + random3d(5.0));
|
|
line.end = line.start + line.direction * (reg.radius * 1.5);
|
|
|
|
@obj = trace(line);
|
|
if(obj is null)
|
|
continue;
|
|
|
|
double deal = randomd(0.5,1.5) * baseDamage;
|
|
|
|
if(obj.isStar) {
|
|
cast<Star>(obj).dealStarDamage(deal);
|
|
}
|
|
else if(obj.isPlanet) {
|
|
cast<Planet>(obj).dealPlanetDamage(deal);
|
|
}
|
|
else {
|
|
@dmg.obj = obj;
|
|
@dmg.target = obj;
|
|
dmg.spillable = false;
|
|
dmg.damage = deal;
|
|
|
|
vec3d off = obj.position - reg.position;
|
|
vec2d dir = vec2d(off.x, off.z).normalized();
|
|
obj.damage(dmg, -1.0, dir);
|
|
}
|
|
}
|
|
}
|
|
|
|
regionDPS *= pow(0.95, time);
|
|
regionDPS -= time;
|
|
}
|
|
|
|
#section server
|
|
void grantExperience(Empire@ toEmpire, double amount, bool combatOnly = false) {
|
|
array<Object@> objects;
|
|
for(uint i = 0, cnt = objectList.length; i < cnt; ++i) {
|
|
Object@ obj = objectList[i];
|
|
if(!obj.hasLeaderAI || !obj.isShip)
|
|
continue;
|
|
if(obj.owner !is toEmpire)
|
|
continue;
|
|
if(combatOnly && !obj.inCombat)
|
|
continue;
|
|
if(cast<Ship>(obj).getFleetStrength() < 1000.0)
|
|
continue;
|
|
objects.insertLast(obj);
|
|
}
|
|
if(objects.length != 0) {
|
|
amount /= double(objects.length);
|
|
for(uint i = 0, cnt = objects.length; i < cnt; ++i)
|
|
objects[i].addExperience(amount);
|
|
}
|
|
}
|
|
|
|
void renameSystem(Object& obj, string name) {
|
|
string oldname = obj.name;
|
|
obj.name = name;
|
|
obj.named = true;
|
|
objectRenamed(ALL_PLAYERS, obj, name);
|
|
|
|
for(uint i = 0, cnt = starList.length; i < cnt; ++i) {
|
|
Star@ star = starList[i];
|
|
if(!star.named) {
|
|
star.name = star.name.replaced(oldname, name);
|
|
star.named = true;
|
|
objectRenamed(ALL_PLAYERS, star, star.name);
|
|
}
|
|
}
|
|
for(uint i = 0, cnt = planetList.length; i < cnt; ++i) {
|
|
Planet@ pl = planetList[i];
|
|
if(!pl.named) {
|
|
pl.name = pl.name.replaced(oldname, name);
|
|
objectRenamed(ALL_PLAYERS, pl, pl.name, setNamed=false);
|
|
}
|
|
}
|
|
}
|
|
#section all
|
|
|
|
void updateEmpLoyalty(Object& region) {
|
|
uint empCnt = empLoyaltyBonus.length;
|
|
|
|
//Calculate new loyalty bonuses
|
|
for(uint i = 0, cnt = empCnt; i < cnt; ++i)
|
|
empLoyaltyBonus[i] = neighbourLoyalty[i] + localLoyalty[i];
|
|
|
|
for(uint i = 0, cnt = system.adjacent.length; i < cnt; ++i) {
|
|
SystemDesc@ desc = getSystem(system.adjacent[i]);
|
|
Region@ other = desc.object;
|
|
|
|
for(uint n = 0; n < empCnt; ++n)
|
|
empLoyaltyBonus[n] += other.getNeighbourLoyalty(getEmpire(n));
|
|
}
|
|
|
|
//Update planet loyalty bonuses
|
|
for(uint i = 0, cnt = planetList.length; i < cnt; ++i) {
|
|
Planet@ pl = planetList[i];
|
|
Empire@ owner = pl.owner;
|
|
if(owner !is null && owner.valid)
|
|
pl.setLoyaltyBonus(empLoyaltyBonus[owner.index]);
|
|
}
|
|
}
|
|
|
|
uint getContestedState(const Object& region, Empire@ forEmpire) {
|
|
if(forEmpire is null || !forEmpire.valid)
|
|
return CM_None;
|
|
|
|
const Region@ reg = cast<const Region>(region);
|
|
if(reg.ContestedMask & forEmpire.mask == 0)
|
|
return CM_None;
|
|
|
|
bool usProtected = reg.ProtectedMask & forEmpire.mask != 0;
|
|
bool usZealot = ZealotMask & forEmpire.mask != 0;
|
|
|
|
if(reg.SiegedMask & forEmpire.mask != 0) {
|
|
if(usZealot)
|
|
return CM_Zealot;
|
|
return CM_LosingLoyalty;
|
|
}
|
|
|
|
bool enemyProtected = false, enemyZealot = false;
|
|
for(uint i = 0, empCnt = getEmpireCount(); i < empCnt; ++i) {
|
|
Empire@ other = getEmpire(i);
|
|
if(!other.major)
|
|
continue;
|
|
if(!other.isHostile(forEmpire))
|
|
continue;
|
|
if(planetCounts[i] == 0)
|
|
continue;
|
|
|
|
if(reg.SiegingMask & forEmpire.mask != 0) {
|
|
bool zeal = ZealotMask & other.mask != 0;
|
|
if(zeal)
|
|
enemyZealot = true;
|
|
}
|
|
|
|
bool prot = reg.ProtectedMask & other.mask != 0;
|
|
if(prot)
|
|
enemyProtected = true;
|
|
}
|
|
|
|
if(usProtected || enemyProtected)
|
|
return CM_Protected;
|
|
if(enemyZealot)
|
|
return CM_Zealot;
|
|
if(reg.SiegingMask & forEmpire.mask != 0)
|
|
return CM_GainingLoyalty;
|
|
return CM_Contested;
|
|
}
|
|
|
|
void updateCombatState(Region& region, double time) {
|
|
region.CombatMask |= region.EngagedMask;
|
|
|
|
combatTimer -= time;
|
|
if(combatTimer <= 0) {
|
|
region.CombatMask = region.EngagedMask;
|
|
region.EngagedMask = 0;
|
|
combatTimer += 20.f;
|
|
}
|
|
}
|
|
|
|
void modMilitaryStrength(Empire@ emp, int amt) {
|
|
if(emp is null || !emp.valid)
|
|
return;
|
|
strengths[emp.index] += amt;
|
|
}
|
|
|
|
void updateContested(Object& region) {
|
|
int newMilitaryMask = 0;
|
|
int newPlanetsMask = 0;
|
|
for(uint i = 0, cnt = strengths.length; i < cnt; ++i) {
|
|
Empire@ other = getEmpire(i);
|
|
if(!other.major)
|
|
continue;
|
|
if(strengths[i] > 0)
|
|
newMilitaryMask |= other.mask;
|
|
if(planetCounts[i] > 0)
|
|
newPlanetsMask |= other.mask;
|
|
}
|
|
HasMilitaryMask = newMilitaryMask;
|
|
HasPlanetsMask = newPlanetsMask;
|
|
|
|
uint CMask = 0, OMask = 0;
|
|
uint empCnt = getEmpireCount();
|
|
Region@ reg = cast<Region>(region);
|
|
reg.PlanetsMask = HasPlanetsMask;
|
|
for(uint i = 0; i < empCnt; ++i) {
|
|
// Contested if this empire has planets or military,
|
|
// and an empire hostile to it has military.
|
|
Empire@ other = getEmpire(i);
|
|
int hostile = other.hostileMask;
|
|
|
|
bool contested = (planetCounts[i] > 0 || strengths[i] > 0)
|
|
&& (hostile & HasMilitaryMask != 0 || reg.SiegedMask & other.mask != 0);
|
|
if(contested && reg.CombatMask & other.mask != 0 && reg.CombatMask & hostile != 0) {
|
|
int totEnemy = 0;
|
|
for(uint n = 0; n < empCnt; ++n) {
|
|
uint mask = getEmpire(n).mask;
|
|
if(hostile & mask != 0 && reg.CombatMask & mask != 0)
|
|
totEnemy += strengths[n];
|
|
}
|
|
|
|
if(totEnemy > 20 || reg.SiegedMask & other.mask != 0) {
|
|
CMask |= other.mask;
|
|
if(isServer && reg.ContestedMask & other.mask == 0 && planetCounts[i] > 0)
|
|
other.notifyWarEvent(region, WET_ContestedSystem);
|
|
}
|
|
}
|
|
|
|
//Check if this is a core system
|
|
if(reg.TradeMask & other.mask != 0) {
|
|
bool isCore = true;
|
|
for(uint j = 0, jcnt = system.adjacent.length; j < jcnt; ++j) {
|
|
SystemDesc@ desc = getSystem(system.adjacent[j]);
|
|
if(desc.object.TradeMask & other.mask == 0) {
|
|
isCore = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(isCore)
|
|
OMask |= other.mask;
|
|
}
|
|
}
|
|
|
|
reg.ContestedMask = CMask;
|
|
reg.CoreSystemMask = OMask;
|
|
|
|
//Update whether the node is set as contested
|
|
if(plane !is null) {
|
|
uint newContested = getContestedState(region, playerEmpire);
|
|
if(visibleContested != newContested) {
|
|
plane.setContested(newContested);
|
|
visibleContested = newContested;
|
|
}
|
|
}
|
|
}
|
|
|
|
void updateZealotry(Object& obj) {
|
|
//Update zealotry for all empires
|
|
Region@ region = cast<Region>(obj);
|
|
uint isZealotMask = 0;
|
|
for(uint i = 0, cnt = getEmpireCount(); i < cnt; ++i) {
|
|
Empire@ emp = getEmpire(i);
|
|
if(ZealotMask & emp.mask == 0)
|
|
continue;
|
|
|
|
if(planetCounts[i] > 0 && region.SiegedMask & emp.mask != 0) {
|
|
isZealotMask |= emp.mask;
|
|
|
|
//Check which zealot effects we need to add
|
|
uint haveEffectMask = 0, needEffectMask = 0;
|
|
for(uint i = 0, cnt = effects.length; i < cnt; ++i) {
|
|
ZealotRegionEffect@ eff = cast<ZealotRegionEffect>(effects[i]);
|
|
if(eff !is null) {
|
|
if(eff.forEmpire is emp)
|
|
haveEffectMask |= eff.other.mask;
|
|
}
|
|
}
|
|
|
|
//Check which effects we need
|
|
for(uint j = 0; j < cnt; ++j) {
|
|
Empire@ other = getEmpire(j);
|
|
if(HasMilitaryMask & other.mask == 0)
|
|
continue;
|
|
if(!other.isHostile(emp))
|
|
continue;
|
|
|
|
//TODO: This is not 100% accurate. Fix zealot stuff to be fully working.
|
|
if(region.SiegingMask & other.mask != 0) {
|
|
needEffectMask |= other.mask;
|
|
if(haveEffectMask & other.mask == 0)
|
|
addRegionEffect(region, createZealotRegionEffect(emp, other));
|
|
}
|
|
}
|
|
|
|
//Check which effects to remove
|
|
for(uint i = 0, cnt = effects.length; i < cnt; ++i) {
|
|
ZealotRegionEffect@ eff = cast<ZealotRegionEffect>(effects[i]);
|
|
if(eff !is null && eff.forEmpire is emp) {
|
|
if(needEffectMask & eff.other.mask == 0) {
|
|
removeRegionEffectByIndex(region, i);
|
|
--i;
|
|
--cnt;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Remove all zealotry-related effects
|
|
for(uint i = 0, cnt = effects.length; i < cnt; ++i) {
|
|
ZealotRegionEffect@ eff = cast<ZealotRegionEffect>(effects[i]);
|
|
if(eff !is null) {
|
|
if(isZealotMask & eff.forEmpire.mask == 0) {
|
|
removeRegionEffectByIndex(region, i);
|
|
--i;
|
|
--cnt;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
uint get_planetCount() const {
|
|
return planetBucket.length;
|
|
}
|
|
|
|
Planet@ get_planets(uint index) const {
|
|
if(index >= planetBucket.length)
|
|
return null;
|
|
return planetBucket[index];
|
|
}
|
|
|
|
uint get_anomalyCount() const {
|
|
return anomalyBucket.length;
|
|
}
|
|
|
|
Anomaly@ get_anomalies(uint index) const {
|
|
if(index >= anomalyBucket.length)
|
|
return null;
|
|
return anomalyBucket[index];
|
|
}
|
|
|
|
uint get_asteroidCount() const {
|
|
return asteroidBucket.length;
|
|
}
|
|
|
|
Asteroid@ get_asteroids(uint index) const {
|
|
if(index >= asteroidBucket.length)
|
|
return null;
|
|
return asteroidBucket[index];
|
|
}
|
|
|
|
void castOnRandomAsteroid(Object@ obj, int ablId) {
|
|
if(obj is null)
|
|
return;
|
|
if(asteroidList.length == 0)
|
|
return;
|
|
obj.activateAbility(ablId, asteroidList[randomi(0, asteroidList.length-1)]);
|
|
}
|
|
|
|
uint getPlanetCount(Empire@ emp) const {
|
|
if(emp is null || !emp.valid)
|
|
return 0;
|
|
return planetCounts[emp.index];
|
|
}
|
|
|
|
#section server
|
|
void addStatusRandomPlanet(int statusType, double duration, uint mask) {
|
|
Planet@ pl;
|
|
double tot = 0;
|
|
|
|
for(uint i = 0, plCnt = planetList.length; i < plCnt; ++i) {
|
|
Planet@ check = planetList[i];
|
|
Empire@ owner = check.owner;
|
|
if(owner is null || !owner.valid)
|
|
continue;
|
|
if(owner.mask & mask == 0)
|
|
continue;
|
|
|
|
tot += 1.0;
|
|
if(randomd() <= 1.0 / tot)
|
|
@pl = check;
|
|
}
|
|
|
|
if(pl !is null)
|
|
pl.addStatus(statusType, duration);
|
|
}
|
|
|
|
void spawnSupportAtRandomPlanet(Empire@ owner, const Design@ design, bool free = true, Planet@ fallback = null) {
|
|
if(owner is null || design is null || !owner.valid)
|
|
return;
|
|
|
|
uint plCnt = planetCounts[owner.index];
|
|
if(plCnt == 0)
|
|
return;
|
|
uint index = randomi(0, plCnt-1);
|
|
Object@ pl;
|
|
for(uint i = 0, cnt = planetList.length; i < cnt; ++i) {
|
|
Planet@ obj = planetList[i];
|
|
if(obj.owner is owner && obj.canGainSupports) {
|
|
if(index == 0) {
|
|
@pl = obj;
|
|
break;
|
|
}
|
|
--index;
|
|
}
|
|
}
|
|
|
|
if(pl is null)
|
|
@pl = fallback;
|
|
if(pl !is null) {
|
|
design.decBuilt(); //automatic built doesn't increment
|
|
createShip(pl, design, owner, pl, false, free);
|
|
}
|
|
}
|
|
|
|
void refreshSupportsFor(Object& dest, bool keepGhosts) {
|
|
auto@ owner = dest.owner;
|
|
if(!owner.valid)
|
|
return;
|
|
for(uint i = 0, cnt = planetList.length; i < cnt; ++i) {
|
|
auto@ pl = planetList[i];
|
|
if(pl.owner is owner && pl.SupplyUsed > 0 && pl.allowFillFrom)
|
|
dest.refreshSupportsFrom(pl, keepGhosts);
|
|
}
|
|
for(uint i = 0, cnt = orbitalList.length; i < cnt; ++i) {
|
|
auto@ obj = orbitalList[i];
|
|
if(obj.owner is owner && obj.SupplyUsed > 0 && obj.allowFillFrom)
|
|
dest.refreshSupportsFrom(obj, keepGhosts);
|
|
}
|
|
}
|
|
|
|
void convertRandomSupport(Object@ toLeader, Empire@ toEmpire, uint mask, int maxSize) {
|
|
Object@ found;
|
|
double foundCount = 0;
|
|
|
|
for(uint i = 0, cnt = objectList.length; i < cnt; ++i) {
|
|
Object@ obj = objectList[i];
|
|
if(obj is null || !obj.hasLeaderAI)
|
|
continue;
|
|
if(obj.owner.mask & mask == 0)
|
|
continue;
|
|
|
|
uint supCnt = obj.supportCount;
|
|
if(supCnt == 0)
|
|
continue;
|
|
|
|
foundCount += supCnt;
|
|
if(randomd() < double(supCnt) / foundCount)
|
|
@found = obj;
|
|
}
|
|
|
|
if(found !is null)
|
|
found.convertRandomSupport(toLeader, toEmpire, maxSize);
|
|
}
|
|
|
|
bool hasTradeStation(Empire@ owner) {
|
|
return HaveStationsMask & owner.mask != 0;
|
|
}
|
|
|
|
bool hasTradeStations() {
|
|
return HaveStationsMask != 0;
|
|
}
|
|
|
|
void getTradeStation(Civilian@ request, Empire@ owner, vec3d position) {
|
|
if(HaveStationsMask & owner.mask == 0) {
|
|
request.gotoTradeStation(null);
|
|
return;
|
|
}
|
|
Civilian@ best;
|
|
double bestDist = INFINITY;
|
|
for(uint i = 0, cnt = tradeStations.length; i < cnt; ++i) {
|
|
auto@ station = tradeStations[i];
|
|
if(station.owner !is owner)
|
|
continue;
|
|
double d = position.distanceToSQ(station.position);
|
|
if(d < bestDist) {
|
|
bestDist = d;
|
|
@best = station;
|
|
}
|
|
}
|
|
|
|
request.gotoTradeStation(best);
|
|
}
|
|
|
|
void getTradePlanet(Civilian@ request, Empire@ owner) {
|
|
uint index = randomi(0, planetCounts[owner.index]-1);
|
|
for(uint i = 0, cnt = planetList.length; i < cnt; ++i) {
|
|
if(planetList[i].owner is owner) {
|
|
if(index == 0) {
|
|
request.gotoTradePlanet(planetList[i]);
|
|
return;
|
|
}
|
|
--index;
|
|
}
|
|
}
|
|
request.gotoTradePlanet(null);
|
|
}
|
|
|
|
void bumpTradeCounter(Empire@ emp) {
|
|
tradeCounter[emp.index] += 1;
|
|
}
|
|
|
|
void updateCivilianTrade(Object& region) {
|
|
//Make sure each planet has a civilian ship assigned
|
|
if(config::ENABLE_CIVILIAN_TRADE == 0.0 || config::CIVILIAN_TRADE_MULT == 0.0)
|
|
return;
|
|
uint needRequests = 0;
|
|
int stationLevels = 0;
|
|
for(uint i = 0; i < planetList.length; ++i) {
|
|
Planet@ pl = planetList[i];
|
|
Empire@ owner = pl.owner;
|
|
if(owner is null || !owner.valid)
|
|
continue;
|
|
Civilian@ civ = pl.getAssignedCivilian();
|
|
if(civ !is null)
|
|
continue;
|
|
double timer = pl.getCivilianTimer();
|
|
if(timer < CIV_TIMER / config::CIVILIAN_TRADE_MULT)
|
|
continue;
|
|
|
|
//Calculate maximum amount of civilians
|
|
int plCount = owner.TotalPlanets.value;
|
|
int civLimit = 0;
|
|
int plLimit = 100 * config::CIVILIAN_TRADE_MULT;
|
|
if(plCount > plLimit)
|
|
civLimit = plLimit + pow(double(plCount - plLimit), CIVILIAN_LIMIT_POW);
|
|
else
|
|
civLimit = plCount;
|
|
civLimit = double(civLimit) * config::CIVILIAN_TRADE_MULT;
|
|
|
|
if(owner.CivilianTradeShips.value < civLimit) {
|
|
Object@ destination = pl.getNativeResourceDestination(owner, 0);
|
|
if(destination is null)
|
|
continue;
|
|
|
|
@civ = createCivilian(pl.position, owner, type=CiT_Freighter,
|
|
radius = randomCivilianFreighterSize());
|
|
if(civ.radius >= CIV_SIZE_CARAVAN)
|
|
civ.modIncome(+CIV_CARAVAN_INCOME);
|
|
civ.pathTo(destination);
|
|
civ.setOrigin(pl);
|
|
civ.setCargoResource(pl.primaryResourceType);
|
|
pl.setAssignedCivilian(civ);
|
|
pl.setCivilianTimer(0.0);
|
|
}
|
|
else {
|
|
needRequests |= owner.mask;
|
|
}
|
|
}
|
|
|
|
if(needRequests != TradeRequestMask) {
|
|
for(uint i = 0, cnt = getEmpireCount(); i < cnt; ++i) {
|
|
Empire@ emp = getEmpire(i);
|
|
if(needRequests & emp.mask != 0) {
|
|
if(TradeRequestMask & emp.mask == 0)
|
|
emp.requestTradeCivilian(cast<Region>(region));
|
|
}
|
|
else {
|
|
if(TradeRequestMask & emp.mask != 0)
|
|
emp.stopRequestTradeCivilian(cast<Region>(region));
|
|
}
|
|
}
|
|
TradeRequestMask = needRequests;
|
|
}
|
|
|
|
if(gameTime >= tradeTimer) {
|
|
tradeTimer = gameTime + TRADE_TIMER;
|
|
|
|
for(uint i = 0, cnt = getEmpireCount(); i < cnt; ++i) {
|
|
Empire@ emp = getEmpire(i);
|
|
if(!emp.major)
|
|
continue;
|
|
uint buildStations = min(planetCounts[i], uint(double(tradeCounter[i]) / STATION_TRADES));
|
|
uint maxStations = max(buildStations, uint(double(tradeCounter[i] * 2) / STATION_TRADES));
|
|
|
|
uint stationCount = 0;
|
|
for(uint i = 0, cnt = tradeStations.length; i < cnt; ++i) {
|
|
Empire@ owner = tradeStations[i].owner;
|
|
if(!tradeStations[i].valid) {
|
|
tradeStations.removeAt(i);
|
|
--i; --cnt;
|
|
}
|
|
else if(owner is emp) {
|
|
stationCount += 1;
|
|
}
|
|
}
|
|
if(stationCount > maxStations) {
|
|
for(uint i = 0, cnt = tradeStations.length; i < cnt && stationCount > maxStations; ++i) {
|
|
if(tradeStations[i].owner is emp) {
|
|
tradeStations[i].destroy();
|
|
stationCount -= 1;
|
|
}
|
|
}
|
|
}
|
|
else if(stationCount < buildStations) {
|
|
for(; stationCount < buildStations; ++stationCount) {
|
|
vec3d pos = system.position;
|
|
vec2d offset = random2d(system.radius * 0.5, system.radius * 0.8);
|
|
pos.x += offset.x;
|
|
pos.z += offset.y;
|
|
|
|
Civilian@ civ = createCivilian(pos, emp, CiT_Station,
|
|
radius=randomd(STATION_MIN_RAD, STATION_MAX_RAD));
|
|
civ.modIncome(+CIV_STATION_INCOME);
|
|
civ.setCargoType(CT_Goods);
|
|
tradeStations.insertLast(civ);
|
|
}
|
|
}
|
|
if(stationCount == 0)
|
|
HaveStationsMask &= ~emp.mask;
|
|
else
|
|
HaveStationsMask |= emp.mask;
|
|
tradeCounter[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void freeUpCivilian(Object& region, Civilian@ civ) {
|
|
//Check which planet here needs a trader the most
|
|
Planet@ bestPlanet;
|
|
Object@ bestDest;
|
|
Empire@ civOwner = civ.owner;
|
|
double bestTimer = 0.0;
|
|
for(uint i = 0; i < planetList.length; ++i) {
|
|
Planet@ pl = planetList[i];
|
|
Empire@ owner = pl.owner;
|
|
if(owner !is civOwner)
|
|
continue;
|
|
Civilian@ civ = pl.getAssignedCivilian();
|
|
if(civ !is null)
|
|
continue;
|
|
Object@ destination = pl.getNativeResourceDestination(owner, 0);
|
|
if(destination is null)
|
|
continue;
|
|
double timer = pl.getCivilianTimer();
|
|
if(timer > bestTimer) {
|
|
@bestPlanet = pl;
|
|
@bestDest = destination;
|
|
bestTimer = timer;
|
|
}
|
|
}
|
|
|
|
if(bestPlanet !is null && bestTimer > randomd(0.0, CIV_TIMER / config::CIVILIAN_TRADE_MULT)) {
|
|
//Reroute the trader
|
|
civ.pathTo(bestPlanet, bestDest);
|
|
civ.setCargoResource(bestPlanet.primaryResourceType);
|
|
civ.resetStepCount();
|
|
bestPlanet.setAssignedCivilian(civ);
|
|
bestPlanet.setCivilianTimer(0.0);
|
|
}
|
|
else {
|
|
//Send the trader to a random adjacent system
|
|
SystemDesc@ nextSys;
|
|
int stepCount = civ.getStepCount();
|
|
if(randomd() > pow(0.9, stepCount)) {
|
|
Region@ reqRegion = civOwner.getTradeCivilianRequest(civ.position);
|
|
if(reqRegion !is null)
|
|
@nextSys = getSystem(reqRegion);
|
|
civ.resetStepCount();
|
|
if(nextSys is null && bestPlanet !is null) {
|
|
civ.pathTo(bestPlanet, bestDest);
|
|
civ.setCargoResource(bestPlanet.primaryResourceType);
|
|
bestPlanet.setAssignedCivilian(civ);
|
|
bestPlanet.setCivilianTimer(0.0);
|
|
return;
|
|
}
|
|
}
|
|
if(nextSys is null) {
|
|
uint sysCount = 0;
|
|
for(uint i = 0, cnt = system.adjacent.length; i < cnt; ++i) {
|
|
SystemDesc@ other = getSystem(system.adjacent[i]);
|
|
if(other.object.getPlanetCount(civOwner) != 0)
|
|
sysCount += 1;
|
|
}
|
|
for(uint i = 0, cnt = system.wormholes.length; i < cnt; ++i) {
|
|
SystemDesc@ other = getSystem(system.wormholes[i]);
|
|
if(other.object.getPlanetCount(civOwner) != 0)
|
|
sysCount += 1;
|
|
}
|
|
if(sysCount != 0) {
|
|
uint index = randomi(0, sysCount-1);
|
|
for(uint i = 0, cnt = system.adjacent.length; i < cnt; ++i) {
|
|
SystemDesc@ other = getSystem(system.adjacent[i]);
|
|
if(other.object.getPlanetCount(civOwner) != 0) {
|
|
if(index == 0) {
|
|
@nextSys = other;
|
|
break;
|
|
}
|
|
else {
|
|
--index;
|
|
}
|
|
}
|
|
}
|
|
if(nextSys is null) {
|
|
for(uint i = 0, cnt = system.wormholes.length; i < cnt; ++i) {
|
|
SystemDesc@ other = getSystem(system.wormholes[i]);
|
|
if(other.object.getPlanetCount(civOwner) != 0) {
|
|
if(index == 0) {
|
|
@nextSys = other;
|
|
break;
|
|
}
|
|
else {
|
|
--index;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(nextSys !is null) {
|
|
civ.setCargoType(CT_Goods);
|
|
civ.pathTo(nextSys.object);
|
|
civ.modStepCount(+1);
|
|
}
|
|
else {
|
|
if(bestPlanet is null) {
|
|
civ.destroy();
|
|
}
|
|
else {
|
|
//TODO: Remember the civilian for later
|
|
civ.destroy();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#section all
|
|
|
|
uint get_objectCount() const {
|
|
return objectList.length;
|
|
}
|
|
|
|
Object@ get_objects(uint index) const {
|
|
if(index >= objectList.length)
|
|
return null;
|
|
return objectList[index];
|
|
}
|
|
|
|
Object@ getOrbitObject(vec3d point) const {
|
|
uint cnt = planetList.length;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
Planet@ pl = planetList[i];
|
|
double d = point.distanceToSQ(pl.position);
|
|
if(d < pl.OrbitSize * pl.OrbitSize)
|
|
return pl;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
uint get_starCount() const {
|
|
return starBucket.length;
|
|
}
|
|
|
|
Star@ get_stars(uint index) const {
|
|
if(index >= starBucket.length)
|
|
return null;
|
|
return starBucket[index];
|
|
}
|
|
|
|
double get_starTemperature() const {
|
|
return StarTemperature;
|
|
}
|
|
|
|
double get_starRadius() const {
|
|
return StarRadius;
|
|
}
|
|
|
|
void getPlanets() {
|
|
for(uint i = 0, cnt = planetBucket.length; i < cnt; ++i)
|
|
yield(planetBucket[i]);
|
|
}
|
|
|
|
void getPickups() {
|
|
for(uint i = 0, cnt = pickupBucket.length; i < cnt; ++i)
|
|
yield(pickupBucket[i]);
|
|
}
|
|
|
|
void getAsteroids() {
|
|
for(uint i = 0, cnt = asteroidBucket.length; i < cnt; ++i)
|
|
yield(asteroidBucket[i]);
|
|
}
|
|
|
|
void getAnomalies() {
|
|
for(uint i = 0, cnt = anomalyBucket.length; i < cnt; ++i)
|
|
yield(anomalyBucket[i]);
|
|
}
|
|
|
|
void getArtifacts() {
|
|
for(uint i = 0, cnt = artifactBucket.length; i < cnt; ++i)
|
|
yield(artifactBucket[i]);
|
|
}
|
|
|
|
int getStrength(Empire@ emp) const {
|
|
if(emp is null || !emp.valid)
|
|
return 0;
|
|
return strengths[emp.index];
|
|
}
|
|
|
|
Territory@ getTerritory(Empire@ emp) const {
|
|
if(emp is null || !emp.valid)
|
|
return null;
|
|
return territories[emp.index].get();
|
|
}
|
|
|
|
bool sharesTerritory(Empire& emp, Region& other) const {
|
|
Territory@ my = getTerritory(emp);
|
|
Territory@ their = other.getTerritory(emp);
|
|
return my !is null && my is their;
|
|
}
|
|
|
|
bool isTradableRegion(const Object& obj, Empire& emp) const {
|
|
const Region@ reg = cast<const Region>(obj);
|
|
if(reg.TradeMask & emp.TradeMask.value != 0)
|
|
return true;
|
|
|
|
for(uint i = 0, cnt = system.adjacent.length; i < cnt; ++i) {
|
|
SystemDesc@ desc = getSystem(system.adjacent[i]);
|
|
if(desc.object.TradeMask & emp.TradeMask.value != 0)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
double getTotalFleetStrength(uint empireMask, bool fleets = true, bool stations = true, bool planets = true) const {
|
|
double str = 0.0;
|
|
for(uint i = 0, cnt = objectList.length; i < cnt; ++i) {
|
|
Object@ obj = objectList[i];
|
|
Empire@ owner = obj.owner;
|
|
if(owner is null || owner.mask & empireMask == 0)
|
|
continue;
|
|
if(!obj.hasLeaderAI)
|
|
continue;
|
|
|
|
if(!fleets && obj.isShip && !cast<Ship>(obj).isStation)
|
|
continue;
|
|
if(!stations && obj.isShip && cast<Ship>(obj).isStation)
|
|
continue;
|
|
if(!stations && obj.isOrbital)
|
|
continue;
|
|
if(!planets && obj.isPlanet)
|
|
continue;
|
|
|
|
str += sqrt(obj.getFleetStrength());
|
|
}
|
|
return str * str;
|
|
}
|
|
|
|
Object@ findEnemy(Empire@ emp, uint empireMask, bool fleets = true, bool stations = true, bool planets = false) const {
|
|
uint offset = randomi(0, objectList.length-1);
|
|
for(uint i = 0, cnt = objectList.length; i < cnt; ++i) {
|
|
Object@ obj = objectList[(i+offset)%cnt];
|
|
Empire@ owner = obj.owner;
|
|
if(owner is null || owner.mask & empireMask == 0)
|
|
continue;
|
|
|
|
uint type = obj.type;
|
|
if(emp !is null && !obj.isVisibleTo(emp))
|
|
continue;
|
|
switch(type) {
|
|
case OT_Ship:
|
|
if(!obj.hasLeaderAI)
|
|
continue;
|
|
if(cast<Ship>(obj).isStation) {
|
|
if(!stations)
|
|
continue;
|
|
}
|
|
else {
|
|
if(!fleets)
|
|
continue;
|
|
}
|
|
if(obj.getFleetStrength() < 100.0)
|
|
continue;
|
|
break;
|
|
case OT_Orbital:
|
|
if(!stations)
|
|
continue;
|
|
break;
|
|
case OT_Planet:
|
|
if(!planets)
|
|
continue;
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
void getEnemies(Empire@ emp, uint empireMask, bool fleets = true, bool stations = true, bool planets = false) const {
|
|
uint offset = randomi(0, objectList.length-1);
|
|
for(uint i = 0, cnt = objectList.length; i < cnt; ++i) {
|
|
Object@ obj = objectList[(i+offset)%cnt];
|
|
Empire@ owner = obj.owner;
|
|
if(owner is null || owner.mask & empireMask == 0)
|
|
continue;
|
|
|
|
uint type = obj.type;
|
|
if(emp !is null && !obj.isVisibleTo(emp))
|
|
continue;
|
|
switch(type) {
|
|
case OT_Ship:
|
|
if(!obj.hasLeaderAI)
|
|
continue;
|
|
if(cast<Ship>(obj).isStation) {
|
|
if(!stations)
|
|
continue;
|
|
}
|
|
else {
|
|
if(!fleets)
|
|
continue;
|
|
}
|
|
if(obj.getFleetStrength() < 100.0)
|
|
continue;
|
|
break;
|
|
case OT_Orbital:
|
|
if(!stations)
|
|
continue;
|
|
break;
|
|
case OT_Planet:
|
|
if(!planets)
|
|
continue;
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
|
|
yield(obj);
|
|
}
|
|
}
|
|
|
|
void destroyOwnedBy(uint mask, bool ships, bool planets) {
|
|
for(uint i = 0, cnt = objectList.length; i < cnt; ++i) {
|
|
Object@ obj = objectList[i];
|
|
Empire@ owner = obj.owner;
|
|
if(owner is null || owner.mask & mask == 0)
|
|
continue;
|
|
|
|
if(obj.isShip && ships)
|
|
obj.destroy();
|
|
else if(obj.isPlanet && planets)
|
|
obj.destroy();
|
|
}
|
|
}
|
|
|
|
void setTerritory(Empire@ emp, Territory@ terr) {
|
|
if(emp is null || !emp.valid)
|
|
return;
|
|
Territory@ prev = territories[emp.index].get();
|
|
territories[emp.index].set(terr);
|
|
|
|
for(uint i = 0, cnt = planetList.length; i < cnt; ++i) {
|
|
Planet@ pl = planetList[i];
|
|
pl.changeResourceTerritory(prev, terr);
|
|
pl.changeSurfaceTerritory(prev, terr);
|
|
}
|
|
|
|
for(uint i = 0, cnt = resourceHolders.length; i < cnt; ++i) {
|
|
Object@ obj = resourceHolders[i];
|
|
|
|
//Planets were already handled before
|
|
if(obj.isPlanet)
|
|
continue;
|
|
|
|
obj.changeResourceTerritory(prev, terr);
|
|
}
|
|
}
|
|
|
|
void clearTerritory(Empire@ emp, Territory@ old) {
|
|
if(emp is null || !emp.valid)
|
|
return;
|
|
Territory@ prev = territories[emp.index].get();
|
|
if(prev is old)
|
|
territories[emp.index].set(null);
|
|
}
|
|
|
|
void regionObjectOwnerChange(Object& thisObj, Object& obj, Empire@ prevOwner, Empire@ newOwner) {
|
|
Region@ region = cast<Region>(thisObj);
|
|
//Change effect owner
|
|
for(uint i = 0, cnt = effects.length; i < cnt; ++i) {
|
|
RegionEffect@ eff = effects[i];
|
|
eff.ownerChange(region, obj, prevOwner, newOwner);
|
|
if(eff.forEmpire is null)
|
|
continue;
|
|
|
|
if(prevOwner is eff.forEmpire)
|
|
eff.disable(region, obj);
|
|
else if(newOwner is eff.forEmpire)
|
|
eff.enable(region, obj);
|
|
}
|
|
|
|
//Check planet trade
|
|
switch(obj.type) {
|
|
case OT_Planet:
|
|
if(prevOwner !is null && prevOwner.valid) {
|
|
planetCounts[prevOwner.index] -= 1;
|
|
}
|
|
|
|
if(newOwner !is null && newOwner.valid) {
|
|
planetCounts[newOwner.index] += 1;
|
|
cast<Planet>(obj).setLoyaltyBonus(empLoyaltyBonus[obj.owner.index]);
|
|
}
|
|
else {
|
|
cast<Planet>(obj).setLoyaltyBonus(0);
|
|
}
|
|
calculatePlanets(region);
|
|
break;
|
|
case OT_Ship:
|
|
{
|
|
//Update ship strength
|
|
Ship@ ship = cast<Ship>(obj);
|
|
if(ship.hasLeaderAI) {
|
|
int value = round(ship.blueprint.design.size);
|
|
if(prevOwner !is null && prevOwner.valid)
|
|
strengths[prevOwner.index] -= value;
|
|
if(newOwner !is null && newOwner.valid)
|
|
strengths[newOwner.index] += value;
|
|
}
|
|
calculateShips(region);
|
|
} break;
|
|
case OT_Orbital:
|
|
{
|
|
Orbital@ orbital = cast<Orbital>(obj);
|
|
calculateTradeAccess(region);
|
|
} break;
|
|
}
|
|
|
|
//Apply statuses
|
|
applyStatuses(region, obj, isOwnerChange=true);
|
|
|
|
//Update object counts
|
|
if(prevOwner !is null && prevOwner.valid)
|
|
objectCounts[prevOwner.index] -= 1;
|
|
if(newOwner !is null && newOwner.valid)
|
|
objectCounts[newOwner.index] += 1;
|
|
|
|
//Update shipyards
|
|
if(obj.hasConstruction)
|
|
calculateShipyards(region);
|
|
}
|
|
|
|
void leaveRegion(Object& thisObj, Object& obj) {
|
|
Region@ region = cast<Region>(thisObj);
|
|
|
|
//Remove effects
|
|
for(uint i = 0, cnt = effects.length; i < cnt; ++i) {
|
|
RegionEffect@ eff = effects[i];
|
|
if(eff.forEmpire is null || obj.owner is eff.forEmpire)
|
|
eff.disable(region, obj);
|
|
}
|
|
|
|
switch(obj.type)
|
|
{
|
|
case OT_Ship:
|
|
{
|
|
Ship@ ship = cast<Ship>(obj);
|
|
auto@ dsg = ship.blueprint.design;
|
|
if(obj.owner !is null && obj.owner.valid && ship.hasLeaderAI) {
|
|
int value = round(dsg.size);
|
|
strengths[obj.owner.index] -= value;
|
|
}
|
|
calculateShips(region);
|
|
}
|
|
break;
|
|
case OT_Planet:
|
|
{
|
|
Planet@ pl = cast<Planet>(obj);
|
|
planetList.remove(pl);
|
|
planetBucket.remove(pl);
|
|
if(obj.owner !is null && obj.owner.valid)
|
|
planetCounts[obj.owner.index] -= 1;
|
|
calculatePlanets(region);
|
|
}
|
|
break;
|
|
case OT_Star:
|
|
{
|
|
Star@ star = cast<Star>(obj);
|
|
starList.remove(star);
|
|
starBucket.remove(star);
|
|
StarTemperature -= star.temperature;
|
|
if(starList.length != 0)
|
|
StarRadius = starList[0].radius;
|
|
else
|
|
StarRadius = 0;
|
|
}
|
|
break;
|
|
case OT_Orbital:
|
|
{
|
|
Orbital@ orbital = cast<Orbital>(obj);
|
|
orbitalList.remove(orbital);
|
|
calculateTradeAccess(region);
|
|
}
|
|
break;
|
|
case OT_Asteroid:
|
|
{
|
|
Asteroid@ roid = cast<Asteroid>(obj);
|
|
asteroidList.remove(roid);
|
|
asteroidBucket.remove(roid);
|
|
}
|
|
break;
|
|
case OT_Anomaly:
|
|
{
|
|
Anomaly@ anomaly = cast<Anomaly>(obj);
|
|
anomalyList.remove(anomaly);
|
|
anomalyBucket.remove(anomaly);
|
|
}
|
|
break;
|
|
case OT_Pickup:
|
|
{
|
|
Pickup@ pickup = cast<Pickup>(obj);
|
|
pickupList.remove(pickup);
|
|
pickupBucket.remove(pickup);
|
|
}
|
|
break;
|
|
case OT_Artifact:
|
|
{
|
|
Artifact@ artifact = cast<Artifact>(obj);
|
|
artifactList.remove(artifact);
|
|
artifactBucket.remove(artifact);
|
|
}
|
|
break;
|
|
}
|
|
|
|
//Handle shipyards
|
|
if(obj.hasConstruction)
|
|
unregisterShipyard(region, obj);
|
|
|
|
//Remove from all objects
|
|
if(obj.owner !is null && obj.owner.valid)
|
|
objectCounts[obj.owner.index] -= 1;
|
|
objectList.remove(obj);
|
|
|
|
//Remove from component-based lists
|
|
if(obj.hasResources)
|
|
resourceHolders.remove(obj);
|
|
}
|
|
|
|
void enterRegion(Object& thisObj, Object& obj) {
|
|
Region@ region = cast<Region>(thisObj);
|
|
switch(obj.type)
|
|
{
|
|
case OT_Ship:
|
|
{
|
|
Ship@ ship = cast<Ship>(obj);
|
|
if(obj.owner !is null && obj.owner.valid && ship.hasLeaderAI) {
|
|
auto@ dsg = ship.blueprint.design;
|
|
if(dsg !is null) {
|
|
int value = round(dsg.size);
|
|
strengths[obj.owner.index] += value;
|
|
}
|
|
}
|
|
calculateShips(region);
|
|
}
|
|
break;
|
|
case OT_Planet:
|
|
{
|
|
Planet@ pl = cast<Planet>(obj);
|
|
planetList.insertLast(pl);
|
|
planetBucket.add(pl);
|
|
if(obj.owner !is null && obj.owner.valid)
|
|
planetCounts[obj.owner.index] += 1;
|
|
calculatePlanets(region);
|
|
}
|
|
break;
|
|
case OT_Star:
|
|
{
|
|
Star@ star = cast<Star>(obj);
|
|
starList.insertLast(star);
|
|
starBucket.add(star);
|
|
StarTemperature += star.temperature;
|
|
if(starList.length != 0)
|
|
StarRadius = starList[0].radius;
|
|
else
|
|
StarRadius = 0;
|
|
}
|
|
break;
|
|
case OT_Orbital:
|
|
{
|
|
Orbital@ orbital = cast<Orbital>(obj);
|
|
orbitalList.insertLast(orbital);
|
|
/*int value = orbital.MilitaryValue;*/
|
|
/*if(obj.owner !is null && obj.owner.valid)*/
|
|
/* strengths[obj.owner.index] += value;*/
|
|
calculateTradeAccess(region);
|
|
}
|
|
break;
|
|
case OT_Asteroid:
|
|
{
|
|
Asteroid@ roid = cast<Asteroid>(obj);
|
|
asteroidList.insertLast(roid);
|
|
asteroidBucket.add(roid);
|
|
}
|
|
break;
|
|
case OT_Anomaly:
|
|
{
|
|
Anomaly@ anomaly = cast<Anomaly>(obj);
|
|
anomalyList.insertLast(anomaly);
|
|
anomalyBucket.add(anomaly);
|
|
}
|
|
break;
|
|
case OT_Pickup:
|
|
{
|
|
Pickup@ pickup = cast<Pickup>(obj);
|
|
pickupList.insertLast(pickup);
|
|
pickupBucket.add(pickup);
|
|
}
|
|
break;
|
|
case OT_Artifact:
|
|
{
|
|
Artifact@ artifact = cast<Artifact>(obj);
|
|
artifactList.insertLast(artifact);
|
|
artifactBucket.add(artifact);
|
|
}
|
|
break;
|
|
}
|
|
|
|
//Add to all objects
|
|
if(obj.owner !is null && obj.owner.valid)
|
|
objectCounts[obj.owner.index] += 1;
|
|
objectList.insertLast(obj);
|
|
|
|
//Add to component-based lists
|
|
if(obj.hasResources)
|
|
resourceHolders.insertLast(obj);
|
|
|
|
//Apply statuses
|
|
applyStatuses(region, obj);
|
|
|
|
//Handle shipyards
|
|
if(obj.hasConstruction)
|
|
registerShipyard(region, obj);
|
|
|
|
//Add effects
|
|
for(uint i = 0, cnt = effects.length; i < cnt; ++i) {
|
|
RegionEffect@ eff = effects[i];
|
|
if(eff.forEmpire is null || obj.owner is eff.forEmpire)
|
|
eff.enable(region, obj);
|
|
}
|
|
}
|
|
|
|
int addRegionEffect(Object& obj, RegionEffect@ eff) {
|
|
Region@ region = cast<Region>(obj);
|
|
eff.id = nextEffectId++;
|
|
effects.insertLast(eff);
|
|
|
|
eff.start(region);
|
|
for(uint i = 0, cnt = objectList.length; i < cnt; ++i) {
|
|
if(eff.forEmpire is null || objectList[i].owner is eff.forEmpire)
|
|
eff.enable(region, objectList[i]);
|
|
}
|
|
|
|
return eff.id;
|
|
}
|
|
|
|
int addRegionEffect(Object& obj, Empire@ forEmpire, uint id) {
|
|
Region@ region = cast<Region>(obj);
|
|
const RegionEffectType@ type = getRegionEffect(id);
|
|
|
|
RegionEffect@ eff = type.create();
|
|
@eff.forEmpire = forEmpire;
|
|
|
|
return addRegionEffect(obj, eff);
|
|
}
|
|
|
|
void addTemporaryVision(Object& obj, Empire@ forEmpire, double timer) {
|
|
addRegionEffect(obj, GrantVision(forEmpire, timer));
|
|
}
|
|
|
|
void removeRegionEffect(Object& obj, int id) {
|
|
Region@ region = cast<Region>(obj);
|
|
for(uint i = 0, cnt = effects.length; i < cnt; ++i) {
|
|
RegionEffect@ eff = effects[i];
|
|
if(eff.id != id)
|
|
continue;
|
|
|
|
removeRegionEffectByIndex(obj, i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void removeRegionEffectByIndex(Object& obj, uint withIndex) {
|
|
Region@ region = cast<Region>(obj);
|
|
RegionEffect@ eff = effects[withIndex];
|
|
eff.end(region);
|
|
for(uint i = 0, cnt = objectList.length; i < cnt; ++i) {
|
|
if(eff.forEmpire is null || objectList[i].owner is eff.forEmpire)
|
|
eff.disable(region, objectList[i]);
|
|
}
|
|
effects.removeAt(withIndex);
|
|
}
|
|
|
|
void changeRegionEffectOwner(Object& obj, int id, Empire@ newOwner) {
|
|
Region@ region = cast<Region>(obj);
|
|
for(uint i = 0, cnt = effects.length; i < cnt; ++i) {
|
|
RegionEffect@ eff = effects[i];
|
|
if(eff.id != id)
|
|
continue;
|
|
|
|
//Disable for anything that is no longer affected, and enable
|
|
//for everything that is now newly affected
|
|
for(uint i = 0, cnt = objectList.length; i < cnt; ++i) {
|
|
if(newOwner !is null && (eff.forEmpire is null || objectList[i].owner is eff.forEmpire))
|
|
eff.disable(region, objectList[i]);
|
|
}
|
|
|
|
Empire@ prevOwner = eff.forEmpire;
|
|
@eff.forEmpire = newOwner;
|
|
eff.changeEffectOwner(region, prevOwner, newOwner);
|
|
|
|
for(uint i = 0, cnt = objectList.length; i < cnt; ++i) {
|
|
if((newOwner is null && objectList[i].owner !is eff.forEmpire) || objectList[i].owner is newOwner)
|
|
eff.enable(region, objectList[i]);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void calculateShips(Object& obj) {
|
|
//Update the vision
|
|
calculateVision(obj);
|
|
}
|
|
|
|
void addTradePathing(int toSystem, Object@ from, Object@ to, int resId, uint resource) {
|
|
//Create line node if needed
|
|
if(tradeLines is null) {
|
|
if(system is null)
|
|
return;
|
|
@tradeLines = TradeLinesNode();
|
|
tradeLines.establish(system.index);
|
|
}
|
|
|
|
//Find other system index
|
|
int other = -1;
|
|
uint sys = toSystem;
|
|
if(sys != system.index && toSystem != -1) {
|
|
for(uint i = 0, cnt = system.adjacent.length; i < cnt; ++i) {
|
|
if(system.adjacent[i] == sys) {
|
|
other = i;
|
|
break;
|
|
}
|
|
}
|
|
if(other == -1)
|
|
return;
|
|
}
|
|
|
|
//Add to the node
|
|
tradeLines.addPathing(other, from, to, resId, resource);
|
|
}
|
|
|
|
void removeTradePathing(int toSystem, Object@ from, int resId) {
|
|
if(tradeLines is null)
|
|
return;
|
|
|
|
//Find other system index
|
|
int other = -1;
|
|
uint sys = toSystem;
|
|
if(sys != system.index && toSystem != -1) {
|
|
for(uint i = 0, cnt = system.adjacent.length; i < cnt; ++i) {
|
|
if(system.adjacent[i] == sys) {
|
|
other = i;
|
|
break;
|
|
}
|
|
}
|
|
if(other == -1)
|
|
return;
|
|
}
|
|
|
|
//Remove from the node
|
|
tradeLines.removePathing(other, from, resId);
|
|
}
|
|
|
|
void calculatePlanets(Object& obj) {
|
|
Region@ region = cast<Region>(obj);
|
|
|
|
//Calculate primary empire (most planets)
|
|
Empire@ primary = null;
|
|
int amount = 0;
|
|
|
|
uint cnt = planetCounts.length;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
int value = planetCounts[i];
|
|
if(value > amount) {
|
|
amount = value;
|
|
@primary = getEmpire(i);
|
|
}
|
|
}
|
|
|
|
if(primary !is primaryEmpire) {
|
|
@primaryEmpire = primary;
|
|
|
|
if(primary is null)
|
|
region.PrimaryEmpire = -1;
|
|
else
|
|
region.PrimaryEmpire = primary.id;
|
|
|
|
updatePlane(region);
|
|
}
|
|
|
|
calculateVision(obj);
|
|
calculateTradeAccess(obj);
|
|
}
|
|
|
|
Empire@ get_visiblePrimaryEmpire(Player& pl, const Object& obj) const {
|
|
const Region@ region = cast<const Region>(obj);
|
|
Empire@ emp = pl.emp;
|
|
if(emp is null)
|
|
return null;
|
|
|
|
if(region.VisionMask & emp.visionMask != 0)
|
|
return primaryEmpire;
|
|
|
|
if(!emp.valid)
|
|
return null;
|
|
return primaryVision[emp.index];
|
|
}
|
|
|
|
void updatePlane(const Region& obj) {
|
|
for(uint i = 0, cnt = primaryVision.length; i < cnt; ++i) {
|
|
Empire@ other = getEmpire(i);
|
|
if(obj.VisionMask & other.visionMask != 0)
|
|
@primaryVision[i] = primaryEmpire;
|
|
}
|
|
|
|
//Inform the nodes
|
|
if(playerEmpire is null || !playerEmpire.valid)
|
|
plane.setPrimaryEmpire(primaryEmpire);
|
|
else
|
|
plane.setPrimaryEmpire(primaryVision[playerEmpire.index]);
|
|
}
|
|
|
|
void calculateTradeAccess(Object& obj) {
|
|
#section server
|
|
Region@ region = cast<Region>(obj);
|
|
|
|
uint mask = 0;
|
|
for(uint i = 0, cnt = planetList.length; i < cnt; ++i) {
|
|
Planet@ pl = planetList[i];
|
|
if(pl.owner is null || !pl.owner.valid)
|
|
continue;
|
|
mask |= pl.owner.mask;
|
|
}
|
|
for(uint i = 0, cnt = tradeGrants.length; i < cnt; ++i) {
|
|
if(tradeGrants[i] > 0)
|
|
mask |= getEmpire(i).mask;
|
|
}
|
|
|
|
region.TradeMask = mask;
|
|
#section all
|
|
}
|
|
|
|
void grantMemory(Empire@ emp) {
|
|
for(uint i = 0, cnt = planetList.length; i < cnt; ++i)
|
|
planetList[i].giveHistoricMemory(emp);
|
|
}
|
|
|
|
void grantVision(Object& obj, Empire@ emp) {
|
|
if(emp !is null && emp.valid) {
|
|
visionGrants[emp.index] += 1;
|
|
calculateVision(obj);
|
|
}
|
|
}
|
|
|
|
void revokeVision(Object& obj, Empire@ emp) {
|
|
if(emp !is null && emp.valid) {
|
|
visionGrants[emp.index] -= 1;
|
|
calculateVision(obj);
|
|
}
|
|
}
|
|
|
|
void grantTrade(Object& obj, Empire@ emp) {
|
|
if(emp !is null && emp.valid) {
|
|
tradeGrants[emp.index] += 1;
|
|
calculateTradeAccess(obj);
|
|
}
|
|
}
|
|
|
|
void revokeTrade(Object& obj, Empire@ emp) {
|
|
if(emp !is null && emp.valid) {
|
|
tradeGrants[emp.index] -= 1;
|
|
calculateTradeAccess(obj);
|
|
}
|
|
}
|
|
|
|
void forceSiegeAllPlanets(Empire@ emp, uint mask, uint doMask = ~0) {
|
|
for(uint i = 0, cnt = planetList.length; i < cnt; ++i) {
|
|
Planet@ pl = planetList[i];
|
|
Empire@ owner = pl.owner;
|
|
if(owner is emp)
|
|
continue;
|
|
if(!pl.valid || owner is null)
|
|
continue;
|
|
if(owner.mask & mask != 0)
|
|
continue;
|
|
if(owner.mask & doMask == 0)
|
|
continue;
|
|
|
|
pl.forceSiege(mask);
|
|
if(pl.getLoyaltyFacing(emp) <= 0)
|
|
pl.annex(emp);
|
|
}
|
|
}
|
|
|
|
void clearForceSiegeAllPlanets(uint mask) {
|
|
for(uint i = 0, cnt = planetList.length; i < cnt; ++i) {
|
|
Planet@ pl = planetList[i];
|
|
pl.clearForceSiege(mask);
|
|
}
|
|
}
|
|
|
|
uint prevMask = 0;
|
|
void calculateVision(Object& obj) {
|
|
Region@ region = cast<Region>(obj);
|
|
|
|
int prevSeen = region.SeenMask;
|
|
uint avSupMask = 0;
|
|
for(uint i = 0, cnt = planetList.length; i < cnt; ++i) {
|
|
auto@ pl = planetList[i];
|
|
Empire@ owner = pl.owner;
|
|
if(owner is null || !owner.valid)
|
|
continue;
|
|
if(pl.supportCount > 0 && pl.SupplyUsed > pl.SupplySatellite && pl.allowFillFrom)
|
|
avSupMask |= owner.mask;
|
|
}
|
|
for(uint i = 0, cnt = orbitalList.length; i < cnt; ++i) {
|
|
auto@ obj = orbitalList[i];
|
|
Empire@ owner = obj.owner;
|
|
if(owner is null || !owner.valid)
|
|
continue;
|
|
if(obj.supportCount > 0 && obj.allowFillFrom)
|
|
avSupMask |= owner.mask;
|
|
}
|
|
region.AvailSupportMask = avSupMask;
|
|
|
|
#section server
|
|
uint mask = 0, basicMask = 0;
|
|
for(uint i = 0, cnt = objectCounts.length; i < cnt; ++i) {
|
|
Empire@ emp = getEmpire(i);
|
|
if(objectCounts[i] > 0) {
|
|
basicMask |= emp.mask;
|
|
mask |= emp.mask;
|
|
}
|
|
if(visionGrants[i] > 0) {
|
|
mask |= emp.mask;
|
|
}
|
|
}
|
|
|
|
for(uint i = 0, cnt = objectCounts.length; i < cnt; ++i) {
|
|
Empire@ emp = getEmpire(i);
|
|
if(emp.visionMask & mask != 0)
|
|
mask |= emp.mask;
|
|
}
|
|
|
|
if(region.VisionMask != mask || prevMask != playerEmpire.visionMask || basicMask != region.BasicVisionMask) {
|
|
region.VisionMask = mask;
|
|
region.MemoryMask |= mask;
|
|
region.SeenMask |= mask;
|
|
updatePlane(region);
|
|
|
|
if(system.donateVision)
|
|
region.DonateVisionMask = mask;
|
|
else
|
|
region.DonateVisionMask = 0;
|
|
|
|
for(uint i = 0, cnt = getEmpireCount(); i < cnt; ++i) {
|
|
Empire@ emp = getEmpire(i);
|
|
if(!emp.major)
|
|
continue;
|
|
if(basicMask & emp.mask == 0)
|
|
continue;
|
|
uint contact = uint(emp.ContactMask.value);
|
|
if((~contact) & basicMask == 0)
|
|
continue;
|
|
|
|
for(uint j = 0; j < cnt; ++j) {
|
|
Empire@ other = getEmpire(j);
|
|
if(!other.major)
|
|
continue;
|
|
if(basicMask & other.mask == 0)
|
|
continue;
|
|
uint prevContact = (emp.ContactMask |= other.mask);
|
|
if(prevContact & other.mask != 0)
|
|
continue;
|
|
|
|
bool gainsBonus = config::INFLUENCE_CONTACT_BONUS > 0
|
|
&& (other.ContactMask & ~(emp.mask | other.mask) == 0);
|
|
if(gainsBonus) {
|
|
emp.addInfluence(config::INFLUENCE_CONTACT_BONUS);
|
|
giveAchievement(emp, "ACH_FIRST_SIGHT");
|
|
}
|
|
emp.notifyEmpireMet(obj, other, gainsBonus);
|
|
}
|
|
}
|
|
|
|
prevMask = playerEmpire.visionMask;
|
|
}
|
|
|
|
region.BasicVisionMask = basicMask;
|
|
#section shadow
|
|
if(system !is null)
|
|
region.SeenMask |= region.VisionMask;
|
|
#section all
|
|
|
|
int newSeen = region.SeenMask;
|
|
if(prevSeen != newSeen && system !is null) {
|
|
region.ExploredMask |= newSeen;
|
|
for(uint i = 0, cnt = system.adjacent.length; i < cnt; ++i) {
|
|
auto@ other = getSystem(system.adjacent[i]);
|
|
if(other !is null)
|
|
other.object.ExploredMask |= newSeen;
|
|
}
|
|
}
|
|
|
|
for(uint i = 0, cnt = icons.length; i < cnt; ++i)
|
|
icons[i].update(region);
|
|
}
|
|
|
|
void updateRegionPlane(const Object& obj) {
|
|
updatePlane(cast<const Region>(obj));
|
|
}
|
|
|
|
void calculateShipyards(Object& obj) {
|
|
Region@ region = cast<Region>(obj);
|
|
|
|
uint mask = 0;
|
|
for(uint i = 0, cnt = shipyardList.length; i < cnt; ++i)
|
|
mask |= shipyardList[i].owner.mask;
|
|
region.ShipyardMask = mask;
|
|
}
|
|
|
|
IconRing@ getIconRing(int level, bool create) {
|
|
IconRing@ ring;
|
|
for(uint i = 0, cnt = icons.length; i < cnt; ++i) {
|
|
if(icons[i].level == level)
|
|
return icons[i];
|
|
}
|
|
|
|
if(create) {
|
|
IconRing ring;
|
|
ring.level = level;
|
|
icons.insertLast(ring);
|
|
return ring;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
void addStrategicIcon(Object& region, int level, Object& obj, Node& node) {
|
|
IconRing@ ring = getIconRing(level, true);
|
|
ring.add(cast<Region>(region), obj, node);
|
|
}
|
|
|
|
void removeStrategicIcon(Object& region, int level, Node& node) {
|
|
IconRing@ ring = getIconRing(level, false);
|
|
if(ring !is null)
|
|
ring.remove(cast<Region>(region), node);
|
|
}
|
|
};
|
|
|
|
tidy class IconRing {
|
|
int level = 0;
|
|
array<Object@> objects;
|
|
array<Node@> nodes;
|
|
array<uint> sortList;
|
|
|
|
void update(Region& region) {
|
|
uint cnt = nodes.length;
|
|
if(cnt == 0)
|
|
return;
|
|
|
|
double angleStep = (twopi / double(cnt));
|
|
vec3d sysPos = region.position;
|
|
double radius = region.OuterRadius + (800 * level);
|
|
vec3d basePos = objects[0].position;
|
|
double baseAngle = vec2d(basePos.x - sysPos.x, basePos.z - sysPos.z).radians();
|
|
|
|
sortList.length = cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
Node@ node = nodes[i];
|
|
vec3d pos = objects[i].position;
|
|
double myAngle = vec2d(pos.x - sysPos.x, pos.z - sysPos.z).radians();
|
|
double diff = angleDiff(myAngle, baseAngle);
|
|
if(diff < 0)
|
|
diff += twopi;
|
|
|
|
sortList[i] = uint(diff * 10000.0) << 8 | i;
|
|
}
|
|
sortList.sortAsc();
|
|
|
|
uint mask = 0;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
uint index = sortList[i] & 0x000000ff;
|
|
Node@ node = nodes[index];
|
|
|
|
double myAngle = baseAngle + double(i) * angleStep;
|
|
vec3d pos = sysPos + vec3d(cos(myAngle) * radius, 0, sin(myAngle) * radius);
|
|
node.hintParentObject(region, false);
|
|
|
|
{
|
|
PlanetIconNode@ icon = cast<PlanetIconNode@>(node);
|
|
if(icon !is null) {
|
|
icon.setStrategic(pos, sysPos);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
{
|
|
StrategicIconNode@ icon = cast<StrategicIconNode@>(node);
|
|
if(icon !is null) {
|
|
icon.setStrategic(pos, sysPos);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void add(Region& region, Object@ obj, Node@ node) {
|
|
objects.insertLast(obj);
|
|
nodes.insertLast(node);
|
|
update(region);
|
|
}
|
|
|
|
void remove(Region& region, Node@ node) {
|
|
int index = nodes.find(node);
|
|
if(index != -1) {
|
|
nodes.removeAt(index);
|
|
objects.removeAt(index);
|
|
}
|
|
|
|
{
|
|
PlanetIconNode@ icon = cast<PlanetIconNode@>(node);
|
|
if(icon !is null)
|
|
icon.clearStrategic();
|
|
}
|
|
|
|
{
|
|
StrategicIconNode@ icon = cast<StrategicIconNode@>(node);
|
|
if(icon !is null)
|
|
icon.clearStrategic();
|
|
}
|
|
|
|
node.hintParentObject(null, false);
|
|
update(region);
|
|
}
|
|
};
|