CombatRuntimePacketHandler.cs

using System;
using System.IO;
using Ben10Mod.Content.Buffs.Abilities;
using Terraria;
using Terraria.ID;
using Terraria.ModLoader;

namespace Ben10Mod.Common.Networking;

internal static class CombatRuntimePacketHandler {
    private const string GhostFreakTransformationId = "Ben10Mod:GhostFreak";

    internal static void Handle(global::Ben10Mod.Ben10Mod.MessageType messageType, BinaryReader reader, int whoAmI) {
        switch (messageType) {
            case global::Ben10Mod.Ben10Mod.MessageType.RequestCombatRuntimeBootstrap:
                HandleBootstrapRequest(reader, whoAmI);
                break;
            case global::Ben10Mod.Ben10Mod.MessageType.SyncCombatRuntimeState:
                HandleRuntimeStateSync(reader);
                break;
            case global::Ben10Mod.Ben10Mod.MessageType.RequestCombatActionIntent:
                HandleActionIntent(reader, whoAmI);
                break;
            case global::Ben10Mod.Ben10Mod.MessageType.ReportCombatEnergyCeiling:
                HandleEnergyCeilingReport(reader, whoAmI);
                break;
        }
    }

    internal static bool TryAuthorizeAction(
        Player player,
        CombatRequestKind requestKind,
        ushort sequence,
        float energyCost,
        int cooldownTicks,
        int cooldownBuffType = 0,
        bool reserveEffect = false) {
        if (Main.netMode != NetmodeID.Server || player == null || !player.active)
            return false;

        OmnitrixPlayer omp = player.GetModPlayer<OmnitrixPlayer>();
        CombatRuntimeStatePlayer runtime = player.GetModPlayer<CombatRuntimeStatePlayer>();
        if (!runtime.HasAuthoritativeEnergy) {
            runtime.ObserveRejected(requestKind, sequence);
            RollbackServerPredictedBuffs(player, requestKind);
            SyncActionResult(player, requestKind, sequence, accepted: false);
            return false;
        }

        if (cooldownBuffType > 0 && player.HasBuff(cooldownBuffType)) {
            runtime.ObserveRejected(requestKind, sequence);
            RollbackServerPredictedBuffs(player, requestKind);
            SyncActionResult(player, requestKind, sequence, accepted: false);
            return false;
        }

        int guardedCooldown = Math.Max(
            CombatRequestPolicy.MinimumAcceptedRequestIntervalTicks,
            cooldownTicks);
        CombatRuntimeAuthorizationResult result = runtime.Authorization.TryAuthorize(
            requestKind,
            sequence,
            Main.GameUpdateCount,
            guardedCooldown,
            energyCost,
            omp.omnitrixEnergy,
            reserveEffect);
        if (result != CombatRuntimeAuthorizationResult.Accepted) {
            RollbackServerPredictedBuffs(player, requestKind);
            SyncActionResult(player, requestKind, sequence, accepted: false);
            return false;
        }

        // The pure ledger made the affordability decision from this same server-owned controller.
        // Terraria processes packets on one thread, so the spend remains atomic with authorization.
        if (!omp.TrySpendOmnitrixEnergy(energyCost)) {
            RollbackServerPredictedBuffs(player, requestKind);
            SyncActionResult(player, requestKind, sequence, accepted: false);
            return false;
        }

        if (cooldownBuffType > 0 && cooldownTicks > 0) {
            player.AddBuff(cooldownBuffType, cooldownTicks);
            NetMessage.SendData(MessageID.PlayerBuffs, -1, -1, null, player.whoAmI);
        }

        SyncActionResult(
            player,
            requestKind,
            sequence,
            accepted: true,
            authoritativeCharge: energyCost);
        return true;
    }

    internal static bool CanAuthorizeAction(
        Player player,
        CombatRequestKind requestKind,
        ushort sequence,
        float energyCost) {
        if (Main.netMode != NetmodeID.Server || player == null || !player.active)
            return false;

        CombatRuntimeStatePlayer runtime = player.GetModPlayer<CombatRuntimeStatePlayer>();
        if (!runtime.HasAuthoritativeEnergy)
            return false;

        float availableEnergy = player.GetModPlayer<OmnitrixPlayer>().omnitrixEnergy;
        return runtime.Authorization.PreviewAuthorization(
                   requestKind,
                   sequence,
                   Main.GameUpdateCount,
                   energyCost,
                   availableEnergy) ==
               CombatRuntimeAuthorizationResult.Accepted;
    }

    internal static void RejectAction(Player player, CombatRequestKind requestKind, ushort sequence) {
        if (Main.netMode != NetmodeID.Server || player == null || !player.active)
            return;

        player.GetModPlayer<CombatRuntimeStatePlayer>().ObserveRejected(requestKind, sequence);
        RollbackServerPredictedBuffs(player, requestKind);
        SyncActionResult(player, requestKind, sequence, accepted: false);
    }

