| const express = require('express'); |
| const http = require('http'); |
| const socketIo = require('socket.io'); |
| const path = require('path'); |
|
|
| const app = express(); |
| const server = http.createServer(app); |
|
|
| const io = socketIo(server, { |
| cors: { |
| origin: "*", |
| methods: ["GET", "POST"], |
| credentials: true |
| }, |
| transports: ['websocket', 'polling'], |
| allowEIO3: true, |
| pingTimeout: 60000, |
| pingInterval: 25000 |
| }); |
|
|
| app.get('/health', (req, res) => { |
| res.status(200).json({ status: 'healthy', timestamp: new Date().toISOString() }); |
| }); |
|
|
| app.use(express.static(path.join(__dirname, 'public'))); |
|
|
| const rooms = new Map(); |
|
|
| const COIN_RADIUS = 12; |
| const STRIKER_RADIUS = 18; |
| const BOARD_WIDTH = 520; |
| const BOARD_HEIGHT = 520; |
| const FRICTION = 0.985; |
| const WALL_BOUNCE = 0.85; |
| const STRIKER_LINE_Y1 = BOARD_HEIGHT - 50; |
| const STRIKER_LINE_Y2 = 50; |
| const STRIKER_MIN_X = 60; |
| const STRIKER_MAX_X = BOARD_WIDTH - 60; |
| const POCKET_RADIUS = 25; |
|
|
| const POCKETS = [ |
| { x: 0, y: 0 }, |
| { x: BOARD_WIDTH, y: 0 }, |
| { x: 0, y: BOARD_HEIGHT }, |
| { x: BOARD_WIDTH, y: BOARD_HEIGHT } |
| ]; |
|
|
| function createInitialState() { |
| const coins = []; |
| |
| coins.push({ |
| id: 'striker', |
| type: 'striker', |
| x: BOARD_WIDTH / 2, |
| y: STRIKER_LINE_Y1, |
| vx: 0, |
| vy: 0, |
| radius: STRIKER_RADIUS, |
| pocketed: false |
| }); |
| |
| coins.push({ |
| id: 'queen', |
| type: 'queen', |
| x: BOARD_WIDTH / 2, |
| y: BOARD_HEIGHT / 2, |
| vx: 0, |
| vy: 0, |
| radius: COIN_RADIUS, |
| pocketed: false |
| }); |
| |
| const whitePositions = [ |
| { x: 0, y: -35 }, { x: 30, y: -17 }, { x: 30, y: 17 }, |
| { x: 0, y: 35 }, { x: -30, y: 17 }, { x: -30, y: -17 }, |
| { x: 0, y: -70 }, { x: 60, y: -35 }, { x: 60, y: 35 } |
| ]; |
| |
| whitePositions.forEach((pos, i) => { |
| coins.push({ |
| id: `white${i}`, |
| type: 'white', |
| x: BOARD_WIDTH / 2 + pos.x, |
| y: BOARD_HEIGHT / 2 + pos.y, |
| vx: 0, |
| vy: 0, |
| radius: COIN_RADIUS, |
| pocketed: false |
| }); |
| }); |
| |
| const blackPositions = [ |
| { x: 0, y: -52 }, { x: 45, y: -26 }, { x: 45, y: 26 }, |
| { x: 0, y: 52 }, { x: -45, y: 26 }, { x: -45, y: -26 }, |
| { x: 52, y: 0 }, { x: -52, y: 0 }, { x: 26, y: -45 } |
| ]; |
| |
| blackPositions.forEach((pos, i) => { |
| coins.push({ |
| id: `black${i}`, |
| type: 'black', |
| x: BOARD_WIDTH / 2 + pos.x, |
| y: BOARD_HEIGHT / 2 + pos.y, |
| vx: 0, |
| vy: 0, |
| radius: COIN_RADIUS, |
| pocketed: false |
| }); |
| }); |
| |
| return { |
| coins, |
| currentPlayer: 1, |
| scores: [0, 0], |
| queenOwner: null, |
| queenNeedsCover: false, |
| gameOver: false, |
| winner: null, |
| isMoving: false, |
| turnAgain: false, |
| foulCommitted: false, |
| lastPocketed: [] |
| }; |
| } |
|
|
| function updatePhysics(state) { |
| let moving = false; |
| state.lastPocketed = []; |
| |
| state.coins.forEach(coin => { |
| if (coin.pocketed) return; |
| |
| coin.x += coin.vx; |
| coin.y += coin.vy; |
| |
| coin.vx *= FRICTION; |
| coin.vy *= FRICTION; |
| |
| if (Math.abs(coin.vx) < 0.05) coin.vx = 0; |
| if (Math.abs(coin.vy) < 0.05) coin.vy = 0; |
| |
| if (coin.vx !== 0 || coin.vy !== 0) moving = true; |
| |
| if (coin.x - coin.radius < 0) { |
| coin.x = coin.radius; |
| coin.vx = -coin.vx * WALL_BOUNCE; |
| } |
| if (coin.x + coin.radius > BOARD_WIDTH) { |
| coin.x = BOARD_WIDTH - coin.radius; |
| coin.vx = -coin.vx * WALL_BOUNCE; |
| } |
| if (coin.y - coin.radius < 0) { |
| coin.y = coin.radius; |
| coin.vy = -coin.vy * WALL_BOUNCE; |
| } |
| if (coin.y + coin.radius > BOARD_HEIGHT) { |
| coin.y = BOARD_HEIGHT - coin.radius; |
| coin.vy = -coin.vy * WALL_BOUNCE; |
| } |
| |
| POCKETS.forEach(pocket => { |
| const dist = Math.hypot(coin.x - pocket.x, coin.y - pocket.y); |
| if (dist < POCKET_RADIUS && coin.type !== 'striker') { |
| coin.pocketed = true; |
| coin.vx = 0; |
| coin.vy = 0; |
| state.lastPocketed.push(coin); |
| } |
| }); |
| }); |
| |
| for (let i = 0; i < state.coins.length; i++) { |
| for (let j = i + 1; j < state.coins.length; j++) { |
| const c1 = state.coins[i]; |
| const c2 = state.coins[j]; |
| |
| if (c1.pocketed || c2.pocketed) continue; |
| |
| const dx = c2.x - c1.x; |
| const dy = c2.y - c1.y; |
| const dist = Math.hypot(dx, dy); |
| const minDist = c1.radius + c2.radius; |
| |
| if (dist < minDist && dist > 0) { |
| const overlap = minDist - dist; |
| const nx = dx / dist; |
| const ny = dy / dist; |
| |
| c1.x -= nx * overlap * 0.5; |
| c1.y -= ny * overlap * 0.5; |
| c2.x += nx * overlap * 0.5; |
| c2.y += ny * overlap * 0.5; |
| |
| const dvx = c2.vx - c1.vx; |
| const dvy = c2.vy - c1.vy; |
| const dv = dvx * nx + dvy * ny; |
| |
| if (dv > 0) continue; |
| |
| const impulse = dv; |
| c1.vx += impulse * nx; |
| c1.vy += impulse * ny; |
| c2.vx -= impulse * nx; |
| c2.vy -= impulse * ny; |
| |
| c1.vx *= 0.98; |
| c1.vy *= 0.98; |
| c2.vx *= 0.98; |
| c2.vy *= 0.98; |
| } |
| } |
| } |
| |
| return moving; |
| } |
|
|
| function handlePocketedCoins(state) { |
| const playerIndex = state.currentPlayer - 1; |
| const opponentIndex = playerIndex === 0 ? 1 : 0; |
| let validPocket = false; |
| let queenPocketed = false; |
| |
| const striker = state.coins.find(c => c.type === 'striker'); |
| if (striker && striker.pocketed) { |
| striker.pocketed = false; |
| striker.vx = 0; |
| striker.vy = 0; |
| state.foulCommitted = true; |
| } |
| |
| state.lastPocketed.forEach(coin => { |
| if (coin.type === 'queen') { |
| queenPocketed = true; |
| state.queenNeedsCover = true; |
| } else if (coin.type === 'white') { |
| if (state.currentPlayer === 1) { |
| state.scores[0]++; |
| validPocket = true; |
| } else { |
| state.foulCommitted = true; |
| } |
| } else if (coin.type === 'black') { |
| if (state.currentPlayer === 2) { |
| state.scores[1]++; |
| validPocket = true; |
| } else { |
| state.foulCommitted = true; |
| } |
| } |
| }); |
| |
| if (state.queenNeedsCover && validPocket) { |
| state.queenOwner = state.currentPlayer; |
| state.queenNeedsCover = false; |
| state.scores[playerIndex] += 3; |
| } |
| |
| if (state.foulCommitted) { |
| const opponentColor = state.currentPlayer === 1 ? 'black' : 'white'; |
| const returnedCoin = state.coins.find(c => c.type === opponentColor && c.pocketed); |
| if (returnedCoin) { |
| returnedCoin.pocketed = false; |
| returnedCoin.x = BOARD_WIDTH / 2 + (Math.random() - 0.5) * 100; |
| returnedCoin.y = BOARD_HEIGHT / 2 + (Math.random() - 0.5) * 100; |
| state.scores[opponentIndex] = Math.max(0, state.scores[opponentIndex] - 1); |
| } |
| } |
| |
| if (validPocket && !state.foulCommitted) { |
| state.turnAgain = true; |
| } else if (queenPocketed && !validPocket && !state.foulCommitted) { |
| state.turnAgain = true; |
| } else { |
| state.turnAgain = false; |
| } |
| |
| if (state.scores[0] >= 8) { |
| state.gameOver = true; |
| state.winner = 1; |
| } else if (state.scores[1] >= 8) { |
| state.gameOver = true; |
| state.winner = 2; |
| } |
| } |
|
|
| function resetStriker(state, playerNum) { |
| const striker = state.coins.find(c => c.type === 'striker'); |
| if (striker) { |
| striker.x = BOARD_WIDTH / 2; |
| striker.y = playerNum === 1 ? STRIKER_LINE_Y1 : STRIKER_LINE_Y2; |
| striker.vx = 0; |
| striker.vy = 0; |
| striker.pocketed = false; |
| } |
| } |
|
|
| function startPhysicsLoop(room) { |
| if (room.physicsInterval) { |
| clearInterval(room.physicsInterval); |
| } |
| |
| room.physicsInterval = setInterval(() => { |
| if (!room || !room.state) return; |
| |
| const moving = updatePhysics(room.state); |
| |
| if (room.state.isMoving && !moving) { |
| room.state.isMoving = false; |
| handlePocketedCoins(room.state); |
| |
| if (!room.state.turnAgain && !room.state.gameOver) { |
| room.state.currentPlayer = room.state.currentPlayer === 1 ? 2 : 1; |
| room.state.foulCommitted = false; |
| resetStriker(room.state, room.state.currentPlayer); |
| } else if (room.state.turnAgain) { |
| room.state.turnAgain = false; |
| room.state.foulCommitted = false; |
| resetStriker(room.state, room.state.currentPlayer); |
| } |
| |
| const currentPlayer = room.players.find(p => p.number === room.state.currentPlayer); |
| io.to(room.id).emit('turnChange', { |
| currentPlayer: room.state.currentPlayer, |
| playerName: currentPlayer ? currentPlayer.name : 'Unknown' |
| }); |
| |
| if (room.state.gameOver) { |
| clearInterval(room.physicsInterval); |
| room.physicsInterval = null; |
| const winner = room.players.find(p => p.number === room.state.winner); |
| io.to(room.id).emit('gameOver', { |
| winner: room.state.winner, |
| winnerName: winner ? winner.name : 'Unknown' |
| }); |
| } |
| } else if (moving) { |
| room.state.isMoving = true; |
| } |
| |
| io.to(room.id).emit('gameState', room.state); |
| }, 1000 / 60); |
| } |
|
|
| io.on('connection', (socket) => { |
| console.log('Client connected:', socket.id); |
| |
| socket.on('joinRoom', ({ name, roomId: requestedRoom }) => { |
| let roomId = requestedRoom || generateRoomId(); |
| |
| if (!rooms.has(roomId)) { |
| rooms.set(roomId, { |
| id: roomId, |
| players: [], |
| state: createInitialState(), |
| physicsInterval: null, |
| gameStarted: false |
| }); |
| } |
| |
| const room = rooms.get(roomId); |
| |
| if (room.players.length >= 2) { |
| socket.emit('error', 'Room is full'); |
| return; |
| } |
| |
| const playerNumber = room.players.length + 1; |
| room.players.push({ |
| id: socket.id, |
| name: name || `Player ${playerNumber}`, |
| number: playerNumber |
| }); |
| |
| socket.join(roomId); |
| socket.roomId = roomId; |
| socket.playerNumber = playerNumber; |
| |
| socket.emit('roomJoined', { |
| roomId, |
| playerNumber, |
| players: room.players.map(p => ({ name: p.name, number: p.number })) |
| }); |
| |
| socket.to(roomId).emit('playerJoined', { |
| name: name || `Player ${playerNumber}`, |
| playerNumber, |
| players: room.players.map(p => ({ name: p.name, number: p.number })) |
| }); |
| |
| if (room.players.length === 2 && !room.gameStarted) { |
| room.gameStarted = true; |
| io.to(roomId).emit('gameState', room.state); |
| io.to(roomId).emit('turnChange', { |
| currentPlayer: 1, |
| playerName: room.players[0].name |
| }); |
| |
| startPhysicsLoop(room); |
| } |
| }); |
| |
| socket.on('moveStriker', ({ roomId, x }) => { |
| const room = rooms.get(roomId); |
| if (!room || !room.state) return; |
| if (room.state.isMoving) return; |
| |
| const striker = room.state.coins.find(c => c.type === 'striker'); |
| if (striker) { |
| striker.x = Math.max(STRIKER_MIN_X, Math.min(STRIKER_MAX_X, x)); |
| } |
| |
| io.to(roomId).emit('gameState', room.state); |
| }); |
| |
| socket.on('strike', ({ roomId, force, angle }) => { |
| const room = rooms.get(roomId); |
| if (!room || !room.state) return; |
| |
| const player = room.players.find(p => p.id === socket.id); |
| if (!player || player.number !== room.state.currentPlayer) return; |
| if (room.state.isMoving) return; |
| |
| const striker = room.state.coins.find(c => c.type === 'striker'); |
| if (striker) { |
| striker.vx = Math.cos(angle) * force; |
| striker.vy = Math.sin(angle) * force; |
| room.state.isMoving = true; |
| } |
| }); |
| |
| socket.on('resetGame', (roomId) => { |
| const room = rooms.get(roomId); |
| if (!room) return; |
| |
| if (room.physicsInterval) { |
| clearInterval(room.physicsInterval); |
| } |
| |
| room.state = createInitialState(); |
| room.gameStarted = true; |
| |
| startPhysicsLoop(room); |
| |
| io.to(roomId).emit('gameState', room.state); |
| io.to(roomId).emit('gameReset'); |
| io.to(roomId).emit('turnChange', { |
| currentPlayer: 1, |
| playerName: room.players[0] ? room.players[0].name : 'Player 1' |
| }); |
| }); |
| |
| socket.on('disconnect', () => { |
| console.log('Client disconnected:', socket.id); |
| |
| if (socket.roomId) { |
| const room = rooms.get(socket.roomId); |
| if (room) { |
| room.players = room.players.filter(p => p.id !== socket.id); |
| |
| if (room.players.length === 0) { |
| if (room.physicsInterval) { |
| clearInterval(room.physicsInterval); |
| } |
| rooms.delete(socket.roomId); |
| } else { |
| io.to(socket.roomId).emit('playerLeft', { |
| message: 'Opponent left the game' |
| }); |
| if (room.physicsInterval) { |
| clearInterval(room.physicsInterval); |
| room.physicsInterval = null; |
| } |
| room.gameStarted = false; |
| } |
| } |
| } |
| }); |
| }); |
|
|
| function generateRoomId() { |
| return Math.random().toString(36).substring(2, 8).toUpperCase(); |
| } |
|
|
| const PORT = process.env.PORT || 7860; |
| server.listen(PORT, '0.0.0.0', () => { |
| console.log(`Server running on port ${PORT}`); |
| }); |
|
|
