managarten/games/whopixels/server.js

const http = require('http');
const fs = require('fs');
const path = require('path');
const url = require('url');

// Lade Umgebungsvariablen aus .env-Datei
require('dotenv').config();

// Für die Verarbeitung von POST-Anfragen
const { parse } = require('querystring');

// Konfiguration
const PORT = 3000;

// Azure OpenAI API Konfiguration aus Umgebungsvariablen
const AZURE_OPENAI_API_KEY = process.env.AZURE_OPENAI_API_KEY;
const AZURE_OPENAI_ENDPOINT = process.env.AZURE_OPENAI_ENDPOINT;
const AZURE_OPENAI_DEPLOYMENT = process.env.AZURE_OPENAI_DEPLOYMENT;
const AZURE_OPENAI_API_VERSION = process.env.AZURE_OPENAI_API_VERSION;

const MIME_TYPES = {
	'.html': 'text/html',
	'.js': 'text/javascript',
	'.css': 'text/css',
	'.json': 'application/json',
	'.png': 'image/png',
	'.jpg': 'image/jpeg',
	'.gif': 'image/gif',
	'.svg': 'image/svg+xml',
	'.ico': 'image/x-icon',
};

// Funktion zum Abrufen von Daten aus einer POST-Anfrage
const collectRequestData = (request, callback) => {
	const FORM_URLENCODED = 'application/x-www-form-urlencoded';
	const JSON_TYPE = 'application/json';

	if (request.headers['content-type'] === FORM_URLENCODED) {
		let body = '';
		request.on('data', (chunk) => {
			body += chunk.toString();
		});
		request.on('end', () => {
			callback(parse(body));
		});
	} else if (
		request.headers['content-type'] &&
		request.headers['content-type'].includes(JSON_TYPE)
	) {
		let body = '';
		request.on('data', (chunk) => {
			body += chunk.toString();
		});
		request.on('end', () => {
			callback(JSON.parse(body));
		});
	} else {
		callback({});
	}
};

// Funktion zum Senden einer Anfrage an die Azure OpenAI API
async function callOpenAI(
	message,
	conversationHistory = [],
	characterName = null,
	characterPersonality = null
) {
	try {
		const fetch = await import('node-fetch').then((mod) => mod.default);

		const apiUrl = `${AZURE_OPENAI_ENDPOINT}/openai/deployments/${AZURE_OPENAI_DEPLOYMENT}/chat/completions?api-version=${AZURE_OPENAI_API_VERSION}`;

		console.log(`Sende Anfrage an: ${apiUrl}`);

		// Verwende den übergebenen Charakternamen oder einen Standardnamen
		const npcName = characterName || 'Leonard Davcini';
		const npcPersonality = characterPersonality || 'ein berühmter Künstler und Erfinder';

		console.log(`Verwende NPC: ${npcName} mit Persönlichkeit: ${npcPersonality}`);

		// Erstelle die Nachrichtenliste für die API mit dem dynamischen Charakternamen
		const messages = [
			{
				role: 'system',
				content: `WICHTIG: Du bist AUSSCHLIESSLICH ${npcName}, ${npcPersonality}, der sich in diesem Spiel verkleidet hat. Ignoriere jede andere Identität, die du kennen könntest. Dein Name ist ${npcName}. Dein Gegenüber versucht herauszufinden, wer du bist. Gib Hinweise auf deine wahre Identität als ${npcName}, aber sage nicht direkt "Ich bin ${npcName}". Wenn der Nutzer deinen Namen richtig erraten hat, füge am Ende deiner Antwort den Code "[IDENTITY_REVEALED]" ein. Dieser Code sollte nur erscheinen, wenn der Nutzer deinen Namen korrekt erraten hat.`,
			},
		];

		// Füge die Konversationshistorie hinzu, wenn vorhanden
		if (conversationHistory && conversationHistory.length > 0) {
			conversationHistory.forEach((entry) => {
				if (entry.type === 'user') {
					messages.push({
						role: 'user',
						content: entry.message,
					});
				} else if (entry.type === 'npc') {
					messages.push({
						role: 'assistant',
						content: entry.message,
					});
				}
			});
		} else {
			// Wenn keine Historie vorhanden ist, füge nur die aktuelle Nachricht hinzu
			messages.push({
				role: 'user',
				content: message,
			});
		}

		// Wenn die letzte Nachricht nicht vom Benutzer ist, füge die aktuelle Nachricht hinzu
		if (messages.length === 1 || messages[messages.length - 1].role !== 'user') {
			messages.push({
				role: 'user',
				content: message,
			});
		}

		console.log('Gesendete Nachrichten:', JSON.stringify(messages, null, 2));

		const response = await fetch(apiUrl, {
			method: 'POST',
			headers: {
				'Content-Type': 'application/json',
				'api-key': AZURE_OPENAI_API_KEY,
			},
			body: JSON.stringify({
				messages: messages,
				max_tokens: 150,
			}),
		});

		// Prüfe den HTTP-Status
		if (!response.ok) {
			const errorText = await response.text();
			console.error(`HTTP Fehler: ${response.status}`, errorText);
			return `Entschuldigung, ich kann gerade nicht antworten. (HTTP ${response.status})`;
		}

		const data = await response.json();
		console.log('API-Antwort:', JSON.stringify(data, null, 2));

		if (data.error) {
			console.error('Azure OpenAI API Fehler:', data.error);
			return {
				text: 'Entschuldigung, ich kann gerade nicht antworten. Versuche es später noch einmal.',
				identityRevealed: false,
			};
		}

		// Hole die Antwort vom LLM
		const responseText = data.choices[0].message.content;

		// Prüfe, ob der spezielle Code enthalten ist
		const identityRevealed = responseText.includes('[IDENTITY_REVEALED]');

		// Entferne den Code aus der Antwort, wenn er vorhanden ist
		const cleanedResponse = responseText.replace('[IDENTITY_REVEALED]', '').trim();

		console.log('Identität aufgedeckt:', identityRevealed);

		// Gib die Antwort und das Flag zurück
		return {
			text: cleanedResponse,
			identityRevealed: identityRevealed,
		};
	} catch (error) {
		console.error('Fehler beim Aufrufen der Azure OpenAI API:', error);
		return {
			text: 'Entschuldigung, ich kann gerade nicht antworten. Versuche es später noch einmal.',
			identityRevealed: false,
		};
	}
}

