Config/DefaultEngine.ini

@@ -26,7 +26,6 @@ r.DefaultFeature.AutoExposure.ExtendDefaultLuminanceRange=True
 r.DefaultFeature.LocalExposure.HighlightContrastScale=0.8
 
 r.DefaultFeature.LocalExposure.ShadowContrastScale=0.8
-r.DefaultFeature.MotionBlur=False
 
 [/Script/WindowsTargetPlatform.WindowsTargetSettings]
 DefaultGraphicsRHI=DefaultGraphicsRHI_DX12
@@ -97,4 +96,3 @@ ManualIPAddress=
 
 [CoreRedirects]
 +ClassRedirects=(OldName="/Script/TengriPlatformer.UTengriCollisionResolver",NewName="/Script/TengriPlatformer.TengriCollisionResolver")
-

Content/Blueprints/BP_MainCharacter.ts

@@ -1,5 +1,6 @@
 // Content/Blueprints/BP_MainCharacter.ts
 
+import { AC_Camera } from '/Content/Camera/AC_Camera.ts';
 import { AC_DebugHUD } from '/Content/Debug/Components/AC_DebugHUD.ts';
 import { AC_InputDevice } from '/Content/Input/Components/AC_InputDevice.ts';
 import { IMC_Default } from '/Content/Input/IMC_Default.ts';
@@ -10,8 +11,11 @@ import { EnhancedInputLocalPlayerSubsystem } from '/Content/UE/EnhancedInputLoca
 import type { Float } from '/Content/UE/Float.ts';
 import { MathLibrary } from '/Content/UE/MathLibrary.ts';
 import type { PlayerController } from '/Content/UE/PlayerController.ts';
+import { Rotator } from '/Content/UE/Rotator.ts';
 import { SystemLibrary } from '/Content/UE/SystemLibrary.ts';
 import { Vector } from '/Content/UE/Vector.ts';
+import { TengriMovementComponent } from '/Source/TengriPlatformer/Movement/TengriMovementComponent.ts';
+import { DA_TengriMovementConfig } from '/Content/Movement/DA_TengriMovementConfig.ts';
 import { TengriCharacter } from '/Source/TengriPlatformer/Character/TengriCharacter.ts';
 import { IA_Interact } from '/Content/Input/Actions/IA_Inreract.ts';
 import { IA_Throw } from '/Content/Input/Actions/IA_Throw.ts';
@@ -19,9 +23,9 @@ import { IA_Aim } from '/Content/Input/Actions/IA_Aim.ts';
 import { IMC_ItemHeld } from '/Content/Input/IMC_ItemHeld.ts';
 import { CreateWidget } from '/Content/UE/CteateWidget.ts';
 import { WBP_HUD } from '/Content/UI/WBP_HUD.ts';
+import { SpringArmComponent } from '/Content/UE/SpringArmComponent.ts';
+import { LinearColor } from '/Content/UE/LinearColor.ts';
 import { CustomDefaultSkeletalMesh } from '/Content/BasicShapes/CustomDefaultSkeletalMesh.ts';
