Update app.py

app.py

@@ -0,0 +1,233 @@
+import random
+import json
+import socketio
+from flask import Flask
+from redis.sentinel import Sentinel
+import eventlet
+eventlet.monkey_patch()
+
+# Redis Sentinel Setup
+SENTINELS = [('sentinel1', 26379), ('sentinel2', 26379), ('sentinel3', 26379)]
+MASTER_NAME = 'mymaster'
+
+sentinel = Sentinel(SENTINELS, socket_timeout=0.1)
+redis_master = sentinel.master_for(MASTER_NAME, socket_timeout=0.1, decode_responses=True)
+redis_slave = sentinel.slave_for(MASTER_NAME, socket_timeout=0.1, decode_responses=True)
+
+# Flask + Socket.IO setup
+sio = socketio.Server(cors_allowed_origins='*')
+app = Flask(__name__)
+app.wsgi_app = socketio.WSGIApp(sio, app.wsgi_app)
+
+# Redis keys for data storage
+WAITING_PLAYERS_KEY = 'waiting_players'  # Redis List
+PLAYERS_HASH = 'players'                 # Redis Hash: sid -> json string
+ROOMS_HASH = 'rooms'                     # Redis Hash: sid -> room
+GAME_STATES_HASH = 'game_states'         # Redis Hash: room -> json string
+
+# Pub/Sub channel for broadcasting moves and events
+CHANNEL = 'checkers_channel'
+
+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 publish_event(event_type, data):
+    message = json.dumps({'type': event_type, 'data': data})
+    redis_master.publish(CHANNEL, message)
+
+def handle_pubsub():
+    pubsub = redis_slave.pubsub()
+    pubsub.subscribe(CHANNEL)
+    for message in pubsub.listen():
+        if message['type'] == 'message':
+            event = json.loads(message['data'])
+            event_type = event['type']
+            data = event['data']
+
+            # Broadcast to all connected sockets as needed
+            if event_type == 'opponent_move':
+                room = data.get('room')
+                if room:
+                    # Emit to the room, skip sender
+                    sio.emit('opponent_move', data['move'], room=room, skip_sid=data['sid'])
+            elif event_type == 'game_over':
+                sio.emit('game_over', data, room=data.get('room'))
+            elif event_type == 'opponent_disconnected':
+                sio.emit('opponent_disconnected', room=data.get('room'))
+            elif event_type == 'match_found':
+                # This can be handled if needed for multi-instance matchmaking
+                pass
+
+@app.route('/')
+def index():
+    return "Checkers server with Redis Sentinel is running."
+
+@sio.event
+def connect(sid, environ):
+    print(f"{sid} connected")
+
+@sio.event
+def set_name(sid, data):
+    name = data.get('name', 'Player')
+
+    # Store player info in Redis
+    player_data = {'name': name}
+    redis_master.hset(PLAYERS_HASH, sid, json.dumps(player_data))
+
+    # Check waiting players
+    waiting = redis_master.lrange(WAITING_PLAYERS_KEY, 0, -1)
+    if waiting:
+        opponent_sid = waiting[0]
+        redis_master.lpop(WAITING_PLAYERS_KEY)
+
+        room = f"room_{sid[:4]}_{opponent_sid[:4]}"
+
+        # Update players with room
+        player_data['room'] = room
+        redis_master.hset(PLAYERS_HASH, sid, json.dumps(player_data))
+
+        opponent_data_json = redis_master.hget(PLAYERS_HASH, opponent_sid)
+        opponent_data = json.loads(opponent_data_json)
+        opponent_data['room'] = room
+        redis_master.hset(PLAYERS_HASH, opponent_sid, json.dumps(opponent_data))
+
+        redis_master.hset(ROOMS_HASH, sid, room)
+        redis_master.hset(ROOMS_HASH, opponent_sid, room)
+
+        sio.enter_room(sid, room)
+        sio.enter_room(opponent_sid, room)
+
+        # Random color assignment
+        pair = [(sid, 'red'), (opponent_sid, 'black')]
+        random.shuffle(pair)
+
+        for psid, color in pair:
+            pdata_json = redis_master.hget(PLAYERS_HASH, psid)
+            pdata = json.loads(pdata_json)
+            pdata['color'] = color
+            redis_master.hset(PLAYERS_HASH, psid, json.dumps(pdata))
+
+            opponent_name = players_get_name(opponent_sid if psid == sid else sid)
+            sio.emit("match_found", {'color': color, 'opponent': opponent_name}, to=psid)
+
+        # Initialize game state in Redis
+        state = {
+            'board': init_board(),
+            'turn': 'red'
+        }
+        redis_master.hset(GAME_STATES_HASH, room, json.dumps(state))
+    else:
+        redis_master.rpush(WAITING_PLAYERS_KEY, sid)
+
+def players_get_name(sid):
+    pdata_json = redis_slave.hget(PLAYERS_HASH, sid)
+    if pdata_json:
+        pdata = json.loads(pdata_json)
+        return pdata.get('name', 'Player')
+    return 'Player'
+
+@sio.event
+def move(sid, data):
+    room = redis_slave.hget(ROOMS_HASH, sid)
+    if not room:
+        return
+    state_json = redis_slave.hget(GAME_STATES_HASH, room)
+    if not state_json:
+        return
+    state = json.loads(state_json)
+
+    board = state['board']
+    turn = state['turn']
+
+    pdata_json = redis_slave.hget(PLAYERS_HASH, sid)
+    if not pdata_json:
+        return
+    pdata = json.loads(pdata_json)
+    color = pdata.get('color')
+
+    if color != turn:
+        return  # not your turn
+
+    from_row, from_col = data['from']
+    to_row, to_col = data['to']
+    captured = data.get('captured')
+
+    piece = board[from_row][from_col]
+    if not piece or piece[0] != color[0]:
+        return
+
+    # Simple move
+    board[to_row][to_col] = board[from_row][from_col]
+    board[from_row][from_col] = None
+    if captured:
+        cap_row, cap_col = captured
+        board[cap_row][cap_col] = None
+
+    # Crown
+    if (color == 'red' and to_row == 0) or (color == 'black' and to_row == 7):
+        board[to_row][to_col] = board[to_row][to_col].upper()
+
+    # Win check
+    flat = sum(board, [])
+    winner = None
+    if 'r' not in flat and 'R' not in flat:
+        winner = 'black'
+    elif 'b' not in flat and 'B' not in flat:
+        winner = 'red'
+
+    if winner:
+        publish_event('game_over', {'winner': winner, 'room': room})
+        redis_master.hdel(GAME_STATES_HASH, room)
+        return
+
+    # Switch turn
+    state['turn'] = 'black' if turn == 'red' else 'red'
+    state['board'] = board
+
+    redis_master.hset(GAME_STATES_HASH, room, json.dumps(state))
+
+    # Broadcast move to other player via Redis pubsub
+    publish_event('opponent_move', {'move': data, 'room': room, 'sid': sid})
+
+@sio.event
+def disconnect(sid):
+    print(f"{sid} disconnected")
+    # Remove from waiting list if present
+    redis_master.lrem(WAITING_PLAYERS_KEY, 0, sid)
+
+    room = redis_slave.hget(ROOMS_HASH, sid)
+    if room:
+        publish_event('opponent_disconnected', {'room': room})
+
+        # Clean up Redis data for this room & players
+        keys_to_delete = []
+        players_in_room = []
+        all_players = redis_slave.hkeys(PLAYERS_HASH)
+        for psid in all_players:
+            pdata_json = redis_slave.hget(PLAYERS_HASH, psid)
+            pdata = json.loads(pdata_json)
+            if pdata.get('room') == room:
+                keys_to_delete.append(psid)
+                players_in_room.append(psid)
+
+        for psid in players_in_room:
+            redis_master.hdel(PLAYERS_HASH, psid)
+            redis_master.hdel(ROOMS_HASH, psid)
+        redis_master.hdel(GAME_STATES_HASH, room)
+
+if __name__ == '__main__':
+    import threading
+    # Start background thread for Redis Pub/Sub listening
+    pubsub_thread = threading.Thread(target=handle_pubsub, daemon=True)
+    pubsub_thread.start()
+
+    eventlet.wsgi.server(eventlet.listen(('0.0.0.0', 5000)), app)