Files
Neutron/tests/GamePort.JetpackTests/Program.cs
T

190 lines
10 KiB
C#

using GamePort.Game;
var count = 0;
void Check(bool condition, string message)
{
if (!condition) throw new Exception(message);
}
void Near(float actual, float expected, string message) =>
Check(MathF.Abs(actual - expected) < .0002f, $"{message}: {actual} != {expected}");
void Test(string name, Action action)
{
action();
count++;
Console.WriteLine($"PASS {name}");
}
JetpackBurstInput Input(bool ground = false, bool held = true, float vy = 20,
float distance = 100, int inventory = 1, float energy = 100, string level = "LV1B",
int mode = -1, float dt = .1f, float extra = -264) =>
new(ground, held, vy, distance, inventory, energy, level, mode, dt, extra);
Test("ordinary jump, release and renewed hold", () =>
{
var first = JetpackBurst.Step(new(), Input(ground: true));
Check(first.State.JumpState == 1 && first.State.HoldSeconds == 0, "ordinary takeoff state");
Check(first.Pose == JetpackPose.Jump && first.ImpulseY == 550 && first.VelocityYOverride is null,
"550 queued impulse selects JUMP");
Near(first.ExtraAccelerationY - 800, -1064, "ballistic net acceleration");
var released = JetpackBurst.Step(first.State, Input(held: false));
Check(released.State.JumpState == 2 && released.ImpulseY == 0, "release arms refire");
var refired = JetpackBurst.Step(released.State, Input(dt: 0));
Check(refired.State.JumpState == 3 && refired.State.EffectRemaining == 8, "refire needs no new .4 delay");
Check(refired.Pose == JetpackPose.Fly && refired.VelocityYOverride == 10
&& refired.RadiusOverride == 100 && refired.StartGadget, "powered start commands");
Near(refired.ExtraAccelerationY, first.ExtraAccelerationY, "start invocation remains ballistic");
});
Test("hold is strictly greater than .4 seconds", () =>
{
var state = new JetpackBurstState(1);
state = JetpackBurst.Step(state, Input(dt: .2f)).State;
state = JetpackBurst.Step(state, Input(dt: .2f)).State;
Check(state.JumpState == 1 && state.EffectRemaining == 0, "exactly .4 does not start");
var started = JetpackBurst.Step(state, Input(dt: .001f));
Check(started.StartGadget && started.State.EffectRemaining == 8, "more than .4 starts");
});
Test("disabled long hold stays ballistic and can jump on landing", () =>
{
var denied = JetpackBurst.Step(new(1, .4f), Input(inventory: 0));
Check(denied.State.JumpState == 3 && denied.Pose == JetpackPose.None
&& denied.VelocityYOverride is null && denied.State.EffectRemaining == 0, "disabled transition only enters3");
var expired = JetpackBurst.Step(denied.State, Input(extra: -271));
Check(expired.State.JumpState == 0 && expired.Pose == JetpackPose.Fall
&& expired.ExtraAccelerationY == -271 && expired.StopGadget, "expired guard preserves external acceleration");
var landed = JetpackBurst.Step(expired.State, Input(ground: true, inventory: 0));
Check(landed.ImpulseY == 550 && landed.State.JumpState == 1, "held unavailable gadget repeats ordinary jump");
});
Test("all blocked levels and gadget modes plus VR04 override", () =>
{
foreach (var level in new[] { "LEV6", "LV4B", "LV6A", "LEV3", "LV3A", "LV3B", "LV3C", "LV3D" })
Check(!JetpackBurst.CanStart(level, -1, 1, 100), $"level {level}");
foreach (var mode in new[] { 2, 6, 7 }) Check(!JetpackBurst.CanStart("LV1B", mode, 1, 100), $"mode {mode}");
Check(!JetpackBurst.CanStart("LV1B", -1, 1, 0), "zero energy");
Check(!JetpackBurst.CanStart("LV1B", -1, 4, 100), "inventory state4");
Check(JetpackBurst.CanStart("VR04", 7, 0, -1), "VR04 bypasses every availability gate");
Check(JetpackBurst.CanStart("LV1B", -1, 2, 100), "inventory state2 is accepted");
});
Test("powered distance and vertical-speed thresholds", () =>
{
var state = new JetpackBurstState(3, .5f, 8);
Near(JetpackBurst.Step(state, Input(vy: -1)).ExtraAccelerationY - 800, 80, "exact -1 uses near hover");
Near(JetpackBurst.Step(state, Input(vy: -1.001f)).ExtraAccelerationY - 800, 240, "descending boost");
Near(JetpackBurst.Step(state, Input(distance: 499.999f)).ExtraAccelerationY - 800, 80, "below500");
Near(JetpackBurst.Step(state, Input(distance: 500)).ExtraAccelerationY - 800, -80, "exact500");
Near(JetpackBurst.Step(state, Input(distance: 800, vy: -40)).ExtraAccelerationY - 800, -80, "far distance wins");
});
Test("airborne release stops without radius reset and preserves transition acceleration", () =>
{
var stopped = JetpackBurst.Step(new(3, .5f, 7), Input(held: false));
Check(stopped.State.JumpState == 4 && stopped.State.EffectRemaining == 0
&& stopped.Pose == JetpackPose.Fall && stopped.RadiusOverride is null && stopped.StopGadget,
"air release stop commands");
Near(stopped.ExtraAccelerationY, 880, "release invocation still powered");
var reset = JetpackBurst.Step(stopped.State, Input(held: false, extra: stopped.ExtraAccelerationY));
Check(reset.State.JumpState == 0, "expired state4 resets");
Near(reset.ExtraAccelerationY, 880, "expired guard preserves last powered acceleration");
var ordinary = JetpackBurst.Step(reset.State, Input(held: false, extra: reset.ExtraAccelerationY));
Near(ordinary.ExtraAccelerationY, -264, "next state0 invocation becomes ballistic");
});
Test("held landing stops effect and restores radius60", () =>
{
var stopped = JetpackBurst.Step(new(3, .5f, 7), Input(ground: true));
Check(stopped.State.JumpState == 4 && stopped.State.EffectRemaining == 0
&& stopped.RadiusOverride == 60 && stopped.MovementModeOverride == 1, "held landing commands");
var releasedGround = JetpackBurst.Step(new(3, .5f, 7), Input(ground: true, held: false, extra: 800));
Check(releasedGround.State.JumpState == 0 && releasedGround.State.EffectRemaining == 7
&& releasedGround.RadiusOverride is null && releasedGround.MovementModeOverride == 0,
"outer grounded release precedes air handler");
Near(releasedGround.ExtraAccelerationY, 800, "ground apply owns acceleration");
});
Test("effect subtracts before visibility and energy drain", () =>
{
var effect = JetpackBurst.StepEffect(new(3, 0, .1f), false, .1f, 90, "LV1B");
Check(effect.State.EffectRemaining == 0 && !effect.Visible && effect.Energy == 90,
"exact expiry does not drain");
effect = JetpackBurst.StepEffect(new(3, 0, .1f), false, .2f, 90, "LV1B");
Near(effect.State.EffectRemaining, -.1f, "negative timer is retained");
Check(!effect.Visible && effect.Energy == 90, "overshoot does not drain partial interval");
effect = JetpackBurst.StepEffect(new(3, 0, 8), false, .2f, 90, "LV1B");
Check(effect.Visible, "positive post-subtraction timer shows effect");
Near(effect.State.EffectRemaining, 7.8f, "active remaining");
Near(effect.Energy, 89.9f, ".5 energy per second");
});
Test("grounded effect resets then stores negative dt", () =>
{
var effect = JetpackBurst.StepEffect(new(3, 0, 8), true, .2f, 90, "LV1B");
Near(effect.State.EffectRemaining, -.2f, "grounded timer");
Check(!effect.Visible && effect.Energy == 90, "grounded effect no drain");
effect = JetpackBurst.StepEffect(effect.State, true, .3f, effect.Energy, "LV1B");
Near(effect.State.EffectRemaining, -.3f, "grounded reset happens each invocation");
});
Test("energy clamps and VR01 through VR08 preserve energy", () =>
{
Near(JetpackBurst.AdjustEnergy(.1f, -1, "LV1B"), 0, "lower clamp");
Near(JetpackBurst.AdjustEnergy(99, 5, "LV1B"), 100, "upper clamp");
for (var i = 1; i <= 8; i++)
{
var effect = JetpackBurst.StepEffect(new(3, 0, 8), false, .2f, 90, $"VR0{i}");
Check(effect.Visible && effect.Energy == 90, $"VR0{i} timer runs but energy is immune");
}
Near(JetpackBurst.AdjustEnergy(50, -2, "VR09"), 48, "VR09 outside numeric range");
Near(JetpackBurst.AdjustEnergy(50, -2, "VR00"), 48, "VR00 outside numeric range");
});
Test("energy depletion does not cancel active burn", () =>
{
var effect = JetpackBurst.StepEffect(new(3, .5f, 8), false, 1, .1f, "LV1B");
Check(effect.Energy == 0 && effect.Visible && effect.State.EffectRemaining == 7, "depletion leaves timer active");
var control = JetpackBurst.Step(effect.State, Input(energy: effect.Energy));
Check(control.State.JumpState == 3 && !control.StopGadget, "availability is checked only on start");
Near(control.ExtraAccelerationY, 880, "burn continues at zero energy");
});
Test("explicit phase ordering exposes first-tick timer difference", () =>
{
var initial = new JetpackBurstState(2);
var before = JetpackBurst.StepEffect(initial, false, .1f, 100, "LV1B");
var effectFirst = JetpackBurst.Step(before.State, Input(energy: before.Energy));
var controlFirst = JetpackBurst.Step(initial, Input());
var after = JetpackBurst.StepEffect(controlFirst.State, false, .1f, 100, "LV1B");
Check(effectFirst.State.EffectRemaining == 8 && before.Energy == 100, "effect-first start");
Near(after.State.EffectRemaining, 7.9f, "controller-first start");
Near(after.Energy, 99.95f, "controller-first drain");
});
Test("null effect bypasses expiry and does not assign radius or timer", () =>
{
var start = JetpackBurst.Step(new(2), Input() with { EffectAvailable = false });
Check(start.StartGadget && start.Pose == JetpackPose.Fly && start.VelocityYOverride == 10
&& start.RadiusOverride is null && start.State.EffectRemaining == 0, "null-effect start boundary");
var flying = JetpackBurst.Step(start.State, Input() with { EffectAvailable = false });
Check(flying.State.JumpState == 3, "no expiry guard for null pointer");
Near(flying.ExtraAccelerationY, 880, "null-effect powered branch");
var absentOwner = JetpackBurst.StepEffect(new(3, 0, 8), false, .1f, 50, "LV1B", ownerAvailable: false);
Check(absentOwner.State.EffectRemaining == 8 && absentOwner.Energy == 50, "absent owner leaves fields");
});
Test("bounded inputs reject invalid state, time and nonfinite values", () =>
{
void Throws(Action action)
{
try { action(); }
catch (ArgumentException) { return; }
throw new Exception("invalid input was accepted");
}
Throws(() => JetpackBurst.Step(new(6), Input()));
Throws(() => JetpackBurst.Step(new(), Input(dt: -1)));
Throws(() => JetpackBurst.Step(new(), Input(vy: float.NaN)));
Throws(() => JetpackBurst.StepEffect(new(), false, float.PositiveInfinity, 100, "LV1B"));
});
Console.WriteLine($"Jetpack checks passed: {count}");