GS2-Realtime

리얼타임 통신 기능

게임 플레이어 간의 대전 기능을 구현하기 위해, 낮은 레이턴시로 높은 빈도의 통신이 필요한 경우에 사용할 수 있는 기능입니다.

GS2에서는 일반적으로 API 리퀘스트 횟수에 대해 요금이 발생하지만, 이 서비스는 게임 서버가 기동하면 해당 게임 서버의 가동 시간과 통신 용량에 대해 비용이 발생하며, 통신 횟수에 대해서는 비용이 발생하지 않습니다.

graph TD
  Match["GS2-Matchmaking 에서<br/>로비 성립"] --> Want["RoomWant 으로 룸 요청"]
  Want -- 핫 스탠바이에서 할당 --> Warm["Warm Start (1~3초)"]
  Want -- 신규 기동 --> Cold["Cold Start (40~60초)"]
  Warm --> Connect["플레이어가 접속"]
  Cold --> Connect
  Connect --> Play["패킷 릴레이로 대전 중 통신"]
  Play -- 1분간 무통신 또는 3시간 경과 --> Shutdown["룸 종료"]

서버 타입

GS2-Realtime에는 다음 세 가지 서버 타입이 있습니다.

serverType기능
relay플레이어 간의 메시지를 중계하는 패킷 릴레이
sync오브젝트의 상태와 누가 갱신할 수 있는지를 관리하는 오브젝트 동기화
stateMachine동기화 기능에 더해, GSL로 정의된 스테이트 머신을 서버에서 실행

Realtime 네임스페이스 설정의 serverType에서 선택합니다. 선택 방법과 sync / stateMachine으로 만드는 것에 대해서는 구성과 선택 방법을 참조해 주세요.

relay에서는 바이너리 데이터를 지정한 플레이어나 참가자에게 전송하며, 페이로드 형식과 게임 처리는 애플리케이션 측에서 구현합니다. 페이로드의 바이너리 인코딩은 애플리케이션 측의 책임이므로, Protocol Buffers / FlatBuffers / MessagePack과 같은 임의의 인코딩을 채택할 수 있습니다. sync와 stateMachine으로 할 수 있는 것은 뒤에 나오는 오브젝트 동기화·롤백 방식 동기화·스테이트 머신을 사용한 서버 사이드 로직에서 설명합니다.

서버 스펙과 라이프사이클은 모든 서버 타입에 공통입니다. 룸 접속·프로필·이벤트 핸들링·구현 예제는 패킷 릴레이(relay)에 대한 설명입니다.

Unreal Engine Dedicated Server 호스팅

개발자가 Unreal Engine으로 빌드한 Dedicated Server를 호스팅할 수 있도록 하는 것을 검토하고 있습니다. 이 기능의 제공 시기는 미정입니다.

유상 지원 계약을 체결한 후 개발을 진행할 수 있는 강한 요구가 있다면 일정을 조정할 수 있으니 상담해 주시기 바랍니다.

오브젝트 동기화

서버 타입 sync 룸은 룸에 있는 오브젝트(플레이어의 캐릭터 등)의 상태를 보유하고, 변경된 값만 참가자 전원에게 배포합니다. 메시지 형식을 설계할 필요가 없으며, Unity에서는 Prefab에 컴포넌트를 붙이기만 하면, Godot에서는 씬에 노드를 추가하기만 하면 위치나 독자적인 값이 동기화됩니다.

