ROTP Ships and Combat

01Hulls

Four sizes, each roughly five times the space and six times the cost of the one below.

Space and cost scale in step, so a huge hull is not intrinsically more efficient than a small one on those axes. What actually differentiates them is the missile defense modifier, which runs from +2 on a small hull to −1 on a huge one and feeds directly into both missile defense and manoeuvrability — and therefore into initiative.

Small ships are harder to hit and act first. That is the entire case for swarms, and it is why the game does not need an explicit counter-system: capital ships are simply worse at the two things that decide who shoots whom.

Construction research adds 2% space per category level, multiplicatively with a racial factor, floored at 90% of base. Hull points are separately scaled by the racial hit-point factor before armour multiplies them.

02Slots and space accounting

Six fixed slots, four weapon banks, three specials — and engines you never choose the count of.

Engines are derived, not chosen

public float enginesRequired(ShipDesign d) {
    float req = power(d);                    // this component's power draw
    float pow = d.engine().powerOutput();    // baseWarp * 10
    return req/pow;
}

// and every component carries its own share of the engine volume:
space(d) = ceil( size(d) + enginesRequired(d) * engine.size(d) )

You pick the engine type; the count falls out of total power draw divided by that engine's output. This is the most elegant thing in the design system, because it makes every component cost space twice — once for its own volume, once for the engines needed to push it. A power-hungry weapon on a low-warp engine can consume more hull in engines than in itself.

It also makes engine research quietly compounding. Warp 1 delivers 1 power per unit of engine space; warp 9 delivers 1.8. Upgrading engines does not just make ships faster — it frees hull across the entire design.

An over-full design is not rejected — it simply costs one extra BC per unit of overflow. The interface and AI gate on validity separately, and the "shrink to smallest hull that fits" helper walks small through huge and silently leaves the design over-full if nothing works.

03Components

Six families, each a simple ladder, each miniaturising as its category advances.

Special devices

Three slots, drawn from a long list and de-duplicated by family so you cannot stack two of the same kind. The ones that change how combat works rather than adding a number:

04Weapons

Five families with genuinely different roles, distinguished by how they meet shields.

