feat: cartes Événement (pioche partagée de 18 cartes, 6 effets, synergies, ciblage)
- Nouveau server/src/game/events.js : 6 événements (Récolte exceptionnelle, Épidémie, Levée des troupes, Accord royal, Complot découvert, Grande fête au château), deck PARTAGÉ de 18 cartes (3 exemplaires de chacun) mélangé au démarrage de la partie. - Room.js : buyEventDraw() (coût fixe 1 point dans chacune des 4 jauges, effet immédiat contrairement aux objets/bâtiments — pas de conflit de stock possible), playEventCard() (choix de jouer une carte de sa main, max 1 par tour, avec ciblage optionnel), _resolvePendingEventPlays() (résolution de TOUS les événements du tour AVANT le calcul des gains de cartes personnage, défausse systématique, protection "Complot découvert" pour soi-même uniquement). Les 6 effets incluent leurs synergies avec les objets/bâtiments existants (Charrue, Trousse+Église pour Épidémie, Trébuchet, Sceau Royal, Château Royal → pioche bonus). - IMPORTANT : le ciblage de joueur (Accord royal, variante Trousse d'Épidémie) transite par teamIndex (identifiant public) et non socketId (jamais exposé au client via getPlayersInfo/getStateFor) — le serveur résout teamIndex -> joueur réel au moment de la résolution. - Nouvel event socket 'buy-event-draw' (effet immédiat) et 'play-event' (résolution différée), eventResults inclus dans round-result. - Client : events.js (miroir), EventCardObject.js (carte épurée façon CardObject, badge rouge "!" pour les événements à effet négatif). BootScene génère les textures plein cadre (méthode _generateClippedTexture généralisée, réutilisée avec les personnages). - GameScene : bouton de pioche à droite du bouton de confirmation (état grisé selon jauges/main pleine/pioche déjà tentée), seconde main de cartes événement (max 2) au-dessus de ce bouton, sélection d'une carte pour la jouer avec séquence de ciblage interactive (surbrillance des slots adversaires cliquables) pour Accord royal et la variante Trousse d'Épidémie. - 61 nouveaux tests unitaires serveur (events.js + Room.js : pioche, choix de jouer, résolution des 6 effets avec/sans synergie, Complot découvert, ordre événements-avant-personnages, deck partagé). - Nouveaux helpers et tests d'intégration E2E Playwright (e2e/tests/events.spec.js) pour la pioche, la limite de main à 2, et les 6 effets — certains scénarios restent probabilistes (pioche aléatoire dans le deck partagé) et peuvent nécessiter une stabilisation supplémentaire du timing.
This commit is contained in:
Kevin L'Hereec committed
1 parent
9139989fa7
commit
1726f8f96b
17 files changed
+1952
-16
No files matched your search
+264
-4
@@ -1,6 +1,7 @@
|
||||
const { dealHands } = require('./cards')
|
||||
const { ITEMS, getItemById } = require('./items')
|
||||
const { BUILDINGS, getBuildingById } = require('./buildings')
|
||||
const { getEventById, buildEventDeck, DRAW_COST } = require('./events')
|
||||
|
||||
const MAX_PLAYERS = 4
|
||||
const MAX_TURNS = 12
|
||||
@@ -29,8 +30,25 @@ const ATTRS = ['food', 'war', 'health', 'diplo']
|
||||
* un bâtiment coûte des points sur DEUX jauges à la fois et garantit un
|
||||
* minimum sur ses deux attributs à chaque tour, avec un bonus de synergie
|
||||
* (+1 supplémentaire) si l'objet correspondant est aussi possédé.
|
||||
*
|
||||
* Événements (voir events.js) :
|
||||
* Deck PARTAGÉ de 18 cartes (3 exemplaires de chacun des 6 événements),
|
||||
* mélangé au démarrage de la partie. En phase 'selecting', un joueur peut
|
||||
* acheter une pioche (coût fixe : 1 point dans CHACUNE des 4 jauges), au
|
||||
* maximum une tentative par tour, tant que sa "main d'événements" (cartes
|
||||
* piochées mais pas encore jouées) contient moins de EVENT_HAND_MAX cartes.
|
||||
* Le joueur choisit ensuite, tour par tour, s'il joue UNE de ses cartes
|
||||
* événement (au maximum) en la sélectionnant explicitement — contrairement
|
||||
* aux objets/bâtiments, jouer un événement n'est jamais automatique.
|
||||
* Les événements du tour sont résolus EN PREMIER dans resolveRound(), avant
|
||||
* le calcul des gains des cartes personnage (dont les jauges reflètent donc
|
||||
* déjà les effets des événements de ce même tour). Une carte événement est
|
||||
* toujours défaussée après résolution (jouée ou consommée par un ciblage
|
||||
* requis mais non fourni), et l'effet ne persiste jamais au tour suivant.
|
||||
*/
|
||||
|
||||
const EVENT_HAND_MAX = 2
|
||||
|
||||
class Room {
|
||||
constructor(id) {
|
||||
this.id = id
|
||||
@@ -44,6 +62,10 @@ class Room {
|
||||
this.availableItems = [] // ids des objets pas encore achetés
|
||||
this.availableBuildings = [] // ids des bâtiments pas encore achetés
|
||||
this.firstPlayerIndex = 0 // index (dans this.players) du joueur prioritaire ce tour
|
||||
|
||||
this.eventDeck = [] // ids d'événements restants dans le deck partagé
|
||||
this.pendingEventDraws = new Set() // socketIds ayant déjà tenté une pioche ce tour
|
||||
this.pendingEventPlays = new Map() // socketId -> { eventId, targets } carte choisie pour être jouée ce tour
|
||||
}
|
||||
|
||||
get playerCount() { return this.players.length }
|
||||
@@ -62,7 +84,8 @@ class Room {
|
||||
hand: [],
|
||||
deck: [], // cartes restantes à piocher
|
||||
items: [], // ids des objets possédés (effets permanents)
|
||||
buildings: [] // ids des bâtiments possédés (effets permanents)
|
||||
buildings: [], // ids des bâtiments possédés (effets permanents)
|
||||
eventHand: [] // ids d'événements piochés mais pas encore joués (max EVENT_HAND_MAX)
|
||||
})
|
||||
return true
|
||||
}
|
||||
@@ -75,6 +98,8 @@ class Room {
|
||||
this.pendingBuys.delete(socketId)
|
||||
this.pendingBuildingBuys.delete(socketId)
|
||||
this.pendingPlays.delete(socketId)
|
||||
this.pendingEventDraws.delete(socketId)
|
||||
this.pendingEventPlays.delete(socketId)
|
||||
|
||||
// Conserver l'identité du "premier joueur" (priorité d'achat) à travers
|
||||
// la suppression : firstPlayerIndex est un index positionnel qui décale
|
||||
@@ -107,14 +132,18 @@ class Room {
|
||||
p.gauges = { food: 0, war: 0, health: 0, diplo: 0 }
|
||||
p.items = []
|
||||
p.buildings = []
|
||||
p.eventHand = []
|
||||
})
|
||||
this.currentTurn = 1
|
||||
this.phase = 'selecting'
|
||||
this.pendingPlays.clear()
|
||||
this.pendingBuys.clear()
|
||||
this.pendingBuildingBuys.clear()
|
||||
this.pendingEventDraws.clear()
|
||||
this.pendingEventPlays.clear()
|
||||
this.availableItems = ITEMS.map(i => i.id)
|
||||
this.availableBuildings = BUILDINGS.map(b => b.id)
|
||||
this.eventDeck = buildEventDeck()
|
||||
this.firstPlayerIndex = 0
|
||||
}
|
||||
|
||||
@@ -212,6 +241,72 @@ class Room {
|
||||
return { ok: true }
|
||||
}
|
||||
|
||||
// ─── Cartes Événement ───────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Achète une pioche d'événement : contrairement aux objets/bâtiments, il
|
||||
* n'y a pas de conflit de stock unique possible (le deck partagé de 18
|
||||
* cartes ne cible jamais une carte précise), donc l'effet est appliqué
|
||||
* IMMÉDIATEMENT (coût débité, carte piochée ajoutée à la main d'événements)
|
||||
* plutôt que différé à resolveRound().
|
||||
*/
|
||||
buyEventDraw(socketId) {
|
||||
if (this.phase !== 'selecting')
|
||||
return { ok: false, error: 'Ce n\'est pas la phase de sélection' }
|
||||
|
||||
const player = this.players.find(p => p.socketId === socketId)
|
||||
if (!player) return { ok: false, error: 'Joueur introuvable' }
|
||||
|
||||
if (this.pendingEventDraws.has(socketId))
|
||||
return { ok: false, error: 'Tu as déjà tenté une pioche d\'événement ce tour' }
|
||||
|
||||
if (player.eventHand.length >= EVENT_HAND_MAX)
|
||||
return { ok: false, error: `Ta main d'événements est pleine (max ${EVENT_HAND_MAX})` }
|
||||
|
||||
if (this.eventDeck.length === 0)
|
||||
return { ok: false, error: 'Le deck d\'événements est épuisé' }
|
||||
|
||||
const missing = Object.entries(DRAW_COST).filter(([attr, cost]) => player.gauges[attr] < cost)
|
||||
if (missing.length > 0)
|
||||
return { ok: false, error: 'Pas assez de points pour piocher un événement (il faut 1 point dans chaque jauge)' }
|
||||
|
||||
Object.entries(DRAW_COST).forEach(([attr, cost]) => { player.gauges[attr] -= cost })
|
||||
const drawnId = this.eventDeck.shift()
|
||||
player.eventHand.push(drawnId)
|
||||
this.pendingEventDraws.add(socketId)
|
||||
|
||||
return { ok: true, eventId: drawnId }
|
||||
}
|
||||
|
||||
/**
|
||||
* Choisit de jouer une carte événement de sa main ce tour (résolution
|
||||
* différée à resolveRound(), en même temps que celle des autres joueurs,
|
||||
* et AVANT le calcul des gains des cartes personnage). `targets` dépend de
|
||||
* l'événement, et référence les cibles par TEAMINDEX (identifiant public,
|
||||
* jamais par socketId — donnée serveur interne non exposée au client via
|
||||
* getPlayersInfo/getStateFor) :
|
||||
* - royal_accord : { gainTargetTeamIndex, loseTargetTeamIndex }
|
||||
* - epidemic : { targetTeamIndex } (utilisé seulement si la variante
|
||||
* Trousse du Médecin s'applique — déterminée à la résolution, pas ici)
|
||||
* Une seule carte événement jouable par tour et par joueur.
|
||||
*/
|
||||
playEventCard(socketId, eventId, targets = {}) {
|
||||
if (this.phase !== 'selecting')
|
||||
return { ok: false, error: 'Ce n\'est pas la phase de sélection' }
|
||||
|
||||
const player = this.players.find(p => p.socketId === socketId)
|
||||
if (!player) return { ok: false, error: 'Joueur introuvable' }
|
||||
|
||||
if (!player.eventHand.includes(eventId))
|
||||
return { ok: false, error: 'Tu ne possèdes pas cette carte événement' }
|
||||
|
||||
if (this.pendingEventPlays.has(socketId))
|
||||
return { ok: false, error: 'Tu as déjà choisi de jouer un événement ce tour' }
|
||||
|
||||
this.pendingEventPlays.set(socketId, { eventId, targets })
|
||||
return { ok: true }
|
||||
}
|
||||
|
||||
// ─── Résolution du tour ─────────────────────────────────────────────────────
|
||||
|
||||
resolveRound() {
|
||||
@@ -225,6 +320,14 @@ class Room {
|
||||
const boughtItems = this._resolvePendingBuys()
|
||||
const boughtBuildings = this._resolvePendingBuildingBuys()
|
||||
|
||||
// ── 1bis. Résoudre les cartes Événement AVANT les gains personnage ─────────
|
||||
// Choix de design validé : les événements du tour modifient les jauges
|
||||
// directement (comme les achats), donc les cartes personnage sont ensuite
|
||||
// comparées avec des jauges déjà à jour — mais le gain voisin-de-gauche
|
||||
// lui-même ne dépend que des VALEURS DE CARTE jouées, pas des jauges, donc
|
||||
// cet ordre n'affecte que le score cumulé, jamais le calcul du gain brut.
|
||||
const eventResults = this._resolvePendingEventPlays()
|
||||
|
||||
// ── 2. Construire un tableau ordonné des cartes jouées ─────────────────────
|
||||
const plays = this.players.map(p => ({
|
||||
player: p,
|
||||
@@ -284,7 +387,7 @@ class Room {
|
||||
this.pendingPlays.clear()
|
||||
this.phase = 'resolve'
|
||||
|
||||
return { playedCards, gains, boughtItems, boughtBuildings, message: lines.join(' | ') }
|
||||
return { playedCards, gains, boughtItems, boughtBuildings, eventResults, message: lines.join(' | ') }
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -473,6 +576,157 @@ class Room {
|
||||
return gains
|
||||
}
|
||||
|
||||
/**
|
||||
* Résout toutes les cartes Événement jouées ce tour (this.pendingEventPlays),
|
||||
* dans l'ordre suivant :
|
||||
* 1. Défausser chaque carte jouée de la main du joueur (elle est toujours
|
||||
* consommée, que son effet s'applique intégralement ou non).
|
||||
* 2. Déterminer l'ensemble des joueurs protégés par "Complot découvert"
|
||||
* joué CE tour (protection uniquement pour soi-même — validé).
|
||||
* 3. Appliquer l'effet de chaque autre carte jouée, en respectant la
|
||||
* protection ci-dessus pour les effets négatifs qui ciblent le porteur
|
||||
* du Complot.
|
||||
* Retourne un tableau de résumés { playerName, eventId, eventName, summary }
|
||||
* pour l'affichage côté client.
|
||||
*/
|
||||
_resolvePendingEventPlays() {
|
||||
if (this.pendingEventPlays.size === 0) return []
|
||||
|
||||
// Snapshot des entrées avant toute défausse/mutation, pour un traitement
|
||||
// stable même si plusieurs joueurs jouent le même id d'événement.
|
||||
const entries = [...this.pendingEventPlays.entries()].map(([socketId, play]) => ({
|
||||
socketId,
|
||||
player: this.players.find(p => p.socketId === socketId),
|
||||
eventId: play.eventId,
|
||||
targets: play.targets ?? {}
|
||||
})).filter(e => e.player)
|
||||
|
||||
// Défausser chaque carte jouée de la main de son joueur, immédiatement
|
||||
// et inconditionnellement (règle : toujours consommée après résolution).
|
||||
entries.forEach(({ player, eventId }) => {
|
||||
const idx = player.eventHand.indexOf(eventId)
|
||||
if (idx !== -1) player.eventHand.splice(idx, 1)
|
||||
})
|
||||
|
||||
// Joueurs protégés par "Complot découvert" ce tour (protection pour
|
||||
// soi-même uniquement, jamais collective).
|
||||
const protectedSocketIds = new Set(
|
||||
entries.filter(e => e.eventId === 'plot_uncovered').map(e => e.socketId)
|
||||
)
|
||||
|
||||
const results = []
|
||||
const extraDraws = [] // socketIds ayant droit à une pioche bonus (Grande fête + Château)
|
||||
|
||||
entries.forEach(({ player, eventId, targets, socketId }) => {
|
||||
const event = getEventById(eventId)
|
||||
if (!event) return
|
||||
|
||||
let summary = ''
|
||||
|
||||
switch (eventId) {
|
||||
case 'bountiful_harvest': {
|
||||
// Récolte exceptionnelle : +2 Nourriture, +1 supplémentaire avec la Charrue.
|
||||
const bonus = player.items.includes('plow') ? 1 : 0
|
||||
const gain = 2 + bonus
|
||||
player.gauges.food += gain
|
||||
summary = `${player.name} : +${gain} Nourriture (Récolte exceptionnelle${bonus ? ' + Charrue' : ''})`
|
||||
break
|
||||
}
|
||||
|
||||
case 'epidemic': {
|
||||
// Épidémie : effet de base (tout le monde -1 Santé), sauf variante
|
||||
// Trousse (un adversaire choisi perd 2 Santé à la place) ou Église
|
||||
// (tous les adversaires perdent 2 Santé à la place) — déterminée
|
||||
// au moment de jouer la carte, selon ce que le lanceur possède.
|
||||
if (player.buildings.includes('church')) {
|
||||
const affected = this.players.filter(p => p.socketId !== socketId)
|
||||
affected.forEach(p => {
|
||||
if (!protectedSocketIds.has(p.socketId)) p.gauges.health = Math.max(0, p.gauges.health - 2)
|
||||
})
|
||||
summary = `${player.name} déclenche Épidémie (Église) : tous les adversaires -2 Santé`
|
||||
} else if (player.items.includes('medkit') && targets.targetTeamIndex !== undefined) {
|
||||
const target = this.players.find(p => p.teamIndex === targets.targetTeamIndex && p.socketId !== socketId)
|
||||
if (target && !protectedSocketIds.has(target.socketId)) {
|
||||
target.gauges.health = Math.max(0, target.gauges.health - 2)
|
||||
summary = `${player.name} déclenche Épidémie (Trousse) : ${target.name} -2 Santé`
|
||||
} else {
|
||||
summary = `${player.name} déclenche Épidémie (Trousse), cible invalide ou protégée`
|
||||
}
|
||||
} else {
|
||||
this.players.forEach(p => {
|
||||
if (!protectedSocketIds.has(p.socketId)) p.gauges.health = Math.max(0, p.gauges.health - 1)
|
||||
})
|
||||
summary = `${player.name} déclenche Épidémie : tous les joueurs -1 Santé`
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
case 'troop_levy': {
|
||||
// Levée des troupes : +2 Guerre / -1 Diplomatie (auto-infligé par
|
||||
// sa propre carte), +2 Guerre suppl. avec le Trébuchet (soit +4
|
||||
// Guerre au total). Note : "Complot découvert" protège des effets
|
||||
// négatifs des AUTRES cartes événement qui ciblent le joueur — ne
|
||||
// s'applique pas ici puisqu'un seul événement est jouable par tour
|
||||
// et par joueur (impossible de jouer les deux la même main).
|
||||
const warBonus = player.items.includes('trebuchet') ? 2 : 0
|
||||
const warGain = 2 + warBonus
|
||||
player.gauges.war += warGain
|
||||
player.gauges.diplo = Math.max(0, player.gauges.diplo - 1)
|
||||
summary = `${player.name} : +${warGain} Guerre, -1 Diplomatie (Levée des troupes${warBonus ? ' + Trébuchet' : ''})`
|
||||
break
|
||||
}
|
||||
|
||||
case 'royal_accord': {
|
||||
// Accord royal : +1 Diplo pour soi (+1 suppl. avec le Sceau), un
|
||||
// joueur choisi gagne 1 Diplo, un joueur choisi (peut être le même
|
||||
// ou différent) en perd 1.
|
||||
const selfBonus = player.items.includes('royal_seal') ? 1 : 0
|
||||
player.gauges.diplo += 1 + selfBonus
|
||||
|
||||
const gainTarget = this.players.find(p => p.teamIndex === targets.gainTargetTeamIndex && p.socketId !== socketId)
|
||||
if (gainTarget) gainTarget.gauges.diplo += 1
|
||||
|
||||
const loseTarget = this.players.find(p => p.teamIndex === targets.loseTargetTeamIndex && p.socketId !== socketId)
|
||||
if (loseTarget && !protectedSocketIds.has(loseTarget.socketId)) {
|
||||
loseTarget.gauges.diplo = Math.max(0, loseTarget.gauges.diplo - 1)
|
||||
}
|
||||
|
||||
summary = `${player.name} : +${1 + selfBonus} Diplomatie (Accord royal${selfBonus ? ' + Sceau' : ''})` +
|
||||
(gainTarget ? `, ${gainTarget.name} +1 Diplomatie` : '') +
|
||||
(loseTarget ? `, ${loseTarget.name} -1 Diplomatie` : '')
|
||||
break
|
||||
}
|
||||
|
||||
case 'plot_uncovered': {
|
||||
// Complot découvert : protection déjà calculée en amont (protectedSocketIds).
|
||||
summary = `${player.name} joue Complot découvert (protégé des effets négatifs ce tour)`
|
||||
break
|
||||
}
|
||||
|
||||
case 'castle_feast': {
|
||||
// Grande fête au château : +1 Nourriture, +1 Diplomatie, pioche
|
||||
// bonus si le Château Royal est possédé (place toujours disponible
|
||||
// puisque jouer cette carte libère un slot dans la main).
|
||||
player.gauges.food += 1
|
||||
player.gauges.diplo += 1
|
||||
let bonusDrawn = null
|
||||
if (player.buildings.includes('castle') && this.eventDeck.length > 0) {
|
||||
bonusDrawn = this.eventDeck.shift()
|
||||
player.eventHand.push(bonusDrawn)
|
||||
}
|
||||
summary = `${player.name} : +1 Nourriture, +1 Diplomatie (Grande fête)` +
|
||||
(bonusDrawn ? `, pioche bonus (Château Royal)` : '')
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
results.push({ playerName: player.name, teamIndex: player.teamIndex, eventId, eventName: event.name, summary })
|
||||
})
|
||||
|
||||
this.pendingEventPlays.clear()
|
||||
return results
|
||||
}
|
||||
|
||||
// ─── Tour suivant ────────────────────────────────────────────────────────────
|
||||
|
||||
nextTurn() {
|
||||
@@ -496,6 +750,7 @@ class Room {
|
||||
this.phase = 'selecting'
|
||||
this.pendingBuys.clear()
|
||||
this.pendingBuildingBuys.clear()
|
||||
this.pendingEventDraws.clear()
|
||||
}
|
||||
|
||||
isGameOver() {
|
||||
@@ -515,7 +770,8 @@ class Room {
|
||||
handSize: p.hand.length,
|
||||
deckSize: p.deck.length,
|
||||
items: [...p.items],
|
||||
buildings: [...p.buildings]
|
||||
buildings: [...p.buildings],
|
||||
eventHandSize: p.eventHand.length
|
||||
}))
|
||||
}
|
||||
|
||||
@@ -538,7 +794,11 @@ class Room {
|
||||
pendingBuyBuildingId: this.pendingBuildingBuys.get(socketId) ?? null,
|
||||
availableItems: [...this.availableItems],
|
||||
availableBuildings: [...this.availableBuildings],
|
||||
firstPlayerName: firstPlayer ? firstPlayer.name : null
|
||||
firstPlayerName: firstPlayer ? firstPlayer.name : null,
|
||||
myEventHand: player ? [...player.eventHand] : [],
|
||||
eventDeckSize: this.eventDeck.length,
|
||||
hasPendingEventDraw: this.pendingEventDraws.has(socketId),
|
||||
pendingEventPlayId: this.pendingEventPlays.get(socketId)?.eventId ?? null
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
/**
|
||||
* Regnum - Définition des 6 cartes Événement et de leur pioche partagée
|
||||
*
|
||||
* La pioche est un deck PARTAGÉ pour toute la partie : 18 cartes (3
|
||||
* exemplaires de chacun des 6 événements), mélangées au démarrage. Quand un
|
||||
* joueur achète une pioche, une carte est retirée du deck commun (les autres
|
||||
* joueurs ne peuvent plus la piocher).
|
||||
*
|
||||
* Chaque définition d'événement porte :
|
||||
* - id, name, description : affichage
|
||||
* - cost: { food, war, health, diplo } — coût de la PIOCHE (identique pour
|
||||
* tous les événements : 1 point dans chacune des 4 jauges, payé à
|
||||
* l'achat, pas au moment de jouer la carte)
|
||||
* - needsTargetOnDraw: true si le joueur doit choisir une/des cible(s) dès
|
||||
* le tirage (Accord royal — le ciblage ne dépend d'aucun objet possédé,
|
||||
* donc peut être figé immédiatement)
|
||||
* - needsTargetOnPlay: true si le ciblage dépend d'un état qui ne peut être
|
||||
* connu qu'au moment de jouer la carte (Épidémie — la variante Trousse
|
||||
* n'est déterminée qu'à cet instant, donc le ciblage doit avoir lieu à
|
||||
* ce moment-là, pas au tirage)
|
||||
* - resolve(ctx) : logique d'effet, voir Room._resolveEventCard pour le
|
||||
* contrat exact de `ctx` (player, allPlayers, targets, hasNegatedByComplot)
|
||||
*/
|
||||
|
||||
const DRAW_COST = { food: 1, war: 1, health: 1, diplo: 1 }
|
||||
|
||||
const EVENTS = [
|
||||
{
|
||||
id: 'bountiful_harvest',
|
||||
name: 'Récolte exceptionnelle',
|
||||
cost: DRAW_COST,
|
||||
negative: false,
|
||||
description: 'Gagnez 2 Nourriture. Synergie — Charrue : si vous possédez la Charrue, gagnez 1 Nourriture supplémentaire.'
|
||||
},
|
||||
{
|
||||
id: 'epidemic',
|
||||
name: 'Épidémie',
|
||||
cost: DRAW_COST,
|
||||
negative: true,
|
||||
needsTargetOnPlay: true, // la cible (si variante Trousse) n'est connue qu'au moment de jouer
|
||||
description: 'Effet de base : chaque joueur perd 1 Santé. Avec la Trousse du Médecin : un adversaire choisi perd 2 Santé à la place. Avec l\'Église : tous les adversaires perdent 2 Santé à la place.'
|
||||
},
|
||||
{
|
||||
id: 'troop_levy',
|
||||
name: 'Levée des troupes',
|
||||
cost: DRAW_COST,
|
||||
negative: false, // le porteur y gagne toujours plus qu'il n'y perd
|
||||
description: 'Gagnez 2 Guerre et perdez 1 Diplomatie. Synergie — Trébuchet : si vous possédez le Trébuchet, gagnez 2 Guerre supplémentaires (soit 4 Guerre au total).'
|
||||
},
|
||||
{
|
||||
id: 'royal_accord',
|
||||
name: 'Accord royal',
|
||||
cost: DRAW_COST,
|
||||
negative: false,
|
||||
needsTargetOnDraw: true, // choix des 2 joueurs ciblés dès le tirage (pas de dépendance à un objet)
|
||||
description: 'Gagnez 1 Diplomatie. Choisissez un autre joueur : il gagne 1 Diplomatie. Choisissez un autre joueur : il perd 1 Diplomatie (les deux joueurs choisis peuvent être différents). Synergie — Sceau Royal : si vous possédez le Sceau, gagnez 1 Diplomatie supplémentaire.'
|
||||
},
|
||||
{
|
||||
id: 'plot_uncovered',
|
||||
name: 'Complot découvert',
|
||||
cost: DRAW_COST,
|
||||
negative: false,
|
||||
description: 'Jusqu\'à la fin du tour, annule pour vous les effets négatifs des autres cartes Événement jouées ce tour.'
|
||||
},
|
||||
{
|
||||
id: 'castle_feast',
|
||||
name: 'Grande fête au château',
|
||||
cost: DRAW_COST,
|
||||
negative: false,
|
||||
description: 'Gagnez 1 Nourriture et 1 Diplomatie. Synergie — Château Royal : si vous possédez le Château Royal, piochez 1 carte Événement supplémentaire.'
|
||||
}
|
||||
]
|
||||
|
||||
function getEventById(id) {
|
||||
return EVENTS.find(e => e.id === id) ?? null
|
||||
}
|
||||
|
||||
function shuffle(arr) {
|
||||
const a = [...arr]
|
||||
for (let i = a.length - 1; i > 0; i--) {
|
||||
const j = Math.floor(Math.random() * (i + 1));
|
||||
[a[i], a[j]] = [a[j], a[i]]
|
||||
}
|
||||
return a
|
||||
}
|
||||
|
||||
/** Construit et mélange le deck partagé de 18 cartes (3 exemplaires de chaque événement). */
|
||||
function buildEventDeck() {
|
||||
const deck = []
|
||||
EVENTS.forEach(e => {
|
||||
for (let i = 0; i < 3; i++) deck.push(e.id)
|
||||
})
|
||||
return shuffle(deck)
|
||||
}
|
||||
|
||||
module.exports = { EVENTS, getEventById, buildEventDeck, DRAW_COST }
|
||||
+39
-1
@@ -99,6 +99,42 @@ io.on('connection', (socket) => {
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Piocher une carte Événement ─────────────────────────────────────────────
|
||||
socket.on('buy-event-draw', ({ roomId }) => {
|
||||
const room = rooms.get(roomId)
|
||||
if (!room) return
|
||||
|
||||
const result = room.buyEventDraw(socket.id)
|
||||
if (!result.ok) {
|
||||
socket.emit('error', { message: result.error })
|
||||
return
|
||||
}
|
||||
|
||||
// Contrairement aux objets/bâtiments, la pioche est immédiate (pas de
|
||||
// conflit de stock possible) : chaque joueur reçoit son état à jour tout
|
||||
// de suite (seul le joueur ayant pioché voit la nouvelle carte dans
|
||||
// myEventHand, les autres voient juste ses jauges diminuer).
|
||||
room.players.forEach(player => {
|
||||
io.to(player.socketId).emit('game-state', room.getStateFor(player.socketId))
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Choisir de jouer une carte Événement ce tour ────────────────────────────
|
||||
socket.on('play-event', ({ roomId, eventId, targets }) => {
|
||||
const room = rooms.get(roomId)
|
||||
if (!room) return
|
||||
|
||||
const result = room.playEventCard(socket.id, eventId, targets)
|
||||
if (!result.ok) {
|
||||
socket.emit('error', { message: result.error })
|
||||
return
|
||||
}
|
||||
|
||||
room.players.forEach(player => {
|
||||
io.to(player.socketId).emit('game-state', room.getStateFor(player.socketId))
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Jouer une carte ─────────────────────────────────────────────────────────
|
||||
socket.on('play-card', ({ roomId, cardId }) => {
|
||||
const room = rooms.get(roomId)
|
||||
@@ -128,12 +164,14 @@ io.on('connection', (socket) => {
|
||||
const roundResult = room.resolveRound()
|
||||
console.log(`[${roomId}] Tour ${room.currentTurn} résolu`)
|
||||
|
||||
// Révéler les cartes jouées, les gains par attribut, et les objets/bâtiments achetés
|
||||
// Révéler les cartes jouées, les gains par attribut, les objets/bâtiments
|
||||
// achetés, et les résultats des cartes Événement jouées ce tour.
|
||||
io.to(roomId).emit('round-result', {
|
||||
playedCards: roundResult.playedCards,
|
||||
gains: roundResult.gains,
|
||||
boughtItems: roundResult.boughtItems,
|
||||
boughtBuildings: roundResult.boughtBuildings,
|
||||
eventResults: roundResult.eventResults,
|
||||
message: roundResult.message
|
||||
})
|
||||
|
||||
|
||||
Reference in new issue
Block a user