Random events, and the things that live between the stars

01What random events are for

Not variety. Rubber-banding, and a reason to hold cash.

Random events in a 4X are usually justified as "flavour" — a bit of texture so no two games feel identical. ROTP's implementation is doing something more specific, and the giveaway is one default-on option called eventsFavorWeak. Bad events are aimed by industrial power at the strongest empire. Good events are aimed by inverse power at the weakest. The event system is a rubber band, and it says so in the source.

The second job is subtler. Two of the worst events — plague and supernova — are not damage. They are bills, payable in banked reserve BC, and the colony dies if you can't cover them. Two more, piracy and comet, are health bars that only armed ships parked in orbit can chew through. Between them, four of the twenty events convert "I keep no reserve and no home fleet" from a mild inefficiency into a real risk. That is the entire mechanical argument for keeping a treasury in a game whose economy otherwise rewards spending every credit.

Everything else in the roster is a one-shot nudge: a planet gets richer or poorer, a research pool is wiped, a colony revolts, someone finds a derelict full of technology.

02The rising clock

One roll per turn, against a probability that grows until something happens.

There is no per-event probability table. There is a single accumulator on the galaxy:

private static final float START_CHANCE    = 0.0f;
private static final float CHANCE_INCR    = 0.01f;
private static final float MAX_CHANCE_INCR = 0.05f;

// ... each turn, inside nextTurn():
eventChance = min(maxChanceIncr(), eventChance + chanceIncr());
if (turnRnd() > eventChance)
    return;
...
RandomEvent triggeredEvent = listRnd(subList);
eventChance = START_CHANCE; // Reset the probability counter

So the per-turn chance climbs 1% → 2% → 3% → 4% → 5%, then holds at 5% until something fires, at which point it drops back to zero and starts climbing again. Both the increment and the ceiling are multiplied by the eventsPace option, which runs 20%–500% around a default of 100%.

Integrating that sequence gives a mean gap of about 22 turns between events at default pace — but the distribution is deliberately lopsided. There is only a 14% chance of an event in the first five turns after one fires, and a 60% chance within twenty. Back-to-back disasters are structurally impossible; a decade of total quiet is unlikely.

The two turn gates

The difficulty multiplier is the quiet one. On the easy settings every event that carries a delay is pushed out two to four times as far — which matters almost entirely for the monsters, whose delays are 100, 100 and 25 turns.

03Who gets hit

Power-weighted roulette, in both directions.

Once an event is chosen, an empire is chosen for it. With eventsFavorWeak on — the default — the two selectors are mirror images:

// empireForBadEvent(): chance based on power for each empire
float power = emp.extinct() ? 0 : emp.industrialPowerLevel(emp);
vals[i] = power;
total += power;
// ... roulette wheel over vals[]

// empireForGoodEvent(): chance based on 1/power for each empire
float power = emp.extinct() ? 0 : emp.industrialPowerLevel(emp);
if (power > 0)
    power = 1/power;
vals[i] = power;

The weighting is on industrial power, not fleet strength or territory — so the empire the events punish is the one with the most factories, which in ROTP is very nearly always the empire that is winning. Turn the option off and the target is simply uniform over living empires.

04The wasted roll

The event is picked before anyone checks whether it can happen.

The selection is uniform and unweighted over an eligible sublist — every event that isn't disabled, isn't too early, wasn't the last one to fire, and isn't already running:

private boolean isValidEvent(RandomEvent event) {
    if (!opts.allowRandomEvent(event))              return false;   // option gate
    if (galaxy().currentTurn() < event.minimumTurn()) return false; // too early
    if (allowConcurrence(event))                    return true;    // multi-monster
    if (event == lastEvent)                         return false;   // no repeats in a row
    ...
    for (RandomEvent ev: activeEvents)
        if (event == ev)                            return false;   // already running
    return true;
}

What that list does not check is whether the event has anywhere to land. There is no canTriggerFor(Empire) in the interface. The event is chosen, the accumulator is reset to zero, the empire is chosen, and only then does trigger(Empire) scan for a suitable colony — and quietly return if it finds none.

The eligibility filters are not trivial, either. Earthquake, plague and supernova all need a colony of at least 30 population. Plague and supernova additionally need one with no research project already running. Assassination needs a contacted, non-hostile empire inside economic range. Piracy needs an active trade agreement. Early in the game — right at turn 50, when the global gate lifts — a large fraction of picks find nothing.

