Gameye + AWS FlexMatch

{
  "Name": "your-matchmaking-config",
  "FlexMatchMode": "STANDALONE",
  "RequestTimeoutSeconds": 30,
  "AcceptanceRequired": false,
  "BackfillMode": "MANUAL",
  "RuleSetName": "your-ruleset",
  "NotificationTarget": "arn:aws:sns:us-east-1:YOUR_ACCOUNT:matchmaking-events"
}

// Fetch available regions for your image
const { locations } = await fetch(
  'https://api.gameye.io/available-location/your-image-name',
  { headers: { Authorization: `Bearer ${GAMEYE_TOKEN}` } }
).then(r => r.json());

// Measure latency to each region's pingable IP
const latencies: Record<string, number> = {};
for (const loc of locations) {
  latencies[loc.location] = await measurePing(loc.latencyIp); // ms
}

// Submit ticket — include latency as playerAttributes
await gamelift.startMatchmaking({
  ConfigurationName: 'your-matchmaking-config',
  Players: [{
    PlayerId: player.id,
    PlayerAttributes: {
      skill:             { N: player.mmr },
      gameye_europe_ms:  { N: latencies['europe']    ?? 9999 },
      gameye_useast_ms:  { N: latencies['us-east']   ?? 9999 },
      gameye_asia_ms:    { N: latencies['asia-east'] ?? 9999 },
    }
  }]
}).promise();

export async function handler(event: EventBridgeEvent) {
  const { matchId, tickets } = event.detail;
  const players = tickets.flatMap(t => t.players);

  // Select region with lowest worst-case latency across all players
  const region = selectBestRegion(players);

  // Start Gameye session
  const res = await fetch('https://api.gameye.io/session', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.GAMEYE_API_TOKEN}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      location: region,
      image:    'your-image-name',
      version:  process.env.GAME_IMAGE_VERSION,
      args:     ['/Game/Maps/Gameplay', `-maxplayers=${players.length}`],
      labels:   { match_id: matchId },
      ttl:      3600,
    }),
  });

  const session = await res.json();
  // session.host  → IP address
  // session.ports → [{ type: 'udp', container: 7777, host: 34521 }]
  const port = session.ports.find(p => p.type === 'udp').host;

  await saveMatchSession(matchId, session.host, port); // e.g. DynamoDB
  await notifyPlayers(players, { host: session.host, port });
}

function selectBestRegion(players: FlexMatchPlayer[]): string {
  const regions = {
    'europe':    'gameye_europe_ms',
    'us-east':   'gameye_useast_ms',
    'asia-east': 'gameye_asia_ms',
  };
  return Object.entries(regions)
    .map(([region, attr]) => ({
      region,
      worstMs: Math.max(...players.map(p => p.playerAttributes?.[attr]?.N ?? 9999))
    }))
    .sort((a, b) => a.worstMs - b.worstMs)[0].region;
}

# Player connected
POST https://api.gameye.io/session/player/join
{ "sessionId": "session-id", "playerId": "player-id" }

# Player disconnected
POST https://api.gameye.io/session/player/leave
{ "sessionId": "session-id", "playerId": "player-id" }