MIrror Networking. Проблема с синхронизацией объектов

@Андрейдиденко · Регистрация: 09.07.2018

Author24 — интернет-сервис помощи студентам

Добрый день. Подскажите пожалуйста.

Использую Mirror Networking.
У меня проблема с синхронизацией объектов в Unity. Когда один игрок приземляется на движущуюся платформу, то у второго игрока первый отображается в другой стороне

Я попробовал присоединить Network Transform к платформе, но он также включил Network Identity, что отключило видимость платформы.

Пробовал отключать Sync Position у игрока когда он находится на платформе и включать когда он не на платформе. Способ рабочий, но есть подергивания во время входа/выхода из коллизии.

Скрипты платформы:

Кликните здесь для просмотра всего текста

C#

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class WaypointFollower : MonoBehaviour
{
    [SerializeField] private GameObject[] waypoints;
    private int currentWaypointIndex = 0;
 
    [SerializeField] private float speed = 2f;
 
    private void Update()
    {
        if (IsWithinDistance(waypoints[currentWaypointIndex].transform.position, transform.position, 0.1f))
        {
            currentWaypointIndex++;
            if (currentWaypointIndex >= waypoints.Length)
            {
                currentWaypointIndex = 0;
            }
        }
 
        transform.position = Vector2.MoveTowards(transform.position, waypoints[currentWaypointIndex].transform.position, Time.deltaTime * speed);
    }
 
    private bool IsWithinDistance(Vector2 a, Vector2 b, float distance)
    {
        float distanceSqr = distance * distance;
        return Vector2.SqrMagnitude(a - b) < distanceSqr;
    }
}

Кликните здесь для просмотра всего текста

C#

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class StickyPlatform : MonoBehaviour
{
 
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.gameObject.CompareTag("Player"))
        {
            collision.gameObject.transform.SetParent(transform);
        }
    }
 
    private void OnTriggerExit2D(Collider2D collision)
    {
        if (collision.gameObject.CompareTag("Player"))
        {
            collision.gameObject.transform.SetParent(null);
        }
    }
}

Скрипты игрока:

Кликните здесь для просмотра всего текста

C#

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Mirror;
using UnityEngine.SceneManagement;
using System;
 
public class Player : NetworkBehaviour
{
    // Компоненты, необходимые для управления физикой и столкновениями
    private Rigidbody2D rb;
    private BoxCollider2D coll;
 
    // Переменные, связанные с состоянием и отображением игрока
    bool facingRight = true;
    public static Player localPlayer;
    public TextMesh NameDisplayText;
    [SyncVar(hook = "DisplayPlayerName")] public string PlayerDisplayName;
    [SyncVar] public string matchID;
    [SyncVar] public Match CurrentMatch;
    public GameObject PlayerLobbyUI;
    private Guid netIDGuid;
    private GameObject GameUI;
    private NetworkMatch networkMatch;
 
    // Параметры, связанные с движением по земле
    [Header("Collision Ground Settings")]
    [SerializeField] private LayerMask jumpableGround;
    [SerializeField] private float groundAcceleration = 10f;
    [SerializeField] private float groundDeceleration = 5f;
    [SerializeField] private float groundjumpForce = 35f;
 
    // Параметры, связанные с движением по песку
    [Header("Collision Sand Settings")]
    [SerializeField] private LayerMask sandGround;
    [SerializeField] private float sandAcceleration = 5f;
    [SerializeField] private float sandDeceleration = 10f;
    [SerializeField] private float sandjumpForce = 30f;
 
    // Прочие параметры
    [Header("Other Settings")]
    [SerializeField] private float airAcceleration = 2f;
    [SerializeField] private float maxSpeed = 10f;
    [SerializeField] private GroundChecker groundChecker;
 
    // Переменные для управления движением
    private Vector2 dirX;
    private bool isGrounded;
    private bool isSand;
    private float basicAcceleration;
    private float basicDeceleration;
    private float jumpForce;
    private bool jumpInProgress = false;
 
    private void Awake()
    {
        // Получаем необходимые компоненты и устанавливаем начальные значения
        networkMatch = GetComponent<NetworkMatch>();
        GameUI = GameObject.FindGameObjectWithTag("GameUI");
        rb = GetComponent<Rigidbody2D>();
        groundChecker = GetComponent<GroundChecker>();
    }
 
