feat: enforce Excalibur must go to a team member; dedupe server game constants

- server: assign-excalibur now requires targetPlayerId in the leader's in-progress teamPlayerIds; propose-team clears excaliburHolder if the final team no longer includes them (official rule: holder must be a mission team member)
- GameView: excalibur assign UI now only lists selectedTeam members and sends teamPlayerIds with the emit
- server.ts: drop duplicated TEAM_DISTRIBUTION/MISSION_SIZES/ROLES/needsTwoFails/assignRoles, import from src/core/avalon.ts instead (client always sends both lancelot roles together, so core's simpler assignRoles behaves identically to the server's old duplicate)
- tests: update existing Excalibur tests for the new teamPlayerIds param; add coverage for the team-membership rule and for clearing the holder when the team changes

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: deyvyd

server.ts

@@ -9,7 +9,10 @@ import { Server } from "socket.io";
 import { createServer as createViteServer } from "vite";
 import path from "path";
 import { fileURLToPath } from "url";
-import { LANCELOT_CONFIGS, generateLoyaltyDeck, shuffle } from "./src/core/avalon.ts";
+import {
+  LANCELOT_CONFIGS, generateLoyaltyDeck, shuffle,
+  TEAM_DISTRIBUTION, MISSION_SIZES, ROLES, needsTwoFails, assignRoles,
+} from "./src/core/avalon.ts";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -486,17 +489,24 @@ io.on("connection", (socket) => {
     room.proposedTeam = teamPlayerIds;
     room.phase = 'team-voting';
     room.teamVotes = {};
+    // Regra oficial: portador da Excalibur deve ser membro da equipe da missão —
+    // se o líder mudou a equipe depois de designar, a designação cai
+    if (room.excaliburHolder && !teamPlayerIds.includes(room.excaliburHolder)) {
+      room.excaliburHolder = null;
+    }
     broadcastRoom(room);
   });
 
