namespace GamePort.Game; public readonly record struct JetpackBurstState( int JumpState = 0, float HoldSeconds = 0, float EffectRemaining = 0); public readonly record struct JetpackBurstInput( bool Grounded, bool JumpHeld, float VelocityY, float ShadowDistance, int InventoryState, float Energy, string LevelCode, int GadgetMode, float DeltaSeconds, float CurrentExtraAccelerationY, bool EffectAvailable = true, float GravityY = -800); public enum JetpackPose { None, Jump, Fall, Fly } public readonly record struct JetpackBurstResult( JetpackBurstState State, float ImpulseY, float? VelocityYOverride, float ExtraAccelerationY, JetpackPose Pose, float? RadiusOverride, bool StartGadget, bool StopGadget, int? MovementModeOverride); public readonly record struct JetpackEffectResult( JetpackBurstState State, float Energy, bool Visible); /// /// The jump/jetpack branches of EXE437F90 and effect timer of EXE421FB0. /// Controller and effect phases are separate. The normal route registry places /// Jimmy before his retained fire; other full-scene phases remain incomplete. Horizontal /// movement, shadow queries, visuals and sound callbacks belong to the caller. /// public static class JetpackBurst { public const float Duration = 8; public const float HoldThreshold = .4f; public const float JumpImpulse = 550; public const float BurstInitialVelocityY = 10; public const float BurstRadius = 100; public const float LandingRadius = 60; public const float EnergyPerSecond = .5f; /// /// Includes the outer update's ordinary grounded/released reset (437B9E). /// CurrentExtraAccelerationY is required because the expired-effect branch /// returns before writing acceleration. Results describe this invocation; /// a newly started/stopped burst changes acceleration on the next call. /// public static JetpackBurstResult Step(JetpackBurstState state, JetpackBurstInput input) { ValidateState(state); ValidateSeconds(input.DeltaSeconds); RequireFinite(input.VelocityY); RequireFinite(input.ShadowDistance); RequireFinite(input.Energy); RequireFinite(input.CurrentExtraAccelerationY); RequireFinite(input.GravityY); ArgumentNullException.ThrowIfNull(input.LevelCode); var extra = input.CurrentExtraAccelerationY; JetpackBurstResult Result(float impulse = 0, float? velocity = null, JetpackPose pose = JetpackPose.None, float? radius = null, bool start = false, bool stop = false, int? mode = null) => new(state, impulse, velocity, extra, pose, radius, start, stop, mode); if (input.Grounded && !input.JumpHeld) { // This path runs ground apply instead of air apply; it does not // itself clear the effect timer or restore the radius. state = state with { JumpState = 0 }; return Result(mode: 0); } if (state.JumpState < 3) extra = (float)((double)input.GravityY * 1.33f - input.GravityY); else { if (input.EffectAvailable && state.EffectRemaining <= 0 && state.JumpState is 3 or 4) { state = state with { JumpState = 0, EffectRemaining = 0 }; return Result(pose: JetpackPose.Fall, stop: true, mode: 1); } // The near-floor constants are doubles in the original; the far // branch uses float .1. Preserve those distinct constant widths. extra = input.ShadowDistance < 500 ? (float)(-input.GravityY - (input.VelocityY < -1 ? .3 : .1) * input.GravityY) : .1f * input.GravityY - input.GravityY; } if (!input.JumpHeld) { switch (state.JumpState) { case 1: state = state with { JumpState = 2 }; break; case 3: state = state with { JumpState = 4, EffectRemaining = input.EffectAvailable ? 0 : state.EffectRemaining }; return Result(pose: JetpackPose.Fall, stop: true, mode: 1); case 4: // Table4387C4 entry3 jumps directly43879A. Only state5's // entry checks grounded at43878C (outer reset above too). state = state with { JumpState = 0 }; break; } return Result(); } switch (state.JumpState) { case 0: if (!input.Grounded) return Result(pose: JetpackPose.Fall, stop: true); state = state with { JumpState = 1, HoldSeconds = 0, EffectRemaining = input.EffectAvailable ? 0 : state.EffectRemaining }; return Result(impulse: JumpImpulse, pose: JetpackPose.Jump); case 1: //438407 storesfloat but keeps the unrounded sum on x87 for //43840D's comparison. Different sums can store the samefloat. double hold=(double)state.HoldSeconds+input.DeltaSeconds; state = state with { HoldSeconds = (float)hold }; if (hold <= HoldThreshold) return Result(); break; case 2: break; case 3: if (!input.Grounded) return Result(); state = state with { JumpState = 4, EffectRemaining = input.EffectAvailable ? 0 : state.EffectRemaining }; return Result(pose: JetpackPose.Fall, radius: LandingRadius, stop: true, mode: 1); case 5: if (input.Grounded) state = state with { JumpState = 0 }; return Result(); default: return Result(); } // Both the >.4-second and released-then-held branches enter state3 // even when no gadget is available. The next expired-effect guard // then returns to state0, preserving the ballistic acceleration. state = state with { JumpState = 3 }; if (!CanStart(input.LevelCode, input.GadgetMode, input.InventoryState, input.Energy)) return Result(); if (input.EffectAvailable) state = state with { EffectRemaining = Duration }; return Result(velocity: BurstInitialVelocityY, pose: JetpackPose.Fly, radius: input.EffectAvailable ? BurstRadius : null, start: true); } public static bool CanStart(string levelCode, int gadgetMode, int inventoryState, float energy) { ArgumentNullException.ThrowIfNull(levelCode); RequireFinite(energy); if (levelCode == "VR04") return true; return levelCode is not ("LEV6" or "LV4B" or "LV6A" or "LEV3" or "LV3A" or "LV3B" or "LV3C" or "LV3D") && gadgetMode is not (2 or 6 or 7) && energy > 0 && inventoryState is not (0 or 4); } /// /// Effect421FB0 resets grounded remaining time to0, subtracts dt (including /// when inactive), then drains only if the stored result is positive. /// Owner/effect absence leaves timer and energy unchanged. Energy reaching /// zero does not cancel an already running burst. Visibility is this phase's /// request; the controller phase does not itself show/hide the effect. /// public static JetpackEffectResult StepEffect(JetpackBurstState state, bool grounded, float deltaSeconds, float energy, string levelCode, bool ownerAvailable = true, bool effectAvailable = true) { ValidateState(state); ValidateSeconds(deltaSeconds); RequireFinite(energy); ArgumentNullException.ThrowIfNull(levelCode); if (!ownerAvailable || !effectAvailable) return new(state, energy, false); var remaining = (grounded ? 0 : state.EffectRemaining) - deltaSeconds; state = state with { EffectRemaining = remaining }; if (remaining <= 0) return new(state, energy, false); return new(state, AdjustEnergy(energy, -deltaSeconds * EnergyPerSecond, levelCode), true); } /// EXE42A920 numeric VR01..VR08 immunity and [0,100] clamp. SFX are external. public static float AdjustEnergy(float energy, float delta, string levelCode) { RequireFinite(energy); RequireFinite(delta); ArgumentNullException.ThrowIfNull(levelCode); // The source compares a big-endian FourCC numerically, not by prefix. if (levelCode.Length == 4) { var code = ((uint)levelCode[0] << 24) | ((uint)levelCode[1] << 16) | ((uint)levelCode[2] << 8) | levelCode[3]; if (code is >= 0x56523031 and <= 0x56523038) return energy; } return Math.Clamp(energy + delta, 0, 100); } private static void ValidateState(JetpackBurstState state) { if (state.JumpState is < 0 or > 5) throw new ArgumentOutOfRangeException(nameof(state)); RequireFinite(state.HoldSeconds); RequireFinite(state.EffectRemaining); } private static void ValidateSeconds(float seconds) { if (!float.IsFinite(seconds) || seconds < 0) throw new ArgumentOutOfRangeException(nameof(seconds)); } private static void RequireFinite(float value) { if (!float.IsFinite(value)) throw new ArgumentOutOfRangeException(nameof(value)); } }