    private void Start()
    {
        networkMatch = GetComponent<NetworkMatch>();
 
        if (isLocalPlayer)
        {
            localPlayer = this;
 
            CmdSendName(MainMenuLobby.instance.DisplayName);
        }
        else
        {
            MainMenuLobby.instance.SpawnPlayerUIPrefab(this);
        }
    }
 
    public override void OnStartServer()
    {
        // Когда игрок подключается к серверу, генерируем уникальный ID для сетевого матча
        netIDGuid = netId.ToString().ToGuid();
        networkMatch.matchId = netIDGuid;
    }
 
    public override void OnStartClient()
    {
        // Если это локальный игрок, сохраняем ссылку на него
        // В противном случае, создаем UI для игрока в лобби
        if (isLocalPlayer)
        {
            localPlayer = this;
        }
        else
        {
            PlayerLobbyUI = MainMenuLobby.instance.SpawnPlayerUIPrefab(this);
        }
    }
 
    // Методы для обработки отключения от сервера или клиента
    public override void OnStopClient()
    {
        ClientDisconnect();
    }
 
    public override void OnStopServer()
    {
        ServerDisconnect();
    }
 
    [Command]
    public void CmdSendName(string name)
    {
        // Устанавливаем отображаемое имя игрока на сервере
        PlayerDisplayName = name;
    }
 
    public void DisplayPlayerName(string name, string playerName)
    {
        // Обновляем отображаемое имя игрока на клиентах
        name = PlayerDisplayName;
        Debug.Log("Имя " + name + " : " + playerName);
        NameDisplayText.text = playerName;
    }
 
    // Методы для создания, присоединения и отключения от игры
    public void HostGame(bool publicMatch)
    {
        string ID = MainMenuLobby.GetRandomID();
        CmdHostGame(ID, publicMatch);
    }
 
    [Command]
    public void CmdHostGame(string ID, bool publicMatch)
    {
        // Создаем игру на сервере
        matchID = ID;
        if (MainMenuLobby.instance.HostGame(ID, gameObject, publicMatch))
        {
            Debug.Log("Лобби было создано успешно");
            networkMatch.matchId = ID.ToGuid();
            TargetHostGame(true, ID);
        }
        else
        {
            Debug.Log("Ошибка в создании лобби");
            TargetHostGame(false, ID);
        }
    }
 
    [TargetRpc]
    void TargetHostGame(bool success, string ID)
    {
        // Обновляем состояние создания игры на клиенте
        matchID = ID;
        Debug.Log($"ID {matchID} == {ID}");
        MainMenuLobby.instance.HostSuccess(success, ID);
    }
 
    public void JoinGame(string inputID)
    {
        CmdJoinGame(inputID);
    }
 
    [Command]
    public void CmdJoinGame(string ID)
    {
        // Присоединяемся к игре на сервере
        matchID = ID;
        if (MainMenuLobby.instance.JoinGame(ID, gameObject))
        {
            Debug.Log("Успешное подключение к лобби");
            networkMatch.matchId = ID.ToGuid();
            TargetJoinGame(true, ID);
        }
        else
        {
            Debug.Log("Не удалось подключиться");
            TargetJoinGame(false, ID);
        }
    }
 
    [TargetRpc]
    void TargetJoinGame(bool success, string ID)
    {
        // Обновляем состояние присоединения к игре на клиенте
        matchID = ID;
        Debug.Log($"ID {matchID} == {ID}");
        MainMenuLobby.instance.JoinSuccess(success, ID);
    }
 
    public void DisconnectGame()
    {
        CmdDisconnectGame();
    }
 
    [Command(requiresAuthority = false)]
    void CmdDisconnectGame()
    {
        // Отключаемся от игры на сервере
        ServerDisconnect();
    }
 
    void ServerDisconnect()
    {
        // Обновляем состояние отключения от игры на сервере
        MainMenuLobby.instance.PlayerDisconnected(gameObject, matchID);
        RpcDisconnectGame();
        networkMatch.matchId = netIDGuid;
    }
 
    [ClientRpc]
    void RpcDisconnectGame()
    {
        // Обновляем состояние отключения от игры на клиентах
        ClientDisconnect();
    }
 
    void ClientDisconnect()
    {
        if (PlayerLobbyUI != null)
        {
            if (!isServer)
            {
                Destroy(PlayerLobbyUI);
            }
            else
            {
                PlayerLobbyUI.SetActive(false);
            }
        }
    }
 
    public void SearchGame()
    {
        CmdSearchGame();
    }
 