    internal static bool TryConsumeCommittedAction(
        Player player,
        CombatRequestKind requestKind,
        ushort sequence) {
        return Main.netMode == NetmodeID.Server &&
               player != null &&
               player.active &&
               player.GetModPlayer<CombatRuntimeStatePlayer>()
                   .Authorization.TryConsumeCommittedEffect(requestKind, sequence, Main.GameUpdateCount);
    }

    internal static void SendActionIntent(CombatRequestKind requestKind, ushort sequence) {
        if (Main.netMode != NetmodeID.MultiplayerClient || sequence == 0)
            return;

        ModPacket packet = ModContent.GetInstance<global::Ben10Mod.Ben10Mod>().GetPacket();
        packet.Write((byte)global::Ben10Mod.Ben10Mod.MessageType.RequestCombatActionIntent);
        packet.Write((byte)requestKind);
        packet.Write(sequence);
        packet.Send();
    }

    private static void HandleBootstrapRequest(BinaryReader reader, int whoAmI) {
        float requestedEnergy = reader.ReadSingle();
        bool clientConfirmedZeroCapacity = reader.ReadBoolean();
        if (Main.netMode != NetmodeID.Server ||
            !float.IsFinite(requestedEnergy) ||
            requestedEnergy < 0f ||
            whoAmI < 0 ||
            whoAmI >= Main.maxPlayers)
            return;

        Player player = Main.player[whoAmI];
        if (!player.active)
            return;

        player.GetModPlayer<CombatRuntimeStatePlayer>().ReceiveBootstrap(
            requestedEnergy,
            clientConfirmedZeroCapacity);
    }

    private static void HandleRuntimeStateSync(BinaryReader reader) {
        int playerIndex = reader.ReadByte();
        CombatRequestKind requestKind = (CombatRequestKind)reader.ReadByte();
        ushort sequence = reader.ReadUInt16();
        bool accepted = reader.ReadBoolean();
        bool energySnapshotValid = reader.ReadBoolean();
        ulong energySnapshotRevision = reader.ReadUInt64();
        float authoritativeEnergy = reader.ReadSingle();
        float authoritativeCharge = reader.ReadSingle();
        int authoritativeCooldownRemaining = reader.ReadInt32();
        if (Main.netMode != NetmodeID.MultiplayerClient ||
            playerIndex < 0 ||
            playerIndex >= Main.maxPlayers ||
            (!float.IsFinite(authoritativeCharge) || authoritativeCharge < 0f) ||
            (!accepted && authoritativeCharge > 0f) ||
            (energySnapshotValid &&
             !CombatRequestPolicy.IsValidEnergySnapshot(
                 energySnapshotValid,
                 energySnapshotRevision,
                 authoritativeEnergy)) ||
            authoritativeCooldownRemaining < 0)
            return;

        Player player = Main.player[playerIndex];
        if (!player.active || playerIndex != Main.myPlayer)
            return;

        player.GetModPlayer<CombatRuntimeStatePlayer>().ApplyActionResult(
            requestKind,
            sequence,
            accepted,
            energySnapshotValid,
            energySnapshotRevision,
            authoritativeEnergy,
            authoritativeCharge,
            authoritativeCooldownRemaining);
    }

    private static void HandleEnergyCeilingReport(BinaryReader reader, int whoAmI) {
        uint reportRevision = reader.ReadUInt32();
        float reportedEnergy = reader.ReadSingle();
        if (Main.netMode != NetmodeID.Server ||
            !float.IsFinite(reportedEnergy) ||
            reportedEnergy < 0f ||
            !CombatRequestValidator.TryGetActivePlayer(whoAmI, out Player player))
            return;

        player.GetModPlayer<CombatRuntimeStatePlayer>()
            .ReceiveEnergyCeilingReport(reportRevision, reportedEnergy);
    }

    private static void HandleActionIntent(BinaryReader reader, int whoAmI) {
        CombatRequestKind requestKind = (CombatRequestKind)reader.ReadByte();
        ushort sequence = reader.ReadUInt16();
        if (Main.netMode != NetmodeID.Server ||
            !CombatRequestValidator.TryGetActivePlayer(whoAmI, out Player player))
            return;

        if (player.dead) {
            RejectAction(player, requestKind, sequence);
            return;
        }

        if (requestKind != CombatRequestKind.GhostFreakPossession) {
            RejectAction(player, requestKind, sequence);
            return;
        }

        OmnitrixPlayer omp = player.GetModPlayer<OmnitrixPlayer>();
        if (!CombatRequestValidator.HasExpectedTransformation(player, omp, GhostFreakTransformationId) ||
            omp.inPossessionMode ||
            player.CCed ||
            player.noItems ||
            !CombatRequestValidator.IsHoldingPlumbersBadge(player)) {
            RejectAction(player, requestKind, sequence);
            return;
        }

        int energyCost = omp.CurrentTransformation?.GetUltimateAbilityCost(omp) ?? 0;
        int cooldown = omp.CurrentTransformation?.GetUltimateAbilityCooldown(omp) ?? 0;
        TryAuthorizeAction(
            player,
            requestKind,
            sequence,
            energyCost,
            cooldown,
            ModContent.BuffType<UltimateAbilityCooldown>(),
            reserveEffect: true);
    }

