1121 lines
27 KiB
Markdown
1121 lines
27 KiB
Markdown
# Movement System - Manual Testing Checklist (Stage 9 Refactored)
|
|
|
|
## Overview
|
|
Comprehensive manual testing procedures для Movement System после архитектурного рефакторинга на Pipeline Processor pattern.
|
|
|
|
**Version:** Stage 9 (Post-Refactoring)
|
|
**Architecture:** Functional Core + Imperative Shell
|
|
**Test Focus:** Verify behavior parity + new architecture stability
|
|
|
|
---
|
|
|
|
## Pre-Testing Setup
|
|
|
|
### Environment Preparation
|
|
- [ ] Launch level: `TestLevel_Movement` (или basic test map)
|
|
- [ ] Place BP_MainCharacter with AC_Movement component
|
|
- [ ] Verify AC_DebugHUD component attached
|
|
- [ ] Enable ShowVisualDebug in debug HUD
|
|
- [ ] Set GameTimeScale = 1.0 (normal speed)
|
|
|
|
### Debug HUD Verification
|
|
- [ ] Debug page "Movement Info" visible
|
|
- [ ] All fields updating in real-time:
|
|
- [ ] Current Velocity
|
|
- [ ] Speed
|
|
- [ ] Is Grounded
|
|
- [ ] Surface Type
|
|
- [ ] Movement State
|
|
- [ ] Rotation data
|
|
- [ ] Collision Count
|
|
|
|
### Component Initialization Check
|
|
- [ ] AC_Movement.IsInitialized = true (visible in debug HUD)
|
|
- [ ] CapsuleComponent reference set
|
|
- [ ] Config values displaying correctly
|
|
- [ ] AngleThresholds converted to radians
|
|
|
|
---
|
|
|
|
## TEST SUITE 1: Basic Movement & Physics
|
|
|
|
### Test 1.1: Idle State
|
|
**Objective:** Verify default state on spawn
|
|
|
|
**Procedure:**
|
|
1. Spawn character
|
|
2. Do not provide any input
|
|
3. Observe for 5 seconds
|
|
|
|
**Expected Results:**
|
|
- [ ] Movement State: `Idle`
|
|
- [ ] Velocity: (0, 0, 0) or near-zero
|
|
- [ ] Speed: 0.0
|
|
- [ ] Is Grounded: `true`
|
|
- [ ] Character not moving
|
|
- [ ] No rotation occurring
|
|
|
|
**Pass Criteria:** All checks pass ✅
|
|
|
|
---
|
|
|
|
### Test 1.2: Forward Movement (Acceleration)
|
|
**Objective:** Verify smooth acceleration from standstill
|
|
|
|
**Procedure:**
|
|
1. Start from Idle state
|
|
2. Press W (forward) fully
|
|
3. Observe velocity increase
|
|
4. Release W after 2 seconds
|
|
|
|
**Expected Results:**
|
|
- [ ] Movement State changes: `Idle` → `Walking`
|
|
- [ ] Velocity.X increases smoothly (not instant)
|
|
- [ ] Speed reaches ~800 cm/s (MaxSpeed)
|
|
- [ ] Acceleration curve is smooth (VInterpTo behavior)
|
|
- [ ] Character rotates to face forward (Yaw → 0°)
|
|
- [ ] Visual debug shows green trace lines
|
|
|
|
**Measurements:**
|
|
- Time to reach MaxSpeed: ~1-2 seconds
|
|
- Final Speed: 800 ± 50 cm/s
|
|
|
|
**Pass Criteria:** Smooth acceleration, no jerking ✅
|
|
|
|
---
|
|
|
|
### Test 1.3: Friction (Deceleration)
|
|
**Objective:** Verify smooth deceleration when input released
|
|
|
|
**Procedure:**
|
|
1. Reach MaxSpeed (from Test 1.2)
|
|
2. Release W (no input)
|
|
3. Observe velocity decrease
|
|
4. Wait until full stop
|
|
|
|
**Expected Results:**
|
|
- [ ] Movement State changes: `Walking` → `Idle`
|
|
- [ ] Velocity decreases smoothly (VInterpTo)
|
|
- [ ] Speed → 0.0
|
|
- [ ] Character continues sliding briefly (natural friction)
|
|
- [ ] Final stop is smooth, not abrupt
|
|
|
|
**Measurements:**
|
|
- Stopping time: ~1-1.5 seconds (depends on Friction = 8.0)
|
|
- Stopping distance: ~600-800 cm
|
|
|
|
**Pass Criteria:** Smooth deceleration, natural feel ✅
|
|
|
|
---
|
|
|
|
### Test 1.4: Directional Movement (WASD)
|
|
**Objective:** Verify all cardinal directions
|
|
|
|
**Procedure:**
|
|
1. Test each direction individually:
|
|
- W (forward, X+)
|
|
- S (backward, X-)
|
|
- A (left, Y-)
|
|
- D (right, Y+)
|
|
2. For each direction:
|
|
- Accelerate to MaxSpeed
|
|
- Verify rotation
|
|
- Verify velocity vector
|
|
|
|
**Expected Results:**
|
|
|
|
| Input | Target Yaw | Velocity Direction | Pass |
|
|
|-------|------------|-------------------|------|
|
|
| W | 0° | (1, 0, 0) | [ ] |
|
|
| S | 180° | (-1, 0, 0) | [ ] |
|
|
| A | -90° | (0, -1, 0) | [ ] |
|
|
| D | 90° | (0, 1, 0) | [ ] |
|
|
|
|
- [ ] All directions reach MaxSpeed
|
|
- [ ] Rotation targets correct yaw
|
|
- [ ] Smooth transitions between directions
|
|
|
|
**Pass Criteria:** All 4 directions work correctly ✅
|
|
|
|
---
|
|
|
|
### Test 1.5: Diagonal Movement
|
|
**Objective:** Verify combined input vectors
|
|
|
|
**Procedure:**
|
|
1. Press W+D simultaneously (northeast)
|
|
2. Observe velocity and rotation
|
|
3. Repeat for all diagonals:
|
|
- W+D (northeast)
|
|
- W+A (northwest)
|
|
- S+D (southeast)
|
|
- S+A (southwest)
|
|
|
|
**Expected Results:**
|
|
- [ ] Velocity vector is normalized diagonal
|
|
- [ ] Speed still reaches MaxSpeed (not faster on diagonals)
|
|
- [ ] Rotation faces correct diagonal direction
|
|
- [ ] Smooth movement, no stuttering
|
|
|
|
**Diagonal Angles:**
|
|
- W+D: 45°
|
|
- W+A: -45°
|
|
- S+D: 135°
|
|
- S+A: -135°
|
|
|
|
**Pass Criteria:** Diagonals work, no speed advantage ✅
|
|
|
|
---
|
|
|
|
### Test 1.6: Rotation Speed
|
|
**Objective:** Verify character rotates at correct speed
|
|
|
|
**Procedure:**
|
|
1. Face forward (W)
|
|
2. Switch to backward (S) input
|
|
3. Measure rotation time
|
|
4. Verify rotation speed
|
|
|
|
**Expected Results:**
|
|
- [ ] Rotation Delta decreases smoothly
|
|
- [ ] Is Rotating: `true` during rotation
|
|
- [ ] Rotation Speed: 360°/sec (default config)
|
|
- [ ] 180° rotation takes ~0.5 seconds
|
|
- [ ] Character doesn't snap, rotates smoothly
|
|
|
|
**Measurements:**
|
|
- Start Yaw: 0°
|
|
- End Yaw: 180°
|
|
- Rotation Time: 0.5 seconds ± 0.1s
|
|
- Calculated Speed: ~360°/sec
|
|
|
|
**Pass Criteria:** Rotation smooth and matches config ✅
|
|
|
|
---
|
|
|
|
### Test 1.7: Min Speed For Rotation
|
|
**Objective:** Verify rotation threshold (MinSpeedForRotation)
|
|
|
|
**Procedure:**
|
|
1. Set MinSpeedForRotation = 50.0 in Config
|
|
2. Apply very light input (analog stick barely pressed)
|
|
3. Observe speed and rotation
|
|
|
|
**Expected Results:**
|
|
- [ ] Speed < 50 cm/s: Is Rotating = `false`
|
|
- [ ] Speed > 50 cm/s: Is Rotating = `true`
|
|
- [ ] Character doesn't jitter when nearly stopped
|
|
- [ ] Clean threshold behavior
|
|
|
|
**Pass Criteria:** Threshold prevents rotation jitter ✅
|
|
|
|
---
|
|
|
|
## TEST SUITE 2: Ground Detection & Snapping
|
|
|
|
### Test 2.1: Ground Detection (Flat Surface)
|
|
**Objective:** Verify basic ground detection
|
|
|
|
**Procedure:**
|
|
1. Stand on flat ground
|
|
2. Observe debug info
|
|
3. Verify ground trace (visual debug)
|
|
|
|
**Expected Results:**
|
|
- [ ] Is Grounded: `true`
|
|
- [ ] Surface Type: `Walkable`
|
|
- [ ] Ground Hit has valid BlockingHit
|
|
- [ ] Ground trace line visible (downward from capsule)
|
|
- [ ] Trace distance: GroundTraceDistance (50 cm default)
|
|
|
|
**Pass Criteria:** Ground detected correctly ✅
|
|
|
|
---
|
|
|
|
### Test 2.2: Ground Snapping
|
|
**Objective:** Verify character stays on ground (no floating)
|
|
|
|
**Procedure:**
|
|
1. Walk across slightly uneven terrain
|
|
2. Walk down small slopes (< 10°)
|
|
3. Observe Z position
|
|
|
|
**Expected Results:**
|
|
- [ ] Character stays on ground (no floating)
|
|
- [ ] Z position updates to follow terrain
|
|
- [ ] No visible jitter or bouncing
|
|
- [ ] Smooth transition over bumps
|
|
|
|
**Visual Check:**
|
|
- No air gap between capsule and ground
|
|
- Feet always touching surface (if model has feet)
|
|
|
|
**Pass Criteria:** Perfect ground contact ✅
|
|
|
|
---
|
|
|
|
### Test 2.3: Airborne State
|
|
**Objective:** Verify loss of ground contact
|
|
|
|
**Procedure:**
|
|
1. Walk character off platform edge
|
|
2. Observe state transition
|
|
3. Monitor gravity application
|
|
|
|
**Expected Results:**
|
|
- [ ] Movement State: `Walking` → `Airborne`
|
|
- [ ] Is Grounded: `true` → `false`
|
|
- [ ] Surface Type: `Walkable` → `None`
|
|
- [ ] Gravity starts applying (Velocity.Z decreasing)
|
|
- [ ] Ground trace shows no hit
|
|
|
|
**Gravity Check:**
|
|
- [ ] Velocity.Z decreases by ~980 cm/s² (Gravity)
|
|
- [ ] Character falls realistically
|
|
|
|
**Pass Criteria:** Proper air state, gravity works ✅
|
|
|
|
---
|
|
|
|
### Test 2.4: Landing
|
|
**Objective:** Verify return to ground state
|
|
|
|
**Procedure:**
|
|
1. Jump/fall from elevated position
|
|
2. Land on flat ground
|
|
3. Observe state transition
|
|
|
|
**Expected Results:**
|
|
- [ ] Movement State: `Airborne` → `Idle` or `Walking`
|
|
- [ ] Is Grounded: `false` → `true`
|
|
- [ ] Velocity.Z: negative → 0 (upon landing)
|
|
- [ ] Smooth landing, no bounce
|
|
- [ ] Ground snapping activates
|
|
|
|
**Pass Criteria:** Clean landing transition ✅
|
|
|
|
---
|
|
|
|
## TEST SUITE 3: Surface Classification
|
|
|
|
### Test 3.1: Walkable Surface (≤50°)
|
|
**Objective:** Verify walkable angle threshold
|
|
|
|
**Test Setup:**
|
|
1. Create ramp at 30° angle
|
|
2. Create ramp at 50° angle (boundary)
|
|
|
|
**Procedure:**
|
|
1. Walk up 30° ramp
|
|
2. Walk up 50° ramp
|
|
3. Observe Surface Type
|
|
|
|
**Expected Results:**
|
|
- [ ] 30° ramp: Surface Type = `Walkable`
|
|
- [ ] 50° ramp: Surface Type = `Walkable` (boundary)
|
|
- [ ] Normal movement possible on both
|
|
- [ ] Character doesn't slide
|
|
|
|
**Pass Criteria:** Walkable threshold correct ✅
|
|
|
|
---
|
|
|
|
### Test 3.2: Steep Slope (50°-85°)
|
|
**Objective:** Verify steep slope detection
|
|
|
|
**Test Setup:**
|
|
1. Create ramp at 60° angle
|
|
2. Create ramp at 80° angle
|
|
|
|
**Procedure:**
|
|
1. Walk onto 60° slope
|
|
2. Observe Surface Type change
|
|
3. Test on 80° slope
|
|
|
|
**Expected Results:**
|
|
- [ ] Surface Type = `SteepSlope`
|
|
- [ ] Movement State = `Sliding`
|
|
- [ ] Character starts sliding (future feature: will implement physics)
|
|
- [ ] Input may not prevent sliding
|
|
|
|
**Note:** Sliding physics not yet implemented (Stage 11+), but classification should work.
|
|
|
|
**Pass Criteria:** Classification correct ✅
|
|
|
|
---
|
|
|
|
### Test 3.3: Wall (85°-95°)
|
|
**Objective:** Verify wall detection
|
|
|
|
**Test Setup:**
|
|
1. Walk into vertical wall (90° angle)
|
|
|
|
**Procedure:**
|
|
1. Walk directly into wall
|
|
2. Observe collision response
|
|
3. Check Surface Type
|
|
|
|
**Expected Results:**
|
|
- [ ] Surface Type = `Wall`
|
|
- [ ] Movement State = `Blocked`
|
|
- [ ] Character stops at wall
|
|
- [ ] Collision sweep detects hit
|
|
- [ ] Is Blocked: `true`
|
|
|
|
**Pass Criteria:** Wall blocks movement ✅
|
|
|
|
---
|
|
|
|
### Test 3.4: Ceiling (>95°)
|
|
**Objective:** Verify ceiling detection
|
|
|
|
**Test Setup:**
|
|
1. Walk under low ceiling
|
|
2. Create overhang at >95° angle
|
|
|
|
**Procedure:**
|
|
1. Walk under ceiling geometry
|
|
2. Observe Surface Type if hit
|
|
|
|
**Expected Results:**
|
|
- [ ] Surface Type = `Ceiling` (if hit occurs)
|
|
- [ ] Character blocked from moving into ceiling
|
|
- [ ] Proper collision response
|
|
|
|
**Note:** Ceiling detection may be rare in normal gameplay.
|
|
|
|
**Pass Criteria:** Ceiling classified correctly ✅
|
|
|
|
---
|
|
|
|
## TEST SUITE 4: Collision System
|
|
|
|
### Test 4.1: Wall Collision (Front)
|
|
**Objective:** Verify frontal collision detection
|
|
|
|
**Procedure:**
|
|
1. Run directly into wall at MaxSpeed
|
|
2. Observe sweep collision
|
|
3. Check collision response
|
|
|
|
**Expected Results:**
|
|
- [ ] Character stops at wall surface
|
|
- [ ] No tunneling through wall
|
|
- [ ] Is Blocked: `true`
|
|
- [ ] Collision Count: >0 (visible in debug)
|
|
- [ ] Visual debug shows red hit marker at impact point
|
|
- [ ] Character position: exactly at wall surface
|
|
|
|
**Collision Accuracy:**
|
|
- [ ] No penetration into wall geometry
|
|
- [ ] Stop position consistent across tests
|
|
|
|
**Pass Criteria:** Perfect collision stop ✅
|
|
|
|
---
|
|
|
|
### Test 4.2: Surface Sliding (Angled Wall)
|
|
**Objective:** Verify slide vector calculation
|
|
|
|
**Procedure:**
|
|
1. Run into wall at 45° angle
|
|
2. Observe sliding behavior
|
|
3. Test various angles
|
|
|
|
**Expected Results:**
|
|
- [ ] Character slides along wall surface
|
|
- [ ] Slide direction perpendicular to hit normal
|
|
- [ ] No stuck behavior
|
|
- [ ] Smooth sliding motion
|
|
- [ ] Speed maintained during slide
|
|
|
|
**Test Angles:**
|
|
- 15° angle: Mostly forward, slight slide
|
|
- 45° angle: Equal forward + slide
|
|
- 75° angle: Mostly slide, little forward
|
|
|
|
**Pass Criteria:** Smooth sliding on all angles ✅
|
|
|
|
---
|
|
|
|
### Test 4.3: Corner Navigation
|
|
**Objective:** Verify multi-collision handling
|
|
|
|
**Procedure:**
|
|
1. Run into 90° corner (two walls meeting)
|
|
2. Attempt to move into corner
|
|
3. Observe collision response
|
|
|
|
**Expected Results:**
|
|
- [ ] Character stops cleanly at corner
|
|
- [ ] No jittering or oscillation
|
|
- [ ] Collision Count reasonable (<MaxCollisionChecks)
|
|
- [ ] Character doesn't get stuck
|
|
- [ ] Can back away from corner
|
|
|
|
**Pass Criteria:** Corner handling smooth ✅
|
|
|
|
---
|
|
|
|
### Test 4.4: Swept Collision Precision
|
|
**Objective:** Verify tunneling prevention
|
|
|
|
**Test Setup:**
|
|
1. Create thin wall (10 cm thick)
|
|
2. Set MaxSpeed very high (2000 cm/s) temporarily
|
|
|
|
**Procedure:**
|
|
1. Run at thin wall at max speed
|
|
2. Verify no tunneling
|
|
3. Check collision detection
|
|
|
|
**Expected Results:**
|
|
- [ ] No tunneling through thin geometry
|
|
- [ ] Swept trace catches all collisions
|
|
- [ ] Adaptive step size working
|
|
- [ ] Collision Count increases with speed
|
|
- [ ] Character always stops at surface
|
|
|
|
**Performance Check:**
|
|
- [ ] Collision Count < MaxCollisionChecks (25)
|
|
- [ ] Frame time acceptable (<2ms)
|
|
|
|
**Pass Criteria:** No tunneling at high speeds ✅
|
|
|
|
---
|
|
|
|
### Test 4.5: Collision Check Limit
|
|
**Objective:** Verify MaxCollisionChecks safety
|
|
|
|
**Test Setup:**
|
|
1. Create complex collision geometry (many overlapping walls)
|
|
2. Set MinStepSize = 1.0 (fine precision)
|
|
|
|
**Procedure:**
|
|
1. Move through complex area
|
|
2. Monitor Collision Count
|
|
3. Verify limit prevents infinite loop
|
|
|
|
**Expected Results:**
|
|
- [ ] Collision Count never exceeds MaxCollisionChecks (25)
|
|
- [ ] No freezing or infinite loops
|
|
- [ ] Movement continues even if limit hit
|
|
- [ ] Character may stop short but doesn't hang
|
|
|
|
**Debug HUD Check:**
|
|
- Collision Checks: X/25
|
|
- Should rarely hit 25 in normal gameplay
|
|
|
|
**Pass Criteria:** Limit prevents hangs ✅
|
|
|
|
---
|
|
|
|
## TEST SUITE 5: State Machine
|
|
|
|
### Test 5.1: Idle → Walking Transition
|
|
**Objective:** Verify state transition on input
|
|
|
|
**Procedure:**
|
|
1. Start in Idle state (no input)
|
|
2. Press W (forward)
|
|
3. Observe state change
|
|
|
|
**Expected Results:**
|
|
- [ ] Movement State: `Idle` → `Walking`
|
|
- [ ] Transition occurs when:
|
|
- Input Magnitude > 0.01
|
|
- Speed > 1.0 cm/s
|
|
- [ ] Clean transition, no flicker
|
|
|
|
**Pass Criteria:** Transition instant and clean ✅
|
|
|
|
---
|
|
|
|
### Test 5.2: Walking → Idle Transition
|
|
**Objective:** Verify state transition on input release
|
|
|
|
**Procedure:**
|
|
1. Reach Walking state (moving)
|
|
2. Release all input
|
|
3. Observe state change
|
|
|
|
**Expected Results:**
|
|
- [ ] Movement State: `Walking` → `Idle`
|
|
- [ ] Transition occurs when:
|
|
- Input Magnitude ≤ 0.01
|
|
- Speed ≤ 1.0 cm/s (after friction)
|
|
- [ ] Brief delay due to friction deceleration
|
|
|
|
**Pass Criteria:** Transition smooth after stop ✅
|
|
|
|
---
|
|
|
|
### Test 5.3: Walking → Airborne Transition
|
|
**Objective:** Verify state change when leaving ground
|
|
|
|
**Procedure:**
|
|
1. Walk off platform edge
|
|
2. Observe immediate state change
|
|
|
|
**Expected Results:**
|
|
- [ ] Movement State: `Walking` → `Airborne`
|
|
- [ ] Transition instant (same frame as IsGrounded = false)
|
|
- [ ] No intermediate states
|
|
|
|
**Pass Criteria:** Instant transition ✅
|
|
|
|
---
|
|
|
|
### Test 5.4: Airborne → Walking Transition
|
|
**Objective:** Verify landing state change
|
|
|
|
**Procedure:**
|
|
1. Fall/jump and land
|
|
2. Have forward input during landing
|
|
|
|
**Expected Results:**
|
|
- [ ] Movement State: `Airborne` → `Walking`
|
|
- [ ] If input present: lands in Walking
|
|
- [ ] If no input: lands in Idle
|
|
- [ ] Speed preserved from air movement
|
|
|
|
**Pass Criteria:** Landing state correct ✅
|
|
|
|
---
|
|
|
|
### Test 5.5: Walking → Blocked Transition
|
|
**Objective:** Verify blocked state on collision
|
|
|
|
**Procedure:**
|
|
1. Run into wall
|
|
2. Observe state change
|
|
|
|
**Expected Results:**
|
|
- [ ] Movement State: `Walking` → `Blocked`
|
|
- [ ] Occurs when:
|
|
- Sweep collision detected
|
|
- Is Blocked = true
|
|
- [ ] State returns to Walking when moving away from wall
|
|
|
|
**Pass Criteria:** Blocked state triggers correctly ✅
|
|
|
|
---
|
|
|
|
### Test 5.6: Walking → Sliding Transition
|
|
**Objective:** Verify steep slope detection
|
|
|
|
**Test Setup:**
|
|
1. Create steep ramp (60°-85°)
|
|
|
|
**Procedure:**
|
|
1. Walk onto steep ramp
|
|
2. Observe state change
|
|
|
|
**Expected Results:**
|
|
- [ ] Movement State: `Walking` → `Sliding`
|
|
- [ ] Surface Type = `SteepSlope`
|
|
- [ ] State persists while on steep surface
|
|
|
|
**Note:** Sliding physics not implemented yet, but state should be set.
|
|
|
|
**Pass Criteria:** State classification correct ✅
|
|
|
|
---
|
|
|
|
## TEST SUITE 6: Data Flow & Architecture
|
|
|
|
### Test 6.1: State Immutability
|
|
**Objective:** Verify state is never mutated
|
|
|
|
**Procedure:**
|
|
1. Add debug logging in AC_Movement.ProcessMovementInput()
|
|
2. Log CurrentMovementState before ProcessMovement()
|
|
3. Log CurrentMovementState after ProcessMovement()
|
|
4. Move character
|
|
|
|
**Expected Results:**
|
|
- [ ] Old state object unchanged (log shows same values)
|
|
- [ ] New state object has different memory address
|
|
- [ ] State transformation is pure (same input → same output)
|
|
|
|
**Technical Check:**
|
|
```typescript
|
|
// Before
|
|
console.log(this.CurrentMovementState.Location);
|
|
const oldState = this.CurrentMovementState;
|
|
|
|
// Process
|
|
this.CurrentMovementState = BFL_MovementProcessor.ProcessMovement(...);
|
|
|
|
// After
|
|
console.log(oldState.Location === this.CurrentMovementState.Location); // false
|
|
```
|
|
|
|
**Pass Criteria:** State never mutated ✅
|
|
|
|
---
|
|
|
|
### Test 6.2: Pipeline Phase Execution
|
|
**Objective:** Verify all 6 phases execute in order
|
|
|
|
**Procedure:**
|
|
1. Add debug logging in BFL_MovementProcessor.ProcessMovement()
|
|
2. Log entry to each phase
|
|
3. Move character
|
|
4. Verify log output
|
|
|
|
**Expected Phases (in order):**
|
|
- [ ] PHASE 1: Input & Rotation
|
|
- [ ] PHASE 2: Ground Detection
|
|
- [ ] PHASE 3: Physics Calculation
|
|
- [ ] PHASE 4: Movement Application (Sweep)
|
|
- [ ] PHASE 5: Ground Snapping
|
|
- [ ] PHASE 6: State Determination
|
|
|
|
**Log Output Example:**
|
|
```
|
|
[ProcessMovement] PHASE 1: Input & Rotation
|
|
[ProcessMovement] PHASE 2: Ground Detection
|
|
[ProcessMovement] PHASE 3: Physics Calculation
|
|
[ProcessMovement] PHASE 4: Movement Application
|
|
[ProcessMovement] PHASE 5: Ground Snapping
|
|
[ProcessMovement] PHASE 6: State Determination
|
|
[ProcessMovement] Return new state
|
|
```
|
|
|
|
**Pass Criteria:** All phases execute in correct order ✅
|
|
|
|
---
|
|
|
|
### Test 6.3: Subsystem Independence
|
|
**Objective:** Verify modules don't have hidden dependencies
|
|
|
|
**Procedure:**
|
|
1. Test each BFL_* module in isolation (if possible via unit tests)
|
|
2. Verify no shared global state
|
|
3. Confirm pure function behavior
|
|
|
|
**Modules to Test:**
|
|
- [ ] BFL_Kinematics (pure physics math)
|
|
- [ ] BFL_RotationController (pure rotation math)
|
|
- [ ] BFL_SurfaceClassifier (pure classification)
|
|
- [ ] BFL_MovementStateMachine (pure FSM logic)
|
|
|
|
**Expected Results:**
|
|
- [ ] Each module works independently
|
|
- [ ] No unexpected side effects
|
|
- [ ] Same input always produces same output (determinism)
|
|
|
|
**Pass Criteria:** Full module independence ✅
|
|
|
|
---
|
|
|
|
### Test 6.4: Configuration Isolation
|
|
**Objective:** Verify DA_MovementConfig is read-only
|
|
|
|
**Procedure:**
|
|
1. Create two characters with different configs
|
|
2. Change MaxSpeed on Character A
|
|
3. Verify Character B unaffected
|
|
|
|
**Expected Results:**
|
|
- [ ] Character A uses Config A
|
|
- [ ] Character B uses Config B
|
|
- [ ] No config bleeding between instances
|
|
- [ ] Each AC_Movement has own Config instance
|
|
|
|
**Pass Criteria:** Config properly isolated ✅
|
|
|
|
---
|
|
|
|
## TEST SUITE 7: Debug & Visualization
|
|
|
|
### Test 7.1: Debug HUD Updates
|
|
**Objective:** Verify all debug fields update in real-time
|
|
|
|
**Procedure:**
|
|
1. Enable debug HUD
|
|
2. Perform various movements
|
|
3. Observe all fields updating
|
|
|
|
**Fields to Verify:**
|
|
- [ ] Current Velocity (changes with movement)
|
|
- [ ] Speed (0-800 range)
|
|
- [ ] Is Grounded (true/false toggle)
|
|
- [ ] Surface Type (changes on different surfaces)
|
|
- [ ] Movement State (FSM state transitions)
|
|
- [ ] Input Magnitude (0-1 range)
|
|
- [ ] Current Yaw (rotation angle)
|
|
- [ ] Rotation Delta (decreases to 0)
|
|
- [ ] Is Rotating (true/false)
|
|
- [ ] Collision Checks (varies with speed)
|
|
- [ ] Sweep Blocked (true when hitting wall)
|
|
|
|
**Update Frequency:**
|
|
- Should update every frame
|
|
- No stale data
|
|
- Smooth value transitions
|
|
|
|
**Pass Criteria:** All fields live and accurate ✅
|
|
|
|
---
|
|
|
|
### Test 7.2: Visual Debug (Traces)
|
|
**Objective:** Verify debug trace rendering
|
|
|
|
**Procedure:**
|
|
1. Enable ShowVisualDebug = true
|
|
2. Move character
|
|
3. Observe visual traces in world
|
|
|
|
**Expected Traces:**
|
|
- [ ] Ground trace (downward line from capsule)
|
|
- Green if hit
|
|
- Red if no hit
|
|
- [ ] Swept collision traces (capsule path)
|
|
- Multiple traces showing steps
|
|
- Red markers at collision points
|
|
- [ ] Traces persist briefly (ForDuration mode)
|
|
|
|
**Pass Criteria:** Visual debug clear and helpful ✅
|
|
|
|
---
|
|
|
|
### Test 7.3: Config Display
|
|
**Objective:** Verify config constants shown in debug
|
|
|
|
**Procedure:**
|
|
1. Open debug HUD
|
|
2. Verify all config values visible
|
|
|
|
**Constants to Check:**
|
|
- [ ] Max Speed: 800.0
|
|
- [ ] Acceleration: 10.0
|
|
- [ ] Friction: 8.0
|
|
- [ ] Gravity: 980.0
|
|
- [ ] Rotation Speed: 360.0
|
|
- [ ] Min Speed For Rotation: 50.0
|
|
- [ ] Ground Trace Distance: 50.0
|
|
|
|
**Pass Criteria:** All config values accurate ✅
|
|
|
|
---
|
|
|
|
## TEST SUITE 8: Performance
|
|
|
|
### Test 8.1: Frame Time
|
|
**Objective:** Verify movement processing stays under budget
|
|
|
|
**Procedure:**
|
|
1. Enable UE profiler (stat game)
|
|
2. Move character continuously
|
|
3. Observe AC_Movement tick time
|
|
|
|
**Expected Results:**
|
|
- [ ] Average frame time: 0.3-0.7ms
|
|
- [ ] Max frame time: <1.5ms
|
|
- [ ] No spikes above 2ms
|
|
- [ ] Consistent performance
|
|
|
|
**Budget:** <1ms target for 60 FPS
|
|
|
|
**Pass Criteria:** Performance within budget ✅
|
|
|
|
---
|
|
|
|
### Test 8.2: Collision Check Count
|
|
**Objective:** Verify sweep efficiency
|
|
|
|
**Procedure:**
|
|
1. Move at various speeds
|
|
2. Monitor Collision Count in debug HUD
|
|
3. Test complex geometry
|
|
|
|
**Expected Results:**
|
|
- [ ] Low speed: 1-3 checks
|
|
- [ ] Medium speed: 3-8 checks
|
|
- [ ] High speed: 8-15 checks
|
|
- [ ] Complex geometry: <20 checks
|
|
- [ ] Never hits MaxCollisionChecks (25) in normal gameplay
|
|
|
|
**Pass Criteria:** Checks reasonable for speed ✅
|
|
|
|
---
|
|
|
|
### Test 8.3: Ground Trace Frequency
|
|
**Objective:** Verify ground detection cost
|
|
|
|
**Procedure:**
|
|
1. Profile LineTraceByChannel calls
|
|
2. Verify one trace per frame
|
|
|
|
**Expected Results:**
|
|
- [ ] Exactly 1 ground trace per frame
|
|
- [ ] Trace executes even when airborne (for landing detection)
|
|
- [ ] Trace cost: <0.1ms
|
|
|
|
**Pass Criteria:** Trace frequency optimal ✅
|
|
|
|
---
|
|
|
|
## TEST SUITE 9: Edge Cases
|
|
|
|
### Test 9.1: Initialization Check
|
|
**Objective:** Verify system handles uninitialized state
|
|
|
|
**Procedure:**
|
|
1. Create AC_Movement without calling InitializeMovementSystem()
|
|
2. Call ProcessMovementInput()
|
|
3. Verify graceful handling
|
|
|
|
**Expected Results:**
|
|
- [ ] IsInitialized = false
|
|
- [ ] ProcessMovementInput() returns early (no processing)
|
|
- [ ] No crash or error
|
|
- [ ] Character doesn't move
|
|
|
|
**Pass Criteria:** Graceful handling of no-init ✅
|
|
|
|
---
|
|
|
|
### Test 9.2: Null CapsuleComponent
|
|
**Objective:** Verify handling of missing capsule
|
|
|
|
**Procedure:**
|
|
1. Initialize with CapsuleComponent = null
|
|
2. Attempt movement
|
|
3. Verify system behavior
|
|
|
|
**Expected Results:**
|
|
- [ ] No crash
|
|
- [ ] Collision detection skips (no traces)
|
|
- [ ] Character may move without collision
|
|
- [ ] Ground detection returns empty HitResult
|
|
|
|
**Pass Criteria:** No crash, graceful degradation ✅
|
|
|
|
---
|
|
|
|
### Test 9.3: Zero DeltaTime
|
|
**Objective:** Verify handling of edge case time
|
|
|
|
**Procedure:**
|
|
1. Pass DeltaTime = 0.0 to ProcessMovementInput()
|
|
2. Observe behavior
|
|
|
|
**Expected Results:**
|
|
- [ ] No division by zero errors
|
|
- [ ] No NaN values in velocity
|
|
- [ ] State remains stable
|
|
- [ ] No movement applied
|
|
|
|
**Pass Criteria:** Zero deltatime handled ✅
|
|
|
|
---
|
|
|
|
### Test 9.4: Extreme Velocity
|
|
**Objective:** Verify handling of very high speeds
|
|
|
|
**Procedure:**
|
|
1. Temporarily set MaxSpeed = 5000 cm/s
|
|
2. Reach max speed
|
|
3. Observe collision system
|
|
|
|
**Expected Results:**
|
|
- [ ] Swept collision still works
|
|
- [ ] No tunneling
|
|
- [ ] Collision Count increases (more steps needed)
|
|
- [ ] May hit MaxCollisionChecks, but no crash
|
|
- [ ] Performance acceptable
|
|
|
|
**Pass Criteria:** System stable at high speeds ✅
|
|
|
|
---
|
|
|
|
### Test 9.5: Rapid Direction Changes
|
|
**Objective:** Verify stability with chaotic input
|
|
|
|
**Procedure:**
|
|
1. Rapidly alternate between W and S (forward/back)
|
|
2. Spin mouse rapidly while moving
|
|
3. Mash all WASD keys randomly
|
|
|
|
**Expected Results:**
|
|
- [ ] No crashes or errors
|
|
- [ ] Velocity responds to input changes
|
|
- [ ] Rotation updates smoothly
|
|
- [ ] No state machine flicker
|
|
- [ ] Character remains stable
|
|
|
|
**Pass Criteria:** Stable under chaos ✅
|
|
|
|
---
|
|
|
|
## TEST SUITE 10: Regression Tests
|
|
|
|
### Test 10.1: Behavior Parity with Pre-Refactor
|
|
**Objective:** Verify refactoring preserved behavior
|
|
|
|
**Setup:**
|
|
1. Record video of movement BEFORE refactor
|
|
2. Record video of movement AFTER refactor
|
|
3. Compare side-by-side
|
|
|
|
**Scenarios to Compare:**
|
|
- [ ] Acceleration from idle
|
|
- [ ] Deceleration to stop
|
|
- [ ] Rotation speed
|
|
- [ ] Wall collision
|
|
- [ ] Surface sliding
|
|
- [ ] Ground detection
|
|
|
|
**Expected Results:**
|
|
- [ ] Identical acceleration curves
|
|
- [ ] Same rotation speed
|
|
- [ ] Identical collision response
|
|
- [ ] No behavioral regressions
|
|
|
|
**Pass Criteria:** Behavior 100% identical ✅
|
|
|
|
---
|
|
|
|
### Test 10.2: Config Compatibility
|
|
**Objective:** Verify DA_MovementConfig unchanged
|
|
|
|
**Procedure:**
|
|
1. Load old config asset (pre-refactor)
|
|
2. Apply to new AC_Movement
|
|
3. Verify all values apply correctly
|
|
|
|
**Expected Results:**
|
|
- [ ] All config values load correctly
|
|
- [ ] No missing or new required fields
|
|
- [ ] Behavior matches config settings
|
|
- [ ] No migration needed
|
|
|
|
**Pass Criteria:** Full config backward compatibility ✅
|
|
|
|
---
|
|
|
|
## TEST SUITE 11: Integration Tests
|
|
|
|
### Test 11.1: BP_MainCharacter Integration
|
|
**Objective:** Verify AC_Movement works in character context
|
|
|
|
**Procedure:**
|
|
1. Place BP_MainCharacter in level
|
|
2. Play as character
|
|
3. Test full movement suite
|
|
|
|
**Expected Results:**
|
|
- [ ] All movement tests pass in character context
|
|
- [ ] Input processing works correctly
|
|
- [ ] Camera-relative movement correct
|
|
- [ ] Animation system receives correct state (if implemented)
|
|
|
|
**Pass Criteria:** Full character integration ✅
|
|
|
|
---
|
|
|
|
### Test 11.2: Multiple Characters
|
|
**Objective:** Verify no state bleeding between instances
|
|
|
|
**Procedure:**
|
|
1. Spawn 3 BP_MainCharacters
|
|
2. Move each independently
|
|
3. Verify no interference
|
|
|
|
**Expected Results:**
|
|
- [ ] Each character has independent state
|
|
- [ ] No shared global state
|
|
- [ ] Collision between characters works
|
|
- [ ] Each character responds to own input
|
|
|
|
**Pass Criteria:** Full instance isolation ✅
|
|
|
|
---
|
|
|
|
## Testing Summary
|
|
|
|
### Critical Tests (Must Pass)
|
|
1. ✅ Basic Movement (1.1-1.7)
|
|
2. ✅ Ground Detection (2.1-2.4)
|
|
3. ✅ Wall Collision (4.1)
|
|
4. ✅ State Immutability (6.1)
|
|
5. ✅ Behavior Parity (10.1)
|
|
|
|
### Important Tests (Should Pass)
|
|
1. Surface Classification (3.1-3.4)
|
|
2. Surface Sliding (4.2)
|
|
3. State Machine (5.1-5.6)
|
|
4. Debug Visualization (7.1-7.3)
|
|
|
|
### Performance Tests (Target)
|
|
1. Frame Time <1ms (8.1)
|
|
2. Collision Checks Reasonable (8.2)
|
|
|
|
### Edge Case Tests (Nice to Have)
|
|
1. Null handling (9.1-9.2)
|
|
2. Extreme conditions (9.3-9.5)
|
|
|
|
---
|
|
|
|
## Test Results Template
|
|
|
|
### Test Session Info
|
|
- **Date:** ___________
|
|
- **Tester:** ___________
|
|
- **Build:** ___________
|
|
- **Level:** ___________
|
|
|
|
### Summary
|
|
- **Tests Run:** ___ / 60
|
|
- **Tests Passed:** ___ / ___
|
|
- **Tests Failed:** ___ / ___
|
|
- **Critical Failures:** ___
|
|
|
|
### Failed Tests
|
|
1. Test X.X: [Description]
|
|
- **Expected:** [...]
|
|
- **Actual:** [...]
|
|
- **Severity:** Critical / High / Medium / Low
|
|
|
|
### Performance Metrics
|
|
- **Average Frame Time:** ___ms
|
|
- **Max Frame Time:** ___ms
|
|
- **Avg Collision Checks:** ___
|
|
- **Max Collision Checks:** ___
|
|
|
|
### Notes
|
|
[Any additional observations or issues]
|
|
|
|
---
|
|
|
|
## Sign-Off
|
|
|
|
### Approval Criteria
|
|
- [ ] All Critical Tests passed
|
|
- [ ] No Critical or High severity failures
|
|
- [ ] Performance within budget
|
|
- [ ] Behavior matches specification
|
|
- [ ] No regressions detected
|
|
|
|
### Approved By
|
|
- **Developer:** ___________ Date: ___________
|
|
- **QA:** ___________ Date: ___________
|
|
|
|
---
|
|
|
|
## Conclusion
|
|
|
|
This comprehensive manual testing checklist ensures the refactored Movement System maintains behavior parity while validating the new architecture. Focus on Critical Tests first, then expand to full coverage.
|
|
|
|
**Estimated Testing Time:** 2-3 hours for full suite
|
|
|
|
**Recommended Approach:**
|
|
1. Day 1: Critical Tests (Suite 1-2, 6.1, 10.1)
|
|
2. Day 2: Important Tests (Suite 3-5, 7)
|
|
3. Day 3: Performance & Edge Cases (Suite 8-9)
|
|
|
|
Good luck testing! 🎮
|