sequenceDiagram
  participant Owner as 소유자의 클라이언트
  participant Room as 룸(sync)
  participant Other as 다른 클라이언트
  Owner ->> Room: world.Instantiate로 캐릭터를 생성
  Room -->> Other: 생성을 배포(Prefab으로부터 GameObject를 만든다)
  loop 이동할 때마다
    Owner ->> Room: 변경된 값만 전송(NetworkTransform)
    Room -->> Other: 배포하고, 수신한 위치로 보간하여 표시
  end
  Note over Room,Other: 나중에 참가한 플레이어에게는<br/>그 시점의 상태(스냅샷)가 도착
  • 값을 변경할 수 있는 사람을 서버가 관리합니다. 플레이어 오브젝트는 소유자만, 조작 권한을 대여하는 오브젝트는 조작 권한을 얻은 1명만 변경할 수 있습니다. 다른 참가자의 쓰기는 룸이 거부합니다.
  • Photon(PUN2)과 같은 감각으로 사용할 수 있습니다. 플레이어 오브젝트 생성, RPC, 룸 이벤트, 룸·플레이어의 커스텀 프로퍼티, 마스터 클라이언트, Interest Group을 갖추고 있습니다. 대응표는 Photon에서의 이전 가이드를 참조해 주세요.
  • 통신량을 줄입니다. 필드 이름을 보내지 않고, 변경된 필드의 번호와 정수 값만 보냅니다. 위치 등의 정기적인 갱신은 UDP로 보내고, 도착하지 않은 분량은 WebSocket으로 보완합니다(WebGL에서는 WebSocket만으로 동작합니다).
  • 재접속에 강한 구성입니다. 재접속하면 그 시점의 상태로부터 표시를 다시 만듭니다. 클라이언트에서 조작 이력을 다시 실행할 필요는 없습니다.

룸의 룰을 작성하지 않고 사용할 수 있습니다. 룸에 생성시킬 Prefab이나 호출할 수 있는 RPC를 제한하고 싶을 때는 네임스페이스 설정의 syncSetting.objectCatalog에 오브젝트 카탈로그를 설정합니다.

절차를 따라 시험해 보려면 튜토리얼: 플레이어 캐릭터 동기화하기를, Unity의 설정과 API는 Unity 클라이언트를, Godot의 설정과 API는 Godot 클라이언트를 참조해 주세요.

롤백 방식 동기화

액션 게임처럼 입력한 순간에 캐릭터가 움직이기를 원하면서도 위치 변조는 막고 싶은 경우에 사용하는 동기화 방식입니다. 서버 타입 stateMachine 룸에서, 룰에 틱(일정 간격의 시뮬레이션)을 정의하여 사용합니다.

  • 위치는 서버가 정합니다. 클라이언트는 “오른쪽으로 이동”, “쏘기"와 같은 입력만 보내고, 룸이 초당 정해진 횟수(1~60회) 전원의 입력으로부터 오브젝트를 움직입니다. 클라이언트는 위치를 쓸 수 없으므로 이동 속도 변조나 벽 통과를 막을 수 있습니다.
  • 자신의 캐릭터는 기다리지 않고 움직입니다. 룰의 이동 처리에 [Predict]를 붙이면 컴파일러가 같은 처리를 Unity용 C#(Godot에서는 GDScript)으로도 출력합니다. 클라이언트는 그것을 사용하여 입력한 틱의 결과를 바로 표시합니다(예측).
  • 어긋남은 서버의 결과로 되돌려 바로잡습니다. 룸의 계산 결과가 도착하면 클라이언트는 그 틱의 상태까지 되돌리고, 현재 틱까지 다시 계산합니다(롤백). 다른 플레이어와 부딪히는 등으로 예측이 빗나가더라도 표시를 약 0.1초에 걸쳐 눈에 띄지 않게 보정합니다.
sequenceDiagram
  participant Client as 자신의 클라이언트
  participant Room as 룸(stateMachine)
  Client ->> Client: 틱 10의 입력을 바로 예측하여 표시
  Client ->> Room: 틱 10의 입력을 보낸다
  Client ->> Client: 틱 11, 12, ...도 예측하여 표시
  Room ->> Room: 틱 10을 전원의 입력으로 계산
  Room -->> Client: 틱 10의 결과
  Client ->> Client: 틱 10의 결과로 되돌리고,<br/>현재 틱까지 다시 계산
  • 쏜 쪽의 화면대로 맞습니다(지연 보상). 입력에는 그때 화면이 얼마나 늦게 표시되고 있었는지가 붙습니다. 룸은 Room.Raycast·Room.Overlap 판정에서 다른 오브젝트를 쏜 쪽이 보고 있던 위치까지 되돌려 판정합니다(최대 500밀리초).
  • 탄도 바로 표시할 수 있습니다(예측 스폰). 예측하는 처리 안에서 생성한 탄은 쏜 플레이어의 화면에 바로 표시되고, 룸이 생성한 탄에 그대로 인계됩니다.
  • 인원이 많아도 통신량을 줄입니다. 먼 오브젝트의 갱신을 줄여서 보낼 수 있습니다.

