B.M.C Ultimate – Jeu de cartes multijoueur en temps réel
Contexte du projet
B.M.C Ultimate est un jeu de cartes multijoueur inspiré des jeux de type Cards Against Humanity, jouable en temps réel dans le navigateur grâce à Socket.io. Le serveur Node.js gère les salles, les rôles (Juge / Joueur), les points, le timer et la révélation progressive des cartes, tandis que le client HTML/CSS/JS propose une interface mobile-first fluide et optimisée pour les parties entre amis.
Toutes les cartes (questions, réponses texte et images) sont stockées dans une base PostgreSQL et peuvent être créées directement via une modale dans le front. Le système de deck permet de combiner plusieurs thèmes, et la logique de jeu est encapsulée dans un namespace Socket.io dédié /bmc pour isoler le jeu du reste du site.
Fonctionnalités principales
- Système de salles BMC avec rôle d'hôte, sélection de decks et gestion de la vie du jeu côté serveur.
- Gestion en temps réel des états de partie (LOBBY, PLAYING, REVEALING, JUDGING, WINNER_REVEAL) synchronisés à tous les clients.
- Interface mobile optimisée : main fixée en bas de l’écran, scroll interne contrôlé, animations de flip des cartes et indicateur de sélection.
- Ajout de cartes texte ou photo via une modale, upload avec Multer, stockage en base et affichage automatique côté client.
- Gestion avancée de la logique de tour : rotation du Juge, timer serveur, annulation de coup, révélation séquentielle des cartes.
Serveur Node.js / Socket.io
Le serveur Express expose une API REST pour gérer les decks et l’ajout de cartes, et utilise un namespace Socket.io /bmc pour gérer l’état des parties et la communication temps réel avec les joueurs.
Afficher / masquer le code
// serveur-bmc.js (extrait)
const express = require('express');
const http = require('http');
const { Server } = require('socket.io');
const { Pool } = require('pg');
const multer = require('multer');
const fs = require('fs');
require('dotenv').config();
const app = express();
const server = http.createServer(app);
const io = new Server(server);
const PORT = process.env.PORT || 3000;
// Connexion PostgreSQL
const pool = new Pool({
connectionString: process.env.DATABASE_URL,
ssl: { rejectUnauthorized: false }
});
// Statique + JSON
app.use(express.static(__dirname));
app.use(express.json());
// Dossier uploads pour les images
if (!fs.existsSync('uploads')) fs.mkdirSync('uploads');
app.use('/uploads', express.static(__dirname + '/uploads'));
// Multer en mémoire pour convertir les images en base64
const storage = multer.memoryStorage();
const upload = multer({ storage });
// --- API BMC ---
app.get('/bmc/api/decks', async (req, res) => {
try {
const result = await pool.query(`
SELECT deck, type, COUNT(*) AS count
FROM cards
GROUP BY deck, type
`);
const decks = {};
result.rows.forEach(r => {
if (!decks[r.deck]) decks[r.deck] = { name: r.deck, qCount: 0, aCount: 0 };
if (r.type === 'question') decks[r.deck].qCount = Number(r.count);
else decks[r.deck].aCount = Number(r.count);
});
res.json(Object.values(decks));
} catch (e) {
console.error(e);
res.status(500).send('Erreur BDD');
}
});
// Ajout de carte texte
app.post('/bmc/api/add-card', async (req, res) => {
const { content, type, deck, pick } = req.body;
const nb = Number(pick) || 1;
try {
await pool.query(
'INSERT INTO cards (content, type, deck, pick) VALUES ($1,$2,$3,$4)',
[content, type, deck, nb]
);
res.json({ success: true });
} catch (e) {
console.error(e);
res.sendStatus(500);
}
});
// Ajout de carte image (base64)
app.post('/bmc/api/add-card-image', upload.single('photo'), async (req, res) => {
const { type, deck, pick } = req.body;
const nb = Number(pick) || 1;
if (!req.file) return res.status(400).send('Aucune image');
const base64Image = req.file.buffer.toString('base64');
const content = `data:${req.file.mimetype};base64,${base64Image}`;
try {
await pool.query(
'INSERT INTO cards (content, type, deck, pick) VALUES ($1,$2,$3,$4)',
[content, type, deck, nb]
);
res.json({ success: true });
} catch (e) {
console.error(e);
res.sendStatus(500);
}
});
// Namespace Socket.io dédié au jeu
const bmc = io.of('/bmc');
const games = {}; // état en mémoire par salle
bmc.on('connection', (socket) => {
socket.on('join_game', ({ username, room }) => {
socket.join(room);
// Initialisation de la salle et ajout du joueur...
});
socket.on('start_game', async ({ room, selectedDecks }) => {
// Chargement des cartes depuis PostgreSQL et lancement d'un nouveau round...
});
socket.on('play_cards', ({ room, cards }) => {
// Enregistrement des cartes jouées et passage éventuel en phase de révélation...
});
socket.on('pick_winner', ({ room, cardId }) => {
// Attribution du point au gagnant et rotation du Juge pour le round suivant...
});
socket.on('disconnect', () => {
// Nettoyage de la salle, réattribution de l'hôte / du Juge si besoin...
});
});
server.listen(PORT, () => {
console.log(`🚀 Serveur BMC lancé sur le port ${PORT}`);
});
Client HTML / Socket.io
Le client se connecte au namespace /bmc, gère les écrans (login, lobby, jeu), rend la main du joueur, la table de cartes et les animations de révélation, et communique avec le serveur via les événements Socket.io.
Afficher / masquer le code
<!-- index-bmc.html (extrait) -->
<script src="/socket.io/socket.io.js"></script>
<script>
const socket = io('/bmc');
let myRoom = '';
let myId = '';
let cardsToPick = 1;
let mySelection = [];
let currentHandData = [];
socket.on('connect', () => { myId = socket.id; });
function join() {
const username = document.getElementById('username').value;
myRoom = document.getElementById('room').value.toUpperCase();
if (username && myRoom) {
socket.emit('join_game', { username, room: myRoom });
}
}
socket.on('update_hand', (hand) => {
currentHandData = hand;
renderHand();
});
function renderHand() {
const handDiv = document.getElementById('my-hand');
handDiv.innerHTML = currentHandData.map(txt => {
const isSel = mySelection.includes(txt);
const selIdx = mySelection.indexOf(txt) + 1;
return \`
<div class="card \${isSel ? 'selected' : ''}" onclick="toggleCard('\${txt.replace(/'/g, "\\\\'")}')">
\${formatCardContent(txt)}
\${isSel && cardsToPick > 1 ? \`<div class="selection-badge"\>\${selIdx}</div\>\` : ''}
</div>\`;
}).join('');
}
function toggleCard(txt) {
const idx = mySelection.indexOf(txt);
if (idx > -1) mySelection.splice(idx, 1);
else if (mySelection.length < cardsToPick) mySelection.push(txt);
renderHand();
if (mySelection.length === cardsToPick) {
setTimeout(() => {
socket.emit('play_cards', { room: myRoom, cards: mySelection });
mySelection = [];
}, 300);
}
}
function formatCardContent(txt) {
if (txt && (txt.startsWith('/uploads/') || txt.startsWith('data:image/'))) {
return \`<img src="\${txt}" style="max-width:100%; max-height:100%; object-fit:contain; border-radius:5px;" />\`;
}
return txt;
}
</script>
Conclusion
Ce projet m’a permis de mettre en pratique la création d’un vrai jeu temps réel complet : API REST, WebSockets, gestion d’état serveur, UI mobile, animations et design d’expérience de jeu. Il est facilement extensible avec de nouveaux decks, des règles alternatives ou des statistiques avancées par joueur grâce à la structure actuelle.
Les prochaines améliorations envisagées incluent un système de persistance des parties terminées, un historique des meilleures manches, une interface responsive plus poussée sur desktop et l’internationalisation complète du jeu pour le rendre jouable en plusieurs langues.