Lucas de Vries
1261 lines
31 KiB
ActionScript
1261 lines
31 KiB
ActionScript
#priority init 1500
|
|
import object_creation;
|
|
import map_systems;
|
|
from map_systems import IMapHook;
|
|
from regions.regions import addRegion;
|
|
import settings.map_lib;
|
|
import settings.game_settings;
|
|
import statuses;
|
|
import planet_types;
|
|
from empire import Creeps, majorEmpireCount;
|
|
import Artifact@ makeArtifact(SystemDesc@ system, uint type = uint(-1)) from "map_effects";
|
|
import void createWormhole(SystemDesc@ from, SystemDesc@ to) from "objects.Oddity";
|
|
import void mapCopyRegion(SystemDesc@ from, SystemDesc@ to, uint typeMask = ~0) from "map_effects";
|
|
import util.map_tools;
|
|
|
|
//Global data to be access after generation
|
|
array<SystemDesc@> generatedSystems;
|
|
array<GasData@> generatedGalaxyGas;
|
|
array<GalaxyData@> generatedGalaxies;
|
|
NameGenerator sysNames;
|
|
|
|
Node@ getCullingNode(const vec3d& pos) {
|
|
/*uint cnt = generatedGalaxies.length;
|
|
if(cnt > 1) {
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
auto@ glx = generatedGalaxies[i];
|
|
if(glx.origin.distanceToSQ(pos) < glx.radius * glx.radius)
|
|
return glx.cullingNode;
|
|
}
|
|
}*/
|
|
|
|
return null;
|
|
}
|
|
|
|
void init() {
|
|
sysNames.preventDuplicates = true;
|
|
sysNames.read("data/system_names.txt");
|
|
|
|
GlobalUniqueSystems.length = getSystemTypeCount();
|
|
for(uint i = 0, cnt = GlobalUniqueSystems.length; i < cnt; ++i)
|
|
GlobalUniqueSystems[i] = false;
|
|
}
|
|
|
|
//Default constants
|
|
const uint HOMEWORLD_TARGET_LINKS = 4;
|
|
array<bool> GlobalUniqueSystems;
|
|
|
|
//A single map generation script
|
|
class MapGeneration {
|
|
GalaxyData gdat;
|
|
MapSettings@ settings;
|
|
|
|
array<bool> uniqueSystems(getSystemTypeCount(), false);
|
|
array<GasData@> gasses;
|
|
array<SystemDesc@> systems;
|
|
array<SystemData@> systemData;
|
|
array<SystemData@> homeworlds;
|
|
array<SystemData@> wormholes;
|
|
array<SystemData@> possibleHomeworlds;
|
|
uint wormholeIndex = 0;
|
|
double gasSideLen = 1000.0;
|
|
bool haveLinks = false;
|
|
bool autoGenerateLinks = true;
|
|
int galaxyQuality = 0;
|
|
|
|
uint estPlayerCount = 1;
|
|
uint universePlayerCount = 1;
|
|
|
|
array<Empire@> teamEmpires;
|
|
array<SystemData@> teamPositions;
|
|
|
|
Node@ cullingNode;
|
|
|
|
vec3d origin;
|
|
vec3d leftExtent;
|
|
vec3d rightExtent;
|
|
double radius;
|
|
|
|
Region@ region;
|
|
Star@ star;
|
|
|
|
ObjectDesc sysDesc;
|
|
ObjectDesc starDesc;
|
|
ObjectDesc planetDesc;
|
|
LightDesc lightDesc;
|
|
SystemDesc@ system;
|
|
|
|
MapGeneration() {
|
|
sysDesc.type = OT_Region;
|
|
sysDesc.flags |= objNoPhysics;
|
|
sysDesc.delayedCreation = true;
|
|
|
|
starDesc.type = OT_Star;
|
|
starDesc.radius = 100.0;
|
|
|
|
planetDesc.flags |= objMemorable;
|
|
planetDesc.type = OT_Planet;
|
|
planetDesc.delayedCreation = true;
|
|
|
|
lightDesc.diffuse = Colorf(2.7f, 2.0f, 1.0f);
|
|
lightDesc.specular = lightDesc.diffuse;
|
|
lightDesc.att_quadratic = 1.f/(2000.f*2000.f);
|
|
}
|
|
|
|
void modSettings(GameSettings& settings) {
|
|
}
|
|
|
|
double getSetting(uint index, double def = 0.0) {
|
|
return settings.getSetting(index, def);
|
|
}
|
|
|
|
void placeSystems() {
|
|
}
|
|
|
|
void placeLinks() {
|
|
}
|
|
|
|
void prepareSystem(SystemData@ data, SystemDesc@ desc) {
|
|
if(data.homeworlds !is null && data.mirrorSystem !is null)
|
|
data.ignoreAdjacencies = true;
|
|
desc.radius = 250.0;
|
|
if(data.homeworlds !is null) {
|
|
const SystemType@ hwType = getSystemType("HomeSystem");
|
|
if(hwType !is null)
|
|
data.systemType = hwType.id;
|
|
@data.systemCode = null;
|
|
}
|
|
}
|
|
|
|
void generateSystems() {
|
|
bool systemCulling = systemData.length > 1;
|
|
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i) {
|
|
prepareSystem(systemData[i], systems[i]);
|
|
generateSystem(systemData[i], systems[i], systemCulling);
|
|
}
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i)
|
|
postGenerateSystem(systemData[i], systems[i]);
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i)
|
|
finalizeSystem(systemData[i], systems[i]);
|
|
}
|
|
|
|
SystemData@ addSystem(vec3d point, int quality = 0, bool canHaveHomeworld = true, int sysType = -1, const SystemCode@ code = null, SystemData@ mirrorSystem = null) {
|
|
SystemData dat;
|
|
dat.index = systemData.length;
|
|
dat.position = point;
|
|
dat.quality = quality;
|
|
dat.canHaveHomeworld = canHaveHomeworld;
|
|
dat.systemType = sysType;
|
|
@dat.mirrorSystem = mirrorSystem;
|
|
if(mirrorSystem !is null && code is null)
|
|
@code = SystemCode();
|
|
@dat.systemCode = code;
|
|
|
|
systemData.insertLast(dat);
|
|
return dat;
|
|
}
|
|
|
|
void preGenerate() {
|
|
//Place systems from the map
|
|
placeSystems();
|
|
|
|
//Place links from the map
|
|
placeLinks();
|
|
|
|
//If the map has no links, automatically generate them
|
|
if(autoGenerateLinks) {
|
|
generateAutomatedLinks();
|
|
while(!ensureConnectedLinks());
|
|
}
|
|
|
|
//Update the full extent of the map
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i) {
|
|
vec3d pos = systemData[i].position;
|
|
|
|
if(pos.x < leftExtent.x)
|
|
leftExtent.x = pos.x;
|
|
if(pos.y < leftExtent.y)
|
|
leftExtent.y = pos.y;
|
|
if(pos.z < leftExtent.z)
|
|
leftExtent.z = pos.z;
|
|
|
|
if(pos.x > rightExtent.x)
|
|
rightExtent.x = pos.x;
|
|
if(pos.y > rightExtent.y)
|
|
rightExtent.y = pos.y;
|
|
if(pos.z > rightExtent.z)
|
|
rightExtent.z = pos.z;
|
|
}
|
|
|
|
radius = max((rightExtent - leftExtent).length / 2.0, 6000.0);
|
|
}
|
|
|
|
void setOrigin(vec3d Origin) {
|
|
origin = Origin;
|
|
move(origin);
|
|
}
|
|
|
|
vec3d getAveragePosition() {
|
|
vec3d avg;
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i)
|
|
avg += systemData[i].position;
|
|
return avg / double(systemData.length);
|
|
}
|
|
|
|
void move(const vec3d& move) {
|
|
leftExtent += origin;
|
|
rightExtent += origin;
|
|
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i)
|
|
systemData[i].position += origin;
|
|
}
|
|
|
|
void generate() {
|
|
//Create the culling node
|
|
//@cullingNode = createCullingNode(origin, radius * 1.5);
|
|
|
|
//Generate everything that was placed
|
|
generateSystems();
|
|
|
|
//Generate the galaxy gas
|
|
prepGalaxyGas(max(rightExtent.x - leftExtent.x, rightExtent.y - leftExtent.y));
|
|
generateGas();
|
|
|
|
//Add local data to generated lists
|
|
for(uint i = 0, cnt = gasses.length; i < cnt; ++i)
|
|
generatedGalaxyGas.insertLast(gasses[i]);
|
|
|
|
//Create placed wormholes
|
|
generateWormholes();
|
|
|
|
//Create galaxy data
|
|
gdat.index = generatedGalaxies.length;
|
|
gdat.origin = origin;
|
|
gdat.radius = radius;
|
|
gdat.systems = systems;
|
|
@gdat.cullingNode = cullingNode;
|
|
|
|
//Create galaxy plane node
|
|
@gdat.plane = GalaxyPlaneNode();
|
|
gdat.plane.establish(origin, radius);
|
|
|
|
generatedGalaxies.insertLast(gdat);
|
|
}
|
|
|
|
//** {{{ Homeworlds
|
|
bool canHaveHomeworld(SystemData@ data, Empire@ emp) {
|
|
return data.canHaveHomeworld;
|
|
}
|
|
|
|
bool canHaveHomeworld(Empire@ emp) {
|
|
return true;
|
|
}
|
|
|
|
SystemData@ addPossibleHomeworld(SystemData@ data) {
|
|
possibleHomeworlds.insertLast(data);
|
|
return data;
|
|
}
|
|
|
|
SystemData@ findHomeworld(Empire@ emp, vec3d goal) {
|
|
if(possibleHomeworlds.length != 0) {
|
|
SystemData@ sys;
|
|
if(emp.team != -1 && teamPositions.length != 0 && config::TEAMS_START_CLOSE != 0) {
|
|
double bestDist = INFINITY;
|
|
for(uint i = 0, cnt = possibleHomeworlds.length; i < cnt; ++i) {
|
|
auto@ check = possibleHomeworlds[i];
|
|
double d = 0;
|
|
for(uint n = 0, ncnt = teamEmpires.length; n < ncnt; ++n) {
|
|
if(teamEmpires[n].team == emp.team)
|
|
d += teamPositions[n].position.distanceTo(check.position);
|
|
}
|
|
if(d < bestDist) {
|
|
@sys = check;
|
|
bestDist = d;
|
|
}
|
|
}
|
|
if(sys !is null)
|
|
possibleHomeworlds.remove(sys);
|
|
}
|
|
if(sys is null) {
|
|
uint index = randomi(0, possibleHomeworlds.length - 1);
|
|
@sys = possibleHomeworlds[index];
|
|
possibleHomeworlds.removeAt(index);
|
|
}
|
|
if(emp.team != -1) {
|
|
teamEmpires.insertLast(emp);
|
|
teamPositions.insertLast(sys);
|
|
}
|
|
return sys;
|
|
}
|
|
double best = 0;
|
|
uint sysCount = systemData.length;
|
|
SystemData@ result;
|
|
for(uint i = 0; i < sysCount; ++i) {
|
|
SystemData@ dat = systemData[i];
|
|
if(!canHaveHomeworld(dat, emp))
|
|
continue;
|
|
|
|
double w = 1.0;
|
|
|
|
uint linkCnt = dat.adjacent.length;
|
|
w /= max(1, sqr(int(linkCnt) - int(HOMEWORLD_TARGET_LINKS)));
|
|
|
|
w /= goal.distanceToSQ(dat.position);
|
|
|
|
if(w > best) {
|
|
best = w;
|
|
@result = dat;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void markHomeworld(SystemData@ dat) {
|
|
//List this as a homeworld
|
|
homeworlds.insertLast(dat);
|
|
}
|
|
// }}}
|
|
|
|
//** {{{ Gas Generation
|
|
void prepGalaxyGas(double sideLen) {
|
|
gasSideLen = sideLen;
|
|
|
|
gasses.length = 64;
|
|
for(uint i = 0; i < 64; ++i) {
|
|
int x = int(i) % 8;
|
|
int y = int(i) / 8;
|
|
|
|
GasData data;
|
|
@data.gdat = gdat;
|
|
data.position = vec3d((double(x) - 3.5) * sideLen / 8.0, 0.0, (double(y) - 3.5) * sideLen / 8.0) + origin;
|
|
data.scale = sideLen / 16.0;
|
|
data.generate(cullingNode);
|
|
@gasses[i] = data;
|
|
}
|
|
}
|
|
|
|
void generateGas() {
|
|
Color innerBright, outerBright;
|
|
|
|
switch(randomi(0,2)) {
|
|
case 0:
|
|
innerBright = Color(0xc08060ff);
|
|
outerBright = Color(0x0040c0ff);
|
|
break;
|
|
case 1:
|
|
innerBright = Color(0xc08060ff);
|
|
outerBright = Color(0x006040ff);
|
|
break;
|
|
case 2:
|
|
innerBright = Color(0xc08060ff);
|
|
outerBright = Color(0x600060ff);
|
|
break;
|
|
}
|
|
|
|
for(uint i = 0, cnt = systems.length; i < cnt; ++i) {
|
|
vec3d sysPos = systems[i].position;
|
|
double edgePct = sysPos.distanceTo(origin) / (radius * 0.6);
|
|
|
|
int brightCount = 10 + int(4.0 * edgePct);
|
|
for(int k = 0; k < brightCount; ++k) {
|
|
Color col = innerBright.interpolate(outerBright, edgePct);
|
|
col.a = randomi(0x14,0x1c);
|
|
vec3d pos = sysPos + vec3d(randomd(-10000.0, 10000.0), randomd(-8000.0,8000.0) * (1.0 - edgePct * 0.75), randomd(-10000.0, 10000.0));
|
|
|
|
createGalaxyGas(pos, 7500.0 - 2000.0 * edgePct, col, k == 0);
|
|
}
|
|
|
|
int darkCount = 1 + int(3.0 * edgePct);
|
|
for(int k = 0; k < darkCount; ++k) {
|
|
//Color col = Color(0x200c1815).interpolate(Color(0x08060340), edgePct);
|
|
Colorf fcol;
|
|
fcol.fromHSV(randomd(0,360.0), randomd(0.0,0.2), randomd(0.0,0.2));
|
|
fcol.a = randomd(0.1,0.2);
|
|
|
|
vec3d pos = sysPos + vec3d(randomd(-10000.0, 10000.0), randomd(-2000.0,2000.0), randomd(-10000.0, 10000.0));
|
|
createGalaxyGas(pos, 4200.0, Color(fcol), true);
|
|
}
|
|
}
|
|
}
|
|
|
|
GasData@ gasNodeForPoint(const vec3d& pos) {
|
|
int x = clamp(int(((pos.x - origin.x) * (8.0 / gasSideLen)) + 4.0), 0, 7);
|
|
int y = clamp(int(((pos.z - origin.z) * (8.0 / gasSideLen)) + 4.0), 0, 7);
|
|
return gasses[x + (y*8)];
|
|
}
|
|
|
|
void createGalaxyGas(const vec3d& position, double radius, const Color& col, bool structured) {
|
|
GasData@ gas = gasNodeForPoint(position);
|
|
gas.addSprite(position, radius, col.rgba, structured);
|
|
}
|
|
// }}}
|
|
|
|
//** {{{ Link Generation
|
|
void addLink(uint from, uint to) {
|
|
addLink(systemData[from], systemData[to]);
|
|
}
|
|
|
|
void addLink(SystemData@ from, SystemData@ to) {
|
|
if(from.adjacent.find(to.index) == -1) {
|
|
from.adjacent.insertLast(to.index);
|
|
from.adjacentData.insertLast(to);
|
|
}
|
|
if(to.adjacent.find(from.index) == -1) {
|
|
to.adjacent.insertLast(from.index);
|
|
to.adjacentData.insertLast(from);
|
|
}
|
|
haveLinks = true;
|
|
}
|
|
|
|
void generateAutomatedLinks(uint targLinks = 3) {
|
|
AngularItem[] items(16);
|
|
uint cnt = systemData.length;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
SystemData@ desc = systemData[i];
|
|
if(!desc.autoGenerateLinks)
|
|
continue;
|
|
|
|
//Clear angular list
|
|
for(uint p = 0; p < 16; ++p)
|
|
items[p].clear();
|
|
|
|
//Add angular items to list
|
|
for(uint j = 0; j < cnt; ++j) {
|
|
SystemData@ other = systemData[j];
|
|
if(other is desc)
|
|
continue;
|
|
|
|
vec2d offset(other.position.x - desc.position.x, other.position.z - desc.position.z);
|
|
|
|
double angle = offset.radians() + twopi;
|
|
double dist = offset.length;
|
|
if(dist > 31000.0)
|
|
continue;
|
|
|
|
//double sz = atan(other.radius / dist);
|
|
double sz = atan(1200.0 / dist); //TODO: Base this on something?
|
|
|
|
int closest = int(angle / twopi * 16.0);
|
|
int firstBox = int((angle - sz) / twopi * 16.0);
|
|
int lastBox = int((angle + sz) / twopi * 16.0);
|
|
|
|
for(int p = firstBox; p <= lastBox; ++p) {
|
|
AngularItem@ item = items[(p+16) % 16];
|
|
if(item.desc is null || item.dist > dist) {
|
|
@item.desc = other;
|
|
item.dist = dist;
|
|
item.blocked = p != closest;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Turn items into links
|
|
uint linksMade = desc.adjacent.length;
|
|
double distReq = 13000.0;
|
|
do {
|
|
for(uint p = 0, n = randomi(0,15); p < 16; ++p) {
|
|
AngularItem@ item = items[n];
|
|
if(!item.blocked && item.desc !is null && item.desc.autoGenerateLinks && item.dist <= distReq) {
|
|
if(desc.adjacent.find(item.desc.index) == -1) {
|
|
desc.adjacent.insertLast(item.desc.index);
|
|
desc.adjacentData.insertLast(item.desc);
|
|
}
|
|
|
|
if(item.desc.adjacent.find(desc.index) == -1) {
|
|
item.desc.adjacent.insertLast(desc.index);
|
|
item.desc.adjacentData.insertLast(desc);
|
|
}
|
|
|
|
++linksMade;
|
|
if(distReq > 13000.0 && linksMade >= targLinks)
|
|
break;
|
|
@item.desc = null;
|
|
}
|
|
|
|
n = (n+1) % 16;
|
|
}
|
|
|
|
//Slowly relax distance requirement until we have at least
|
|
//the target amount of links to work with.
|
|
distReq += 3000.0;
|
|
} while(linksMade < targLinks && distReq <= 31000.0);
|
|
}
|
|
}
|
|
|
|
void mark(SystemData@ desc, int markWith, vec3d& point, uint& count) {
|
|
count += 1;
|
|
point += desc.position;
|
|
desc.marked = markWith;
|
|
|
|
for(uint i = 0, cnt = desc.adjacent.length; i < cnt; ++i) {
|
|
SystemData@ other = systemData[desc.adjacent[i]];
|
|
if(other.marked != markWith)
|
|
mark(other, markWith, point, count);
|
|
}
|
|
}
|
|
|
|
bool ensureConnectedLinks() {
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i)
|
|
systemData[i].marked = -1;
|
|
|
|
int ind = 0;
|
|
array<vec3d> centers;
|
|
array<uint> counts;
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i) {
|
|
SystemData@ desc = systemData[i];
|
|
if(desc.marked == -1) {
|
|
vec3d point;
|
|
uint count = 0;
|
|
|
|
mark(desc, ind, point, count);
|
|
|
|
centers.insertLast(point / double(count));
|
|
counts.insertLast(count);
|
|
++ind;
|
|
}
|
|
}
|
|
|
|
if(ind > 1) {
|
|
//Find the smallest subgraph.
|
|
int smallest = 0;
|
|
uint smallnum = counts[0];
|
|
for(int i = 1; i < ind; ++i) {
|
|
if(counts[i] < smallnum) {
|
|
smallnum = counts[i];
|
|
smallest = i;
|
|
}
|
|
}
|
|
|
|
//Find the best way to connect it to any other subgraph
|
|
SystemData@ bestSmall;
|
|
SystemData@ bestLarge;
|
|
double bestDist = INFINITY;
|
|
for(int n = 0; n < ind; ++n) {
|
|
if(n == smallest)
|
|
continue;
|
|
|
|
vec3d center = centers[n];
|
|
SystemData@ closestSmall;
|
|
double closest = INFINITY;
|
|
|
|
//Find a system from the smaller set closest to the larger set's center
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i) {
|
|
SystemData@ desc = systemData[i];
|
|
if(desc.marked == smallest) {
|
|
double d = desc.position.distanceToSQ(center);
|
|
if(d < closest) {
|
|
@closestSmall = desc;
|
|
closest = d;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Find the system from the larger set that is closest to the smaller system
|
|
SystemData@ closestLarge;
|
|
closest = INFINITY;
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i) {
|
|
SystemData@ desc = systemData[i];
|
|
if(desc.marked == n) {
|
|
double d = desc.position.distanceToSQ(closestSmall.position);
|
|
if(d < closest) {
|
|
@closestLarge = desc;
|
|
closest = d;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(closest < bestDist) {
|
|
@bestSmall = closestSmall;
|
|
@bestLarge = closestLarge;
|
|
bestDist = closest;
|
|
}
|
|
}
|
|
|
|
//Make the link
|
|
addLink(bestSmall, bestLarge);
|
|
return false;
|
|
}
|
|
else {
|
|
return true;
|
|
}
|
|
}
|
|
//}}}
|
|
|
|
//** {{{ System Calculation
|
|
double getContestation(SystemData@ data, array<double>@ local) {
|
|
double nearest = INFINITY, secondary = INFINITY;
|
|
|
|
uint hwCnt = homeworlds.length;
|
|
if(local.length < hwCnt)
|
|
local.length = hwCnt;
|
|
for(uint i = 0; i < hwCnt; ++i) {
|
|
double dist = data.hwDistances[i];
|
|
if(dist < nearest) {
|
|
secondary = nearest;
|
|
nearest = dist;
|
|
}
|
|
else if(dist < secondary) {
|
|
secondary = dist;
|
|
}
|
|
local[i] = dist;
|
|
}
|
|
|
|
double pts = 0.0;
|
|
|
|
//The nearest 2 players make up most of the points
|
|
pts += (nearest / secondary) * 200.0 - 50.0;
|
|
|
|
//Additional players can give bonus points
|
|
for(uint i = 0; i < hwCnt; ++i) {
|
|
double d = local[i];
|
|
if(d <= secondary)
|
|
continue;
|
|
double pct = (nearest / d);
|
|
if(pct > 0.5)
|
|
pts += (pct - 0.5) * 100;
|
|
}
|
|
|
|
return pts;
|
|
}
|
|
|
|
void calculateGalaxyQuality(array<SystemData@>@ globalHomeworlds) {
|
|
galaxyQuality = 0;
|
|
}
|
|
|
|
void calculateQuality(SystemData@ data, array<SystemData@>@ globalHomeworlds, array<double>@ local) {
|
|
if(data.homeworlds !is null)
|
|
return;
|
|
if(homeworlds.length < 2) {
|
|
data.quality += galaxyQuality;
|
|
data.contestation = homeworlds.length == 0 ? INFINITY : 0;
|
|
}
|
|
else {
|
|
data.contestation = getContestation(data, local);
|
|
data.quality += galaxyQuality + max(int(data.contestation), 0);
|
|
}
|
|
}
|
|
|
|
void calculateHomeworldDistances() {
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i)
|
|
@systemData[i].hwDistances = array<double>(homeworlds.length, INFINITY);
|
|
|
|
for(uint hwInd = 0, hwCnt = homeworlds.length; hwInd < hwCnt; ++hwInd) {
|
|
priority_queue pqueue;
|
|
set_int visited;
|
|
|
|
pqueue.push(int(homeworlds[hwInd].index), INFINITY);
|
|
systemData[homeworlds[hwInd].index].hwDistances[hwInd] = 0.0;
|
|
|
|
while(!pqueue.empty()) {
|
|
int index = pqueue.top();
|
|
pqueue.pop();
|
|
|
|
if(visited.contains(index))
|
|
continue;
|
|
visited.insert(index);
|
|
|
|
auto@ dat = systemData[index];
|
|
double curDist = dat.hwDistances[hwInd];
|
|
|
|
for(uint i = 0, cnt = dat.adjacentData.length; i < cnt; ++i) {
|
|
auto@ adj = dat.adjacentData[i];
|
|
if(visited.contains(adj.index))
|
|
continue;
|
|
|
|
double dDist = curDist + 1000.0 + adj.position.distanceTo(dat.position);
|
|
if(dDist < adj.hwDistances[hwInd]) {
|
|
adj.hwDistances[hwInd] = dDist;
|
|
pqueue.push(adj.index, -int(dDist/1000.0));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
array<const ResourceType@>@ getDistributedResources(uint count, int quality, double contestation) {
|
|
array<const ResourceType@> resources(count);
|
|
if(count == 0)
|
|
return resources;
|
|
|
|
double score = 1.0;
|
|
for(uint i = 0; i < count; ++i) {
|
|
const ResourceType@ type = getDistributedResourceContest(contestation);
|
|
@resources[i] = type;
|
|
score /= type.rarityScore;
|
|
}
|
|
|
|
array<const ResourceType@> prev = resources;
|
|
uint rolls = 0;
|
|
|
|
if(quality != 0) {
|
|
double bestScore = score;
|
|
|
|
array<const ResourceType@> reroll(count);
|
|
while(quality != 0) {
|
|
bool getBetter = false;
|
|
if(quality > 0) {
|
|
getBetter = true;
|
|
if(quality < 100) {
|
|
if(randomi(0,99) > quality)
|
|
break;
|
|
quality = 0;
|
|
}
|
|
else {
|
|
quality -= 100;
|
|
}
|
|
}
|
|
else if(quality > -100) {
|
|
if(randomi(0,99) > -quality)
|
|
break;
|
|
quality = 0;
|
|
}
|
|
else {
|
|
quality += 100;
|
|
}
|
|
|
|
double rrScore = 1.0;
|
|
for(uint i = 0; i < count; ++i) {
|
|
const ResourceType@ type = getDistributedResourceContest(contestation);
|
|
@reroll[i] = type;
|
|
rrScore /= type.rarityScore;
|
|
}
|
|
|
|
rolls += 1;
|
|
if(getBetter) {
|
|
if(rrScore > bestScore) {
|
|
bestScore = rrScore;
|
|
resources = reroll;
|
|
}
|
|
}
|
|
else {
|
|
if(rrScore < bestScore) {
|
|
bestScore = rrScore;
|
|
resources = reroll;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return resources;
|
|
}
|
|
//}}}
|
|
|
|
//** {{{ System Generation
|
|
void generateLinks(SystemData@ from, SystemDesc@ into) {
|
|
for(uint i = 0, cnt = from.adjacent.length; i < cnt; ++i) {
|
|
if(from.adjacent[i] > from.index)
|
|
continue;
|
|
SystemDesc@ other = systems[from.adjacent[i]];
|
|
double dist = from.position.distanceTo(other.position);
|
|
|
|
into.adjacent.insertLast(other.index);
|
|
into.adjacentDist.insertLast(dist);
|
|
|
|
other.adjacent.insertLast(into.index);
|
|
other.adjacentDist.insertLast(dist);
|
|
}
|
|
}
|
|
|
|
void generateRegions() {
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i) {
|
|
SystemData@ data = systemData[i];
|
|
|
|
//Create the region
|
|
string name = sysNames.generate();
|
|
sysDesc.name = name;
|
|
sysDesc.position = data.position;
|
|
|
|
//Hint the creation of the region, so we can reference its hint data in saves
|
|
LockHint hint();
|
|
Region@ region = cast<Region>(makeObject(sysDesc));
|
|
region.alwaysVisible = true;
|
|
|
|
//Remember the system position
|
|
region.InnerRadius = 1000;
|
|
region.OuterRadius = 1500;
|
|
region.radius = region.OuterRadius;
|
|
|
|
//Create the system descriptor
|
|
SystemDesc desc;
|
|
desc.index = generatedSystems.length;
|
|
region.SystemId = desc.index;
|
|
desc.name = name;
|
|
desc.position = data.position;
|
|
desc.radius = region.OuterRadius;
|
|
desc.assignGroup = data.assignGroup;
|
|
@desc.object = region;
|
|
data.sysIndex = desc.index;
|
|
|
|
systems.insertLast(desc);
|
|
generatedSystems.insertLast(desc);
|
|
}
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i) {
|
|
auto@ data = systemData[i];
|
|
auto@ desc = systems[i];
|
|
|
|
generateLinks(data, desc);
|
|
addRegion(desc.object);
|
|
}
|
|
}
|
|
|
|
void generateSystem(SystemData@ data, SystemDesc@ desc, bool systemCulling = true) {
|
|
//Hint that objects in one iteration should
|
|
//start in the same lock
|
|
@region = desc.object;
|
|
@system = desc;
|
|
desc.contestation = data.contestation;
|
|
|
|
LockHint hint(region);
|
|
|
|
//Create the system node
|
|
Node@ snode;
|
|
if(systemCulling) {
|
|
@snode = bindCullingNode(region, desc.position, 1000.0);
|
|
//snode.reparent(cullingNode);
|
|
}
|
|
|
|
//Find a valid system type
|
|
if(data.systemCode !is null) {
|
|
Object@ current;
|
|
for(uint i = 0, cnt = data.systemCode.hooks.length; i < cnt; ++i) {
|
|
auto@ hook = cast<IMapHook@>(data.systemCode.hooks[i]);
|
|
if(hook !is null)
|
|
hook.trigger(data, system, current);
|
|
}
|
|
}
|
|
else {
|
|
const SystemType@ type = getSystemType(data.systemType);
|
|
if(type is null) {
|
|
@type = getDistributedSystemType();
|
|
data.systemType = type.id;
|
|
while(type.unique != SU_NonUnique) {
|
|
if(type.unique == SU_Galaxy) {
|
|
if(uniqueSystems[type.id]) {
|
|
@type = getDistributedSystemType();
|
|
continue;
|
|
}
|
|
else {
|
|
uniqueSystems[type.id] = true;
|
|
break;
|
|
}
|
|
}
|
|
else if(type.unique == SU_Global) {
|
|
if(GlobalUniqueSystems[type.id]) {
|
|
@type = getDistributedSystemType();
|
|
continue;
|
|
}
|
|
else {
|
|
GlobalUniqueSystems[type.id] = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
type.generate(data, desc);
|
|
}
|
|
|
|
if(data.mirrorSystem !is null) {
|
|
SystemDesc@ otherDesc = systems[data.mirrorSystem.index];
|
|
desc.radius = otherDesc.radius / 1.5;
|
|
}
|
|
|
|
//Set region radius
|
|
region.InnerRadius = desc.radius;
|
|
region.OuterRadius = desc.radius * 1.5;
|
|
region.radius = region.OuterRadius;
|
|
desc.radius = region.OuterRadius;
|
|
|
|
//Update the culling node boundary based on the system data
|
|
if(snode !is null) {
|
|
snode.scale = region.radius + 128.0;
|
|
snode.rebuildTransform();
|
|
}
|
|
|
|
//Clear unnecessary references
|
|
@region = null;
|
|
@star = null;
|
|
}
|
|
|
|
void postGenerateSystem(SystemData@ data, SystemDesc@ desc) {
|
|
//Do post generation effects
|
|
if(data.systemCode !is null) {
|
|
Object@ current;
|
|
for(uint i = 0, cnt = data.systemCode.hooks.length; i < cnt; ++i) {
|
|
auto@ hook = cast<IMapHook@>(data.systemCode.hooks[i]);
|
|
if(hook !is null)
|
|
hook.postTrigger(data, system, current);
|
|
}
|
|
}
|
|
else {
|
|
const SystemType@ type = getSystemType(data.systemType);
|
|
if(type !is null)
|
|
type.postGenerate(data, desc);
|
|
}
|
|
}
|
|
|
|
void finalizeSystem(SystemData@ data, SystemDesc@ desc) {
|
|
//Do mirror copying
|
|
if(data.mirrorSystem !is null && data.homeworlds is null)
|
|
mapCopyRegion(systems[data.mirrorSystem.index], desc);
|
|
|
|
//Deal with resource scarcity
|
|
if(config::RESOURCE_SCARCITY != 0 && data.distributedResources.length != 0) {
|
|
uint sysCnt = generatedSystems.length;
|
|
double targSys = 20.0 * double(majorEmpireCount);
|
|
double factor = 1.0;
|
|
if(sysCnt > uint(targSys))
|
|
factor = pow(double(sysCnt) - targSys, 0.1);
|
|
double pct = (targSys * factor) / double(sysCnt) / config::RESOURCE_SCARCITY;
|
|
if(pct < 1.0) {
|
|
double step = 1.0 / double(data.distributedResources.length);
|
|
uint amount = floor(pct / step);
|
|
if(randomd() < (pct - double(amount)*step) / step)
|
|
amount += 1;
|
|
amount = max(amount, data.quality / 200);
|
|
|
|
for(uint i = amount, cnt = data.distributedResources.length; i < cnt; ++i) {
|
|
auto@ obj = data.distributedResources[amount];
|
|
if(obj.isPlanet) {
|
|
auto@ barren = getStatusType("Barren");
|
|
if(barren !is null)
|
|
obj.addStatus(barren.id);
|
|
auto@ barrenType = getPlanetType("Barren");
|
|
if(barrenType !is null)
|
|
cast<Planet>(obj).PlanetType = barrenType.id;
|
|
data.distributedConditions.remove(cast<Planet>(obj));
|
|
}
|
|
data.distributedResources.removeAt(amount);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Finalize resource distribution
|
|
uint resCnt = data.distributedResources.length;
|
|
bool hasEnergy = false;
|
|
if(resCnt != 0) {
|
|
array<const ResourceType@>@ resources = getDistributedResources(resCnt, data.quality, data.contestation);
|
|
for(uint i = 0; i < resCnt; ++i) {
|
|
if(resources[i].tilePressure[TR_Energy] > 0)
|
|
hasEnergy = true;
|
|
data.distributedResources[i].addResource(resources[i].id);
|
|
|
|
auto@ biome = getBiome(resources[i].nativeBiome);
|
|
if(biome !is null)
|
|
data.distributedResources[i].replaceFirstBiomeWith(biome.id);
|
|
markResourceUsed(resources[i]);
|
|
}
|
|
data.distributedResources.length = 0;
|
|
}
|
|
|
|
//Finalize conditions
|
|
for(uint i = 0, cnt = data.distributedConditions.length; i < cnt; ++i)
|
|
data.distributedConditions[i].addRandomCondition();
|
|
|
|
//Do handicaps
|
|
if(data.homeworlds !is null && data.homeworlds.length == 1) {
|
|
Empire@ emp = data.homeworlds[0];
|
|
while(emp.handicap >= 10) {
|
|
bool found = false;
|
|
uint plCnt = region.planetCount;
|
|
for(uint i = 0, index = randomi(0, plCnt-1); i < plCnt; ++i) {
|
|
Planet@ pl = region.planets[index];
|
|
if((pl.owner is null || !pl.owner.valid) && pl.valid && !pl.destroying) {
|
|
pl.destroy();
|
|
emp.handicap -= 10;
|
|
found = true;
|
|
break;
|
|
}
|
|
index = (index + 1) % plCnt;
|
|
}
|
|
|
|
if(!found)
|
|
break;
|
|
}
|
|
}
|
|
if(data.homeworlds !is null) {
|
|
for(uint i = 0, cnt = data.homeworlds.length; i < cnt; ++i)
|
|
@data.homeworlds[i].HomeSystem = desc.object;
|
|
}
|
|
|
|
//Ensure artifacts in systems with energy
|
|
if(hasEnergy && data.artifacts == 0)
|
|
makeArtifact(desc);
|
|
|
|
//Do home system mirroring
|
|
if(data.homeworlds !is null && data.mirrorSystem !is null) {
|
|
if(data.mirrorSystem.homeworlds !is null) {
|
|
SystemData@ other = data.mirrorSystem;
|
|
SystemDesc@ otherDesc = systems[other.index];
|
|
|
|
for(uint i = 0, cnt = desc.object.objectCount; i < cnt; ++i) {
|
|
Object@ obj = desc.object.objects[i];
|
|
if(obj.isAsteroid)
|
|
obj.destroy();
|
|
}
|
|
|
|
uint types = 1<<uint(OT_Anomaly);
|
|
types |= 1<<uint(OT_Artifact);
|
|
types |= 1<<uint(OT_Asteroid);
|
|
mapCopyRegion(otherDesc, desc, types);
|
|
|
|
for(uint i = 0, cnt = otherDesc.object.planetCount; i < cnt; ++i) {
|
|
Planet@ pl = otherDesc.object.planets[i];
|
|
vec3d destPos = pl.position - other.position;
|
|
destPos.z = -destPos.z;
|
|
destPos += data.position;
|
|
|
|
Planet@ mirr = desc.object.planets[i];
|
|
mirr.orbitAround(destPos, data.position);
|
|
if(pl !is null && mirr !is null) {
|
|
for(uint n = 0, ncnt = mirr.nativeResourceCount; n < ncnt; ++n) {
|
|
mirr.removeResource(mirr.nativeResourceId[0]);
|
|
mirr.wait();
|
|
}
|
|
for(uint n = 0, ncnt = pl.nativeResourceCount; n < ncnt; ++n)
|
|
mirr.addResource(pl.nativeResourceType[n]);
|
|
mirr.wait();
|
|
}
|
|
mirr.mirrorSurfaceFrom(pl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//}}}
|
|
|
|
//** {{{ Wormhole Generation
|
|
void placeWormholes(uint amount) {
|
|
uint sysCnt = systemData.length;
|
|
for(uint i = 0; i < amount; ++i) {
|
|
uint index = randomi(0, sysCnt - 1);
|
|
SystemData@ data;
|
|
|
|
for(uint n = 0; n < sysCnt; ++n) {
|
|
@data = systemData[index];
|
|
index = (index+1) % sysCnt;
|
|
|
|
if(data.homeworlds !is null)
|
|
continue;
|
|
bool adjHW = false;
|
|
for(uint j = 0, jcnt = data.adjacent.length; j < jcnt; ++j) {
|
|
if(systemData[data.adjacent[j]].homeworlds !is null) {
|
|
adjHW = true;
|
|
break;
|
|
}
|
|
}
|
|
if(adjHW)
|
|
continue;
|
|
break;
|
|
}
|
|
|
|
wormholes.insertLast(data);
|
|
}
|
|
}
|
|
|
|
SystemDesc@ getWormhole() {
|
|
if(wormholeIndex >= wormholes.length)
|
|
return null;
|
|
auto@ sys = generatedSystems[wormholes[wormholeIndex].sysIndex];
|
|
wormholeIndex += 1;
|
|
return sys;
|
|
}
|
|
|
|
void createWormhole(SystemData@ from, SystemData@ to) {
|
|
from.wormholes.insertLast(to.index);
|
|
}
|
|
|
|
void generateWormholes() {
|
|
for(uint i = 0, cnt = systemData.length; i < cnt; ++i) {
|
|
auto@ data = systemData[i];
|
|
for(uint n = 0, ncnt = data.wormholes.length; n < ncnt; ++n) {
|
|
auto@ other = systemData[data.wormholes[n]];
|
|
auto@ desc = systems[i];
|
|
auto@ otherDesc = systems[other.index];
|
|
|
|
::createWormhole(desc, otherDesc);
|
|
addWormhole(desc, otherDesc);
|
|
addWormhole(otherDesc, desc);
|
|
}
|
|
}
|
|
}
|
|
|
|
void addWormhole(SystemDesc@ dat, SystemDesc@ other) {
|
|
dat.wormholes.insertLast(other.index);
|
|
}
|
|
//}}}
|
|
|
|
//** {{{ Utilities
|
|
double middleAngle(double from, double to) {
|
|
double diff = to - from;
|
|
if(diff < 0)
|
|
diff += twopi;
|
|
double newAngle = from + (diff * 0.5);
|
|
if(newAngle >= twopi)
|
|
newAngle -= twopi;
|
|
return newAngle;
|
|
}
|
|
|
|
double angleDiff(double a, double b) {
|
|
double diff = a - b;
|
|
if(diff < -pi)
|
|
diff += twopi;
|
|
else if(diff >= pi)
|
|
diff -= twopi;
|
|
return abs(diff);
|
|
}
|
|
//}}}
|
|
|
|
//** {{{ Game code
|
|
void initDefs() {
|
|
}
|
|
|
|
void preInit() {
|
|
}
|
|
|
|
void init() {
|
|
}
|
|
|
|
void tick(double time) {
|
|
}
|
|
|
|
void save(SaveFile& file) {
|
|
}
|
|
|
|
void load(SaveFile& file) {
|
|
}
|
|
//}}}
|
|
};
|
|
|
|
// {{{ Automation data structures
|
|
final class AngularItem {
|
|
double dist = 0.0;
|
|
SystemData@ desc;
|
|
bool blocked = false;
|
|
|
|
void clear() {
|
|
@desc = null;
|
|
blocked = false;
|
|
}
|
|
};
|
|
|
|
//}}}
|
|
|
|
// {{{ Gas data structures
|
|
final class GasSprite {
|
|
vec3d pos;
|
|
double scale;
|
|
uint color;
|
|
bool structured;
|
|
};
|
|
|
|
final class GasData {
|
|
GalaxyData@ gdat;
|
|
GalaxyGas@ node;
|
|
GasSprite[] sprites;
|
|
vec3d position;
|
|
double scale;
|
|
|
|
void generate(Node@ parent = null) {
|
|
@node = GalaxyGas();
|
|
node.position = position;
|
|
node.scale = scale;
|
|
if(parent !is null)
|
|
node.reparent(parent);
|
|
node.rebuildTransform();
|
|
}
|
|
|
|
void addSprite(vec3d pos, double scale, uint color, bool structured) {
|
|
GasSprite sprt;
|
|
sprt.pos = pos;
|
|
sprt.scale = scale;
|
|
sprt.color = color;
|
|
sprt.structured = structured;
|
|
|
|
sprites.insertLast(sprt);
|
|
node.addSprite(pos, scale, color, structured);
|
|
}
|
|
|
|
void save(SaveFile& msg) {
|
|
msg << position;
|
|
msg << scale;
|
|
msg << gdat.index;
|
|
|
|
uint cnt = sprites.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
GasSprite@ sprt = sprites[i];
|
|
msg << sprt.pos;
|
|
msg << sprt.scale;
|
|
msg << sprt.color;
|
|
msg << sprt.structured;
|
|
}
|
|
}
|
|
|
|
void load(SaveFile& msg) {
|
|
msg >> position;
|
|
msg >> scale;
|
|
|
|
uint gindex = 0;
|
|
msg >> gindex;
|
|
@gdat = generatedGalaxies[gindex];
|
|
generate(gdat.cullingNode);
|
|
|
|
uint cnt = 0;
|
|
msg >> cnt;
|
|
sprites.length = cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
GasSprite@ sprt = sprites[i];
|
|
msg >> sprt.pos;
|
|
msg >> sprt.scale;
|
|
msg >> sprt.color;
|
|
bool structured = true;
|
|
if(msg >= SV_0041)
|
|
msg >> structured;
|
|
|
|
node.addSprite(sprt.pos, sprt.scale, sprt.color, structured);
|
|
}
|
|
}
|
|
};
|
|
//}}}
|
|
|
|
// {{{ Galaxy data structures
|
|
final class GalaxyData {
|
|
uint index = 0;
|
|
vec3d origin;
|
|
double radius;
|
|
SystemDesc@[] systems;
|
|
Node@ cullingNode;
|
|
GalaxyPlaneNode@ plane;
|
|
|
|
void save(SaveFile& msg) {
|
|
msg << origin;
|
|
msg << radius;
|
|
|
|
uint cnt = systems.length;
|
|
msg << cnt;
|
|
for(uint i = 0; i < cnt; ++i)
|
|
msg << systems[i].index;
|
|
}
|
|
|
|
void load(SaveFile& msg) {
|
|
msg >> origin;
|
|
msg >> radius;
|
|
@cullingNode = createCullingNode(origin, radius * 1.5);
|
|
|
|
@plane = GalaxyPlaneNode();
|
|
plane.establish(origin, radius);
|
|
|
|
uint cnt = 0;
|
|
msg >> cnt;
|
|
systems.length = cnt;
|
|
|
|
uint ind = 0;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
msg >> ind;
|
|
@systems[i] = generatedSystems[ind];
|
|
}
|
|
}
|
|
};
|
|
//}}}
|