Create app.py

app.py

@@ -0,0 +1,568 @@
+import os
+import json
+import uuid
+import time
+from datetime import datetime, timedelta
+from flask import Flask, render_template, request, send_from_directory
+from flask_socketio import SocketIO, emit, join_room, leave_room
+from flask_sqlalchemy import SQLAlchemy
+import threading
+
+# Initialize Flask app with explicit static folder
+app = Flask(__name__, 
+            static_folder='static',
+            static_url_path='/static',
+            template_folder='templates')
+
+app.config['SECRET_KEY'] = os.urandom(24).hex()
+app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///chess_games.db'
+app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0  # Disable caching for development
+
+db = SQLAlchemy(app)
+socketio = SocketIO(app, cors_allowed_origins="*", async_mode='eventlet', 
+                    ping_timeout=60, ping_interval=25)
+
+# ========================================
+# Database Models
+# ========================================
+class SavedGame(db.Model):
+    id = db.Column(db.String(36), primary_key=True)
+    room_id = db.Column(db.String(36), nullable=False)
+    fen = db.Column(db.String(100), nullable=False)
+    pgn = db.Column(db.Text, nullable=True)
+    white_player = db.Column(db.String(50), nullable=False)
+    black_player = db.Column(db.String(50), nullable=False)
+    white_time = db.Column(db.Integer, nullable=True)
+    black_time = db.Column(db.Integer, nullable=True)
+    time_control = db.Column(db.Integer, nullable=True)
+    current_turn = db.Column(db.String(1), nullable=False, default='w')
+    move_history = db.Column(db.Text, nullable=True)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    expires_at = db.Column(db.DateTime, nullable=False)
+    status = db.Column(db.String(20), default='paused')
+
+class GameHistory(db.Model):
+    id = db.Column(db.String(36), primary_key=True)
+    white_player = db.Column(db.String(50), nullable=False)
+    black_player = db.Column(db.String(50), nullable=False)
+    winner = db.Column(db.String(50), nullable=True)
+    result = db.Column(db.String(20), nullable=False)
+    pgn = db.Column(db.Text, nullable=True)
+    time_control = db.Column(db.Integer, nullable=True)
+    played_at = db.Column(db.DateTime, default=datetime.utcnow)
+
+# ========================================
+# In-memory Storage
+# ========================================
+rooms = {}
+players = {}
+disconnected_players = {}
+
+def generate_room_id():
+    return str(uuid.uuid4())[:8].upper()
+
+def cleanup_expired_games():
+    """Remove expired saved games"""
+    while True:
+        try:
+            with app.app_context():
+                expired = SavedGame.query.filter(SavedGame.expires_at < datetime.utcnow()).all()
+                for game in expired:
+                    db.session.delete(game)
+                db.session.commit()
+        except Exception as e:
+            print(f"Cleanup error: {e}")
+        time.sleep(60)
+
+# ========================================
+# Routes
+# ========================================
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/static/<path:filename>')
+def serve_static(filename):
+    return send_from_directory(app.static_folder, filename)
+
+@app.route('/health')
+def health():
+    return {'status': 'healthy'}
+
+# ========================================
+# Socket Events
+# ========================================
+@socketio.on('connect')
+def handle_connect():
+    print(f"Client connected: {request.sid}")
+    emit('connected', {'sid': request.sid})
+
+@socketio.on('disconnect')
+def handle_disconnect():
+    sid = request.sid
+    print(f"Client disconnected: {sid}")
+    
+    if sid in players:
+        player_info = players[sid]
+        room_id = player_info.get('room')
+        username = player_info.get('username')
+        
+        if room_id and room_id in rooms:
+            room = rooms[room_id]
+            
+            # Mark player as disconnected
+            disconnected_players[sid] = {
+                'username': username,
+                'room': room_id,
+                'color': player_info.get('color'),
+                'disconnected_at': datetime.utcnow()
+            }
+            
+            # Save game state
+            save_game_state(room_id)
+            
+            # Notify opponent
+            emit('opponent_disconnected', {
+                'username': username,
+                'timeout': 600
+            }, room=room_id)
+            
+            # Start reconnection timer
+            threading.Thread(target=check_reconnection, args=(sid, room_id, 600), daemon=True).start()
+        
+        del players[sid]
+
+def check_reconnection(sid, room_id, timeout):
+    """Check if player reconnects within timeout"""
+    time.sleep(timeout)
+    
+    if sid in disconnected_players:
+        with app.app_context():
+            if room_id in rooms:
+                room = rooms[room_id]
+                disconnected = disconnected_players[sid]
+                winner_color = 'black' if disconnected['color'] == 'white' else 'white'
+                
+                winner = None
+                for p in room.get('players', []):
+                    if p.get('color') == winner_color:
+                        winner = p.get('username')
+                        break
+                
+                socketio.emit('game_over', {
+                    'reason': 'abandonment',
+                    'winner': winner,
+                    'message': f"{disconnected['username']} abandoned the game"
+                }, room=room_id)
+                
+                save_game_history(room_id, winner, 'abandonment')
+                cleanup_room(room_id)
+        
+        del disconnected_players[sid]
+
+def save_game_state(room_id):
+    """Save current game state to database"""
+    if room_id not in rooms:
+        return
+    
+    room = rooms[room_id]
+    game_state = room.get('game_state', {})
+    
+    try:
+        saved_game = SavedGame(
+            id=str(uuid.uuid4()),
+            room_id=room_id,
+            fen=game_state.get('fen', 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'),
+            pgn=game_state.get('pgn', ''),
+            white_player=room.get('white', ''),
+            black_player=room.get('black', ''),
+            white_time=room.get('white_time'),
+            black_time=room.get('black_time'),
+            time_control=room.get('time_control'),
+            current_turn=game_state.get('turn', 'w'),
+            move_history=json.dumps(game_state.get('moves', [])),
+            expires_at=datetime.utcnow() + timedelta(minutes=10),
+            status='paused'
+        )
+        db.session.add(saved_game)
+        db.session.commit()
+    except Exception as e:
+        print(f"Error saving game: {e}")
+        db.session.rollback()
+
+def save_game_history(room_id, winner, result):
+    """Save completed game to history"""
+    if room_id not in rooms:
+        return
+    
+    room = rooms[room_id]
+    
+    try:
+        history = GameHistory(
+            id=str(uuid.uuid4()),
+            white_player=room.get('white', ''),
+            black_player=room.get('black', ''),
+            winner=winner,
+            result=result,
+            pgn=room.get('game_state', {}).get('pgn', ''),
+            time_control=room.get('time_control')
+        )
+        db.session.add(history)
+        db.session.commit()
+    except Exception as e:
+        print(f"Error saving history: {e}")
+        db.session.rollback()
+
+def cleanup_room(room_id):
+    """Clean up room data"""
+    if room_id in rooms:
+        del rooms[room_id]
+
+@socketio.on('create_room')
+def handle_create_room(data):
+    username = data.get('username', 'Anonymous')
+    time_control = data.get('time_control')
+    
+    room_id = generate_room_id()
+    
+    rooms[room_id] = {
+        'players': [],
+        'game_state': {
+            'fen': 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1',
+            'turn': 'w',
+            'moves': [],
+            'pgn': ''
+        },
+        'time_control': time_control,
+        'white_time': time_control * 60 if time_control else None,
+        'black_time': time_control * 60 if time_control else None,
+        'started': False,
+        'white': None,
+        'black': None,
+        'last_move_time': None
+    }
+    
+    join_room(room_id)
+    
+    color = 'white'
+    rooms[room_id]['players'].append({
+        'sid': request.sid,
+        'username': username,
+        'color': color
+    })
+    rooms[room_id]['white'] = username
+    
+    players[request.sid] = {
+        'username': username,
+        'room': room_id,
+        'color': color
+    }
+    
+    emit('room_created', {
+        'room_id': room_id,
+        'color': color,
+        'time_control': time_control
+    })
+
+@socketio.on('join_room')
+def handle_join_room(data):
+    username = data.get('username', 'Anonymous')
+    room_id = data.get('room_id', '').upper().strip()
+    
+    if room_id not in rooms:
+        emit('error', {'message': 'Room not found'})
+        return
+    
+    room = rooms[room_id]
+    
+    if len(room['players']) >= 2:
+        emit('error', {'message': 'Room is full'})
+        return
+    
+    join_room(room_id)
+    
+    color = 'black'
+    room['players'].append({
+        'sid': request.sid,
+        'username': username,
+        'color': color
+    })
+    room['black'] = username
+    
+    players[request.sid] = {
+        'username': username,
+        'room': room_id,
+        'color': color
+    }
+    
+    # Check if this is a reconnection
+    saved_game = None
+    try:
+        saved_game = SavedGame.query.filter_by(room_id=room_id, status='paused').first()
+    except:
+        pass
+    
+    if saved_game:
+        room['game_state'] = {
+            'fen': saved_game.fen,
+            'turn': saved_game.current_turn,
+            'moves': json.loads(saved_game.move_history) if saved_game.move_history else [],
+            'pgn': saved_game.pgn or ''
+        }
+        room['white_time'] = saved_game.white_time
+        room['black_time'] = saved_game.black_time
+        
+        db.session.delete(saved_game)
+        db.session.commit()
+        
+        emit('game_restored', {
+            'room_id': room_id,
+            'color': color,
+            'game_state': room['game_state'],
+            'white_time': room['white_time'],
+            'black_time': room['black_time'],
+            'opponent': room['white']
+        })
+        
+        emit('opponent_reconnected', {
+            'username': username,
+            'game_state': room['game_state'],
+            'white_time': room['white_time'],
+            'black_time': room['black_time']
+        }, room=room_id, include_self=False)
+    else:
+        emit('room_joined', {
+            'room_id': room_id,
+            'color': color,
+            'time_control': room['time_control'],
+            'opponent': room['white']
+        })
+        
+        emit('opponent_joined', {
+            'username': username,
+            'color': 'black'
+        }, room=room_id, include_self=False)
+    
+    if len(room['players']) == 2:
+        room['started'] = True
+        room['last_move_time'] = time.time()
+        emit('game_start', {
+            'white': room['white'],
+            'black': room['black'],
+            'time_control': room['time_control'],
+            'game_state': room['game_state']
+        }, room=room_id)
+
+@socketio.on('make_move')
+def handle_move(data):
+    sid = request.sid
+    
+    if sid not in players:
+        emit('error', {'message': 'Player not found'})
+        return
+    
+    player = players[sid]
+    room_id = player['room']
+    
+    if room_id not in rooms:
+        emit('error', {'message': 'Room not found'})
+        return
+    
+    room = rooms[room_id]
+    
+    if not room['started']:
+        emit('error', {'message': 'Game not started'})
+        return
+    
+    move = data.get('move')
+    fen = data.get('fen')
+    pgn = data.get('pgn', '')
+    turn = data.get('turn')
+    
+    # Update time
+    if room['time_control']:
+        current_time = time.time()
+        if room['last_move_time']:
+            elapsed = current_time - room['last_move_time']
+            
+            if room['game_state']['turn'] == 'w':
+                room['white_time'] = max(0, room['white_time'] - elapsed)
+                if room['white_time'] <= 0:
+                    emit('game_over', {
+                        'reason': 'timeout',
+                        'winner': room['black'],
+                        'loser_color': 'white'
+                    }, room=room_id)
+                    save_game_history(room_id, room['black'], 'timeout')
+                    cleanup_room(room_id)
+                    return
+            else:
+                room['black_time'] = max(0, room['black_time'] - elapsed)
+                if room['black_time'] <= 0:
+                    emit('game_over', {
+                        'reason': 'timeout',
+                        'winner': room['white'],
+                        'loser_color': 'black'
+                    }, room=room_id)
+                    save_game_history(room_id, room['white'], 'timeout')
+                    cleanup_room(room_id)
+                    return
+        
+        room['last_move_time'] = current_time
+    
+    # Update game state
+    room['game_state']['fen'] = fen
+    room['game_state']['turn'] = turn
+    room['game_state']['moves'].append(move)
+    room['game_state']['pgn'] = pgn
+    
+    # Broadcast move
+    emit('move_made', {
+        'move': move,
+        'fen': fen,
+        'pgn': pgn,
+        'turn': turn,
+        'white_time': room['white_time'],
+        'black_time': room['black_time'],
+        'is_check': data.get('is_check', False),
+        'is_checkmate': data.get('is_checkmate', False),
+        'is_draw': data.get('is_draw', False),
+        'is_stalemate': data.get('is_stalemate', False)
+    }, room=room_id)
+    
+    # Check for game end
+    if data.get('is_checkmate'):
+        winner = room['black'] if turn == 'w' else room['white']
+        save_game_history(room_id, winner, 'checkmate')
+    elif data.get('is_draw') or data.get('is_stalemate'):
+        save_game_history(room_id, None, 'draw')
+
+@socketio.on('resign')
+def handle_resign():
+    sid = request.sid
+    
+    if sid not in players:
+        return
+    
+    player = players[sid]
+    room_id = player['room']
+    
+    if room_id not in rooms:
+        return
+    
+    room = rooms[room_id]
+    winner = room['black'] if player['color'] == 'white' else room['white']
+    
+    emit('game_over', {
+        'reason': 'resignation',
+        'winner': winner,
+        'resigned': player['username']
+    }, room=room_id)
+    
+    save_game_history(room_id, winner, 'resignation')
+    cleanup_room(room_id)
+
+@socketio.on('offer_draw')
+def handle_draw_offer():
+    sid = request.sid
+    
+    if sid not in players:
+        return
+    
+    player = players[sid]
+    room_id = player['room']
+    
+    emit('draw_offered', {
+        'from': player['username']
+    }, room=room_id, include_self=False)
+
+@socketio.on('accept_draw')
+def handle_draw_accept():
+    sid = request.sid
+    
+    if sid not in players:
+        return
+    
+    player = players[sid]
+    room_id = player['room']
+    
+    emit('game_over', {
+        'reason': 'draw',
+        'winner': None
+    }, room=room_id)
+    
+    save_game_history(room_id, None, 'draw_agreement')
+    cleanup_room(room_id)
+
+@socketio.on('decline_draw')
+def handle_draw_decline():
+    sid = request.sid
+    
+    if sid not in players:
+        return
+    
+    player = players[sid]
+    room_id = player['room']
+    
+    emit('draw_declined', {
+        'by': player['username']
+    }, room=room_id, include_self=False)
+
+@socketio.on('chat_message')
+def handle_chat(data):
+    sid = request.sid
+    
+    if sid not in players:
+        return
+    
+    player = players[sid]
+    room_id = player['room']
+    
+    emit('chat_message', {
+        'username': player['username'],
+        'message': data.get('message', '')[:500],
+        'timestamp': datetime.utcnow().isoformat()
+    }, room=room_id)
+
+@socketio.on('get_rooms')
+def handle_get_rooms():
+    available_rooms = []
+    for room_id, room in rooms.items():
+        if len(room['players']) < 2:
+            available_rooms.append({
+                'room_id': room_id,
+                'host': room['white'],
+                'time_control': room['time_control']
+            })
+    emit('rooms_list', {'rooms': available_rooms})
+
+@socketio.on('leave_room')
+def handle_leave_room():
+    sid = request.sid
+    if sid in players:
+        player = players[sid]
+        room_id = player.get('room')
+        if room_id:
+            leave_room(room_id)
+            if room_id in rooms:
+                room = rooms[room_id]
+                room['players'] = [p for p in room['players'] if p['sid'] != sid]
+                if len(room['players']) == 0:
+                    del rooms[room_id]
+        del players[sid]
+
+# ========================================
+# Main
+# ========================================
+if __name__ == '__main__':
+    with app.app_context():
+        db.create_all()
+    
+    # Start cleanup thread
+    cleanup_thread = threading.Thread(target=cleanup_expired_games, daemon=True)
+    cleanup_thread.start()
+    
+    print("Starting Chess Arena on http://0.0.0.0:7860")
+    socketio.run(app, host='0.0.0.0', port=7860, debug=False, allow_unsafe_werkzeug=True)
+