룰의 계산은 정수만으로 수행하므로, 룸과 클라이언트의 예측에서 같은 결과가 됩니다. 다른 플레이어의 캐릭터는 예측하지 않고, 룸의 결과를 보간하여 표시합니다.

절차를 따라 시험해 보려면 튜토리얼: 롤백 방식 동기화로 캐릭터 움직이기를, 룰 작성 방법은 틱을 참조해 주세요. SDK에는 예측·지연 보상이 적용된 사격·예측 스폰을 사용하는 샘플(Assets/Scenes/Samples/Realtime/Arena)이 있습니다.

스테이트 머신을 사용한 서버 사이드 로직

서버 타입 stateMachine 룸은 오브젝트 동기화 기능에 더해, GS2-StateMachine에 등록한 룰을 룸 안에서 실행합니다. 적의 HP, 공격 가능 여부, 보스의 페이즈, 제한 시간처럼 클라이언트에 맡기면 변조될 수 있는 처리를 서버에서 수행할 수 있습니다.

룰은 C#으로 작성합니다. 컴파일러가 C#으로부터 룸에서 실행하는 룰(GSL)과, Unity에서 사용하는 동기화 스키마·조작 번호 enum을 동시에 생성하므로, 서버와 클라이언트에서 값의 번호가 어긋나지 않습니다. Godot으로 게임을 만드는 경우에는 룰을 GDScript로 작성하고, Godot에서 사용하는 동기화 스키마와 상수 클래스를 생성할 수 있습니다(GDScript로 룰 작성하기).

graph LR
  CS["C# 룰"] --> Gen["Unity의<br/>Generate from C#"]
  Gen --> GSL["main.gsl"]
  Gen --> Unity["동기화 스키마·enum<br/>(Unity용)"]
  GSL --> Master["GS2-StateMachine<br/>StateMachineMaster"]
  Master --> Room["룸(stateMachine)<br/>이 룰을 실행"]
  Unity --> Client["Unity 클라이언트"]
  Client -- "Interact(조작)" --> Room
  Room -- "확정된 값을 배포" --> Client
룰이 받는 것호출되는 시점예
Start룸 시작 시에 한 번적이나 문을 생성한다
Interact플레이어가 SharedObject.Interact로 조작을 보냈을 때공격을 검증하여 HP를 줄인다
TimerRoom.After로 예약한 시각이 되었을 때8초 후에 적을 부활시킨다
Tick일정 간격마다전원의 입력으로부터 캐릭터를 움직인다(롤백 방식 동기화)
Spawned플레이어가 자신의 오브젝트를 생성한 직후팀별 출현 위치에 배치한다
  • 1회의 조작은 한꺼번에 확정되거나 한꺼번에 취소됩니다. 룰이 Step.Ignore로 거부하면 그 조작으로 수행한 변경은 모두 취소되고, 사유 코드가 조작한 클라이언트에 전달됩니다.
  • 룰의 버전을 관리할 수 있습니다. 룸은 할당되었을 때 룰을 읽어 들이고, 끝날 때까지 같은 버전으로 동작합니다. 룰을 다시 등록하면 그 이후에 할당되는 룸부터 새로운 룰이 사용됩니다.
  • 룸 안에서 완결됩니다. 룰에서는 외부 API나 GS2-Script를 호출할 수 없습니다. 룸의 상태는 룸이 끝나면 사라지므로, 보상 지급이나 결과 저장은 룸 바깥에서 GS2의 각 서비스를 사용하여 수행합니다.

