Разработка социального пространства в метавселенной

Разработка социального пространства в метавселенной

Социальное пространство в метавселенной — это виртуальное место для взаимодействия людей: конференции, тусовки, концерты, деловые встречи. В отличие от игровых метавселенных, здесь фокус на человеческой коммуникации, а не на gameplay. Технически это real-time multiplayer 3D среда с voice/video коммуникацией и инструментами для социального взаимодействия.

Техническая архитектура

Серверная топология

Для социального пространства важна физическая близость серверов к пользователям — высокий latency в голосовом общении неприемлем:

Global CDN (статические ассеты, 3D модели)
        │
Regional Game Servers (AWS eu-west-1, us-east-1, ap-southeast-1)
        │
        ├── Room Manager (создание/уничтожение комнат)
        ├── State Sync Service (позиции аватаров, объектов)
        ├── Voice Server (SFU: Selective Forwarding Unit)
        └── Chat Service (text, reactions, file sharing)

Spatial Audio и proximity chat

В реальном пространстве звук тише на расстоянии. Метавселенная должна имитировать это — иначе в комнате с 50 людьми все говорят одновременно и непонятно кто к кому обращается.

class SpatialAudioManager {
  private audioContext: AudioContext;
  private panners: Map<string, PannerNode> = new Map();

  addParticipant(userId: string, stream: MediaStream) {
    const source = this.audioContext.createMediaStreamSource(stream);
    const panner = this.audioContext.createPanner();

    // Web Audio API spatial settings
    panner.panningModel = 'HRTF';  // Head-Related Transfer Function - биауральный звук
    panner.distanceModel = 'inverse';
    panner.refDistance = 3;        // полная громкость до 3 метров
    panner.maxDistance = 20;       // не слышно дальше 20 метров
    panner.rolloffFactor = 2;

    source.connect(panner);
    panner.connect(this.audioContext.destination);
    this.panners.set(userId, panner);
  }

  updateParticipantPosition(userId: string, position: Vector3) {
    const panner = this.panners.get(userId);
    if (panner) {
      panner.positionX.value = position.x;
      panner.positionY.value = position.y;
      panner.positionZ.value = position.z;
    }
  }

  updateListenerPosition(position: Vector3, orientation: Quaternion) {
    const listener = this.audioContext.listener;
    listener.positionX.value = position.x;
    listener.positionY.value = position.y;
    listener.positionZ.value = position.z;

    // Направление взгляда слушателя
    const forward = new THREE.Vector3(0, 0, -1).applyQuaternion(
      new THREE.Quaternion(orientation.x, orientation.y, orientation.z, orientation.w)
    );
    listener.forwardX.value = forward.x;
    listener.forwardY.value = forward.y;
    listener.forwardZ.value = forward.z;
  }
}

WebRTC SFU архитектура

Для масштабируемого голоса с десятками участников нужен SFU (Selective Forwarding Unit). Каждый клиент отправляет поток один раз на SFU, SFU пересылает нужным получателям:

[Participant A] ──send──► [SFU Server] ──forward──► [Participant B]
[Participant B] ──send──►              ──forward──► [Participant C]
[Participant C] ──send──►              ──forward──► [Participant A]

Рекомендованные open-source SFU: mediasoup (Node.js, высокая производительность), livekit (Go, cloud-native), janus (C, зрелый проект).

// LiveKit client integration
import { Room, RoomEvent, Track } from 'livekit-client';

class MetaverseVoiceClient {
  private room: Room;

  async connect(roomToken: string) {
    this.room = new Room({
      adaptiveStream: true,   // авто-качество по сети
      dynacast: true,         // отключает видео-потоки вне viewport
    });

    this.room.on(RoomEvent.ParticipantConnected, (participant) => {
      participant.on('trackSubscribed', (track) => {
        if (track.kind === Track.Kind.Audio) {
          this.spatialAudio.addParticipant(participant.identity, track.mediaStream!);
        }
      });
    });

    await this.room.connect('wss://your-livekit-server.com', roomToken);

    // Публикуем микрофон
    await this.room.localParticipant.enableMicrophone();
  }
}

State Synchronization

Позиции аватаров должны синхронизироваться в реальном времени для всех участников комнаты:

import asyncio
from dataclasses import dataclass
import msgpack  # бинарная сериализация, быстрее JSON

