Клиент-серверная архитектура игр: основа многопользовательского взаимодействия

using Unity.Netcode;
using UnityEngine;

public class GameNetworkManager : MonoBehaviour
{
public void StartHost()
{
NetworkManager.Singleton.StartHost();
}

public void StartClient()
{
NetworkManager.Singleton.StartClient();
}

public void StartServer()
{
NetworkManager.Singleton.StartServer();
}
}

using Unity.Netcode;
using UnityEngine;

public class PlayerController : NetworkBehaviour
{
// Синхронизируемая переменная здоровья
private NetworkVariable<int> health = new NetworkVariable<int>(100);

// Вызывается только на объекте, принадлежащем локальному клиенту
public override void OnNetworkSpawn()
{
if (IsOwner)
{
Debug.Log("Это мой персонаж!");
}

// Подписка на изменение здоровья
health.OnValueChanged += OnHealthChanged;
}

private void OnHealthChanged(int previous, int current)
{
Debug.Log($"Здоровье изменилось: {previous} -> {current}");
}

// Метод, вызываемый на сервере при получении урона
[ServerRpc]
public void TakeDamageServerRpc(int damage)
{
// Логика обработки урона только на сервере
health.Value -= damage;

if (health.Value <= 0)
{
// Информирование всех клиентов о смерти
PlayerDiedClientRpc(OwnerClientId);
}
}

// Метод, вызываемый на всех клиентах при смерти игрока
[ClientRpc]
public void PlayerDiedClientRpc(ulong playerId)
{
Debug.Log($"Игрок с ID {playerId} погиб!");
// Воспроизведение анимации смерти и т.д.
}
}

using Unity.Netcode;
using UnityEngine;

public class CombatSystem : NetworkBehaviour
{
// Константы баланса игры
private const float MAX_ATTACK_DISTANCE = 2.5f;
private const float ATTACK_COOLDOWN = 1.0f;

// Серверные данные для каждого игрока
private Dictionary<ulong, float> lastAttackTime = new Dictionary<ulong, float>();

// Клиент запрашивает атаку
[ServerRpc]
public void RequestAttackServerRpc(Vector3 targetPosition, ServerRpcParams rpcParams = default)
{
// Получаем ID клиента из параметров RPC
ulong clientId = rpcParams.Receive.SenderClientId;

// Проверяем время перезарядки
if (!ValidateCooldown(clientId))
{
NotifyAttackFailedClientRpc(AttackFailReason.Cooldown, clientId);
return;
}

// Получаем позицию атакующего игрока
if (!TryGetPlayerPosition(clientId, out Vector3 attackerPosition))
return;

// Проверяем дистанцию атаки
if (Vector3.Distance(attackerPosition, targetPosition) > MAX_ATTACK_DISTANCE)
{
NotifyAttackFailedClientRpc(AttackFailReason.OutOfRange, clientId);
return;
}

// Находим потенциальные цели в зоне атаки
List<NetworkObject> potentialTargets = FindTargetsInAttackArea(attackerPosition, targetPosition);

// Обрабатываем урон по целям
foreach (var target in potentialTargets)
{
if (target.TryGetComponent<HealthSystem>(out var healthSystem))
{
// Применяем урон только на сервере
healthSystem.ApplyDamage(10, clientId);
}
}

// Обновляем время последней атаки
lastAttackTime[clientId] = Time.time;

// Уведомляем клиентов об успешной атаке
NotifyAttackSuccessClientRpc(attackerPosition, targetPosition, clientId);
}

private bool ValidateCooldown(ulong clientId)
{
if (!lastAttackTime.TryGetValue(clientId, out float lastTime))
return true;

return Time.time – lastTime >= ATTACK_COOLDOWN;
}

private bool TryGetPlayerPosition(ulong clientId, out Vector3 position)
{
position = Vector3.zero;

foreach (NetworkClient client in NetworkManager.Singleton.ConnectedClientsList)
{
if (client.ClientId == clientId && client.PlayerObject != null)
{
position = client.PlayerObject.transform.position;
return true;
}
}

Debug.LogError($"Не удалось найти позицию игрока с ID {clientId}");
return false;
}

// Метод для поиска целей в зоне атаки (упрощенная версия)
private List<NetworkObject> FindTargetsInAttackArea(Vector3 attackerPosition, Vector3 targetPosition)
{
List<NetworkObject> targets = new List<NetworkObject>();

// Рассчитываем направление атаки
Vector3 attackDirection = (targetPosition – attackerPosition).normalized;

// Используем Physics.OverlapSphere для поиска потенциальных целей
Collider[] colliders = Physics.OverlapSphere(
attackerPosition + attackDirection * (MAX_ATTACK_DISTANCE / 2), 
MAX_ATTACK_DISTANCE / 2
);

foreach (var collider in colliders)
{
if (collider.TryGetComponent<NetworkObject>(out var networkObject))
{
// Не атакуем себя
if (networkObject.OwnerClientId != attackerPosition)
{
targets.Add(networkObject);
}
}
}

return targets;
}

// Уведомление о неудачной атаке
[ClientRpc]
private void NotifyAttackFailedClientRpc(AttackFailReason reason, ulong clientId)
{
// Этот код выполнится на всех клиентах
if (NetworkManager.Singleton.LocalClientId == clientId)
{
Debug.Log($"Атака не удалась: {reason}");
// Здесь можно добавить показ UI для игрока
}
}

// Уведомление об успешной атаке
[ClientRpc]
private void NotifyAttackSuccessClientRpc(Vector3 attackerPosition, Vector3 targetPosition, ulong clientId)
{
// Визуальные эффекты атаки, звуки, анимации и т.д.
// Это выполнится на всех клиентах
SpawnAttackVFX(attackerPosition, targetPosition);

// Дополнительный фидбэк для атакующего игрока
if (NetworkManager.Singleton.LocalClientId == clientId)
{
PlayHapticFeedback();
}
}

// Вспомогательные методы для клиентских эффектов
private void SpawnAttackVFX(Vector3 start, Vector3 end) { /* ... */ }
private void PlayHapticFeedback() { /* ... */ }

// Перечисление причин неудачной атаки
public enum AttackFailReason
{
Cooldown,
OutOfRange,
InvalidTarget
}
}