절차를 따라 시험해 보려면 튜토리얼: 서버에서 HP를 관리하는 적 만들기를, 룰 작성 방법은 룸 정의 레퍼런스를 참조해 주세요.

도입 흐름

만들고 싶은 것에 맞춰 서버 타입을 선택하고, 튜토리얼부터 시작해 주세요.

만들고 싶은 것서버 타입튜토리얼
플레이어의 위치나 상태를 공유하고 싶다sync플레이어 캐릭터 동기화하기
적의 HP나 게임 진행을 서버에서 관리하고 싶다stateMachine서버에서 HP를 관리하는 적 만들기
입력으로 움직이는 캐릭터를 지연을 느끼지 않게 움직이고 싶다stateMachine(틱)롤백 방식 동기화로 캐릭터 움직이기
독자적인 형식의 메시지를 중계하고 싶다relay이 페이지의 구현 예제

sync와 stateMachine에 공통된 준비는 다음과 같습니다.

  1. Unity 프로젝트(Unity 2021.3 이상)에 GS2 SDK for Unity를 도입합니다. 동기화 컴포넌트(Gs2.Realtime.Sync)는 SDK에 포함되어 있습니다. stateMachine 룰을 C#으로 작성하는 경우에는 LocalStateMachineKit의 C# 생성 기능을 포함한 버전을 사용합니다.
  2. GS2-Realtime 네임스페이스를 만들고 serverType을 설정합니다. stateMachine에서는 룰을 등록한 GS2-StateMachine의 네임스페이스도 지정합니다.
  3. GS2-Matchmaking으로 플레이어를 모으고, RoomWant로 룸을 준비합니다.
  4. Unity에서는 씬에 NetworkWorld와 NetworkSession을 배치하고, 룸의 접속 정보(IP 주소·포트·암호화 키)와 액세스 토큰을 전달하여 접속합니다.

Godot(Godot 4)의 경우에는 순서 1에서 GS2 SDK for Godot을 도입하고, 순서 4에서 씬에 Gs2NetworkWorld와 Gs2NetworkSession을 배치합니다. stateMachine 룰은 GDScript로 작성할 수 있습니다. 자세한 내용은 Godot 클라이언트를 참조해 주세요.

서버 스펙

서버의 성능을 설정할 수 있습니다. 성능에 따라 1분당 이용 요금에 차이가 발생합니다. 가장 저렴한 realtime1.nano에서 8명의 플레이어가 1초에 3회 메시지를 주고받을 수 있음을 확인했습니다.

검토 중인 Unreal Engine Dedicated Server 호스팅에서는 요구 스펙이 이보다 높아질 것으로 예상됩니다. 개발 효율이 아닌 비용 효율이 가장 중요한 프로젝트에서는 Unreal Engine Dedicated Server 사용을 권장하지 않습니다.

서버 스펙은 Namespace마다 설정하며, serverSpec 필드에 realtime1.nano와 같은 식별자를 지정합니다.

라이프사이클

게임 서버는 기동 리퀘스트를 접수한 후부터 준비가 시작됩니다.

이때, 기동 리퀘스트가 빈번하게 발생하는 게임 서버에 대해서는 GS2가 핫 스탠바이를 준비합니다. 따라서 기동 리퀘스트를 접수한 직후에 할당이 이루어질 것으로 기대할 수 있지만, 기동 리퀘스트가 빈번하게 발생하지 않는 소규모 게임에서는 기동 리퀘스트부터 실제 할당까지 시간이 걸립니다.

핫 스탠바이에서 할당하는 경우를 웜 스타트, 서버를 새로 기동하여 할당하는 경우를 콜드 스타트라고 부릅니다. 콜드 스타트 시 할당에 필요한 예상 시간은 40초60초 정도, 웜 스타트 시 할당에 필요한 시간은 1초3초로 가정해 주시기 바랍니다.

