From 57233a133b5c3f20edead79921c4d0b4f7d647b3 Mon Sep 17 00:00:00 2001
From: dbc <dbcloud@yeah.net>
Date: Sun, 8 Jun 2025 00:22:48 +0800
Subject: [PATCH] feat: Challenge mode

---
 backend/cmd/server/static/js/canvas-game.js   |  40 +-
 backend/cmd/server/templates/game.html        |  97 +++-
 backend/cmd/server/templates/leaderboard.html | 115 ++++-
 backend/internal/database/gorm.go             |  49 ++
 backend/internal/database/interface.go        |   1 +
 backend/internal/database/postgres.go         | 134 +++++-
 backend/internal/game/engine.go               | 435 ++++++++++++++++--
 backend/internal/handlers/leaderboard.go      |  43 +-
 backend/internal/websocket/handlers.go        | 106 ++++-
 backend/migrations/001_initial_schema.sql     |  86 ++--
 backend/pkg/models/game.go                    |  89 +++-
 backend/pkg/models/gorm_models.go             |  83 +++-
 12 files changed, 1097 insertions(+), 181 deletions(-)

diff --git a/backend/cmd/server/static/js/canvas-game.js b/backend/cmd/server/static/js/canvas-game.js
index c9b78a3..8e1b6c5 100644
--- a/backend/cmd/server/static/js/canvas-game.js
+++ b/backend/cmd/server/static/js/canvas-game.js
@@ -9,6 +9,8 @@ class CanvasGame {
         this.score = 0;
         this.victory = false;
         this.gameOver = false;
+        this.gameMode = 'classic';
+        this.disabledCell = null;
 
         // Canvas settings
         this.setupCanvas();
@@ -17,6 +19,7 @@ class CanvasGame {
         this.colors = {
             background: '#faf8ef',
             empty: 'rgba(238, 228, 218, 0.35)',
+            disabled: 'rgba(119, 110, 101, 0.3)',
             text: '#776e65',
             textLight: '#f9f6f2',
             tiles: {
@@ -193,6 +196,8 @@ class CanvasGame {
         this.score = gameState.score;
         this.victory = gameState.victory;
         this.gameOver = gameState.game_over;
+        this.gameMode = gameState.game_mode || 'classic';
+        this.disabledCell = gameState.disabled_cell || null;
 
         // Update score display
         const scoreElement = document.getElementById('score');
@@ -311,6 +316,11 @@ class CanvasGame {
             }
         }
 
+        // Draw disabled cell overlay if in challenge mode
+        if (this.gameMode === 'challenge' && this.disabledCell) {
+            this.drawDisabledCell(this.disabledCell.row, this.disabledCell.col);
+        }
+
         // Draw tiles with values (skip animated tiles)
         for (let row = 0; row < 4; row++) {
             for (let col = 0; col < 4; col++) {
@@ -402,6 +412,30 @@ class CanvasGame {
         this.ctx.fill();
     }
 
+    drawDisabledCell(row, col) {
+        const x = this.padding + col * (this.tileSize + this.gap);
+        const y = this.padding + row * (this.tileSize + this.gap);
+
+        // Draw disabled cell overlay
+        this.ctx.fillStyle = this.colors.disabled;
+        const borderRadius = Math.min(this.tileSize * 0.1, 6);
+        this.drawRoundedRect(x, y, this.tileSize, this.tileSize, borderRadius);
+        this.ctx.fill();
+
+        // Draw X pattern to indicate disabled
+        this.ctx.strokeStyle = '#776e65';
+        this.ctx.lineWidth = 3;
+        this.ctx.lineCap = 'round';
+
+        const margin = this.tileSize * 0.25;
+        this.ctx.beginPath();
+        this.ctx.moveTo(x + margin, y + margin);
+        this.ctx.lineTo(x + this.tileSize - margin, y + this.tileSize - margin);
+        this.ctx.moveTo(x + this.tileSize - margin, y + margin);
+        this.ctx.lineTo(x + margin, y + this.tileSize - margin);
+        this.ctx.stroke();
+    }
+
     drawTile(row, col, value, scale = 1, opacity = 1, offsetX = 0, offsetY = 0) {
         const x = this.padding + col * (this.tileSize + this.gap) + offsetX;
         const y = this.padding + row * (this.tileSize + this.gap) + offsetY;
@@ -488,12 +522,14 @@ class CanvasGame {
         }
     }
     
-    newGame() {
+    newGame(gameMode = 'classic') {
         this.hideGameOverlay();
         if (this.ws && this.ws.readyState === WebSocket.OPEN) {
             this.ws.send(JSON.stringify({
                 type: 'new_game',
-                data: {}
+                data: {
+                    game_mode: gameMode
+                }
             }));
         }
     }
diff --git a/backend/cmd/server/templates/game.html b/backend/cmd/server/templates/game.html
index 2678ec8..d0be1a8 100644
--- a/backend/cmd/server/templates/game.html
+++ b/backend/cmd/server/templates/game.html
@@ -42,6 +42,20 @@ <h1 class="game-title">2048</h1>
         </div>
     </div>
 
+    <!-- Game Mode Selector -->
+    <div class="game-mode-selector">
+        <div class="mode-buttons">
+            <button id="classic-mode-btn" class="mode-btn active" data-mode="classic">
+                <span class="mode-title">Classic</span>
+                <span class="mode-desc">Standard 2048 game</span>
+            </button>
+            <button id="challenge-mode-btn" class="mode-btn" data-mode="challenge">
+                <span class="mode-title">Challenge</span>
+                <span class="mode-desc">One cell disabled</span>
+            </button>
+        </div>
+    </div>
+
     <!-- Game Board -->
     <div class="game-board-container">
         <canvas id="game-canvas" class="game-canvas"></canvas>
@@ -119,9 +133,27 @@ <h1 class="game-title">2048</h1>
     // Global functions for UI
     function startNewGame() {
         if (window.canvasGame) {
-            window.canvasGame.newGame();
+            const selectedMode = document.querySelector('.mode-btn.active').dataset.mode;
+            window.canvasGame.newGame(selectedMode);
         }
     }
+
+    // Game mode selection
+    document.addEventListener('DOMContentLoaded', function() {
+        const modeButtons = document.querySelectorAll('.mode-btn');
+
+        modeButtons.forEach(button => {
+            button.addEventListener('click', function() {
+                // Remove active class from all buttons
+                modeButtons.forEach(btn => btn.classList.remove('active'));
+                // Add active class to clicked button
+                this.classList.add('active');
+
+                // Start new game with selected mode
+                startNewGame();
+            });
+        });
+    });
 </script>
 
 <style>
@@ -234,6 +266,51 @@ <h1 class="game-title">2048</h1>
     background: #776e65;
 }
 
+.game-mode-selector {
+    margin-bottom: 20px;
+}
+
+.mode-buttons {
+    display: flex;
+    gap: 10px;
+    justify-content: center;
+}
+
+.mode-btn {
+    background: #f8f8f8;
+    border: 2px solid #ddd;
+    border-radius: 8px;
+    padding: 12px 20px;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    min-width: 120px;
+}
+
+.mode-btn:hover {
+    border-color: #8f7a66;
+    background: #f0f0f0;
+}
+
+.mode-btn.active {
+    background: #8f7a66;
+    border-color: #8f7a66;
+    color: white;
+}
+
+.mode-title {
+    font-weight: 600;
+    font-size: 1rem;
+    margin-bottom: 4px;
+}
+
+.mode-desc {
+    font-size: 0.8rem;
+    opacity: 0.8;
+}
+
 .game-board-container {
     position: relative;
     margin-bottom: 20px;
@@ -449,6 +526,24 @@ <h1 class="game-title">2048</h1>
         padding: 6px 12px;
         font-size: 0.8rem;
     }
+
+    .mode-buttons {
+        flex-direction: column;
+        gap: 8px;
+    }
+
+    .mode-btn {
+        min-width: auto;
+        padding: 10px 15px;
+    }
+
+    .mode-title {
+        font-size: 1rem;
+    }
+
+    .mode-desc {
+        font-size: 0.75rem;
+    }
 }
 </style>
 </body>
diff --git a/backend/cmd/server/templates/leaderboard.html b/backend/cmd/server/templates/leaderboard.html
index 3f04d87..332b3ed 100644
--- a/backend/cmd/server/templates/leaderboard.html
+++ b/backend/cmd/server/templates/leaderboard.html
@@ -23,6 +23,19 @@ <h1 class="page-title">🏆 2048 Leaderboards</h1>
         </header>
 
         <div class="leaderboard-container">
+            <!-- Game Mode Selection -->
+            <div class="game-mode-tabs">
+                <button class="mode-tab-btn active" data-mode="classic" onclick="switchGameMode('classic')">
+                    <span class="mode-title">Classic</span>
+                    <span class="mode-desc">Standard 2048</span>
+                </button>
+                <button class="mode-tab-btn" data-mode="challenge" onclick="switchGameMode('challenge')">
+                    <span class="mode-title">Challenge</span>
+                    <span class="mode-desc">One cell disabled</span>
+                </button>
+            </div>
+
+            <!-- Time Period Selection -->
             <div class="leaderboard-tabs">
                 <button class="tab-btn active" data-type="daily" onclick="switchLeaderboard('daily')">Daily</button>
                 <button class="tab-btn" data-type="weekly" onclick="switchLeaderboard('weekly')">Weekly</button>
@@ -38,45 +51,64 @@ <h1 class="page-title">🏆 2048 Leaderboards</h1>
 
     <script>
         let currentType = 'daily';
+        let currentMode = 'classic';
         let cache = new Map();
 
         // Load initial leaderboard
         loadLeaderboard('daily');
 
+        function switchGameMode(mode) {
+            // Update active mode tab
+            document.querySelectorAll('.mode-tab-btn').forEach(btn => {
+                btn.classList.remove('active');
+            });
+            document.querySelector(`[data-mode="${mode}"]`).classList.add('active');
+
+            currentMode = mode;
+            // Clear cache when switching modes
+            cache.clear();
+
+            // Reload current leaderboard with new mode
+            loadLeaderboard(currentType);
+        }
+
         function switchLeaderboard(type) {
             // Update active tab
             document.querySelectorAll('.tab-btn').forEach(btn => {
                 btn.classList.remove('active');
             });
             document.querySelector(`[data-type="${type}"]`).classList.add('active');
-            
+
             // Load leaderboard
             loadLeaderboard(type);
         }
 
         async function loadLeaderboard(type) {
             currentType = type;
-            
+
+            // Create cache key that includes both type and mode
+            const cacheKey = `${type}_${currentMode}`;
+
             // Check cache first
-            if (cache.has(type)) {
-                displayLeaderboard(cache.get(type));
+            if (cache.has(cacheKey)) {
+                displayLeaderboard(cache.get(cacheKey));
                 return;
             }
-            
+
             // Show loading state
             showLoading();
-            
+
             try {
-                const response = await fetch(`/api/public/leaderboard?type=${type}&limit=50`);
+                const response = await fetch(`/api/public/leaderboard?type=${type}&game_mode=${currentMode}&limit=50`);
                 if (!response.ok) {
                     throw new Error('Failed to fetch leaderboard');
                 }
-                
+
                 const data = await response.json();
-                
+
                 // Cache the data
-                cache.set(type, data);
-                
+                cache.set(cacheKey, data);
+
                 // Display the leaderboard
                 displayLeaderboard(data);
             } catch (error) {
@@ -192,6 +224,53 @@ <h1 class="page-title">🏆 2048 Leaderboards</h1>
             padding: 0 20px;
         }
 
+        .game-mode-tabs {
+            display: flex;
+            gap: 15px;
+            margin-bottom: 20px;
+            justify-content: center;
+        }
+
+        .mode-tab-btn {
+            background: white;
+            border: 2px solid #ddd;
+            border-radius: 10px;
+            padding: 15px 25px;
+            cursor: pointer;
+            transition: all 0.2s ease;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            min-width: 140px;
+            box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+        }
+
+        .mode-tab-btn:hover {
+            border-color: #8f7a66;
+            background: #f8f8f8;
+            transform: translateY(-2px);
+            box-shadow: 0 4px 10px rgba(0, 0, 0, 0.15);
+        }
+
+        .mode-tab-btn.active {
+            background: #8f7a66;
+            border-color: #8f7a66;
+            color: white;
+            transform: translateY(-2px);
+            box-shadow: 0 4px 10px rgba(0, 0, 0, 0.2);
+        }
+
+        .mode-title {
+            font-weight: 600;
+            font-size: 1.1rem;
+            margin-bottom: 4px;
+        }
+
+        .mode-desc {
+            font-size: 0.85rem;
+            opacity: 0.8;
+        }
+
         .leaderboard-tabs {
             display: flex;
             background: white;
@@ -326,11 +405,21 @@ <h1 class="page-title">🏆 2048 Leaderboards</h1>
             .page-title {
                 font-size: 2rem;
             }
-            
+
+            .game-mode-tabs {
+                flex-direction: column;
+                gap: 10px;
+            }
+
+            .mode-tab-btn {
+                min-width: auto;
+                padding: 12px 20px;
+            }
+
             .leaderboard-tabs {
                 flex-wrap: wrap;
             }
-            
+
             .tab-btn {
                 flex: 1 1 50%;
             }
diff --git a/backend/internal/database/gorm.go b/backend/internal/database/gorm.go
index 8211ad4..57167cd 100644
--- a/backend/internal/database/gorm.go
+++ b/backend/internal/database/gorm.go
@@ -263,6 +263,55 @@ func (g *GormDB) GetLeaderboard(leaderboardType models.LeaderboardType, limit in
 	return leaderboardEntries, nil
 }
 
+// GetLeaderboardByMode retrieves leaderboard entries for a specific game mode
+func (g *GormDB) GetLeaderboardByMode(leaderboardType models.LeaderboardType, gameMode models.GameMode, limit int) ([]models.LeaderboardEntry, error) {
+	var entries []models.GormLeaderboardEntry
+
+	// Build subquery to get max score per user for specific game mode
+	subquery := g.db.Table("games").
+		Select("user_id, MAX(score) as max_score").
+		Where("(game_over = ? OR victory = ?) AND game_mode = ?", true, true, string(gameMode))
+
+	switch leaderboardType {
+	case models.LeaderboardDaily:
+		subquery = subquery.Where("created_at >= CURRENT_DATE")
+	case models.LeaderboardWeekly:
+		subquery = subquery.Where("created_at >= DATE_TRUNC('week', CURRENT_DATE)")
+	case models.LeaderboardMonthly:
+		subquery = subquery.Where("created_at >= DATE_TRUNC('month', CURRENT_DATE)")
+	case models.LeaderboardAll:
+		// No additional filter for all-time leaderboard
+	default:
+		return nil, fmt.Errorf("invalid leaderboard type")
+	}
+
+	subquery = subquery.Group("user_id")
+
+	// Main query to get full game details for the max score games
+	query := g.db.Table("games g").
+		Select("g.user_id, u.name as user_name, u.avatar as user_avatar, g.score, g.id as game_id, g.created_at, ROW_NUMBER() OVER (ORDER BY g.score DESC) as rank").
+		Joins("JOIN users u ON g.user_id = u.id").
+		Joins("JOIN (?) max_scores ON g.user_id = max_scores.user_id AND g.score = max_scores.max_score", subquery).
+		Where("(g.game_over = ? OR g.victory = ?) AND g.game_mode = ?", true, true, string(gameMode)).
+		Order("g.score DESC").
+		Limit(limit)
+
+	result := query.Scan(&entries)
+	if result.Error != nil {
+		return nil, fmt.Errorf("failed to query leaderboard by mode: %w", result.Error)
+	}
+
+	// Convert to regular LeaderboardEntry
+	var leaderboardEntries []models.LeaderboardEntry
+	for _, entry := range entries {
+		leaderboardEntry := entry.ToLeaderboardEntry()
+		leaderboardEntry.GameMode = gameMode
+		leaderboardEntries = append(leaderboardEntries, *leaderboardEntry)
+	}
+
+	return leaderboardEntries, nil
+}
+
 // GetDB returns the underlying GORM database instance
 func (g *GormDB) GetDB() *gorm.DB {
 	return g.db
diff --git a/backend/internal/database/interface.go b/backend/internal/database/interface.go
index 4851007..cd3e3e2 100644
--- a/backend/internal/database/interface.go
+++ b/backend/internal/database/interface.go
@@ -17,6 +17,7 @@ type Database interface {
 
 	// Leaderboard operations
 	GetLeaderboard(leaderboardType models.LeaderboardType, limit int) ([]models.LeaderboardEntry, error)
+	GetLeaderboardByMode(leaderboardType models.LeaderboardType, gameMode models.GameMode, limit int) ([]models.LeaderboardEntry, error)
 
 	// Connection management
 	Close() error
diff --git a/backend/internal/database/postgres.go b/backend/internal/database/postgres.go
index f916547..b8271a4 100644
--- a/backend/internal/database/postgres.go
+++ b/backend/internal/database/postgres.go
@@ -127,16 +127,24 @@ func (p *PostgresDB) CreateGame(game *models.GameState) error {
 		return fmt.Errorf("failed to marshal board: %w", err)
 	}
 
+	var disabledCellJSON []byte
+	if game.DisabledCell != nil {
+		disabledCellJSON, err = json.Marshal(game.DisabledCell)
+		if err != nil {
+			return fmt.Errorf("failed to marshal disabled cell: %w", err)
+		}
+	}
+
 	query := `
-		INSERT INTO games (id, user_id, board, score, game_over, victory, created_at, updated_at)
-		VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`
+		INSERT INTO games (id, user_id, board, score, game_over, victory, game_mode, disabled_cell, created_at, updated_at)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`
 
 	now := time.Now()
 	game.CreatedAt = now
 	game.UpdatedAt = now
 
 	_, err = p.db.Exec(query, game.ID, game.UserID, boardJSON, game.Score,
-		game.GameOver, game.Victory, game.CreatedAt, game.UpdatedAt)
+		game.GameOver, game.Victory, string(game.GameMode), disabledCellJSON, game.CreatedAt, game.UpdatedAt)
 
 	if err != nil {
 		return fmt.Errorf("failed to create game: %w", err)
@@ -152,15 +160,23 @@ func (p *PostgresDB) UpdateGame(game *models.GameState) error {
 		return fmt.Errorf("failed to marshal board: %w", err)
 	}
 
+	var disabledCellJSON []byte
+	if game.DisabledCell != nil {
+		disabledCellJSON, err = json.Marshal(game.DisabledCell)
+		if err != nil {
+			return fmt.Errorf("failed to marshal disabled cell: %w", err)
+		}
+	}
+
 	query := `
-		UPDATE games 
-		SET board = $1, score = $2, game_over = $3, victory = $4, updated_at = $5
-		WHERE id = $6 AND user_id = $7`
+		UPDATE games
+		SET board = $1, score = $2, game_over = $3, victory = $4, game_mode = $5, disabled_cell = $6, updated_at = $7
+		WHERE id = $8 AND user_id = $9`
 
 	game.UpdatedAt = time.Now()
 
 	result, err := p.db.Exec(query, boardJSON, game.Score, game.GameOver,
-		game.Victory, game.UpdatedAt, game.ID, game.UserID)
+		game.Victory, string(game.GameMode), disabledCellJSON, game.UpdatedAt, game.ID, game.UserID)
 
 	if err != nil {
 		return fmt.Errorf("failed to update game: %w", err)
@@ -181,15 +197,17 @@ func (p *PostgresDB) UpdateGame(game *models.GameState) error {
 // GetGame retrieves a game by ID and user ID
 func (p *PostgresDB) GetGame(gameID, userID string) (*models.GameState, error) {
 	query := `
-		SELECT id, user_id, board, score, game_over, victory, created_at, updated_at
+		SELECT id, user_id, board, score, game_over, victory, game_mode, disabled_cell, created_at, updated_at
 		FROM games WHERE id = $1 AND user_id = $2`
 
 	game := &models.GameState{}
 	var boardJSON []byte
+	var disabledCellJSON []byte
+	var gameMode string
 
 	err := p.db.QueryRow(query, gameID, userID).Scan(
 		&game.ID, &game.UserID, &boardJSON, &game.Score,
-		&game.GameOver, &game.Victory, &game.CreatedAt, &game.UpdatedAt)
+		&game.GameOver, &game.Victory, &gameMode, &disabledCellJSON, &game.CreatedAt, &game.UpdatedAt)
 
 	if err != nil {
 		if err == sql.ErrNoRows {
@@ -202,24 +220,36 @@ func (p *PostgresDB) GetGame(gameID, userID string) (*models.GameState, error) {
 		return nil, fmt.Errorf("failed to unmarshal board: %w", err)
 	}
 
+	game.GameMode = models.GameMode(gameMode)
+
+	if len(disabledCellJSON) > 0 {
+		var disabledCell models.DisabledCell
+		if err := json.Unmarshal(disabledCellJSON, &disabledCell); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal disabled cell: %w", err)
+		}
+		game.DisabledCell = &disabledCell
+	}
+
 	return game, nil
 }
 
 // GetUserActiveGame retrieves the user's active (non-finished) game
 func (p *PostgresDB) GetUserActiveGame(userID string) (*models.GameState, error) {
 	query := `
-		SELECT id, user_id, board, score, game_over, victory, created_at, updated_at
-		FROM games 
+		SELECT id, user_id, board, score, game_over, victory, game_mode, disabled_cell, created_at, updated_at
+		FROM games
 		WHERE user_id = $1 AND game_over = false AND victory = false
 		ORDER BY updated_at DESC
 		LIMIT 1`
 
 	game := &models.GameState{}
 	var boardJSON []byte
+	var disabledCellJSON []byte
+	var gameMode string
 
 	err := p.db.QueryRow(query, userID).Scan(
 		&game.ID, &game.UserID, &boardJSON, &game.Score,
-		&game.GameOver, &game.Victory, &game.CreatedAt, &game.UpdatedAt)
+		&game.GameOver, &game.Victory, &gameMode, &disabledCellJSON, &game.CreatedAt, &game.UpdatedAt)
 
 	if err != nil {
 		if err == sql.ErrNoRows {
@@ -232,6 +262,16 @@ func (p *PostgresDB) GetUserActiveGame(userID string) (*models.GameState, error)
 		return nil, fmt.Errorf("failed to unmarshal board: %w", err)
 	}
 
+	game.GameMode = models.GameMode(gameMode)
+
+	if len(disabledCellJSON) > 0 {
+		var disabledCell models.DisabledCell
+		if err := json.Unmarshal(disabledCellJSON, &disabledCell); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal disabled cell: %w", err)
+		}
+		game.DisabledCell = &disabledCell
+	}
+
 	return game, nil
 }
 
@@ -303,3 +343,73 @@ func (p *PostgresDB) GetLeaderboard(leaderboardType models.LeaderboardType, limi
 
 	return entries, nil
 }
+
+// GetLeaderboardByMode retrieves leaderboard entries for a specific game mode
+func (p *PostgresDB) GetLeaderboardByMode(leaderboardType models.LeaderboardType, gameMode models.GameMode, limit int) ([]models.LeaderboardEntry, error) {
+	var query string
+	var args []interface{}
+
+	baseQuery := `
+		SELECT
+			g.user_id,
+			u.name as user_name,
+			u.avatar as user_avatar,
+			g.score,
+			g.id as game_id,
+			g.created_at,
+			ROW_NUMBER() OVER (ORDER BY g.score DESC) as rank
+		FROM (
+			SELECT
+				user_id,
+				MAX(score) as score,
+				(ARRAY_AGG(id ORDER BY score DESC))[1] as id,
+				(ARRAY_AGG(created_at ORDER BY score DESC))[1] as created_at
+			FROM games
+			WHERE (game_over = true OR victory = true) AND game_mode = $1`
+
+	var timeFilter string
+	switch leaderboardType {
+	case models.LeaderboardDaily:
+		timeFilter = ` AND created_at >= CURRENT_DATE`
+	case models.LeaderboardWeekly:
+		timeFilter = ` AND created_at >= DATE_TRUNC('week', CURRENT_DATE)`
+	case models.LeaderboardMonthly:
+		timeFilter = ` AND created_at >= DATE_TRUNC('month', CURRENT_DATE)`
+	case models.LeaderboardAll:
+		timeFilter = ""
+	default:
+		return nil, fmt.Errorf("invalid leaderboard type")
+	}
+
+	query = baseQuery + timeFilter + `
+			GROUP BY user_id
+		) g
+		JOIN users u ON g.user_id = u.id
+		ORDER BY g.score DESC LIMIT $2`
+	args = append(args, string(gameMode), limit)
+
+	rows, err := p.db.Query(query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query leaderboard by mode: %w", err)
+	}
+	defer rows.Close()
+
+	var entries []models.LeaderboardEntry
+	for rows.Next() {
+		var entry models.LeaderboardEntry
+		err := rows.Scan(
+			&entry.UserID, &entry.UserName, &entry.UserAvatar,
+			&entry.Score, &entry.GameID, &entry.CreatedAt, &entry.Rank)
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan leaderboard entry: %w", err)
+		}
+		entry.GameMode = gameMode
+		entries = append(entries, entry)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating leaderboard rows: %w", err)
+	}
+
+	return entries, nil
+}
diff --git a/backend/internal/game/engine.go b/backend/internal/game/engine.go
index f63e2e4..c89655c 100644
--- a/backend/internal/game/engine.go
+++ b/backend/internal/game/engine.go
@@ -1,9 +1,9 @@
 package game
 
 import (
+	"game2048/pkg/models"
 	"math/rand"
 	"time"
-	"game2048/pkg/models"
 )
 
 // Engine handles the core 2048 game logic
@@ -21,20 +21,37 @@ func NewEngine() *Engine {
 // NewGame creates a new game with initial tiles
 func (e *Engine) NewGame() models.Board {
 	board := models.NewBoard()
-	
+
 	// Add two initial tiles
 	e.addRandomTile(&board)
 	e.addRandomTile(&board)
-	
+
 	return board
 }
 
+// NewGameWithMode creates a new game with specified mode
+func (e *Engine) NewGameWithMode(gameMode models.GameMode) (models.Board, *models.DisabledCell) {
+	board := models.NewBoard()
+	var disabledCell *models.DisabledCell
+
+	// For challenge mode, randomly disable one cell
+	if gameMode == models.GameModeChallenge {
+		disabledCell = e.generateRandomDisabledCell()
+	}
+
+	// Add two initial tiles (avoiding disabled cell in challenge mode)
+	e.addRandomTileExcluding(&board, disabledCell)
+	e.addRandomTileExcluding(&board, disabledCell)
+
+	return board, disabledCell
+}
+
 // Move executes a move in the given direction and returns the new board and score gained
 func (e *Engine) Move(board models.Board, direction models.Direction) (models.Board, int, bool) {
 	newBoard := board.Copy()
 	scoreGained := 0
 	moved := false
-	
+
 	switch direction {
 	case models.DirectionUp:
 		scoreGained, moved = e.moveUp(&newBoard)
@@ -45,12 +62,37 @@ func (e *Engine) Move(board models.Board, direction models.Direction) (models.Bo
 	case models.DirectionRight:
 		scoreGained, moved = e.moveRight(&newBoard)
 	}
-	
+
 	// Add a new tile if the move was valid
 	if moved {
 		e.addRandomTile(&newBoard)
 	}
-	
+
+	return newBoard, scoreGained, moved
+}
+
+// MoveWithDisabledCell executes a move considering disabled cells
+func (e *Engine) MoveWithDisabledCell(board models.Board, direction models.Direction, disabledCell *models.DisabledCell) (models.Board, int, bool) {
+	newBoard := board.Copy()
+	scoreGained := 0
+	moved := false
+
+	switch direction {
+	case models.DirectionUp:
+		scoreGained, moved = e.moveUpWithDisabled(&newBoard, disabledCell)
+	case models.DirectionDown:
+		scoreGained, moved = e.moveDownWithDisabled(&newBoard, disabledCell)
+	case models.DirectionLeft:
+		scoreGained, moved = e.moveLeftWithDisabled(&newBoard, disabledCell)
+	case models.DirectionRight:
+		scoreGained, moved = e.moveRightWithDisabled(&newBoard, disabledCell)
+	}
+
+	// Add a new tile if the move was valid (avoiding disabled cell)
+	if moved {
+		e.addRandomTileExcluding(&newBoard, disabledCell)
+	}
+
 	return newBoard, scoreGained, moved
 }
 
@@ -60,20 +102,44 @@ func (e *Engine) IsGameOver(board models.Board) bool {
 	if !board.IsFull() {
 		return false
 	}
-	
+
 	// Check if any moves are possible
 	directions := []models.Direction{
 		models.DirectionUp, models.DirectionDown,
 		models.DirectionLeft, models.DirectionRight,
 	}
-	
+
 	for _, dir := range directions {
 		_, _, moved := e.Move(board, dir)
 		if moved {
 			return false
 		}
 	}
-	
+
+	return true
+}
+
+// IsGameOverWithDisabledCell checks if the game is over considering disabled cells
+func (e *Engine) IsGameOverWithDisabledCell(board models.Board, disabledCell *models.DisabledCell) bool {
+	// If there are empty cells (excluding disabled), game is not over
+	emptyCells := board.GetEmptyCellsExcluding(disabledCell)
+	if len(emptyCells) > 0 {
+		return false
+	}
+
+	// Check if any moves are possible with disabled cell logic
+	directions := []models.Direction{
+		models.DirectionUp, models.DirectionDown,
+		models.DirectionLeft, models.DirectionRight,
+	}
+
+	for _, dir := range directions {
+		_, _, moved := e.MoveWithDisabledCell(board, dir, disabledCell)
+		if moved {
+			return false
+		}
+	}
+
 	return true
 }
 
@@ -88,16 +154,16 @@ func (e *Engine) addRandomTile(board *models.Board) bool {
 	if len(emptyCells) == 0 {
 		return false
 	}
-	
+
 	// Choose random empty cell
 	pos := emptyCells[e.rng.Intn(len(emptyCells))]
-	
+
 	// 90% chance for 2, 10% chance for 4
 	value := 2
 	if e.rng.Float32() < 0.1 {
 		value = 4
 	}
-	
+
 	board.SetCell(pos[0], pos[1], value)
 	return true
 }
@@ -106,7 +172,7 @@ func (e *Engine) addRandomTile(board *models.Board) bool {
 func (e *Engine) moveLeft(board *models.Board) (int, bool) {
 	scoreGained := 0
 	moved := false
-	
+
 	for row := 0; row < models.BoardSize; row++ {
 		// Extract non-zero values
 		var line []int
@@ -115,25 +181,25 @@ func (e *Engine) moveLeft(board *models.Board) (int, bool) {
 				line = append(line, board.GetCell(row, col))
 			}
 		}
-		
+
 		// Merge adjacent equal values
 		merged := e.mergeLine(line)
 		scoreGained += merged.score
-		
+
 		// Check if anything changed
 		for col := 0; col < models.BoardSize; col++ {
 			newValue := 0
 			if col < len(merged.line) {
 				newValue = merged.line[col]
 			}
-			
+
 			if board.GetCell(row, col) != newValue {
 				moved = true
 			}
 			board.SetCell(row, col, newValue)
 		}
 	}
-	
+
 	return scoreGained, moved
 }
 
@@ -141,7 +207,7 @@ func (e *Engine) moveLeft(board *models.Board) (int, bool) {
 func (e *Engine) moveRight(board *models.Board) (int, bool) {
 	scoreGained := 0
 	moved := false
-	
+
 	for row := 0; row < models.BoardSize; row++ {
 		// Extract non-zero values (in reverse order)
 		var line []int
@@ -150,18 +216,18 @@ func (e *Engine) moveRight(board *models.Board) (int, bool) {
 				line = append(line, board.GetCell(row, col))
 			}
 		}
-		
+
 		// Merge adjacent equal values
 		merged := e.mergeLine(line)
 		scoreGained += merged.score
-		
+
 		// Place back in reverse order
 		for col := 0; col < models.BoardSize; col++ {
 			newValue := 0
 			if col < len(merged.line) {
 				newValue = merged.line[col]
 			}
-			
+
 			actualCol := models.BoardSize - 1 - col
 			if board.GetCell(row, actualCol) != newValue {
 				moved = true
@@ -169,7 +235,7 @@ func (e *Engine) moveRight(board *models.Board) (int, bool) {
 			board.SetCell(row, actualCol, newValue)
 		}
 	}
-	
+
 	return scoreGained, moved
 }
 
@@ -177,7 +243,7 @@ func (e *Engine) moveRight(board *models.Board) (int, bool) {
 func (e *Engine) moveUp(board *models.Board) (int, bool) {
 	scoreGained := 0
 	moved := false
-	
+
 	for col := 0; col < models.BoardSize; col++ {
 		// Extract non-zero values
 		var line []int
@@ -186,25 +252,25 @@ func (e *Engine) moveUp(board *models.Board) (int, bool) {
 				line = append(line, board.GetCell(row, col))
 			}
 		}
-		
+
 		// Merge adjacent equal values
 		merged := e.mergeLine(line)
 		scoreGained += merged.score
-		
+
 		// Check if anything changed
 		for row := 0; row < models.BoardSize; row++ {
 			newValue := 0
 			if row < len(merged.line) {
 				newValue = merged.line[row]
 			}
-			
+
 			if board.GetCell(row, col) != newValue {
 				moved = true
 			}
 			board.SetCell(row, col, newValue)
 		}
 	}
-	
+
 	return scoreGained, moved
 }
 
@@ -212,7 +278,7 @@ func (e *Engine) moveUp(board *models.Board) (int, bool) {
 func (e *Engine) moveDown(board *models.Board) (int, bool) {
 	scoreGained := 0
 	moved := false
-	
+
 	for col := 0; col < models.BoardSize; col++ {
 		// Extract non-zero values (in reverse order)
 		var line []int
@@ -221,18 +287,18 @@ func (e *Engine) moveDown(board *models.Board) (int, bool) {
 				line = append(line, board.GetCell(row, col))
 			}
 		}
-		
+
 		// Merge adjacent equal values
 		merged := e.mergeLine(line)
 		scoreGained += merged.score
-		
+
 		// Place back in reverse order
 		for row := 0; row < models.BoardSize; row++ {
 			newValue := 0
 			if row < len(merged.line) {
 				newValue = merged.line[row]
 			}
-			
+
 			actualRow := models.BoardSize - 1 - row
 			if board.GetCell(actualRow, col) != newValue {
 				moved = true
@@ -240,7 +306,7 @@ func (e *Engine) moveDown(board *models.Board) (int, bool) {
 			board.SetCell(actualRow, col, newValue)
 		}
 	}
-	
+
 	return scoreGained, moved
 }
 
@@ -255,11 +321,11 @@ func (e *Engine) mergeLine(line []int) mergeResult {
 	if len(line) <= 1 {
 		return mergeResult{line: line, score: 0}
 	}
-	
+
 	var result []int
 	score := 0
 	i := 0
-	
+
 	for i < len(line) {
 		if i+1 < len(line) && line[i] == line[i+1] {
 			// Merge the two tiles
@@ -273,6 +339,305 @@ func (e *Engine) mergeLine(line []int) mergeResult {
 			i++
 		}
 	}
-	
+
 	return mergeResult{line: result, score: score}
 }
+
+// generateRandomDisabledCell generates a random disabled cell position
+func (e *Engine) generateRandomDisabledCell() *models.DisabledCell {
+	row := e.rng.Intn(models.BoardSize)
+	col := e.rng.Intn(models.BoardSize)
+	return &models.DisabledCell{
+		Row: row,
+		Col: col,
+	}
+}
+
+// addRandomTileExcluding adds a random tile to the board excluding disabled cells
+func (e *Engine) addRandomTileExcluding(board *models.Board, disabledCell *models.DisabledCell) {
+	emptyCells := board.GetEmptyCellsExcluding(disabledCell)
+	if len(emptyCells) == 0 {
+		return
+	}
+
+	// Choose random empty cell
+	randomIndex := e.rng.Intn(len(emptyCells))
+	cell := emptyCells[randomIndex]
+
+	// 90% chance for 2, 10% chance for 4
+	value := 2
+	if e.rng.Float32() < 0.1 {
+		value = 4
+	}
+
+	board.SetCell(cell[0], cell[1], value)
+}
+
+// moveLeftWithDisabled moves all tiles to the left considering disabled cells
+func (e *Engine) moveLeftWithDisabled(board *models.Board, disabledCell *models.DisabledCell) (int, bool) {
+	scoreGained := 0
+	moved := false
+
+	for row := 0; row < models.BoardSize; row++ {
+		// Extract non-zero values, treating disabled cell as immovable
+		var line []int
+		var positions []int // Track original positions
+
+		for col := 0; col < models.BoardSize; col++ {
+			if board.IsDisabledCell(row, col, disabledCell) {
+				// Disabled cell acts as a barrier - process left and right sides separately
+				if len(line) > 0 {
+					// Process left side
+					merged := e.mergeLine(line)
+					scoreGained += merged.score
+
+					// Place merged tiles back
+					for i, val := range merged.line {
+						if positions[i] != board.GetCell(row, positions[i]) {
+							moved = true
+						}
+						board.SetCell(row, positions[i], val)
+					}
+					// Clear remaining positions on left side
+					for i := len(merged.line); i < len(positions); i++ {
+						if board.GetCell(row, positions[i]) != 0 {
+							moved = true
+						}
+						board.SetCell(row, positions[i], 0)
+					}
+				}
+				// Reset for right side
+				line = nil
+				positions = nil
+			} else if board.GetCell(row, col) != 0 {
+				line = append(line, board.GetCell(row, col))
+				positions = append(positions, col)
+			}
+		}
+
+		// Process remaining tiles (right side of disabled cell or entire row if no disabled cell)
+		if len(line) > 0 {
+			merged := e.mergeLine(line)
+			scoreGained += merged.score
+
+			// Place merged tiles back
+			for i, val := range merged.line {
+				if positions[i] != board.GetCell(row, positions[i]) {
+					moved = true
+				}
+				board.SetCell(row, positions[i], val)
+			}
+			// Clear remaining positions
+			for i := len(merged.line); i < len(positions); i++ {
+				if board.GetCell(row, positions[i]) != 0 {
+					moved = true
+				}
+				board.SetCell(row, positions[i], 0)
+			}
+		}
+	}
+
+	return scoreGained, moved
+}
+
+// moveRightWithDisabled moves all tiles to the right considering disabled cells
+func (e *Engine) moveRightWithDisabled(board *models.Board, disabledCell *models.DisabledCell) (int, bool) {
+	if disabledCell == nil {
+		return e.moveRight(board)
+	}
+
+	scoreGained := 0
+	moved := false
+
+	for row := 0; row < models.BoardSize; row++ {
+		// Extract non-zero values from right to left, treating disabled cell as barrier
+		var line []int
+		var positions []int
+
+		for col := models.BoardSize - 1; col >= 0; col-- {
+			if board.IsDisabledCell(row, col, disabledCell) {
+				// Process right side first
+				if len(line) > 0 {
+					merged := e.mergeLine(line)
+					scoreGained += merged.score
+
+					// Place merged tiles back from right
+					for i, val := range merged.line {
+						pos := positions[i]
+						if board.GetCell(row, pos) != val {
+							moved = true
+						}
+						board.SetCell(row, pos, val)
+					}
+					// Clear remaining positions
+					for i := len(merged.line); i < len(positions); i++ {
+						if board.GetCell(row, positions[i]) != 0 {
+							moved = true
+						}
+						board.SetCell(row, positions[i], 0)
+					}
+				}
+				// Reset for left side
+				line = nil
+				positions = nil
+			} else if board.GetCell(row, col) != 0 {
+				line = append(line, board.GetCell(row, col))
+				positions = append(positions, col)
+			}
+		}
+
+		// Process remaining tiles (left side or entire row)
+		if len(line) > 0 {
+			merged := e.mergeLine(line)
+			scoreGained += merged.score
+
+			for i, val := range merged.line {
+				pos := positions[i]
+				if board.GetCell(row, pos) != val {
+					moved = true
+				}
+				board.SetCell(row, pos, val)
+			}
+			for i := len(merged.line); i < len(positions); i++ {
+				if board.GetCell(row, positions[i]) != 0 {
+					moved = true
+				}
+				board.SetCell(row, positions[i], 0)
+			}
+		}
+	}
+
+	return scoreGained, moved
+}
+
+// moveUpWithDisabled moves all tiles up considering disabled cells
+func (e *Engine) moveUpWithDisabled(board *models.Board, disabledCell *models.DisabledCell) (int, bool) {
+	if disabledCell == nil {
+		return e.moveUp(board)
+	}
+
+	scoreGained := 0
+	moved := false
+
+	for col := 0; col < models.BoardSize; col++ {
+		var line []int
+		var positions []int
+
+		for row := 0; row < models.BoardSize; row++ {
+			if board.IsDisabledCell(row, col, disabledCell) {
+				// Process top side first
+				if len(line) > 0 {
+					merged := e.mergeLine(line)
+					scoreGained += merged.score
+
+					for i, val := range merged.line {
+						pos := positions[i]
+						if board.GetCell(pos, col) != val {
+							moved = true
+						}
+						board.SetCell(pos, col, val)
+					}
+					for i := len(merged.line); i < len(positions); i++ {
+						if board.GetCell(positions[i], col) != 0 {
+							moved = true
+						}
+						board.SetCell(positions[i], col, 0)
+					}
+				}
+				line = nil
+				positions = nil
+			} else if board.GetCell(row, col) != 0 {
+				line = append(line, board.GetCell(row, col))
+				positions = append(positions, row)
+			}
+		}
+
+		// Process remaining tiles
+		if len(line) > 0 {
+			merged := e.mergeLine(line)
+			scoreGained += merged.score
+
+			for i, val := range merged.line {
+				pos := positions[i]
+				if board.GetCell(pos, col) != val {
+					moved = true
+				}
+				board.SetCell(pos, col, val)
+			}
+			for i := len(merged.line); i < len(positions); i++ {
+				if board.GetCell(positions[i], col) != 0 {
+					moved = true
+				}
+				board.SetCell(positions[i], col, 0)
+			}
+		}
+	}
+
+	return scoreGained, moved
+}
+
+// moveDownWithDisabled moves all tiles down considering disabled cells
+func (e *Engine) moveDownWithDisabled(board *models.Board, disabledCell *models.DisabledCell) (int, bool) {
+	if disabledCell == nil {
+		return e.moveDown(board)
+	}
+
+	scoreGained := 0
+	moved := false
+
+	for col := 0; col < models.BoardSize; col++ {
+		var line []int
+		var positions []int
+
+		for row := models.BoardSize - 1; row >= 0; row-- {
+			if board.IsDisabledCell(row, col, disabledCell) {
+				// Process bottom side first
+				if len(line) > 0 {
+					merged := e.mergeLine(line)
+					scoreGained += merged.score
+
+					for i, val := range merged.line {
+						pos := positions[i]
+						if board.GetCell(pos, col) != val {
+							moved = true
+						}
+						board.SetCell(pos, col, val)
+					}
+					for i := len(merged.line); i < len(positions); i++ {
+						if board.GetCell(positions[i], col) != 0 {
+							moved = true
+						}
+						board.SetCell(positions[i], col, 0)
+					}
+				}
+				line = nil
+				positions = nil
+			} else if board.GetCell(row, col) != 0 {
+				line = append(line, board.GetCell(row, col))
+				positions = append(positions, row)
+			}
+		}
+
+		// Process remaining tiles
+		if len(line) > 0 {
+			merged := e.mergeLine(line)
+			scoreGained += merged.score
+
+			for i, val := range merged.line {
+				pos := positions[i]
+				if board.GetCell(pos, col) != val {
+					moved = true
+				}
+				board.SetCell(pos, col, val)
+			}
+			for i := len(merged.line); i < len(positions); i++ {
+				if board.GetCell(positions[i], col) != 0 {
+					moved = true
+				}
+				board.SetCell(positions[i], col, 0)
+			}
+		}
+	}
+
+	return scoreGained, moved
+}
diff --git a/backend/internal/handlers/leaderboard.go b/backend/internal/handlers/leaderboard.go
index f17610c..932f79a 100644
--- a/backend/internal/handlers/leaderboard.go
+++ b/backend/internal/handlers/leaderboard.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"net/http"
 	"strconv"
-	"time"
 
 	"game2048/internal/cache"
 	"game2048/internal/database"
@@ -50,6 +49,18 @@ func (h *LeaderboardHandler) GetLeaderboard(c *gin.Context) {
 		return
 	}
 
+	// Get game mode from query parameter
+	gameModeStr := c.DefaultQuery("game_mode", "classic")
+	var gameMode models.GameMode
+	switch gameModeStr {
+	case "classic":
+		gameMode = models.GameModeClassic
+	case "challenge":
+		gameMode = models.GameModeChallenge
+	default:
+		gameMode = models.GameModeClassic
+	}
+
 	// Get limit from query parameter (default 100, max 100)
 	limitStr := c.DefaultQuery("limit", "100")
 	limit, err := strconv.Atoi(limitStr)
@@ -57,24 +68,12 @@ func (h *LeaderboardHandler) GetLeaderboard(c *gin.Context) {
 		limit = 100
 	}
 
-	// Try to get from cache first
+	// Try to get from cache first (for now, skip cache for game mode specific queries)
 	var entries []models.LeaderboardEntry
 
-	if h.cache != nil {
-		entries, err = h.cache.GetLeaderboard(lbType)
-		if err == nil {
-			// Cache hit, return cached data
-			response := models.LeaderboardResponse{
-				Type:     lbType,
-				Rankings: entries,
-			}
-			c.JSON(http.StatusOK, response)
-			return
-		}
-	}
-
-	// Cache miss or no cache, get from database
-	entries, err = h.db.GetLeaderboard(lbType, limit)
+	// For now, always get from database to support game mode filtering
+	// TODO: Update cache to support game mode keys
+	entries, err = h.db.GetLeaderboardByMode(lbType, gameMode, limit)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{
 			"error": "Failed to get leaderboard",
@@ -82,14 +81,8 @@ func (h *LeaderboardHandler) GetLeaderboard(c *gin.Context) {
 		return
 	}
 
-	// Cache the result if cache is available
-	if h.cache != nil {
-		cacheTTL := 30 * time.Second // 30 seconds cache
-		if err := h.cache.SetLeaderboard(lbType, entries, cacheTTL); err != nil {
-			// Log error but don't fail the request
-			// log.Printf("Failed to cache leaderboard: %v", err)
-		}
-	}
+	// TODO: Cache the result if cache is available (update cache to support game modes)
+	// For now, skip caching for game mode specific queries
 
 	// Return response
 	response := models.LeaderboardResponse{
diff --git a/backend/internal/websocket/handlers.go b/backend/internal/websocket/handlers.go
index 963b1d4..6cf3bfc 100644
--- a/backend/internal/websocket/handlers.go
+++ b/backend/internal/websocket/handlers.go
@@ -52,8 +52,17 @@ func (c *Client) handleMove(data interface{}) {
 		return
 	}
 
-	// Execute move
-	newBoard, scoreGained, moved := c.hub.gameEngine.Move(gameState.Board, moveRequest.Direction)
+	// Execute move based on game mode
+	var newBoard models.Board
+	var scoreGained int
+	var moved bool
+
+	if gameState.GameMode == models.GameModeChallenge && gameState.DisabledCell != nil {
+		newBoard, scoreGained, moved = c.hub.gameEngine.MoveWithDisabledCell(gameState.Board, moveRequest.Direction, gameState.DisabledCell)
+	} else {
+		newBoard, scoreGained, moved = c.hub.gameEngine.Move(gameState.Board, moveRequest.Direction)
+	}
+
 	if !moved {
 		c.sendError("Invalid move - no tiles moved")
 		return
@@ -68,9 +77,15 @@ func (c *Client) handleMove(data interface{}) {
 		gameState.Victory = true
 	}
 
-	// Check for game over
-	if c.hub.gameEngine.IsGameOver(gameState.Board) {
-		gameState.GameOver = true
+	// Check for game over (use appropriate logic based on game mode)
+	if gameState.GameMode == models.GameModeChallenge && gameState.DisabledCell != nil {
+		if c.hub.gameEngine.IsGameOverWithDisabledCell(gameState.Board, gameState.DisabledCell) {
+			gameState.GameOver = true
+		}
+	} else {
+		if c.hub.gameEngine.IsGameOver(gameState.Board) {
+			gameState.GameOver = true
+		}
 	}
 
 	// Save updated game state to cache
@@ -100,10 +115,12 @@ func (c *Client) handleMove(data interface{}) {
 
 	// Send response
 	response := models.GameResponse{
-		Board:    gameState.Board,
-		Score:    gameState.Score,
-		GameOver: gameState.GameOver,
-		Victory:  gameState.Victory,
+		Board:        gameState.Board,
+		Score:        gameState.Score,
+		GameOver:     gameState.GameOver,
+		Victory:      gameState.Victory,
+		GameMode:     gameState.GameMode,
+		DisabledCell: gameState.DisabledCell,
 	}
 
 	if gameState.Victory {
@@ -127,17 +144,45 @@ func (c *Client) handleMove(data interface{}) {
 
 // handleNewGame handles new game requests
 func (c *Client) handleNewGame(data interface{}) {
-	// Create new game
-	board := c.hub.gameEngine.NewGame()
+	// Parse new game request
+	dataBytes, err := json.Marshal(data)
+	if err != nil {
+		c.sendError("Invalid new game data")
+		return
+	}
+
+	var newGameRequest models.NewGameRequest
+	if err := json.Unmarshal(dataBytes, &newGameRequest); err != nil {
+		// Default to classic mode if no mode specified
+		newGameRequest.GameMode = models.GameModeClassic
+	}
+
+	// Validate game mode
+	if newGameRequest.GameMode != models.GameModeClassic && newGameRequest.GameMode != models.GameModeChallenge {
+		newGameRequest.GameMode = models.GameModeClassic
+	}
+
+	// Create new game based on mode
+	var board models.Board
+	var disabledCell *models.DisabledCell
+
+	if newGameRequest.GameMode == models.GameModeChallenge {
+		board, disabledCell = c.hub.gameEngine.NewGameWithMode(models.GameModeChallenge)
+	} else {
+		board = c.hub.gameEngine.NewGame()
+	}
+
 	gameID := uuid.New()
 
 	gameState := &models.GameState{
-		ID:       gameID,
-		UserID:   c.userID,
-		Board:    board,
-		Score:    0,
-		GameOver: false,
-		Victory:  false,
+		ID:           gameID,
+		UserID:       c.userID,
+		Board:        board,
+		Score:        0,
+		GameOver:     false,
+		Victory:      false,
+		GameMode:     newGameRequest.GameMode,
+		DisabledCell: disabledCell,
 	}
 
 	// Save new game state to cache
@@ -161,12 +206,19 @@ func (c *Client) handleNewGame(data interface{}) {
 	c.gameID = gameID
 
 	// Send response
+	statusMessage := "New game started!"
+	if gameState.GameMode == models.GameModeChallenge {
+		statusMessage = "Challenge mode started! One cell is disabled."
+	}
+
 	response := models.GameResponse{
-		Board:    gameState.Board,
-		Score:    gameState.Score,
-		GameOver: gameState.GameOver,
-		Victory:  gameState.Victory,
-		Message:  "New game started!",
+		Board:        gameState.Board,
+		Score:        gameState.Score,
+		GameOver:     gameState.GameOver,
+		Victory:      gameState.Victory,
+		GameMode:     gameState.GameMode,
+		DisabledCell: gameState.DisabledCell,
+		Message:      statusMessage,
 	}
 
 	message := models.WebSocketMessage{
@@ -201,8 +253,14 @@ func (c *Client) handleGetLeaderboard(data interface{}) {
 		return
 	}
 
-	// Get leaderboard entries
-	entries, err := c.hub.db.GetLeaderboard(leaderboardRequest.Type, 100)
+	// Validate game mode
+	if leaderboardRequest.GameMode != models.GameModeClassic &&
+		leaderboardRequest.GameMode != models.GameModeChallenge {
+		leaderboardRequest.GameMode = models.GameModeClassic
+	}
+
+	// Get leaderboard entries for the specific game mode
+	entries, err := c.hub.db.GetLeaderboardByMode(leaderboardRequest.Type, leaderboardRequest.GameMode, 100)
 	if err != nil {
 		log.Printf("Failed to get leaderboard: %v", err)
 		c.sendError("Failed to get leaderboard")
diff --git a/backend/migrations/001_initial_schema.sql b/backend/migrations/001_initial_schema.sql
index da7e3b8..1680d42 100644
--- a/backend/migrations/001_initial_schema.sql
+++ b/backend/migrations/001_initial_schema.sql
@@ -24,6 +24,8 @@ CREATE TABLE IF NOT EXISTS games (
     score INTEGER NOT NULL DEFAULT 0,
     game_over BOOLEAN NOT NULL DEFAULT FALSE,
     victory BOOLEAN NOT NULL DEFAULT FALSE,
+    game_mode VARCHAR(20) NOT NULL DEFAULT 'classic',
+    disabled_cell JSONB,
     created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
     updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
 );
@@ -33,11 +35,12 @@ CREATE INDEX IF NOT EXISTS idx_games_user_id ON games(user_id);
 CREATE INDEX IF NOT EXISTS idx_games_score ON games(score DESC);
 CREATE INDEX IF NOT EXISTS idx_games_created_at ON games(created_at DESC);
 CREATE INDEX IF NOT EXISTS idx_games_active ON games(user_id, game_over, victory) WHERE game_over = FALSE AND victory = FALSE;
+CREATE INDEX IF NOT EXISTS idx_games_mode ON games(game_mode);
 
--- Create composite index for leaderboard queries
-CREATE INDEX IF NOT EXISTS idx_games_leaderboard_daily ON games(created_at, score DESC) WHERE (game_over = TRUE OR victory = TRUE);
-CREATE INDEX IF NOT EXISTS idx_games_leaderboard_weekly ON games(created_at, score DESC) WHERE (game_over = TRUE OR victory = TRUE);
-CREATE INDEX IF NOT EXISTS idx_games_leaderboard_all ON games(score DESC) WHERE (game_over = TRUE OR victory = TRUE);
+-- Create composite index for leaderboard queries (separated by game mode)
+CREATE INDEX IF NOT EXISTS idx_games_leaderboard_daily ON games(game_mode, created_at, score DESC) WHERE (game_over = TRUE OR victory = TRUE);
+CREATE INDEX IF NOT EXISTS idx_games_leaderboard_weekly ON games(game_mode, created_at, score DESC) WHERE (game_over = TRUE OR victory = TRUE);
+CREATE INDEX IF NOT EXISTS idx_games_leaderboard_all ON games(game_mode, score DESC) WHERE (game_over = TRUE OR victory = TRUE);
 
 -- Create leaderboard cache tables for better performance
 CREATE TABLE IF NOT EXISTS leaderboard_daily (
@@ -47,10 +50,11 @@ CREATE TABLE IF NOT EXISTS leaderboard_daily (
     score INTEGER NOT NULL,
     rank INTEGER NOT NULL,
     game_id UUID NOT NULL REFERENCES games(id) ON DELETE CASCADE,
+    game_mode VARCHAR(20) NOT NULL DEFAULT 'classic',
     date DATE NOT NULL DEFAULT CURRENT_DATE,
     created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    
-    PRIMARY KEY (date, user_id)
+
+    PRIMARY KEY (date, user_id, game_mode)
 );
 
 CREATE TABLE IF NOT EXISTS leaderboard_weekly (
@@ -60,10 +64,11 @@ CREATE TABLE IF NOT EXISTS leaderboard_weekly (
     score INTEGER NOT NULL,
     rank INTEGER NOT NULL,
     game_id UUID NOT NULL REFERENCES games(id) ON DELETE CASCADE,
+    game_mode VARCHAR(20) NOT NULL DEFAULT 'classic',
     week_start DATE NOT NULL,
     created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    
-    PRIMARY KEY (week_start, user_id)
+
+    PRIMARY KEY (week_start, user_id, game_mode)
 );
 
 CREATE TABLE IF NOT EXISTS leaderboard_monthly (
@@ -73,16 +78,17 @@ CREATE TABLE IF NOT EXISTS leaderboard_monthly (
     score INTEGER NOT NULL,
     rank INTEGER NOT NULL,
     game_id UUID NOT NULL REFERENCES games(id) ON DELETE CASCADE,
+    game_mode VARCHAR(20) NOT NULL DEFAULT 'classic',
     month_start DATE NOT NULL,
     created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    
-    PRIMARY KEY (month_start, user_id)
+
+    PRIMARY KEY (month_start, user_id, game_mode)
 );
 
 -- Create indexes for leaderboard cache tables
-CREATE INDEX IF NOT EXISTS idx_leaderboard_daily_score ON leaderboard_daily(date, score DESC);
-CREATE INDEX IF NOT EXISTS idx_leaderboard_weekly_score ON leaderboard_weekly(week_start, score DESC);
-CREATE INDEX IF NOT EXISTS idx_leaderboard_monthly_score ON leaderboard_monthly(month_start, score DESC);
+CREATE INDEX IF NOT EXISTS idx_leaderboard_daily_score ON leaderboard_daily(date, game_mode, score DESC);
+CREATE INDEX IF NOT EXISTS idx_leaderboard_weekly_score ON leaderboard_weekly(week_start, game_mode, score DESC);
+CREATE INDEX IF NOT EXISTS idx_leaderboard_monthly_score ON leaderboard_monthly(month_start, game_mode, score DESC);
 
 -- Create function to update updated_at timestamp
 CREATE OR REPLACE FUNCTION update_updated_at_column()
@@ -104,26 +110,28 @@ CREATE TRIGGER update_games_updated_at
     FOR EACH ROW 
     EXECUTE FUNCTION update_updated_at_column();
 
--- Create function to refresh leaderboard cache
-CREATE OR REPLACE FUNCTION refresh_daily_leaderboard()
+-- Create function to refresh leaderboard cache (updated for game modes)
+CREATE OR REPLACE FUNCTION refresh_daily_leaderboard(mode VARCHAR(20) DEFAULT 'classic')
 RETURNS VOID AS $$
 BEGIN
-    -- Clear today's leaderboard
-    DELETE FROM leaderboard_daily WHERE date = CURRENT_DATE;
-    
-    -- Insert today's top scores
-    INSERT INTO leaderboard_daily (user_id, user_name, user_avatar, score, rank, game_id, date)
-    SELECT 
+    -- Clear today's leaderboard for the specified mode
+    DELETE FROM leaderboard_daily WHERE date = CURRENT_DATE AND game_mode = mode;
+
+    -- Insert today's top scores for the specified mode
+    INSERT INTO leaderboard_daily (user_id, user_name, user_avatar, score, rank, game_id, game_mode, date)
+    SELECT
         g.user_id,
         u.name,
         u.avatar,
         g.score,
         ROW_NUMBER() OVER (ORDER BY g.score DESC),
         g.id,
+        g.game_mode,
         CURRENT_DATE
     FROM games g
     JOIN users u ON g.user_id = u.id
     WHERE (g.game_over = TRUE OR g.victory = TRUE)
+        AND g.game_mode = mode
         AND g.created_at >= CURRENT_DATE
         AND g.created_at < CURRENT_DATE + INTERVAL '1 day'
     ORDER BY g.score DESC
@@ -131,28 +139,30 @@ BEGIN
 END;
 $$ LANGUAGE plpgsql;
 
--- Create function to refresh weekly leaderboard
-CREATE OR REPLACE FUNCTION refresh_weekly_leaderboard()
+-- Create function to refresh weekly leaderboard (updated for game modes)
+CREATE OR REPLACE FUNCTION refresh_weekly_leaderboard(mode VARCHAR(20) DEFAULT 'classic')
 RETURNS VOID AS $$
 DECLARE
     week_start DATE := DATE_TRUNC('week', CURRENT_DATE)::DATE;
 BEGIN
-    -- Clear this week's leaderboard
-    DELETE FROM leaderboard_weekly WHERE week_start = week_start;
-    
-    -- Insert this week's top scores
-    INSERT INTO leaderboard_weekly (user_id, user_name, user_avatar, score, rank, game_id, week_start)
-    SELECT 
+    -- Clear this week's leaderboard for the specified mode
+    DELETE FROM leaderboard_weekly WHERE week_start = week_start AND game_mode = mode;
+
+    -- Insert this week's top scores for the specified mode
+    INSERT INTO leaderboard_weekly (user_id, user_name, user_avatar, score, rank, game_id, game_mode, week_start)
+    SELECT
         g.user_id,
         u.name,
         u.avatar,
         g.score,
         ROW_NUMBER() OVER (ORDER BY g.score DESC),
         g.id,
+        g.game_mode,
         week_start
     FROM games g
     JOIN users u ON g.user_id = u.id
     WHERE (g.game_over = TRUE OR g.victory = TRUE)
+        AND g.game_mode = mode
         AND g.created_at >= week_start
         AND g.created_at < week_start + INTERVAL '1 week'
     ORDER BY g.score DESC
@@ -160,28 +170,30 @@ BEGIN
 END;
 $$ LANGUAGE plpgsql;
 
--- Create function to refresh monthly leaderboard
-CREATE OR REPLACE FUNCTION refresh_monthly_leaderboard()
+-- Create function to refresh monthly leaderboard (updated for game modes)
+CREATE OR REPLACE FUNCTION refresh_monthly_leaderboard(mode VARCHAR(20) DEFAULT 'classic')
 RETURNS VOID AS $$
 DECLARE
     month_start DATE := DATE_TRUNC('month', CURRENT_DATE)::DATE;
 BEGIN
-    -- Clear this month's leaderboard
-    DELETE FROM leaderboard_monthly WHERE month_start = month_start;
-    
-    -- Insert this month's top scores
-    INSERT INTO leaderboard_monthly (user_id, user_name, user_avatar, score, rank, game_id, month_start)
-    SELECT 
+    -- Clear this month's leaderboard for the specified mode
+    DELETE FROM leaderboard_monthly WHERE month_start = month_start AND game_mode = mode;
+
+    -- Insert this month's top scores for the specified mode
+    INSERT INTO leaderboard_monthly (user_id, user_name, user_avatar, score, rank, game_id, game_mode, month_start)
+    SELECT
         g.user_id,
         u.name,
         u.avatar,
         g.score,
         ROW_NUMBER() OVER (ORDER BY g.score DESC),
         g.id,
+        g.game_mode,
         month_start
     FROM games g
     JOIN users u ON g.user_id = u.id
     WHERE (g.game_over = TRUE OR g.victory = TRUE)
+        AND g.game_mode = mode
         AND g.created_at >= month_start
         AND g.created_at < month_start + INTERVAL '1 month'
     ORDER BY g.score DESC
diff --git a/backend/pkg/models/game.go b/backend/pkg/models/game.go
index 727633c..591289b 100644
--- a/backend/pkg/models/game.go
+++ b/backend/pkg/models/game.go
@@ -16,16 +16,32 @@ const (
 	DirectionRight Direction = "right"
 )
 
+// GameMode represents different game modes
+type GameMode string
+
+const (
+	GameModeClassic   GameMode = "classic"
+	GameModeChallenge GameMode = "challenge"
+)
+
+// DisabledCell represents a disabled cell position
+type DisabledCell struct {
+	Row int `json:"row"`
+	Col int `json:"col"`
+}
+
 // GameState represents the current state of a 2048 game
 type GameState struct {
-	ID        uuid.UUID `json:"id" db:"id"`
-	UserID    string    `json:"user_id" db:"user_id"`
-	Board     Board     `json:"board" db:"board"`
-	Score     int       `json:"score" db:"score"`
-	GameOver  bool      `json:"game_over" db:"game_over"`
-	Victory   bool      `json:"victory" db:"victory"`
-	CreatedAt time.Time `json:"created_at" db:"created_at"`
-	UpdatedAt time.Time `json:"updated_at" db:"updated_at"`
+	ID           uuid.UUID     `json:"id" db:"id"`
+	UserID       string        `json:"user_id" db:"user_id"`
+	Board        Board         `json:"board" db:"board"`
+	Score        int           `json:"score" db:"score"`
+	GameOver     bool          `json:"game_over" db:"game_over"`
+	Victory      bool          `json:"victory" db:"victory"`
+	GameMode     GameMode      `json:"game_mode" db:"game_mode"`
+	DisabledCell *DisabledCell `json:"disabled_cell,omitempty" db:"disabled_cell"`
+	CreatedAt    time.Time     `json:"created_at" db:"created_at"`
+	UpdatedAt    time.Time     `json:"updated_at" db:"updated_at"`
 }
 
 // Board represents a 4x4 game board
@@ -51,6 +67,7 @@ type LeaderboardEntry struct {
 	Score      int       `json:"score" db:"score"`
 	Rank       int       `json:"rank" db:"rank"`
 	GameID     uuid.UUID `json:"game_id" db:"game_id"`
+	GameMode   GameMode  `json:"game_mode" db:"game_mode"`
 	CreatedAt  time.Time `json:"created_at" db:"created_at"`
 }
 
@@ -64,6 +81,18 @@ const (
 	LeaderboardAll     LeaderboardType = "all"
 )
 
+// Combined leaderboard types for different game modes
+const (
+	LeaderboardClassicDaily     LeaderboardType = "classic_daily"
+	LeaderboardClassicWeekly    LeaderboardType = "classic_weekly"
+	LeaderboardClassicMonthly   LeaderboardType = "classic_monthly"
+	LeaderboardClassicAll       LeaderboardType = "classic_all"
+	LeaderboardChallengeDaily   LeaderboardType = "challenge_daily"
+	LeaderboardChallengeWeekly  LeaderboardType = "challenge_weekly"
+	LeaderboardChallengeMonthly LeaderboardType = "challenge_monthly"
+	LeaderboardChallengeAll     LeaderboardType = "challenge_all"
+)
+
 // WebSocketMessage represents a message sent over WebSocket
 type WebSocketMessage struct {
 	Type string      `json:"type"`
@@ -75,23 +104,26 @@ type MoveRequest struct {
 	Direction Direction `json:"direction"`
 }
 
-// NewGameRequest represents a new game request
+// NewGameRequest represents a new game request from client
 type NewGameRequest struct {
-	// Empty for now, can be extended with game options
+	GameMode GameMode `json:"game_mode"`
 }
 
 // LeaderboardRequest represents a leaderboard request
 type LeaderboardRequest struct {
-	Type LeaderboardType `json:"type"`
+	Type     LeaderboardType `json:"type"`
+	GameMode GameMode        `json:"game_mode"`
 }
 
 // GameResponse represents the response sent to client after a move
 type GameResponse struct {
-	Board    Board  `json:"board"`
-	Score    int    `json:"score"`
-	GameOver bool   `json:"game_over"`
-	Victory  bool   `json:"victory"`
-	Message  string `json:"message,omitempty"`
+	Board        Board         `json:"board"`
+	Score        int           `json:"score"`
+	GameOver     bool          `json:"game_over"`
+	Victory      bool          `json:"victory"`
+	GameMode     GameMode      `json:"game_mode"`
+	DisabledCell *DisabledCell `json:"disabled_cell,omitempty"`
+	Message      string        `json:"message,omitempty"`
 }
 
 // LeaderboardResponse represents the leaderboard response
@@ -136,6 +168,31 @@ func (b *Board) GetEmptyCells() [][2]int {
 	return empty
 }
 
+// GetEmptyCellsExcluding returns all empty cell positions excluding disabled cells
+func (b *Board) GetEmptyCellsExcluding(disabledCell *DisabledCell) [][2]int {
+	var empty [][2]int
+	for i := 0; i < BoardSize; i++ {
+		for j := 0; j < BoardSize; j++ {
+			if b.IsEmpty(i, j) {
+				// Skip disabled cell
+				if disabledCell != nil && disabledCell.Row == i && disabledCell.Col == j {
+					continue
+				}
+				empty = append(empty, [2]int{i, j})
+			}
+		}
+	}
+	return empty
+}
+
+// IsDisabledCell checks if a cell is disabled
+func (b *Board) IsDisabledCell(row, col int, disabledCell *DisabledCell) bool {
+	if disabledCell == nil {
+		return false
+	}
+	return disabledCell.Row == row && disabledCell.Col == col
+}
+
 // SetCell sets a value at the given position
 func (b *Board) SetCell(row, col, value int) {
 	if row >= 0 && row < BoardSize && col >= 0 && col < BoardSize {
diff --git a/backend/pkg/models/gorm_models.go b/backend/pkg/models/gorm_models.go
index a8e0bda..541bb5b 100644
--- a/backend/pkg/models/gorm_models.go
+++ b/backend/pkg/models/gorm_models.go
@@ -57,14 +57,16 @@ func (gu *GormUser) FromUser(u *User) {
 
 // GormGame represents a game session using GORM
 type GormGame struct {
-	ID        uuid.UUID `gorm:"type:uuid;primaryKey;default:gen_random_uuid()" json:"id"`
-	UserID    string    `gorm:"type:varchar(255);not null;index" json:"user_id"`
-	Board     BoardJSON `gorm:"type:jsonb;not null" json:"board"`
-	Score     int       `gorm:"not null;default:0;index:idx_games_score" json:"score"`
-	GameOver  bool      `gorm:"not null;default:false" json:"game_over"`
-	Victory   bool      `gorm:"not null;default:false" json:"victory"`
-	CreatedAt time.Time `gorm:"autoCreateTime;index:idx_games_created_at" json:"created_at"`
-	UpdatedAt time.Time `gorm:"autoUpdateTime" json:"updated_at"`
+	ID           uuid.UUID         `gorm:"type:uuid;primaryKey;default:gen_random_uuid()" json:"id"`
+	UserID       string            `gorm:"type:varchar(255);not null;index" json:"user_id"`
+	Board        BoardJSON         `gorm:"type:jsonb;not null" json:"board"`
+	Score        int               `gorm:"not null;default:0;index:idx_games_score" json:"score"`
+	GameOver     bool              `gorm:"not null;default:false" json:"game_over"`
+	Victory      bool              `gorm:"not null;default:false" json:"victory"`
+	GameMode     string            `gorm:"type:varchar(20);not null;default:'classic';index:idx_games_mode" json:"game_mode"`
+	DisabledCell *DisabledCellJSON `gorm:"type:jsonb" json:"disabled_cell"`
+	CreatedAt    time.Time         `gorm:"autoCreateTime;index:idx_games_created_at" json:"created_at"`
+	UpdatedAt    time.Time         `gorm:"autoUpdateTime" json:"updated_at"`
 
 	// Relationships
 	User GormUser `gorm:"foreignKey:UserID;references:ID" json:"user,omitempty"`
@@ -104,17 +106,54 @@ func (b BoardJSON) Value() (driver.Value, error) {
 	return json.Marshal(Board(b))
 }
 
+// DisabledCellJSON is a custom type for handling JSON serialization of disabled cells
+type DisabledCellJSON DisabledCell
+
+// Scan implements the sql.Scanner interface for reading from database
+func (dc *DisabledCellJSON) Scan(value interface{}) error {
+	if value == nil {
+		*dc = DisabledCellJSON{}
+		return nil
+	}
+
+	bytes, ok := value.([]byte)
+	if !ok {
+		return fmt.Errorf("cannot scan %T into DisabledCellJSON", value)
+	}
+
+	var disabledCell DisabledCell
+	if err := json.Unmarshal(bytes, &disabledCell); err != nil {
+		return err
+	}
+
+	*dc = DisabledCellJSON(disabledCell)
+	return nil
+}
+
+// Value implements the driver.Valuer interface for writing to database
+func (dc DisabledCellJSON) Value() (driver.Value, error) {
+	return json.Marshal(DisabledCell(dc))
+}
+
 // ToGameState converts GormGame to GameState
 func (gg *GormGame) ToGameState() *GameState {
+	var disabledCell *DisabledCell
+	if gg.DisabledCell != nil {
+		dc := DisabledCell(*gg.DisabledCell)
+		disabledCell = &dc
+	}
+
 	return &GameState{
-		ID:        gg.ID,
-		UserID:    gg.UserID,
-		Board:     Board(gg.Board),
-		Score:     gg.Score,
-		GameOver:  gg.GameOver,
-		Victory:   gg.Victory,
-		CreatedAt: gg.CreatedAt,
-		UpdatedAt: gg.UpdatedAt,
+		ID:           gg.ID,
+		UserID:       gg.UserID,
+		Board:        Board(gg.Board),
+		Score:        gg.Score,
+		GameOver:     gg.GameOver,
+		Victory:      gg.Victory,
+		GameMode:     GameMode(gg.GameMode),
+		DisabledCell: disabledCell,
+		CreatedAt:    gg.CreatedAt,
+		UpdatedAt:    gg.UpdatedAt,
 	}
 }
 
@@ -126,6 +165,15 @@ func (gg *GormGame) FromGameState(gs *GameState) {
 	gg.Score = gs.Score
 	gg.GameOver = gs.GameOver
 	gg.Victory = gs.Victory
+	gg.GameMode = string(gs.GameMode)
+
+	if gs.DisabledCell != nil {
+		dc := DisabledCellJSON(*gs.DisabledCell)
+		gg.DisabledCell = &dc
+	} else {
+		gg.DisabledCell = nil
+	}
+
 	gg.CreatedAt = gs.CreatedAt
 	gg.UpdatedAt = gs.UpdatedAt
 }
@@ -162,6 +210,7 @@ type GormDailyLeaderboard struct {
 	Score      int       `gorm:"not null;index:idx_daily_score" json:"score"`
 	Rank       int       `gorm:"not null" json:"rank"`
 	GameID     uuid.UUID `gorm:"type:uuid;not null" json:"game_id"`
+	GameMode   string    `gorm:"type:varchar(20);not null;default:'classic';primaryKey" json:"game_mode"`
 	Date       time.Time `gorm:"type:date;not null;primaryKey;default:CURRENT_DATE" json:"date"`
 	CreatedAt  time.Time `gorm:"autoCreateTime" json:"created_at"`
 }
@@ -178,6 +227,7 @@ type GormWeeklyLeaderboard struct {
 	Score      int       `gorm:"not null;index:idx_weekly_score" json:"score"`
 	Rank       int       `gorm:"not null" json:"rank"`
 	GameID     uuid.UUID `gorm:"type:uuid;not null" json:"game_id"`
+	GameMode   string    `gorm:"type:varchar(20);not null;default:'classic';primaryKey" json:"game_mode"`
 	WeekStart  time.Time `gorm:"type:date;not null;primaryKey" json:"week_start"`
 	CreatedAt  time.Time `gorm:"autoCreateTime" json:"created_at"`
 }
@@ -194,6 +244,7 @@ type GormMonthlyLeaderboard struct {
 	Score      int       `gorm:"not null;index:idx_monthly_score" json:"score"`
 	Rank       int       `gorm:"not null" json:"rank"`
 	GameID     uuid.UUID `gorm:"type:uuid;not null" json:"game_id"`
+	GameMode   string    `gorm:"type:varchar(20);not null;default:'classic';primaryKey" json:"game_mode"`
 	MonthStart time.Time `gorm:"type:date;not null;primaryKey" json:"month_start"`
 	CreatedAt  time.Time `gorm:"autoCreateTime" json:"created_at"`
 }