@dataclass
class AvatarState:
    user_id: str
    position: tuple  # (x, y, z)
    rotation: tuple  # quaternion (x, y, z, w)
    animation: str   # 'idle', 'walk', 'wave', etc.
    timestamp: float

class StateSync:
    def __init__(self, room_id: str):
        self.room_id = room_id
        self.states: dict[str, AvatarState] = {}
        self.clients: set = set()

    async def update_position(self, user_id: str, state_data: dict):
        self.states[user_id] = AvatarState(**state_data)
        await self.broadcast_delta(user_id, state_data)

    async def broadcast_delta(self, updated_user_id: str, delta: dict):
        """Отправляем только изменение, не полное состояние"""
        message = msgpack.packb({
            'type': 'position_update',
            'user_id': updated_user_id,
            'state': delta
        })

        # Отправляем всем кроме отправителя
        tasks = [
            client.send(message)
            for client_id, client in self.clients.items()
            if client_id != updated_user_id
        ]
        await asyncio.gather(*tasks, return_exceptions=True)

Interpolation на клиенте: из-за сетевых задержек позиции приходят дискретно. Клиент интерполирует между полученными состояниями для плавности:

class AvatarInterpolator {
  private stateBuffer: Array<{time: number, state: AvatarState}> = [];
  private INTERPOLATION_DELAY_MS = 100;  // буфер для сглаживания

  update(state: AvatarState) {
    this.stateBuffer.push({time: Date.now(), state});
    // Держим только последние 10 состояний
    if (this.stateBuffer.length > 10) this.stateBuffer.shift();
  }

  getInterpolatedState(): AvatarState | null {
    const renderTime = Date.now() - this.INTERPOLATION_DELAY_MS;

    const before = this.stateBuffer.filter(s => s.time <= renderTime).at(-1);
    const after = this.stateBuffer.find(s => s.time > renderTime);

    if (!before || !after) return before?.state || null;

    const t = (renderTime - before.time) / (after.time - before.time);
    return this.lerp(before.state, after.state, t);
  }
}

Инструменты социального взаимодействия

Эмоции и жесты: набор быстрых команд (wave, clap, dance). Анимации воспроизводятся синхронно для всех участников.

Collaborative whiteboard: общая доска для рисования, поддерживает CRDT (Conflict-free Replicated Data Type) для бесконфликтного совместного редактирования.

Presentation mode: один участник транслирует экран/слайды всем в комнате. Реализуется через WebRTC screen sharing + SFU forward.

Spatial objects: размещение 3D объектов, NFT artwork, embedded видео/аудио в пространстве. Объекты persisted в базе и загружаются при входе в комнату.

Управление доступом

interface RoomConfig {
  id: string;
  name: string;
  maxParticipants: number;
  accessControl: {
    type: 'public' | 'token_gated' | 'invite_only' | 'nft_holders';
    nftContract?: string;    // для token-gated
    minNFTBalance?: number;  // сколько NFT нужно иметь
    inviteList?: string[];   // адреса кошельков
  };
  spatialAudio: boolean;
  recordingEnabled: boolean;
}

async function checkRoomAccess(userWallet: string, roomConfig: RoomConfig): Promise<boolean> {
  if (roomConfig.accessControl.type === 'public') return true;

  if (roomConfig.accessControl.type === 'nft_holders') {
    const balance = await nftContract.balanceOf(userWallet);
    return balance >= (roomConfig.accessControl.minNFTBalance || 1);
  }

  if (roomConfig.accessControl.type === 'token_gated') {
    const tokenBalance = await erc20Contract.balanceOf(userWallet);
    return tokenBalance > 0;
  }

  return false;
}

Token-gated социальные пространства — это мощный инструмент для DAO community calls, holder-only events, и VIP networking. NFT становится не просто коллекционным предметом, а ключом доступа к эксклюзивным социальным пространствам.

Производительность: WebGL оптимизации

Рендеринг 50+ аватаров в браузере требует серьёзных оптимизаций:

• LOD (Level of Detail): дальние аватары рендерятся с меньшим числом полигонов
• Instanced rendering: одинаковые объекты рендерятся одним GPU draw call
• Frustum culling: не рендерим то, что вне поля зрения камеры
• Occlusion culling: не рендерим то, что скрыто за другими объектами
• Asset streaming: загружаем 3D ресурсы по мере приближения к ним

Социальное пространство в метавселенной — это технически самый сложный класс real-time веб-приложений. Правильная архитектура с первого дня экономит месяцы переработки при масштабировании.