기동 리퀘스트가 빈번하게 발생하지 않는 규모의 타이틀에서 콜드 스타트 시간을 허용할 수 없는 경우, 매월 고정 비용이 발생하는 것을 전제로 핫 스탠바이를 제공할 수 있습니다. 핫 스탠바이 계약은 5대부터 접수하고 있습니다.

핫 스탠바이를 계약했거나 기동 리퀘스트가 빈번하게 발생하는 상황이라도 콜드 스타트가 발생하지 않는다는 것을 보장할 수는 없습니다. 핫 스탠바이가 준비되는 것보다 빠르게 서버 기동 리퀘스트가 발생하거나, 게임 서버의 버전 업 시에는 콜드 스타트가 발생할 가능성이 있습니다. 따라서 최악의 경우 콜드 스타트가 발생하는 상황을 염두에 두고 시스템을 설계해 주시기 바랍니다.

스타트 종류

종류소요 시간설명
웜 스타트1~3초핫 스탠바이에서 즉시 할당
콜드 스타트40~60초서버 프로세스를 새로 기동

룸 종료 조건

기동된 룸은 다음 조건에서 종료됩니다.

  • 룸 생성 후 5분간 아무도 접속하지 않은 경우
  • 룸에 참가하는 모든 플레이어로부터 1분간 무통신 상태가 지속된 경우
  • 룸의 최대 가동 시간인 3시간이 경과한 경우

또한, 명시적으로 RoomShutdown을 호출하여 룸을 즉시 종료시킬 수도 있습니다.

또한, 핫 스탠바이의 룸에도 동일한 종료 처리가 적용되지만, 핫 스탠바이의 가동 시간은 이용 요금에 가산되지 않습니다.

룸 접속

GS2-Realtime은 다음 흐름으로 접속합니다.

sequenceDiagram
  participant Player
  participant Realtime as GS2-Realtime
  participant Server as GameServer
  Player ->> Realtime: Room(roomName).Model()
  Realtime -->> Player: IpAddress / Port / EncryptionKey
  Player ->> Server: RelayRealtimeSession.ConnectAsync()
  Server -->> Player: 접속 완료
  Note over Player,Server: 이후에는 게임 서버와 직접 WebSocket 통신

접속 정보는 다음 세 가지로 구성됩니다.

  • IpAddress: 게임 서버의 IP 주소
  • Port: 접속 대상 포트 번호
  • EncryptionKey: 메시지 페이로드 암호화 키

접속 시에는 액세스 토큰과 플레이어의 프로필 초기값을 전달합니다.

프로필

릴레이 서버는 수신한 메시지를 다른 플레이어에게 전파할 뿐만 아니라, 플레이어별로 프로필 데이터를 가질 수 있습니다.

새로운 플레이어가 게임 서버에 접속했을 때, 참가 중인 다른 모든 플레이어의 프로필 데이터를 받을 수 있습니다. 플레이어의 기본 정보를 저장해 둠으로써, 신규 플레이어가 접속했을 때의 처리를 간소화할 수 있습니다.

프로필을 갱신하면 다른 플레이어에게 그 내용이 전송되므로 메시지 전송 대신 사용할 수도 있지만, 갱신 시 페이로드 전체가 송수신되는 프로필 갱신으로 높은 빈도의 메시징을 수행하는 것은 통신 효율 면에서 최적이 아닙니다.

프로필은 바이너리 페이로드로서 임의의 형식으로 인코딩할 수 있습니다. 플레이어의 캐릭터 정보, 장비, 레벨, 게임 내 통화 등의 스냅샷을 저장하는 데 적합합니다.

이벤트 핸들링

RelayRealtimeSession에는 다음 이벤트 핸들러를 설정할 수 있습니다.

핸들러발생 시점
OnJoinPlayer다른 플레이어가 룸에 참가했을 때
OnLeavePlayer다른 플레이어가 룸에서 퇴장했을 때
OnRelayMessage다른 플레이어로부터 릴레이 메시지를 수신했을 때
OnUpdateProfile다른 플레이어가 프로필을 갱신했을 때
OnError프로토콜 오류가 발생했을 때
OnGeneralError통신 오류가 발생했을 때
OnClose게임 서버와의 접속이 끊어졌을 때