using Unity.Netcode;
using UnityEngine;
using System.Collections.Generic;

public class PredictivePlayerController : NetworkBehaviour
{
[SerializeField] private float moveSpeed = 5f;

// Буфер для хранения предсказанных входных данных
private Queue<InputState> inputBuffer = new Queue<InputState>();

// Последний подтвержденный сервером тик
private NetworkVariable<ushort> serverConfirmedTick = 
new NetworkVariable<ushort>(0, NetworkVariableReadPermission.Owner);

// Текущий локальный тик для клиента
private ushort localTick;

// Состояние, подтвержденное сервером
private Vector3 serverConfirmedPosition;

private CharacterController characterController;

private void Awake()
{
characterController = GetComponent<CharacterController>();
}

public override void OnNetworkSpawn()
{
if (!IsOwner) return;

serverConfirmedTick.OnValueChanged += OnServerConfirmation;
}

private void Update()
{
if (!IsOwner) return;

// Получаем ввод пользователя
Vector2 input = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));

// Формируем состояние ввода
InputState inputState = new InputState
{
tick = localTick,
inputVector = input,
timestamp = Time.time
};

// Добавляем в буфер и отправляем на сервер
inputBuffer.Enqueue(inputState);
MovePlayerServerRpc(inputState);

// Применяем предсказание локально
ApplyInput(inputState);

localTick++;
}

// Применение ввода локально для предсказания
private void ApplyInput(InputState input)
{
Vector3 movement = new Vector3(input.inputVector.x, 0, input.inputVector.y) * moveSpeed * Time.deltaTime;
characterController.Move(movement);
}

// Callback при получении подтверждения с сервера
private void OnServerConfirmation(ushort oldValue, ushort newValue)
{
// Удаляем подтвержденные входные данные из буфера
while (inputBuffer.Count > 0 && inputBuffer.Peek().tick <= newValue)
{
inputBuffer.Dequeue();
}

// Проверяем, нужна ли корректировка позиции
if (Vector3.Distance(transform.position, serverConfirmedPosition) > 0.1f)
{
// Перемещаем на подтвержденную сервером позицию
characterController.enabled = false;
transform.position = serverConfirmedPosition;
characterController.enabled = true;

// Повторно применяем непроверенный ввод
foreach (var input in inputBuffer)
{
ApplyInput(input);
}
}
}