    private static void SyncActionResult(
        Player player,
        CombatRequestKind requestKind,
        ushort sequence,
        bool accepted,
        float authoritativeCharge = 0f) {
        if (Main.netMode != NetmodeID.Server || player == null || !player.active)
            return;

        CombatRuntimeStatePlayer runtime = player.GetModPlayer<CombatRuntimeStatePlayer>();
        bool energySnapshotValid = runtime.HasAuthoritativeEnergy;
        ulong energySnapshotRevision = energySnapshotValid
            ? runtime.NextEnergySnapshotRevision()
            : 0;
        ModPacket packet = ModContent.GetInstance<global::Ben10Mod.Ben10Mod>().GetPacket();
        packet.Write((byte)global::Ben10Mod.Ben10Mod.MessageType.SyncCombatRuntimeState);
        packet.Write((byte)player.whoAmI);
        packet.Write((byte)requestKind);
        packet.Write(sequence);
        packet.Write(accepted);
        packet.Write(energySnapshotValid);
        packet.Write(energySnapshotRevision);
        packet.Write(player.GetModPlayer<OmnitrixPlayer>().omnitrixEnergy);
        packet.Write(accepted ? Math.Max(0f, authoritativeCharge) : 0f);
        packet.Write(GetAuthoritativeCooldownRemaining(player, requestKind));
        packet.Send(player.whoAmI);
    }

    internal static void SyncEnergySnapshot(Player player) {
        SyncActionResult(
            player,
            CombatRequestKind.Count,
            sequence: 0,
            accepted: false);
    }

    private static int GetAuthoritativeCooldownRemaining(
        Player player,
        CombatRequestKind requestKind) {
        int ledgerRemaining = player.GetModPlayer<CombatRuntimeStatePlayer>()
            .Authorization.GetRemainingCooldownTicks(requestKind, Main.GameUpdateCount);
        if (ledgerRemaining > 0)
            return ledgerRemaining;

        int cooldownBuffType = GetCombatCooldownBuffType(requestKind);
        int buffIndex = cooldownBuffType > 0
            ? player.FindBuffIndex(cooldownBuffType)
            : -1;
        return buffIndex >= 0 ? Math.Max(0, player.buffTime[buffIndex]) : 0;
    }

    private static int GetCombatCooldownBuffType(CombatRequestKind requestKind) {
        return requestKind switch {
            CombatRequestKind.BuzzShockTeleport => ModContent.BuffType<PrimaryAbilityCooldown>(),
            CombatRequestKind.EchoEchoShift => ModContent.BuffType<SecondaryAbilityCooldown>(),
            CombatRequestKind.UltimateEchoEchoRelay => ModContent.BuffType<TertiaryAbilityCooldown>(),
            CombatRequestKind.AmpFibianPhaseShift => ModContent.BuffType<PrimaryAbilityCooldown>(),
            CombatRequestKind.GhostFreakPossession => ModContent.BuffType<UltimateAbilityCooldown>(),
            _ => 0
        };
    }

