diff --git a/src/main.js b/src/main.js
index 8b0bccc..b7cbe4f 100644
--- a/src/main.js
+++ b/src/main.js
@@ -6,11 +6,16 @@
* (Vanilla-Start, Microsoft-Login und Mod-Loader folgen in späteren Phasen.)
*/
-const { app, BrowserWindow, ipcMain, dialog, shell, safeStorage, Notification, Tray, Menu, nativeImage, clipboard, desktopCapturer, session, screen } = require('electron');
+const { app, BrowserWindow, ipcMain, dialog, shell, safeStorage, Notification, Tray, Menu, nativeImage, clipboard, desktopCapturer, session, screen, globalShortcut } = require('electron');
const path = require('path');
const fs = require('fs');
const os = require('os');
const { execFile, spawn } = require('child_process');
+// Statisches ffmpeg-Binary für die Umwandlung der Spielaufzeichnung nach MP4
+// (siehe recording:save) - liefert null, falls kein Binary für diese
+// Plattform/Architektur vorliegt (dann bleibt die Aufnahme als .webm erhalten)
+let ffmpegPfad = null;
+try { ffmpegPfad = require('ffmpeg-static'); } catch { /* egal, siehe Rückfall in recording:save */ }
const pkg = require('../package.json');
const store = require('./store');
const services = require('./services');
@@ -33,6 +38,7 @@ const skins = require('./skins');
const servers = require('./servers');
const mcping = require('./mcping');
const discordpresence = require('./discordpresence');
+const friends = require('./friends');
// undici als globales fetch verwenden -> ermöglicht Proxy via setGlobalDispatcher
const undici = require('undici');
@@ -111,6 +117,7 @@ const POPOUT_SPEC = {
instance: { title: 'AeroMC – Instanz', width: 640, height: 760, minWidth: 520, minHeight: 500 },
update: { title: 'AeroMC – Update', width: 460, height: 460, minWidth: 420, minHeight: 380 },
record: { title: 'AeroMC – Spielaufzeichnung', width: 960, height: 800, minWidth: 640, minHeight: 560 },
+ friends: { title: 'AeroMC – Freunde', width: 420, height: 560, minWidth: 360, minHeight: 420 },
};
const POPOUT_DEFAULT = { title: 'AeroMC', width: 860, height: 680, minWidth: 640, minHeight: 480 };
let pendingUpdateInfo = null; // letztes Ergebnis von update:check/checkForUpdate, für Update-Popup
@@ -204,6 +211,10 @@ const VERBINDUNGS_ZEILE = /Connecting to ([^,]+),\s*(\d+)/i;
ipcMain.handle('recording:getServer', (_e, id) => letzteQuickPlayServer.get(id) || null);
const laufendePid = new Map(); // instanceId -> pid des zuletzt gestarteten Minecraft-Prozesses
+const kontoPid = new Map(); // kontoId -> pid, für den Ingame-Toast: der muss auf DEM Fenster
+// des prüfenden Kontos erscheinen, nicht auf irgendeinem laufenden Minecraft-Fenster
+// (sonst sieht z. B. M_Viper eine Meldung über sich selbst, weil zufällig sein
+// Fenster zuerst gefunden wurde, obwohl Electric__Max der Freund war, der geprüft hat)
ipcMain.handle('recording:getPid', (_e, id) => laufendePid.get(id) || null);
// Welche Bildschirmquelle als Nächstes über getDisplayMedia erfasst werden
@@ -329,19 +340,61 @@ function aufzeichnungsOrdner(instanceName) {
String(instanceName || 'Instanz').replace(/[^\w.-]+/g, '_'));
}
-ipcMain.handle('recording:save', async (_e, instanceName, buffer, serverLabel) => {
+// Aufnahme kommt vom MediaRecorder als WebM - für Abspielbarkeit in
+// praktisch jedem Player (Windows Media Player, Smart-TVs, Handys usw.) wird
+// direkt nach dem Speichern per ffmpeg in eine MP4-Datei (H.264 + AAC)
+// umgewandelt, das temporäre WebM danach gelöscht.
+//
+// -r erzwingt eine SAUBERE, konstante Bildrate im Ausgabevideo: die
+// Aufnahme kommt aus einer Canvas-Zeichenschleife (für Zuschnitt/Skalierung,
+// siehe erzeugeSkaliertenStream im Renderer) und deren Bild-Zeitstempel sind
+// nicht perfekt gleichmäßig - ohne -r übernimmt ffmpeg diese unregelmäßigen
+// Zeitstempel unverändert, was zu einer falschen/kaputten Bildrate im
+// Ausgabevideo führt (z. B. fälschlich "1000fps" laut ffprobe) und manche
+// Player die Datei gar nicht erst abspielen lässt.
+function wandleInMp4Um(quellDatei, zielDatei, fps) {
+ return new Promise((resolve, reject) => {
+ execFile(ffmpegPfad, [
+ '-y', '-i', quellDatei,
+ '-r', String(fps || 30), '-vsync', 'cfr',
+ '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '20', '-pix_fmt', 'yuv420p',
+ '-c:a', 'aac', '-b:a', '192k',
+ zielDatei,
+ ], (err, _stdout, stderr) => {
+ if (err) reject(new Error(stderr ? String(stderr).split('\n').slice(-5).join(' ') : err.message));
+ else resolve();
+ });
+ });
+}
+
+ipcMain.handle('recording:save', async (_e, instanceName, buffer, serverLabel, fps) => {
+ let tempDatei = null;
try {
const zielOrdner = aufzeichnungsOrdner(instanceName);
fs.mkdirSync(zielOrdner, { recursive: true });
const zeitstempel = new Date().toISOString().replace(/[:T]/g, '-').slice(0, 16);
const serverTeil = serverLabel ? String(serverLabel).replace(/[^\w.-]+/g, '_') + '_' : '';
- let zielDatei = path.join(zielOrdner, `${serverTeil}${zeitstempel}.webm`);
+ let zielDatei = path.join(zielOrdner, `${serverTeil}${zeitstempel}.mp4`);
let n = 2;
- while (fs.existsSync(zielDatei)) { zielDatei = path.join(zielOrdner, `${serverTeil}${zeitstempel}_${n}.webm`); n++; }
- fs.writeFileSync(zielDatei, Buffer.from(buffer));
+ while (fs.existsSync(zielDatei)) { zielDatei = path.join(zielOrdner, `${serverTeil}${zeitstempel}_${n}.mp4`); n++; }
+
+ tempDatei = zielDatei.slice(0, -4) + '.webm.tmp';
+ fs.writeFileSync(tempDatei, Buffer.from(buffer));
+
+ if (ffmpegPfad) {
+ await wandleInMp4Um(tempDatei, zielDatei, fps);
+ fs.rmSync(tempDatei, { force: true });
+ } else {
+ // ffmpeg fehlt (sollte nur in einer kaputten Installation vorkommen) -
+ // wenigstens das unveränderte WebM behalten statt die Aufnahme zu verlieren
+ zielDatei = zielDatei.slice(0, -4) + '.webm';
+ fs.renameSync(tempDatei, zielDatei);
+ }
+
notify('Aufzeichnung gespeichert', `${instanceName}: ${path.basename(zielDatei)}`);
return { ok: true, path: zielDatei };
} catch (err) {
+ if (tempDatei) fs.rmSync(tempDatei, { force: true });
return { ok: false, message: 'Speichern fehlgeschlagen: ' + err.message };
}
});
@@ -353,6 +406,57 @@ ipcMain.handle('recording:openFolder', (_e, instanceName) => {
return true;
});
+// ---------- Aufzeichnungen-Galerie ----------
+
+ipcMain.handle('recording:list', (_e, instanceName) => {
+ const ordner = aufzeichnungsOrdner(instanceName);
+ try {
+ return fs.readdirSync(ordner)
+ .filter((name) => name.toLowerCase().endsWith('.mp4'))
+ .map((name) => {
+ const stat = fs.statSync(path.join(ordner, name));
+ return { name, size: stat.size, mtimeMs: stat.mtimeMs };
+ })
+ .sort((a, b) => b.mtimeMs - a.mtimeMs);
+ } catch { return []; }
+});
+
+ipcMain.handle('recording:thumbnail', async (_e, instanceName, dateiname) => {
+ if (!ffmpegPfad) return null;
+ const ordner = aufzeichnungsOrdner(instanceName);
+ const quelle = path.join(ordner, dateiname);
+ if (!fs.existsSync(quelle)) return null;
+ const cacheOrdner = path.join(ordner, '.thumbnails');
+ const cacheDatei = path.join(cacheOrdner, dateiname + '.jpg');
+ if (!fs.existsSync(cacheDatei)) {
+ fs.mkdirSync(cacheOrdner, { recursive: true });
+ await new Promise((resolve) => {
+ // Erster Versuch bei 1s (überspringt oft ein schwarzes/leeres Startbild),
+ // Fehler wird ignoriert - dann bleibt einfach kein Vorschaubild
+ execFile(ffmpegPfad, ['-y', '-ss', '00:00:01', '-i', quelle, '-frames:v', '1', '-vf', 'scale=240:-1', cacheDatei], () => resolve());
+ });
+ }
+ try {
+ if (!fs.existsSync(cacheDatei)) return null;
+ return 'data:image/jpeg;base64,' + fs.readFileSync(cacheDatei).toString('base64');
+ } catch { return null; }
+});
+
+ipcMain.handle('recording:delete', (_e, instanceName, dateiname) => {
+ const ordner = aufzeichnungsOrdner(instanceName);
+ try {
+ fs.rmSync(path.join(ordner, dateiname), { force: true });
+ fs.rmSync(path.join(ordner, '.thumbnails', dateiname + '.jpg'), { force: true });
+ return true;
+ } catch { return false; }
+});
+
+ipcMain.handle('recording:open', (_e, instanceName, dateiname) => {
+ const ziel = path.join(aufzeichnungsOrdner(instanceName), dateiname);
+ if (fs.existsSync(ziel)) shell.openPath(ziel);
+ return true;
+});
+
// ---------------------------------------------------------------------------
// Verknüpfungen: "AeroMC.exe --launch " startet eine Instanz direkt
// ---------------------------------------------------------------------------
@@ -609,6 +713,16 @@ app.whenReady().then(() => {
setTimeout(() => { backupNachZeitplan('zeitplan').catch(() => {}); }, 60000);
setInterval(() => { backupNachZeitplan('zeitplan').catch(() => {}); }, 3600000);
+ // Freundesystem: alle 60s im Hintergrund prüfen, ob ein Freund neu online
+ // gegangen ist -> Windows-Meldung. Der erste Durchlauf legt nur die
+ // Vergleichsbasis an (noch keine Meldung, sonst würde jeder schon online
+ // befindliche Freund beim Start fälschlich als "gerade online gegangen" gelten).
+ setTimeout(() => { pruefeFreundeOnline().catch(() => {}); }, 15000);
+ setInterval(() => { pruefeFreundeOnline().catch(() => {}); }, 60000);
+ // Zahl offener Freundschaftsanfragen für den "Freunde"-Knopf
+ setTimeout(() => { aktualisiereAnfragenZahl().catch(() => {}); }, 3000);
+ setInterval(() => { aktualisiereAnfragenZahl().catch(() => {}); }, 60000);
+
// automatisch auf Updates prüfen (kurz nach dem Start)
setTimeout(async () => {
try {
@@ -646,6 +760,7 @@ app.on('window-all-closed', () => {
});
app.on('before-quit', () => { appIsQuitting = true; discordpresence.shutdown(); });
+app.on('will-quit', () => { globalShortcut.unregisterAll(); });
// ---------------------------------------------------------------------------
// Java-Erkennung (für Anzeige in den Einstellungen)
@@ -674,6 +789,10 @@ ipcMain.handle('settings:save', (_e, patch) => {
applyProxy(s);
if (patch && Object.prototype.hasOwnProperty.call(patch, 'autostart')) applyAutostart(s.autostart);
if (patch && Object.prototype.hasOwnProperty.call(patch, 'discordClientId')) discordpresence.configure(s);
+ if (patch && Object.prototype.hasOwnProperty.call(patch, 'friendsEnabled')) {
+ aktualisiereFreundeTastenkuerzel();
+ aktualisiereAnfragenZahl().catch(() => {});
+ }
// Einstellungen können jetzt auch aus dem Popup-Fenster gespeichert werden –
// das Hauptfenster muss Theme/Sortierung/Bedrock-Sichtbarkeit/Skin-Hintergrund
// dann selbst nachziehen. NICHT bei der beiläufigen "letzte Instanz"-Notiz
@@ -1136,7 +1255,18 @@ ipcMain.handle('auth:recheck', () => checkAuthServices());
// "playing" kommt aus den tatsächlich laufenden Spielen, nicht aus dem Aktiv-Merkmal
ipcMain.handle('auth:accounts', () => auth.listAccounts()
.map((a) => Object.assign({}, a, { playing: spielendeKonten.has(a.id) })));
-ipcMain.handle('auth:setActive', (_e, id) => auth.setActive(id));
+ipcMain.handle('auth:setActive', (_e, id) => {
+ const res = auth.setActive(id);
+ // Ohne das hier bleibt z. B. ein separates Konten- oder Aufzeichnungs-
+ // Fenster (eigener Renderer-Prozess, siehe cross-window state) auf dem
+ // alten Konto stehen, bis irgendein anderes Ereignis zufällig ein Neuladen
+ // auslöst - der Listener auf 'accounts:changed' existiert im Renderer
+ // schon, wurde von hier nur nie ausgelöst.
+ broadcast('accounts:changed');
+ // Anfragen-Zahl am "Freunde"-Knopf gilt für das aktive Konto
+ aktualisiereAnfragenZahl().catch(() => {});
+ return res;
+});
// ---- Skin des aktiven Kontos ----
@@ -1197,6 +1327,294 @@ ipcMain.handle('skin:reset', async () => {
ipcMain.handle('auth:remove', (_e, id) => auth.removeAccount(id));
ipcMain.handle('auth:logout', () => { auth.clearAccount(); return true; });
+// ---------- Freundesystem ----------
+// Nutzt immer das aktive Konto (gleiche Quelle wie discordpresence/die
+// "spielt gerade"-Anzeige: auth.currentAccount().profile.{id,name}) - keine
+// eigene Anmeldung nötig.
+
+// Findet DAS Minecraft-Fenster des angegebenen Prozesses (pid) - wichtig,
+// damit der Ingame-Toast auf dem Bildschirm des prüfenden Kontos erscheint,
+// nicht zufällig auf dem eines anderen laufenden Kontos (bei zwei Konten
+// über denselben Launcher gäbe es sonst z. B. eine Meldung über M_Viper
+// selbst, angezeigt auf M_Vipers eigenem Fenster).
+//
+// node-window-manager erkennt ein gerade laufendes Fenster manchmal nicht
+// beim allerersten Abfragen (z. B. Spiel lädt noch, kurz minimiert) - deshalb
+// mehrere Versuche mit kurzer Pause. Wird das Fenster DIESER PID trotzdem
+// nicht gefunden, wird bewusst auf kein anderes Fenster ausgewichen - lieber
+// keine Meldung als eine beim falschen Spieler.
+async function findeMinecraftFenster(pid) {
+ if (!pid) return null;
+ let windowManager;
+ try { ({ windowManager } = require('node-window-manager')); } catch { return null; }
+ for (let versuch = 1; versuch <= 4; versuch++) {
+ let alleFenster;
+ try { alleFenster = windowManager.getWindows(); } catch { alleFenster = []; }
+ const treffer = alleFenster.find((w) => w.processId === pid);
+ if (treffer) return treffer;
+ if (versuch < 4) await new Promise((r) => setTimeout(r, 300));
+ }
+ return null;
+}
+
+// pid -> Anzahl gerade sichtbarer Toasts auf diesem Fenster (zum Stapeln,
+// falls mehrere Freunde im selben Durchlauf gemeldet werden)
+const toastsProFenster = new Map();
+
+// 3D-Spielerkopf (isometrischer Würfel, gleiche Quelle wie im Freunde-Dialog)
+// als data:-URI - vorab im Hauptprozess geladen und eingebettet, damit der
+// Kopf schon beim Erscheinen des Toasts da ist statt nachzuladen. Pro uuid
+// zwischengespeichert; bei Fehler/Zeitüberschreitung einfach ohne Kopf.
+const spielerKopfCache = new Map();
+async function spielerKopf(uuid) {
+ if (!uuid) return null;
+ if (spielerKopfCache.has(uuid)) return spielerKopfCache.get(uuid);
+ const abbruch = new AbortController();
+ const zeitgeber = setTimeout(() => abbruch.abort(), 3000);
+ try {
+ const res = await fetch(`https://crafthead.net/cube/${encodeURIComponent(uuid)}/64`, { signal: abbruch.signal });
+ if (!res.ok) return null;
+ const uri = 'data:image/png;base64,' + Buffer.from(await res.arrayBuffer()).toString('base64');
+ spielerKopfCache.set(uuid, uri);
+ return uri;
+ } catch {
+ return null;
+ } finally {
+ clearTimeout(zeitgeber);
+ }
+}
+
+// Kleiner, durchsichtiger Toast oben rechts auf dem Minecraft-Fenster (wie
+// Discords Ingame-Overlay), bewusst OHNE Windows-Meldung als Rückfall -
+// stiehlt nie den Fokus (showInactive + focusable:false), damit das Spiel
+// nicht gestört wird. Jeder Toast ist ein eigenes Fenster, damit zwei
+// gleichzeitig laufende Konten jeweils ihre eigene Meldung bekommen.
+// Liefert true, wenn der Toast angezeigt wurde. `text` ist eine Zeile oder
+// eine Liste von Zeilen; eine Zeile ist entweder Text oder { uuid, text } -
+// dann steht der 3D-Spielerkopf davor.
+async function zeigeIngameOverlay(titel, text, pid, dauerMs = 6000) {
+ const fenster = await findeMinecraftFenster(pid);
+ if (!fenster) return false;
+ const bounds = fenster.getBounds();
+
+ const zeilen = await Promise.all((Array.isArray(text) ? text : [text]).map(async (z) => {
+ if (typeof z === 'string') return { text: z, kopf: null };
+ return { text: z.text, kopf: await spielerKopf(z.uuid) };
+ }));
+ const breite = 320;
+ const hoehe = 44 + zeilen.reduce((summe, z) => summe + (z.kopf ? 24 : 18), 0);
+ const stapel = toastsProFenster.get(pid) || 0;
+ toastsProFenster.set(pid, stapel + 1);
+ const overlayFenster = new BrowserWindow({
+ x: Math.round(bounds.x + bounds.width - breite - 24),
+ y: Math.round(bounds.y + 24 + stapel * (hoehe + 8)),
+ width: breite,
+ height: hoehe,
+ frame: false,
+ transparent: true,
+ alwaysOnTop: true,
+ skipTaskbar: true,
+ focusable: false,
+ resizable: false,
+ hasShadow: false,
+ show: false,
+ webPreferences: { contextIsolation: true, sandbox: true },
+ });
+ overlayFenster.setIgnoreMouseEvents(true);
+ overlayFenster.setAlwaysOnTop(true, 'screen-saver');
+
+ const esc = (s) => String(s).replace(/[&<>"']/g, (c) => ({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' }[c]));
+ // charset=utf-8 nicht vergessen: ohne das interpretiert Chromium die
+ // data:-URL mit einer anderen Kodierung, wodurch z. B. "·" als "·"
+ // dargestellt wird (klassisches UTF-8/Latin-1-Mojibake)
+ const html = `data:text/html;charset=utf-8,${encodeURIComponent(`
+ ![]()
▶
+ }/64)
+
+
+ `;
+ row.querySelector('.friend-avatar').addEventListener('error', function () { this.remove(); });
+ row.querySelector('[data-act="accept"]').addEventListener('click', async () => {
+ await window.api.friendsRespond(r.uuid, true);
+ ladeFreunde();
+ });
+ row.querySelector('[data-act="decline"]').addEventListener('click', async () => {
+ await window.api.friendsRespond(r.uuid, false);
+ ladeFreunde();
+ });
+ reqBox.appendChild(row);
+ }
+ }
+ if (gesendetRes.ok && gesendetRes.list.length) {
+ const titel = document.createElement('div');
+ titel.className = 'friends-section-title';
+ titel.textContent = 'Gesendet';
+ reqBox.appendChild(titel);
+ for (const r of gesendetRes.list) {
+ const row = document.createElement('div');
+ row.className = 'friend-row';
+ row.innerHTML = `
+
+ `;
+ row.querySelector('.friend-avatar').addEventListener('error', function () { this.remove(); });
+ row.querySelector('[data-act="cancel"]').addEventListener('click', async () => {
+ await window.api.friendsCancel(r.uuid);
+ ladeFreunde();
+ });
+ reqBox.appendChild(row);
+ }
+ }
+
+ const listBox = el('friends-list-box');
+ listBox.innerHTML = '}/64)
+
+
+ `;
+ row.querySelector('.friend-avatar').addEventListener('error', function () { this.remove(); });
+ row.querySelector('[data-act="nick"]').addEventListener('click', async () => {
+ const wert = await askPrompt({
+ title: 'Spitzname',
+ label: `Eigener Spitzname für ${f.username || f.uuid} (leer lassen zum Entfernen)`,
+ value: spitznamen[f.uuid] || '',
+ okLabel: 'Speichern',
+ });
+ if (wert === null) return; // Abgebrochen
+ await window.api.friendsSetNickname(f.uuid, wert.trim());
+ ladeFreunde();
+ });
+ row.querySelector('[data-act="remove"]').addEventListener('click', () => {
+ askConfirm('Freund entfernen', `„${anzeigeName}" aus der Freundesliste entfernen?`, '🗑 Entfernen', async () => {
+ await window.api.friendsRemove(f.uuid);
+ ladeFreunde();
+ });
+ });
+ listBox.appendChild(row);
+ }
+}
+
+async function sendeFreundschaftsanfrage() {
+ const input = el('friends-add-input');
+ const name = input.value.trim();
+ if (!name) return;
+ const res = await window.api.friendsAdd(name);
+ if (res.ok) {
+ toast('Anfrage gesendet.');
+ input.value = '';
+ ladeFreunde();
+ } else {
+ toast(res.message || 'Anfrage fehlgeschlagen.', true);
+ }
+}
+
function renderContentList(boxId, items, sub, emoji) {
const box = el(boxId);
box.innerHTML = '';
@@ -3846,6 +4118,7 @@ async function openSettings(pane) {
el('s-iso3d').checked = s.iso3dIcons !== false;
el('s-bedrock').checked = s.bedrockEnabled !== false;
el('s-notify').checked = s.desktopNotifications !== false;
+ el('s-friends').checked = s.friendsEnabled !== false;
el('s-autostart').checked = !!s.autostart;
el('s-auto-java').checked = s.autoJava !== false;
el('s-autobackup').checked = !!s.autoBackupEnabled;
@@ -3974,6 +4247,7 @@ async function saveSettings() {
iso3dIcons: el('s-iso3d').checked,
bedrockEnabled: el('s-bedrock').checked,
desktopNotifications: el('s-notify').checked,
+ friendsEnabled: el('s-friends').checked,
autostart: el('s-autostart').checked,
autoJava: el('s-auto-java').checked,
autoBackupEnabled: el('s-autobackup').checked,
@@ -4629,6 +4903,16 @@ function wire() {
document.querySelectorAll('.btab').forEach((t) =>
t.addEventListener('click', () => switchBedrockTab(t.dataset.kind)));
+ // Freunde
+ el('btn-friends').addEventListener('click', openFriends);
+ el('friends-add-btn').addEventListener('click', sendeFreundschaftsanfrage);
+ el('friends-add-input').addEventListener('keydown', (e) => {
+ if (e.key === 'Enter') sendeFreundschaftsanfrage();
+ });
+ new MutationObserver(() => {
+ if (el('modal-friends').classList.contains('hidden')) { clearInterval(friendsAutoRefresh); friendsAutoRefresh = null; }
+ }).observe(el('modal-friends'), { attributes: true, attributeFilter: ['class'] });
+
// Konsole
el('btn-console').addEventListener('click', openConsole);
el('console-clear').addEventListener('click', () => { consoleBuffer = ''; el('console-out').textContent = ''; });
@@ -4846,7 +5130,14 @@ function wire() {
// Ordner-Buttons in den Inhalte-/Screenshots-Dialogen
el('content-open-worlds').addEventListener('click', () => window.api.openSubdir(currentDetailId, 'saves'));
el('content-open-rp').addEventListener('click', () => window.api.openSubdir(currentDetailId, 'resourcepacks'));
- el('screens-open').addEventListener('click', () => window.api.openSubdir(currentDetailId, 'screenshots'));
+ el('screens-open').addEventListener('click', async () => {
+ if (screensAktiverTab === 'records') {
+ const inst = await window.api.getInstance(currentDetailId);
+ if (inst) window.api.recordingOpenFolder(inst.name);
+ } else {
+ window.api.openSubdir(currentDetailId, 'screenshots');
+ }
+ });
el('screens-select-all').addEventListener('click', () => {
document.querySelectorAll('#screens-grid .screen-thumb').forEach((t) => {
if (t.dataset.name) screenSelected.add(t.dataset.name);
@@ -4858,6 +5149,19 @@ function wire() {
updateScreensSelectionUi();
});
el('screens-delete-sel').addEventListener('click', () => deleteSelectedScreenshots());
+ el('screens-tab-photos').addEventListener('click', () => switchScreensTab('photos'));
+ el('screens-tab-records').addEventListener('click', () => switchScreensTab('records'));
+ el('records-select-all').addEventListener('click', () => {
+ document.querySelectorAll('#records-grid .screen-thumb').forEach((t) => {
+ if (t.dataset.name) recordSelected.add(t.dataset.name);
+ });
+ updateRecordsSelectionUi();
+ });
+ el('records-select-none').addEventListener('click', () => {
+ recordSelected.clear();
+ updateRecordsSelectionUi();
+ });
+ el('records-delete-sel').addEventListener('click', () => deleteSelectedRecords());
el('content-open-dp').addEventListener('click', () => window.api.openSubdir(currentDetailId, 'datapacks'));
// Mod-Dialog
@@ -5172,6 +5476,7 @@ const POPOUT_OPENERS = {
}
},
record: () => openRecording(),
+ friends: () => openFriends(),
};
function popoutBoot(params) {
@@ -5209,7 +5514,22 @@ window.addEventListener('DOMContentLoaded', async () => {
applyTheme(s.theme);
iso3dEnabled = s.iso3dIcons !== false;
consoleMaxChars = Math.max(50000, (s.consoleMaxLines || 100000) * 3);
+ el('btn-friends').classList.toggle('hidden', s.friendsEnabled === false);
} catch { applyTheme('dark'); }
+ // Zahl offener Freundschaftsanfragen am "Freunde"-Knopf (nur Hauptfenster
+ // zeigt die Werkzeugleiste)
+ if (!POPOUT) {
+ const zeigeAnfragenZahl = (zahl) => {
+ const badge = el('friends-badge');
+ badge.textContent = zahl > 99 ? '99+' : String(zahl);
+ badge.classList.toggle('hidden', !zahl);
+ el('btn-friends').title = zahl
+ ? `Freunde – ${zahl} offene Anfrage${zahl === 1 ? '' : 'n'} (ingame: Strg+Alt+F zeigt, wer online ist)`
+ : 'Freunde (ingame: Strg+Alt+F zeigt, wer online ist)';
+ };
+ window.api.onFriendsRequestCount(zeigeAnfragenZahl);
+ window.api.friendsRequestCount().then(zeigeAnfragenZahl).catch(() => {});
+ }
await refreshSkinBackground();
window.api.onLaunchProgress(onLaunchEvt);
// Servername live in den Titel nachtragen, falls das Aufzeichnungs-Fenster
@@ -5221,8 +5541,14 @@ window.addEventListener('DOMContentLoaded', async () => {
window.api.onAuthCode(onAuthCode);
window.api.onAuthRefreshed(async () => { await refreshAccountButton(); await refreshSkinBackground(); });
window.api.onAuthHealth(showAuthHealth);
- // Spiel gestartet oder beendet -> "spielt gerade" in den Kontenlisten nachziehen
- window.api.onAccountsChanged(() => { refreshAllAccountLists(); });
+ // Spiel gestartet/beendet ODER das aktive Konto in einem ANDEREN Fenster
+ // gewechselt (separater Renderer-Prozess, siehe cross-window state) ->
+ // Kontenlisten, Kopfzeile und Skin-Hintergrund hier ebenfalls nachziehen
+ window.api.onAccountsChanged(async () => {
+ await refreshAllAccountLists();
+ await refreshAccountButton();
+ await refreshSkinBackground();
+ });
// über eine Desktop-Verknüpfung gestartet -> Instanz auswählen und anwerfen
// (bei einer Server-Verknüpfung zusätzlich direkt mit dem Server verbinden)
window.api.onLaunchRequest(async (payload) => {
@@ -5247,7 +5573,12 @@ window.addEventListener('DOMContentLoaded', async () => {
window.api.onSettingsChanged((s) => {
applyTheme(s.theme);
iso3dEnabled = s.iso3dIcons !== false;
- if (!POPOUT) { applyBedrockVisibility(); refreshSkinBackground(); reload(); }
+ if (!POPOUT) {
+ applyBedrockVisibility();
+ refreshSkinBackground();
+ reload();
+ el('btn-friends').classList.toggle('hidden', s.friendsEnabled === false);
+ }
});
// Ein Skin-Wechsel oder eine neue/aktualisierte Instanz aus einem anderen
// Fenster (Skin-/Import-Popup) betrifft ebenfalls nur die Anzeige im
diff --git a/src/store.js b/src/store.js
index 486ac99..e834d5b 100644
--- a/src/store.js
+++ b/src/store.js
@@ -76,6 +76,8 @@ const DEFAULT_SETTINGS = {
iso3dIcons: true, // Block-Symbole räumlich darstellen
bedrockEnabled: true, // Bedrock-Bereich anzeigen (nur wenn auch installiert)
desktopNotifications: true, // Windows-Meldung bei fertigem Hintergrund-Download/-Backup
+ friendsEnabled: true, // Freundesystem: eigene Online-Meldung + auffindbar für Anfragen
+ friendNicknames: {}, // rein lokal: uuid -> eigener Spitzname für einen Freund
autostart: false, // mit Windows starten, im Infobereich statt als Fenster
discordClientId: '', // optional, nur per Hand in settings.json; leer => eingebaute AeroMC-App-ID
bgSkin: '', // '' = aus, 'active' = aktives Konto, sonst Konto-UUID
diff --git a/src/styles.css b/src/styles.css
index 2492ee0..995ca04 100644
--- a/src/styles.css
+++ b/src/styles.css
@@ -208,9 +208,13 @@ body.is-popout>header.toolbar,body.is-popout>main.workspace,body.is-popout>foote
#modal-record.popout-host .modal-body{display:flex;flex-direction:column}
.popout-host .console-out,
#modal-logs.popout-host .crash-voll,
-.popout-host .screens-grid,
.popout-host .mods-list,
.popout-host .record-stage{flex:1 1 auto;height:auto;max-height:none;min-height:0}
+/* Screenshots/Aufzeichnungen NICHT auf die volle Fensterhöhe zwingen (Grid-
+ Zeilen strecken sich sonst nicht mit, es bliebe bei wenigen Einträgen ein
+ großer sichtbar leerer Kasten stehen) - nur die feste 460px-Deckelung
+ aufheben, damit bei VIELEN Einträgen trotzdem mehr Platz genutzt wird */
+.popout-host .screens-grid{max-height:none}
/* Mods-Fenster: die aktive Ansicht (Katalog/Installiert) muss selbst ein
Flex-Container werden, damit ihre eigene Liste (.mods-list) die Regel oben
nutzen und den restlichen Platz füllen kann */
@@ -378,6 +382,25 @@ img.account-av{object-fit:cover;image-rendering:auto}
.screens-toolbar{display:flex;align-items:center;gap:8px;margin-bottom:10px;flex-wrap:wrap}
.screens-toolbar .hint{font-size:11px}
.screens-empty{color:var(--dim);text-align:center;padding:30px;grid-column:1/-1}
+.record-thumb-img-wrap{position:relative}
+.record-thumb-img-wrap img{background:#000}
+.record-thumb-play{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;color:#fff;font-size:22px;text-shadow:0 1px 4px rgba(0,0,0,.7);pointer-events:none}
+.record-thumb-size{font-size:10px;color:var(--dim);padding:0 6px 4px}
+
+/* Freunde */
+.tb-badge{display:inline-block;min-width:16px;height:16px;padding:0 4px;margin-left:6px;border-radius:8px;background:#d9453c;color:#fff;font-size:11px;font-weight:600;line-height:16px;text-align:center;box-sizing:border-box}
+#modal-friends .field-row{margin-bottom:14px}
+#modal-friends .field-row input{flex:1}
+.friends-section-title{font-size:11px;color:var(--dim);text-transform:uppercase;letter-spacing:.03em;margin:10px 0 6px}
+.friend-row{display:flex;align-items:center;gap:10px;padding:6px 4px;border-radius:3px}
+.friend-row:hover{background:var(--sel,rgba(0,0,0,.04))}
+.friend-dot{width:9px;height:9px;border-radius:50%;background:#8a8a8a;flex:0 0 auto}
+.friend-dot.online{background:#3bb54a}
+.friend-avatar{width:28px;height:28px;border-radius:4px;flex:0 0 auto;background:#1e1e1e;object-fit:contain}
+.friend-info{flex:1;min-width:0}
+.friend-name{font-size:13px}
+.friend-status{font-size:11px;color:var(--dim);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.friends-empty{color:var(--dim);font-size:12px;padding:8px 4px}
/* Spielaufzeichnung */
.record-search{display:flex;flex-direction:column;align-items:center;gap:10px;padding:48px 0;color:var(--dim)}
diff --git a/wordpress-plugin/aeromc-friends/aeromc-friends.php b/wordpress-plugin/aeromc-friends/aeromc-friends.php
new file mode 100644
index 0000000..59657c3
--- /dev/null
+++ b/wordpress-plugin/aeromc-friends/aeromc-friends.php
@@ -0,0 +1,56 @@
+get_charset_collate();
+ $presence_table = $wpdb->prefix . AEROMC_FRIENDS_PRESENCE_TABLE;
+ $friends_table = $wpdb->prefix . AEROMC_FRIENDS_FRIENDS_TABLE;
+
+ require_once ABSPATH . 'wp-admin/includes/upgrade.php';
+
+ // uuid ohne Bindestriche gespeichert (siehe aeromc_friends_normalize_uuid
+ // in includes/routes.php) - vermeidet doppelte Zeilen durch
+ // unterschiedliche Schreibweisen derselben UUID
+ $sql_presence = "CREATE TABLE $presence_table (
+ uuid varchar(32) NOT NULL,
+ username varchar(32) NOT NULL,
+ instance_name varchar(128) DEFAULT NULL,
+ server_label varchar(128) DEFAULT NULL,
+ last_seen datetime NOT NULL,
+ PRIMARY KEY (uuid)
+ ) $charset_collate;";
+ dbDelta($sql_presence);
+
+ $sql_friends = "CREATE TABLE $friends_table (
+ id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
+ uuid_a varchar(32) NOT NULL,
+ uuid_b varchar(32) NOT NULL,
+ status varchar(20) NOT NULL DEFAULT 'pending',
+ created_at datetime NOT NULL,
+ PRIMARY KEY (id),
+ KEY uuid_a (uuid_a),
+ KEY uuid_b (uuid_b)
+ ) $charset_collate;";
+ dbDelta($sql_friends);
+}
+register_activation_hook(__FILE__, 'aeromc_friends_install');
+
+require_once plugin_dir_path(__FILE__) . 'includes/routes.php';
diff --git a/wordpress-plugin/aeromc-friends/includes/routes.php b/wordpress-plugin/aeromc-friends/includes/routes.php
new file mode 100644
index 0000000..a66b765
--- /dev/null
+++ b/wordpress-plugin/aeromc-friends/includes/routes.php
@@ -0,0 +1,303 @@
+prepare, um SQL-Injection
+ * auszuschließen.
+ */
+
+if (!defined('ABSPATH')) {
+ exit;
+}
+
+// Konten gelten als "online", solange ihr letzter Herzschlag (der Launcher
+// sendet alle 60s einen) nicht älter als das hier ist.
+define('AEROMC_FRIENDS_ONLINE_SECONDS', 180);
+// Häufigere Herzschläge als das werden ignoriert (Schutz gegen Missbrauch/
+// versehentliche Anfrageflut) - der Launcher selbst sendet ohnehin nur alle 60s.
+define('AEROMC_FRIENDS_HEARTBEAT_MIN_GAP', 20);
+
+function aeromc_friends_presence_table() {
+ global $wpdb;
+ return $wpdb->prefix . AEROMC_FRIENDS_PRESENCE_TABLE;
+}
+
+function aeromc_friends_friends_table() {
+ global $wpdb;
+ return $wpdb->prefix . AEROMC_FRIENDS_FRIENDS_TABLE;
+}
+
+/** Minecraft-UUIDs kommen mal mit, mal ohne Bindestriche an - einheitlich
+ * ohne Bindestriche, klein geschrieben speichern/vergleichen. Gibt false
+ * zurück, wenn es keine gültige UUID (32 Hex-Zeichen) ist. */
+function aeromc_friends_normalize_uuid($uuid) {
+ $stripped = strtolower(str_replace('-', '', (string) $uuid));
+ if (!preg_match('/^[a-f0-9]{32}$/', $stripped)) {
+ return false;
+ }
+ return $stripped;
+}
+
+/** Minecraft-Namensregeln: 1-16 Zeichen, Buchstaben/Ziffern/Unterstrich. */
+function aeromc_friends_valid_username($name) {
+ return is_string($name) && preg_match('/^[A-Za-z0-9_]{1,16}$/', $name);
+}
+
+add_action('rest_api_init', function () {
+ register_rest_route('aeromc/v1', '/presence', [
+ 'methods' => 'POST',
+ 'callback' => 'aeromc_friends_route_presence',
+ 'permission_callback' => '__return_true',
+ ]);
+ register_rest_route('aeromc/v1', '/friends', [
+ 'methods' => 'GET',
+ 'callback' => 'aeromc_friends_route_list',
+ 'permission_callback' => '__return_true',
+ ]);
+ register_rest_route('aeromc/v1', '/friends/requests', [
+ 'methods' => 'GET',
+ 'callback' => 'aeromc_friends_route_requests',
+ 'permission_callback' => '__return_true',
+ ]);
+ register_rest_route('aeromc/v1', '/friends/sent', [
+ 'methods' => 'GET',
+ 'callback' => 'aeromc_friends_route_sent',
+ 'permission_callback' => '__return_true',
+ ]);
+ register_rest_route('aeromc/v1', '/friends/request', [
+ 'methods' => 'POST',
+ 'callback' => 'aeromc_friends_route_request',
+ 'permission_callback' => '__return_true',
+ ]);
+ register_rest_route('aeromc/v1', '/friends/respond', [
+ 'methods' => 'POST',
+ 'callback' => 'aeromc_friends_route_respond',
+ 'permission_callback' => '__return_true',
+ ]);
+ register_rest_route('aeromc/v1', '/friends/cancel', [
+ 'methods' => 'POST',
+ 'callback' => 'aeromc_friends_route_cancel',
+ 'permission_callback' => '__return_true',
+ ]);
+ register_rest_route('aeromc/v1', '/friends/remove', [
+ 'methods' => 'POST',
+ 'callback' => 'aeromc_friends_route_remove',
+ 'permission_callback' => '__return_true',
+ ]);
+});
+
+/** POST /presence {uuid, username, instance, server} */
+function aeromc_friends_route_presence($request) {
+ global $wpdb;
+ $uuid = aeromc_friends_normalize_uuid($request->get_param('uuid'));
+ $username = $request->get_param('username');
+ if (!$uuid || !aeromc_friends_valid_username($username)) {
+ return new WP_Error('aeromc_invalid', 'Ungültige uuid/username.', ['status' => 400]);
+ }
+ $instance = sanitize_text_field((string) $request->get_param('instance'));
+ $server = sanitize_text_field((string) $request->get_param('server'));
+ $table = aeromc_friends_presence_table();
+
+ $letzte = $wpdb->get_var($wpdb->prepare(
+ "SELECT last_seen FROM $table WHERE uuid = %s", $uuid
+ ));
+ if ($letzte && (time() - strtotime($letzte)) < AEROMC_FRIENDS_HEARTBEAT_MIN_GAP) {
+ return ['ok' => true]; // zu häufig - stillschweigend ignoriert
+ }
+
+ // current_time('mysql', true) statt current_time('mysql'): das zweite
+ // Argument erzwingt GMT/UTC. Ohne das liefert current_time() die an die
+ // WordPress-Zeitzone angepasste ORTSZEIT (Einstellungen > Allgemein) -
+ // das online/offline-Fenster unten vergleicht last_seen aber per
+ // strtotime()/time() als UTC, wodurch ein Freund bei abweichender
+ // Zeitzone praktisch nie als offline erkannt worden wäre.
+ $jetzt_utc = current_time('mysql', true);
+ $wpdb->query($wpdb->prepare(
+ "INSERT INTO $table (uuid, username, instance_name, server_label, last_seen)
+ VALUES (%s, %s, %s, %s, %s)
+ ON DUPLICATE KEY UPDATE username = %s, instance_name = %s, server_label = %s, last_seen = %s",
+ $uuid, $username, $instance ?: null, $server ?: null, $jetzt_utc,
+ $username, $instance ?: null, $server ?: null, $jetzt_utc
+ ));
+ return ['ok' => true];
+}
+
+/** GET /friends?uuid= - akzeptierte Freunde inkl. Online-Status */
+function aeromc_friends_route_list($request) {
+ global $wpdb;
+ $uuid = aeromc_friends_normalize_uuid($request->get_param('uuid'));
+ if (!$uuid) {
+ return new WP_Error('aeromc_invalid', 'Ungültige uuid.', ['status' => 400]);
+ }
+ $friends_table = aeromc_friends_friends_table();
+ $presence_table = aeromc_friends_presence_table();
+
+ $rows = $wpdb->get_results($wpdb->prepare(
+ "SELECT IF(f.uuid_a = %s, f.uuid_b, f.uuid_a) AS other_uuid
+ FROM $friends_table f
+ WHERE (f.uuid_a = %s OR f.uuid_b = %s) AND f.status = 'accepted'",
+ $uuid, $uuid, $uuid
+ ));
+
+ $ergebnis = [];
+ foreach ($rows as $row) {
+ $p = $wpdb->get_row($wpdb->prepare(
+ "SELECT username, instance_name, server_label, last_seen FROM $presence_table WHERE uuid = %s",
+ $row->other_uuid
+ ));
+ $online = $p && (time() - strtotime($p->last_seen)) < AEROMC_FRIENDS_ONLINE_SECONDS;
+ $ergebnis[] = [
+ 'uuid' => $row->other_uuid,
+ 'username' => $p ? $p->username : null,
+ 'online' => (bool) $online,
+ 'instance' => $online ? $p->instance_name : null,
+ 'server' => $online ? $p->server_label : null,
+ ];
+ }
+ return $ergebnis;
+}
+
+/** GET /friends/requests?uuid= - offene, an mich gerichtete Anfragen */
+function aeromc_friends_route_requests($request) {
+ global $wpdb;
+ $uuid = aeromc_friends_normalize_uuid($request->get_param('uuid'));
+ if (!$uuid) {
+ return new WP_Error('aeromc_invalid', 'Ungültige uuid.', ['status' => 400]);
+ }
+ $friends_table = aeromc_friends_friends_table();
+ $presence_table = aeromc_friends_presence_table();
+
+ $rows = $wpdb->get_results($wpdb->prepare(
+ "SELECT f.uuid_a AS from_uuid, p.username AS from_username
+ FROM $friends_table f
+ LEFT JOIN $presence_table p ON p.uuid = f.uuid_a
+ WHERE f.uuid_b = %s AND f.status = 'pending'",
+ $uuid
+ ));
+ return array_map(function ($r) {
+ return ['uuid' => $r->from_uuid, 'username' => $r->from_username];
+ }, $rows);
+}
+
+/** GET /friends/sent?uuid= - offene, von mir SELBST gesendete Anfragen */
+function aeromc_friends_route_sent($request) {
+ global $wpdb;
+ $uuid = aeromc_friends_normalize_uuid($request->get_param('uuid'));
+ if (!$uuid) {
+ return new WP_Error('aeromc_invalid', 'Ungültige uuid.', ['status' => 400]);
+ }
+ $friends_table = aeromc_friends_friends_table();
+ $presence_table = aeromc_friends_presence_table();
+
+ $rows = $wpdb->get_results($wpdb->prepare(
+ "SELECT f.uuid_b AS to_uuid, p.username AS to_username
+ FROM $friends_table f
+ LEFT JOIN $presence_table p ON p.uuid = f.uuid_b
+ WHERE f.uuid_a = %s AND f.status = 'pending'",
+ $uuid
+ ));
+ return array_map(function ($r) {
+ return ['uuid' => $r->to_uuid, 'username' => $r->to_username];
+ }, $rows);
+}
+
+/** POST /friends/request {uuid, username, targetUsername} */
+function aeromc_friends_route_request($request) {
+ global $wpdb;
+ $uuid = aeromc_friends_normalize_uuid($request->get_param('uuid'));
+ $targetUsername = $request->get_param('targetUsername');
+ if (!$uuid || !aeromc_friends_valid_username($targetUsername)) {
+ return new WP_Error('aeromc_invalid', 'Ungültige uuid/targetUsername.', ['status' => 400]);
+ }
+ $presence_table = aeromc_friends_presence_table();
+ $friends_table = aeromc_friends_friends_table();
+
+ $ziel = $wpdb->get_row($wpdb->prepare(
+ "SELECT uuid FROM $presence_table WHERE username = %s", $targetUsername
+ ));
+ if (!$ziel) {
+ return new WP_Error('aeromc_not_found', 'Dieser Name wurde noch nie im Launcher gesehen.', ['status' => 404]);
+ }
+ $ziel_uuid = $ziel->uuid;
+ if ($ziel_uuid === $uuid) {
+ return new WP_Error('aeromc_self', 'Du kannst dich nicht selbst hinzufügen.', ['status' => 400]);
+ }
+
+ $vorhanden = $wpdb->get_var($wpdb->prepare(
+ "SELECT id FROM $friends_table WHERE (uuid_a = %s AND uuid_b = %s) OR (uuid_a = %s AND uuid_b = %s)",
+ $uuid, $ziel_uuid, $ziel_uuid, $uuid
+ ));
+ if ($vorhanden) {
+ return new WP_Error('aeromc_exists', 'Es gibt schon eine Anfrage oder Freundschaft.', ['status' => 409]);
+ }
+
+ $wpdb->insert($friends_table, [
+ 'uuid_a' => $uuid,
+ 'uuid_b' => $ziel_uuid,
+ 'status' => 'pending',
+ 'created_at' => current_time('mysql'),
+ ]);
+ return ['ok' => true];
+}
+
+/** POST /friends/respond {uuid, otherUuid, accept} */
+function aeromc_friends_route_respond($request) {
+ global $wpdb;
+ $uuid = aeromc_friends_normalize_uuid($request->get_param('uuid'));
+ $other = aeromc_friends_normalize_uuid($request->get_param('otherUuid'));
+ $accept = (bool) $request->get_param('accept');
+ if (!$uuid || !$other) {
+ return new WP_Error('aeromc_invalid', 'Ungültige uuid/otherUuid.', ['status' => 400]);
+ }
+ $friends_table = aeromc_friends_friends_table();
+
+ if ($accept) {
+ $wpdb->query($wpdb->prepare(
+ "UPDATE $friends_table SET status = 'accepted' WHERE uuid_a = %s AND uuid_b = %s AND status = 'pending'",
+ $other, $uuid
+ ));
+ } else {
+ $wpdb->query($wpdb->prepare(
+ "DELETE FROM $friends_table WHERE uuid_a = %s AND uuid_b = %s AND status = 'pending'",
+ $other, $uuid
+ ));
+ }
+ return ['ok' => true];
+}
+
+/** POST /friends/cancel {uuid, otherUuid} - eine SELBST gesendete Anfrage zurückziehen */
+function aeromc_friends_route_cancel($request) {
+ global $wpdb;
+ $uuid = aeromc_friends_normalize_uuid($request->get_param('uuid'));
+ $other = aeromc_friends_normalize_uuid($request->get_param('otherUuid'));
+ if (!$uuid || !$other) {
+ return new WP_Error('aeromc_invalid', 'Ungültige uuid/otherUuid.', ['status' => 400]);
+ }
+ $friends_table = aeromc_friends_friends_table();
+ $wpdb->query($wpdb->prepare(
+ "DELETE FROM $friends_table WHERE uuid_a = %s AND uuid_b = %s AND status = 'pending'",
+ $uuid, $other
+ ));
+ return ['ok' => true];
+}
+
+/** POST /friends/remove {uuid, otherUuid} */
+function aeromc_friends_route_remove($request) {
+ global $wpdb;
+ $uuid = aeromc_friends_normalize_uuid($request->get_param('uuid'));
+ $other = aeromc_friends_normalize_uuid($request->get_param('otherUuid'));
+ if (!$uuid || !$other) {
+ return new WP_Error('aeromc_invalid', 'Ungültige uuid/otherUuid.', ['status' => 400]);
+ }
+ $friends_table = aeromc_friends_friends_table();
+ $wpdb->query($wpdb->prepare(
+ "DELETE FROM $friends_table WHERE ((uuid_a = %s AND uuid_b = %s) OR (uuid_a = %s AND uuid_b = %s)) AND status = 'accepted'",
+ $uuid, $other, $other, $uuid
+ ));
+ return ['ok' => true];
+}
+
+ `)}`;
+ overlayFenster.loadURL(html);
+ overlayFenster.once('ready-to-show', () => { if (!overlayFenster.isDestroyed()) overlayFenster.showInactive(); });
+ setTimeout(() => {
+ if (!overlayFenster.isDestroyed()) overlayFenster.destroy();
+ toastsProFenster.set(pid, Math.max(0, (toastsProFenster.get(pid) || 1) - 1));
+ }, dauerMs);
+ return true;
+}
+
+// ---------- Tastenkürzel: Online-Freunde ingame anzeigen ----------
+// Nur registriert, solange über diesen Launcher ein Spiel läuft - ein globales
+// Tastenkürzel fängt die Kombination systemweit ab, das soll andere Programme
+// außerhalb des Spielens nicht stören.
+const FREUNDE_TASTENKUERZEL = 'Control+Alt+F';
+let freundeTastenkuerzelAktiv = false;
+
+function aktualisiereFreundeTastenkuerzel() {
+ const soll = kontoPid.size > 0 && store.getSettings().friendsEnabled !== false;
+ if (soll && !freundeTastenkuerzelAktiv) {
+ freundeTastenkuerzelAktiv = globalShortcut.register(FREUNDE_TASTENKUERZEL, () => {
+ zeigeOnlineFreundeIngame().catch(() => {});
+ });
+ } else if (!soll && freundeTastenkuerzelAktiv) {
+ globalShortcut.unregister(FREUNDE_TASTENKUERZEL);
+ freundeTastenkuerzelAktiv = false;
+ }
+}
+
+// Zeigt die gerade online befindlichen Freunde des Kontos, dessen
+// Minecraft-Fenster gerade im Vordergrund ist, als Toast auf genau diesem
+// Fenster. Läuft nur ein Spiel, wird dieses genommen, auch wenn es nicht
+// im Vordergrund ist.
+async function zeigeOnlineFreundeIngame() {
+ let aktivePid = null;
+ try { aktivePid = require('node-window-manager').windowManager.getActiveWindow().processId; } catch { /* egal */ }
+ let eintrag = [...kontoPid].find(([, pid]) => pid === aktivePid);
+ if (!eintrag && kontoPid.size === 1) eintrag = [...kontoPid][0];
+ if (!eintrag) return;
+ const [kontoUuid, pid] = eintrag;
+
+ const res = await friends.getFriends(kontoUuid);
+ if (!res.ok) { await zeigeIngameOverlay('Freunde', 'Freundesystem nicht erreichbar', pid, 4000); return; }
+ const spitznamen = store.getSettings().friendNicknames || {};
+ const online = (res.data || []).filter((f) => f.online);
+ const MAX_ZEILEN = 10;
+ const zeilen = online.slice(0, MAX_ZEILEN).map((f) => ({
+ uuid: f.uuid,
+ text: (spitznamen[f.uuid] || f.username) + (f.server ? ` · ${f.server}` : ''),
+ }));
+ if (online.length > MAX_ZEILEN) zeilen.push(`… und ${online.length - MAX_ZEILEN} weitere`);
+ await zeigeIngameOverlay(
+ online.length ? `Freunde online (${online.length})` : 'Freunde online',
+ zeilen.length ? zeilen : ['Gerade ist niemand online'],
+ pid,
+ 8000,
+ );
+}
+
+// ---------- Offene Freundschaftsanfragen (Zahl am "Freunde"-Knopf) ----------
+let letzteAnfragenZahl = 0;
+async function aktualisiereAnfragenZahl() {
+ let zahl = 0;
+ const acc = auth.currentAccount();
+ if (store.getSettings().friendsEnabled !== false && acc && acc.profile) {
+ const res = await friends.getRequests(acc.profile.id);
+ if (!res.ok) return; // nicht erreichbar -> letzten bekannten Stand behalten
+ zahl = (res.data || []).length;
+ }
+ letzteAnfragenZahl = zahl;
+ broadcast('friends:requestCount', zahl);
+}
+ipcMain.handle('friends:requestCount', () => letzteAnfragenZahl);
+
+// eigene uuid -> (freund-uuid -> war beim letzten Durchlauf online). Pro
+// Konto getrennt, damit zwei gleichzeitig spielende Konten sich die
+// Vergleichsbasis nicht gegenseitig überschreiben.
+const freundeOnlineBaseline = new Map();
+
+// Prüft für JEDES gerade über diesen Launcher spielende Konto (kontoPid) dessen
+// eigene Freundesliste und zeigt die Meldung auf DESSEN Fenster - nicht nur für
+// das gerade "aktive" Konto, sonst bekäme bei zwei laufenden Konten immer nur
+// eines die Meldungen. Ohne laufendes Spiel gibt es kein Fenster für den Toast,
+// daher werden nur spielende Konten geprüft.
+async function pruefeFreundeOnline() {
+ if (store.getSettings().friendsEnabled === false) return;
+ for (const [kontoUuid, pid] of kontoPid) {
+ const res = await friends.getFriends(kontoUuid);
+ if (!res.ok) continue;
+ const bisherige = freundeOnlineBaseline.get(kontoUuid);
+ const neu = new Map();
+ for (const f of res.data || []) {
+ let bekanntOnline = f.online;
+ // Meldet auch beim allerersten Check, wenn ein Freund schon online ist -
+ // nur ausgelassen, wenn er beim vorherigen Check schon als online
+ // gemeldet war (sonst käme jede Minute dieselbe Meldung)
+ if (f.online && (!bisherige || bisherige.get(f.uuid) !== true)) {
+ const gezeigt = await zeigeIngameOverlay(
+ 'Freund online',
+ { uuid: f.uuid, text: `${f.username} ist jetzt online` },
+ pid,
+ );
+ // Fenster (noch) nicht gefunden, z. B. weil das Spiel noch lädt ->
+ // nicht als "schon gemeldet" merken, nächster Durchlauf versucht es erneut
+ if (!gezeigt) bekanntOnline = false;
+ }
+ neu.set(f.uuid, bekanntOnline);
+ }
+ freundeOnlineBaseline.set(kontoUuid, neu);
+ }
+}
+
+function aktivesFreundeKonto() {
+ const acc = auth.currentAccount();
+ return acc && acc.profile ? { uuid: acc.profile.id, username: acc.profile.name } : null;
+}
+
+ipcMain.handle('friends:enabled', () => store.getSettings().friendsEnabled !== false);
+
+ipcMain.handle('friends:list', async () => {
+ const konto = aktivesFreundeKonto();
+ if (!konto) return { ok: false, message: 'Kein Konto angemeldet.' };
+ const res = await friends.getFriends(konto.uuid);
+ return res.ok ? { ok: true, list: res.data || [] } : res;
+});
+
+ipcMain.handle('friends:requests', async () => {
+ const konto = aktivesFreundeKonto();
+ if (!konto) return { ok: false, message: 'Kein Konto angemeldet.' };
+ const res = await friends.getRequests(konto.uuid);
+ return res.ok ? { ok: true, list: res.data || [] } : res;
+});
+
+ipcMain.handle('friends:add', async (_e, targetUsername) => {
+ const konto = aktivesFreundeKonto();
+ if (!konto) return { ok: false, message: 'Kein Konto angemeldet.' };
+ const res = await friends.sendRequest(konto.uuid, konto.username, targetUsername);
+ return res.ok ? { ok: true } : res;
+});
+
+ipcMain.handle('friends:sentRequests', async () => {
+ const konto = aktivesFreundeKonto();
+ if (!konto) return { ok: false, message: 'Kein Konto angemeldet.' };
+ const res = await friends.getSentRequests(konto.uuid);
+ return res.ok ? { ok: true, list: res.data || [] } : res;
+});
+
+ipcMain.handle('friends:cancel', async (_e, otherUuid) => {
+ const konto = aktivesFreundeKonto();
+ if (!konto) return { ok: false, message: 'Kein Konto angemeldet.' };
+ const res = await friends.cancelRequest(konto.uuid, otherUuid);
+ return res.ok ? { ok: true } : res;
+});
+
+ipcMain.handle('friends:respond', async (_e, otherUuid, accept) => {
+ const konto = aktivesFreundeKonto();
+ if (!konto) return { ok: false, message: 'Kein Konto angemeldet.' };
+ const res = await friends.respond(konto.uuid, otherUuid, accept);
+ aktualisiereAnfragenZahl().catch(() => {});
+ return res.ok ? { ok: true } : res;
+});
+
+ipcMain.handle('friends:remove', async (_e, otherUuid) => {
+ const konto = aktivesFreundeKonto();
+ if (!konto) return { ok: false, message: 'Kein Konto angemeldet.' };
+ const res = await friends.removeFriend(konto.uuid, otherUuid);
+ return res.ok ? { ok: true } : res;
+});
+
+// Spitznamen sind rein lokal (nur meine eigene Ansicht) - kein Grund, dafür
+// die WordPress-Datenbank zu bemühen, landen einfach in settings.json
+ipcMain.handle('friends:setNickname', (_e, uuid, nickname) => {
+ const aktuelle = store.getSettings().friendNicknames || {};
+ const neu = Object.assign({}, aktuelle);
+ if (nickname) neu[uuid] = nickname; else delete neu[uuid];
+ store.saveSettings({ friendNicknames: neu });
+ return true;
+});
+
ipcMain.handle('auth:login', async () => {
const clientId = store.getSettings().azureClientId || auth.DEFAULT_CLIENT_ID;
try {
@@ -2225,6 +2643,7 @@ ipcMain.handle('instances:launch', async (_e, id, accountId, launchOpts) => {
// gewechselt worden sein, während dieses Spiel noch läuft.
const kontoId = account && account.profile ? account.profile.id : null;
let gezaehlt = false;
+ let freundeHerzschlag = null;
try {
let launchStart = 0;
@@ -2237,11 +2656,31 @@ ipcMain.handle('instances:launch', async (_e, id, accountId, launchOpts) => {
state: `${inst.name} · ${inst.minecraft.version}`,
startTimestamp: launchStart,
});
+ // Freundesystem: eigene Online-Meldung, nur wenn nicht in den
+ // Einstellungen ausgeschaltet (siehe friendsEnabled) - sonst bleibt
+ // man für niemanden auffindbar/sichtbar
+ if (account && account.profile && store.getSettings().friendsEnabled !== false) {
+ const sendeHerzschlag = () => {
+ friends.heartbeat({
+ uuid: account.profile.id,
+ username: account.profile.name,
+ instance: inst.name,
+ server: letzteQuickPlayServer.get(id) || '',
+ }).catch(() => {});
+ };
+ sendeHerzschlag();
+ freundeHerzschlag = setInterval(sendeHerzschlag, 60000);
+ }
}
if (evt.phase === 'exit') {
if (gezaehlt) { gezaehlt = false; kontoSpieltNichtMehr(kontoId); }
discordpresence.clearActivity();
+ if (freundeHerzschlag) { clearInterval(freundeHerzschlag); freundeHerzschlag = null; }
laufendePid.delete(id); // für die "Nur Minecraft"-Tonaufnahme: Prozess ist weg
+ // beim nächsten Start dieses Kontos sollen bereits online befindliche
+ // Freunde wieder gemeldet werden
+ if (kontoId) { kontoPid.delete(kontoId); freundeOnlineBaseline.delete(kontoId); }
+ aktualisiereFreundeTastenkuerzel();
if (launchStart) {
const secs = Math.max(0, Math.round((Date.now() - launchStart) / 1000));
launchStart = 0; // Spielzeit nur einmal gutschreiben
@@ -2264,11 +2703,14 @@ ipcMain.handle('instances:launch', async (_e, id, accountId, launchOpts) => {
// Start fehlgeschlagen, obwohl schon gezählt -> Zählung zurücknehmen,
// sonst bliebe das Konto für immer als "spielt" stehen
if (!res.ok && gezaehlt) { gezaehlt = false; kontoSpieltNichtMehr(kontoId); discordpresence.clearActivity(); }
+ if (!res.ok && freundeHerzschlag) { clearInterval(freundeHerzschlag); freundeHerzschlag = null; }
if (res.ok) store.updateInstance(id, { lastPlayed: new Date().toISOString() });
if (res.ok && res.pid) laufendePid.set(id, res.pid);
+ if (res.ok && res.pid && kontoId) { kontoPid.set(kontoId, res.pid); aktualisiereFreundeTastenkuerzel(); }
return res;
} catch (err) {
if (gezaehlt) { gezaehlt = false; kontoSpieltNichtMehr(kontoId); discordpresence.clearActivity(); }
+ if (freundeHerzschlag) { clearInterval(freundeHerzschlag); freundeHerzschlag = null; }
return { ok: false, message: 'Start fehlgeschlagen: ' + err.message };
}
});
diff --git a/src/preload.js b/src/preload.js
index 5b65b2f..8ce0d58 100644
--- a/src/preload.js
+++ b/src/preload.js
@@ -279,8 +279,29 @@ contextBridge.exposeInMainWorld('api', {
// Spielaufzeichnung
recordingListWindows: () => ipcRenderer.invoke('recording:listWindows'),
recordingGetAudioSourceId: () => ipcRenderer.invoke('recording:getAudioSourceId'),
- recordingSave: (instanceName, buffer, serverLabel) => ipcRenderer.invoke('recording:save', instanceName, buffer, serverLabel),
+ recordingSave: (instanceName, buffer, serverLabel, fps) => ipcRenderer.invoke('recording:save', instanceName, buffer, serverLabel, fps),
recordingOpenFolder: (instanceName) => ipcRenderer.invoke('recording:openFolder', instanceName),
+ recordingList: (instanceName) => ipcRenderer.invoke('recording:list', instanceName),
+ recordingThumbnail: (instanceName, dateiname) => ipcRenderer.invoke('recording:thumbnail', instanceName, dateiname),
+ recordingDelete: (instanceName, dateiname) => ipcRenderer.invoke('recording:delete', instanceName, dateiname),
+ recordingOpen: (instanceName, dateiname) => ipcRenderer.invoke('recording:open', instanceName, dateiname),
+
+ // Freundesystem
+ friendsEnabled: () => ipcRenderer.invoke('friends:enabled'),
+ friendsList: () => ipcRenderer.invoke('friends:list'),
+ friendsRequests: () => ipcRenderer.invoke('friends:requests'),
+ friendsAdd: (targetUsername) => ipcRenderer.invoke('friends:add', targetUsername),
+ friendsRespond: (otherUuid, accept) => ipcRenderer.invoke('friends:respond', otherUuid, accept),
+ friendsRemove: (otherUuid) => ipcRenderer.invoke('friends:remove', otherUuid),
+ friendsSentRequests: () => ipcRenderer.invoke('friends:sentRequests'),
+ friendsCancel: (otherUuid) => ipcRenderer.invoke('friends:cancel', otherUuid),
+ friendsSetNickname: (uuid, nickname) => ipcRenderer.invoke('friends:setNickname', uuid, nickname),
+ friendsRequestCount: () => ipcRenderer.invoke('friends:requestCount'),
+ onFriendsRequestCount: (cb) => {
+ const l = (_e, zahl) => cb(zahl);
+ ipcRenderer.on('friends:requestCount', l);
+ return () => ipcRenderer.removeListener('friends:requestCount', l);
+ },
recordingGetServer: (instanceId) => ipcRenderer.invoke('recording:getServer', instanceId),
onRecordingServerDetected: (cb) => {
const l = (_e, payload) => cb(payload);
diff --git a/src/renderer.js b/src/renderer.js
index 00456d0..3e4d5b3 100644
--- a/src/renderer.js
+++ b/src/renderer.js
@@ -1507,6 +1507,7 @@ const ICONS_SVG = {
folder: '${esc(titel)}
+ ${zeilen.map((z) => `
+ ${z.kopf ? `
` : ''}
+
+
`).join('')}
+ Lade …
';
screenSelected = new Set();
updateScreensSelectionUi();
+ recordsGeladen = false;
+ switchScreensTab('photos');
show('modal-screens');
const shots = await window.api.screenshots(currentDetailId);
@@ -3402,6 +3429,251 @@ async function deleteSelectedScreenshots() {
});
}
+// ---------- Aufzeichnungen-Galerie (im selben Dialog, zweiter Tab) ----------
+let screensAktiverTab = 'photos';
+let recordSelected = new Set();
+let recordsGeladen = false; // nur beim ersten Wechsel auf den Tab laden, nicht bei jedem Öffnen
+
+function switchScreensTab(which) {
+ screensAktiverTab = which;
+ const photos = which === 'photos';
+ el('screens-tab-photos').classList.toggle('on', photos);
+ el('screens-tab-records').classList.toggle('on', !photos);
+ el('screens-pane-photos').classList.toggle('hidden', !photos);
+ el('screens-pane-records').classList.toggle('hidden', photos);
+ if (!photos && !recordsGeladen) { recordsGeladen = true; openRecordsList(); }
+}
+
+function updateRecordsSelectionUi() {
+ const n = recordSelected.size;
+ const btn = el('records-delete-sel');
+ if (btn) {
+ btn.disabled = n === 0;
+ btn.textContent = n ? (n + ' löschen') : 'Auswahl löschen';
+ }
+ const hint = el('records-sel-hint');
+ if (hint) hint.textContent = n ? (n + ' ausgewählt – Doppelklick spielt ab') : 'Klick auf Vorschaubild zum Auswählen, Doppelklick zum Abspielen';
+ document.querySelectorAll('#records-grid .screen-thumb').forEach((t) => {
+ const name = t.dataset.name;
+ t.classList.toggle('selected', !!(name && recordSelected.has(name)));
+ const cb = t.querySelector('.screen-check');
+ if (cb) cb.checked = !!(name && recordSelected.has(name));
+ });
+}
+
+function formatDateigroesse(bytes) {
+ if (bytes >= 1024 * 1024 * 1024) return (bytes / (1024 * 1024 * 1024)).toFixed(1) + ' GB';
+ if (bytes >= 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+ return Math.round(bytes / 1024) + ' KB';
+}
+
+async function openRecordsList() {
+ const grid = el('records-grid');
+ grid.innerHTML = 'Lade …
';
+ recordSelected = new Set();
+ updateRecordsSelectionUi();
+
+ const inst = await window.api.getInstance(currentDetailId);
+ const instanceName = inst ? inst.name : null;
+ if (!instanceName) { grid.innerHTML = 'Keine Instanz ausgewählt.
'; return; }
+
+ const aufnahmen = await window.api.recordingList(instanceName);
+ grid.innerHTML = '';
+ if (!aufnahmen.length) {
+ grid.innerHTML = 'Keine Aufzeichnungen vorhanden.
';
+ updateRecordsSelectionUi();
+ return;
+ }
+ for (const a of aufnahmen) {
+ const thumb = document.createElement('div');
+ thumb.className = 'screen-thumb record-thumb';
+ thumb.dataset.name = a.name;
+ thumb.innerHTML =
+ `
+ ${escapeHtml(a.name)}
+ ${formatDateigroesse(a.size)}
+ `;
+ const img = thumb.querySelector('img');
+ window.api.recordingThumbnail(instanceName, a.name).then((d) => { if (d) img.src = d; });
+
+ const toggle = () => {
+ if (recordSelected.has(a.name)) recordSelected.delete(a.name);
+ else recordSelected.add(a.name);
+ updateRecordsSelectionUi();
+ };
+ thumb.querySelector('.screen-check').addEventListener('click', (e) => { e.stopPropagation(); toggle(); });
+ thumb.addEventListener('click', (e) => {
+ if (e.target.closest('.screen-del') || e.target.closest('.screen-check')) return;
+ toggle();
+ });
+ thumb.addEventListener('dblclick', (e) => {
+ if (e.target.closest('.screen-del') || e.target.closest('.screen-check')) return;
+ window.api.recordingOpen(instanceName, a.name);
+ });
+ thumb.querySelector('.screen-del').addEventListener('click', (e) => {
+ e.stopPropagation();
+ askConfirm('Aufzeichnung löschen', `„${a.name}" löschen?`, '🗑 Löschen', async () => {
+ await window.api.recordingDelete(instanceName, a.name);
+ openRecordsList();
+ });
+ });
+ grid.appendChild(thumb);
+ }
+ updateRecordsSelectionUi();
+}
+
+async function deleteSelectedRecords() {
+ const names = [...recordSelected];
+ if (!names.length || !currentDetailId) return;
+ const inst = await window.api.getInstance(currentDetailId);
+ const instanceName = inst ? inst.name : null;
+ if (!instanceName) return;
+ const label = names.length === 1
+ ? `„${names[0]}" löschen?`
+ : `${names.length} Aufzeichnungen unwiderruflich löschen?`;
+ askConfirm('Aufzeichnungen löschen', label, '🗑 Löschen', async () => {
+ for (const name of names) {
+ await window.api.recordingDelete(instanceName, name);
+ }
+ toast(names.length === 1 ? 'Aufzeichnung gelöscht.' : names.length + ' Aufzeichnungen gelöscht.');
+ openRecordsList();
+ });
+}
+
+// ---------- Freunde ----------
+let friendsAutoRefresh = null;
+
+async function openFriends() {
+ if (POPOUT !== 'friends') { window.api.popoutOpen('friends'); return; }
+ show('modal-friends');
+ await ladeFreunde();
+ clearInterval(friendsAutoRefresh);
+ friendsAutoRefresh = setInterval(ladeFreunde, 30000);
+}
+
+async function ladeFreunde() {
+ const aktiv = await window.api.friendsEnabled();
+ el('friends-disabled-hint').classList.toggle('hidden', aktiv);
+ el('friends-content').classList.toggle('hidden', !aktiv);
+ if (!aktiv) return;
+
+ const [anfragenRes, gesendetRes, freundeRes, einstellungen] = await Promise.all([
+ window.api.friendsRequests(),
+ window.api.friendsSentRequests(),
+ window.api.friendsList(),
+ window.api.getSettings(),
+ ]);
+ const spitznamen = einstellungen.friendNicknames || {};
+
+ const reqBox = el('friends-requests-box');
+ reqBox.innerHTML = '';
+ if (anfragenRes.ok && anfragenRes.list.length) {
+ const titel = document.createElement('div');
+ titel.className = 'friends-section-title';
+ titel.textContent = 'Anfragen';
+ reqBox.appendChild(titel);
+ for (const r of anfragenRes.list) {
+ const row = document.createElement('div');
+ row.className = 'friend-row';
+ row.innerHTML = `${escapeHtml(r.username || r.uuid)}
${escapeHtml(r.username || r.uuid)}
wartet auf Bestätigung
Freunde
';
+ if (!freundeRes.ok) {
+ listBox.innerHTML += `${escapeHtml(freundeRes.message || 'Nicht erreichbar.')}
`;
+ return;
+ }
+ if (!freundeRes.list.length) {
+ listBox.innerHTML += 'Noch keine Freunde. Namen oben eingeben, um eine Anfrage zu senden.
';
+ return;
+ }
+ const sortiert = [...freundeRes.list].sort((a, b) => {
+ if (a.online !== b.online) return a.online ? -1 : 1;
+ return (a.username || '').localeCompare(b.username || '');
+ });
+ for (const f of sortiert) {
+ const row = document.createElement('div');
+ row.className = 'friend-row';
+ const anzeigeName = spitznamen[f.uuid] || f.username || f.uuid;
+ const status = f.online
+ ? (f.instance ? `spielt ${f.instance}${f.server ? ' · ' + f.server : ''}` : 'online')
+ : 'offline';
+ row.innerHTML = `
+ ${escapeHtml(anzeigeName)}
${escapeHtml(status)}