Creating Dynamic Dialogue

class DialogueManager {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.conversationHistory = new Map();
    this.emotionStates = new Map();
    this.baseUrl = 'https://api.chromagolem.com/v1';
  }

  async generateDialogue(npcId, playerMessage, context = {}) {
    const history = this.conversationHistory.get(npcId) || [];
    const emotions = this.emotionStates.get(npcId) || {};
    
    const messages = [
      {
        role: 'system',
        content: this.buildSystemMessage(context, emotions)
      },
      ...history.slice(-10), // Keep last 10 exchanges
      { role: 'user', content: playerMessage }
    ];

    try {
      const response = await fetch(`${this.baseUrl}/chat/completions`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${this.apiKey}`
        },
        body: JSON.stringify({
          messages,
          client_id: context.playerId || 'default'
        })
      });

      const data = await response.json();
      const npcResponse = data.choices[0].message.content;
      
      // Update conversation history
      this.updateHistory(npcId, playerMessage, npcResponse);
      this.updateEmotions(npcId, playerMessage, context);
      
      return {
        response: npcResponse,
        emotions: this.emotionStates.get(npcId),
        context: context
      };
    } catch (error) {
      console.error('Dialogue generation error:', error);
      return this.getFallbackResponse(npcId);
    }
  }

  buildSystemMessage(context, emotions) {
    return `You are ${context.npcName}, ${context.npcRole}.

Current Emotional State:
- Primary: ${emotions.primary || 'neutral'} (${emotions.intensity || 5}/10)
- Mood: ${emotions.mood || 'balanced'}
- Recent Trigger: ${emotions.lastTrigger || 'none'}

Environment & Context:
- Location: ${context.location}
- Time: ${context.timeOfDay}
- Recent Events: ${context.recentEvents}
- Other Present: ${context.othersPresent}

Dialogue Guidelines:
- Respond naturally based on your emotional state
- Reference the environment when appropriate
- Remember our conversation history
- Stay true to your character while adapting to the situation`;
  }
}

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using UnityEngine;
using Newtonsoft.Json;

[System.Serializable]
public class EmotionState
{
    public string primary;
    public int intensity;
    public string mood;
    public string lastTrigger;
}

public class DialogueNPC : MonoBehaviour
{
    [Header("NPC Configuration")]
    public string npcName = "Guard";
    public string npcRole = "Town Guard";
    public string apiKey = "your_api_key_here";
    
    [Header("Dialogue State")]
    public EmotionState currentEmotions;
    public List<string> conversationHistory;
    
    private const string API_BASE_URL = "https://api.chromagolem.com/v1";
    
    public async Task<string> GenerateDialogueAsync(string playerMessage, string context = "")
    {
        var systemMessage = BuildSystemMessage(context);
        var messages = BuildMessageArray(systemMessage, playerMessage);
        
        var requestData = new
        {
            messages = messages,
            client_id = SystemInfo.deviceUniqueIdentifier
        };
        
        string jsonRequest = JsonConvert.SerializeObject(requestData);
        
        using (UnityWebRequest request = new UnityWebRequest($"{API_BASE_URL}/chat/completions", "POST"))
        {
            byte[] jsonBytes = System.Text.Encoding.UTF8.GetBytes(jsonRequest);
            request.uploadHandler = new UploadHandlerRaw(jsonBytes);
            request.downloadHandler = new DownloadHandlerBuffer();
            request.SetRequestHeader("Content-Type", "application/json");
            request.SetRequestHeader("Authorization", $"Bearer {apiKey}");
            
            await SendWebRequest(request);
            
            if (request.result == UnityWebRequest.Result.Success)
            {
                var response = JsonConvert.DeserializeObject<DialogueResponse>(request.downloadHandler.text);
                string npcResponse = response.choices[0].message.content;
                
                // Update conversation history
                UpdateConversationHistory(playerMessage, npcResponse);
                UpdateEmotionalState(playerMessage);
                
                return npcResponse;
            }
            else
            {
                Debug.LogError($"Dialogue API Error: {request.error}");
                return GetFallbackResponse();
            }
        }
    }
}

import json
import time
import requests
from typing import Dict, List, Optional
from dataclasses import dataclass, asdict

@dataclass
class EmotionState:
    primary: str = "neutral"
    intensity: int = 5
    mood: str = "balanced"
    last_trigger: str = "none"
    timestamp: float = 0.0

class DialogueEngine:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.chromagolem.com/v1"
        self.npc_states = {}
        self.conversation_histories = {}
        
    async def generate_dialogue(self, npc_id: str, player_message: str, 
                           context: Dict = None) -> Dict:
        """Generate dynamic dialogue response with emotional context."""
        if context is None:
            context = {}
            
        # Get or initialize NPC state
        emotions = self.npc_states.get(npc_id, EmotionState())
        history = self.conversation_histories.get(npc_id, [])
        
        # Build system message with full context
        system_message = self._build_system_message(context, emotions)
        
        messages = [
            {"role": "system", "content": system_message},
            *history[-10:],  # Last 10 exchanges
            {"role": "user", "content": player_message}
        ]
        
        try:
            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers={
                    "Content-Type": "application/json",
                    "Authorization": f"Bearer {self.api_key}"
                },
                json={
                    "messages": messages,
                    "client_id": context.get("player_id", "default")
                },
                timeout=30
            )
            
            response.raise_for_status()
            data = response.json()
            npc_response = data["choices"][0]["message"]["content"]
            
            # Update NPC state
            self._update_conversation_history(npc_id, player_message, npc_response)
            self._update_emotional_state(npc_id, player_message, context)
            
            return {
                "response": npc_response,
                "emotions": asdict(self.npc_states[npc_id]),
                "context": context
            }
            
        except requests.RequestException as e:
            print(f"Dialogue generation error: {e}")
            return self._get_fallback_response(npc_id, context)