각 이벤트에는 MessageMetadata를 포함하는 확장판(OnRelayMessageWithMetadata 등)도 준비되어 있어, 메시지의 메타 정보를 함께 취득할 수 있습니다.

푸시 알림

설정할 수 있는 주요 푸시 알림과 설정명은 다음과 같습니다.

  • createNotification: 룸 할당 시 알림

enableTransferMobileNotification을 활성화하면 오프라인 단말로의 모바일 푸시 전송에도 대응합니다.

GS2-Matchmaking으로 모인 멤버 전원에게 룸 할당을 알림으로써, 대전 준비 완료를 실시간으로 알릴 수 있습니다.

마스터 데이터 운용

GS2-Realtime은 마스터 데이터를 필요로 하지 않습니다. 네임스페이스 설정(서버 타입·서버 스펙·푸시 알림 설정)만으로 운용할 수 있습니다.

트랜잭션 액션

GS2-Realtime에서는 트랜잭션 액션을 제공하지 않습니다.

다른 마이크로서비스와의 연계

GS2-Realtime은 단독으로 사용하기보다는 다음 마이크로서비스와 조합하여 사용하는 것이 일반적입니다.

서비스용도
GS2-Matchmaking대전 상대를 매칭하고, 성립 후 RoomWant를 호출
GS2-Gateway푸시 알림 경로로 createNotification을 이용
GS2-Account플레이어의 액세스 토큰을 발행

구현 예제

게임 서버 접속 정보 취득

룸 이름을 지정하여 접속 대상 정보를 취득합니다. RoomWant를 경유하여 매치메이킹을 통해 룸이 준비된 경우에는 해당 roomName을 지정합니다.

    var item = await gs2.Realtime.Namespace(
        namespaceName: "namespace-0001"
    ).Room(
        roomName: "room-0001"
    ).ModelAsync();

    var ipAddress = item.IpAddress;
    var port = item.Port;
    var encryptionKey = item.EncryptionKey;
    const auto Domain = Gs2->Realtime->Namespace(
        "namespace-0001" // namespaceName
    )->Room(
        "room-0001" // roomName
    );
    const auto Future = Domain->Model();
    Future->StartSynchronousTask();
    if (Future->GetTask().IsError()) return false;
    const auto Result = Future->GetTask().Result();

    const auto IpAddress = Result->GetIpAddress();
    const auto Port = Result->GetPort();
    const auto EncryptionKey = Result->GetEncryptionKey();
var domain = ez.realtime.namespace_(
        "namespace-0001"
    ).room(
        "room-0001"
    )

var async_result = await domain.model()
if async_result.error != null:
    push_error(str(async_result.error))
    return

var result = async_result.result

게임 서버에 접속

    using (
      var session = new RelayRealtimeSession(
         accessToken, // 액세스 토큰
         ipAddress, // 게임 서버의 IP 주소
         port, // 게임 서버의 포트
         encryptionKey, // 암호화 키
         ByteString.CopyFromUtf8("my profile") // 프로필 초기값
      )
    )
    {
      // 이벤트 핸들러를 설정

      await session.ConnectAsync();

      // 세션이 유효한 스코프
    }
    // Unreal Engine용 Realtime SDK는 현재 준비 중입니다.
var session = Gs2RelayRealtimeSession.new(
    game_session.access_token.token, ip_address, port, encryption_key,
    "my profile".to_utf8_buffer()
)
var async_result = await session.connect_session()
if async_result.error != null:
    push_error(str(async_result.error))
    return
session.dispatch()

다른 플레이어의 접속 핸들링

    session.OnJoinPlayer += player => {
        var connectionId = player.ConnectionId;
        var profile = player.Profile;
        // 신규 참가자의 초기 표시 등을 수행
    };
    // Unreal Engine용 Realtime SDK는 현재 준비 중입니다.
