game-networking

Purpose

This skill allows the AI to implement multiplayer game networking, managing protocols (e.g., UDP, TCP), minimizing latency, and ensuring game state synchronization for seamless player interactions.

When to Use

Use this skill when building multiplayer games that require real-time communication, such as online shooters, MMOs, or cooperative adventures. Apply it for scenarios involving player synchronization, server-client architectures, or handling network interruptions in game loops.

Key Capabilities

• Handles UDP for low-latency, unreliable data transmission and TCP for reliable, ordered delivery.
• Implements latency compensation via interpolation and prediction algorithms to smooth gameplay.
• Synchronizes game states using techniques like delta encoding and authoritative servers.
• Supports NAT traversal and peer-to-peer connections for reduced server dependency.
• Manages bandwidth optimization through packet compression and prioritization.

Usage Patterns

To use this skill, first initialize a network context, then establish connections, send/receive data, and handle disconnections. Always wrap network operations in try-catch blocks for robustness. For example, in a game loop, check for incoming packets every frame and update game state accordingly. Use asynchronous patterns to avoid blocking the main thread. If authentication is needed, set the environment variable $GAME_NETWORKING_API_KEY before invoking commands.

Common Commands/API

Interact via OpenClaw CLI or REST API. CLI commands require the skill to be activated first with openclaw activate game-networking.

• CLI Commands:

  • Initialize a network session: openclaw game-networking init --protocol udp --port 5000 --key $GAME_NETWORKING_API_KEY
    • Example: Sets up a UDP server on port 5000, requiring an API key.
  • Send a packet: openclaw game-networking send --host 192.168.1.1 --data '{"player_pos": [10, 20]}'
    • Flags: --host for target IP, --data for JSON payload.
  • Receive packets: openclaw game-networking listen --timeout 5
    • Listens for incoming data with a 5-second timeout.

• API Endpoints:

  • POST /api/network/connect: Establishes a connection; body: {"protocol": "udp", "host": "localhost", "port": 5000}
    • Requires header: Authorization: Bearer $GAME_NETWORKING_API_KEY
  • GET /api/network/status: Retrieves current latency and connection stats; query param: ?sessionID=123
  • PUT /api/network/sync: Sends game state updates; body: {"state": {"players": [{"id": 1, "pos": [5, 10]}]}}

• Code Snippets:

  • Initialize and connect in Python:

    import openclaw
    api_key = os.environ.get('GAME_NETWORKING_API_KEY')
    session = openclaw.game_networking.init(protocol='udp', port=5000, key=api_key)
    session.connect(host='192.168.1.1')
    

  • Send data:

    data = {'player_pos': [10, 20]}
    openclaw.game_networking.send(session, data)
    

• Config Formats:

  • Use JSON for configurations, e.g.:

    {
      "protocol": "tcp",
      "maxLatency": 100,
      "syncInterval": 50
    }
    

    • Save as network-config.json and pass via CLI: openclaw game-networking init --config network-config.json

Integration Notes

Integrate this skill into game engines like Unity or Godot by importing the OpenClaw SDK and calling functions from your scripts. For Unity, add the OpenClaw package via NuGet and reference it in C# scripts. Always verify dependencies: ensure the skill is compatible with your game's architecture (e.g., client-server vs. P2P). If using with other OpenClaw skills, chain them; for example, use game-auth first to handle user logins, then pass the token to network commands via $GAME_NETWORKING_API_KEY. Test integrations in a simulated environment to handle firewall issues.

Error Handling

Anticipate common errors like connection timeouts, packet loss, or invalid API keys. Use try-except blocks for CLI/API calls; for example, catch NetworkError for failed connections. Specific patterns:

• If a command fails with "Timeout", retry up to 3 times with exponential backoff: openclaw game-networking send --retry 3.
• For API errors, check HTTP status codes (e.g., 401 for unauthorized; respond by prompting for $GAME_NETWORKING_API_KEY).
• In code, handle exceptions like this:

  try:
      response = openclaw.game_networking.listen(timeout=5)
  except openclaw.NetworkTimeoutError as e:
      print(f"Timeout occurred: {e}. Retrying...")
      # Implement retry logic here
  

Log errors with timestamps and include debug flags in commands, e.g., openclaw game-networking init --debug to output detailed traces.

Usage Examples

1. Set up a multiplayer lobby: Use this to create a simple server for player connections. First, run openclaw game-networking init --protocol tcp --port 8080 --key $GAME_NETWORKING_API_KEY. Then, in your game code, connect clients with: ```python import openclaw session = openclaw.game_networking.connect(host='localhost', port=8080) session.send({'action': 'join_lobby', 'player_name': 'User1'})

2. **Synchronize player positions in a real-time game:** Initialize with `openclaw game-networking init --protocol udp`. In the game loop, send updates: ```python
while game_running:
    pos = get_player_position()
    openclaw.game_networking.send(session, {'player_pos': pos})
    incoming = openclaw.game_networking.receive()
    if incoming: update_game_state(incoming)
``` This ensures low-latency synchronization, compensating for delays by interpolating positions.

## Graph Relationships
- Depends on: authentication (for secure connections), game-physics (for synchronized simulations)
- Related to: game-dev cluster skills like game-ai (for intelligent network behaviors), data-storage (for persisting game states)
- Conflicts with: none directly, but avoid overlapping with low-level socket implementations