    private static void RollbackServerPredictedBuffs(Player player, CombatRequestKind requestKind) {
        OmnitrixPlayer omp = player.GetModPlayer<OmnitrixPlayer>();
        string expectedTransformationId = requestKind switch {
            CombatRequestKind.BuzzShockTeleport => "Ben10Mod:BuzzShock",
            CombatRequestKind.EchoEchoShift => "Ben10Mod:EchoEcho",
            CombatRequestKind.UltimateEchoEchoRelay => "Ben10Mod:UltimateEchoEcho",
            CombatRequestKind.AmpFibianPhaseShift => "Ben10Mod:AmpFibian",
            CombatRequestKind.GhostFreakPossession => GhostFreakTransformationId,
            _ => string.Empty
        };
        if (string.IsNullOrEmpty(expectedTransformationId) ||
            !CombatRequestValidator.HasExpectedTransformation(player, omp, expectedTransformationId))
            return;

        CombatRuntimeStatePlayer runtime = player.GetModPlayer<CombatRuntimeStatePlayer>();
        int authoritativeCooldownRemaining =
            runtime.Authorization.GetRemainingCooldownTicks(requestKind, Main.GameUpdateCount);
        bool changed = false;

        void ClearBuff(int buffType) {
            if (buffType <= 0 || !player.HasBuff(buffType))
                return;

            player.ClearBuff(buffType);
            changed = true;
        }

        void ReconcileCooldown(int buffType) {
            if (authoritativeCooldownRemaining <= 0)
                return;

            bool hadBuff = buffType > 0 && player.HasBuff(buffType);
            if (hadBuff)
                player.ClearBuff(buffType);
            player.AddBuff(buffType, authoritativeCooldownRemaining);
            changed = true;
        }

        switch (requestKind) {
            case CombatRequestKind.BuzzShockTeleport:
                ClearBuff(ModContent.BuffType<PrimaryAbility>());
                ReconcileCooldown(ModContent.BuffType<PrimaryAbilityCooldown>());
                omp.PrimaryAbilityEnabled = false;
                omp.PrimaryAbilityWasEnabled = false;
                omp.primaryAbilityTransformationId = string.Empty;
                break;

            case CombatRequestKind.EchoEchoShift:
                ClearBuff(ModContent.BuffType<SecondaryAbility>());
                ReconcileCooldown(ModContent.BuffType<SecondaryAbilityCooldown>());
                omp.SecondaryAbilityEnabled = false;
                omp.SecondaryAbilityWasEnabled = false;
                omp.secondaryAbilityTransformationId = string.Empty;
                break;

            case CombatRequestKind.UltimateEchoEchoRelay:
                ReconcileCooldown(ModContent.BuffType<TertiaryAbilityCooldown>());
                break;

            case CombatRequestKind.AmpFibianPhaseShift:
                ReconcileCooldown(ModContent.BuffType<PrimaryAbilityCooldown>());
                break;

            case CombatRequestKind.GhostFreakPossession:
                ReconcileCooldown(ModContent.BuffType<UltimateAbilityCooldown>());
                break;
        }

        if (changed)
            NetMessage.SendData(MessageID.PlayerBuffs, -1, -1, null, player.whoAmI);
    }
}

public sealed class CombatRuntimeStatePlayer : ModPlayer {
    private const int ClientBootstrapWaitTicks = 60;
    private const int ServerBootstrapZeroCapacityGraceTicks = 120;
    private const int ReservedPredictionLifetimeTicks = 5;

    private readonly ushort[] _nextClientSequences = new ushort[(int)CombatRequestKind.Count];
    private readonly PredictedAction[] _predictedActions = new PredictedAction[(int)CombatRequestKind.Count];
    private bool _clientBootstrapSent;
    private int _clientBootstrapWaitTicks;
    private bool _serverEnergyInitialized;
    private bool _hasPendingBootstrap;
    private float _pendingBootstrapEnergy;
    private bool _pendingBootstrapAllowsZeroCapacity;
    private ulong _pendingBootstrapReceivedTick;
    private ulong _nextServerEnergySnapshotRevision;
    private ulong _lastAppliedEnergySnapshotRevision;
    private bool _hasPendingEnergySnapshot;
    private ulong _pendingEnergySnapshotRevision;
    private float _pendingEnergySnapshot;
    private bool _clientEnergyCeilingDirty;
    private bool _clientEnergyCeilingNeedsPostPredictionFlush;
    private uint _nextClientEnergyCeilingRevision;
    private bool _serverHasEnergyCeilingRevision;
    private uint _serverEnergyCeilingRevision;
    private bool _hasPendingServerEnergyCeiling;
    private float _pendingServerEnergyCeiling;

    internal CombatRuntimeAuthorizationState Authorization { get; } = new();
    internal bool HasAuthoritativeEnergy => _serverEnergyInitialized;

    public override void Initialize() {
        Array.Clear(_nextClientSequences, 0, _nextClientSequences.Length);
        Array.Clear(_predictedActions, 0, _predictedActions.Length);
        _clientBootstrapSent = false;
        _clientBootstrapWaitTicks = 0;
        _serverEnergyInitialized = false;
        _hasPendingBootstrap = false;
        _pendingBootstrapEnergy = 0f;
        _pendingBootstrapAllowsZeroCapacity = false;
        _pendingBootstrapReceivedTick = 0;
        _nextServerEnergySnapshotRevision = 0;
        _lastAppliedEnergySnapshotRevision = 0;
        _hasPendingEnergySnapshot = false;
        _pendingEnergySnapshotRevision = 0;
        _pendingEnergySnapshot = 0f;
        _clientEnergyCeilingDirty = false;
        _clientEnergyCeilingNeedsPostPredictionFlush = false;
        _nextClientEnergyCeilingRevision = 0;
        _serverHasEnergyCeilingRevision = false;
        _serverEnergyCeilingRevision = 0;
        _hasPendingServerEnergyCeiling = false;
        _pendingServerEnergyCeiling = 0f;
        Authorization.Reset();
    }