    [Command]
    void CmdSearchGame()
    {
        if (MainMenuLobby.instance.SearchGame(gameObject, out matchID))
        {
            Debug.Log("Игра найдена успешно");
            networkMatch.matchId = matchID.ToGuid();
            TargetSearchGame(true, matchID);
 
            if (isServer && PlayerLobbyUI != null)
            {
                PlayerLobbyUI.SetActive(true);
            }
        }
        else
        {
            Debug.Log("Поиск игры не удался");
            TargetSearchGame(false, matchID);
        }
    }
 
    [TargetRpc]
    void TargetSearchGame(bool success, string ID)
    {
        matchID = ID;
        Debug.Log("ID: " + matchID + "==" + ID + " | " + success);
        MainMenuLobby.instance.SearchGameSuccess(success, ID);
    }
 
    [Server]
    public void PlayerCountUpdated(int playerCount)
    {
        TargetPlayerCountUpdated(playerCount);
    }
 
    [TargetRpc]
    void TargetPlayerCountUpdated(int playerCount)
    {
        if (playerCount > 1)
        {
            MainMenuLobby.instance.SetBeginButtonActive(true);
        }
        else
        {
            MainMenuLobby.instance.SetBeginButtonActive(false);
        }
    }
 
    public void BeginGame()
    {
        CmdBeginGame();
    }
 
    [Command]
    public void CmdBeginGame()
    {
        MainMenuLobby.instance.BeginGame(matchID);
        Debug.Log("Игра началась");
    }
 
    public void StartGame()
    {
        TargetBeginGame();
    }
 
    [TargetRpc]
    void TargetBeginGame()
    {
        Debug.Log($"ID {matchID} | начало");
 
        Player[] players = FindObjectsOfType<Player>();
        for (int i = 0; i < players.Length; i++)
        {
            DontDestroyOnLoad(players[i]);
        }
 
        GameUI.GetComponent<Canvas>().enabled = true;
        MainMenuLobby.instance.inGame = true;
 
        facingRight = true;
        SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex + 1);
    }
 
 
    private void Update()
    {
        if (hasAuthority)
        {
            dirX = new Vector2(Input.GetAxisRaw("Horizontal"), 0);
 
            isGrounded = groundChecker.IsGrounded();
            isSand = groundChecker.IsSand();
 
            if (isGrounded)
            {
                jumpInProgress = false;
                basicAcceleration = groundAcceleration;
                basicDeceleration = groundDeceleration;
                jumpForce = groundjumpForce;
            }
 
            if (isSand)
            {
                jumpInProgress = false;
                basicAcceleration = sandAcceleration;
                basicDeceleration = sandDeceleration;
                jumpForce = sandjumpForce;
            }
 
            HandleMovement();
            HandleJumping();
 
            if (!facingRight && dirX.x > 0)
            {
                Flip();
            }
            else if (facingRight && dirX.x < 0)
            {
                Flip();
            }
        }
    }
 
    private void HandleMovement()
    {
        float acceleration = isGrounded ? basicAcceleration : airAcceleration;  // Выбираем ускорение в зависимости от состояния на земле
        float deceleration = basicDeceleration;  // Задаем основное замедление
 
        if (dirX.x != 0)
        {
            float targetSpeed = dirX.x * maxSpeed;  // Вычисляем целевую скорость
            rb.velocity = new Vector2(Mathf.Lerp(rb.velocity.x, targetSpeed, Time.deltaTime * acceleration), rb.velocity.y);  // Применяем ускорение
        }
        else if (isGrounded)
        {
            rb.velocity = new Vector2(Mathf.Lerp(rb.velocity.x, 0, Time.deltaTime * deceleration), rb.velocity.y);  // Применяем замедление при остановке на земле
        }
    }
 
    private void HandleJumping()
    {
        if (Input.GetButtonDown("Jump") && (isGrounded || isSand) && !jumpInProgress)
        {
            rb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
            jumpInProgress = true;
        }
    }
 
    private void Flip()
    {
        if (hasAuthority)
        {
            facingRight = !facingRight;
            Vector3 Scale = transform.localScale;
            Scale.x *= -1;
            transform.localScale = Scale;
 
            if (MainMenuLobby.instance.inGame)
            {
                Vector3 TextScale = NameDisplayText.transform.localScale;
                TextScale.x *= -1;
                NameDisplayText.transform.localScale = TextScale;
            }
        }
    }
}

Скриншоты:

	11.02.2024, 19:50