session.join_player.connect(func(player):
    var connection_id = player.connection_id
    var profile = player.profile
    # Initialize the newly joined player in the game UI.
)

다른 플레이어의 접속 해제 핸들링

    session.OnLeavePlayer += player => {
        // 퇴장한 플레이어의 표시를 정리
    };
    // Unreal Engine용 Realtime SDK는 현재 준비 중입니다.
session.leave_player.connect(func(player):
    # Remove the player who left from the game UI.
    pass
)

다른 플레이어로부터의 메시지 핸들링

    session.OnRelayMessage += message => {
        var sourceConnectionId = message.ConnectionId;
        var payload = message.Data;
        // payload 를 애플리케이션 계층에서 복호화·해석
    };
    // Unreal Engine용 Realtime SDK는 현재 준비 중입니다.
session.relay_message.connect(func(message):
    var source_connection_id = message.connection_id
    var payload = message.data
    # Decode and handle the payload in the application layer.
)

다른 플레이어의 프로필 갱신 핸들링

    session.OnUpdateProfile += player => {
        // 프로필 변경 사항을 화면에 반영
    };
    // Unreal Engine용 Realtime SDK는 현재 준비 중입니다.
session.update_profile_received.connect(func(player):
    # Reflect the changed profile in the game UI.
    pass
)

게임 서버로부터의 접속 해제 핸들링

    session.OnClose += () => {
        // 접속 해제 시 재시도·화면 전환 처리
    };
    // Unreal Engine용 Realtime SDK는 현재 준비 중입니다.
session.closed.connect(func():
    # Retry the connection or transition to an error screen.
    pass
)

프로필 갱신

    await session.UpdateProfileAsync(
      ByteString.CopyFromUtf8("my profile2")
    );
    // Unreal Engine용 Realtime SDK는 현재 준비 중입니다.
var async_result = await session.update_profile(
    "my profile2".to_utf8_buffer()
)
if async_result.error != null:
    push_error(str(async_result.error))
    return

브로드캐스트 메시지 전송

targetConnectionIds를 생략하면 자신을 제외한 룸 내 모든 플레이어에게 배포됩니다.

    await session.SendAsync(
      ByteString.CopyFrom(0x00, 0x01, 0x02)
    );
    // Unreal Engine용 Realtime SDK는 현재 준비 중입니다.
var async_result = await session.send(
    PackedByteArray([0x00, 0x01, 0x02])
)
if async_result.error != null:
    push_error(str(async_result.error))
    return

유니캐스트 메시지 전송

targetConnectionIds에 대상 플레이어의 ConnectionId를 지정합니다. ConnectionId는 OnJoinPlayer 등에서 받을 수 있습니다.

    await session.SendAsync(
      ByteString.CopyFrom(0x00, 0x01, 0x02),
      new uint[] { targetConnectionId1, targetConnectionId2 }
    );
    // Unreal Engine용 Realtime SDK는 현재 준비 중입니다.
var async_result = await session.send(
    PackedByteArray([0x00, 0x01, 0x02]),
    [target_connection_id]
)
if async_result.error != null:
    push_error(str(async_result.error))
    return

설계 시 주의사항

바이너리 페이로드 설계

GS2-Realtime은 바이너리 데이터를 그대로 중계할 뿐, 내용을 해석하지 않습니다. 따라서 다음 사항은 애플리케이션 측에서 설계해야 합니다.

  • 메시지 종류를 식별하기 위한 헤더(선두 1바이트에 opcode를 넣는 등)
  • 직렬화 형식(Protocol Buffers / FlatBuffers / MessagePack 등)
  • 순서 보장의 필요성(필요한 경우 애플리케이션 계층에서 시퀀스 번호를 부여)

치트 대책

릴레이 서버는 페이로드의 내용을 해석하지 않으므로, 치트 행위 자체를 탐지할 수는 없습니다. 레이팅 계산 등에서는 투표를 통한 다수결로 결과를 결정합니다.

상세 레퍼런스