# 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! 🎮