The three parameters that make beams interesting are shield piercing (some multiply the target's shield by a fraction), streaming (overkill damage carries into the next ship in the stack), and heavy mounts, which triple cost, size and power in exchange for roughly double damage and range 2.

05Six design slots, forever

The sharpest constraint in the game, and the most under-appreciated.

An empire holds exactly six ship designs. Five of them carry role pointers — scout, colony ship, fighter, bomber, destroyer — leaving one free slot at game start. A new design must displace an existing one.

This is what forces doctrine. You cannot maintain a museum of specialised hulls, so each of the six slots must earn its place against everything you might meet. It also gives obsolescence real consequences — a design marked obsolete carries a countdown, and the AI has to weigh replacing it against losing the hulls already flying.

And it is why miniaturisation matters so much. Because progress re-prices your existing designs rather than invalidating them, a good design stays viable for a long time. The six-slot limit and retroactive progress are two halves of the same idea: commit to a doctrine, and let research make it cheaper rather than obsolete.

06The battlefield

A ten-by-eight grid, king-move distance, and stacks rather than ships.

Combat is tactical and gridded: 10 columns by 8 rows, with distance measured as Chebyshev — the larger of the horizontal and vertical gaps, so diagonals are free. Movement cost and weapon range both use it.

A stack is every ship of one design in one fleet, acting as a single unit. The stack has a ship count, a per-ship hull value, and the current ship's remaining hull. Damage chews through one ship at a time: when hull reaches zero the count drops by one and hull resets. Since an empire has six designs, it brings at most six ship stacks plus possibly a colony — which is exactly the seven starting positions the game defines.

Stacks deploy into the leftmost and rightmost columns, filling from the middle rows outward. An asteroid belt may sit between them, blocking movement and — under the MOO1 rules option — acting as roughly three points of extra shielding per asteroid crossed by a beam.

07Turn structure

Initiative order, free interleaving of move and fire, and one hidden extra action.

initiative = computerLevel + specialInitiativeBonuses
           + manoeuvrability + empireShipInitiativeBonus

// but the ORDER uses a different number:
if (cloaked)                        rank = 200 + initiative;
else if (hasTeleporting && !interdicted) rank = 100 + initiative;
else                                rank = initiative;

Cloaked stacks always act first, then teleporters, then everyone by raw initiative. Since manoeuvrability includes the hull's missile-defense modifier, small ships with good computers systematically win initiative — the same property that makes them hard to hit.

On its turn a stack may move and fire in any order, repeatedly, until it has neither movement nor a weapon that can fire. Beams dump every remaining shot in one action — every ship in the stack, every bank, every attack per round, resolved at once. Combat runs to a limit of 100 rounds by default, 50 under the MOO1 preset.

08To-hit and damage

One curve for every weapon in the game.

public float hitPct(float dLevel) { return bounds(.05f, (5 + dLevel)/10, 1); }

50% at parity, ten percentage points per level of advantage, floored at 5% and capped at 100%. That is the whole model. What differs between weapon families is only what goes into dLevel:

The beam range penalty is the only positional modifier in the game: point blank is free, and every extra square costs ten percentage points of accuracy. Missiles and bombs have no equivalent. That one asymmetry is what makes beams a close-range weapon and missiles a standoff weapon, without either being named as such.

Damage is rolled per shot, uniformly between the weapon's minimum and maximum. Under the MOO1 resolution option, accuracy above 100% is not wasted — it raises the minimum damage toward the maximum instead, so an overwhelming computer advantage translates into reliability rather than being clipped.

09Shields

Flat subtraction, per shot — and the whole counter-system falls out of it.

float ensuingShield = shieldLevel() * shieldAdj;
if (moo1ShieldRules) ensuingShield = (int) ensuingShield;
float dmg = max(0, damage - ensuingShield);

Shields subtract a flat value from each individual shot, not from the salvo total. A twenty-shot volley of one-to-four damage weapons against shield 4 does exactly nothing at all.

Note what escapes it. Bioweapons ignore shields entirely. Black hole generators kill a percentage of a stack and are resisted at only two points per shield level, making them size-blind and by some margin the most cost-effective anti-capital weapon in the game. Stream projectors permanently shrink the target's hull ceiling. Stasis fields simply remove a stack from the battle.

The MOO1 shield rules option truncates the effective shield to an integer, which matters only against shield-piercing weapons — a halving beam against shield 5 faces 2.5 in ROTP and 2 under MOO1.

10Missiles as stacks

Launched objects that pursue across the board on their target's turn.

A missile salvo is a real stack on the grid, but deliberately kept out of the initiative list. Instead it moves during its target's turn, pursuing in small steps as the target moves, at a rate proportional to the missile's speed divided by the target's. A missile faster than its target closes the gap no matter how the target runs.

Three ways a salvo fails to land:

• Interception — a single roll for the entire salvo at the moment of impact, against the best missile shield in the target stack. Newer missiles are harder to block.
• Displacement devices — an identical all-or-nothing roll one step earlier.
• Running out of life — ten rounds, or the salvo's range, which is doubled for colony-launched missiles.

Missiles in flight also keep the battle alive: combat cannot end while a salvo is still travelling toward a living target. That is a small rule with a real consequence — you cannot disengage from a missile volley by winning the ship fight.

11Retreat and how combat ends

The MOO1 one-turn delay, and two exits.

Retreating

A stack may retreat unless it is at its owner's last colony, or a warp dissipator has reduced its manoeuvrability to zero. Under the MOO1 rules option, ordering a retreat does not remove the stack: it announces, burns the rest of its turn, and stays on the board and shootable for a full round before leaving at the start of its next turn.

That delay is the difference between a fighting withdrawal and a free escape, and it is what makes committing to an engagement a real decision rather than a reversible one.

Retreating fleets go to a system the empire is allowed to retreat to — which must be within ship range, so an overextended fleet can be genuinely trapped. If a battle is won, the victor's own retreat orders are cancelled: winners do not run.

Ending

Combat ends in exactly two ways:

1. No conflict remains — no two mutually hostile stacks where at least one is armed, and no missiles still in flight.
2. The turn limit expires — at which point the attacker is expelled unconditionally, with no eligibility check.

Results feed straight back into diplomacy. The battle records hull points destroyed on each side, population and factories lost, and whether bioweapons were used — then writes those into the treaty's war-weariness tracking and files the corresponding incidents: skirmish, colony attacked, colony destroyed, attacked-ally and attacked-enemy.

12Planets in combat

The colony is a stack whose ship count is its missile bases.

A colony fights as an immovable stack. Its "ship count" is the number of active missile bases and its per-ship hull is a base's hit points, so destroying bases is literally destroying ships in the stack. With no bases at all it has no defensive statistics whatsoever and simply absorbs bombardment.

Bases fire once per round, three missiles per base, in a single enormous salvo. Their range is generous and measured oddly — on the horizontal axis only, at double range — so a planet effectively covers the whole board vertically.

Planetary shielding is two numbers. While bases live, the colony's shield includes the deflector component; once they are gone it drops to the planetary shield alone. Killing the bases weakens the planet's shield as well as its guns.

Beams and torpedoes do half damage to colonies; missiles always do maximum damage. After the tactical battle, surviving fleets may bombard in a separate un-gridded phase, each weapon firing its bombardment allotment — ten shots for beams and bombs, five for bioweapons.

13The tactical AI

Target scoring, kiting, and a genuinely thoughtful retreat calculation.

Targets are scored as killChance × stackSize × targetValue × rangeAdjustment, where target value is design cost for ships and population-plus-factories for colonies — so bombers naturally rate colonies by expected population loss rather than by hull damage.

Three refinements stand out as good design:

• It avoids overkill. If missiles already in flight will destroy a stack, that stack's desirability drops by the amount those missiles will already accomplish.
• It refuses repulsor traps. A stack whose maximum firing range is inside an enemy's repulsor bubble gets a hard negative score — the AI will not walk somewhere it cannot shoot from.
• It re-targets between banks. After every weapon fires, the AI re-picks a target, so a stack naturally splits its fire across enemies as they die.

Kiting engages when the stack has missiles, out-ranges its target, has repulsors, or is simply faster — and switches off against a self-repairing enemy, where stalling achieves nothing.

The retreat decision compares how long we need to kill them against how long they need to kill us, summed across stacks and adjusted for self-repair. It has some genuinely careful touches: it mentally de-cloaks enemies for estimation, gives bombers their own timeline and stays if they will finish the colony before dying, and assumes the worst case on incoming missile damage because, as the comment puts it, you have to.

14Quirks worth knowing

Dead code, inert options and one genuinely confused loop.

• The risk map is never read. A grid of tactical risk values is allocated and recomputed on every single stack's turn, and the function that reads it returns a hard zero. Nothing in the codebase consults it. Its fill loop also misses the last row.
• Torpedo damage routes through the missile path. The torpedo-specific damage handler is commented out, so a torpedo does full damage to a colony while the AI's own estimator assumes half.
• The AI's standoff calculation compares its own stacks against each other. Both filters in the loop keep the same empire, and the range condition is inverted — so the first-strike flag it produces is effectively always on, running the positioning logic on garbage.
• The AI's kill estimator uses a different to-hit formula than the weapons do — it omits the weapon's built-in computer bonus and the beam range penalty, so it systematically overestimates long-range beam effectiveness.
• Decloaking does not re-sort initiative. The initiative rank is memoised and only invalidated when initiative itself changes, so a stack that uncloaks to fire keeps its highest-priority rank for the rest of the round.
• Missile distance-decay is inert. The per-distance damage loss returns zero for every real missile; only one torpedo tech sets it. The self-destruct clause that depends on it never fires.
• Energy pulsars hit friendly ships. The area effect scans the surrounding squares for any ship stack other than the source, with no ownership check.
• A "heavy mount range" constant is never assigned. Every heavy mount has range exactly 2 regardless of the base weapon it is mounted from.