[ServerRpc]
private void MovePlayerServerRpc(InputState input)
{
// Авторитетная обработка движения на сервере
Vector3 movement = new Vector3(input.inputVector.x, 0, input.inputVector.y) * moveSpeed * Time.deltaTime;

// Проверка на коллизии и другие серверные ограничения
characterController.Move(movement);

// Подтверждение обработанного тика
serverConfirmedTick.Value = input.tick;

// Сообщаем всем клиентам обновленную позицию
UpdatePositionClientRpc(transform.position, serverConfirmedTick.Value);
}

[ClientRpc]
private void UpdatePositionClientRpc(Vector3 position, ushort confirmedTick)
{
// Если это владелец, запоминаем подтвержденную позицию
if (IsOwner)
{
serverConfirmedPosition = position;
return;
}

// Для других клиентов применяем позицию с интерполяцией
StartCoroutine(InterpolatePosition(position));
}

private System.Collections.IEnumerator InterpolatePosition(Vector3 targetPosition)
{
Vector3 startPosition = transform.position;
float interpolationTime = 0.1f; // 100ms для сглаживания
float elapsedTime = 0;

while (elapsedTime < interpolationTime)
{
transform.position = Vector3.Lerp(startPosition, targetPosition, elapsedTime / interpolationTime);
elapsedTime += Time.deltaTime;
yield return null;
}

transform.position = targetPosition;
}

// Структура для хранения состояния ввода
public struct InputState : INetworkSerializable
{
public ushort tick;
public Vector2 inputVector;
public float timestamp;

public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
{
serializer.SerializeValue(ref tick);
serializer.SerializeValue(ref inputVector);
serializer.SerializeValue(ref timestamp);
}
}
}

using Unity.Netcode;
using UnityEngine;

public class LagCompensationShooter : NetworkBehaviour
{
[SerializeField] private float bulletSpeed = 100f;
[SerializeField] private Transform weaponBarrel;

[ServerRpc]
public void FireServerRpc(Vector3 origin, Vector3 direction, double clientTime)
{
// Получаем текущее серверное время
double serverTime = NetworkManager.Singleton.ServerTime.Time;

// Вычисляем величину компенсации (разница времён + половина RTT)
double timeToCompensate = serverTime – clientTime + 
(NetworkManager.Singleton.GetComponent<NetworkMetrics>().AverageRoundTripTime / 2000.0);

// Запускаем поиск попаданий с учётом исторических данных
HistoricalHitDetection.Instance.CheckHit(
origin, 
direction, 
timeToCompensate, 
bulletSpeed, 
NetworkManager.Singleton.LocalClientId,
OnHitConfirmed
);

// Уведомляем всех клиентов о выстреле для визуальных эффектов
FireEffectClientRpc(origin, direction);
}

[ClientRpc]
private void FireEffectClientRpc(Vector3 origin, Vector3 direction)
{
// Воспроизводим визуальные и звуковые эффекты выстрела
PlayMuzzleFlash();
PlayGunshotSound();
ShowBulletTrail(origin, direction);
}

[ClientRpc]
private void HitConfirmationClientRpc(ulong targetId, Vector3 hitPosition)
{
// Показываем эффект попадания
ShowHitEffect(hitPosition);

// Если это локальный игрок – даем тактильную обратную связь
if (IsOwner)
{
PlayHapticFeedback();
}
}

private void Update()
{
if (!IsOwner) return;

if (Input.GetMouseButtonDown(0))
{
// Получаем направление выстрела
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);

// Отправляем информацию о выстреле на сервер вместе с клиентским временем
FireServerRpc(
weaponBarrel.position, 
ray.direction, 
NetworkManager.Singleton.LocalTime.Time
);
}
}

private void OnHitConfirmed(ulong targetId, Vector3 hitPosition)
{
// Вызывается на сервере при подтверждении попадания
HitConfirmationClientRpc(targetId, hitPosition);

// Наносим урон цели
NetworkManager.Singleton.ConnectedClients[targetId].PlayerObject
.GetComponent<HealthSystem>()
.TakeDamage(25);
}