-import { ETengriCameraBehavior } from '/Source/TengriPlatformer/Camera/Core/TengriCameraConfig.ts';
-import { DA_CameraAiming } from '/Content/Camera/DA_CameraAiming.ts';
 
 /**
  * Main Character Blueprint
@@ -86,13 +90,17 @@ export class BP_MainCharacter extends TengriCharacter {
     actionValueX: Float,
     actionValueY: Float
   ): void {
-    if (
+    this.CameraComponent.ProcessLookInput(
-      this.CameraManager.CurrentConfig.BehaviorType ===
+      new Vector(actionValueX, actionValueY, 0),
-      ETengriCameraBehavior.FreeLook
+      this.DeltaTime
-    ) {
+    );
-      this.AddControllerYawInput(actionValueX);
+  }
-      this.AddControllerPitchInput(actionValueY);
+
-    }
+  /**
+   * Reset look input when look action is completed
+   */
+  EnhancedInputActionLookCompleted(): void {
+    this.CameraComponent.ProcessLookInput(new Vector(0, 0, 0), this.DeltaTime);
   }
 
   /**
@@ -124,7 +132,7 @@ export class BP_MainCharacter extends TengriCharacter {
       return new Vector(vec1.X + vec2.X, vec1.Y + vec2.Y, 0);
     };
 
-    this.MovementComponent.SetInputVector(
+    this.TengriMovement.SetInputVector(
       CalculateResultMovementInputVector(
         MathLibrary.GetRightVector(
           this.GetControlRotation().roll,
@@ -142,7 +150,7 @@ export class BP_MainCharacter extends TengriCharacter {
    * Reset movement input when move action is completed
    */
   EnhancedInputActionMoveCompleted(): void {
-    this.MovementComponent.SetInputVector(new Vector(0, 0, 0));
+    this.TengriMovement.SetInputVector(new Vector(0, 0, 0));
   }
 
   EnhancedInputActionJumpTriggered(): void {
@@ -153,6 +161,24 @@ export class BP_MainCharacter extends TengriCharacter {
     this.MovementComponent.SetJumpInput(false);
   }
 
+  MovementComponentOnLanded(IsHeavy: boolean): void {
+    if (IsHeavy) {
+      SystemLibrary.PrintString(
+        'Boom! (Heavy)',
+        true,
+        true,
+        new LinearColor(1, 0, 0, 1)
+      );
+    } else {
+      SystemLibrary.PrintString(
+        'Tap (Light)',
+        true,
+        true,
+        new LinearColor(0, 1, 0, 1)
+      );
+    }
+  }
+
   /**
    * Initialize all systems when character spawns
    * Order: Toast → Debug → Movement (movement last as it may generate debug output)
@@ -174,6 +200,11 @@ export class BP_MainCharacter extends TengriCharacter {
       );
     }
 
+    this.CameraComponent.InitializeCameraSystem(
+      this.InputDeviceComponent,
+      this.DebugHUDComponent
+    );
+
     CreateWidget(WBP_HUD).AddToViewport();
   }
 
@@ -181,21 +212,60 @@ export class BP_MainCharacter extends TengriCharacter {
    * Update all systems each frame
    * Called by Unreal Engine game loop
    */
-  EventTick(): void {
+  EventTick(DeltaTime: Float): void {
+    this.DeltaTime = DeltaTime;
+
     if (this.ShowDebugInfo) {
       this.DebugHUDComponent.UpdateHUD(SystemLibrary.GetGameTimeInSeconds());
       this.ToastSystemComponent.UpdateToastSystem();
     }
 
+    this.CameraComponent.UpdateCameraRotation(DeltaTime);
+
+    this.GetController().SetControlRotation(
+      new Rotator(
+        0,
+        this.CameraComponent.GetCameraRotation().Pitch,
+        this.CameraComponent.GetCameraRotation().Yaw
+      )
+    );
+
     if (this.ShowDebugInfo) {
       this.InputDeviceComponent.UpdateDebugPage();
+      this.CameraComponent.UpdateDebugPage();
     }
+
+    this.SpringArm.TargetArmLength = MathLibrary.FInterpTo(
+      this.SpringArm.TargetArmLength,
+      this.bIsAiming ? this.AimArmLength : this.DefaultArmLength,
+      DeltaTime,
+      10.0
+    );
+
+    this.SpringArm.TargetOffset = MathLibrary.VInterpTo(
+      this.SpringArm.TargetOffset,
+      this.bIsAiming ? this.AimSocketOffset : this.DefaultSocketOffset,
+      DeltaTime,
+      10.0
+    );
   }
 
   // ════════════════════════════════════════════════════════════════════════════════════════
   //                                    VARIABLES
   // ════════════════════════════════════════════════════════════════════════════════════════
 
+  /**
+   * Camera system component - handles camera rotation and sensitivity
+   * @category Components
+   */
+  SpringArm = new SpringArmComponent();
+
+  /**
+   * Camera system component - handles camera rotation and sensitivity
+   * @category Components
+   */
+  CameraComponent = new AC_Camera();
+
   /**
    * Input device detection component - manages input device state and detection
    * @category Components
@@ -208,6 +278,10 @@ export class BP_MainCharacter extends TengriCharacter {
    */
   ToastSystemComponent = new AC_ToastSystem();
 
+  TengriMovement = new TengriMovementComponent({
+    MovementConfig: DA_TengriMovementConfig,
+  });
+
   /**
    * Debug HUD system - displays movement parameters and performance metrics
    * @category Components
@@ -221,8 +295,37 @@ export class BP_MainCharacter extends TengriCharacter {
    */
   private ShowDebugInfo: boolean = true;
 
+  /**
+   * @category Camera
+   * @instanceEditable true
+   */
+  private readonly DefaultArmLength: Float = 400.0;
+
+  /**
+   * @category Camera
+   * @instanceEditable true
+   */
+  private readonly AimArmLength: Float = 250.0;
+
+  /**
+   * @category Camera
+   * @instanceEditable true
+   */
+  private readonly DefaultSocketOffset: Vector = new Vector(0.0, 0.0, 0.0);
+
+  /**
+   * @category Camera
+   * @instanceEditable true
+   */
+  private readonly AimSocketOffset: Vector = new Vector(0.0, 100.0, 60.0);
+
+  /**
+   * Cached delta time from last tick - used for time-based calculations
+   */
+  private DeltaTime: Float = 0.0;
+
   constructor() {
-    super(new DA_CameraAiming());
+    super();
 
     this.InteractAction = IA_Interact;
     this.ThrowAction = IA_Throw;

Content/Camera/AC_Camera.ts

@@ -0,0 +1,323 @@
+// Content/Camera/Components/AC_Camera.ts
+
+import type { AC_DebugHUD } from '/Content/Debug/Components/AC_DebugHUD.ts';
+import type { AC_InputDevice } from '/Content/Input/Components/AC_InputDevice.ts';
+import { ActorComponent } from '/Content/UE/ActorComponent.ts';
+import type { Float } from '/Content/UE/Float.ts';
+import { MathLibrary } from '/Content/UE/MathLibrary.ts';
+import { SystemLibrary } from '/Content/UE/SystemLibrary.ts';
+import { Vector } from '/Content/UE/Vector.ts';
+
+/**
+ * Camera System Component
+ * Deterministic camera control with smooth rotation and device-aware sensitivity
+ * Provides precise control over camera behavior for consistent experience
+ */
+export class AC_Camera extends ActorComponent {
+  // ════════════════════════════════════════════════════════════════════════════════════════
+  //                                    FUNCTIONS
+  // ════════════════════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Process look input and update camera rotation
+   * @param InputDelta - Input delta (X = Yaw, Y = Pitch)
+   * @param DeltaTime - Time since last frame
+   * @category Input Processing
+   */
+  public ProcessLookInput(InputDelta: Vector, DeltaTime: Float): void {
+    if (this.IsInitialized) {
+      const invertMultiplier = this.InvertYAxis ? -1.0 : 1.0;
+      let sensitivity: Float = 0;
+
+      if (SystemLibrary.IsValid(this.InputDeviceComponent)) {
+        sensitivity = this.InputDeviceComponent.IsGamepad()
+          ? this.GamepadSensitivity
+          : this.MouseSensitivity;
+      } else {
+        sensitivity = this.MouseSensitivity;
+      }
+
+      const CalculateTargetPitch = (
+        targetPitch: Float,
+        inputDeltaY: Float,
+        deltaTime: Float
+      ): Float =>
+        targetPitch - inputDeltaY * sensitivity * invertMultiplier * deltaTime;
+
+      const CalculateTargetYaw = (
+        targetYaw: Float,
+        inputDeltaX: Float,
+        deltaTime: Float
+      ): Float => targetYaw + inputDeltaX * sensitivity * deltaTime;
+
+      this.TargetPitch = MathLibrary.ClampFloat(
+        CalculateTargetPitch(this.TargetPitch, InputDelta.Y, DeltaTime),
+        this.PitchMin,
+        this.PitchMax
+      );
+
+      this.TargetYaw = CalculateTargetYaw(
+        this.TargetYaw,
+        InputDelta.X,
+        DeltaTime
+      );
+
+      this.InputMagnitude = MathLibrary.VectorLength(InputDelta);
+    }
+  }
+
+  /**
+   * Update camera rotation with smooth interpolation
+   * @param DeltaTime - Time since last frame
+   * @category Camera Updates
+   */
+  public UpdateCameraRotation(DeltaTime: Float): void {
+    if (this.IsInitialized) {
+      if (this.SmoothingSpeed > 0) {
+        // Smooth interpolation to target rotation
+        this.CurrentPitch = MathLibrary.FInterpTo(
+          this.CurrentPitch,
+          this.TargetPitch,
+          DeltaTime,
+          this.SmoothingSpeed
+        );
+
+        this.CurrentYaw = MathLibrary.FInterpTo(
+          this.CurrentYaw,
+          this.TargetYaw,
+          DeltaTime,
+          this.SmoothingSpeed
+        );
+      } else {
+        // Instant rotation (no smoothing)
+        this.CurrentPitch = this.TargetPitch;
+        this.CurrentYaw = this.TargetYaw;
+      }
+    }
+  }
+
+  /**
+   * Get current camera rotation for applying to SpringArm
+   * @returns Current camera rotation values
+   * @category Public Interface
+   * @pure true
+   */
+  public GetCameraRotation(): { Pitch: Float; Yaw: Float } {
+    return {
+      Pitch: this.CurrentPitch,
+      Yaw: this.CurrentYaw,
+    };
+  }
+
+  /**
+   * Check if camera is currently rotating
+   * @returns True if there's active rotation input
+   * @category State Queries
+   * @pure true
+   */
+  public IsCameraRotating(): boolean {
+    return this.InputMagnitude > 0.01;
+  }
+
+  /**
+   * Initialize camera system with default settings
+   * @category System Setup
+   */
+  public InitializeCameraSystem(
+    InputDeviceRef: AC_InputDevice,
+    DebugComponentRef: AC_DebugHUD
+  ): void {
+    this.InputDeviceComponent = InputDeviceRef;
+    this.DebugHUDComponent = DebugComponentRef;
+
+    this.IsInitialized = true;
+
+    if (SystemLibrary.IsValid(this.DebugHUDComponent)) {
+      this.DebugHUDComponent.AddDebugPage(
+        this.DebugPageID,
+        'Camera System',
+        60
+      );
+    }
+  }
+
+  /**
+   * Update debug HUD with current camera info
+   * @category Debug
+   */
+  public UpdateDebugPage(): void {
+    if (SystemLibrary.IsValid(this.DebugHUDComponent)) {
+      if (
+        this.DebugHUDComponent.ShouldUpdatePage(
+          this.DebugPageID,
+          SystemLibrary.GetGameTimeInSeconds()
+        )
+      ) {
+        this.DebugHUDComponent.UpdatePageContent(
+          this.DebugPageID,
+          `Current Device: ${SystemLibrary.IsValid(this.InputDeviceComponent) ? this.InputDeviceComponent.GetCurrentInputDevice() : 'Input Device Component Not Found'}\n` +
+            `Sensitivity: ${SystemLibrary.IsValid(this.InputDeviceComponent) && this.InputDeviceComponent.IsGamepad() ? this.GamepadSensitivity : this.MouseSensitivity}\n` +
+            `Pitch: ${this.GetCameraRotation().Pitch}°\n` +
+            `Yaw: ${this.GetCameraRotation().Yaw}°\n` +
+            `Is Rotating: ${this.IsCameraRotating() ? 'Yes' : 'No'}\n` +
+            `Smoothing: ${this.SmoothingSpeed}\n` +
+            `Invert Y: ${this.InvertYAxis ? 'Yes' : 'No'}`
+        );
+      }
+    }
+  }
+
+  /**
+   * Get camera configuration and state data for testing purposes
+   * Provides read-only access to private variables for automated tests
+   * Only includes essential data needed for test validation
+   * @category Debug
+   * @returns Object containing camera settings (sensitivity, pitch limits) for test assertions
+   */
+  public GetTestData(): {
+    MouseSensitivity: Float;
+    GamepadSensitivity: Float;
+    PitchMin: Float;
+    PitchMax: Float;
+  } {
+    return {
+      MouseSensitivity: this.MouseSensitivity,
+      GamepadSensitivity: this.GamepadSensitivity,
+      PitchMin: this.PitchMin,
+      PitchMax: this.PitchMax,
+    };
+  }
+
+  // ════════════════════════════════════════════════════════════════════════════════════════
+  //                                    VARIABLES
+  // ════════════════════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Mouse sensitivity multiplier for camera rotation
+   * Higher values result in faster camera movement with mouse input
+   * Typical range: 50.0 (slow) - 200.0 (fast)
+   * @category Camera Config
+   * @instanceEditable true
+   * @default 100.0
+   */
+  private readonly MouseSensitivity: Float = 100.0;
+
+  /**
+   * Gamepad sensitivity multiplier for camera rotation
+   * Higher than mouse sensitivity to compensate for analog stick precision
+   * Typical range: 100.0 (slow) - 300.0 (fast)
+   * @category Camera Config
+   * @instanceEditable true
+   * @default 150.0
+   */
+  private readonly GamepadSensitivity: Float = 150.0;
+
+  /**
+   * Invert vertical axis for camera rotation
+   * When true, pushing up on input rotates camera down and vice versa
+   * Common preference for flight-sim style controls
+   * @category Camera Config
+   * @instanceEditable true
+   * @default false
+   */
+  private readonly InvertYAxis: boolean = false;
+
+  /**
+   * Minimum pitch angle in degrees (looking down)
+   * Prevents camera from rotating beyond this angle
+   * Set to -89° to avoid gimbal lock at -90°
+   * @category Camera Config
+   * @instanceEditable true
+   * @default -89.0
+   */
+  private readonly PitchMin: Float = -89.0;
+
+  /**
+   * Maximum pitch angle in degrees (looking up)
+   * Prevents camera from rotating beyond this angle
+   * Set to +89° to avoid gimbal lock at +90°
+   * @category Camera Config
+   * @instanceEditable true
+   * @default 89.0
+   */
+  private readonly PitchMax: Float = 89.0;
+
+  /**
+   * Speed of smooth interpolation to target rotation
+   * Higher values make camera more responsive but less smooth
+   * Set to 0 for instant rotation without interpolation
+   * Typical range: 10.0 (smooth) - 30.0 (responsive)
+   * @category Camera Config
+   * @instanceEditable true
+   * @default 20.0
+   */
+  private readonly SmoothingSpeed: Float = 20.0;
+
+  /**
+   * Current pitch angle for rendering
+   * Smoothly interpolates towards TargetPitch based on SmoothingSpeed
+   * Updated every frame by UpdateCameraRotation()
+   * @category Camera State
+   */
+  private CurrentPitch: Float = 0;
+
+  /**
+   * Current yaw angle for rendering
+   * Smoothly interpolates towards TargetYaw based on SmoothingSpeed
+   * Updated every frame by UpdateCameraRotation()
+   * @category Camera State
+   */
+  private CurrentYaw: Float = 0;
+
+  /**
+   * Target pitch angle from player input
+   * Updated by ProcessLookInput() based on input delta
+   * Clamped to PitchMin/PitchMax range
+   * @category Camera State
+   */
+  private TargetPitch: Float = 0;
+
+  /**
+   * Target yaw angle from player input
+   * Updated by ProcessLookInput() based on input delta
+   * No clamping - can rotate freely beyond 360°
+   * @category Camera State
+   */
+  private TargetYaw: Float = 0;
+
+  /**
+   * Magnitude of current input vector
+   * Used by IsCameraRotating() to detect active camera input
+   * Cached to avoid recalculating VectorLength every frame
+   * @category Camera State
+   * @default 0.0
+   */
+  private InputMagnitude: Float = 0;
+
+  /**
+   * System initialization state flag
+   * @category Camera State
+   */
+  private IsInitialized: boolean = false;
+
+  /**
+   * Reference to input device component for device detection
+   * Set externally, used for sensitivity adjustments
+   * @category Components
+   */
+  public InputDeviceComponent: AC_InputDevice | null = null;
+
+  /**
+   * Reference to debug HUD component for displaying camera info
+   * Optional, used for debugging purposes
+   * @category Components
+   */
+  public DebugHUDComponent: AC_DebugHUD | null = null;
+
+  /**
+   * Debug page identifier for organizing debug output
+   * Used by debug HUD to categorize information
+   * @category Debug
+   */
+  public readonly DebugPageID: string = 'CameraInfo';
+}

Content/Camera/BP_CameraZone.ts

@@ -1,25 +0,0 @@
-// Content/Camera/BP_CameraZone.ts
-
-import { Actor } from '/Content/UE/Actor.ts';
-import type { TengriCharacter } from '/Source/TengriPlatformer/Character/TengriCharacter.ts';
-import type { TengriCameraConfig } from '/Source/TengriPlatformer/Camera/Core/TengriCameraConfig.ts';
-
-export class BP_CameraZone extends Actor {
-  constructor(ZoneConfig: TengriCameraConfig) {
-    super();
-
-    this.ZoneConfig = ZoneConfig;
-  }
-
-  EventActorBeginOverlap(OtherActor: Actor): void {
-    (OtherActor as TengriCharacter).CameraManager.SetCameraConfig(
-      this.ZoneConfig
-    );
-  }
-
-  EventActorEndOverlap(OtherActor: Actor): void {
-    (OtherActor as TengriCharacter).CameraManager.SetCameraConfig();
-  }
-
-  private readonly ZoneConfig: TengriCameraConfig;
-}

Content/Camera/DA_CameraAiming.ts

@@ -1,23 +0,0 @@
-import {
-  ETengriCameraBehavior,
-  TengriCameraConfig,
-} from '/Source/TengriPlatformer/Camera/Core/TengriCameraConfig.ts';
-import { Vector } from '/Content/UE/Vector.ts';
-import { Rotator } from '/Content/UE/Rotator.ts';
-
-export class DA_CameraAiming extends TengriCameraConfig {
-  override BehaviorType = ETengriCameraBehavior.FreeLook;
-
-  override FixedRotation = new Rotator(0, -15, -90);
-  override TargetArmLength = 250;
-  override SocketOffset = new Vector(0, 100, 60);
-
-  override TransitionSpeed = 2;
-
-  override bEnableLag = false;
-
-  override DeadZoneExtent = new Vector(200, 0, 150);
-  override DeadZoneOffset = new Vector(0, 0, 50);
-
-  override bDrawDebugBox = false;
-}

Content/Camera/DA_CameraDefault.ts

@@ -1,23 +0,0 @@
-import {
-  ETengriCameraBehavior,
-  TengriCameraConfig,
-} from '/Source/TengriPlatformer/Camera/Core/TengriCameraConfig.ts';
-import { Vector } from '/Content/UE/Vector.ts';
-import { Rotator } from '/Content/UE/Rotator.ts';
-
-export class DA_CameraDefault extends TengriCameraConfig {
-  override BehaviorType = ETengriCameraBehavior.FreeLook;
-
-  override FixedRotation = new Rotator(0, -15, -90);
-  override TargetArmLength = 400;
-  override SocketOffset = new Vector(0, 0, 0);
-
-  override TransitionSpeed = 2;
-
-  override bEnableLag = false;
-
-  override DeadZoneExtent = new Vector(200, 0, 150);
-  override DeadZoneOffset = new Vector(0, 0, 50);
-
-  override bDrawDebugBox = false;
-}

Content/Camera/DA_CameraScroller.ts

@@ -1,24 +0,0 @@
-import {
-  ETengriCameraBehavior,
-  TengriCameraConfig,
-} from '/Source/TengriPlatformer/Camera/Core/TengriCameraConfig.ts';
-import { Vector } from '/Content/UE/Vector.ts';
-import { Rotator } from '/Content/UE/Rotator.ts';
-
-export class DA_CameraScroller extends TengriCameraConfig {
-  override BehaviorType = ETengriCameraBehavior.FreeLook;
-
-  override FixedRotation = new Rotator(0, 0, 0);
-  override TargetArmLength = 1200;
-  override SocketOffset = new Vector(0, 0, 100);
-
-  override TransitionSpeed = 1.5;
-
-  override bEnableLag = true;
-  override LagSpeed = 5;
-
-  override DeadZoneExtent = new Vector(100, 300, 100);
-  override DeadZoneOffset = new Vector(0, 0, 50);
-
-  override bDrawDebugBox = false;
-}

Content/Movement/DA_TengriMovementConfig.ts

@@ -5,34 +5,20 @@ import { TengriMovementConfig } from '/Source/TengriPlatformer/Movement/Core/Ten
 export class DA_TengriMovementConfig extends TengriMovementConfig {
   override MaxSpeed = 800.0;
   override Acceleration = 2048.0;
-  override Friction = 6.0;
+  override Friction = 8.0;
+  override Gravity = 980.0;
   override RotationSpeed = 360.0;
   override MinSpeedForRotation = 10.0;
   override SteepSlopeSlideFactor = 0.0;
 
-  override MaxJumpHeight = 1000.0;
+  override CapsuleRadius = 34.0;
-  override MinJumpHeight = 40;
+  override CapsuleHalfHeight = 88.0;
-  override TimeToJumpApex = 0.5;
-
-  override CoyoteTime = 0.15;
-  override JumpBufferTime = 0.15;
-
-  override AirControl = 0.15;
-  override AirFriction = 0.1;
-  override FallingGravityScale = 1.5;
-  override TerminalVelocity = 2000;
-  override HeavyLandVelocityThreshold = -1000;
-
   override MaxSlideIterations = 3;
   override MaxStepHeight = 45.0;
 
   override GroundSnapDistance = 20.0;
   override GroundSnapOffset = 0.15;
 
-  override PhysicsTickRate = 120;
-  override MaxAccumulatedTime = 0.1;
-  override bEnableInterpolation = true;
-
   override WalkableAngleDeg = 50.0;
   override SteepSlopeAngleDeg = 85.0;
   override WallAngleDeg = 95.0;