black-sheep-bluff/public/assets/js/play.js
2026-09-18 06:46:56 +02:00

1235 lines
58 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Black Sheep Bluff – Spiel (play.html) – ausgelagertes JS */
const App = (() => {
const API = '/api';
const COLORS = ['#3ECC5C','#4A5BE8','#5DCAA5','#ffcf6e','#65DC7A','#85B7EB','#D4537E','#97C459'];
let role=null, room=null, pkey=null, name=null, timer=null, lastJSON='';
let lastState=null, selectedImposters=new Set(), questionsLoaded=false;
let currentUser=null, lastRoundNum=-1, lastAnswerRound=-1, hostPass=null, adminSpectating=false;
let soundVolume=0.6; try{ const _sv=parseFloat(localStorage.getItem('bsb_sound_vol')); if(!isNaN(_sv)) soundVolume=Math.min(1,Math.max(0,_sv)); }catch(_){}
const $ = id => document.getElementById(id);
const show = (id,v=true) => $(id).classList.toggle('hidden',!v);
const esc = s => (s||'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
const initials = s => (s||'?').trim().split(/\s+/).map(w=>w[0]).join('').slice(0,2).toUpperCase();
const colorFor = s => { let h=0;for(const c of(s||''))h=(h*31+c.charCodeAt(0))>>>0;return COLORS[h%COLORS.length]; };
const nameColor = p => (p&&p.color) ? p.color : colorFor(p&&p.name||'');
const BSB_FONTS={inter:"Inter",sora:"Sora",pacifico:"Pacifico",lobster:"Lobster",bungee:"Bungee",bangers:"Bangers",orbitron:"Orbitron",pressstart:"'Press Start 2P'"};
function nameStyle(p){
p=p||{};
const c1=p.color||'var(--text)';
const st=p.nameStyle||'solid';
const font=BSB_FONTS[p.nameFont]||'';
let style='',cls='';
if(st==='rainbow'){ cls='name-rainbow'; }
else if(st==='gradient'&&p.color2){ style=`background:linear-gradient(90deg,${c1},${p.color2});-webkit-background-clip:text;background-clip:text;-webkit-text-fill-color:transparent;color:transparent`; }
else { style=`color:${c1}`; }
if(font) style+=`;font-family:${font}`;
return {style,cls};
}
function nameSpan(p, baseCls, text, extra){
const ns=nameStyle(p);
return `<span class="${baseCls}${ns.cls?' '+ns.cls:''}" style="${extra||''}${ns.style}">${text}</span>`;
}
const avatar = (p,cls='') => {
const n = typeof p === 'string' ? p : p.name;
const av = typeof p === 'object' && p.avatar ? p.avatar : null;
if(av) return `<img class="avatar ${cls}" src="/uploads/avatars/${encodeURIComponent(av)}" alt="${esc(n)}" style="object-fit:cover">`;
const bg = (typeof p === 'object' && p.color) ? p.color : colorFor(n);
return `<div class="avatar ${cls}" style="background:${bg}">${esc(initials(n))}</div>`;
};
const isImp = (pk,state) => (state.liarKeys||[]).includes(pk);
const isVotedOut = (pk,state) => (state.votedOutKeys||[]).includes(pk);
// ── Emoji reactions ───────────────────────────────────────
const seenEmojis = new Set();
function renderEmojis(list){
if(!list||!list.length) return;
const stage=$('emojiStage');
list.forEach(e=>{
if(seenEmojis.has(e.id)) return;
seenEmojis.add(e.id);
if(e.sound){ try{ const au=new Audio(e.sound); au.volume=soundVolume; au.play().catch(()=>{}); }catch(_){} return; }
const el=document.createElement('span');
el.className='efloat';
if(e.sticker){
const img=document.createElement('img');
img.src=e.sticker; img.alt='Sticker'; img.className='efloat-sticker';
el.appendChild(img);
} else {
el.textContent=e.emoji;
}
// random horizontal position
el.style.left=(10+Math.random()*80)+'%';
el.style.bottom='80px';
el.style.animationDelay=(Math.random()*0.4)+'s';
stage.appendChild(el);
el.addEventListener('animationend',()=>el.remove());
});
}
async function sendReaction(id){
if(!room) return;
try{ await api('send_reaction',{code:room,id}); }catch(e){}
}
async function sendSticker(){
if(!room) return;
try{ await api('send_sticker',{code:room}); }catch(e){}
}
async function sendStickerGlobal(id){
if(!room) return;
try{ await api('send_sticker',{code:room,id}); }catch(e){}
}
function toggleSound(){ const p=$('soundPanel'); show('soundPanel',p.classList.contains('hidden')); }
async function sendSound(id){
if(!room) return;
try{ await api('send_sound',{code:room,id}); }catch(e){}
}
// ── Globale Assets (Reaktionen / globale Sticker / Sounds) laden + rendern ──
let assetsLoaded=false;
async function loadAssets(){
if(assetsLoaded) return;
try{
const r=await fetch('/api/assets'); const d=await r.json();
if(!d||!d.ok) return;
assetsLoaded=true;
const bar=$('reactionBar'), own=$('stickerBtn');
if(bar){
const reactBtns=(d.reactions||[]).map(x=> x.emoji
? `<button class="emoji-side-btn" onclick="App.sendReaction(${parseInt(x.id)})">${esc(x.emoji)}</button>`
: `<button class="emoji-side-btn emoji-side-img" onclick="App.sendReaction(${parseInt(x.id)})" style="background-image:url('${encodeURI(x.image)}')"></button>`
).join('');
const stickBtns=(d.stickers||[]).map(x=>
`<button class="emoji-side-btn emoji-side-img" title="${esc(x.label)}" onclick="App.sendStickerGlobal(${parseInt(x.id)})" style="background-image:url('${encodeURI(x.file)}')"></button>`
).join('');
if(own) own.insertAdjacentHTML('beforebegin', reactBtns+stickBtns);
else bar.innerHTML=reactBtns+stickBtns;
}
const sl=$('soundList');
if(sl){
const sounds=d.sounds||[];
sl.innerHTML = sounds.length
? sounds.map(s=>`<button class="sb-btn" onclick="App.sendSound(${parseInt(s.id)})">${esc(s.label)}</button>`).join('')
: '<p class="sb-empty">Noch keine Sounds.</p>';
}
}catch(e){}
}
function err(msg){ const e=$('errBox'); e.textContent=msg; show('errBox',true); setTimeout(()=>show('errBox',false),4500); }
async function api(action, payload, method='POST'){
const url=API+'/'+action+(method==='GET'&&payload?'?'+new URLSearchParams(payload):'');
const opt={method};
if(method==='POST'){ opt.headers={'Content-Type':'application/json'}; opt.body=JSON.stringify(payload||{}); }
const res=await fetch(url,opt);
const data=await res.json().catch(()=>({error:'Ungültige Antwort.'}));
if(!res.ok||data.error) throw new Error(data.error||'Fehler '+res.status);
return data;
}
// ── Auth init ─────────────────────────────────────────────
async function initAuth(){
try{
const res=await fetch('/api/auth/me');
const data=await res.json();
if(!data.user){ window.location.href='/login'; return; }
currentUser=data.user;
if(data.impersonating){
const b=document.createElement('div'); b.id='imp-bar';
b.style.cssText='position:fixed;top:0;left:0;right:0;z-index:5000;background:#a86f00;color:#fff;font:600 13px/1.4 Inter,system-ui,sans-serif;padding:8px 14px;display:flex;align-items:center;justify-content:center;gap:12px;flex-wrap:wrap';
b.innerHTML='👁 Admin-Modus – du bist als anderer User angemeldet <button type="button" style="background:#fff;color:#a86f00;border:none;border-radius:6px;padding:5px 12px;font-weight:700;cursor:pointer">Zurück zum Admin</button>';
b.querySelector('button').onclick=async()=>{ try{ await fetch('/api/auth/stop_impersonating',{method:'POST'}); }catch(e){} location.href='/admin'; };
document.body.appendChild(b);
}
$('navUser').textContent=data.user.username;
$('joinName').value=data.user.username;
const donate=(window.BSB_CONFIG&&window.BSB_CONFIG.donationUrl)||'';
if(donate){ const dl=$('navDonate'); dl.href=donate; dl.classList.remove('hidden'); }
if(data.user.role==='admin'){
$('navAdmin').href='/admin';
$('navAdmin').classList.remove('hidden');
$('adminSpectateCard').classList.remove('hidden');
}
}catch(e){ window.location.href='/login'; }
}
async function logout(){
await fetch('/api/auth/logout',{method:'POST'});
window.location.href='/login';
}
function enterHostView(state, sessionData){
role='host'; room=state.code;
adminSpectating=!!sessionData.adminSpectate;
selectedImposters=new Set(state.liarKeys||[]);
questionsLoaded=false; lastJSON=''; lastChatLen=0; lastRoundNum=-1; resetChatUI();
sessionStorage.setItem('bsb_session',JSON.stringify(sessionData));
show('lobby',false); show('playerView',false); show('hostView',true);
show('hSpectateBadge',adminSpectating); showChatWidget(true);
$('hRoom').textContent=room;
render(state); startPoll();
}
// ── Host / Player open ────────────────────────────────────
async function hostOpen(){
const code=$('hostCode').value, pass=$('hostPass').value;
if(!code||!pass){ err('Code und Passwort ausfüllen.'); return; }
try{
const d=await api('host_open',{code,pass});
hostPass=pass;
enterHostView(d.state,{role:'host',room:d.state.code,pass});
}catch(e){ err(e.message); }
}
async function adminSpectate(){
const code=($('spectateCode').value||'').trim().toUpperCase();
if(!code){ err('Raum-Code eingeben.'); return; }
try{
const d=await api('admin_spectate',{code});
enterHostView(d.state,{role:'host',room:d.state.code,adminSpectate:true});
}catch(e){ err(e.message); }
}
async function playerJoin(){
const code=$('joinCode').value, nm=$('joinName').value.trim();
if(!code||!nm){ err('Code und Name ausfüllen.'); return; }
try{
const d=await api('player_join',{code,name:nm});
role='player'; room=d.state.code; pkey=d.pkey; name=nm;
lastJSON=''; lastChatLen=0; lastRoundNum=-1; localVotes=new Set(); resetChatUI();
sessionStorage.setItem('bsb_session',JSON.stringify({role:'player',room:d.state.code,pkey:d.pkey,name:nm}));
show('lobby',false); show('hostView',false); show('playerView',true); showChatWidget(true);
$('pRoom').textContent=room; $('pName').textContent=nm;
render(d.state); startPoll();
}catch(e){ err(e.message); }
}
function startPoll(){ clearInterval(timer); timer=setInterval(refresh,1500); }
async function refresh(){
if(!room) return;
try{ const d=await api('state',{code:room},'GET'); render(d.state); }catch(e){}
}
// ── Voting Pie Chart ──────────────────────────────────────
const CHART_COLORS=['#4A5BE8','#3ECC5C','#e85d5c','#ffcf6e','#2bb585',
'#6B7BFF','#65DC7A','#f09b3a','#85B7EB','#D4537E'];
const chartInstances={};
function computeTally(players){
// Only locked votes; unlocked players don't contribute
const counts={__nobody__:0};
players.forEach(p=>{ counts[p.pkey]=0; });
players.filter(p=>p.voteLocked).forEach(p=>{
const vs=p.votes||[];
if(!vs.length||vs.includes('__nobody__')){ counts.__nobody__++; }
else{ vs.forEach(v=>{ if(counts[v]!==undefined) counts[v]++; }); }
});
return counts;
}
function updateVotingChart(canvasId, players, state){
const canvas=$(canvasId);
if(!canvas) return;
const counts=computeTally(players);
// Build label/data arrays — skip entries with 0 votes
const labels=[];
const data=[];
const colors=[];
let colorIdx=0;
players.forEach(p=>{
if(counts[p.pkey]>0){
labels.push(p.name);
data.push(counts[p.pkey]);
colors.push(p.color || CHART_COLORS[colorIdx%CHART_COLORS.length]);
colorIdx++;
}
});
if(counts.__nobody__>0){
labels.push('Niemand');
data.push(counts.__nobody__);
colors.push('#7a8aaa');
}
if(!data.length){ show(canvasId,false); return; }
show(canvasId,true);
if(chartInstances[canvasId]){
// Update existing chart in place (no flicker)
const ch=chartInstances[canvasId];
ch.data.labels=labels;
ch.data.datasets[0].data=data;
ch.data.datasets[0].backgroundColor=colors;
ch.update('none'); // skip animation on live updates
return;
}
// First render — create with entry animation
chartInstances[canvasId]=new Chart(canvas,{
type:'doughnut',
data:{
labels,
datasets:[{
data,
backgroundColor:colors,
borderColor:'#ffffff',
borderWidth:3,
hoverOffset:8,
}]
},
options:{
responsive:true,
maintainAspectRatio:true,
cutout:'55%',
animation:{duration:600,easing:'easeInOutQuart'},
plugins:{
legend:{
position:'bottom',
labels:{color:'#16203a',font:{family:'Inter',size:12},
padding:12,boxWidth:12,boxHeight:12}
},
tooltip:{
callbacks:{
label:(ctx)=>{
const total=ctx.dataset.data.reduce((a,b)=>a+b,0);
const pct=total?Math.round(ctx.parsed/total*100):0;
return ` ${ctx.parsed} Stimme${ctx.parsed!==1?'n':''} (${pct}%)`;
}
},
backgroundColor:'#1a2030',
borderColor:'#2a3550',
borderWidth:1,
titleColor:'#e8edf8',
bodyColor:'#a8b8d8',
}
}
}
});
}
function destroyChart(canvasId){
if(chartInstances[canvasId]){
chartInstances[canvasId].destroy();
delete chartInstances[canvasId];
}
const canvas=$(canvasId);
if(canvas) show(canvasId,false);
}
// ── Chat-Overlay (Emoji + GIF) ────────────────────────────
let lastChatLen=0, chatOpen=false, unread=0, gifTimer=null;
const CHAT_EMOJIS=['🐑','🔥','😂','🤣','👍','👎','😮','😢','😡','🎉','❤️','🤔','😏','🙈','👀','💀','😅','🙌','👏','🤝','🤡','🧐','😬','🥳','😱','🤥','😈','✅','❌','❓'];
const GIF_RX=/^gif:(https:\/\/(?:media\d*\.giphy\.com|i\.giphy\.com|media\.giphy\.com)\/[^\s"'<>]+)$/i;
const GIPHY_KEY=(window.BSB_CONFIG&&window.BSB_CONFIG.giphyApiKey)||'';
// Chat-Anzeige beim Lobby-Wechsel leeren (sonst bleiben Nachrichten der vorherigen Lobby stehen)
function resetChatUI(){ lastChatLen=0; const cm=$('chatMsgs'); if(cm) cm.innerHTML='<p class="empty" style="font-size:12px">Noch keine Nachrichten.</p>'; }
function renderChat(msgs, colorMap={}){
const wrap=$('chatMsgs');
if(!wrap) return;
if(!msgs||!msgs.length){
if(lastChatLen===0) return;
wrap.innerHTML='<p class="empty" style="font-size:12px">Noch keine Nachrichten.</p>';
lastChatLen=0; return;
}
const prev=lastChatLen;
if(msgs.length===prev) return;
lastChatLen=msgs.length;
const atBottom=wrap.scrollHeight-wrap.scrollTop<=wrap.clientHeight+50;
wrap.innerHTML=msgs.map(m=>{
const c=colorMap[m.player_name]||colorFor(m.player_name);
const gif=GIF_RX.exec(m.message||'');
const body=gif?`<img class="gif" src="${esc(gif[1])}" alt="GIF" loading="lazy">`
:`<span class="ct">${esc(m.message)}</span>`;
return `<div class="chat-msg"><span class="cn" style="color:${c}">${esc(m.player_name)}</span>${body}</div>`;
}).join('');
if(atBottom||chatOpen) wrap.scrollTop=wrap.scrollHeight;
if(!chatOpen && prev>0 && msgs.length>prev){
unread+=msgs.length-prev;
const b=$('chatBadge'); b.textContent=unread>99?'99+':unread; b.classList.remove('hidden');
}
}
async function sendChat(){
const msg=$('chatInput').value.trim();
if(!msg||!room) return;
const sender=role==='host'?('Host:'+room):(name||'?');
$('chatInput').value='';
try{ await api('send_chat',{code:room,name:sender,message:msg}); refresh(); }
catch(e){ err(e.message); }
}
function toggleChat(){
chatOpen=!chatOpen;
show('chatPanel',chatOpen);
if(chatOpen){
unread=0; $('chatBadge').classList.add('hidden');
const m=$('chatMsgs'); m.scrollTop=m.scrollHeight; $('chatInput').focus();
} else {
show('emojiPicker',false); show('gifPanel',false);
$('emojiToolBtn').classList.remove('active'); $('gifToolBtn').classList.remove('active');
}
}
function buildEmojiPicker(){
const p=$('emojiPicker'); if(p.dataset.built) return;
p.innerHTML=CHAT_EMOJIS.map(e=>`<button type="button" onclick="App.insertEmoji('${e}')">${e}</button>`).join('');
p.dataset.built='1';
}
function insertEmoji(e){ const i=$('chatInput'); i.value+=e; i.focus(); }
function toggleEmojiPicker(){
buildEmojiPicker();
const open=$('emojiPicker').classList.contains('hidden');
show('emojiPicker',open); show('gifPanel',false);
$('emojiToolBtn').classList.toggle('active',open); $('gifToolBtn').classList.remove('active');
}
function toggleGifPanel(){
const open=$('gifPanel').classList.contains('hidden');
show('gifPanel',open); show('emojiPicker',false);
$('gifToolBtn').classList.toggle('active',open); $('emojiToolBtn').classList.remove('active');
if(open) $('gifSearch').focus();
}
function gifSearchDebounced(){ clearTimeout(gifTimer); gifTimer=setTimeout(gifSearch,350); }
async function gifSearch(){
const q=$('gifSearch').value.trim();
const box=$('gifResults');
if(!GIPHY_KEY || GIPHY_KEY.indexOf('HIER_')===0){
box.innerHTML='<p class="gif-hint">Kein Giphy-API-Key in config.js hinterlegt.</p>'; return;
}
if(!q){ box.innerHTML='<p class="gif-hint">Tippe oben, um GIFs zu suchen.</p>'; return; }
box.innerHTML='<p class="gif-hint">Suche…</p>';
try{
const url='https://api.giphy.com/v1/gifs/search?api_key='+encodeURIComponent(GIPHY_KEY)
+'&q='+encodeURIComponent(q)+'&limit=18&rating=pg-13&bundle=fixed_height_small';
const r=await fetch(url); const d=await r.json();
if(!d.data||!d.data.length){ box.innerHTML='<p class="gif-hint">Nichts gefunden.</p>'; return; }
box.innerHTML=d.data.map(g=>{
const prev=(g.images.fixed_height_small||g.images.fixed_height||g.images.original).url;
const full=(g.images.downsized_medium||g.images.fixed_height||g.images.original).url;
return `<img src="${esc(prev)}" data-full="${esc(full)}" loading="lazy" alt="GIF" onclick="App.sendGif(this.dataset.full)">`;
}).join('');
}catch(e){ box.innerHTML='<p class="gif-hint">Fehler bei der GIF-Suche.</p>'; }
}
async function sendGif(url){
if(!url||!room) return;
const sender=role==='host'?('Host:'+room):(name||'?');
show('gifPanel',false); $('gifToolBtn').classList.remove('active');
$('gifSearch').value=''; $('gifResults').innerHTML='<p class="gif-hint">Tippe oben, um GIFs zu suchen.</p>';
try{ await api('send_chat',{code:room,name:sender,message:'gif:'+url}); refresh(); }
catch(e){ err(e.message); }
}
function showChatWidget(on){
show('chatWidget',on);
show('soundWidget',on);
if(!on){ chatOpen=false; show('chatPanel',false); show('emojiPicker',false); show('gifPanel',false); show('soundPanel',false); }
unread=0; $('chatBadge').classList.add('hidden');
}
// ── Lobby-Tabs (Teilnehmen / Starten) ─────────────────────
function lobbyTab(which){
const join=which==='join';
$('tabJoin').classList.toggle('active',join);
$('tabHost').classList.toggle('active',!join);
show('lobbyJoin',join); show('lobbyHost',!join);
}
function render(state){
lastState=state;
// Neue Runde: eigenes Antwortfeld leeren (Server hat die Antwort bereits zurückgesetzt)
if(state.roundNum !== lastAnswerRound){ lastAnswerRound=state.roundNum; const _ta=$('pAnswer'); if(_ta) _ta.value=''; }
renderEmojis(state.activeEmojis);
const sig=JSON.stringify({...state, activeEmojis:[], chat:[]});
if(sig!==lastJSON){
lastJSON=sig;
role==='host' ? renderHost(state) : renderPlayer(state);
}
// Chat updates always (separate from main state diff)
const colorMap=Object.fromEntries(Object.values(state.players||{}).map(p=>[p.name,nameColor(p)]));
renderChat(state.chat||[], colorMap);
}
// ── Outcome helpers ───────────────────────────────────────
function outcomeHTML(state, myPkey){
if(!state.roundOutcome) return '';
const o=state.roundOutcome;
const liarKeys=state.liarKeys||[];
const votedOutKeys=state.votedOutKeys||[];
const survivingLiarKeys=liarKeys.filter(k=>!votedOutKeys.includes(k));
let cls,emoji,title;
if(myPkey){
const wasImp=isImp(myPkey,state);
const wasVotedOut=isVotedOut(myPkey,state);
const iWon=wasImp ? !wasVotedOut : (o==='innocents_win');
if(o==='no_liar'){cls='draw';emoji='🤷';title='Keine Imposters gesetzt';}
else if(iWon){cls='win';emoji='🏆';title=wasImp?'Du hast überlebt! (Imposter)':'Innocents gewinnen!';}
else{cls='loss';emoji='💀';title=wasImp?'Du wurdest aufgedeckt!':'Imposters entkommen!';}
} else {
if(o==='innocents_win'){cls='win';emoji='🎯';title='Innocents gewinnen!';}
else if(o==='imposters_win'){
cls='loss';emoji='🎭';
const winnerNames=survivingLiarKeys.map(k=>esc(state.players[k]?.name||k));
if(winnerNames.length===1){
title=`Imposter ${winnerNames[0]} gewinnt!`;
} else if(winnerNames.length>=2){
const last=winnerNames.pop();
title=`Die Imposter ${winnerNames.join(', ')} und ${last} gewinnen!`;
} else {
title='Imposters gewinnen!';
}
}
else{cls='draw';emoji='🤷';title='Kein Imposter';}
}
// Per-imposter coloring
const imposterLines=liarKeys.map(k=>{
const nm=state.players[k]?.name||k;
const survived=survivingLiarKeys.includes(k);
const color=survived?'var(--green)':'var(--red)';
const tag=survived?'überlebt 🟢':'rausgewählt 🔴';
return `<span style="color:${color};font-weight:700">${esc(nm)}</span> <span style="font-size:11px;color:${color}">(${tag})</span>`;
});
let sub='';
if(imposterLines.length) sub+=`Imposters: ${imposterLines.join(', ')}. `;
else sub+='Kein Imposter. ';
if(!votedOutKeys.length) sub+='Niemand wurde rausgewählt.';
return `<div class="outcome-banner ${cls}">
<div class="emoji">${emoji}</div>
<div class="title">${title}</div>
<div class="sub">${sub}</div>
</div>`;
}
// Voting transparency: show who voted for whom
function voteResultsHTML(state){
const players=Object.values(state.players);
if(!players.length) return '';
const tag=(label,color)=>`<b style="color:${color}">${esc(label)}</b>`;
const rows=players.map(p=>{
const voted=(p.votes||[]).map(v=>{
if(v==='__nobody__') return tag('Niemand','var(--muted)');
const t=state.players[v];
return tag(t?.name||v, t?nameColor(t):'var(--text)');
});
return `<div class="vote-result-row">
${tag(p.name,nameColor(p))} stimmte für: ${voted.length?voted.join(', '):'<i style="color:var(--muted)">—</i>'}
</div>`;
});
return `<div class="vote-result-list">${rows.join('')}</div>`;
}
// ── PLAYER render ─────────────────────────────────────────
let localVotes = new Set(); // client-side checkbox state (cleared on lock or new round)
function renderPlayer(state){
const me=state.players[pkey]||{};
const players=Object.values(state.players);
const ri=state.revealIndex??-1;
const revealedKeys=state.revealedKeys||[];
// Use revealedKeys for targeted reveal; ri>=9999 means all revealed.
// Strikt in Aufdeck-Reihenfolge (revealedKeys ist chronologisch angehängt),
// damit neu freigegebene Karten stabil unten erscheinen statt umherzuspringen.
const revealedPlayers=ri>=9999?players:revealedKeys.map(k=>state.players[k]).filter(Boolean);
const anyRevealed=state.revealed||ri>=9999||revealedKeys.length>0;
const allFullyRevealed=players.length>0&&(ri>=9999||revealedKeys.length>=players.length);
// Header
$('pRound').textContent=state.roundNum||1;
$('pScore').textContent=me.score||0;
$('pName').textContent=me.name||name;
const avEl=$('pAvatar');
if(me.avatar){
avEl.outerHTML=`<div id="pAvatar" class="avatar" style="width:32px;height:32px;font-size:13px;overflow:hidden;padding:0"><img src="/uploads/avatars/${encodeURIComponent(me.avatar)}" style="width:100%;height:100%;object-fit:cover" alt="${esc(me.name||name)}"></div>`;
} else {
avEl.style.background=me.color||colorFor(me.name||name);
avEl.textContent=initials(me.name||name);
}
// Sidebar scoreboard — always update, even while waiting for a question
$('pScoreboard').innerHTML=sidebarScoreboard(players,pkey);
// Custom-Sticker-Button anzeigen, wenn der Spieler einen Sticker hochgeladen hat
const sBtn=$('stickerBtn');
if(sBtn){
if(me.sticker){
sBtn.style.backgroundImage=`url(/uploads/sticker/${encodeURIComponent(me.sticker)})`;
sBtn.style.backgroundSize='contain'; sBtn.style.backgroundRepeat='no-repeat';
sBtn.style.backgroundPosition='center'; sBtn.style.aspectRatio='1';
show('stickerBtn',true);
} else { show('stickerBtn',false); }
}
const hasQuestion=!!(me.question&&me.question.trim());
$('pQuestion').textContent=hasQuestion?me.question:'Warten auf den Spielleiter…';
// Lock answer area until host has set a question
if(!hasQuestion){
show('pImposterReal',false);
show('pAnswerArea',false);
show('pSubmitted',false);
$('pAnswers').innerHTML='<div class="status live"><span class="live-dot"></span>Der Leiter startet gleich die Runde…</div>';
show('pVoteCard',false);
return;
}
// Imposter sieht die echte Frage, sobald der Leiter sie aufdeckt (zum Argumentieren)
const amImposter=!!(state.normalQuestion&&me.question.trim()!==state.normalQuestion.trim());
if(amImposter&&state.questionsRevealed){
$('pImposterRealQ').textContent=state.normalQuestion;
show('pImposterReal',true);
} else {
show('pImposterReal',false);
}
show('pAnswerArea',!me.answered);
// "warte auf die Aufdeckung" nur zeigen, solange noch nichts aufgedeckt ist
show('pSubmitted',!!me.answered && !anyRevealed);
// Antwort darf zurückgezogen werden, solange der Host noch nichts aufgedeckt hat
show('pWithdrawBtn',!!me.answered && !anyRevealed);
const box=$('pAnswers');
const resolved=!!state.roundOutcome;
if(anyRevealed){
box.innerHTML=revealedPlayers.map((p,i)=>{
const imp=resolved&&isImp(p.pkey,state);
const vo=resolved&&isVotedOut(p.pkey,state);
return `<div class="abox ${imp?'imposter-hl':vo?'votedout-hl':''}">
<div class="who">${avatar(p,'miniav')}${nameSpan(p,'',esc(p.name))}
${imp?'<span class="liartag">Imposter</span>':''}
${vo?'<span class="badge" style="background:rgba(201,138,0,.15);color:#a86f00">Rausgewählt</span>':''}
</div>
<div class="ans">${p.answer?esc(p.answer):'<i>keine Antwort</i>'}</div>
</div>`;
}).join('')+(revealedPlayers.length<players.length?
`<div class="status live"><span class="live-dot"></span>${players.length-revealedPlayers.length} weitere werden noch aufgedeckt…</div>`:'')||
'<p class="empty">Keine Antworten.</p>';
show('pVoteCard',true);
if(resolved){
$('pVoteGrid').innerHTML='';
} else if(!state.votingOpen){
// Democratic voting request
const myReq=me.voteRequest||false;
const requesters=players.filter(p=>p.voteRequest);
const reqCount=requesters.length;
const requesterNames=requesters.map(p=>`<span style="color:${nameColor(p)};font-weight:700">${esc(p.name)}</span>`).join(', ');
const reqListHTML=reqCount>0?`<div style="font-size:12px;color:var(--muted);margin-top:6px">Beantragt: ${requesterNames}</div>`:'';
if(!allFullyRevealed){
$('pVoteGrid').innerHTML=`<div class="status" style="margin:0;color:var(--muted);font-size:13px">⏳ Alle Antworten müssen zuerst aufgedeckt werden</div>`;
} else {
$('pVoteGrid').innerHTML=myReq
?`<div class="status ok" style="margin:0">✓ Voting beantragt (${reqCount}/${players.length})</div>${reqListHTML}`
:`<div><button class="ghost" style="width:100%;margin-bottom:6px" onclick="App.requestVoting()">Voting beantragen 🗳 (${reqCount}/${players.length})</button>${reqListHTML}</div>`;
}
} else if(me.voteLocked){
const myVotedNames=(me.votes||[]).map(v=>v==='__nobody__'?'Niemand':(state.players[v]?.name||v));
// Live tally — only locked votes count (no ghost nobody)
const tally={'__nobody__':0};
players.forEach(p=>{ tally[p.pkey]=0; });
players.filter(p=>p.voteLocked).forEach(p=>{
const vs=p.votes||[];
if(!vs.length||vs.includes('__nobody__')){ tally['__nobody__']++; }
else{ vs.forEach(v=>{ if(tally[v]!==undefined) tally[v]++; }); }
});
const locked=players.filter(p=>p.voteLocked).length;
const tallyRows=players.map(p=>`
<div class="sb-row">
${avatar(p,'sb-av')}
${nameSpan(p,'sb-name',esc(p.name),'font-size:12px;')}
<span style="font-size:11px;margin-right:4px" title="${p.voteLocked?'hat abgestimmt':'stimmt noch ab'}">${p.voteLocked?'✅':'⏳'}</span>
<span class="sb-score" style="font-size:13px">${tally[p.pkey]||0}🗳</span>
</div>`).join('')+
`<div class="sb-row" style="border-top:1px dashed var(--line);margin-top:4px;padding-top:4px">
<span style="font-size:14px">🤷</span>
<span class="sb-name" style="font-size:12px;color:var(--muted)">Niemand</span>
<span class="sb-score" style="font-size:13px">${tally['__nobody__']||0}🗳</span>
</div>`;
$('pVoteGrid').innerHTML=`
<div class="vote-locked-msg">✓ Stimme abgeschickt: <b>${myVotedNames.join(', ')||'—'}</b></div>
<div style="margin-top:10px">
<div style="font-size:11px;color:var(--muted);font-weight:600;text-transform:uppercase;letter-spacing:.5px;margin-bottom:6px">
Live-Ergebnis (${locked}/${players.length} abgestimmt)
</div>
${tallyRows}
</div>`;
} else {
// Multi-vote checkboxes — actual <input> is hidden, card is the visual toggle
const others=players.filter(p=>p.pkey!==pkey);
$('pVoteGrid').innerHTML=`
<div class="vote-check-grid" id="voteCheckGrid">
${others.map(p=>`
<label class="vote-check-item ${localVotes.has(p.pkey)?'checked':''}">
<input type="checkbox" value="${p.pkey}" ${localVotes.has(p.pkey)?'checked':''}
onchange="App.toggleVoteCheck(this)" style="display:none">
${avatar(p,'miniav')}
<span class="vc-name" style="color:${nameColor(p)}">${esc(p.name)}</span>
</label>`).join('')}
<label class="vote-check-item nobody ${localVotes.has('__nobody__')?'checked':''}">
<input type="checkbox" value="__nobody__" ${localVotes.has('__nobody__')?'checked':''}
onchange="App.toggleVoteCheck(this)" style="display:none">
<span style="font-size:18px">🤷</span>
<span class="vc-name">Niemand</span>
</label>
</div>
<button class="vote-lock-btn" onclick="App.lockVote()"
${localVotes.size===0?'disabled':''}>Stimme abschicken ✓</button>`;
}
$('pOutcomeBanner').innerHTML=outcomeHTML(state,pkey)+(resolved?voteResultsHTML(state):'');
// Pie chart: show when player has voted or round is resolved
if(me.voteLocked||resolved){
updateVotingChart('pVotingChart',players,state);
} else {
destroyChart('pVotingChart');
}
} else {
destroyChart('pVotingChart');
show('pVoteCard',false);
const waiting=players.filter(p=>!p.answered).length;
box.innerHTML=`<div class="status live"><span class="live-dot"></span>
${waiting>0?waiting+' Spieler tippen noch…':'Alle fertig — warten auf Aufdeckung'}</div>`;
}
}
// ── HOST: Player-Liste (Sidebar) ──────────────────────────
function renderHostPlayers(players, votingActive=false){
const wrap=$('hPlayers');
if(!players.length){
if(wrap.dataset.empty!=='1'){wrap.innerHTML='<p class="empty" style="font-size:12px">Noch keine Spieler.</p>';wrap.dataset.empty='1';}
return;
}
wrap.dataset.empty='0';
const seen=new Set();
players.forEach(p=>{
seen.add(p.pkey);
let row=wrap.querySelector(`[data-row="${p.pkey}"]`);
if(!row){
row=document.createElement('div');
row.className='sb-row'; row.dataset.row=p.pkey;
row.innerHTML=`${avatar(p,'sb-av')}<span class="sb-name" data-name></span>
<span class="badge" data-badge style="font-size:9px;padding:2px 5px"></span>
<button class="kickbtn" data-kick title="Entfernen" style="width:18px;height:18px;font-size:10px;padding:0;margin-left:2px">✕</button>`;
row.querySelector('[data-kick]').addEventListener('click',()=>removePlayer(p.pkey,p.name));
wrap.appendChild(row);
}
const nameEl=row.querySelector('[data-name]');
nameEl.textContent=p.name;
nameEl.style.color=nameColor(p);
const badge=row.querySelector('[data-badge]');
// Nachzügler = Zuschauer dieser Runde. Sonst: während Voting Sanduhr/Häkchen,
// davor Antwort-Status (abgegeben / wartet).
const want=p.lateJoin ? 'late'
: (votingActive ? (p.voteLocked?'voted':'voting') : (p.answered?'done':'wait'));
if(badge.dataset.state!==want){
badge.dataset.state=want;
badge.className='badge '+(want==='voted'||want==='done'?'done':'wait');
badge.textContent=want==='late'?'👀':want==='voted'?'✅':want==='voting'?'⏳':want==='done'?'✓':'…';
badge.title=want==='late'?'Später beigetreten – Zuschauer':'';
}
});
wrap.querySelectorAll('[data-row]').forEach(row=>{if(!seen.has(row.dataset.row))row.remove();});
}
// ── HOST: Imposter-Auswahl ─────────────────────────────────
function renderImposterList(players, locked=false){
const wrap=$('hImposterList');
// Lock random/clear buttons when round is active
const randomBtn=document.querySelector('button[onclick="App.randomImposters()"]');
const clearBtn=document.querySelector('button[onclick="App.clearImposters()"]');
if(randomBtn) randomBtn.disabled=locked;
if(clearBtn) clearBtn.disabled=locked;
if(!players.length){
wrap.innerHTML='<p class="empty" style="grid-column:1/-1">Erst Spieler beitreten lassen.</p>';
updateImposterCount(); return;
}
// Remove the placeholder text if it's still in the DOM
wrap.querySelectorAll('p.empty').forEach(el=>el.remove());
const existing=new Map([...wrap.querySelectorAll('[data-imp]')].map(el=>[el.dataset.imp,el]));
const seen=new Set();
players.forEach(p=>{
seen.add(p.pkey);
const active=selectedImposters.has(p.pkey);
let btn=existing.get(p.pkey);
if(!btn){
btn=document.createElement('button');
btn.className='votebtn';
btn.dataset.imp=p.pkey;
btn.addEventListener('click',()=>{ if(!btn.disabled) toggleImposter(p.pkey); });
wrap.appendChild(btn);
}
btn.className='votebtn '+(active?'imposter-picked':'');
btn.disabled=locked;
btn.style.opacity=locked?'0.5':'';
btn.innerHTML=`${avatar(p,'miniav')}${esc(p.name)}${active?'<span class="liartag" style="margin-left:auto">Imposter</span>':''}`;
});
wrap.querySelectorAll('[data-imp]').forEach(el=>{if(!seen.has(el.dataset.imp))el.remove();});
updateImposterCount();
}
function updateImposterCount(){
const n=selectedImposters.size;
const b=$('hImposterCount');
b.textContent=n+' ausgewählt';
b.className='count-badge'+(n===0?' none':'');
}
function toggleImposter(pk){
selectedImposters.has(pk)?selectedImposters.delete(pk):selectedImposters.add(pk);
if(lastState) renderImposterList(Object.values(lastState.players));
}
function randomImposters(){
const players=lastState?Object.values(lastState.players):[];
if(!players.length){ err('Noch keine Spieler im Raum.'); return; }
const n=players.length;
let count=1;
try{
const weightsRaw=$('hWeights').value.trim()||lastState?.imposterWeights||'{"3-5":1,"6-9":2,"10+":3}';
const weights=JSON.parse(weightsRaw);
for(const [range,c] of Object.entries(weights)){
if(range.endsWith('+')){
const min=parseInt(range);
if(n>=min) count=Number(c);
} else {
const [lo,hi]=range.split('-').map(Number);
if(n>=lo&&n<=hi){ count=Number(c); break; }
}
}
}catch(e){ /* ignore bad JSON, use default 1 */ }
count=Math.min(Math.max(1,count),Math.max(1,n-1));
// Unverzerrte Auswahl per Fisher-Yates-Shuffle (mathematisch korrekt,
// im Gegensatz zum biased sort(()=>Math.random()-.5)).
const pool=players.map(p=>p.pkey);
for(let i=pool.length-1;i>0;i--){ const j=Math.floor(Math.random()*(i+1)); [pool[i],pool[j]]=[pool[j],pool[i]]; }
selectedImposters=new Set(pool.slice(0,count));
renderImposterList(players);
}
function clearImposters(){
selectedImposters=new Set();
if(lastState) renderImposterList(Object.values(lastState.players));
}
async function assignQuestions(){
const normalQ=$('hNormalQ').value.trim();
const imposterQ=$('hImposterQ').value.trim();
if(!normalQ){ err('Normale Frage darf nicht leer sein.'); return; }
if(!imposterQ){ err('Imposter-Frage darf nicht leer sein.'); return; }
const players=lastState?Object.values(lastState.players):[];
if(!players.length){ err('Noch keine Spieler.'); return; }
try{
const d=await api('assign_questions',{code:room,normalQuestion:normalQ,imposterQuestion:imposterQ,imposterKeys:[...selectedImposters]});
render(d.state);
}catch(e){ err(e.message); }
}
// ── HOST: Hauptrender ──────────────────────────────────────
function renderHost(state){
const players=Object.values(state.players);
// Admin spectator: imposter selection is driven by the server, keep it in sync each poll
if(adminSpectating) selectedImposters=new Set(state.liarKeys||[]);
const ri=state.revealIndex??-1;
const revealedKeys=state.revealedKeys||[];
const anyRevealed=state.revealed||ri>=9999||revealedKeys.length>0;
const revealCount=ri>=9999?players.length:revealedKeys.length;
// Must be defined before use in renderImposterList
const roundActive=!!(state.normalQuestion);
$('hRound').textContent=state.roundNum||1;
$('hRoundState').textContent=anyRevealed?(revealCount>=players.length&&players.length>0?'aufgedeckt':`${revealCount}/${players.length} aufgedeckt`):'verdeckt';
renderHostPlayers(players, !!state.votingOpen && !state.roundOutcome);
renderImposterList(players, roundActive);
// Imposter weights field - populate once
if(state.imposterWeights && $('hWeights').value===''){
$('hWeights').value=state.imposterWeights;
}
if(!questionsLoaded&&(state.normalQuestion||state.imposterQuestion)){
if($('hNormalQ').value===''&&state.normalQuestion) $('hNormalQ').value=state.normalQuestion;
if($('hImposterQ').value===''&&state.imposterQuestion) $('hImposterQ').value=state.imposterQuestion;
questionsLoaded=true;
}
// Question locking: disable textareas when a round is active (roundActive already defined above)
$('hNormalQ').disabled=roundActive;
$('hImposterQ').disabled=roundActive;
$('hNormalQ').style.opacity=roundActive?'0.5':'1';
$('hImposterQ').style.opacity=roundActive?'0.5':'1';
const resolved=!!state.roundOutcome;
// Reveal buttons: only before reveal all
show('hRevealNextBtn', false); // replaced by clickable cards
const allFullyRevealed = revealCount >= players.length && players.length > 0;
show('hRevealAllBtn', !resolved && !state.votingOpen && !allFullyRevealed);
show('hOpenVotingBtn', allFullyRevealed && !state.votingOpen && !resolved);
show('hResolveBtn', anyRevealed && state.votingOpen && !resolved);
// Echte Frage für Imposter aufdecken: nur während aktiver Runde, einmalig
const qBtn=$('hRevealQuestionsBtn');
show('hRevealQuestionsBtn', roundActive && !resolved);
if(roundActive && !resolved){
qBtn.disabled=!!state.questionsRevealed;
qBtn.style.opacity=state.questionsRevealed?'0.55':'1';
qBtn.textContent=state.questionsRevealed?'✓ Echte Frage aufgedeckt':'🐑 Echte Frage für Imposter aufdecken';
}
show('hOutcomeCard', !!resolved);
if(resolved) $('hOutcomeBanner').innerHTML=outcomeHTML(state,null)+voteResultsHTML(state);
// Answers — host always sees all; click card to reveal to players
const allRevd=ri>=9999;
$('hAnswers').innerHTML=players.length?players.map((p)=>{
const imp=resolved&&isImp(p.pkey,state);
const vo=resolved&&isVotedOut(p.pkey,state);
const isRevealed=allRevd||revealedKeys.includes(p.pkey);
const canReveal=!resolved&&!state.votingOpen&&p.answered&&!isRevealed;
return `<div class="abox ${p.answered?'':'pending'} ${imp?'imposter-hl':vo?'votedout-hl':''}"
${canReveal?`style="cursor:pointer;border:1px dashed var(--accent-deep)" onclick="App.revealAnswer('${p.pkey}')" title="Klicken zum Aufdecken"`:''}>
<div class="who">${avatar(p,'miniav')}${esc(p.name)}
${imp?'<span class="liartag">Imposter</span>':''}
${vo?'<span class="badge" style="background:rgba(201,138,0,.15);color:#a86f00">Rausgewählt</span>':''}
${canReveal?'<span class="badge wait" style="margin-left:auto">👁 aufdecken</span>':''}
${isRevealed&&p.answered&&!resolved?`<button class="delbtn" onclick="event.stopPropagation();App.deleteAnswer('${p.pkey}')" title="Antwort löschen">✕</button>`:''}
${resolved&&p.answered?`<button class="delbtn" onclick="App.deleteAnswer('${p.pkey}')" title="Antwort löschen">✕</button>`:''}
</div>
<div class="ans">${p.answered?esc(p.answer):'<i style="color:var(--muted)">noch keine Antwort</i>'}</div>
</div>`;
}).join(''):'<p class="empty">Noch keine Antworten.</p>';
// Voting tally in sidebar — use votes array
show('hVoteCard', anyRevealed && players.length>0);
if(anyRevealed && players.length){
const tally={'__nobody__':0};
players.forEach(p=>{ tally[p.pkey]=0; });
// Only count players who have explicitly locked their vote
players.filter(p=>p.voteLocked).forEach(p=>{
const votes=p.votes||[];
if(!votes.length||votes.includes('__nobody__')){ tally['__nobody__']++; }
else{ votes.forEach(v=>{ if(tally[v]!==undefined) tally[v]++; }); }
});
const locked=players.filter(p=>p.voteLocked).length;
$('hVoteTally').innerHTML=
`<p style="font-size:12px;color:var(--muted);margin:0 0 8px">${locked}/${players.length} abgestimmt</p>`+
players.map(p=>{
const imp=isImp(p.pkey,state);
const vo=isVotedOut(p.pkey,state);
const status=(state.votingOpen&&!resolved)?`<span style="font-size:11px;margin-right:4px" title="${p.voteLocked?'hat abgestimmt':'stimmt noch ab'}">${p.voteLocked?'✅':'⏳'}</span>`:'';
return `<div class="sb-row ${imp?'imposter-hl':vo?'votedout-hl':''}">
${avatar(p,'sb-av')}
${nameSpan(p,'sb-name',esc(p.name)+(imp?' 🎭':''))}
${status}
<span class="sb-score" style="font-size:13px">${tally[p.pkey]||0}🗳</span>
</div>`;
}).join('')+
`<div class="sb-row" style="border-top:1px dashed var(--line);margin-top:4px;padding-top:6px">
<span style="font-size:16px">🤷</span>
<span class="sb-name" style="color:var(--muted)">Niemand</span>
<span class="sb-score" style="font-size:13px">${tally['__nobody__']||0}🗳</span>
</div>`;
updateVotingChart('hVotingChart', players, state);
} else {
destroyChart('hVotingChart');
}
if(state.roundNum !== lastRoundNum){
lastRoundNum = state.roundNum;
loadHostHistory(state.code);
}
// Sidebar scoreboard with manual +/- buttons
const sorted=[...players].sort((a,b)=>(b.score||0)-(a.score||0));
$('hScoreboard').innerHTML=sorted.length?sorted.map((p,i)=>`
<div class="sb-row ${i===0&&p.score>0?'lead':''}">
${avatar(p,'sb-av')}
${nameSpan(p,'sb-name',esc(p.name))}
<span class="sb-score">${p.score||0}</span>
<div style="display:flex;gap:3px">
<button class="minus" style="width:22px;height:22px;padding:0;font-size:12px;border-radius:6px" onclick="App.score('${p.pkey}',-1)">−</button>
<button class="plus" style="width:22px;height:22px;padding:0;font-size:11px;border-radius:6px" onclick="App.score('${p.pkey}',1)">+</button>
</div>
</div>`).join(''):'<p class="empty" style="font-size:12px">—</p>';
}
// Compact sidebar scoreboard for player view
function sidebarScoreboard(players, myPkey){
const sorted=[...players].sort((a,b)=>(b.score||0)-(a.score||0));
if(!sorted.length) return '<p class="empty" style="font-size:12px">—</p>';
return sorted.map((p,i)=>`<div class="sb-row ${i===0&&p.score>0?'lead':''} ${p.pkey===myPkey?'reveal-hl':''}">
${avatar(p,'sb-av')}
${nameSpan(p,'sb-name',esc(p.name))}
<span class="sb-score">${p.score||0}</span>
</div>`).join('');
}
// ── Actions ────────────────────────────────────────────────
async function deleteAnswer(pk){
try{ const d=await api('delete_answer',{code:room,pkey:pk}); render(d.state); }
catch(e){ err(e.message); }
}
async function loadHostHistory(code){
try{
const d = await api('get_host_history',{code},'GET');
const wrap = $('hHistory');
if(!d.history||!d.history.length){
wrap.innerHTML='<p class="empty">Noch keine abgeschlossenen Runden.</p>';
return;
}
const outcomeLabel = o => {
if(!o) return '<span style="color:var(--muted)">Nicht ausgewertet</span>';
if(o==='innocents_win') return '<span style="color:var(--green)">✓ Innocents gewonnen</span>';
if(o==='imposters_win') return '<span style="color:var(--red)">✓ Imposters gewonnen</span>';
return '<span style="color:var(--muted)">Kein Imposter</span>';
};
wrap.innerHTML = d.history.map((r,i) => {
const date = r.played_at ? new Date(r.played_at*1000).toLocaleDateString('de-DE',{day:'2-digit',month:'2-digit',hour:'2-digit',minute:'2-digit'}) : '';
const bodyId = 'hhr_'+r.round_num;
return `<div class="hist-round">
<div class="hist-head ${i===0?'open':''}" onclick="this.classList.toggle('open');document.getElementById('${bodyId}').classList.toggle('open')">
<span class="rnum">Runde #${r.round_num}</span>
<span class="rout">${outcomeLabel(r.outcome)}</span>
<span class="rdate">${date}</span>
<span class="chevron">▶</span>
</div>
<div class="hist-body ${i===0?'open':''}" id="${bodyId}">
${r.players.map(p=>{
const tags=[
p.was_imposter?'<span class="liartag">Imposter</span>':'',
p.voted_out?'<span class="badge" style="background:rgba(201,138,0,.15);color:#a86f00">Rausgewählt</span>':''
].filter(Boolean).join(' ');
return `<div class="hist-prow">
${avatar(p,'miniav')}
<div style="flex:1;min-width:0">
<div style="display:flex;align-items:center;gap:7px;flex-wrap:wrap">
<span class="hname">${esc(p.name)}</span>${tags}
</div>
${p.question?`<div class="hq">❓ ${esc(p.question)}</div>`:''}
<div class="ha">${p.answer?esc(p.answer):'<i style="color:var(--muted)">keine Antwort</i>'}</div>
</div>
</div>`;
}).join('')}
</div>
</div>`;
}).join('');
}catch(e){ /* History-Fehler still ignorieren */ }
}
async function submitAnswer(){
const a=$('pAnswer').value.trim();
if(!a){ err('Schreib erst eine Antwort.'); return; }
try{ await api('submit_answer',{code:room,pkey,answer:a}); refresh(); }
catch(e){ err(e.message); }
}
// Bereits abgeschickte Antwort zurückziehen (nur solange nichts aufgedeckt ist)
async function withdrawAnswer(){
const me=lastState&&lastState.players?lastState.players[pkey]:null;
const anyRevealed=lastState&&(lastState.revealed||(lastState.revealIndex??-1)>=9999||(lastState.revealedKeys||[]).length>0);
if(anyRevealed){ err('Es wurde bereits aufgedeckt – Ändern nicht mehr möglich.'); return; }
try{
const d=await api('delete_answer',{code:room,pkey});
if(me&&me.answer&&$('pAnswer')) $('pAnswer').value=me.answer; // zum Bearbeiten vorbefüllen
render(d.state);
if($('pAnswer')) $('pAnswer').focus();
}catch(e){ err(e.message); }
}
// Multi-vote checkbox toggle (client-side only)
function toggleVoteCheck(cb){
const v=cb.value;
const item=cb.closest('.vote-check-item');
if(v==='__nobody__'){
if(cb.checked){ localVotes=new Set(['__nobody__']); }
else{ localVotes.delete('__nobody__'); }
} else {
localVotes.delete('__nobody__');
if(cb.checked){ localVotes.add(v); }
else{ localVotes.delete(v); }
}
// Re-render vote grid without full refresh
if(lastState) renderPlayer(lastState);
// Haptisches Feedback: die (neu gerenderte) Karte kurz wackeln lassen
const inp=document.querySelector(`#pVoteGrid .vote-check-item input[value="${v}"]`);
const card=inp&&inp.closest('.vote-check-item');
if(card){ card.classList.remove('shake'); void card.offsetWidth; card.classList.add('shake'); }
}
async function lockVote(){
if(localVotes.size===0){ err('Bitte mindestens eine Auswahl treffen.'); return; }
try{
const d=await api('lock_vote',{code:room,pkey,votes:[...localVotes]});
localVotes=new Set();
render(d.state);
}catch(e){ err(e.message); }
}
async function requestVoting(){
try{ const d=await api('request_voting',{code:room,pkey}); render(d.state); }
catch(e){ err(e.message); }
}
async function removePlayer(pk,nm){
if(!confirm('Spieler "'+nm+'" wirklich entfernen?')) return;
selectedImposters.delete(pk);
try{ await api('remove_player',{code:room,pkey:pk}); refresh(); }
catch(e){ err(e.message); }
}
async function score(pk,delta){
try{ await api('score',{code:room,pkey:pk,delta}); refresh(); }
catch(e){ err(e.message); }
}
async function reveal(){
try{ const d=await api('reveal',{code:room}); render(d.state); }
catch(e){ err(e.message); }
}
async function revealAnswer(pk){
try{ const d=await api('reveal_answer',{code:room,pkey:pk}); render(d.state); }
catch(e){ err(e.message); }
}
async function revealQuestions(){
try{ const d=await api('reveal_questions',{code:room}); render(d.state); }
catch(e){ err(e.message); }
}
async function revealNext(){
try{ const d=await api('reveal_next',{code:room}); render(d.state); }
catch(e){ err(e.message); }
}
async function openVoting(){
try{ const d=await api('open_voting',{code:room}); render(d.state); }
catch(e){ err(e.message); }
}
async function saveWeights(){
const w=$('hWeights').value.trim();
if(!w){ err('Gewichte darf nicht leer sein.'); return; }
try{ JSON.parse(w); }catch(e){ err('Ungültiges JSON.'); return; }
try{ await api('update_weights',{code:room,weights:w}); }
catch(e){ err(e.message); }
}
async function resolveRound(){
try{
const d=await api('resolve_round',{code:room});
selectedImposters=new Set(); questionsLoaded=false;
$('hNormalQ').value=''; $('hImposterQ').value='';
render(d.state);
}catch(e){ err(e.message); }
}
async function newRound(){
try{
await api('new_round',{code:room});
selectedImposters=new Set(); questionsLoaded=false; lastJSON='';
lastRoundNum=-1; localVotes=new Set(); lastChatLen=0;
$('hNormalQ').value=''; $('hImposterQ').value='';
if($('pAnswer')) $('pAnswer').value='';
destroyChart('pVotingChart'); destroyChart('hVotingChart');
refresh();
}catch(e){ err(e.message); }
}
async function resetScores(){
if(!confirm('Wirklich alle Punkte auf 0?')) return;
try{ await api('reset_scores',{code:room}); refresh(); }
catch(e){ err(e.message); }
}
async function deleteRoom(){
if(!confirm('Lobby „'+room+'" wirklich löschen? Alle Spieler werden rausgeworfen.')) return;
try{
await api('delete_room',{code:room,pass:hostPass});
clearInterval(timer);
role=room=pkey=name=hostPass=null;
lastState=null; selectedImposters=new Set(); questionsLoaded=false; lastJSON='';
lastRoundNum=-1;
show('playerView',false); show('hostView',false); show('lobby',true); showChatWidget(false);
}catch(e){ err(e.message); }
}
function leave(){
clearInterval(timer); role=room=pkey=name=null;
lastState=null; selectedImposters=new Set(); questionsLoaded=false; lastJSON='';
lastRoundNum=-1; lastChatLen=0; adminSpectating=false;
show('hSpectateBadge',false);
sessionStorage.removeItem('bsb_session');
show('playerView',false); show('hostView',false); show('lobby',true); showChatWidget(false);
}
async function tryRestoreSession(){
const raw=sessionStorage.getItem('bsb_session');
if(!raw) return false;
try{
const s=JSON.parse(raw);
if(s.role==='host'){
let d;
if(s.adminSpectate){
d=await api('admin_spectate',{code:s.room});
} else {
d=await api('host_open',{code:s.room,pass:s.pass});
hostPass=s.pass;
}
enterHostView(d.state,s); return true;
} else if(s.role==='player'){
// rejoin: server keeps the player row, just re-enter view
const d=await api('state',{code:s.room},'GET');
if(!d.state.players[s.pkey]) throw new Error('not found');
role='player'; room=s.room; pkey=s.pkey; name=s.name;
show('lobby',false); show('hostView',false); show('playerView',true); showChatWidget(true);
$('pRoom').textContent=room; $('pName').textContent=name;
render(d.state); startPoll(); return true;
}
}catch(e){ sessionStorage.removeItem('bsb_session'); }
return false;
}
// ── Offene Lobbys (Join-Screen) ──
async function loadLobbies(){
const wrap=$('lobbyList'); if(!wrap) return;
try{
const r=await fetch('/api/active_rooms'); const d=await r.json();
const rooms=(d&&d.rooms)||[];
if(!rooms.length){ wrap.innerHTML='<p class="lobby-empty">Gerade keine offenen Lobbys – starte selbst eine! 🐑</p>'; return; }
wrap.innerHTML=rooms.map(lo=>`<button type="button" class="lobby-item" onclick="App.pickLobby('${esc(String(lo.code))}')">
<span class="lobby-item-code">${esc(String(lo.code))}</span>
<span class="lobby-item-meta">${parseInt(lo.players)||0} 🐑 · Runde ${parseInt(lo.round_num)||1}${parseInt(lo.voting_open)?' · Voting läuft':''}</span>
</button>`).join('');
}catch(e){}
}
function pickLobby(code){ lobbyTab('join'); $('joinCode').value=code; const n=$('joinName'); if(n) n.focus(); }
initAuth().then(()=>{ tryRestoreSession(); loadAssets(); });
loadLobbies();
setInterval(()=>{ const l=$('lobby'); if(l && !l.classList.contains('hidden')) loadLobbies(); }, 5000);
// Soundboard-Lautstärkeregler (persistiert in localStorage)
(function(){
const sv=$('soundVol'), lbl=$('soundVolVal'); if(!sv) return;
sv.value=Math.round(soundVolume*100); if(lbl) lbl.textContent=sv.value+'%';
sv.addEventListener('input',()=>{ soundVolume=sv.value/100; try{ localStorage.setItem('bsb_sound_vol',String(soundVolume)); }catch(_){}
if(lbl) lbl.textContent=sv.value+'%'; });
})();
return {
hostOpen, playerJoin, submitAnswer, withdrawAnswer, removePlayer, score,
reveal, revealAnswer, revealQuestions, revealNext, openVoting, resolveRound, newRound, resetScores, deleteRoom,
leave, logout, assignQuestions, deleteAnswer, saveWeights,
toggleImposter, randomImposters, clearImposters, sendReaction, sendSticker, sendStickerGlobal, toggleSound, sendSound,
toggleVoteCheck, lockVote, requestVoting, sendChat, adminSpectate,
toggleChat, toggleEmojiPicker, toggleGifPanel, insertEmoji, gifSearchDebounced, sendGif, lobbyTab, pickLobby
};
})();
/* ── Fake-Werbung: pollt aktive Joke-Anzeigen und rotiert sie ── */
(function(){
let ads=[];
const q=u=>String(u==null?'':u).replace(/"/g,'%22');
function pick(){ return ads.length?ads[Math.floor(Math.random()*ads.length)]:null; }
function renderOne(elId){
const el=document.getElementById(elId); if(!el) return;
const a=pick();
if(!a){ el.classList.add('hidden'); el.innerHTML=''; return; }
const inner='<span class="ad-tag">Anzeige</span>'+
'<img src="'+q(a.image_url)+'" alt="Werbung" onerror="this.closest(\'.fake-ad\').classList.add(\'hidden\')">';
el.innerHTML = a.target_url ? '<a href="'+q(a.target_url)+'" target="_blank" rel="noopener nofollow">'+inner+'</a>' : inner;
el.classList.remove('hidden');
}
async function load(){
try{ const r=await fetch('/api/fake_ads'); const d=await r.json(); ads=(d&&d.ads)||[]; }catch(e){ ads=[]; }
renderOne('fakeAdLeft'); renderOne('fakeAdRight');
}
load(); setInterval(load, 20000);
})();