// Методы для визуальных эффектов
private void PlayMuzzleFlash() { /* ... */ }
private void PlayGunshotSound() { /* ... */ }
private void ShowBulletTrail(Vector3 origin, Vector3 direction) { /* ... */ }
private void ShowHitEffect(Vector3 hitPosition) { /* ... */ }
private void PlayHapticFeedback() { /* ... */ }
}

// В файле ServerManager.cs
using Unity.Netcode;
using UnityEngine;

public class ServerManager : MonoBehaviour
{
[SerializeField] private int port = 7777;
[SerializeField] private int maxConnections = 100;

private void Start()
{
// Отключаем ненужные компоненты на сервере
DisableUnnecessaryComponents();

// Настраиваем транспорт
NetworkManager.Singleton.GetComponent<UnityTransport>().SetConnectionData(
"0.0.0.0", // Прослушиваем все интерфейсы
(ushort)port,
"0.0.0.0" // Для подключений извне
);

// Устанавливаем максимальное количество подключений
NetworkManager.Singleton.ConnectionApprovalCallback = ApproveConnection;

// Запускаем сервер
NetworkManager.Singleton.StartServer();

Debug.Log($"Сервер запущен на порту {port}, максимум подключений: {maxConnections}");
}

private void DisableUnnecessaryComponents()
{
// Отключаем ненужные системы на сервере
Camera.main?.gameObject.SetActive(false);

// Отключаем аудио
AudioListener[] audioListeners = FindObjectsOfType<AudioListener>();
foreach (AudioListener listener in audioListeners)
{
listener.enabled = false;
}

// Отключаем пост-процессинг и другие графические элементы
if (TryGetComponent<UnityEngine.Rendering.Volume>(out var volume))
{
volume.enabled = false;
}
}

private void ApproveConnection(
NetworkManager.ConnectionApprovalRequest request, 
NetworkManager.ConnectionApprovalResponse response)
{
// Проверка, не превышен ли лимит игроков
if (NetworkManager.Singleton.ConnectedClientsIds.Count >= maxConnections)
{
response.Approved = false;
response.Reason = "Сервер заполнен";
return;
}

// Дополнительные проверки (бан-лист, авторизация и т.д.)
bool playerIsBanned = CheckIfPlayerIsBanned(request.ClientNetworkId);
if (playerIsBanned)
{
response.Approved = false;
response.Reason = "Вы заблокированы на сервере";
return;
}

// Одобряем подключение
response.Approved = true;
response.CreatePlayerObject = true;
response.Position = GetSpawnPosition();
response.Rotation = Quaternion.identity;
}

private bool CheckIfPlayerIsBanned(ulong clientId)
{
// Реализация проверки бан-листа
return false;
}

private Vector3 GetSpawnPosition()
{
// Логика выбора точки появления игрока
return new Vector3(0, 1, 0);
}
}

using Unity.Netcode;
using UnityEngine;
using System.Collections.Generic;

