Skip to main content Skills Marktplatz Entdecken und erkunden Sie KI-Skills, die von der Community erstellt wurden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Prompt-Details anzeigen Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
npx skills add https://github.com/pluginagentmarketplace/custom-plugin-server-side-game-dev --skill communication-protocolsDer Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.
Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.
ZIP herunterladen Herunterladen... name communication-protocols description Game server communication protocols including gRPC, REST, and custom binary protocols sasmp_version 1.3.0 version 2.0.0 bonded_agent 02-networking-specialist bond_type SECONDARY_BOND parameters {"required":["protocol_type"],"optional":["serialization_format","compression"],"validation":{"protocol_type":{"type":"string","enum":["grpc","rest","websocket","custom_binary","quic"]},"serialization_format":{"type":"string","enum":["protobuf","json","msgpack","flatbuffers"],"default":"protobuf"},"compression":{"type":"string","enum":["none","gzip","lz4","zstd"],"default":"none"}}} retry_config {"max_attempts":3,"backoff":"exponential","initial_delay_ms":100,"retryable_errors":["UNAVAILABLE","DEADLINE_EXCEEDED"]} observability {"logging":{"level":"info","fields":["protocol","method","duration_ms","status"]},"metrics":[{"name":"rpc_duration_seconds","type":"histogram"},{"name":"rpc_requests_total","type":"counter"},{"name":"rpc_errors_total","type":"counter"},{"name":"message_size_bytes","type":"histogram"}]}
Communication Protocols for Game Servers
Implement efficient communication protocols between game services and clients.
Protocol Selection Guide
Protocol Latency Throughput Use Case Custom Binary Lowest Highest Real-time gameplay gRPC Low High Service-to-service WebSocket Low Medium Browser clients REST Medium Medium Admin APIs, lobbies QUIC Low High Mobile, unreliable networks
gRPC for Game Services
// matchmaking.proto
syntax = "proto3";
package game.matchmaking;
service Matchmaking {
rpc FindMatch(MatchRequest) returns (MatchResponse);
rpc JoinQueue(QueueRequest) returns (stream QueueUpdate);
rpc CancelQueue(CancelRequest) returns (CancelResponse);
}
message MatchRequest {
string player_id = 1;
string game_mode = 2;
int32 skill_rating = 3;
repeated string preferred_regions = 4;
}
message MatchResponse {
string match_id = 1;
string server_address = 2;
int32 server_port = 3;
repeated TeamAssignment teams = 4;
string connection_token = 5;
}
message QueueUpdate {
enum Status {
SEARCHING = 0;
MATCH_FOUND = 1;
CANCELLED = 2;
}
Status status = 1;
int32 estimated_wait_seconds = 2;
int32 players_in_queue = 3;
}
Go gRPC Server
type matchmakingServer struct {
pb.UnimplementedMatchmakingServer
matchmaker *Matchmaker
}
func (s *matchmakingServer) error ) {
match, err := s.matchmaker.FindMatch(ctx, req.PlayerId, req.GameMode, req.SkillRating)
if err != nil {
return nil , status.Errorf(codes.Internal, "matchmaking failed: %v" , err)
}
return
int32
nil
func (s *matchmakingServer)
error
defer
for
range
if
nil
return
if
return
nil
return
nil
Custom Binary Protocol
struct PacketHeader {
uint8_t type;
uint8_t flags;
uint16_t length;
uint32_t sequence;
};
enum PacketType : uint8_t {
PLAYER_INPUT = 0x01 ,
STATE_UPDATE = 0x02 ,
PLAYER_JOIN = 0x03 ,
PLAYER_LEAVE = 0x04 ,
CHAT_MESSAGE = 0x10 ,
PING = 0xFE ,
PONG = 0xFF
};
enum PacketFlags : uint8_t {
FLAG_RELIABLE = 0x01 ,
FLAG_COMPRESSED = 0x02 ,
FLAG_ENCRYPTED = 0x04
};
class PacketBuilder {
uint8_t buffer[MAX_PACKET_SIZE];
size_t offset = sizeof (PacketHeader);
public :
PacketBuilder& writeU8 (uint8_t v) {
buffer[offset++] = v;
return *this ;
}
PacketBuilder& writeU16 (uint16_t v) {
*reinterpret_cast <uint16_t *>(&buffer[offset]) = htons (v);
offset += 2 ;
return *this ;
}
PacketBuilder& writeFloat (float v) {
*reinterpret_cast <float *>(&buffer[offset]) = v;
offset += 4 ;
return *this ;
}
std::span<uint8_t > build (PacketType type, uint8_t flags = 0 ) {
auto * header = reinterpret_cast <PacketHeader*>(buffer);
header->type = static_cast <uint8_t >(type);
header->flags = flags;
header->length = htons (offset - sizeof (PacketHeader));
header->sequence = htonl (nextSequence++);
return {buffer, offset};
}
};
struct PlayerInputPacket {
uint32_t tick;
uint8_t keys;
int16_t aim_x;
int16_t aim_y;
};
WebSocket for Browser Games
const WebSocket = require ('ws' );
const wss = new WebSocket .Server ({
port : 8080 ,
perMessageDeflate : true ,
maxPayload : 64 * 1024
});
wss.on ('connection' , (ws, req ) => {
const playerId = authenticate (req);
ws.on ('message' , (data, isBinary ) => {
if (isBinary) {
const view = new DataView (data.buffer );
const type = view.getUint8 (0 );
handleBinaryMessage (playerId, type, view);
} else {
const msg = JSON .parse (data);
handleJsonMessage (playerId, msg);
}
});
ws.on ('close' , () => {
onPlayerDisconnect (playerId);
});
const tickInterval = setInterval (() => {
if (ws.readyState === WebSocket .OPEN ) {
const state = serializeGameState (playerId);
ws.send (state, { binary : true });
}
}, 16 );
ws.on ('close' , () => clearInterval (tickInterval));
});
class GameClient {
constructor (url ) {
this .ws = new WebSocket (url);
this .ws .binaryType = 'arraybuffer' ;
this .ws .onmessage = (event ) => {
if (event.data instanceof ArrayBuffer ) {
this .handleStateUpdate (new DataView (event.data ));
} else {
this .handleJsonMessage (JSON .parse (event.data ));
}
};
}
sendInput (keys, aimX, aimY ) {
const buffer = new ArrayBuffer (9 );
const view = new DataView (buffer);
view.setUint32 (0 , this .currentTick );
view.setUint8 (4 , keys);
view.setInt16 (5 , aimX);
view.setInt16 (7 , aimY);
this .ws .send (buffer);
}
}
REST API for Game Services
type LobbyHandler struct {
lobbyService *LobbyService
}
func (h *LobbyHandler) var req CreateLobbyRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
respondError(w, http.StatusBadRequest, "invalid request body" )
return
}
lobby, err := h.lobbyService.Create(r.Context(), req)
if err != nil {
switch {
case errors.Is(err, ErrPlayerAlreadyInLobby):
respondError(w, http.StatusConflict, err.Error())
case errors.Is(err, ErrMaxLobbiesReached):
respondError(w, http.StatusTooManyRequests, err.Error())
default :
respondError(w, http.StatusInternalServerError, "internal error" )
}
return
}
respondJSON(w, http.StatusCreated, lobby)
}
func respondJSON (w http.ResponseWriter, status int , data interface {}) "Content-Type" , "application/json" )
w.WriteHeader(status)
json.NewEncoder(w).Encode(data)
}
Protocol Selection Matrix Scenario Protocol Reason Real-time gameplay Custom UDP binary Lowest latency Microservices gRPC Type safety, streaming Web/mobile lobby WebSocket JSON Browser compatibility Admin dashboard REST Standard tooling Streaming updates gRPC streaming Backpressure handling
Troubleshooting
Common Failure Modes Error Root Cause Solution Connection reset Message too large Chunk large messages Timeout Slow processing Async handlers Parse error Version mismatch Protocol versioning High latency No compression Enable compression
Debug Checklist
GRPC_VERBOSITY=DEBUG GRPC_TRACE=all ./game-server
wscat -c ws://localhost:8080
protoc --decode=game.StateUpdate game.proto < message.bin
tcpdump -i any port 8080 -w capture.pcap
Unit Test Template func TestMatchmakingRPC (t *testing.T) defer server.Stop()
conn, err := grpc.Dial(server.Addr, grpc.WithInsecure())
require.NoError(t, err)
defer conn.Close()
client := pb.NewMatchmakingClient(conn)
resp, err := client.FindMatch(context.Background(), &pb.MatchRequest{
PlayerId: "player123" ,
GameMode: "ranked" ,
SkillRating: 1500 ,
})
require.NoError(t, err)
assert.NotEmpty(t, resp.MatchId)
assert.NotEmpty(t, resp.ServerAddress)
}
func TestBinaryProtocol (t *testing.T) 12345 ).
WriteU8(0x0F ).
WriteI16(1000 ).
WriteI16(-500 ).
Build(PLAYER_INPUT)
parsed := ParsePlayerInput(packet)
assert.Equal(t, uint32 (12345 ), parsed.Tick)
assert.Equal(t, uint8 (0x0F ), parsed.Keys)
}
Resources
assets/ - Protocol templatesreferences/ - Performance benchmarks Mehr aus diesem Repository Verwandte Berufe SOC
Basierend auf der SOC-Berufsklassifikation
