1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

package networking
 
import (
    "encoding/binary"
    "net"
)
 
// GamePacket represents a UDP packet with custom reliability
type GamePacket struct {
    Header      PacketHeader
    Payload     []byte
}
 
type PacketHeader struct {
    SequenceNumber  uint32    // For ordering and ack
    AckBitfield     uint32    // Acks for last 32 packets
    LastAckedSeq    uint32    // Most recent sequence we've processed
    PacketType      uint8     // Type of packet
    Flags           uint8     // Reliability flags
    PayloadLength   uint16    // Length of payload
}
 
const (
    PacketTypeGameState   uint8 = 1
    PacketTypeInput       uint8 = 2
    PacketTypeReliable    uint8 = 3  // Reliable message (death, spawn, etc.)
    PacketTypeAck         uint8 = 4
)
 
const (
    FlagReliable    uint8 = 1 << 0  // Must be acknowledged
    FlagOrdered     uint8 = 1 << 1  // Must be processed in order
    FlagCompressed  uint8 = 1 << 2  // Payload is compressed
)
 
// ReliableUDPChannel provides reliability on top of UDP for critical messages
type ReliableUDPChannel struct {
    conn             *net.UDPConn
    localSequence    uint32
    remoteSequence   uint32
    pendingAcks      map[uint32]*PendingPacket
    receivedBitfield uint32
}
 
type PendingPacket struct {
    packet     GamePacket
    sentTime   int64
    retries    int
}
 
func (c *ReliableUDPChannel) SendReliable(payload []byte) error {
    packet := GamePacket{
        Header: PacketHeader{
            SequenceNumber:  c.localSequence,
            AckBitfield:     c.receivedBitfield,
            LastAckedSeq:    c.remoteSequence,
            PacketType:      PacketTypeReliable,
            Flags:           FlagReliable,
            PayloadLength:   uint16(len(payload)),
        },
        Payload: payload,
    }
    
    // Store for potential retransmission
    c.pendingAcks[c.localSequence] = &PendingPacket{
        packet:   packet,
        sentTime: time.Now().UnixNano(),
        retries:  0,
    }
    
    c.localSequence++
    return c.send(packet)
}
 
func (c *ReliableUDPChannel) SendUnreliable(payload []byte) error {
    // For game state - no retransmission needed
    packet := GamePacket{
        Header: PacketHeader{
            SequenceNumber:  c.localSequence,
            AckBitfield:     c.receivedBitfield,
            LastAckedSeq:    c.remoteSequence,
            PacketType:      PacketTypeGameState,
            Flags:           0,
            PayloadLength:   uint16(len(payload)),
        },
        Payload: payload,
    }
    
    c.localSequence++
    return c.send(packet)
}
 
// ProcessAcks handles incoming acknowledgements, removes packets from pending
func (c *ReliableUDPChannel) ProcessAcks(header PacketHeader) {
    // Mark the last acked sequence as received
    delete(c.pendingAcks, header.LastAckedSeq)
    
    // Process bitfield for previous 32 packets
    for i := uint32(0); i < 32; i++ {
        if header.AckBitfield & (1 << i) != 0 {
            seq := header.LastAckedSeq - i - 1
            delete(c.pendingAcks, seq)
        }
    }
}
 
// RetransmitPending resends packets that haven't been acknowledged
func (c *ReliableUDPChannel) RetransmitPending(timeout int64) {
    now := time.Now().UnixNano()
    
    for seq, pending := range c.pendingAcks {
        if now - pending.sentTime > timeout {
            pending.retries++
            pending.sentTime = now
            
            if pending.retries > 5 {
                // Too many retries - consider connection dead
                delete(c.pendingAcks, seq)
                continue
            }
            
            c.send(pending.packet)
        }
    }
}
 