public class WorldZoneManager : NetworkBehaviour
{
[SerializeField] private float zoneSize = 100f;
[SerializeField] private int totalZonesX = 10;
[SerializeField] private int totalZonesZ = 10;

// Матрица зон мира
private WorldZone[,] zones;

// Список игроков и их текущих зон
private Dictionary<ulong, Vector2Int> playerZones = new Dictionary<ulong, Vector2Int>();

// Частота обновления зон в зависимости от дистанции до игрока
[SerializeField] private float[] updateFrequencies = { 0.033f, 0.1f, 0.5f, 1.0f };

private void Start()
{
if (!IsServer) return;

// Инициализируем зоны
InitializeZones();

// Подписываемся на события подключения/отключения игроков
NetworkManager.Singleton.OnClientConnectedCallback += OnClientConnected;
NetworkManager.Singleton.OnClientDisconnectCallback += OnClientDisconnected;
}

private void Update()
{
if (!IsServer) return;

// Обновляем зоны каждый кадр
UpdateZones();
}

private void InitializeZones()
{
zones = new WorldZone[totalZonesX, totalZonesZ];

for (int x = 0; x < totalZonesX; x++)
{
for (int z = 0; z < totalZonesZ; z++)
{
Vector3 zoneCenter = new Vector3(
x * zoneSize + zoneSize/2,
0,
z * zoneSize + zoneSize/2
);

zones[x, z] = new WorldZone(zoneCenter, zoneSize);
}
}
}

private void OnClientConnected(ulong clientId)
{
// Когда игрок подключается, определяем его начальную зону
NetworkObject playerObject = NetworkManager.Singleton.ConnectedClients[clientId].PlayerObject;
Vector3 position = playerObject.transform.position;

Vector2Int zoneIndex = GetZoneIndex(position);
playerZones[clientId] = zoneIndex;

// Добавляем игрока в соответствующую зону
zones[zoneIndex.x, zoneIndex.y].AddPlayer(clientId);
}

private void OnClientDisconnected(ulong clientId)
{
if (playerZones.TryGetValue(clientId, out Vector2Int zoneIndex))
{
// Удаляем игрока из его текущей зоны
zones[zoneIndex.x, zoneIndex.y].RemovePlayer(clientId);
playerZones.Remove(clientId);
}
}

private Vector2Int GetZoneIndex(Vector3 position)
{
int x = Mathf.Clamp(Mathf.FloorToInt(position.x / zoneSize), 0, totalZonesX – 1);
int z = Mathf.Clamp(Mathf.FloorToInt(position.z / zoneSize), 0, totalZonesZ – 1);
return new Vector2Int(x, z);
}

private void UpdateZones()
{
// Для каждого игрока проверяем, не сменил ли он зону
foreach (var client in NetworkManager.Singleton.ConnectedClientsList)
{
ulong clientId = client.ClientId;
Vector3 position = client.PlayerObject.transform.position;
Vector2Int currentZoneIndex = GetZoneIndex(position);

// Если игрок перешел в новую зону
if (playerZones.TryGetValue(clientId, out Vector2Int oldZoneIndex) && 
oldZoneIndex != currentZoneIndex)
{
// Удаляем из старой, добавляем в новую
zones[oldZoneIndex.x, oldZoneIndex.y].RemovePlayer(clientId);
zones[currentZoneIndex.x, currentZoneIndex.y].AddPlayer(clientId);
playerZones[clientId] = currentZoneIndex;
}

// Обновляем приоритеты зон для этого игрока
UpdateZonePriorities(currentZoneIndex, clientId);
}

// Обновляем каждую зону с соответствующей частотой
for (int x = 0; x < totalZonesX; x++)
{
for (int z = 0; z < totalZonesZ; z++)
{
zones[x, z].Update(Time.deltaTime);
}
}
}

private void UpdateZonePriorities(Vector2Int playerZoneIndex, ulong playerId)
{
// Для каждой зоны устанавливаем приоритет в зависимости от ра

**Читайте также**
- [Клиент в клиент-серверной архитектуре: роль и принципы работы](/javascript/klient-v-klient-servernoj-arhitekture/)
- [Серверы в клиент-серверной архитектуре: принципы и оптимизация](/sql/server-v-klient-servernoj-arhitekture/)
- [Клиент-серверная архитектура: основы взаимодействия в сети](/javascript/klient-servernaya-arhitektura-v-veb-razrabotke/)
- [Клиент-серверная архитектура баз данных: принципы, модели, защита](/sql/baza-dannyh-v-klient-servernoj-arhitekture/)
- [P2P-архитектура: принципы, протоколы и будущее децентрализации](/javascript/odnorangovaya-p2p-arhitektura/)
- [Клиент-серверная архитектура: как работает современное ПО](/sql/programmnoe-obespechenie-v-klient-servernoj-arhitekture/)
- [Проектирование клиент-серверных приложений: архитектура и опыт](/javascript/razrabotka-klient-servernyh-prilozhenij/)
- [Одноуровневая клиент-серверная архитектура: принципы и примеры](/javascript/odnourovnevaya-klient-servernaya-arhitektura/)
- [Клиент-серверная архитектура: принципы работы и применение](/sql/klient-servernaya-arhitektura-chto-eto-i-zachem-nuzhno/)
- [Клиент-серверная архитектура: основы, компоненты и принципы](/javascript/osnovnye-komponenty-klient-servernoj-arhitektury/)