Upload server.py

server.py

@@ -0,0 +1,199 @@
+import random
+import json
+import socketio
+from flask import Flask, jsonify
+import eventlet
+import threading
+from nats.aio.client import Client as NATS
+import asyncpg
+import asyncio
+
+eventlet.monkey_patch()
+
+sio = socketio.Server(cors_allowed_origins='*')
+app = Flask(__name__)
+app.wsgi_app = socketio.WSGIApp(sio, app.wsgi_app)
+
+DB_DSN = "postgresql://postgres:postgres@pgbouncer:6432/postgres"
+NATS_URL = "nats://nats:4222"
+
+WAITING_PLAYERS = []
+PLAYER_DATA = {}
+GAME_STATES = {}
+
+nats_client = NATS()
+loop = asyncio.new_event_loop()
+asyncio.set_event_loop(loop)
+
+async def init_db():
+    return await asyncpg.create_pool(dsn=DB_DSN)
+
+db_pool = loop.run_until_complete(init_db())
+
+async def publish_event(event_type, data):
+    message = json.dumps({'type': event_type, 'data': data})
+    await nats_client.publish("checkers", message.encode())
+
+async def subscribe():
+    async def message_handler(msg):
+        event = json.loads(msg.data.decode())
+        if event['type'] == 'opponent_move':
+            sio.emit('opponent_move', event['data']['move'], room=event['data']['room'], skip_sid=event['data']['sid'])
+        elif event['type'] == 'game_over':
+            sio.emit('game_over', event['data'], room=event['data']['room'])
+        elif event['type'] == 'opponent_disconnected':
+            sio.emit('opponent_disconnected', room=event['data']['room'])
+
+    await nats_client.connect(servers=[NATS_URL], loop=loop)
+    await nats_client.subscribe("checkers", cb=message_handler)
+
+def init_board():
+    board = [[None for _ in range(8)] for _ in range(8)]
+    for row in range(3):
+        for col in range(8):
+            if (row + col) % 2 == 1:
+                board[row][col] = 'b'
+    for row in range(5, 8):
+        for col in range(8):
+            if (row + col) % 2 == 1:
+                board[row][col] = 'r'
+    return board
+
+def get_valid_moves(board, row, col, color, is_king):
+    directions = [(-1, -1), (-1, 1)] if color == 'red' else [(1, -1), (1, 1)]
+    if is_king:
+        directions += [(-d[0], -d[1]) for d in directions]
+
+    moves, captures = [], []
+    for dr, dc in directions:
+        r, c = row + dr, col + dc
+        if 0 <= r < 8 and 0 <= c < 8 and board[r][c] is None:
+            moves.append((r, c))
+        elif 0 <= r < 8 and 0 <= c < 8:
+            mid_piece = board[r][c]
+            if mid_piece and mid_piece[0].lower() != color[0]:
+                r2, c2 = r + dr, c + dc
+                if 0 <= r2 < 8 and 0 <= c2 < 8 and board[r2][c2] is None:
+                    captures.append(((r2, c2), (r, c)))
+    return moves, captures
+
+@app.route('/')
+def index():
+    return "Checkers server running."
+
+@app.route('/state')
+def game_state():
+    for sid, pdata in PLAYER_DATA.items():
+        if 'room' in pdata:
+            room = pdata['room']
+            if room in GAME_STATES:
+                return jsonify({'board': GAME_STATES[room]['board']})
+    return jsonify({'board': [[None]*8 for _ in range(8)]})
+
+@sio.event
+def connect(sid, environ):
+    print(f"{sid} connected")
+
+@sio.event
+def set_name(sid, data):
+    name = data.get('name', 'Player')
+    PLAYER_DATA[sid] = {'name': name}
+
+    if WAITING_PLAYERS:
+        opponent_sid = WAITING_PLAYERS.pop(0)
+        room = f"room_{sid[:4]}_{opponent_sid[:4]}"
+        for psid in [sid, opponent_sid]:
+            pdata = PLAYER_DATA[psid]
+            pdata['room'] = room
+            sio.enter_room(psid, room)
+
+        players = [(sid, 'red'), (opponent_sid, 'black')]
+        random.shuffle(players)
+        for psid, color in players:
+            PLAYER_DATA[psid]['color'] = color
+            opp_sid = opponent_sid if psid == sid else sid
+            opp_name = PLAYER_DATA[opp_sid]['name']
+            sio.emit("match_found", {'color': color, 'opponent': opp_name}, to=psid)
+
+        GAME_STATES[room] = {'board': init_board(), 'turn': 'red'}
+    else:
+        WAITING_PLAYERS.append(sid)
+
+@sio.event
+def move(sid, data):
+    pdata = PLAYER_DATA.get(sid)
+    if not pdata:
+        return
+    room = pdata.get('room')
+    state = GAME_STATES.get(room)
+    if not state:
+        return
+    board = state['board']
+    turn = state['turn']
+    color = pdata['color']
+
+    if color != turn:
+        return
+
+    from_row, from_col = data['from']
+    to_row, to_col = data['to']
+    piece = board[from_row][from_col]
+    if not piece or piece[0].lower() != color[0]:
+        return
+
+    is_king = piece.isupper()
+    _, captures = get_valid_moves(board, from_row, from_col, color, is_king)
+    move_is_capture = abs(to_row - from_row) == 2
+    if captures and not move_is_capture:
+        return
+
+    board[to_row][to_col] = piece
+    board[from_row][from_col] = None
+
+    if move_is_capture:
+        cap_row = (from_row + to_row) // 2
+        cap_col = (from_col + to_col) // 2
+        board[cap_row][cap_col] = None
+        _, new_captures = get_valid_moves(board, to_row, to_col, color, is_king or to_row in (0, 7))
+        if new_captures:
+            state['board'] = board
+            GAME_STATES[room] = state
+            sio.emit('multi_jump', {'from': [to_row, to_col]}, to=sid)
+            return
+
+    if (color == 'red' and to_row == 0) or (color == 'black' and to_row == 7):
+        board[to_row][to_col] = piece.upper()
+
+    flat = sum(board, [])
+    if all(p not in flat for p in ['r', 'R']):
+        loop.create_task(publish_event('game_over', {'winner': 'black', 'room': room}))
+        del GAME_STATES[room]
+        return
+    if all(p not in flat for p in ['b', 'B']):
+        loop.create_task(publish_event('game_over', {'winner': 'red', 'room': room}))
+        del GAME_STATES[room]
+        return
+
+    state['board'] = board
+    state['turn'] = 'black' if turn == 'red' else 'red'
+    GAME_STATES[room] = state
+    loop.create_task(publish_event('opponent_move', {'move': data, 'room': room, 'sid': sid}))
+
+@sio.event
+def disconnect(sid):
+    print(f"{sid} disconnected")
+    if sid in WAITING_PLAYERS:
+        WAITING_PLAYERS.remove(sid)
+    pdata = PLAYER_DATA.pop(sid, None)
+    if pdata and 'room' in pdata:
+        room = pdata['room']
+        for psid in list(PLAYER_DATA.keys()):
+            if PLAYER_DATA[psid].get('room') == room:
+                del PLAYER_DATA[psid]
+        if room in GAME_STATES:
+            del GAME_STATES[room]
+        loop.create_task(publish_event('opponent_disconnected', {'room': room}))
+
+if __name__ == '__main__':
+    threading.Thread(target=lambda: loop.run_until_complete(subscribe()), daemon=True).start()
+    eventlet.wsgi.server(eventlet.listen(('0.0.0.0', 5000)), app)