05All twenty events

Registration order. Every one is equally likely when eligible.

06Disasters with an invoice

Plague and supernova aren't damage — they're a bill, denominated in production.

Both implement ColonyResearchProject: they attach themselves to the afflicted colony's research slot, which is why neither can land on a colony that already has a project running. You clear them by paying, and the price is a multiple of what the colony earns:

The two are deliberately different problems. The supernova is a countdown with a known price and a known deadline — it is a budgeting decision, and a cheap enough colony is worth deliberately abandoning. The plague has no deadline, so it looks survivable, and isn't:

If a plagued or supernova-bound colony changes hands mid-event, the project transfers with it and researchRemaining is reset to the full amount for the new owner. Invading a plague world buys you the whole bill from scratch.

07Disasters with a health bar

Piracy and comet are killed by parked warships, and by nothing else.

Both events carry hit points and both use the identical damage function — the only place in ROTP where a fleet's composition matters without a battle happening:

for (int i = 0; i < ShipDesignLab.MAX_DESIGNS; i++) {
    if (fl.num(i) > 0) {
        int size = fl.design(i).size();
        float weight = pow(5, size);
        dmgInflicted += (fl.num(i) * weight);
    }
}
pirateHP = max(0, pirateHP - dmgInflicted);

Hull size is a zero-based index, so the per-ship contribution is 1 / 5 / 25 / 125 for Small / Medium / Large / Huge. Weapons, armour and tech level are irrelevant; only tonnage counts. Only armed fleets belonging to the afflicted empire or its allies contribute, and they must be in orbit.

Two details are easy to miss. First, piracy's penalty is empire-wide — it is applied as tradePiracyRate on the empire, not on the raided colony, so a single pirate incursion taxes every trade agreement you hold. Second, the rate falls as you damage them: chipping the pirates from 450 HP to 200 drops the trade loss from 90% to 40% without killing them, so partial progress pays immediately.

The comet is all-or-nothing in the other direction. Nothing happens for 10–15 turns, and then sufferImpactEvent destroys the colony and downgrades the planet to Barren. There is no partial impact.

08The windfalls

Five gifts, one of which quietly rewrites the map.

The small ones are small: a donation of turn × 10 credits, a planet upgraded to Rich, soil enriched from Normal to Fertile. Two are large enough to change a game.

Boost Planet Size adds a flat +50 base size to any colony under 50 — which is to say it can triple a marginal world. Given that base size is the ceiling on population and population is the council vote, this is the most valuable single-colony event in the roster.

Precursor Relic is galaxy-scale. It walks every star system in the galaxy and converts every asteroid field into a real, colonisable planet:

for (StarSystem sys : galaxy().starSystems())
    if (sys.planet().type().isAsteroids())
        systems.add(sys);

if (!systems.isEmpty()) {
    float richArtifactProb = 0.02f;
    for (StarSystem sys : systems) {
        do { sys.planet(PlanetFactory.createPlanet(sys, session().populationBonus())); }
        while (sys.hasAsteroid());
        sys.addEvent(new SystemRandomEvent("SYSEVENT_PRECURSOR_RELIC"));
        if (rng().nextFloat() < richArtifactProb) {
            richArtifactProb = 0;
            sys.planet().setArtifact();
            if (rng().nextBoolean()) sys.planet().setResourceUltraRich();
            else                     sys.planet().setResourceRich();
        }
    }
}

Every dead rock in the galaxy becomes settleable at once, and exactly one of them (2% per system until it hits, then the probability is zeroed) becomes an Antaran-ruins artifact world with Rich or Ultra-Rich resources. The nominated empire also gets 5 free Construction techs — but the map change benefits everyone, and disproportionately whoever has the range and the colony ships to reach the new worlds first. It is a "good" event that hands the leader a bigger prize than its intended beneficiary.

Ancient Derelict grants up to 10 free technologies — nominally split between the Force Field and Weapon trees, though see §15 for why the weapons half doesn't work.

09The Gauntlet Relic

Classified as a good event. Halves the population of every colony in the galaxy.

@Override public boolean goodEvent() { return true; } // classify as positive event, has galactic effects

