Building Intelligent NPCs

class ChromaNPC {
  constructor(apiKey, personality, memories = []) {
    this.apiKey = apiKey;
    this.personality = personality;
    this.memories = memories;
    this.baseUrl = 'https://api.chromagolem.com/v1';
  }

  async generateResponse(playerMessage, context = {}) {
    const messages = [
      {
        role: 'system',
        content: `${this.personality}\\n\\nMemories:\\n${this.formatMemories()}\\n\\nContext: ${JSON.stringify(context)}`
      },
      ...this.memories.slice(-5), // Include last 5 interactions
      { 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;
      
      // Store interaction in memory
      this.addMemory('user', playerMessage);
      this.addMemory('assistant', npcResponse);
      
      return npcResponse;
    } catch (error) {
      console.error('NPC response error:', error);
      return this.getFallbackResponse();
    }
  }

  async makeDecision(situation, options = []) {
    const decisionPrompt = `
Situation: ${situation}
Available options: ${options.join(', ')}

Respond with JSON containing your decision:
{
  "chosen_action": "selected option",
  "reasoning": "why you chose this",
  "confidence": "0-100%",
  "alternative": "backup plan if this fails"
}`;

    const response = await this.generateResponse(decisionPrompt);
    try {
      return JSON.parse(response);
    } catch {
      return { chosen_action: options[0], reasoning: "Default choice", confidence: "50%" };
    }
  }
}

// Usage example:
const elara = new ChromaNPC(
  'your_api_key_here',
  `You are Elara, a skilled alchemist. You are curious, analytical, and slightly eccentric.
   You run a potion shop in the mountain village of Highpeak.`
);

// Generate a response
const response = await elara.generateResponse(
  "Do you have any healing potions?", 
  { playerId: "player_123", location: "elara_shop", timeOfDay: "evening" }
);

console.log("Elara says:", response);

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

[System.Serializable]
public class NPCMemory
{
    public string role;
    public string content;
    public long timestamp;
}

public class ChromaNPC : MonoBehaviour
{
    [Header("NPC Configuration")]
    public string npcName = "Elara";
    public string apiKey = "your_api_key_here";
    [TextArea(5, 10)]
    public string personality = "You are Elara, a skilled alchemist...";
    
    private List<NPCMemory> memories = new List<NPCMemory>();
    private const string API_BASE_URL = "https://api.chromagolem.com/v1";
    
    public async Task<string> GenerateResponseAsync(string playerMessage, string context = "")
    {
        var requestData = new
        {
            messages = BuildMessageArray(playerMessage, context),
            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<ChromaResponse>(request.downloadHandler.text);
                string npcResponse = response.choices[0].message.content;
                
                // Store memories
                AddMemory("user", playerMessage);
                AddMemory("assistant", npcResponse);
                
                return npcResponse;
            }
            else
            {
                Debug.LogError($"NPC API Error: {request.error}");
                return GetFallbackResponse();
            }
        }
    }
    
    public async Task<NPCDecision> MakeDecisionAsync(string situation, string[] options)
    {
        string prompt = $@"Situation: {situation}
Available options: {string.Join(", ", options)}

Respond with JSON:
{{
  ""chosen_action"": ""selected option"",
  ""reasoning"": ""why you chose this"",
  ""confidence"": 75
}}";

        string response = await GenerateResponseAsync(prompt);
        
        try
        {
            return JsonConvert.DeserializeObject<NPCDecision>(response);
        }
        catch
        {
            return new NPCDecision 
            { 
                chosen_action = options[0], 
                reasoning = "Default choice", 
                confidence = 50 
            };
        }
    }
}

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

@dataclass
class NPCMemory:
    role: str
    content: str
    timestamp: float

class ChromaNPC:
    def __init__(self, api_key: str, personality: str, name: str = "NPC"):
        self.api_key = api_key
        self.personality = personality
        self.name = name
        self.memories: List[NPCMemory] = []
        self.base_url = "https://api.chromagolem.com/v1"
        self.max_memories = 20
        
    async def generate_response(self, player_message: str, context: Dict = None) -> str:
        """Generate an NPC response to player input."""
        if context is None:
            context = {}
            
        messages = self._build_message_array(player_message, context)
        
        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"]
            
            # Store interaction in memory
            self.add_memory("user", player_message)
            self.add_memory("assistant", npc_response)
            
            return npc_response
            
        except requests.RequestException as e:
            print(f"NPC API Error: {e}")
            return self._get_fallback_response()
    
    def add_memory(self, role: str, content: str):
        """Add a new memory to the NPC's memory system."""
        memory = NPCMemory(
            role=role,
            content=content,
            timestamp=time.time()
        )
        
        self.memories.append(memory)
        
        # Trim old memories
        if len(self.memories) > self.max_memories:
            self.memories = self.memories[-self.max_memories:]