func (c *ReliableUDPChannel) send(packet GamePacket) error {
    // Serialize and send
    return nil
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

interface Input {
  sequence: number;
  timestamp: number;
  moveDirection: { x: number; y: number };
  actions: string[];
}
 
interface PlayerState {
  position: { x: number; y: number; z: number };
  velocity: { x: number; y: number; z: number };
  rotation: number;
}
 
interface ServerUpdate {
  tick: number;
  lastProcessedInput: number;
  players: Map<string, PlayerState>;
}
 
class ClientPrediction {
  private pendingInputs: Input[] = [];
  private localState: PlayerState;
  private displayState: PlayerState;  // What player sees (smoothed)
  private inputSequence: number = 0;
 
  // Called every frame
  processLocalInput(input: Input): void {
    input.sequence = ++this.inputSequence;
    input.timestamp = Date.now();
    
    // 1. Apply input to local state immediately (prediction)
    this.localState = this.applyInput(this.localState, input);
    
    // 2. Send to server
    this.network.sendInput(input);
    
    // 3. Store for later reconciliation
    this.pendingInputs.push(input);
    
    // 4. Update display (with smoothing)
    this.updateDisplay();
  }
 
  // Called when server update arrives
  processServerUpdate(update: ServerUpdate): void {
    const myState = update.players.get(this.playerId);
    if (!myState) return;
 
    // 1. Set authoritative state
    this.localState = { ...myState };
    
    // 2. Remove acknowledged inputs
    this.pendingInputs = this.pendingInputs.filter(
      input => input.sequence > update.lastProcessedInput
    );
    
    // 3. Re-apply remaining (unacknowledged) inputs
    for (const input of this.pendingInputs) {
      this.localState = this.applyInput(this.localState, input);
    }
    
    // 4. Check for misprediction
    const error = this.calculatePositionError(this.displayState, this.localState);
    
    if (error > this.correctionThreshold) {
      // Smoothly correct visible position
      this.scheduleCorrection(this.localState);
    }
    
    this.updateDisplay();
  }
 
  private applyInput(state: PlayerState, input: Input): PlayerState {
    // Simulate one tick of movement
    const speed = 5.0;
    const dt = 1 / 60;  // 60 tick rate
    
    return {
      ...state,
      position: {
        x: state.position.x + input.moveDirection.x * speed * dt,
        y: state.position.y + input.moveDirection.y * speed * dt,
        z: state.position.z,
      },
    };
  }
 
  private updateDisplay(): void {
    // Interpolate towards predicted state for smooth visuals
    const t = 0.2;  // Interpolation factor
    this.displayState = {
      position: {
        x: this.displayState.position.x + (this.localState.position.x - this.displayState.position.x) * t,
        y: this.displayState.position.y + (this.localState.position.y - this.displayState.position.y) * t,
        z: this.displayState.position.z + (this.localState.position.z - this.displayState.position.z) * t,
      },
      velocity: this.localState.velocity,
      rotation: this.localState.rotation,
    };
  }
 
  private scheduleCorrection(targetState: PlayerState): void {
    // Animate towards correct position over ~100ms
    // to hide the correction from the player
  }
 
  private calculatePositionError(a: PlayerState, b: PlayerState): number {
    const dx = a.position.x - b.position.x;
    const dy = a.position.y - b.position.y;
    return Math.sqrt(dx * dx + dy * dy);
  }
 
  private correctionThreshold = 0.5;  // Correct if error > 0.5 units
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200

package sync
 
import (
    "bytes"
    "encoding/binary"
)
 
// EntityState represents the state of a game entity
type EntityState struct {
    ID          uint32
    Position    [3]float32
    Rotation    [4]float32  // Quaternion
    Velocity    [3]float32
    Animation   uint16
    Health      uint8
    Flags       uint8
}
 
// DeltaCompressor compresses game state using delta encoding
type DeltaCompressor struct {
    baseline      map[uint32]EntityState
    tickNumber    uint32
    baselineTick  uint32
}
 
// CompressDelta creates a delta-compressed snapshot
func (dc *DeltaCompressor) CompressDelta(
    tick uint32,
    entities []EntityState,
) []byte {
    buf := new(bytes.Buffer)
    
    // Write tick info
    binary.Write(buf, binary.LittleEndian, tick)
    binary.Write(buf, binary.LittleEndian, dc.baselineTick)
    
    for _, entity := range entities {
        baseline, hasBaseline := dc.baseline[entity.ID]
        
        if !hasBaseline {
            // New entity - send full state
            dc.writeFullEntity(buf, entity)
            continue
        }
        
        // Calculate which fields changed
        changed := dc.calculateDelta(baseline, entity)
        
        if changed == 0 {
            // No change - skip entirely
            continue
        }
        
        // Write entity ID and change mask
        binary.Write(buf, binary.LittleEndian, entity.ID)
        binary.Write(buf, binary.LittleEndian, changed)
        
        // Write only changed fields
        dc.writeDelta(buf, baseline, entity, changed)
    }
    
    return buf.Bytes()
}
 
// FieldMask tracks which fields changed
const (
    FieldPosition  uint16 = 1 << 0
    FieldRotation  uint16 = 1 << 1
    FieldVelocity  uint16 = 1 << 2
    FieldAnimation uint16 = 1 << 3
    FieldHealth    uint16 = 1 << 4
    FieldFlags     uint16 = 1 << 5
)
 
func (dc *DeltaCompressor) calculateDelta(a, b EntityState) uint16 {
    var changed uint16
    
    if !nearEqual(a.Position, b.Position, 0.001) {
        changed |= FieldPosition
    }
    if !nearEqualQuat(a.Rotation, b.Rotation, 0.001) {
        changed |= FieldRotation
    }
    if !nearEqual(a.Velocity, b.Velocity, 0.01) {
        changed |= FieldVelocity
    }
    if a.Animation != b.Animation {
        changed |= FieldAnimation
    }
    if a.Health != b.Health {
        changed |= FieldHealth
    }
    if a.Flags != b.Flags {
        changed |= FieldFlags
    }
    
    return changed
}
 
func (dc *DeltaCompressor) writeDelta(
    buf *bytes.Buffer,
    baseline, current EntityState,
    changed uint16,
) {
    if changed&FieldPosition != 0 {
        // Quantize position to 16-bit fixed-point deltas
        for i := 0; i < 3; i++ {
            delta := current.Position[i] - baseline.Position[i]
            quantized := quantizeFloat(delta, -100, 100, 16)
            binary.Write(buf, binary.LittleEndian, quantized)
        }
    }
    
    if changed&FieldRotation != 0 {
        // Smallest-three quaternion compression
        // Only send 3 components, derive 4th
        dc.writeSmallestThreeQuat(buf, current.Rotation)
    }
    
    if changed&FieldVelocity != 0 {
        for i := 0; i < 3; i++ {
            quantized := quantizeFloat(current.Velocity[i], -50, 50, 12)
            binary.Write(buf, binary.LittleEndian, quantized)
        }
    }
    
    if changed&FieldAnimation != 0 {
        binary.Write(buf, binary.LittleEndian, current.Animation)
    }
    
    if changed&FieldHealth != 0 {
        buf.WriteByte(current.Health)
    }
    
    if changed&FieldFlags != 0 {
        buf.WriteByte(current.Flags)
    }
}
 
// Quantize float to n-bit integer
func quantizeFloat(value, min, max float32, bits int) uint16 {
    normalized := (value - min) / (max - min)
    maxValue := (1 << bits) - 1
    return uint16(normalized * float32(maxValue))
}
 
// Smallest-three quaternion compression
// Quaternion has unit length, so we only need 3 components
// The 4th can be derived: w = sqrt(1 - x² - y² - z²)
func (dc *DeltaCompressor) writeSmallestThreeQuat(buf *bytes.Buffer, q [4]float32) {
    // Find largest component
    largest := 0
    for i := 1; i < 4; i++ {
        if abs(q[i]) > abs(q[largest]) {
            largest = i
        }
    }
    
    // Write 2 bits for which component is largest
    // Write 10 bits each for the other 3 components
    // Total: 32 bits instead of 128 bits
    var packed uint32
    packed |= uint32(largest) << 30
    
    j := 0
    for i := 0; i < 4; i++ {
        if i != largest {
            quantized := quantizeFloat(q[i], -0.707107, 0.707107, 10)
            packed |= uint32(quantized) << (j * 10)
            j++
        }
    }
    
    binary.Write(buf, binary.LittleEndian, packed)
}
 
func nearEqual(a, b [3]float32, epsilon float32) bool {
    for i := 0; i < 3; i++ {
        if abs(a[i]-b[i]) > epsilon {
            return false
        }
    }
    return true
}
 
func nearEqualQuat(a, b [4]float32, epsilon float32) bool {
    for i := 0; i < 4; i++ {
        if abs(a[i]-b[i]) > epsilon {
            return false
        }
    }
    return true
}
 
func abs(x float32) float32 {
    if x < 0 {
        return -x
    }
    return x
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215

// Deterministic lockstep simulation
 
// Use fixed-point math to avoid floating-point variance
class FixedPoint {
  private value: bigint;
  private static SCALE = 1000n;  // 3 decimal places
 
  constructor(value: number | bigint) {
    if (typeof value === 'number') {
      this.value = BigInt(Math.round(value * 1000));
    } else {
      this.value = value;
    }
  }
 
  add(other: FixedPoint): FixedPoint {
    return new FixedPoint(this.value + other.value);
  }
 
  sub(other: FixedPoint): FixedPoint {
    return new FixedPoint(this.value - other.value);
  }
 
  mul(other: FixedPoint): FixedPoint {
    return new FixedPoint((this.value * other.value) / FixedPoint.SCALE);
  }
 
  div(other: FixedPoint): FixedPoint {
    return new FixedPoint((this.value * FixedPoint.SCALE) / other.value);
  }
 
  toNumber(): number {
    return Number(this.value) / 1000;
  }
}
 
// Seeded random number generator (deterministic)
class SeededRNG {
  private seed: number;
 
  constructor(seed: number) {
    this.seed = seed;
  }
 
  // Mulberry32 - fast, deterministic PRNG
  next(): number {
    let t = this.seed += 0x6D2B79F5;
    t = Math.imul(t ^ t >>> 15, t | 1);
    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
    return ((t ^ t >>> 14) >>> 0) / 4294967296;
  }
 
  nextInt(min: number, max: number): number {
    return Math.floor(this.next() * (max - min + 1)) + min;
  }
}
 
interface TurnInput {
  playerId: string;
  turnNumber: number;
  commands: GameCommand[];
  checksum: number;  // For desync detection
}
 
interface GameCommand {
  type: 'move' | 'attack' | 'build' | 'upgrade';
  entityIds: number[];
  targetPosition?: { x: FixedPoint; y: FixedPoint };
  targetEntityId?: number;
}
 
class LockstepSimulation {
  private turnNumber: number = 0;
  private players: string[];
  private pendingInputs: Map<string, TurnInput[]> = new Map();
  private turnDelay: number = 2;  // Process turn N-2 when we're at turn N
  private stateChecksum: number = 0;
 
  // Collection of inputs to send
  private localCommands: GameCommand[] = [];
 
  constructor(players: string[], seed: number) {
    this.players = players;
    for (const player of players) {
      this.pendingInputs.set(player, []);
    }
    this.rng = new SeededRNG(seed);
  }
 
  private rng: SeededRNG;
 
  // Called every simulation tick (e.g., 100ms / 10 ticks per second)
  tick(): boolean {
    // Send our inputs for this turn
    this.broadcastInput({
      playerId: this.localPlayerId,
      turnNumber: this.turnNumber,
      commands: this.localCommands,
      checksum: this.stateChecksum,
    });
    this.localCommands = [];
 
    // Can we simulate the next turn?
    const turnToSimulate = this.turnNumber - this.turnDelay;
    if (turnToSimulate < 0) {
      this.turnNumber++;
      return true;  // Still in startup delay
    }
 
    if (!this.haveAllInputsForTurn(turnToSimulate)) {
      // Wait for slow players
      console.log(`Waiting for inputs for turn ${turnToSimulate}`);
      return false;  // Don't advance
    }
 
    // Simulate the turn
    const inputs = this.getInputsForTurn(turnToSimulate);
    this.simulateTurn(inputs);
 
    // Verify all players have same state
    for (const input of inputs) {
      if (input.checksum !== this.stateChecksum) {
        console.error(`DESYNC! Player ${input.playerId} has different state`);
        // Handle desync - usually disconnect or resync
      }
    }
 
    this.turnNumber++;
    return true;
  }
 
  private simulateTurn(inputs: TurnInput[]): void {
    // Sort inputs deterministically (by player ID)
    inputs.sort((a, b) => a.playerId.localeCompare(b.playerId));
 
    // Apply all commands
    for (const input of inputs) {
      for (const command of input.commands) {
        this.executeCommand(command);
      }
    }
 
    // Update game simulation (AI, physics, etc.)
    this.updateSimulation();
 
    // Update checksum for desync detection
    this.stateChecksum = this.calculateStateChecksum();
  }
 
  private executeCommand(command: GameCommand): void {
    // Deterministic command execution
    switch (command.type) {
      case 'move':
        for (const entityId of command.entityIds) {
          this.units.get(entityId)?.setMoveTarget(command.targetPosition!);
        }
        break;
      case 'attack':
        for (const entityId of command.entityIds) {
          this.units.get(entityId)?.setAttackTarget(command.targetEntityId!);
        }
        break;
      // ... other commands
    }
  }
 
  private updateSimulation(): void {
    // Update all units in deterministic order (by ID)
    const unitIds = Array.from(this.units.keys()).sort((a, b) => a - b);
    
    for (const unitId of unitIds) {
      const unit = this.units.get(unitId)!;
      unit.update(this.rng);  // RNG calls must be deterministic
    }
  }
 
  private calculateStateChecksum(): number {
    // Hash of relevant game state for desync detection
    let hash = 0;
    for (const [id, unit] of this.units) {
      hash ^= id;
      hash ^= Math.floor(unit.position.x.toNumber() * 1000);
      hash ^= Math.floor(unit.position.y.toNumber() * 1000);
      hash ^= unit.health;
    }
    return hash >>> 0;
  }
 
  private haveAllInputsForTurn(turn: number): boolean {
    for (const player of this.players) {
      const inputs = this.pendingInputs.get(player)!;
      if (!inputs.some(i => i.turnNumber === turn)) {
        return false;
      }
    }
    return true;
  }
 
  private getInputsForTurn(turn: number): TurnInput[] {
    const result: TurnInput[] = [];
    for (const player of this.players) {
      const inputs = this.pendingInputs.get(player)!;
      const input = inputs.find(i => i.turnNumber === turn);
      if (input) {
        result.push(input);
      }
    }
    return result;
  }
 
  // External interface
  private localPlayerId: string = '';
  private units: Map<number, any> = new Map();
  private broadcastInput(input: TurnInput): void { /* ... */ }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228

package matchmaking
 
import (
    "container/heap"
    "sync"
    "time"
)
 
type Player struct {
    ID           string
    SkillRating  int      // MMR/ELO score
    Region       string   // Geographic region
    PartyID      string   // If in a party with others
    QueuedAt     time.Time
    GameMode     string
    Preferences  MatchPreferences
}
 
type MatchPreferences struct {
    MaxPing          int   // Maximum acceptable ping
    AcceptFillParty  bool  // Willing to fill incomplete party
}
 
type Match struct {
    ID        string
    Players   []*Player
    GameMode  string
    Region    string
    ServerID  string
}
 
// Matchmaker implements skill-based matchmaking with expanding search
type Matchmaker struct {
    queues       map[string]*PlayerQueue  // per-gamemode queues
    mu           sync.RWMutex
    matchSize    int
    baseWindow   int  // Initial skill window (e.g., ±50)
    maxWindow    int  // Maximum skill window (e.g., ±500)
    expandRate   int  // Expand window by this much per second of wait
}
 
type PlayerQueue struct {
    players []*Player
    mu      sync.Mutex
}
 
func NewMatchmaker(matchSize, baseWindow, maxWindow, expandRate int) *Matchmaker {
    return &Matchmaker{
        queues:     make(map[string]*PlayerQueue),
        matchSize:  matchSize,
        baseWindow: baseWindow,
        maxWindow:  maxWindow,
        expandRate: expandRate,
    }
}
 
// AddToQueue adds a player to the matchmaking queue
func (m *Matchmaker) AddToQueue(player *Player) {
    player.QueuedAt = time.Now()
    
    m.mu.Lock()
    queue, exists := m.queues[player.GameMode]
    if !exists {
        queue = &PlayerQueue{}
        m.queues[player.GameMode] = queue
    }
    m.mu.Unlock()
    
    queue.mu.Lock()
    queue.players = append(queue.players, player)
    queue.mu.Unlock()
}
 
// FindMatches attempts to create matches from the queue
func (m *Matchmaker) FindMatches(gameMode string) []*Match {
    m.mu.RLock()
    queue, exists := m.queues[gameMode]
    m.mu.RUnlock()
    
    if !exists {
        return nil
    }
    
    queue.mu.Lock()
    defer queue.mu.Unlock()
    
    var matches []*Match
    now := time.Now()
    
    // Sort by queue time (longest waiting first)
    sort.Slice(queue.players, func(i, j int) bool {
        return queue.players[i].QueuedAt.Before(queue.players[j].QueuedAt)
    })
    
    matched := make(map[string]bool)
    
    for _, anchor := range queue.players {
        if matched[anchor.ID] {
            continue
        }
        
        // Calculate expanded skill window based on wait time
        waitSeconds := int(now.Sub(anchor.QueuedAt).Seconds())
        skillWindow := min(m.baseWindow + waitSeconds*m.expandRate, m.maxWindow)
        
        // Find compatible players
        candidates := m.findCompatiblePlayers(
            queue.players,
            anchor,
            skillWindow,
            matched,
        )
        
        if len(candidates) >= m.matchSize-1 {
            // Create match
            match := &Match{
                ID:       generateMatchID(),
                Players:  append([]*Player{anchor}, candidates[:m.matchSize-1]...),
                GameMode: gameMode,
                Region:   anchor.Region,
            }
            
            matches = append(matches, match)
            
            // Mark as matched
            matched[anchor.ID] = true
            for _, p := range match.Players {
                matched[p.ID] = true
            }
        }
    }
    
    // Remove matched players from queue
    remaining := make([]*Player, 0)
    for _, player := range queue.players {
        if !matched[player.ID] {
            remaining = append(remaining, player)
        }
    }
    queue.players = remaining
    
    return matches
}
 
func (m *Matchmaker) findCompatiblePlayers(
    pool []*Player,
    anchor *Player,
    skillWindow int,
    excluded map[string]bool,
) []*Player {
    var compatible []*Player
    
    for _, candidate := range pool {
        if excluded[candidate.ID] || candidate.ID == anchor.ID {
            continue
        }
        
        // Check skill compatibility
        skillDiff := abs(candidate.SkillRating - anchor.SkillRating)
        if skillDiff > skillWindow {
            continue
        }
        
        // Check region compatibility
        if candidate.Region != anchor.Region {
            continue
        }
        
        // Check party conflicts
        if anchor.PartyID != "" && candidate.PartyID != "" && 
           anchor.PartyID != candidate.PartyID {
            // Both in parties, but different parties
            // Can still match if party sizes allow
        }
        
        compatible = append(compatible, candidate)
    }
    
    // Sort by skill proximity
    sort.Slice(compatible, func(i, j int) bool {
        diffI := abs(compatible[i].SkillRating - anchor.SkillRating)
        diffJ := abs(compatible[j].SkillRating - anchor.SkillRating)
        return diffI < diffJ
    })
    
    return compatible
}
 
// Skill Rating Systems
type EloCalculator struct {
    kFactor int  // How much ratings change per game
}
 
func (e *EloCalculator) CalculateNewRatings(
    winnerRating, loserRating int,
) (newWinner, newLoser int) {
    // Expected score based on rating difference
    expectedWinner := 1.0 / (1.0 + pow(10, float64(loserRating-winnerRating)/400))
    expectedLoser := 1.0 - expectedWinner
    
    // Actual scores (1 for win, 0 for loss)
    newWinner = winnerRating + int(float64(e.kFactor)*(1.0-expectedWinner))
    newLoser = loserRating + int(float64(e.kFactor)*(0.0-expectedLoser))
    
    return newWinner, newLoser
}
 
func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}
 
func abs(x int) int {
    if x < 0 {
        return -x
    }
    return x
}
 
func pow(base float64, exp float64) float64 {
    return 1 // Simplified
}
 
func generateMatchID() string {
    return "match-" + time.Now().Format("20060102150405")
}