    public override void PostUpdate() {
        if (Main.netMode == NetmodeID.MultiplayerClient && Player.whoAmI == Main.myPlayer) {
            OmnitrixPlayer omp = Player.GetModPlayer<OmnitrixPlayer>();
            if (!_clientBootstrapSent) {
                _clientBootstrapWaitTicks++;
                if (omp.omnitrixEnergyMax > 0f ||
                    _clientBootstrapWaitTicks >= ClientBootstrapWaitTicks)
                    EnsureBootstrap(energyAlreadySpent: 0f);
            }
            CancelOrphanedReservedPredictions(omp);
            FlushClientEnergyCeiling();
            return;
        }

        if (Main.netMode == NetmodeID.Server && _hasPendingBootstrap)
            TryFinalizeBootstrap();
    }

    internal ushort BeginPredictedAction(CombatRequestKind requestKind, float energyAlreadySpent) {
        return BeginPredictedAction(requestKind, energyAlreadySpent, requestSent: true);
    }

    internal ushort ReservePredictedAction(CombatRequestKind requestKind, float energyAlreadySpent) {
        return BeginPredictedAction(requestKind, energyAlreadySpent, requestSent: false);
    }

    private ushort BeginPredictedAction(
        CombatRequestKind requestKind,
        float energyAlreadySpent,
        bool requestSent) {
        if (Main.netMode != NetmodeID.MultiplayerClient ||
            Player.whoAmI != Main.myPlayer ||
            !TryGetIndex(requestKind, out int requestIndex))
            return 0;

        // Keep one in-flight prediction per action kind so an earlier acknowledgement cannot be
        // orphaned by a later sequence overwriting its refund/rollback record.
        if (_predictedActions[requestIndex].Active)
            return 0;

        FlushClientEnergyCeiling(energyAlreadySpent);
        EnsureBootstrap(energyAlreadySpent);

        ushort next = _nextClientSequences[requestIndex];
        next = next == ushort.MaxValue ? (ushort)1 : (ushort)(next + 1);
        if (next == 0)
            next = 1;
        _nextClientSequences[requestIndex] = next;

        _predictedActions[requestIndex] = new PredictedAction {
            Active = true,
            Sequence = next,
            EnergyCost = Math.Max(0f, float.IsFinite(energyAlreadySpent) ? energyAlreadySpent : 0f),
            RequestSent = requestSent,
            CreatedTick = Main.GameUpdateCount
        };
        return next;
    }

    internal ushort CommitReservedPredictedAction(CombatRequestKind requestKind) {
        if (Main.netMode != NetmodeID.MultiplayerClient ||
            Player.whoAmI != Main.myPlayer ||
            !TryGetIndex(requestKind, out int requestIndex))
            return 0;

        PredictedAction prediction = _predictedActions[requestIndex];
        if (!prediction.Active || prediction.RequestSent)
            return 0;

        prediction.RequestSent = true;
        _predictedActions[requestIndex] = prediction;
        return prediction.Sequence;
    }

    internal bool CancelReservedPredictedAction(CombatRequestKind requestKind) {
        if (Main.netMode != NetmodeID.MultiplayerClient ||
            Player.whoAmI != Main.myPlayer ||
            !TryGetIndex(requestKind, out int requestIndex))
            return false;

        PredictedAction prediction = _predictedActions[requestIndex];
        if (!prediction.Active || prediction.RequestSent)
            return false;

        _predictedActions[requestIndex] = default;
        OmnitrixPlayer omp = Player.GetModPlayer<OmnitrixPlayer>();
        omp.RollbackPredictedCombatAction(
            requestKind,
            prediction.SelectionRollbackArmed,
            prediction.ExpectedSelection,
            prediction.ExpectedBaseSelection,
            prediction.ExpectedSelectionRevision);
        ApplyPredictedEnergyCorrection(
            omp,
            prediction.EnergyCost);
        SchedulePostPredictionEnergyCeilingFlush();
        TryApplyPendingEnergySnapshot(omp);
        return true;
    }

    internal void CaptureSelectionRollback(CombatRequestKind requestKind) {
        if (Main.netMode != NetmodeID.MultiplayerClient ||
            Player.whoAmI != Main.myPlayer ||
            !TryGetIndex(requestKind, out int requestIndex))
            return;

        PredictedAction prediction = _predictedActions[requestIndex];
        if (!prediction.Active)
            return;

        OmnitrixPlayer omp = Player.GetModPlayer<OmnitrixPlayer>();
        prediction.SelectionRollbackArmed = true;
        prediction.ExpectedSelection = omp.setAttack;
        prediction.ExpectedBaseSelection = omp.AttackSelectionState.Base;
        prediction.ExpectedSelectionRevision = omp.AttackSelectionState.SelectionRevision;
        _predictedActions[requestIndex] = prediction;
    }