# Usage example:
async def main():
    elara = ChromaNPC(
        api_key="your_api_key_here",
        personality="""You are Elara, a skilled alchemist living in the mountain village of Highpeak.
        You are curious, analytical, and slightly eccentric. You run a potion shop and help travelers.""",
        name="Elara"
    )
    
    # Generate a response
    response = await elara.generate_response(
        "Do you have any healing potions?",
        context={"player_id": "player_123", "location": "shop", "time": "evening"}
    )
    
    print(f"Elara says: {response}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

// ChromaNPCComponent.h
#pragma once

#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "Http.h"
#include "Dom/JsonObject.h"
#include "ChromaNPCComponent.generated.h"

USTRUCT(BlueprintType)
struct FNPCMemory
{
    GENERATED_BODY()

    UPROPERTY(BlueprintReadWrite)
    FString Role;

    UPROPERTY(BlueprintReadWrite)
    FString Content;

    UPROPERTY(BlueprintReadWrite)
    float Timestamp;
};

UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class MYGAME_API UChromaNPCComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UChromaNPCComponent();

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "NPC Configuration")
    FString ApiKey;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "NPC Configuration", meta = (MultiLine = true))
    FString Personality;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "NPC Configuration")
    FString NPCName;

    UFUNCTION(BlueprintCallable, Category = "NPC")
    void GenerateResponse(const FString& PlayerMessage, const FString& Context = "");

    UFUNCTION(BlueprintCallable, Category = "NPC")
    void AddMemory(const FString& Role, const FString& Content);

protected:
    virtual void BeginPlay() override;

private:
    UPROPERTY()
    TArray<FNPCMemory> Memories;

    const FString API_BASE_URL = "https://api.chromagolem.com/v1";
    const int32 MAX_MEMORIES = 20;

    void OnResponseReceived(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful);
    FString BuildRequestBody(const FString& PlayerMessage, const FString& Context);
    FString GetFallbackResponse();
};

// ChromaNPCComponent.cpp
void UChromaNPCComponent::GenerateResponse(const FString& PlayerMessage, const FString& Context)
{
    TSharedRef<IHttpRequest, ESPMode::ThreadSafe> Request = FHttpModule::Get().CreateRequest();
    Request->OnProcessRequestComplete().BindUObject(this, &UChromaNPCComponent::OnResponseReceived);
    
    Request->SetURL(API_BASE_URL + "/chat/completions");
    Request->SetVerb("POST");
    Request->SetHeader("Content-Type", "application/json");
    Request->SetHeader("Authorization", "Bearer " + ApiKey);
    
    FString RequestBody = BuildRequestBody(PlayerMessage, Context);
    Request->SetContentAsString(RequestBody);
    
    AddMemory("user", PlayerMessage);
    Request->ProcessRequest();
}

extends Node
class_name ChromaNPC

# NPC Configuration
@export var api_key: String = "your_api_key_here"
@export_multiline var personality: String = "You are Elara, a skilled alchemist..."
@export var npc_name: String = "Elara"
@export var max_memories: int = 20

# Private variables
var memories: Array = []
var http_request: HTTPRequest
const API_BASE_URL = "https://api.chromagolem.com/v1"

# Signals
signal response_received(response: String)
signal request_failed(error: String)

func _ready():
    # Initialize HTTP request node
    http_request = HTTPRequest.new()
    add_child(http_request)
    http_request.request_completed.connect(_on_request_completed)

func generate_response(player_message: String, context: Dictionary = {}):
    """Generate an NPC response to player input."""
    
    var messages = _build_message_array(player_message, context)
    
    var request_data = {
        "messages": messages,
        "client_id": context.get("player_id", "default")
    }
    
    var json_string = JSON.stringify(request_data)
    var headers = [
        "Content-Type: application/json",
        "Authorization: Bearer " + api_key
    ]
    
    # Store player message in memory
    add_memory("user", player_message)
    
    # Make HTTP request
    var error = http_request.request(API_BASE_URL + "/chat/completions", headers, HTTPClient.METHOD_POST, json_string)
    
    if error != OK:
        request_failed.emit("Failed to make HTTP request")
        return _get_fallback_response()

func add_memory(role: String, content: String):
    """Add a new memory to the NPC's memory system."""
    var memory = {
        "role": role,
        "content": content,
        "timestamp": Time.get_unix_time_from_system()
    }
    
    memories.append(memory)
    
    # Trim old memories
    if memories.size() > max_memories:
        memories = memories.slice(-max_memories)

func make_decision(situation: String, options: Array) -> Dictionary:
    """Have the NPC make a decision given a situation and options."""
    var decision_prompt = """
Situation: %s
Available options: %s

Respond with JSON containing your decision:
{
  "chosen_action": "selected option",
  "reasoning": "why you chose this",
  "confidence": 75
}""" % [situation, ", ".join(options)]
    
    # This would typically be async, but simplified for example
    var response = generate_response(decision_prompt)
    
    # Parse JSON response
    var json = JSON.new()
    var parse_result = json.parse(response)
    
    if parse_result == OK:
        return json.data
    else:
        # Return default decision
        return {
            "chosen_action": options[0] if options.size() > 0 else "wait",
            "reasoning": "Default choice due to parsing error",
            "confidence": 50
        }

func _on_request_completed(result: int, response_code: int, headers: PackedStringArray, body: PackedByteArray):
    if response_code == 200:
        var json = JSON.new()
        var parse_result = json.parse(body.get_string_from_utf8())
        
        if parse_result == OK:
            var response_data = json.data
            var npc_response = response_data["choices"][0]["message"]["content"]
            
            # Store NPC response in memory
            add_memory("assistant", npc_response)
            
            response_received.emit(npc_response)
        else:
            request_failed.emit("Failed to parse JSON response")
    else:
        request_failed.emit("HTTP request failed with code: " + str(response_code))

func _get_fallback_response() -> String:
    var fallbacks = [
        "I'm having trouble thinking clearly right now.",
        "Could you repeat that? My mind wandered.",
        "I'm not sure I understand. Could you explain differently?"
    ]
    return fallbacks[randi() % fallbacks.size()]