CodingThings.txt

you could do
Vector3 vec = new Vector3
{
    x = ...
    y = ...
    z = ...
};



transform.position = targetToFollow.position + new Vector3(xOffset, yOffset, zOffset);

transform.position = new Vector3
        {

            x = targetToFollow.position.x + xOffset,
            y = targetToFollow.position.y + yOffset,
            z = targetToFollow.position.z + zOffset
        };

        transform.rotation = new Quaternion
        {
            x = Mathf.Deg2Rad * xRotation,
            y = Mathf.Deg2Rad * yRotation,
            z = Mathf.Deg2Rad * zRotation,
            w = Quaternion.identity.w
        };


transform.rotation = Quaternion.Euler(x, y, z);


ok looks like NetworkManager does its stuff in Start
so you can make another component that will change the port in Awake and it should run fine



also, try replacing this
transform.Translate(desiredMoveDirection * MoveSpeed * Time.deltaTime);

with Rigidbody.MovePosition



to rotate, you do X and Y rotation of the pivot object
This just might be
and for zoom you change the Z pos of the MainCamera

DecayingDevToday at 10:15 PM
what exactly is that camera pivot object?
MediocreToday at 10:16 PM
just an empty GO
but you would sync its position to the player
think like a selfie stick

use this to get mouse input
float mouseX = Input.GetAxis("Mouse X");
float mouseY = Input.GetAxis("Mouse Y");

you probably also want to clamp the x rotation
Vector3 euler = cameraPivot.localEulerAngles;
euler.x = Mathf.Clamp(Mathf.Repeat(cameraPivot.eulerAngles.x + 180, 360), minY, maxY) - 180;
cameraPivot.localEulerAngles = euler;


but i prefer separate, then do a smooth follow using Vector3.SmoothDamp
this will hopefully also cause less motion sickness if your player does some sick moves like backflips xD


there will be 2 options
1 local splitscreenmultiplayer(1 player, 2, 3 4? 43?)
2 LAN multiplayer with only one screen per player




----------------------------------------------------------------------------

    private SimpleControls controls;

    private Vector2 m_Move;
    private Vector2 m_Look;



    private Vector2 m_Rotation;


public void Awake()
    {
        controls = new SimpleControls();
        controls.gameplay.move.performed += ctx => m_Move = ctx.ReadValue<Vector2>();
        controls.gameplay.look.performed += ctx => m_Look = ctx.ReadValue<Vector2>();
        controls.gameplay.move.canceled += ctx => m_Move = Vector2.zero;
        controls.gameplay.look.canceled += ctx => m_Look = Vector2.zero;


    public void OnEnable()
    {
        controls.Enable();
    }

    public void OnDisable()
    {
        controls.Disable();
    }



   public void Update()
    {
        Move(m_Move);
        Look(m_Look);
    }

    private void Move(Vector2 direction)
    {
        var scaledMoveSpeed = moveSpeed * Time.deltaTime;
        var move = transform.TransformDirection(direction.x, 0, direction.y);
        transform.localPosition += move * scaledMoveSpeed;
    }

    private void Look(Vector2 rotate)
    {
        const float kClampAngle = 80.0f;

        m_Rotation.y += rotate.x * rotateSpeed * Time.deltaTime;
        m_Rotation.x -= rotate.y * rotateSpeed * Time.deltaTime;

        m_Rotation.x = Mathf.Clamp(m_Rotation.x, -kClampAngle, kClampAngle);

        var localRotation = Quaternion.Euler(m_Rotation.x, m_Rotation.y, 0.0f);
        transform.rotation = localRotation;
    }








[Server]

if(isServer)

NetworkServer.connections is a dictionary of all clients (players)