    internal void ReceiveBootstrap(float requestedEnergy, bool clientConfirmedZeroCapacity) {
        if (Main.netMode != NetmodeID.Server ||
            _serverEnergyInitialized ||
            _hasPendingBootstrap ||
            !float.IsFinite(requestedEnergy) ||
            requestedEnergy < 0f)
            return;

        _pendingBootstrapEnergy = requestedEnergy;
        _pendingBootstrapAllowsZeroCapacity = clientConfirmedZeroCapacity;
        _pendingBootstrapReceivedTick = Main.GameUpdateCount;
        _hasPendingBootstrap = true;
        TryFinalizeBootstrap();
    }

    internal void MarkClientEnergyCeilingDirty() {
        if (Main.netMode == NetmodeID.MultiplayerClient &&
            Player.whoAmI == Main.myPlayer)
            _clientEnergyCeilingDirty = true;
    }

    internal void ReceiveEnergyCeilingReport(uint reportRevision, float reportedEnergy) {
        if (Main.netMode != NetmodeID.Server ||
            !float.IsFinite(reportedEnergy) ||
            reportedEnergy < 0f ||
            !CombatRequestPolicy.IsNewerEnergyReportRevision(
                reportRevision,
                _serverEnergyCeilingRevision,
                _serverHasEnergyCeilingRevision))
            return;

        _serverHasEnergyCeilingRevision = true;
        _serverEnergyCeilingRevision = reportRevision;
        if (!_serverEnergyInitialized) {
            // Reports are absolute balance observations. The newest revision supersedes an older
            // one; bootstrap still applies it as a lowering-only ceiling.
            _hasPendingServerEnergyCeiling = true;
            _pendingServerEnergyCeiling = reportedEnergy;
            return;
        }

        ApplyServerEnergyCeiling(reportedEnergy);
        CombatRuntimePacketHandler.SyncEnergySnapshot(Player);
    }

    internal ulong NextEnergySnapshotRevision() {
        if (Main.netMode != NetmodeID.Server)
            return 0;

        if (_nextServerEnergySnapshotRevision < ulong.MaxValue)
            _nextServerEnergySnapshotRevision++;
        return _nextServerEnergySnapshotRevision;
    }

    internal void ObserveRejected(CombatRequestKind requestKind, ushort sequence) {
        Authorization.ObserveRejected(requestKind, sequence);
    }

    internal void ApplyActionResult(
        CombatRequestKind requestKind,
        ushort sequence,
        bool accepted,
        bool energySnapshotValid,
        ulong energySnapshotRevision,
        float authoritativeEnergy,
        float authoritativeCharge,
        int authoritativeCooldownRemaining) {
        if (!float.IsFinite(authoritativeCharge) ||
            authoritativeCharge < 0f ||
            (!accepted && authoritativeCharge > 0f) ||
            (energySnapshotValid &&
             !CombatRequestPolicy.IsValidEnergySnapshot(
                 energySnapshotValid,
                 energySnapshotRevision,
                 authoritativeEnergy)) ||
            authoritativeCooldownRemaining < 0)
            return;

        OmnitrixPlayer omp = Player.GetModPlayer<OmnitrixPlayer>();
        if (TryGetIndex(requestKind, out int requestIndex) && sequence != 0) {
            PredictedAction prediction = _predictedActions[requestIndex];
            if (prediction.Active && prediction.Sequence == sequence) {
                _predictedActions[requestIndex] = default;
                if (!accepted) {
                    // The rollback helper guards transformation identity and requires the exact
                    // post-shot selection revision, so it cannot take ownership from later input.
                    omp.RollbackPredictedCombatAction(
                        requestKind,
                        prediction.SelectionRollbackArmed,
                        prediction.ExpectedSelection,
                        prediction.ExpectedBaseSelection,
                        prediction.ExpectedSelectionRevision);
                }

                float correction = CombatRequestPolicy.GetPredictedEnergyCorrection(
                    prediction.EnergyCost,
                    authoritativeCharge);
                ApplyPredictedEnergyCorrection(omp, correction);
                omp.ReconcileAuthoritativeCombatCooldown(
                    requestKind,
                    authoritativeCooldownRemaining);
                SchedulePostPredictionEnergyCeilingFlush();
            }
        }

        if (energySnapshotValid)
            StorePendingEnergySnapshot(energySnapshotRevision, authoritativeEnergy);
        TryApplyPendingEnergySnapshot(omp);
    }

