use external camera

lc-hax/Scripts/Components/CharacterMovement.cs

@@ -5,27 +5,34 @@
 using Hax;
 
 class CharacterMovement : MonoBehaviour {
-    // Movement constants
-    const float WalkingSpeed = 0.5f; // Walking speed when left control is held
-    const float SprintDuration = 0.0f; // Duration sprint key must be held for sprinting (adjust as needed)
+    const float WalkingSpeed = 0.5f;
+    const float SprintDuration = 0.0f;
     const float JumpForce = 9.2f;
     const float Gravity = 18.0f;
 
     internal float CharacterSpeed { get; set; } = 5.0f;
     internal float CharacterSprintSpeed { get; set; } = 2.8f;
-
-    // used to sync with the enemy to make sure it plays the correct animation when it is moving
+    internal bool CanMove { get; set; } = true;
     internal bool IsMoving { get; private set; } = false;
     internal bool IsSprinting { get; private set; } = false;
 
-    // Components and state variables
     float VelocityY { get; set; } = 0.0f;
-    bool IsSprintHeld { get; set; } = false;
     float SprintTimer { get; set; } = 0.0f;
-    Keyboard Keyboard { get; set; } = Keyboard.current;
-    KeyboardMovement? NoClipKeyboard { get; set; } = null;
+    bool IsSprintHeld { get; set; } = false;
+
+    Keyboard Keyboard { get; } = Keyboard.current;
+    KeyboardMovement? NoClipKeyboard { get; set; }
     CharacterController? CharacterController { get; set; }
 
+    void Awake() {
+        this.NoClipKeyboard = this.gameObject.AddComponent<KeyboardMovement>();
+        this.CharacterController = this.gameObject.AddComponent<CharacterController>();
+    }
+
+    void OnEnable() => InputListener.OnSpacePress += this.Jump;
+
+    void OnDisable() => InputListener.OnSpacePress -= this.Jump;
+
     internal void SetNoClipMode(bool enabled) {
         if (this.NoClipKeyboard is null) return;
         this.NoClipKeyboard.enabled = enabled;
@@ -44,7 +51,6 @@ internal void SetPosition(Vector3 newPosition) {
         this.CharacterController.enabled = true;
     }
 
-
     internal void CalibrateCollision(EnemyAI enemy) {
         if (this.CharacterController is null) return;
 
@@ -60,56 +66,11 @@ internal void CalibrateCollision(EnemyAI enemy) {
              .ForEach(collider => Physics.IgnoreCollision(this.CharacterController, collider));
     }
 
-
-    void Awake() {
-        this.Keyboard = Keyboard.current;
-        this.NoClipKeyboard = this.gameObject.AddComponent<KeyboardMovement>();
-        this.CharacterController = this.gameObject.AddComponent<CharacterController>();
-    }
-
-    // Update is called once per frame
-    void Update() {
-        if (this.NoClipKeyboard is { enabled: true }) return;
-        if (this.CharacterController is { enabled: false }) return;
-
-        Vector2 moveInput = new Vector2(
-            this.Keyboard.dKey.ReadValue() - this.Keyboard.aKey.ReadValue(),
-            this.Keyboard.wKey.ReadValue() - this.Keyboard.sKey.ReadValue()
-        ).normalized;
-
-        this.IsMoving = moveInput.magnitude > 0.0f;
-
-        float speedModifier = this.Keyboard.leftCtrlKey.isPressed
-            ? CharacterMovement.WalkingSpeed
-            : 1.0f;
-
-        // Calculate movement direction relative to character's forward direction
-        Vector3 forward = Vector3.ProjectOnPlane(this.transform.forward, Vector3.up);
-        Vector3 right = Vector3.ProjectOnPlane(this.transform.right, Vector3.up);
-        Vector3 moveDirection = (forward * moveInput.y) + (right * moveInput.x);
-
-        // Apply speed and sprint modifiers
-        moveDirection *= speedModifier * (
-            this.IsSprinting
-                ? this.CharacterSpeed * this.CharacterSprintSpeed
-                : this.CharacterSpeed
-            );
-
-        // Apply gravity
-        this.ApplyGravity();
-
-        // Attempt to move
-        _ = this.CharacterController?.Move(moveDirection * Time.deltaTime);
-
-        // Jump if jump key is pressed
-        if (this.Keyboard.spaceKey.wasPressedThisFrame) {
-            this.Jump();
-        }
-
-        // Sprinting mechanic: Hold to sprint
+    void Move(Vector3 moveDirection) {
+        if (Helper.LocalPlayer is { isTypingChat: true } || !this.CanMove) return;
         if (this.Keyboard.leftShiftKey.isPressed) {
             if (!this.IsSprintHeld) {
-                this.SprintTimer = 0f;
+                this.SprintTimer = 0.0f;
                 this.IsSprintHeld = true;
             }
 
@@ -122,23 +83,46 @@ void Update() {
 
         else {
             this.IsSprintHeld = false;
-
-            if (this.IsSprinting) {
-                this.IsSprinting = false;
-            }
+            this.IsSprinting = !this.IsSprinting;
         }
+
+        _ = this.CharacterController?.Move(moveDirection * Time.deltaTime);
+    }
+
+    Vector3 GetMovementDirection() {
+        Vector2 moveInput = new(
+            this.Keyboard.dKey.ReadValue() - this.Keyboard.aKey.ReadValue(),
+            this.Keyboard.wKey.ReadValue() - this.Keyboard.sKey.ReadValue()
+        );
+
+        float speedModifier = this.Keyboard.leftCtrlKey.isPressed ? CharacterMovement.WalkingSpeed : 1.0f;
+        float sprintModifier = this.IsSprinting ? this.CharacterSpeed * this.CharacterSprintSpeed : this.CharacterSpeed;
+
+        return sprintModifier * (
+            (this.transform.forward * moveInput.y) +
+            (this.transform.right * moveInput.x * speedModifier)
+        );
+    }
+
+    void Update() {
+        if (this.NoClipKeyboard is { enabled: true }) return;
+        if (this.CharacterController is { enabled: false }) return;
+
+        Vector3 moveDirection = this.GetMovementDirection();
+        this.IsMoving = moveDirection != Vector3.zero;
+        this.ApplyGravity();
+        this.Move(moveDirection);
     }
 
-    // Apply gravity to the character controller
     void ApplyGravity() {
         this.VelocityY = this.CharacterController is { isGrounded: false }
             ? this.VelocityY - (CharacterMovement.Gravity * Time.deltaTime)
             : 0.0f;
 
-        Vector3 motion = new(0.0f, this.VelocityY, 0.0f);
-        _ = this.CharacterController?.Move(motion * Time.deltaTime);
+        _ = this.CharacterController?.Move(
+            new Vector3(0.0f, this.VelocityY, 0.0f) * Time.deltaTime
+        );
     }
 
-    // Jumping action
     void Jump() => this.VelocityY = CharacterMovement.JumpForce;
 }

lc-hax/Scripts/Core/HaxCamera.cs

@@ -0,0 +1,155 @@
+using GameNetcodeStuff;
+using Hax;
+using UnityEngine;
+using UnityEngine.Rendering.HighDefinition;
+
+internal class HaxCamera : MonoBehaviour {
+    internal static HaxCamera? Instance { get; private set; }
+    KeyboardMovement? KeyboardMovement { get; set; }
+    MousePan? MousePan { get; set; }
+    GameObject? HaxCameraAudioContainer { get; set; }
+    AudioListener? HaxCameraAudioListener { get; set; }
+    internal GameObject? HaxCameraContainer { get; private set; }
+    internal Camera? CustomCamera { get; private set; }
+
+    void OnEnable() {
+        GameListener.OnGameStart += this.DisableCamera;
+        GameListener.OnGameEnd += this.DisableCamera;
+
+        Instance = this;
+        _ = this.GetCamera();
+    }
+
+    void OnDisable() {
+        GameListener.OnGameStart -= this.DisableCamera;
+        GameListener.OnGameEnd -= this.DisableCamera;
+    }
+
+    void LateUpdate() {
+        if (this.HaxCameraContainer is null) return;
+        if (this.KeyboardMovement is null) return;
+        if (!this.HaxCameraContainer.activeSelf) return;
+
+        this.KeyboardMovement.IsPaused = Helper.LocalPlayer is { isTypingChat: true };
+    }
+
+    void DisableCamera() {
+        if (PhantomMod.Instance is PhantomMod phantom) {
+            phantom.DisablePhantom();
+        }
+
+        this.HaxCameraContainer?.SetActive(false);
+    }
+
+    internal void SetActive(bool active) {
+        if (Helper.StartOfRound is not StartOfRound startOfRound) return;
+        if (Helper.LocalPlayer is not PlayerControllerB player) return;
+        if (player.activeAudioListener is not AudioListener playerlistener) return;
+        if (this.HaxCameraContainer is null) return;
+        if (this.HaxCameraAudioListener is not AudioListener haxListener) return;
+        if (this.GetCamera() is not Camera camera) return;
+
+        this.HaxCameraContainer.SetActive(active);
+
+        if (!this.HaxCameraContainer.activeSelf) {
+            playerlistener.enabled = true;
+            startOfRound.audioListener = playerlistener;
+            startOfRound.activeCamera.enabled = true;
+        }
+
+        else {
+            this.CopyFromCamera(camera, startOfRound.activeCamera);
+            startOfRound.activeCamera.enabled = false;
+            playerlistener.enabled = false;
+            startOfRound.audioListener = haxListener;
+        }
+    }
+
+    Camera? GetCamera() {
+        if (this.CustomCamera is not null) return this.CustomCamera;
+
+        this.HaxCameraAudioContainer ??= new GameObject("HaxCamera Audio Container");
+        this.HaxCameraContainer ??= new GameObject("HaxCamera Container");
+        DontDestroyOnLoad(this.HaxCameraContainer);
+
+        this.CustomCamera = this.HaxCameraContainer.AddComponent<Camera>();
+
+        this.HaxCameraAudioListener =
+            this.HaxCameraAudioContainer.GetComponent<AudioListener>() ??
+            this.HaxCameraAudioContainer.AddComponent<AudioListener>();
+
+        this.HaxCameraAudioContainer.transform.SetParent(this.HaxCameraContainer.transform, false);
+        this.HaxCameraAudioListener.transform.SetParent(this.HaxCameraContainer.transform, false);
+        this.HaxCameraAudioListener.transform.localScale = new Vector3(0.8196f, 0.8196f, 0.8196f);
+        this.HaxCameraAudioListener.transform.localPosition = Vector3.zero;
+        this.HaxCameraAudioListener.transform.localRotation = Quaternion.identity;
+
+        this.KeyboardMovement =
+            this.CustomCamera.GetComponent<KeyboardMovement>() ??
+            this.CustomCamera.gameObject.AddComponent<KeyboardMovement>();
+
+        this.MousePan =
+            this.CustomCamera.GetComponent<MousePan>() ??
+            this.CustomCamera.gameObject.AddComponent<MousePan>();
+
+        this.MousePan.enabled = true;
+        this.KeyboardMovement.enabled = true;
+        this.HaxCameraAudioListener.enabled = true;
+        this.HaxCameraContainer.SetActive(false);
+
+        return this.CustomCamera;
+    }
+
+    void AddHDCameraCompatibility(Camera camera) {
+        if (!camera.TryGetComponent(out HDAdditionalCameraData dataToCopy)) return;
+
+        HDAdditionalCameraData hdData =
+            camera.GetComponent<HDAdditionalCameraData>() ??
+            camera.gameObject.AddComponent<HDAdditionalCameraData>();
+
+        hdData.customRenderingSettings = true;
+        hdData.renderingPathCustomFrameSettingsOverrideMask.mask = dataToCopy.renderingPathCustomFrameSettingsOverrideMask.mask;
+        hdData.renderingPathCustomFrameSettings.lodBiasMode = dataToCopy.renderingPathCustomFrameSettings.lodBiasMode;
+        hdData.renderingPathCustomFrameSettings.lodBias = dataToCopy.renderingPathCustomFrameSettings.lodBias;
+        hdData.antialiasing = dataToCopy.antialiasing;
+
+        hdData.renderingPathCustomFrameSettings.SetEnabled(
+            FrameSettingsField.CustomPass,
+            dataToCopy.renderingPathCustomFrameSettings.IsEnabled(FrameSettingsField.CustomPass)
+        );
+
+        hdData.renderingPathCustomFrameSettings.SetEnabled(
+            FrameSettingsField.Volumetrics,
+            dataToCopy.renderingPathCustomFrameSettings.IsEnabled(FrameSettingsField.Volumetrics)
+        );
+
+        hdData.renderingPathCustomFrameSettings.SetEnabled(
+            FrameSettingsField.ShadowMaps,
+            dataToCopy.renderingPathCustomFrameSettings.IsEnabled(FrameSettingsField.ShadowMaps)
+        );
+    }
+
+    void UpdateCameraTransform(Transform target) {
+        if (this.HaxCameraContainer is not GameObject cameraContainer) return;
+        if (this.KeyboardMovement != null) {
+            this.KeyboardMovement.LastPosition = target.position;
+        }
+
+        cameraContainer.transform.position = target.position;
+        cameraContainer.transform.rotation = target.rotation;
+    }
+
+    void CopyFromCamera(Camera camera, Camera originalCamera) {
+        camera.CopyFrom(originalCamera);
+        camera.transform.localRotation = originalCamera.transform.localRotation;
+        camera.backgroundColor = originalCamera.backgroundColor;
+        camera.renderingPath = originalCamera.renderingPath;
+        camera.nearClipPlane = originalCamera.nearClipPlane;
+        camera.farClipPlane = originalCamera.farClipPlane;
+        camera.depth = originalCamera.depth;
+        camera.tag = originalCamera.tag;
+
+        this.AddHDCameraCompatibility(camera);
+        this.UpdateCameraTransform(originalCamera.transform);
+    }
+}

lc-hax/Scripts/Core/InputListener.cs

@@ -17,16 +17,20 @@ class InputListener : MonoBehaviour {
     internal static event Action? OnLeftBracketPress;
     internal static event Action? OnRightBracketPress;
     internal static event Action? OnBackslashPress;
-    internal static event Action? OnZPress;
     internal static event Action? OnDelPress;
-    internal static event Action? OnXPress;
-    internal static event Action? OnNPress;
     internal static event Action? OnUpArrowPress;
     internal static event Action? OnDownArrowPress;
     internal static event Action? OnF4Press;
     internal static event Action? OnF5Press;
     internal static event Action? OnF9Press;
     internal static event Action<bool>? OnRightButtonHold;
+    internal static event Action<bool>? OnLeftAltButtonHold;
+    internal static event Action? OnZPress;
+    internal static event Action? OnXPress;
+    internal static event Action? OnNPress;
+    internal static event Action? OnQPress;
+    internal static event Action? OnEPress;
+    internal static event Action? OnSpacePress;
 
     (Func<bool>, Action)[] InputActions { get; } = [
         (() => Mouse.current.middleButton.wasPressedThisFrame, () => InputListener.OnMiddleButtonPress?.Invoke()),
@@ -41,21 +45,25 @@ class InputListener : MonoBehaviour {
         (() => Keyboard.current[Key.RightBracket].wasPressedThisFrame, () => InputListener.OnRightBracketPress?.Invoke()),
         (() => Keyboard.current[Key.Backslash].wasPressedThisFrame, () => InputListener.OnBackslashPress?.Invoke()),
         (() => Keyboard.current[Key.Delete].wasPressedThisFrame, () => InputListener.OnDelPress?.Invoke()),
-        (() => Keyboard.current[Key.Z].wasPressedThisFrame, () => InputListener.OnZPress?.Invoke()),
-        (() => Keyboard.current[Key.X].wasPressedThisFrame, () => InputListener.OnXPress?.Invoke()),
-        (() => Keyboard.current[Key.N].wasPressedThisFrame, () => InputListener.OnNPress?.Invoke()),
         (() => Keyboard.current[Key.UpArrow].wasPressedThisFrame, () => InputListener.OnUpArrowPress?.Invoke()),
         (() => Keyboard.current[Key.DownArrow].wasPressedThisFrame, () => InputListener.OnDownArrowPress?.Invoke()),
         (() => Keyboard.current[Key.F4].wasPressedThisFrame, () => InputListener.OnF4Press?.Invoke()),
         (() => Keyboard.current[Key.F5].wasPressedThisFrame, () => InputListener.OnF5Press?.Invoke()),
         (() => Keyboard.current[Key.F9].wasPressedThisFrame, () => InputListener.OnF9Press?.Invoke()),
+        (() => Keyboard.current[Key.Z].wasPressedThisFrame, () => InputListener.OnZPress?.Invoke()),
+        (() => Keyboard.current[Key.X].wasPressedThisFrame, () => InputListener.OnXPress?.Invoke()),
+        (() => Keyboard.current[Key.N].wasPressedThisFrame, () => InputListener.OnNPress?.Invoke()),
+        (() => Keyboard.current[Key.Q].wasPressedThisFrame, () => InputListener.OnQPress?.Invoke()),
+        (() => Keyboard.current[Key.E].wasPressedThisFrame, () => InputListener.OnEPress?.Invoke()),
+        (() => Keyboard.current[Key.Space].wasPressedThisFrame, () => InputListener.OnSpacePress?.Invoke()),
     ];
 
     void Update() {
-        InputListener.OnShiftButtonHold?.Invoke(Keyboard.current[Key.LeftShift].isPressed);
         InputListener.OnFButtonHold?.Invoke(Keyboard.current[Key.F].isPressed);
         InputListener.OnEButtonHold?.Invoke(Keyboard.current[Key.E].isPressed);
+        InputListener.OnShiftButtonHold?.Invoke(Keyboard.current[Key.LeftShift].isPressed);
         InputListener.OnRightButtonHold?.Invoke(Mouse.current.rightButton.isPressed);
+        InputListener.OnLeftAltButtonHold?.Invoke(Keyboard.current[Key.LeftAlt].isPressed);
 
         foreach ((Func<bool> keyPressed, Action eventAction) in this.InputActions) {
             if (!keyPressed()) continue;

lc-hax/Scripts/Helpers/Camera.cs

@@ -4,9 +4,9 @@ namespace Hax;
 
 static partial class Helper {
     internal static Camera? CurrentCamera =>
-        Helper.LocalPlayer?.gameplayCamera is Camera { enabled: true } gameplayCamera
-            ? gameplayCamera
-            : Helper.StartOfRound?.spectateCamera;
+        HaxCamera.Instance?.HaxCameraContainer is { activeSelf: true }
+            ? HaxCamera.Instance.CustomCamera
+            : Helper.StartOfRound?.activeCamera;
 
     internal static Vector3 WorldToEyesPoint(this Camera camera, Vector3 worldPosition) {
         Vector3 screen = camera.WorldToViewportPoint(worldPosition);