-  socket.on("assign-excalibur", ({ roomCode, targetPlayerId }) => {
+  socket.on("assign-excalibur", ({ roomCode, targetPlayerId, teamPlayerIds }) => {
     const room = rooms.get(roomCode);
     const { playerId } = socketToPlayer.get(socket.id) || {};
     if (!room || room.phase !== 'team-proposal' || !room.excaliburEnabled) return;
     if (playerId !== room.players[room.currentLeaderIndex]?.id) return;
     // Líder não pode manter a Excalibur consigo
     if (targetPlayerId === playerId) return;
     if (!room.players.some(p => p.id === targetPlayerId)) return;
+    // Regra oficial: portador deve ser membro da equipe que o líder está montando
+    if (!Array.isArray(teamPlayerIds) || !teamPlayerIds.includes(targetPlayerId)) return;
 
     room.excaliburHolder = targetPlayerId;
     broadcastRoom(room);
@@ -787,38 +797,6 @@ io.on("connection", (socket) => {
   });
 });
 
-// Avalon game logic helper (duplicate for server context)
-const TEAM_DISTRIBUTION: Record<number, { good: number; evil: number }> = {
-  5: { good: 3, evil: 2 },
-  6: { good: 4, evil: 2 },
-  7: { good: 4, evil: 3 },
-  8: { good: 5, evil: 3 },
-  9: { good: 6, evil: 3 },
-  10: { good: 6, evil: 4 },
-};
-
-const MISSION_SIZES: Record<number, number[]> = {
-  5: [2, 3, 2, 3, 3],
-  6: [2, 3, 4, 3, 4],
-  7: [2, 3, 3, 4, 4],
-  8: [3, 4, 4, 5, 5],
-  9: [3, 4, 4, 5, 5],
-  10: [3, 4, 4, 5, 5],
-};
-
-const ROLES: Record<string, { team: 'good' | 'evil' }> = {
-  merlin: { team: 'good' },
-  assassin: { team: 'evil' },
-  servant: { team: 'good' },
-  minion: { team: 'evil' },
-  percival: { team: 'good' },
-  morgana: { team: 'evil' },
-  mordred: { team: 'evil' },
-  oberon: { team: 'evil' },
-  lancelot_good: { team: 'good' },
-  lancelot_evil: { team: 'evil' },
-};
-
 interface KnowledgeItem {
   playerId: string;
   hint: 'evil' | 'maybe-merlin' | 'lancelot';
@@ -1039,44 +1017,6 @@ function saveMatchHistory(room: Room) {
   if (room.matchHistory.length > 10) room.matchHistory.pop();
 }
 
-function needsTwoFails(missionIndex: number, playerCount: number): boolean {
-  return missionIndex === 3 && playerCount >= 7;
-}
-
-function assignRoles(playerIds: string[], selectedOptionalRoles: string[]): Record<string, string> {
-  const playerCount = playerIds.length;
-  const distribution = TEAM_DISTRIBUTION[playerCount];
-  if (!distribution) throw new Error('Número de jogadores inválido');
-
-  const rolesToAssign: string[] = [];
-  rolesToAssign.push('merlin');
-  rolesToAssign.push('assassin');
-  
-  // Handle Lancelots separately if selected
-  const useLancelots = selectedOptionalRoles.includes('lancelot_good') || selectedOptionalRoles.includes('lancelot_evil');
-  const otherOptionalRoles = selectedOptionalRoles.filter(r => r !== 'lancelot_good' && r !== 'lancelot_evil');
-  
-  if (useLancelots) {
-    rolesToAssign.push('lancelot_good');
-    rolesToAssign.push('lancelot_evil');
-  }
-  
-  otherOptionalRoles.forEach(roleId => rolesToAssign.push(roleId));
-
-  const currentGood = rolesToAssign.filter(r => ROLES[r].team === 'good').length;
-  const currentEvil = rolesToAssign.filter(r => ROLES[r].team === 'evil').length;
-
-  for (let i = 0; i < distribution.good - currentGood; i++) rolesToAssign.push('servant');
-  for (let i = 0; i < distribution.evil - currentEvil; i++) rolesToAssign.push('minion');
-
-  const shuffledRoles = shuffle(rolesToAssign);
-  const assignments: Record<string, string> = {};
-  playerIds.forEach((id, index) => {
-    assignments[id] = shuffledRoles[index];
-  });
-  return assignments;
-}
-
 export { httpServer, io };
 
 async function startServer() {

src/components/game/GameView.tsx

@@ -277,19 +277,24 @@ export const GameView = ({ room, me, isHost, onLeave }: { room: Room; me?: Playe
                 {room.excaliburEnabled && !room.excaliburUsed && (
                   <div className="pt-4 border-t border-white/5 space-y-3">
                     <p className="text-xs uppercase tracking-widest text-gray-400 font-bold">{t('app.game.excaliburAssign')}</p>
-                    <div className="grid grid-cols-2 gap-2">
-                      {room.players.filter(p => p.id !== playerId).map(p => (
-                        <button
-                          key={p.id}
-                          onClick={() => socket.emit('assign-excalibur', { roomCode: room.code, targetPlayerId: p.id })}
-                          className={`p-2 rounded-lg border transition-all text-xs font-bold ${
-                            room.excaliburHolder === p.id ? 'border-[#ffd700] bg-[#ffd700]/10 text-[#ffd700]' : 'border-white/10 bg-white/5 text-gray-400'
-                          }`}
-                        >
-                          {p.name}
-                        </button>
-                      ))}
-                    </div>
+                    {selectedTeam.length === 0 ? (
+                      <p className="text-[10px] text-gray-500 italic">{t('app.game.excaliburSelectTeamFirst')}</p>
+                    ) : (
+                      <div className="grid grid-cols-2 gap-2">
+                        {/* Regra oficial: portador precisa estar na equipe da missão */}
+                        {room.players.filter(p => p.id !== playerId && selectedTeam.includes(p.id)).map(p => (
+                          <button
+                            key={p.id}
+                            onClick={() => socket.emit('assign-excalibur', { roomCode: room.code, targetPlayerId: p.id, teamPlayerIds: selectedTeam })}
+                            className={`p-2 rounded-lg border transition-all text-xs font-bold ${
+                              room.excaliburHolder === p.id ? 'border-[#ffd700] bg-[#ffd700]/10 text-[#ffd700]' : 'border-white/10 bg-white/5 text-gray-400'
+                            }`}
+                          >
+                            {p.name}
+                          </button>
+                        ))}
+                      </div>
+                    )}
                     <p className="text-[10px] text-gray-400 italic">{t('app.game.excaliburHint')}</p>
                   </div>
                 )}

src/i18n/locales/en.json

@@ -157,7 +157,8 @@
       "selectMissionLabel": "Select the Mission",
       "confirmTeam": "Confirm Team",
       "excaliburAssign": "Give Excalibur",
-      "excaliburHint": "The leader must give Excalibur to another team member (or any player depending on your interpretation, but generally to a team member or another player).",
+      "excaliburSelectTeamFirst": "Select the mission team first — Excalibur can only go to a team member.",
+      "excaliburHint": "The leader must give Excalibur to another member of the mission team.",
       "waitingFormation": "Waiting for team formation...",
       "teamVote": "Team Vote",
       "youVoted": "You voted!",

src/i18n/locales/pt.json

@@ -157,7 +157,8 @@
       "selectMissionLabel": "Selecione a Missão",
       "confirmTeam": "Confirmar Equipe",
       "excaliburAssign": "Entregar Excalibur",
-      "excaliburHint": "O líder deve entregar a Excalibur a outro cavaleiro da equipe (ou qualquer jogador dependendo da sua interpretação, mas geralmente é para alguém da equipe ou apenas outro jogador).",
+      "excaliburSelectTeamFirst": "Selecione a equipe da missão primeiro — a Excalibur só pode ir para um membro dela.",
+      "excaliburHint": "O líder deve entregar a Excalibur a outro cavaleiro da equipe da missão.",
       "waitingFormation": "Aguardando a formação da equipe...",
       "teamVote": "Votação da Equipe",
       "youVoted": "Você votou!",

tests/game.test.ts

@@ -252,7 +252,7 @@ describe('Excalibur', () => {
     const team = h.currentTeam(0); // 2 jogadores do bem
     const leader = h.leader();
     const holderCandidate = team.find(id => id !== leader.playerId) ?? team[0];
-    leader.socket.emit('assign-excalibur', { roomCode: h.code, targetPlayerId: holderCandidate });
+    leader.socket.emit('assign-excalibur', { roomCode: h.code, targetPlayerId: holderCandidate, teamPlayerIds: team });
     await h.waitFor(() => h.room.excaliburHolder === holderCandidate, 'excalibur atribuída');
 
     await h.proposeAndApprove(team);
@@ -275,7 +275,7 @@ describe('Excalibur', () => {
     const team = h.currentTeam(0);
     const leader = h.leader();
     const holderCandidate = team.find(id => id !== leader.playerId) ?? team[0];
-    leader.socket.emit('assign-excalibur', { roomCode: h.code, targetPlayerId: holderCandidate });
+    leader.socket.emit('assign-excalibur', { roomCode: h.code, targetPlayerId: holderCandidate, teamPlayerIds: team });
     await h.waitFor(() => h.room.excaliburHolder === holderCandidate, 'excalibur atribuída');
     await h.proposeAndApprove(team);
     team.forEach(id => h.byId(id).socket.emit('vote-mission', { roomCode: h.code, vote: 'success' }));

tests/rules.test.ts

@@ -161,6 +161,39 @@ describe('guards do assign-excalibur (fix C)', () => {
     await new Promise(r => setTimeout(r, 300));
     expect(h.room.excaliburHolder).toBeNull();
   });
+
+  it('portador precisa estar na equipe proposta (regra oficial)', async () => {
+    h = await Harness.create(5);
+    await h.startGame({ excaliburEnabled: true });
+    const team = h.currentTeam(0);
+    const outsider = h.clients.find(c => !team.includes(c.playerId) && c !== h.leader())!;
+    // Sem equipe enviada: rejeitado
+    h.leader().socket.emit('assign-excalibur', { roomCode: h.code, targetPlayerId: outsider.playerId });
+    await new Promise(r => setTimeout(r, 300));
+    expect(h.room.excaliburHolder).toBeNull();
+    // Alvo fora da equipe enviada: rejeitado
+    h.leader().socket.emit('assign-excalibur', { roomCode: h.code, targetPlayerId: outsider.playerId, teamPlayerIds: team });
+    await new Promise(r => setTimeout(r, 300));
+    expect(h.room.excaliburHolder).toBeNull();
+  });
+
+  it('mudar a equipe depois de atribuir Excalibur limpa a designação ao propor', async () => {
+    h = await Harness.create(5);
+    await h.startGame({ excaliburEnabled: true });
+    const team = h.currentTeam(0);
+    const leader = h.leader();
+    const holderCandidate = team.find(id => id !== leader.playerId)!;
+    leader.socket.emit('assign-excalibur', { roomCode: h.code, targetPlayerId: holderCandidate, teamPlayerIds: team });
+    await h.waitFor(() => h.room.excaliburHolder === holderCandidate, 'excalibur atribuída');
+
+    // Propõe uma equipe diferente, sem o antigo portador
+    const missionSize = h.room.missions[0].size;
+    const others = h.room.players.map((p: any) => p.id).filter((id: string) => id !== holderCandidate);
+    const newTeam = others.slice(0, missionSize);
+    leader.socket.emit('propose-team', { roomCode: h.code, teamPlayerIds: newTeam });
+    await h.waitPhase('team-voting');
+    expect(h.room.excaliburHolder).toBeNull();
+  });
 });
 
 describe('leave-room no meio da partida (fix D)', () => {