    private void FlushClientEnergyCeiling(float additionalPredictedDebit = 0f) {
        if (!_clientEnergyCeilingDirty ||
            Main.netMode != NetmodeID.MultiplayerClient ||
            Player.whoAmI != Main.myPlayer)
            return;

        OmnitrixPlayer omp = Player.GetModPlayer<OmnitrixPlayer>();
        float reconstructedEnergy = omp.omnitrixEnergy +
                                    Math.Max(
                                        0f,
                                        float.IsFinite(additionalPredictedDebit)
                                            ? additionalPredictedDebit
                                            : 0f);
        for (int i = 0; i < _predictedActions.Length; i++) {
            if (_predictedActions[i].Active)
                reconstructedEnergy += _predictedActions[i].EnergyCost;
        }

        if (!float.IsFinite(reconstructedEnergy))
            reconstructedEnergy = omp.omnitrixEnergy;
        if (omp.omnitrixEnergyMax > 0f)
            reconstructedEnergy = Math.Min(reconstructedEnergy, omp.omnitrixEnergyMax);
        reconstructedEnergy = Math.Max(0f, reconstructedEnergy);

        _nextClientEnergyCeilingRevision =
            _nextClientEnergyCeilingRevision == uint.MaxValue
                ? 1u
                : _nextClientEnergyCeilingRevision + 1u;
        ModPacket packet = ModContent.GetInstance<global::Ben10Mod.Ben10Mod>().GetPacket();
        packet.Write((byte)global::Ben10Mod.Ben10Mod.MessageType.ReportCombatEnergyCeiling);
        packet.Write(_nextClientEnergyCeilingRevision);
        packet.Write(reconstructedEnergy);
        packet.Send();
        if (HasActivePredictedActions() || additionalPredictedDebit > 0f)
            _clientEnergyCeilingNeedsPostPredictionFlush = true;
        _clientEnergyCeilingDirty = false;
    }

    private static void ApplyPredictedEnergyCorrection(OmnitrixPlayer omp, float correction) {
        if (!float.IsFinite(correction) || Math.Abs(correction) < 0.0001f)
            return;

        if (correction > 0f) {
            omp.RestoreOmnitrixEnergy(correction);
            return;
        }

        omp.omnitrixEnergy = Math.Max(0f, omp.omnitrixEnergy + correction);
    }

    private void StorePendingEnergySnapshot(ulong revision, float authoritativeEnergy) {
        if (revision == 0 ||
            !float.IsFinite(authoritativeEnergy) ||
            authoritativeEnergy < 0f ||
            revision <= _lastAppliedEnergySnapshotRevision ||
            (_hasPendingEnergySnapshot && revision <= _pendingEnergySnapshotRevision))
            return;

        _hasPendingEnergySnapshot = true;
        _pendingEnergySnapshotRevision = revision;
        _pendingEnergySnapshot = authoritativeEnergy;
    }

    private void TryApplyPendingEnergySnapshot(OmnitrixPlayer omp) {
        if (!_hasPendingEnergySnapshot || HasActivePredictedActions())
            return;

        // Remaining legacy OE mutations are owner-local. A snapshot may lower the local value but
        // must not raise it until those writers have migrated to the server.
        omp.omnitrixEnergy = CombatRequestPolicy.ClampEnergyToAuthoritativeCeiling(
            omp.omnitrixEnergy,
            _pendingEnergySnapshot);
        _lastAppliedEnergySnapshotRevision = _pendingEnergySnapshotRevision;
        _hasPendingEnergySnapshot = false;
        _pendingEnergySnapshotRevision = 0;
        _pendingEnergySnapshot = 0f;
    }

    private bool HasActivePredictedActions() {
        for (int i = 0; i < _predictedActions.Length; i++) {
            if (_predictedActions[i].Active)
                return true;
        }

        return false;
    }

    private void SchedulePostPredictionEnergyCeilingFlush() {
        if (!_clientEnergyCeilingNeedsPostPredictionFlush ||
            HasActivePredictedActions())
            return;

        _clientEnergyCeilingNeedsPostPredictionFlush = false;
        _clientEnergyCeilingDirty = true;
    }

    private void CancelOrphanedReservedPredictions(OmnitrixPlayer omp) {
        ulong currentTick = Main.GameUpdateCount;
        for (int i = 0; i < _predictedActions.Length; i++) {
            PredictedAction prediction = _predictedActions[i];
            if (!prediction.Active ||
                prediction.RequestSent ||
                currentTick == prediction.CreatedTick)
                continue;

            CombatRequestKind requestKind = (CombatRequestKind)i;
            ulong age = currentTick > prediction.CreatedTick
                ? currentTick - prediction.CreatedTick
                : ulong.MaxValue;
            if (age <= ReservedPredictionLifetimeTicks &&
                IsReservedPredictionStillOwned(requestKind, omp))
                continue;

            // No request was sent, so local rollback and refund are sufficient.
            CancelReservedPredictedAction(requestKind);
        }
    }