@Override public void trigger(Empire emp) {
    // step through all colonized systems
    // cut population on all colonies in half
    for (Empire e: galaxy().empires()) {
        for (StarSystem sys: e.allColonizedSystems()) {
            sys.planet().colony().setPopulation( 0.5f * sys.population() );
        }
    }
    ...
    // then, for the chosen empire only:
    for (StarSystem sys : emp.allColonizedSystems()) {
        Planet pl = sys.planet();
        if (pl.baseSize() <= 90.0f)
            pl.baseSize(pl.baseSize() + 10.0f);
    }
    // ... plus 5 free Planetology techs

This is the single most violent thing in the file. It halves the population of every colony of every empire, including the beneficiary's, and then hands one empire +10 base size on its smaller worlds and five free Planetology techs.

Two consequences follow from that goodEvent() flag. First, the beneficiary is chosen by the 1/power selector — so the free techs and the size increases go to the weakest empire while the population tax lands on everybody. Second, because the tax is proportional, the empire with the most population loses the most in absolute terms. It is the hardest rubber-band snap in the game, and it is delivered under the label "positive event."

Note also that the population halving runs before the null/extinct check on the beneficiary. Even a degenerate target can't stop the galaxy from taking the hit.

10Assassination — the only diplomatic event

The empire the event targets is the one that gets blamed.

Nineteen of the twenty events touch colonies, planets, tech or money. Exactly one reaches into the diplomacy ledger, and it does so from an unexpected direction:

if (galaxy().council().finalWar()) return;

for (Empire e: emp.contactedEmpires())
    if (!emp.atWarWith(e.id) && emp.inEconomicRange(e.id))
        emps.add(e);
if (emps.isEmpty()) return;

Empire assassin = emp;              // the "targeted" empire
Empire victim   = random(emps);
...
AssassinationIncident.create(assassin, victim);

The empire selected by the bad-event roulette is the assassin, not the victim. Since the bad-event selector aims at the strongest empire, the effect is to take whoever is winning and frame them for murdering a random peaceful neighbour who is close enough to trade with.

The incident is severe and immediate: −50 severity for 20 turns against the assassin in the victim's ledger, the ambassador recalled, and both triggersWar() and triggersImmediateWar() true — so this doesn't degrade relations, it declares a war. Every empire already at war with the victim gets a +50 / 10-turn praise incident toward the assassin and an opened embassy, so the leader is simultaneously handed a new enemy and a set of new friends among that enemy's enemies.

It is the cleanest expression of the whole system's intent: the game notices you are ahead, and manufactures a coalition problem.

11Monsters are off by default

Which is worth knowing before reading anything else about them.

The random-events setting has five values, and the shipped default is not "on":

public boolean allowRandomEvent(RandomEvent ev) {
    switch(selectedRandomEventOption()) {
        case RANDOM_EVENTS_ON:            return true;
        case RANDOM_EVENTS_OFF:           return false;
        case RANDOM_EVENTS_NO_MONSTERS:   return !ev.monsterEvent();   // ← default
        case RANDOM_EVENTS_TECH_MONSTERS: return ev.techDiscovered();
        case RANDOM_EVENTS_ONLY_MONSTERS: return ev.monsterEvent() && ev.techDiscovered();
    }
}

Under the default, the Amoeba, Crystal and Pirates never spawn at all. The two "tech" modes gate them behind a research trigger instead — Cloning:1 for the Amoeba, Stargate:0 for the Crystal, EngineWarp:8 for the Pirates — and the empire that researches the trigger tech becomes the monster's first target. That is a genuinely elegant coupling: it turns three specific technologies into a decision rather than a free upgrade, and it makes the tech leader the one who pays for being the tech leader.

Alongside the three roamers there are five stationary guardians (Guardian Amoeba, Guardian Crystal, Guardian Pirates, Space Jellyfish, Space Cuttlefish) that can be seeded onto planets at galaxy generation, with a probability scaling off planet size. That option's default is None, so outside Orion the galaxy generates without them too.

12The three roamers

A wandering monster is not a battle. It is a battle you have to choose to have.

Once loose, a monster picks a colonised system inside a ring 0–8 light years out, travels there over several turns with 2–5 turns of GNN warning, and arrives. The targeting is weighted against repetition:

protected float baseChance(StarSystem sys) {
    return monster.vistedSystems().contains(sys.id) ? 0.05f : 0.25f;
}
protected float systemChance(StarSystem s) { return s.isColonized() ? baseChance(s) : 0; }

25% for a fresh colonised system, 5% for a revisit, and uncolonised systems are never chosen. It hunts people, not space.

Arrival is the interesting part:

monster.visitSystem(targetSysId);
monster.initCombat();
Colony col = targetSystem.colony();
if (!targetSystem.orbitingFleets().isEmpty())
    startCombat();
else if ((col != null) && col.defense().isArmed())
    startCombat();

if (monster.alive()) {
    degradePlanet(targetSystem);
    ...moveToNextSystem();
}

An undefended colony gets no battle at all. If nothing is in orbit and the colony has no armed defence, the monster simply applies its damage and moves on. The fight is opt-in, and opting in is the only way to ever stop it — with the default max-systems setting of 0, a monster never dies of old age and roams indefinitely.

The Amoeba's damage cap deserves a note, because it inverts normal combat logic. Alpha-striking it is wasted — anything over 500 in a bucket is discarded, and the surplus you did land triggers mitosis into two independent stacks next turn. The correct answer is many small, sustained hits, which is the exact opposite of the flat-shield arithmetic that governs every other fight in the game.

13Orion

The best planet in the galaxy, behind the hardest fight in the galaxy.

Orion isn't a random event — it is placed deterministically at galaxy generation, first among the unsettled systems, at coordinate index 0 of the galaxy shape. Its planet is built by a dedicated factory:

public static Planet createOrion(StarSystem sys, float bonus) {
    Planet p = instance.options().orionPlanet(sys);   // always Terran
    p.setOrionArtifact();                              // Orion ruins: 3 bonus techs
    p.makeEnvironmentFertile();
    p.baseSize(creationSizeMax() * bonus);             // default max: 120
    return p;
}

Terran, fertile, base size 120, Orion ruins worth 3 bonus technologies at minimum level 20, and a ×4 research multiplier on anything built there. Then the council bonus on top:

public float orionCouncilBonus() {
    if (galaxy().orionSystem().empire() == this) return .2f;
    return 0;
}

Note the condition: owning Orion, not killing its guardian. The +0.2 to every AI's vote calculation, and the automatic loyalty rule that makes any AI accept an Orion-holder's council election, both follow the deed rather than the kill.

The Guardian

Plus a Zyro shield, High Energy Focus, Advanced Damage Control, and immunity to stasis. Its combat stack overrides reloadWeapons() to grant exactly one shot per weapon slot per turn — which is why the source carries the comment "do not change this sequence" above the weapon assignments. The slot order is the firing priority, and it steps down from missiles at range 9 to torpedoes at range 10 to everything else at range 3.

The reward is fixed and guaranteed: ShipWeapon:16 — the Death Ray, learned outright, plus a KillGuardianIncident at severity 100 for 50 years broadcast to every empire that knows you. Killing the Guardian is simultaneously the best weapon in the game, the best planet in the game, a permanent council advantage, and the largest single positive diplomatic event available. It is the one place where ROTP puts everything behind a single door.

14Why this design works

Three properties, one of which is doing most of the work.

The accumulator beats a flat probability

A fixed 4%-per-turn chance would produce clusters — two disasters in three turns, then sixty quiet ones. The rising counter guarantees a gap after every event and guarantees pressure during a long quiet stretch. It is a memoryless system made non-memoryless for exactly the reason that makes games feel fair, and it costs three constants.

The rubber band is honest about being a rubber band

Power-weighted targeting is usually hidden. ROTP names the option eventsFavorWeak, defaults it on, and implements it as a plain roulette wheel over industrial power. The effect is that a runaway leader faces a rising tax on being ahead — assassination framing, earthquakes on their best worlds, a computer virus in their deepest research pool — while the trailing AI accumulates gifts. In a game where a snowballing 4X economy is otherwise unstoppable, this is the only counter-pressure that exists outside the council.

Four events make the treasury matter

ROTP's colony economy rewards spending everything on factories. Plague and supernova are payable only in banked reserve; piracy and comet are payable only in warships that aren't doing anything else. Together they put a price on total optimisation, without ever adding an upkeep mechanic. That is the events system earning its place: not as flavour, but as the reason two otherwise-dominant strategies have a cost.

15Quirks, dead code, and things that look wrong

Verified against the source, not inferred.