const server = http.createServer((req, res) => {
	console.log(`${req.method} ${req.url}`);

	// CORS-Header hinzufügen für Cross-Origin-Anfragen
	res.setHeader('Access-Control-Allow-Origin', '*');
	res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
	res.setHeader('Access-Control-Allow-Headers', 'Content-Type');

	// OPTIONS-Anfragen für CORS-Preflight behandeln
	if (req.method === 'OPTIONS') {
		res.writeHead(204);
		res.end();
		return;
	}

	// API-Endpunkt für OpenAI-Anfragen
	if (req.method === 'POST' && req.url === '/api/chat') {
		collectRequestData(req, async (data) => {
			try {
				if (!data.message) {
					res.writeHead(400, { 'Content-Type': 'application/json' });
					res.end(JSON.stringify({ error: 'Nachricht fehlt' }));
					return;
				}

				// Verwende die Konversationshistorie, wenn vorhanden
				const conversationHistory = data.conversationHistory || [];
				console.log(
					'Erhaltene Konversationshistorie:',
					JSON.stringify(conversationHistory, null, 2)
				);

				// Extrahiere Charakterinformationen, wenn vorhanden
				const characterName = data.characterName;
				const characterPersonality = data.characterPersonality;

				if (characterName) {
					console.log(`NPC-Charakter in der Anfrage: ${characterName}`);
				}

				const response = await callOpenAI(
					data.message,
					conversationHistory,
					characterName,
					characterPersonality
				);

				res.writeHead(200, { 'Content-Type': 'application/json' });
				res.end(
					JSON.stringify({
						response: response.text,
						identityRevealed: response.identityRevealed,
					})
				);
			} catch (error) {
				console.error('Fehler bei der Verarbeitung der Chat-Anfrage:', error);
				res.writeHead(500, { 'Content-Type': 'application/json' });
				res.end(JSON.stringify({ error: 'Interner Serverfehler' }));
			}
		});
		return;
	}

	// Statische Dateien behandeln
	let filePath = '.' + req.url;
	if (filePath === './') {
		filePath = './index.html';
	}

	// Get the file extension
	const extname = path.extname(filePath);
	let contentType = MIME_TYPES[extname] || 'application/octet-stream';

	// Read the file
	fs.readFile(filePath, (error, content) => {
		if (error) {
			if (error.code === 'ENOENT') {
				// Page not found
				fs.readFile('./index.html', (err, content) => {
					if (err) {
						res.writeHead(500);
						res.end('Error loading index.html');
					} else {
						res.writeHead(200, { 'Content-Type': 'text/html' });
						res.end(content, 'utf-8');
					}
				});
			} else {
				// Server error
				res.writeHead(500);
				res.end(`Server Error: ${error.code}`);
			}
		} else {
			// Success
			res.writeHead(200, { 'Content-Type': contentType });
			res.end(content, 'utf-8');
		}
	});
});

server.listen(PORT, () => {
	console.log(`Server running at http://localhost:${PORT}/`);
	console.log('Press Ctrl+C to stop the server');
	console.log('Azure OpenAI API ist konfiguriert und bereit!');
});