    private bool IsReservedPredictionStillOwned(
        CombatRequestKind requestKind,
        OmnitrixPlayer omp) {
        if (!Player.active || Player.dead || !omp.IsTransformed)
            return false;

        return requestKind switch {
            CombatRequestKind.BuzzShockTeleport =>
                string.Equals(
                    omp.currentTransformationId,
                    "Ben10Mod:BuzzShock",
                    StringComparison.Ordinal),
            CombatRequestKind.EchoEchoShift =>
                string.Equals(
                    omp.currentTransformationId,
                    "Ben10Mod:EchoEcho",
                    StringComparison.Ordinal),
            _ => true
        };
    }

    private void EnsureBootstrap(float energyAlreadySpent) {
        if (_clientBootstrapSent ||
            Main.netMode != NetmodeID.MultiplayerClient ||
            Player.whoAmI != Main.myPlayer)
            return;

        OmnitrixPlayer omp = Player.GetModPlayer<OmnitrixPlayer>();
        float reconstructedEnergy = omp.omnitrixEnergy +
                                    Math.Max(0f, float.IsFinite(energyAlreadySpent) ? energyAlreadySpent : 0f);
        if (omp.omnitrixEnergyMax > 0f)
            reconstructedEnergy = Math.Min(reconstructedEnergy, omp.omnitrixEnergyMax);

        ModPacket packet = ModContent.GetInstance<global::Ben10Mod.Ben10Mod>().GetPacket();
        packet.Write((byte)global::Ben10Mod.Ben10Mod.MessageType.RequestCombatRuntimeBootstrap);
        packet.Write(reconstructedEnergy);
        packet.Write(
            omp.omnitrixEnergyMax <= 0f &&
            _clientBootstrapWaitTicks >= ClientBootstrapWaitTicks);
        packet.Send();
        _clientBootstrapSent = true;
    }

    private void TryFinalizeBootstrap() {
        if (!_hasPendingBootstrap || _serverEnergyInitialized)
            return;

        OmnitrixPlayer omp = Player.GetModPlayer<OmnitrixPlayer>();
        float maximumEnergy = omp.omnitrixEnergyMax;
        ulong currentTick = Main.GameUpdateCount;
        ulong ticksPending = currentTick >= _pendingBootstrapReceivedTick
            ? currentTick - _pendingBootstrapReceivedTick
            : 0;
        if (!CombatRequestPolicy.ShouldFinalizeEnergyBootstrap(
                maximumEnergy,
                _pendingBootstrapAllowsZeroCapacity,
                ticksPending,
                ServerBootstrapZeroCapacityGraceTicks))
            return;

        omp.omnitrixEnergy = float.IsFinite(maximumEnergy) && maximumEnergy > 0f
            ? Math.Min(_pendingBootstrapEnergy, maximumEnergy)
            : 0f;
        _pendingBootstrapEnergy = 0f;
        _pendingBootstrapAllowsZeroCapacity = false;
        _pendingBootstrapReceivedTick = 0;
        _hasPendingBootstrap = false;
        _serverEnergyInitialized = true;
        if (_hasPendingServerEnergyCeiling) {
            ApplyServerEnergyCeiling(_pendingServerEnergyCeiling);
            _hasPendingServerEnergyCeiling = false;
            _pendingServerEnergyCeiling = 0f;
        }
        CombatRuntimePacketHandler.SyncEnergySnapshot(Player);
    }

    private void ApplyServerEnergyCeiling(float reportedEnergy) {
        OmnitrixPlayer omp = Player.GetModPlayer<OmnitrixPlayer>();
        omp.omnitrixEnergy = CombatRequestPolicy.ApplyReportedEnergyCeiling(
            omp.omnitrixEnergy,
            reportedEnergy,
            omp.omnitrixEnergyMax);
    }

    private static bool TryGetIndex(CombatRequestKind requestKind, out int requestIndex) {
        requestIndex = (int)requestKind;
        return requestIndex >= 0 && requestIndex < (int)CombatRequestKind.Count;
    }

    private struct PredictedAction {
        internal bool Active;
        internal ushort Sequence;
        internal float EnergyCost;
        internal bool RequestSent;
        internal ulong CreatedTick;
        internal bool SelectionRollbackArmed;
        internal OmnitrixPlayer.AttackSelection ExpectedSelection;
        internal OmnitrixPlayer.AttackSelection ExpectedBaseSelection;
        internal ulong ExpectedSelectionRevision;
    }
}