#include "app/phase_catalog.h" namespace sots::app { const char* DriverName(Driver d) { switch (d) { case Driver::Host: return "host turn sequence (outside the two turn drivers)"; case Driver::Strategic: return "StrategyServer::ProcessTurn"; case Driver::Player: return "ServerPlayer::ProcessTurn"; case Driver::Tail: return "StrategyServer::OnAllCombatDone_Tail"; } return "?"; } const char* StatusName(PhaseStatus s) { switch (s) { case PhaseStatus::Verified: return "verified"; case PhaseStatus::Implemented: return "implemented"; case PhaseStatus::Partial: return "partial"; case PhaseStatus::Blocked: return "blocked"; case PhaseStatus::Stub: return "stub"; } return "?"; } char StatusGlyph(PhaseStatus s) { switch (s) { case PhaseStatus::Verified: return 'V'; case PhaseStatus::Implemented: return 'I'; case PhaseStatus::Partial: return 'P'; case PhaseStatus::Blocked: return 'B'; case PhaseStatus::Stub: return '.'; } return '?'; } // --------------------------------------------------------------------------------------- // StrategyServer::ProcessTurn -- 32 phases, 0..31 // --------------------------------------------------------------------------------------- namespace { // The host steps around the drivers. Two turn counters live here, not in either driver. constexpr PhaseDesc kHost[] = { {Driver::Host, 0, "H00", "BeginProcessTurn", PhaseStatus::Implemented, "advances the frame counter, which is the turn number the whole game displays; runs " "before the spine and is where the 'Begin processing turn N' line comes from"}, {Driver::Host, 1, "H03", "ScriptHookTurnBegin", PhaseStatus::Partial, "the turn's FIRST script-object event delivery, sent from inside BeginProcessTurn right " "after the frame counter. Two of the twelve script objects our saves carry react to it. " "The refugees' one-shot latch IS modelled and committed; the design instantiation behind " "the same latch is not, because nothing here allocates handles. The swarm queen's hive " "registration, prune and per-turn slip ARE modelled -- which system each hive sits on and " "that it has no queen are exact -- but the hive's target turn is drawn from the strategic " "generator here, outside both turn drivers, and that draw is not placed. See " "docs/SV-script-objects.md"}, {Driver::Host, 2, "H02", "StampTreatyTurns", PhaseStatus::Implemented, "the diplomacy ledger's 'this treaty was last in force on turn N' stamp, over every " "ORDERED pair of players that holds one, creating the entry on demand. Runs in the " "command-application step -- after the frame counter has advanced and before either " "turn driver -- so it stamps the NEW turn. It is the only writer of these fields on a " "turn with no combat and no diplomatic command"}, {Driver::Host, 3, "H01", "SaveWriterInvariants", PhaseStatus::Implemented, "the summary's turn number is the simulation's frame counter -- an identity that holds " "across every save in the corpus and belongs to the writer, not to a turn phase"}, }; constexpr PhaseDesc kStrategic[] = { {Driver::Strategic, 0, "S00", "SnapshotPreviousTurn", PhaseStatus::Partial, "bumps the modification counter and stamps PvSav from Sav on every live player -- the " "treasury's previous-turn shadow, taken before any phase of the turn can move it, which " "is what makes the tail's Sav-PvSav the turn's own net. Measured on the reference pairs: " "0 closed on turn1->turn2 (the snapshot is a no-op there, every treasury is untouched) " "and 2 closed on turn2->turn3, 0 regressed on both. It is short by exactly 11,900 on the " "one AI empire, whose queued build order is deducted before this phase and exists nowhere " "in the input file (Rung B). The REST of the shadow words are still not modelled: they " "are not all identified on the wire"}, {Driver::Strategic, 1, "S01", "SystemPrePassMoraleAndAbandon", PhaseStatus::Stub, "per-system morale event + the abandon/chaos check below the minimum chaos population"}, {Driver::Strategic, 2, "S02", "TradeManagerTurn", PhaseStatus::Stub, "ServerTradeManager::ProcessTurn -- feeds the trade slot of the budget"}, {Driver::Strategic, 3, "S03", "RegisterTradeSystems", PhaseStatus::Stub, ""}, {Driver::Strategic, 4, "S04", "RebuildAllianceMasks", PhaseStatus::Implemented, "per-player shared-vision / alliance mask, rebuilt from scratch each turn: the player's " "own bit -- its POSITION IN THE PLAYER VECTOR, not its index field -- OR the alliance's " "member mask when the player carries an alliance id. The word is not a leaf of its own; " "it reaches the wire through the tail's turn-record archive, and it agrees with the " "archived bytes on 72 of 80 player-records with the other 8 predicted"}, {Driver::Strategic, 5, "S05", "BuildShipActionTypeSets", PhaseStatus::Stub, "builds the two action-type id sets the dispatcher runs over"}, {Driver::Strategic, 6, "S06", "ShipActionsExceptType2", PhaseStatus::Stub, "the ship-action dispatcher over every action type but type 2 (colonise, build, " "terraform, mine, scrap)"}, {Driver::Strategic, 7, "S07", "NodeSpaceTravel", PhaseStatus::Stub, ""}, {Driver::Strategic, 8, "S08", "FleetMovement", PhaseStatus::Stub, "game::sim movement primitives exist and are mechanism-verified, but the fleet/waypoint " "adapter over the save's flight plans is not written"}, {Driver::Strategic, 9, "S09", "ShipActionsType2", PhaseStatus::Stub, "the action type that needs the fleet to have arrived first"}, {Driver::Strategic, 10, "S10", "ShipUpkeep", PhaseStatus::Stub, "upkeep of population carried aboard colony/slaver hulls in transit"}, {Driver::Strategic, 11, "S11", "SystemTurn", PhaseStatus::Partial, "runs game::sim ProcessColonyTurn per system and commits the parts that need neither the " "tuning table nor a carrying capacity. CIVILIAN GROWTH now runs and commits: the whole " "system's civilian delta is clamped to POPTYPE[1]+0x08 = 20,000,000, an int64 literal in " "the executable, and on both reference pairs that clamp -- not the growth curve and not " "any capacity -- is what decides the value (the uncapped delta is 7.5x it and the " "capacity headroom 25x it). The one input that is genuinely off the wire, the per-species " "civilian capacity factor, is handled by running the pass twice, once with the modelled " "capacity and once with the system's own wire-known dcs limit, and committing only when " "the two agree. Plague, resources, slaves and rebellion remain the model's input " "boundary, as does IMPERIAL growth -- it is a no-op on this corpus (the homeworld sits " "exactly at its cap) and committing it would need a capacity the corpus cannot bound " "from above. The BUILD QUEUE is " "modelled and runs (it is the only writer of the per-class built counter in the whole " "image) but has no points to spend: they come from the per-system output term. It is " "NOT what the missing destroyer waits on -- no build order exists anywhere in either " "reference save, so that order is created inside the turn by the AI"}, {Driver::Strategic, 12, "S12", "TradeSliderFinalisation", PhaseStatus::Stub, "re-normalises the per-system output rates"}, {Driver::Strategic, 13, "S13", "PlayerTurn", PhaseStatus::Partial, "runs the 12-phase player driver once per player, in save order"}, {Driver::Strategic, 14, "S14", "ProcessMissions", PhaseStatus::Stub, ""}, {Driver::Strategic, 15, "S15", "ProcessStations", PhaseStatus::Stub, ""}, {Driver::Strategic, 16, "S16", "ProcessDefenceSats", PhaseStatus::Stub, ""}, {Driver::Strategic, 17, "S17", "ShipStatCacheRefresh", PhaseStatus::Stub, "re-syncs cached per-ship stat words from the design record"}, {Driver::Strategic, 18, "S18", "ShipActionsForceValidate", PhaseStatus::Stub, "the dispatcher a third time over all action types with the force flag: validate and " "cancel whatever is left"}, {Driver::Strategic, 19, "S19", "ProcessAid", PhaseStatus::Stub, "writes savings and research points of OTHER players; an input to the budget"}, {Driver::Strategic, 20, "S20", "ProcessSpecialProjectsServer", PhaseStatus::Stub, ""}, {Driver::Strategic, 21, "S21", "ProcessSurrenders", PhaseStatus::Stub, ""}, {Driver::Strategic, 22, "S22", "AdvanceAIRebellion", PhaseStatus::Stub, "steps an in-progress AI rebellion; the rebellion object is opaque on the wire"}, {Driver::Strategic, 23, "S23", "ScriptHookTurnStart", PhaseStatus::Stub, "scripted-scenario callback pair; dead in a normal game but not proven so"}, {Driver::Strategic, 24, "S24", "SensorUpdate", PhaseStatus::Stub, "packs 2-bit per-player visibility into every system and fleet"}, {Driver::Strategic, 25, "S25", "ScriptHookPostSensor", PhaseStatus::Stub, ""}, {Driver::Strategic, 26, "S26", "RefreshPlayerViews", PhaseStatus::Stub, ""}, {Driver::Strategic, 27, "S27", "RecomputePlayerReports", PhaseStatus::Stub, ""}, {Driver::Strategic, 28, "S28", "GrantMetSpeciesTechs", PhaseStatus::Stub, "the 'you have met this race, its racial tech appears in your tree' rule -- small, pure, " "draw-free, and the cheapest unimplemented phase in this table"}, {Driver::Strategic, 29, "S29", "SystemObservedStamp", PhaseStatus::Implemented, "the system's own last-observed turn, written wherever some player can currently see " "the system and left alone everywhere else. Whole function modelled; the gate is the " "active-presence mask, which falls when the last fleet leaves"}, {Driver::Strategic, 30, "S30", "BuildTeamPartition", PhaseStatus::Stub, ""}, {Driver::Strategic, 31, "S31", "EncounterDetectionAndStatusRestore", PhaseStatus::Partial, "trade-raid generation runs first here and IS modelled: two chances per player, one word " "each, neither site inside a back edge, so the count is a bound -- it is the turn's " "dominant generator cost and it is committed under --commit-rng. Detection proper is not " "modelled and spends two further words. The player-status restore that follows it IS " "modelled -- it writes 1 -- but the value the file carries is 4, so a further writer " "between this phase and the autosave is unaccounted. Committing the 1 turned two agreeing " "leaves into disagreeing ones on the turn2->turn3 pair, so it is evaluated and reported"}, }; // --------------------------------------------------------------------------------------- // ServerPlayer::ProcessTurn -- 12 phases, 1..12 // --------------------------------------------------------------------------------------- constexpr PhaseDesc kPlayer[] = { {Driver::Player, 1, "P01", "ComputeBudget", PhaseStatus::Partial, "the formula is compared clean against the live game -- lane L5, 3,895 calls on VM146, 0 " "divergences, 0 undeclared writes -- over 5 distinct treasury states, TWO of them on the " "interest rounding boundary, and with a control build that proves the compare can see " "the boundary (the exact-decimal constants produce 1,359 divergences on the same run). " "The game fills savingsInterest with 499 at a treasury of 50,000, so G3's widened-float " "reading is now measured, not inferred; the one-money error also moves `available` and " "`researchMoney`. TWO further rule-23 constants in this same routine are corrected and " "UNVERIFIED: the research-yield factor is a widened 0.85f (needs a research money that " "is a multiple of 40,000; the run presented 9 distinct values and none is) and the three " "research modifiers are summed in single precision (needs shrm or TRM non-zero; the " "corpus has both at 0). The per-system money " "input is now modelled on the TURN path -- ComputeOutput with the system's own rate " "sliders, so the build queue, the ship-repair pass and the infrastructure -> terraform " "-> money cascade are all live, none of which is the max-income form T31 sums. What is " "still missing is upstream, not here: the repair demand of ships in orbit is taken as 0 " "(its two design fields are cached stats, nowhere on the wire; the phase now reports the " "candidate set that evidences the zero). S11's civilian growth IS committed as of G3, so " "a colony that grew this turn is priced from its post-growth population. The phase " "self-checks every run by " "running the same colonies through the projected path, which the save's own BnkEl " "states"}, {Driver::Player, 2, "P02", "ApplyNetToSavings", PhaseStatus::Partial, "saturating add of the budget net into savings, committed. EXACT for the human and for " "the independent colony on BOTH reference pairs now that S11 commits civilian growth " "and the two interest rates are the widened float literals the image holds. Still " "wrong for an AI whose research rate and target are set by its own orders during the " "turn (Rung B). The two interest rates are now verified against the running game " "(lane L5): the game pays 499 on 50,000 and 380 on 38,100, and the exact decimals pay " "500 and 381"}, {Driver::Player, 3, "P03", "RecordBudgetDerivedFields", PhaseStatus::Blocked, "trade income, savings-given-away and research-points-given-away land on the turn record " "and on two player words that are not identified on the wire"}, {Driver::Player, 4, "P04", "ProcessSpecialProjectsSpend", PhaseStatus::Stub, "special-project spend; the project bodies are opaque on the wire"}, {Driver::Player, 5, "P05", "ProcessResearch", PhaseStatus::Blocked, "the research slice is verified end to end (35 live calls, 0 divergences) and P01 now " "supplies the allocation, but the blocker has MOVED rather than cleared: the only " "corpus player that reaches this phase with a research target is the AI, and its " "research rate and target are set by its own orders during the same turn, so the " "allocation fed in would be wrong. Evaluated and reported, not committed, until AI " "order generation exists"}, {Driver::Player, 6, "P06", "ResearchRefund", PhaseStatus::Blocked, "unspent research points converted back to money at the turn's own rate; needs P05, " "which is now blocked on the AI's orders rather than on the budget"}, {Driver::Player, 7, "P07", "ClearTimedResearchAccumulators", PhaseStatus::Partial, "zeroes the three timed-research accumulators that are on the wire; two further words the " "phase also zeroes are not identified"}, {Driver::Player, 8, "P08", "DecayRebellionOutputModifier", PhaseStatus::Implemented, "rebel AI only: the output modifier walks down by 0.04f per turn, clamped to [1, 2]"}, {Driver::Player, 9, "P09", "AccumulateTimedResearchBonuses", PhaseStatus::Implemented, "the timed research-bonus vector, iterated from the LAST element down to index 0 -- the " "descending order is load-bearing because float addition is not associative"}, {Driver::Player, 10, "P10", "ConsumeResearchRollPending", PhaseStatus::Partial, "the flag/threshold test and the flag clear are implemented and committed; the draw it " "fires is counted into the RNG ledger but the generator state is only written back under " "--commit-rng, because the turn's other draws are not yet attributed"}, {Driver::Player, 11, "P11", "PostNoResearchEvent", PhaseStatus::Blocked, "posting IS wired now: the event goes into the player's own turn bucket through " "game::events, with the id sequence, the per-bucket dedup, the FLT_MAX position sentinel " "and EvAct=1. Three of the original's four inputs are computed from the wire -- no " "research target, nothing researched on this turn or later (the test that keeps the " "event off the turn a tech lands), and at least one available tech, which is what " "excludes the monster factions whose whole tree is researched. Two things keep it " "blocked and neither is the posting. First the displayed text: the engine carries only " "the EVENTSUM_/EVENTMSG_ keys, so a run without a data root resolves them to nothing and " "the phase refuses to write a record it cannot fill. Second the target: the save's " "ResTNm is the target the FILE was written with, and three of the four real players on " "the reference pair acquire one during the turn -- that is AI research selection, and " "--ai-player N stands in for it as a stated hypothesis. Measured with " "--commit-blocked=P11 --data ROOT --ai-player 1 --ai-player 2 --ai-player 3: 4 leaves " "closed on turn1->turn2 and 3 on turn2->turn3, 0 regressed. Without the roster the phase " "over-fires by three players; that run is the control and it is in docs/EV-events.md"}, {Driver::Player, 12, "P12", "PruneRaidTargets", PhaseStatus::Stub, "20-turn ageing of the raid-target list; the records are opaque on the wire"}, }; // --------------------------------------------------------------------------------------- // StrategyServer::OnAllCombatDone_Tail -- 37 phases, 0..36. // // This is the driver the autosave is written from: everything below runs AFTER combat and // BEFORE the file hits disk. Nothing here is implemented. It is listed in full because a // reimplementation that reproduces the spine exactly and stops will still diverge -- two of // these phases draw from the same generator. // --------------------------------------------------------------------------------------- constexpr PhaseDesc kTail[] = { {Driver::Tail, 0, "T00", "IncrementModCount", PhaseStatus::Implemented, "the same modification counter the spine's phase 0 bumps"}, {Driver::Tail, 1, "T01", "ValidateEncounterResultArity", PhaseStatus::Stub, ""}, {Driver::Tail, 2, "T02", "ResolveFirstContact", PhaseStatus::Stub, ""}, {Driver::Tail, 3, "T03", "AnnounceEncounterSightings", PhaseStatus::Stub, ""}, {Driver::Tail, 4, "T04", "TallyBattlesFought", PhaseStatus::Stub, ""}, {Driver::Tail, 5, "T05", "UpdateDiplomacyStatsFromCombat", PhaseStatus::Stub, ""}, {Driver::Tail, 6, "T06", "ApplyEncounterResults", PhaseStatus::Stub, "DRAWS RNG -- node-cannon and salvage paths; the word count is combat-dependent"}, {Driver::Tail, 7, "T07", "ClearEncounters", PhaseStatus::Stub, ""}, {Driver::Tail, 8, "T08", "ScriptHookCombatDone", PhaseStatus::Stub, "script-object event 8. Five of the twelve classes our saves carry override it -- von " "Neumann, refugees, traps, crow defenders, independent systems -- and NONE of them moves " "a leaf that diverges on either reference pair, so this phase is listed and not run"}, {Driver::Tail, 9, "T09", "AdvanceAIRebellionPostCombat", PhaseStatus::Stub, ""}, {Driver::Tail, 10, "T10", "NodeSpaceTravelSecondPass", PhaseStatus::Stub, "node-space travel runs a SECOND time this turn"}, {Driver::Tail, 11, "T11", "DecayNodeLines", PhaseStatus::Stub, "DRAWS RNG -- exactly one unit draw per expired node line per turn"}, {Driver::Tail, 12, "T12", "DrainColonyLossQueue", PhaseStatus::Stub, ""}, {Driver::Tail, 13, "T13", "UpdateTreasuryMorale", PhaseStatus::Stub, ""}, {Driver::Tail, 14, "T14", "UpdateForeignFleetMorale", PhaseStatus::Stub, ""}, {Driver::Tail, 15, "T15", "ProcessBankruptcy", PhaseStatus::Stub, "the decision function is modelled in game::sim; the per-player state it reads is not " "assembled here"}, {Driver::Tail, 16, "T16", "ResolveArrivedColonizers", PhaseStatus::Stub, ""}, {Driver::Tail, 17, "T17", "RebuildPlayerViewTree", PhaseStatus::Partial, "the per-(system, player) observation record IS modelled and committed -- who saw " "the system, on what turn, and what encounter was there. The colony-numbers view " "the same phase rebuilds beside it is NOT: its list is empty on both reference " "pairs, so nothing here has evidence to build it against"}, {Driver::Tail, 18, "T18", "PostFleetWarnings", PhaseStatus::Stub, ""}, {Driver::Tail, 19, "T19", "DrainInfraTerraformQueue", PhaseStatus::Stub, ""}, {Driver::Tail, 20, "T20", "ScriptHooksTurnEnd", PhaseStatus::Partial, "two script-object event deliveries, 0x14 then 0x15. The slavers-refuel difficulty tier " "IS modelled and committed: a three-record table scanned against the frame, boundaries at " "1/50/100, written only when it changes -- and at frame 100 and above the scan runs off " "the end and writes nothing, so the tier can never reach 2. The per-system pass the " "original enters after a tier change is not modelled. Event 0x15 is overridden by no " "class in any save we hold"}, {Driver::Tail, 21, "T21", "UpdateSurveyAndSystemStats", PhaseStatus::Partial, "the explored sweep IS modelled and committed: every player who can currently see a " "system has now surveyed it. The event this owes per newly-surveyed pair is not " "posted, and the derived per-system defence figure the same phase computes is not " "modelled"}, {Driver::Tail, 22, "T22", "TradeSliderFinalisationSecondPass", PhaseStatus::Stub, ""}, {Driver::Tail, 23, "T23", "TradeManagerEndOfTurnHooks", PhaseStatus::Stub, "eight vtable calls, wholly unidentified"}, {Driver::Tail, 24, "T24", "RecomputeMaintenanceAndResearchBonus", PhaseStatus::Stub, "recomputes per-player ship maintenance and research bonus and rebuilds the ship records"}, {Driver::Tail, 25, "T25", "SensorUpdateSecondPass", PhaseStatus::Stub, ""}, {Driver::Tail, 26, "T26", "ScriptHookPostSensorTail", PhaseStatus::Stub, ""}, {Driver::Tail, 27, "T27", "RefreshPlayerViewsSecondPass", PhaseStatus::Stub, ""}, {Driver::Tail, 28, "T28", "UpdateNodeLineSightingMasks", PhaseStatus::Stub, ""}, {Driver::Tail, 29, "T29", "AbortInvisibleInterceptOrders", PhaseStatus::Stub, ""}, {Driver::Tail, 30, "T30", "RebuildCommunicationMasks", PhaseStatus::Stub, ""}, {Driver::Tail, 31, "T31", "UpdateBankruptcyLimits", PhaseStatus::Partial, "BnkEl is modelled and committed; BnkPr is not. The chain is the sum over owned, " "non-abandoned systems of max(ComputeMaxIncome, 0). CORRECTION (lane PL): this phase used " "to claim it self-checked against the BnkEl the input save carries, and it did not -- it " "compared its POST-turn computation against the PRE-turn stored value, so the only " "players it could ever 'reproduce' were the six whose limit does not move, and its " "6-of-8 was thin coverage of exactly the shape rule 15 describes. The check is now taken " "at LOAD, from the colony state the save was written from, and it passes 8 of 8 on the " "reference saves and for every live player of all 11 corpus saves. That same check " "replaces the operator flag: `ServerPlayer+0xf9` (is this player AI?) is not on the wire, " "but it is worth 10% of the max income and BnkEl has a 6.67x slope, so recomputing the " "stored limit under both difficulty columns identifies which one was used -- 1 AI and 1 " "non-AI on every corpus save, the rest ambiguous because both columns agree there (zero " "income, or an NPC, whose row is gated on `isAI && !npc`). A player neither column " "reproduces abstains and keeps its pass-through leaf. Measured with NO operator input: 2 " "closed, 0 regressed on EACH reference pair. VERIFIED AGAINST THE RUNNING GAME (lane " "L5, VM146): the live `ServerPlayer+0xf9` and NPC flags, read on all eight players of " "turn1-state across 3,895 calls, are exactly what this inversion claims -- one player " "is AI-and-not-NPC, the human is neither, six are NPCs, and the awkward case (a player " "that owns a system and is still ambiguous) reads npc=true, which is the reason lane " "PL gave after its own prediction missed it. aidf (+0x368) reads 1 on all eight. What " "is left is BnkPr, which needs BANKRUPTCY_PROTECTION_LIMIT_FACTOR from the data files " "-- it is read as a 32-bit operand, so it is a float32 in the image and the engine now " "narrows it (rule 23). Its RUN-TIME VALUE is no longer an assumption either: read live " "through its pointer slot it is 3.29999995231628, i.e. (float)3.3, so the data file " "carries 3.3 and the narrowing is real. The file image of that slot is zero, so this " "is a fact only a running process could supply"}, {Driver::Tail, 32, "T32", "PostIncomingFleetWarnings", PhaseStatus::Stub, ""}, {Driver::Tail, 33, "T33", "ShipManagerEndOfTurnHooks", PhaseStatus::Stub, ""}, {Driver::Tail, 34, "T34", "RecordObservedDesigns", PhaseStatus::Stub, ""}, {Driver::Tail, 35, "T35", "RebuildPlayerReports", PhaseStatus::Stub, ""}, {Driver::Tail, 36, "T36", "FinalizeTurnRecords", PhaseStatus::Blocked, "fills every player's turn record and archives it by turn; must stay last. Thirteen of " "its fields are modelled and self-checked every run against the record the input save " "already carries for its own turn: seven from the wire -- turn, colony count, savings, " "the savings delta, the completed-tech count, the summed population and the alliance mask " "phase S04 rebuilt -- and, when a data root is given, the six per-hull-class ship counts, " "which need each design's hull size and defence-platform flag from the section catalog " "because neither is on the wire. Only 32 of the 480 census leaves the corpus archives are " "nonzero, so cls1 (cruisers) and cls2's platform count are UNEXERCISED, not verified. " "Still not committed, and now blocked on exactly two named things, neither of them here: " "savings and the income derived from it come from P01/P02, which are blocked on the " "per-system money output; and a ship the turn BUILDS never enters our fleet list, so the " "census carries the pre-construction count. Measured with --commit-blocked=T36 on " "turn1->turn2: 29 leaves closed, 7 regressed -- sav x3, inc x3 and one shpt[0] short by " "exactly the one destroyer that turn completes. The archived record is one struct on the " "wire, so those words cannot be omitted while the rest is written: committing is " "all-or-nothing at the record"}, }; PhaseTally Tally(const PhaseDesc* p, std::size_t n) { PhaseTally t; t.total = static_cast(n); for (std::size_t i = 0; i < n; ++i) { switch (p[i].status) { case PhaseStatus::Verified: ++t.verified; break; case PhaseStatus::Implemented: ++t.implemented; break; case PhaseStatus::Partial: ++t.partial; break; case PhaseStatus::Blocked: ++t.blocked; break; case PhaseStatus::Stub: ++t.stub; break; } } return t; } } // namespace const PhaseDesc* HostPhases(std::size_t& count) { count = sizeof(kHost) / sizeof(kHost[0]); return kHost; } const PhaseDesc* StrategicPhases(std::size_t& count) { count = sizeof(kStrategic) / sizeof(kStrategic[0]); return kStrategic; } const PhaseDesc* PlayerPhases(std::size_t& count) { count = sizeof(kPlayer) / sizeof(kPlayer[0]); return kPlayer; } const PhaseDesc* TailPhases(std::size_t& count) { count = sizeof(kTail) / sizeof(kTail[0]); return kTail; } PhaseTally TallySpine() { std::size_t ns = 0, np = 0; const PhaseDesc* s = StrategicPhases(ns); const PhaseDesc* p = PlayerPhases(np); PhaseTally a = Tally(s, ns), b = Tally(p, np); PhaseTally t; t.total = a.total + b.total; t.verified = a.verified + b.verified; t.implemented = a.implemented + b.implemented; t.partial = a.partial + b.partial; t.blocked = a.blocked + b.blocked; t.stub = a.stub + b.stub; return t; } PhaseTally TallyTail() { std::size_t n = 0; const PhaseDesc* p = TailPhases(n); return Tally(p, n); } } // namespace sots::app