Jonas/planetsim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
planetsim/src/render/Viewer.cpp

670 lines
35 KiB
C++
Raw Blame History

#include "Viewer.hpp"
#include "Picking.hpp" // angBetween (rebuildSub)
#include "Projection.hpp" // EqualEarth (layout)
#include <algorithm>
#include <cmath>
#include <cstring>
#include <fstream>
namespace {
const char* weatherEventName(const WeatherSystem& ws, const Planet& p) {
double lon = 0.0, lat = 0.0;
dirToLonLat(Vec3{ws.pos.x, ws.pos.y, ws.pos.z}, lon, lat);
if (ws.tropical && ws.strength >= p.cfg.weatherHurricaneStr)
return (lon > -0.5 && lon < 2.4) ? "Typhoon" : "Hurricane";
return ws.tropical ? "Tropical low" : "Low";
}
int eventSeverityForWeather(const WeatherSystem& ws, const Planet& p) {
return (ws.tropical && ws.strength >= p.cfg.weatherHurricaneStr) ? 2 : (ws.tropical ? 1 : 0);
}
}
bool Viewer::init(int argc, char** argv) {
uint32_t cliSeed = 0; // 0 = no --seed given
for (int a = 1; a < argc; ++a) {
if (!std::strcmp(argv[a], "--seed") && a + 1 < argc)
cliSeed = (uint32_t)std::strtoul(argv[++a], nullptr, 10);
else if (!std::strcmp(argv[a], "--config") && a + 1 < argc)
configPath = argv[++a];
}
SetConfigFlags(FLAG_MSAA_4X_HINT);
InitWindow(screenW, screenH, "Planet Sim - Phase 1: Tectonics");
SetTargetFPS(60);
// Layout: left column 70% wide (3D globe 60% h on top, 2D map 40% h below);
// right column 30% wide (cell info 50% h on top, subareas 50% below).
leftW = (int)(screenW * 0.70f); // 1344
rightX = leftW; rightW = screenW - leftW; // 576
rightH = screenH / 2; // 540
// Top-left: 3D globe (render texture, its own aspect).
view3DW = leftW; view3DH = (int)(screenH * 0.60f); // 1344 x 648
rt3d = LoadRenderTexture(view3DW, view3DH);
SetTextureFilter(rt3d.texture, TEXTURE_FILTER_BILINEAR);
// Bottom-left: 2D Equal Earth map, fit (keep aspect) into the 40% strip.
const int mapAreaY = view3DH, mapAreaH = screenH - view3DH; // (0,648) 1344 x 432
int mapH = mapAreaH - 30;
int mapW = (int)(mapH * (EqualEarth::halfWidth() / EqualEarth::halfHeight()));
if (mapW > leftW - 30) { mapW = leftW - 30; mapH = (int)(mapW / (EqualEarth::halfWidth() / EqualEarth::halfHeight())); }
// Left-align the 2D map (was centered) so the freed space at right holds the live sky panel.
const float mapMargin = 16.0f;
mapRect = Rectangle{ mapMargin,
(float)(mapAreaY + (mapAreaH - mapH) / 2),
(float)mapW, (float)mapH };
float liveX = mapRect.x + mapRect.width + 16.0f;
liveInfoRect = Rectangle{ liveX, mapRect.y, (float)leftW - liveX - 8.0f, mapRect.height };
// Right column.
hoverRect = Rectangle{ (float)rightX + 8, 8.0f, (float)rightW - 16, (float)rightH - 16 };
panelRect = Rectangle{ (float)rightX + 8, (float)rightH + 8, (float)rightW - 16, (float)rightH - 16 };
const float panelHeader = 120.0f;
const float gridSide = std::min(panelRect.width - 40.0f, panelRect.height - panelHeader - 56.0f);
gridRect = Rectangle{ panelRect.x + (panelRect.width - gridSide) / 2.0f,
panelRect.y + panelHeader, gridSide, gridSide };
// Buttons (pause + Phase-3 prompt, centered in the 3D viewport).
pauseBtn = Rectangle{ 16.0f, (float)view3DH - 44.0f, 160.0f, 32.0f };
const float pbW = 220.0f, pbH = 42.0f, pbGap = 24.0f;
pbCx = view3DW * 0.5f; pbCy = view3DH * 0.5f;
p3ContinueBtn = Rectangle{ pbCx - pbW - pbGap * 0.5f, pbCy + 8.0f, pbW, pbH };
p3StartBtn = Rectangle{ pbCx + pbGap * 0.5f, pbCy + 8.0f, pbW, pbH };
cfg.subdivisions = 5;
if (!loadConfig(configPath, cfg)) saveConfig(configPath, cfg); // load, or create a default
if (cliSeed != 0) cfg.seed = cliSeed; // CLI --seed overrides config
std::string cfgErr = validateConfig(cfg);
if (!cfgErr.empty()) cfg = PlanetConfig{}; // revert to safe defaults
planet.generate(cfg);
cam.position = {0, 0, 6}; cam.target = {0, 0, 0}; cam.up = {0, 1, 0};
cam.fovy = 45; cam.projection = CAMERA_PERSPECTIVE;
buildBorders(planet, borderR, borders, ridgeBorders);
buildDriftArrows(planet, driftR, driftArrows, plateLabels);
graticule = buildGraticule();
buildMap2D(planet, mapRect, map2D);
phase3PromptAt = planet.cfg.phase3AfterMy;
refreshView(); // colour the freshly generated (flat) world
return true;
}
void Viewer::rebuildSub() {
subgrids.clear();
if (selectedCell < 0) return;
subgrids.push_back(planet.makeSubGrid(selectedCell, subRes));
const Cell& c = planet.cells[selectedCell];
for (int nb : c.neighbors) subgrids.push_back(planet.makeSubGrid(nb, subRes));
double ma = 0.0;
for (int nb : c.neighbors) ma += angBetween(c.unit, planet.cells[nb].unit);
ma /= std::max<size_t>(1, c.neighbors.size());
selectedThresh = ma * 1.4;
}
void Viewer::selectCell(int idx) {
if (idx < 0) return;
if (idx == selectedCell) { selectedCell = -1; subgrids.clear(); return; }
selectedCell = idx; rebuildSub();
}
// Recolor the mesh + refresh the elevation range, read straight from cells.
void Viewer::recolor() {
double maxAge = 1.0; for (const auto& c : planet.cells) maxAge = std::max(maxAge, c.geoAge);
const std::vector<double>& temp = planet.temperature();
const std::vector<double>& summer = planet.summerTemp();
const std::vector<double>& winter = planet.winterTemp();
const std::vector<double>& moist = planet.moisture(); // 0..1, already robustly normalized
const std::vector<double>& flora = planet.floraDensity();
const std::vector<double>& fauna = planet.faunaDensity();
const std::vector<double>& funga = planet.fungaDensity();
vcolors.resize(planet.cells.size());
for (size_t i = 0; i < planet.cells.size(); ++i) {
switch (mode) {
case ColorMode::Plate: {
int pid = planet.cells[i].plateId;
vcolors[i] = (pid >= 0 && pid < (int)planet.plates.size() && planet.plates[pid].baby)
? Color{70, 80, 95, 255} // young spreading-ridge crust
: plateColor(pid);
break;
}
case ColorMode::Age: vcolors[i] = ageColor(planet.cells[i].geoAge, maxAge); break;
case ColorMode::Crust: vcolors[i] = crustColor(planet.cells[i].oceanic); break;
case ColorMode::Biome: vcolors[i] = biomeColor(planet.cells[i].biome); break;
case ColorMode::Temperature: vcolors[i] = temp.empty() ? Color{90,90,90,255} : tempColor(temp[i]); break;
case ColorMode::TempSummer: vcolors[i] = summer.empty()? Color{90,90,90,255} : tempColor(summer[i]); break;
case ColorMode::TempWinter: vcolors[i] = winter.empty()? Color{90,90,90,255} : tempColor(winter[i]); break;
case ColorMode::Seasonality: vcolors[i] = (summer.empty()||winter.empty()) ? Color{90,90,90,255}
: seasonColor(summer[i] - winter[i]); break;
case ColorMode::Precip: vcolors[i] = moist.empty() ? Color{90,90,90,255} : precipColor(moist[i]); break;
case ColorMode::FloraDensity: vcolors[i] = flora.empty() ? Color{90,90,90,255}
: (planet.cells[i].elevation <= planet.cfg.seaLevel ? marineFloraColor(flora[i]) : floraColor(flora[i])); break;
case ColorMode::FaunaDensity: vcolors[i] = fauna.empty() ? Color{90,90,90,255}
: (planet.cells[i].elevation <= planet.cfg.seaLevel ? marineFaunaColor(fauna[i]) : faunaColor(fauna[i])); break;
case ColorMode::FungaDensity: vcolors[i] = funga.empty() ? Color{90,90,90,255} : fungaColor(funga[i]); break;
default: vcolors[i] = elevationColor(planet.cells[i].elevation, planet.cfg.seaLevel);
}
}
// Phase 3: shade filled basins above sea level as inland water (lakes).
const std::vector<double>& lk = planet.lakeDepth();
if (phase3 && !lk.empty())
for (size_t i = 0; i < planet.cells.size(); ++i)
if (lk[i] > 20.0 && planet.cells[i].elevation > planet.cfg.seaLevel)
vcolors[i] = lakeColor();
minE = planet.minElevation(); maxE = planet.maxElevation();
}
// Live World: from the sim's insolation + live-temperature fields, build the per-cell
// day/night brightness (illum) and the shaded draw colours (base colour -> snow/ice tint ->
// day/night dim). Cheap O(n); called every frame while in Live World.
void Viewer::rebuildLiveOverlay() {
const size_t n = planet.cells.size();
const std::vector<double>& sun = planet.insolation();
const std::vector<double>& lt = planet.liveTemp();
const double sea = planet.cfg.seaLevel;
const double snowT = planet.cfg.snowTemp;
const double iceT = planet.cfg.seaIceTemp;
const float nightFloor = 0.18f; // night side dim (not black) so colours read
illum.assign(n, 1.0f);
shadedColors.resize(n);
auto smoothstep = [](double e0, double e1, double x) {
double t = (e1 > e0) ? (x - e0) / (e1 - e0) : 0.0;
t = t < 0.0 ? 0.0 : (t > 1.0 ? 1.0 : t);
return t * t * (3.0 - 2.0 * t);
};
// Solar eclipse: a moon roughly between the sun and the planet (its model-space direction
// near the sun's) casts a shadow around the sub-solar point. Strength ramps with alignment.
const Vec3 sd{ sunDir.x, sunDir.y, sunDir.z };
const double eclipseReach = 0.13; // rad: how close a moon must be to the sun to eclipse
const double umbra = 0.10; // rad: angular radius of the shadow spot
double eclipseStrength = 0.0;
for (const auto& md : moonDirs) {
double d = std::acos(std::clamp((double)(md.x*sd.x + md.y*sd.y + md.z*sd.z), -1.0, 1.0));
if (d < eclipseReach) eclipseStrength = std::max(eclipseStrength, 1.0 - d / eclipseReach);
}
auto blend = [](unsigned char c, unsigned char to, double a) {
return (unsigned char)(c + (to - c) * a);
};
for (size_t i = 0; i < n; ++i) {
// Day/night: soft sunrise band over the clamped cosine incidence.
float f = nightFloor;
if (!sun.empty()) f = nightFloor + (1.0f - nightFloor) * (float)smoothstep(0.0, 0.12, sun[i]);
// Eclipse shadow: darken cells near the sub-solar point while a moon transits the sun.
if (eclipseStrength > 0.0 && !sun.empty()) {
double dd = std::acos(std::clamp(planet.cells[i].unit.x*sd.x + planet.cells[i].unit.y*sd.y
+ planet.cells[i].unit.z*sd.z, -1.0, 1.0));
double sh = eclipseStrength * std::exp(-(dd / umbra) * (dd / umbra));
f *= (float)std::max(0.10, 1.0 - 0.85 * sh);
}
illum[i] = f;
Color c = vcolors[i];
// Snow on cold land, sea ice on cold ocean (live seasonal temperature).
if (!lt.empty()) {
double e = planet.cells[i].elevation;
if (e > sea) {
double a = (snowT - lt[i]) / 8.0; // fully snow ~8 C below freezing
if (a > 0.0) { a = a > 0.85 ? 0.85 : a;
c = Color{ blend(c.r, 242, a), blend(c.g, 246, a), blend(c.b, 250, a), 255 }; }
} else {
double a = (iceT - lt[i]) / 6.0; // sea ice
if (a > 0.0) { a = a > 0.9 ? 0.9 : a;
c = Color{ blend(c.r, 212, a), blend(c.g, 226, a), blend(c.b, 236, a), 255 }; }
}
}
// Day/night dimming over the (possibly snow-tinted) colour.
if (dayNightOn) c = Color{ (unsigned char)(c.r * f), (unsigned char)(c.g * f), (unsigned char)(c.b * f), 255 };
shadedColors[i] = c;
}
}
void Viewer::refreshView() {
if (phase3) planet.computeHydrology(); // refresh lakes/rivers for the view
planet.computeClimate(); // temperature + precipitation fields
planet.classifyBiomes(); // keep cell.biome current (reads the climate)
planet.computeBiotaDensity(); // flora/fauna/funga density (population is on-demand)
recolor();
if (settled) { // Phase 2: plates moved -> boundaries moved
buildBorders(planet, borderR, borders, ridgeBorders);
buildDriftArrows(planet, driftR, driftArrows, plateLabels);
}
if (phase3) buildRivers(planet, riverR, rivers, bigRivers);
buildCoastline(planet, riverR, coast, coastOcean); // land/ocean boundary (for tide lines)
buildCurrents(planet, driftR, currentSegs, currentCols); // ocean current arrows (warm/cold)
if (selectedCell >= 0) rebuildSub();
}
void Viewer::regenWorld() { // after generate(): geometry changed
buildBorders(planet, borderR, borders, ridgeBorders);
buildDriftArrows(planet, driftR, driftArrows, plateLabels);
buildMap2D(planet, mapRect, map2D);
selectedCell = -1; subgrids.clear();
settled = false; settleRun = 0; formAccum = 0.0; stepCount = 0; paused = false;
liveWorld = false; followId = 0; wxUndo.clear(); events.clear(); nextEventId = 1; // reseed/regen drops back to World Creation
liveInfoTab = 0; eventRowRects.clear(); eventRowIndices.clear();
planet.drifting = false; // Phase 1: original forming behavior
phase3 = false; phase3Prompt = false; phase3PromptAt = planet.cfg.phase3AfterMy;
rivers.clear(); bigRivers.clear();
elapsedMy = 0.0; dtMy = 0.0; driftAccum = 0.0;
refreshView();
}
void Viewer::regen() { planet.generate(cfg); regenWorld(); }
void Viewer::stepOnce() { // one tick + settle bookkeeping
maxChange = planet.step(); ++stepCount;
if (maxChange < settleThresh) { if (++settleRun >= settleNeed) settled = true; }
else settleRun = 0;
}
void Viewer::pauseAction() { paused = !paused; } // pause/resume forming or drift
void Viewer::setStatus(const std::string& m) { statusMsg = m; statusUntil = GetTime() + 3.0; }
void Viewer::appendEvent(uint8_t kind, uint8_t severity, double timeHours, int cell, uint32_t sourceId,
const std::string& title, const std::string& detail) {
if (cell < 0 || cell >= (int)planet.cells.size()) return;
WorldEvent e;
e.id = nextEventId++;
e.kind = kind;
e.severity = severity;
e.timeHours = timeHours;
e.cell = cell;
e.sourceId = sourceId;
e.title = title;
e.detail = detail;
events.push_back(std::move(e));
if ((int)events.size() > EVENT_LOG_MAX)
events.erase(events.begin(), events.begin() + ((int)events.size() - EVENT_LOG_MAX));
}
void Viewer::detectLiveEvents(const std::vector<WeatherSystem>& beforeStorms,
const std::vector<Volcano>& beforeVolcanoes) {
auto beforeStorm = [&](uint32_t id) -> const WeatherSystem* {
for (const WeatherSystem& ws : beforeStorms) if (ws.id == id) return &ws;
return nullptr;
};
for (const WeatherSystem& ws : planet.storms()) {
const WeatherSystem* old = beforeStorm(ws.id);
int cell = nearestCell(planet, Vec3{ws.pos.x, ws.pos.y, ws.pos.z});
double lon = 0.0, lat = 0.0; dirToLonLat(Vec3{ws.pos.x, ws.pos.y, ws.pos.z}, lon, lat);
std::string loc = std::string(TextFormat("%+.0f lat, %+.0f lon", lat * 180.0 / M_PI, lon * 180.0 / M_PI));
if (!old) {
const char* name = weatherEventName(ws, planet);
appendEvent(1, (uint8_t)eventSeverityForWeather(ws, planet), liveTime, cell, ws.id,
std::string(name) + " formed",
std::string(TextFormat("%.0f%% strength, %s", ws.strength * 100.0, loc.c_str())));
} else if (ws.tropical && old->strength < planet.cfg.weatherHurricaneStr
&& ws.strength >= planet.cfg.weatherHurricaneStr) {
const char* name = weatherEventName(ws, planet);
appendEvent(1, 2, liveTime, cell, ws.id,
std::string(name) + " intensified",
std::string(TextFormat("%.0f%% strength, %s", ws.strength * 100.0, loc.c_str())));
}
}
auto beforeVolcano = [&](uint32_t id) -> const Volcano* {
for (const Volcano& v : beforeVolcanoes) if (v.id == id) return &v;
return nullptr;
};
for (const Volcano& v : planet.volcanoes) {
const Volcano* old = beforeVolcano(v.id);
if (!old || v.cell < 0 || v.cell >= (int)planet.cells.size()) continue;
const char* kind = v.kind == 0 ? "Ridge volcano" : v.kind == 1 ? "Border volcano" : "Hotspot volcano";
double oldElev = old->baseElev + old->built;
double newElev = v.baseElev + v.built;
if (old->submarine && oldElev <= planet.cfg.seaLevel && newElev > planet.cfg.seaLevel) {
// Add the new land to the atlas: join an adjacent landmass or mint a fresh Island name.
std::string land = planet.nameNewLand(v.cell);
std::string title = land.empty() ? std::string("Volcanic island formed")
: land + " formed";
appendEvent(2, 1, liveTime, v.cell, v.id, title,
std::string(TextFormat("%s breached sea level (+%.0f m built)", kind, v.built)));
}
if (old->phase != 1 && v.phase == 1) {
appendEvent(2, 1, liveTime, v.cell, v.id, "Volcano went dormant",
std::string(TextFormat("%s, +%.0f m built", kind, v.built)));
}
if (old->phase == 1 && v.phase == 0 && v.ashTimer > 0.0) {
appendEvent(2, 2, liveTime, v.cell, v.id, "Volcano erupted",
std::string(TextFormat("%s exploded, +%.0f m remains", kind, v.built)));
}
}
}
void Viewer::focusCell(int idx, const std::string& status) {
if (idx < 0 || idx >= (int)planet.cells.size()) return;
selectedCell = idx;
rebuildSub();
followId = 0;
Vec3 wd = rotateZ(planet.cells[idx].unit, planet.cfg.axialTilt);
camPitch = std::clamp((float)std::asin(std::clamp(wd.y, -1.0, 1.0)), -1.5f, 1.5f);
camYaw = (float)std::atan2(wd.x, wd.z);
cam.position = { camDist * cosf(camPitch) * sinf(camYaw),
camDist * sinf(camPitch),
camDist * cosf(camPitch) * cosf(camYaw) };
double lon = map2D.lon.empty() ? 0.0 : map2D.lon[idx];
double lat = map2D.lat.empty() ? 0.0 : map2D.lat[idx];
mapLon = wrapPi(-lon);
if (mapZoom <= 1.0001) {
mapPanX = mapPanY = 0.0;
} else {
double x = 0.0, y = 0.0;
EqualEarth::forward(0.0, lat, x, y);
double hh = EqualEarth::halfHeight();
double h = mapRect.height * mapZoom;
double targetY = mapRect.y + (0.5 - y / hh * 0.5) * h + (mapRect.height - h) * 0.5;
mapPanY = std::clamp(mapRect.y + mapRect.height * 0.5 - targetY,
-(h - mapRect.height) * 0.5, (h - mapRect.height) * 0.5);
double w = mapRect.width * mapZoom;
mapPanX = std::clamp(0.0, -(w - mapRect.width) * 0.5, (w - mapRect.width) * 0.5);
}
if (!status.empty()) setStatus(status);
}
// F5: write seed + config + full planet state. F9: read it back and resume.
void Viewer::saveGame(const char* path) {
std::ofstream os(path, std::ios::binary);
if (!os) { setStatus("Save failed"); return; }
uint32_t ver = SAVE_VERSION; uint8_t st = settled ? 1 : 0; uint8_t p3 = phase3 ? 1 : 0;
uint8_t lw = liveWorld ? 1 : 0;
os.write("PLSV", 4);
os.write(reinterpret_cast<const char*>(&ver), sizeof ver);
os.write(reinterpret_cast<const char*>(&elapsedMy), sizeof elapsedMy);
os.write(reinterpret_cast<const char*>(&st), sizeof st);
os.write(reinterpret_cast<const char*>(&driftRate), sizeof driftRate);
os.write(reinterpret_cast<const char*>(&p3), sizeof p3); // v3: Phase-3 flag
os.write(reinterpret_cast<const char*>(&lw), sizeof lw); // v8: Live World flag
os.write(reinterpret_cast<const char*>(&liveTime), sizeof liveTime); // v8: live clock (hours)
os.write(reinterpret_cast<const char*>(&liveRate), sizeof liveRate); // v13: live clock rate
planet.writeState(os);
// v12: persist the most recent step-back frames so a load can rewind storms past the moment.
// v15: frames also carry stateful volcano agents + their RNG.
auto wD = [&](const std::vector<double>& v){ uint64_t m = v.size(); os.write((char*)&m, 8); if (m) os.write((const char*)v.data(), (std::streamsize)(m * sizeof(double))); };
auto wV = [&](const std::vector<Volcano>& v){ uint64_t m = v.size(); os.write((char*)&m, 8); if (m) os.write((const char*)v.data(), (std::streamsize)(m * sizeof(Volcano))); };
auto wS = [&](const std::string& s){ uint64_t m = s.size(); os.write((char*)&m, 8); if (m) os.write(s.data(), (std::streamsize)m); };
uint32_t hn = (uint32_t)std::min<size_t>(wxUndo.size(), (size_t)wxSaveMax);
os.write((char*)&hn, 4);
for (size_t i = wxUndo.size() - hn; i < wxUndo.size(); ++i) {
const WxFrame& f = wxUndo[i];
os.write((char*)&f.t, 8);
wD(f.w.humidity); wD(f.w.cloud); wD(f.w.rain);
uint64_t sc = f.w.storms.size(); os.write((char*)&sc, 8);
if (sc) os.write((const char*)f.w.storms.data(), (std::streamsize)(sc * sizeof(WeatherSystem)));
os.write((char*)&f.w.rng, 4); os.write((char*)&f.w.nextId, 4);
wV(f.w.volcanoes);
os.write((char*)&f.w.volRng, 4);
}
// v16: persistent world event journal, separate from step-back history.
uint32_t en = (uint32_t)std::min<size_t>(events.size(), (size_t)EVENT_LOG_MAX);
os.write((char*)&nextEventId, 4);
os.write((char*)&en, 4);
for (size_t i = events.size() - en; i < events.size(); ++i) {
const WorldEvent& e = events[i];
os.write((char*)&e.id, 4);
os.write((char*)&e.kind, 1);
os.write((char*)&e.severity, 1);
os.write((char*)&e.timeHours, 8);
os.write((char*)&e.cell, 4);
os.write((char*)&e.sourceId, 4);
wS(e.title); wS(e.detail);
}
setStatus(os ? std::string("Saved ") + path : "Save failed");
}
void Viewer::loadGame(const char* path) {
std::ifstream is(path, std::ios::binary);
if (!is) { setStatus(std::string("No ") + path); return; }
char magic[4] = {0}; uint32_t ver = 0; double em = 0; uint8_t st = 0; double dr = 4.0; uint8_t p3 = 0;
uint8_t lw = 0; double lh = 0.0; double lr = 1.0;
is.read(magic, 4);
is.read(reinterpret_cast<char*>(&ver), sizeof ver);
is.read(reinterpret_cast<char*>(&em), sizeof em);
is.read(reinterpret_cast<char*>(&st), sizeof st);
if (ver >= 2) is.read(reinterpret_cast<char*>(&dr), sizeof dr);
if (ver >= 3) is.read(reinterpret_cast<char*>(&p3), sizeof p3);
if (ver >= 8) { is.read(reinterpret_cast<char*>(&lw), sizeof lw);
is.read(reinterpret_cast<char*>(&lh), sizeof lh); } // v8: Live World clock
if (ver >= 13) is.read(reinterpret_cast<char*>(&lr), sizeof lr); // v13: Live World rate
if (!is || std::memcmp(magic, "PLSV", 4) != 0 || ver > SAVE_VERSION) { setStatus("Load failed: bad file"); return; }
if (!planet.readState(is, ver >= 4, ver >= 7, ver >= 9, ver >= 10, ver >= 11, ver >= 14, ver >= 15, ver >= 17, ver >= 18)) { setStatus("Load failed: corrupt/mismatch"); return; } // v4 biome, v7 biota, v9 moons, v10 weather, v11 storms, v14 old volcanoes, v15 stateful volcanoes, v17 geography, v18 geography salt
cfg = planet.cfg; // adopt the loaded config
elapsedMy = em; settled = (st != 0);
planet.drifting = settled; // resume drift boosts iff mid-drift
phase3 = (p3 != 0); phase3Prompt = false;
phase3PromptAt = phase3 ? elapsedMy : (elapsedMy + planet.cfg.phase3AfterMy);
driftRate = dr;
liveWorld = (lw != 0); liveTime = lh; liveRate = std::clamp(lr, 0.25, 720.0); // v8/v13: resume the Live World clock
settleRun = settleNeed; // keep the settled latch consistent
dtMy = settled ? planet.cflDtMy() : 0.0;
driftAccum = 0.0; formAccum = 0.0;
wxUndo.clear(); followId = 0; // drop stale step-back history / follow target
bool skippedHistory = false;
if (ver >= 12 && ver < 15) {
skippedHistory = true; // old frames lack stateful volcanoes; do not restore them
}
if (ver >= 15) { // v15: restore saved step-back frames, including volcano state
bool historyOk = true;
const uint64_t cellCount = planet.cells.size();
auto rD = [&](std::vector<double>& v){
uint64_t m = 0; is.read((char*)&m, 8);
if (!is || (m != 0 && m != cellCount)) { historyOk = false; v.clear(); return; }
v.resize((size_t)m);
if (m) is.read((char*)v.data(), (std::streamsize)(m * sizeof(double)));
if (!is) historyOk = false;
};
auto rV = [&](std::vector<Volcano>& v){
uint64_t m = 0; is.read((char*)&m, 8);
if (!is || m > 100000) { historyOk = false; v.clear(); return; }
v.resize((size_t)m);
if (m) is.read((char*)v.data(), (std::streamsize)(m * sizeof(Volcano)));
if (!is) historyOk = false;
};
uint32_t hn = 0; is.read((char*)&hn, 4);
if (!is || hn > (uint32_t)wxUndoMax) historyOk = false;
for (uint32_t k = 0; k < hn && is; ++k) {
WxFrame f; is.read((char*)&f.t, 8);
rD(f.w.humidity); rD(f.w.cloud); rD(f.w.rain);
uint64_t sc = 0; is.read((char*)&sc, 8);
if (!is || sc > (uint64_t)planet.cfg.weatherSystemMax) { historyOk = false; break; }
f.w.storms.resize((size_t)sc);
if (sc) is.read((char*)f.w.storms.data(), (std::streamsize)(sc * sizeof(WeatherSystem)));
is.read((char*)&f.w.rng, 4); is.read((char*)&f.w.nextId, 4);
rV(f.w.volcanoes);
is.read((char*)&f.w.volRng, 4);
auto sized = [&](const std::vector<double>& v) { return v.empty() || v.size() == planet.cells.size(); };
if (!is || !sized(f.w.humidity) || !sized(f.w.cloud) || !sized(f.w.rain)
|| f.w.humidity.size() != f.w.cloud.size() || f.w.humidity.size() != f.w.rain.size())
historyOk = false;
for (const WeatherSystem& ws : f.w.storms)
if (!std::isfinite(ws.pos.x) || !std::isfinite(ws.pos.y) || !std::isfinite(ws.pos.z)
|| std::fabs(ws.pos.length() - 1.0) > 1e-6
|| !std::isfinite(ws.strength) || ws.strength < 0.0 || ws.strength > 1.0
|| !std::isfinite(ws.radius) || ws.radius <= 0.0
|| !std::isfinite(ws.age) || !std::isfinite(ws.life)
|| !std::isfinite(ws.spin)) historyOk = false;
for (const Volcano& v : f.w.volcanoes)
if (v.cell < 0 || v.cell >= (int)planet.cells.size() || v.phase > 1
|| !std::isfinite(v.activity) || !std::isfinite(v.baseElev)
|| !std::isfinite(v.built) || !std::isfinite(v.timer)
|| !std::isfinite(v.ashTimer) || !std::isfinite(v.ashCarry)) historyOk = false;
if (historyOk) wxUndo.push_back(std::move(f));
}
if (!historyOk) { wxUndo.clear(); skippedHistory = true; }
}
events.clear(); nextEventId = 1; liveInfoTab = 0; eventRowRects.clear(); eventRowIndices.clear();
if (ver >= 16) {
bool eventsOk = true;
auto rS = [&](std::string& s) {
uint64_t m = 0; is.read((char*)&m, 8);
if (!is || m > 4096) { eventsOk = false; s.clear(); return; }
s.assign((size_t)m, '\0');
if (m) is.read(&s[0], (std::streamsize)m);
if (!is) eventsOk = false;
};
uint32_t en = 0;
is.read((char*)&nextEventId, 4);
is.read((char*)&en, 4);
if (!is || en > (uint32_t)EVENT_LOG_MAX) eventsOk = false;
for (uint32_t k = 0; k < en && is; ++k) {
WorldEvent e;
is.read((char*)&e.id, 4);
is.read((char*)&e.kind, 1);
is.read((char*)&e.severity, 1);
is.read((char*)&e.timeHours, 8);
is.read((char*)&e.cell, 4);
is.read((char*)&e.sourceId, 4);
rS(e.title); rS(e.detail);
if (e.cell < 0 || e.cell >= (int)planet.cells.size()
|| !std::isfinite(e.timeHours) || e.kind == 0 || e.kind > 32 || e.severity > 3)
eventsOk = false;
if (eventsOk) events.push_back(std::move(e));
}
if (!eventsOk) { events.clear(); nextEventId = 1; skippedHistory = true; }
}
paused = true; selectedCell = -1; subgrids.clear();
// Pre-v14 save already in Live World: it has no volcano block, so place a set now (v14+ saves
// restore their own). A non-live save places them when the user first presses W.
if (liveWorld && planet.volcanoes.empty()) planet.placeVolcanoes(liveTime);
buildBorders(planet, borderR, borders, ridgeBorders);
buildDriftArrows(planet, driftR, driftArrows, plateLabels);
buildMap2D(planet, mapRect, map2D);
refreshView();
setStatus(skippedHistory ? std::string("Loaded ") + path + " (history skipped)"
: std::string("Loaded ") + path);
}
// Advance the simulation this frame: Phase-1 forming (paced ticks toward
// equilibrium), or Phase-2 drift / Phase-3 drift+hydrology at a finer dt.
void Viewer::stepSim() {
if (liveWorld) {
// --- Live World: advance the slow clock; geology is frozen --------
double dtH = (!paused) ? liveRate * GetFrameTime() : 0.0; // simulated hours this frame
if (dtH > 0.0 && (wxUndo.empty() || liveTime - wxUndo.back().t >= liveRate - 1e-9))
wxPushSnapshot(); // throttled history during a continuous run (~1 snapshot/sec)
liveAdvance(dtH, dtH);
return;
}
if (!paused && !settled) {
// --- Phase 1: forming, paced ticks toward equilibrium -------------
formAccum += GetFrameTime() * formRate;
int budget = 0;
while (formAccum >= 1.0 && budget < 2000) {
stepOnce(); formAccum -= 1.0; ++budget;
if (settled) break;
}
if (settled) { dtMy = planet.cflDtMy(); planet.drifting = true; } // entering Phase 2
refreshView(); // live update so you watch the terrain rise
} else if (!paused && settled) {
// --- Phase 2 drift (and Phase 3 = drift + hydrology at a finer dt) --
// Drift never stops; Phase 3 just uses a smaller timestep so each step
// advances fewer My (more steps before plates visibly move) while
// rivers/lakes/fluvial erosion resolve.
double dt = planet.cflDtMy() * (phase3 ? planet.cfg.phase3DtScale : 1.0);
dtMy = dt;
driftAccum += driftRate * GetFrameTime(); // accumulate across frames
const int guardMax = phase3 ? 60 : 500; // Phase-3 ticks are heavier
int guard = 0; bool advanced = false;
while (driftAccum >= dt && guard < guardMax) {
planet.advect(dt); planet.step(); planet.erode(dt);
if (phase3) planet.hydrology(dt);
elapsedMy += dt; driftAccum -= dt; ++guard; advanced = true;
// Timed Phase-3 invitation: pause + prompt once we cross the mark.
if (!phase3 && elapsedMy >= phase3PromptAt) { phase3Prompt = true; paused = true; break; }
}
if (driftAccum > 2.0 * dt) driftAccum = 2.0 * dt; // drop backlog (don't runaway)
if (advanced) refreshView(); // live: watch the world evolve
}
}
// Advance the Live World clock by dtClock hours and recompute the derived fields. Weather is an
// integrated, non-reversible path, so it advances by dtWeather (0 = hold, used for a backward
// step which still rewinds the deterministic sky: day/night, tides, seasons, moon phases).
void Viewer::liveAdvance(double dtClock, double dtWeather) {
liveTime = std::max(0.0, liveTime + dtClock);
double days = liveTime / planet.cfg.dayLengthHours;
double dayOfYear01 = days / planet.cfg.yearLengthDays; dayOfYear01 -= std::floor(dayOfYear01);
double timeOfDay01 = days - std::floor(days);
planet.computeInsolation(dayOfYear01, timeOfDay01);
planet.computeLiveSeason(dayOfYear01);
planet.computeTides(dayOfYear01, timeOfDay01, days);
Vec3 s = planet.sunDirection(dayOfYear01, timeOfDay01);
sunDir = Vector3{ (float)s.x, (float)s.y, (float)s.z };
moonDirs.clear(); moonNormals.clear();
for (int m = 0; m < (int)planet.getMoons().size(); ++m) {
Vec3 md = planet.moonDirection(m, timeOfDay01, days);
Vec3 mn = planet.moonOrbitNormal(m, timeOfDay01);
moonDirs.push_back(Vector3{ (float)md.x, (float)md.y, (float)md.z });
moonNormals.push_back(Vector3{ (float)mn.x, (float)mn.y, (float)mn.z });
}
std::vector<WeatherSystem> beforeStorms;
std::vector<Volcano> beforeVolcanoes;
if (dtWeather > 0.0) {
beforeStorms = planet.storms();
beforeVolcanoes = planet.volcanoes;
}
planet.stepWeather(dtWeather);
// Volcanoes are stateful lifecycle agents; step-back restores their snapshot, then dt=0 here
// reasserts restored terrain/biome state without advancing the lifecycle.
VolcanoUpdate vu = planet.stepVolcanoes(dtWeather);
if (dtWeather > 0.0) detectLiveEvents(beforeStorms, beforeVolcanoes);
if (vu.breach) refreshView();
else if (vu.recolor) recolor();
rebuildLiveOverlay();
}
// Push the current (pre-advance) weather state onto the bounded step-back ring.
void Viewer::wxPushSnapshot() {
if ((int)wxUndo.size() >= wxUndoMax) wxUndo.erase(wxUndo.begin());
wxUndo.push_back(WxFrame{ liveTime, planet.captureWeather() });
}
// Step the live clock forward one rate-unit. Auto-pauses (like a video frame-step); always records
// the pre-step snapshot first (rate-independent) so the backward step restores weather + storms.
void Viewer::liveStepForward() {
paused = true;
wxPushSnapshot();
liveAdvance(liveRate, liveRate);
}
// Step everything back: restore the newest snapshot at or before the current time (clock +
// weather + storms) -- so storms reverse whether they were born while stepping or during a run. If
// the history is exhausted, fall back to rewinding the deterministic sky only.
void Viewer::liveStepBack() {
paused = true;
while (!wxUndo.empty() && wxUndo.back().t > liveTime + 1e-6) wxUndo.pop_back(); // drop only true future frames
if (!wxUndo.empty()) {
WxFrame f = wxUndo.back(); wxUndo.pop_back();
liveTime = f.t;
planet.restoreWeather(f.w);
liveAdvance(0.0, 0.0); // recompute the sky/overlay at the restored time (weather held)
setStatus("Step back");
} else {
liveAdvance(-liveRate, 0.0); // no recorded past (e.g. right after a load): sky rewinds, weather holds
setStatus("Step back (sky only - no earlier weather; play/step forward first)");
}
}
// The 2D map's projection rect after zoom/pan: mapRect scaled about its centre by mapZoom and
// shifted by the screen-space pan. The scissor + frame stay the real mapRect, so it clips cleanly.
Rectangle Viewer::mapViewRect() const {
float w = (float)(mapRect.width * mapZoom), h = (float)(mapRect.height * mapZoom);
float x = mapRect.x + (mapRect.width - w) * 0.5f + (float)mapPanX;
float y = mapRect.y + (mapRect.height - h) * 0.5f + (float)mapPanY;
return Rectangle{ x, y, w, h };
}
void Viewer::run() {
while (!WindowShouldClose()) {
handleInput();
stepSim();
// A regenerate this frame may have shrunk the planet; keep indices valid.
if (hovered >= (int)planet.cells.size()) hovered = -1;
renderFrame();
}
UnloadRenderTexture(rt3d);
CloseWindow();
}
Reference in New Issue View Git Blame Copy Permalink