0
\$\begingroup\$

I try to sync the CharacterController::MouseLook in a multiplayer game.

I added a syncvar to my player controller script (named Player_Controller)

[SyncVar (hook="OnCamRotate")]
public Quaternion camRotation;
public void OnCamRotate(Quaternion q) {
    if(isLocalPlayer) return;
    camRotation = q;
    MouseLook.m_CameraTargetRot = camRotation;
}

and changed the m_CameraTargetRot of the MouseLook script to be static. In the LookRotation function of MouseLook i added

character.gameObject.GetComponent<Player_Controller>().camRotation = camera.localRotation;

but even though i return if it is the local player it applies to the wrong player. I believe its because i access the static script in my Hook function

MouseLook.m_CameraTargetRot = camRotation;

How should i sync the MouseLook rotation?

Edit As @DMGregory stated i should post the code of the standard asset "MouseLook" so here it is..

using System;
using UnityEngine;
using UnityStandardAssets.CrossPlatformInput;

namespace UnityStandardAssets.Characters.FirstPerson
{
    [Serializable] /* to show up in parent script */
    public class MouseLook
    {
        public float XSensitivity = 2f;
        public float YSensitivity = 2f;
        public bool clampVerticalRotation = true;
        public float MinimumX = -90F;
        public float MaximumX = 90F;
        public bool smooth;
        public float smoothTime = 5f;
        public bool lockCursor = true;


        private Quaternion m_CharacterTargetRot;
        private Quaternion m_CameraTargetRot;
        private bool m_cursorIsLocked = true;

        public void Init(Transform character, Transform camera)
        {
            m_CharacterTargetRot = character.localRotation;
            m_CameraTargetRot = camera.localRotation;
        }


        public void LookRotation(Transform character, Transform camera)
        {
            float yRot = CrossPlatformInputManager.GetAxis("Mouse X") * XSensitivity;
            float xRot = CrossPlatformInputManager.GetAxis("Mouse Y") * YSensitivity;

            m_CharacterTargetRot *= Quaternion.Euler (0f, yRot, 0f);
            m_CameraTargetRot *= Quaternion.Euler (-xRot, 0f, 0f);

            if(clampVerticalRotation)
                m_CameraTargetRot = ClampRotationAroundXAxis (m_CameraTargetRot);

            if(smooth)
            {
                character.localRotation = Quaternion.Slerp (character.localRotation, m_CharacterTargetRot,
                    smoothTime * Time.deltaTime);
                camera.localRotation = Quaternion.Slerp (camera.localRotation, m_CameraTargetRot,
                    smoothTime * Time.deltaTime);
            }
            else
            {
                character.localRotation = m_CharacterTargetRot;
                camera.localRotation = m_CameraTargetRot;
            }

            UpdateCursorLock();
        }

        public void SetCursorLock(bool value)
        {
            lockCursor = value;
            if(!lockCursor)
            {//we force unlock the cursor if the user disable the cursor locking helper
                Cursor.lockState = CursorLockMode.None;
                Cursor.visible = true;
            }
        }

        public void UpdateCursorLock()
        {
            //if the user set "lockCursor" we check & properly lock the cursos
            if (lockCursor)
                InternalLockUpdate();
        }

        private void InternalLockUpdate()
        {
            if(Input.GetKeyUp(KeyCode.Escape))
            {
                m_cursorIsLocked = false;
            }
            else if(Input.GetMouseButtonUp(0))
            {
                m_cursorIsLocked = true;
            }

            if (m_cursorIsLocked)
            {
                Cursor.lockState = CursorLockMode.Locked;
                Cursor.visible = false;
            }
            else if (!m_cursorIsLocked)
            {
                Cursor.lockState = CursorLockMode.None;
                Cursor.visible = true;
            }
        }

        Quaternion ClampRotationAroundXAxis(Quaternion q)
        {
            q.x /= q.w;
            q.y /= q.w;
            q.z /= q.w;
            q.w = 1.0f;

            float angleX = 2.0f * Mathf.Rad2Deg * Mathf.Atan (q.x);

            angleX = Mathf.Clamp (angleX, MinimumX, MaximumX);

            q.x = Mathf.Tan (0.5f * Mathf.Deg2Rad * angleX);

            return q;
        }

    }
}
\$\endgroup\$
4
  • \$\begingroup\$ How are you using the variable m_CameraTargetRot ? \$\endgroup\$
    – DMGregory
    May 11, 2019 at 11:51
  • \$\begingroup\$ Sorry i dont understand your question. m_CameraTargetRot is a property of MouseLook (included in the standard assets) \$\endgroup\$
    – MBrain
    May 11, 2019 at 16:23
  • \$\begingroup\$ With the information you've shown here, we can't evaluate whether the choice to make m_CameraTargetRot static was a safe one. The bug you describes suggests that it probably was not. By including the details of how this variable is used by the MouseLook script inside your question itself, you broaden the pool of people who can help you, from just those who already know this asset inside-out, to everyone who can read C# code, helping you get better answers faster. \$\endgroup\$
    – DMGregory
    May 11, 2019 at 18:01
  • \$\begingroup\$ I added the sourcecode, i hope i got you right. \$\endgroup\$
    – MBrain
    May 11, 2019 at 20:47

0

You must log in to answer this question.

Browse other questions tagged .