การพัฒนา AI NPC ในเกม: การใช้ LLM สร้างตัวละครสนทนาอัจฉริยะ

เมื่อคืนผมเจอปัญหาหนักใจตอนพัฒนา NPC สำหรับเกม RPG ของตัวเอง — ConnectionError: timeout after 30s ดังขึ้นทุกครั้งที่ผู้เล่นคุยกับ NPC หลายตัวพร้อมกัน แถม token ก็บริโภคเกินงบประมาณอย่างรวดเร็ว หลังจากทดลองหลายวิธี สุดท้ายมาใช้ HolySheep AI แทน API เดิม ตอนนี้ latency ลดลงเหลือต่ำกว่า 50 มิลลิวินาที และค่าใช้จ่ายลดลงกว่า 85% เลยอยากแชร์วิธีการให้ทุกคนได้ลอง

ทำไมต้องใช้ LLM สำหรับ NPC ในเกม

ระบบ NPC แบบเดิมที่ใช้ dialogue tree ต้องเขียน script ล่วงหน้าทั้งหมด ทำให้ผู้เล่นรู้สึกว่า NPC ไม่มีชีวิตชีวา การใช้ LLM ช่วยให้ NPC ตอบสนองได้อย่างเป็นธรรมชาติ จำคำพูดผู้เล่นได้ และปรับบุคลิกภาพตามสถานการณ์ในเกม ข้อดีหลักคือ:

• การสนทนาที่เป็นธรรมชาติและไม่ซ้ำรอย
• NPC จดจำประวัติการสนทนากับผู้เล่นได้
• ปรับแต่งบุคลิกภาพและความรู้เฉพาะทางได้ง่าย
• รองรับหลายภาษารวมถึงภาษาไทย

การตั้งค่า HolySheep API สำหรับ Game NPC

ก่อนเริ่ม ต้องสมัครบัญชีที่ สมัครที่นี่ ก่อน จะได้ API key มาใช้งาน ราคาถูกมากเมื่อเทียบกับคุณภาพ — เพียง 0.42 ดอลลาร์ต่อล้าน token สำหรับ DeepSeek V3.2 หรือ 2.50 ดอลลาร์สำหรับ Gemini 2.5 Flash รองรับ WeChat และ Alipay ด้วย

# ติดตั้ง OpenAI SDK
pip install openai

สร้างไฟล์ game_npc.py

import openai
from openai import OpenAI
import json
import time

class GameNPC:
    def __init__(self, api_key, npc_name, npc_personality, npc_knowledge):
        self.client = OpenAI(
            api_key=api_key,
            base_url="https://api.holysheep.ai/v1"  # บรรทัดสำคัญ!
        )
        self.npc_name = npc_name
        self.conversation_history = []
        
        # ตั้งค่าบุคลิกภาพและความรู้เฉพาะของ NPC
        self.system_prompt = f"""คุณคือ {npc_name} ในเกม RPG
บุคลิกภาพ: {npc_personality}
ความรู้พื้นฐาน: {npc_knowledge}
ตอบเป็นภาษาไทยอย่างเป็นธรรมชาติ จำคำถามของผู้เล่นได้
ถ้าถามเรื่องที่ไม่รู้ ให้ตอบว่าไม่แน่ใจและแนะนำให้ไปถามคนอื่น"""
    
    def think(self, user_message):
        """ส่งข้อความไปยัง LLM และรับคำตอบ"""
        self.conversation_history.append({
            "role": "user", 
            "content": user_message
        })
        
        try:
            response = self.client.chat.completions.create(
                model="gpt-4.1",  # หรือ deepseek-v3.2, gemini-2.5-flash
                messages=[
                    {"role": "system", "content": self.system_prompt},
                    *self.conversation_history[-10:]  # เก็บ 10 ข้อความล่าสุด
                ],
                temperature=0.8,
                max_tokens=150,
                timeout=10  # timeout 10 วินาที
            )
            
            assistant_message = response.choices[0].message.content
            
            self.conversation_history.append({
                "role": "assistant",
                "content": assistant_message
            })
            
            # แสดง latency จริง
            print(f"⏱️ Response time: {response.response_ms}ms")
            
            return assistant_message
            
        except Exception as e:
            print(f"❌ Error: {e}")
            return f"ขอโทษนะ ไม่สามารถตอบได้ในขณะนี้: {str(e)}"

ทดสอบการใช้งาน
if __name__ == "__main__":
    npc = GameNPC(
        api_key="YOUR_HOLYSHEEP_API_KEY",
        npc_name="พี่สาวชาวบ้าน",
        npc_personality="อบอุ่น ดูแลเอาใจใส่ แต่ก็มีความรู้เรื่องการเดินทางดี",
        npc_knowledge="รู้จักเส้นทางป่าทางตะวันตก มีพี่น้องชาวบ้านที่คอยช่วยเหลือกัน"
    )
    
    # ทดสอบการสนทนา
    print(npc.think("ทางไปหมู่บ้านป่าทางตะวันตกยังไง?"))

ระบบ Conversation Manager สำหรับหลาย NPC

ในเกมจริงต้องมี NPC หลายตัว ต้องจัดการ context แยกกัน ผมใช้ dictionary เก็บ conversation ของแต่ละ NPC และใช้ session_id ระบุว่าผู้เล่นคุยกับ NPC ตัวไหน

import uuid
from collections import defaultdict

class NPCConversationManager:
    def __init__(self, api_key):
        self.client = OpenAI(
            api_key=api_key,
            base_url="https://api.holysheep.ai/v1"
        )
        # เก็บ conversation แยกตาม session_id
        self.sessions = defaultdict(lambda: {
            "npc_name": None,
            "history": []
        })
        self.npc_database = {}
    
    def register_npc(self, npc_id, name, personality, knowledge, avatar=None):
        """ลงทะเบียน NPC ใหม่ในระบบ"""
        self.npc_database[npc_id] = {
            "name": name,
            "personality": personality,
            "knowledge": knowledge,
            "avatar": avatar
        }
    
    def start_conversation(self, session_id, npc_id):
        """เริ่มบทสนทนาใหม่กับ NPC"""
        if npc_id not in self.npc_database:
            return False, f"ไม่พบ NPC: {npc_id}"
        
        npc_info = self.npc_database[npc_id]
        system_prompt = f"""คุณคือ {npc_info['name']} ในเกม
บุคลิกภาพ: {npc_info['personality']}
ความรู้: {npc_info['knowledge']}
ตอบสนองอย่างเป็นธรรมชาติ กระชับ ไม่เกิน 2 ประโยค
ถ้าคำถามอยู่นอกความรู้ ให้บอกว่าไม่รู้อย่างนุ่มนวล"""
        
        self.sessions[session_id] = {
            "npc_id": npc_id,
            "npc_name": npc_info['name'],
            "history": [{"role": "system", "content": system_prompt}]
        }
        return True, f"เริ่มสนทนากับ {npc_info['name']}"
    
    def chat(self, session_id, player_message):
        """ส่งข้อความและรับคำตอบจาก NPC"""
        if session_id not in self.sessions:
            return None, "ไม่พบ session โปรดเริ่มบทสนทนาใหม่"
        
        session = self.sessions[session_id]
        
        # เพิ่มข้อความผู้เล่น
        session["history"].append({
            "role": "user",
            "content": player_message
        })
        
        start_time = time.time()
        
        try:
            response = self.client.chat.completions.create(
                model="gemini-2.5-flash",  # เลือก model ตามความเหมาะสม
                messages=session["history"][-12:],  # context window จำกัด
                temperature=0.7,
                max_tokens=100
            )
            
            elapsed_ms = int((time.time() - start_time) * 1000)
            reply = response.choices[0].message.content
            
            # เก็บประวัติ
            session["history"].append({
                "role": "assistant",
                "content": reply
            })
            
            # ตัด context ถ้าเกิน 20 ข้อความ
            if len(session["history"]) > 20:
                session["history"] = [session["history"][0]] + session["history"][-19:]
            
            return {
                "npc_name": session["npc_name"],
                "reply": reply,
                "latency_ms": elapsed_ms,
                "history_length": len(session["history"])
            }, None
            
        except Exception as e:
            return None, str(e)
    
    def end_conversation(self, session_id):
        """จบบทสนทนา"""
        if session_id in self.sessions:
            del self.sessions[session_id]
            return True
        return False

วิธีใช้งาน
manager = NPCConversationManager("YOUR_HOLYSHEEP_API_KEY")

ลงทะเบียน NPC
manager.register_npc(
    npc_id="blacksmith_001",
    name="ช่างตีดาบหลวง",
    personality="ขรึม เงียบขรึม แต่เชี่ยวชาญด้านอาวุธมาก ชอบเล่าเรื่องสงครามในอดีต",
    knowledge="ตีดาบเหล็ก ซ่อมอาวุธ รู้จักแร่หายาก รู้วิธีเสริมพลังอาวุธ"
)

เริ่มสนทนา
session_id = str(uuid.uuid4())
success, msg = manager.start_conversation(session_id, "blacksmith_001")
print(msg)

พูดคุยกับ NPC
result, error = manager.chat(session_id, "ทำดาบเล่มนี้ให้แข็งแกร่งขึ้นได้ไหม?")
if result:
    print(f"{result['npc_name']}: {result['reply']}")
    print(f"⏱️ Latency: {result['latency_ms']}ms")

การจัดการ Memory และ Context ของ NPC

เทคนิคสำคัญคือการทำให้ NPC จดจำสิ่งที่เกิดขึ้นในเกมได้ ผมใช้ระบบ memory ที่แบ่งเป็น 3 ระดับ:

• Working Memory: ข้อความสนทนาล่าสุด 10-20 ข้อความ
• Episodic Memory: เหตุการณ์สำคัญที่ NPC ร่วมมือหรือทะเลาะกับผู้เล่น
• World Knowledge: ความรู้พื้นฐานของ NPC เกี่ยวกับโลกในเกม

import sqlite3
from datetime import datetime

class NPCMemorySystem:
    def __init__(self, db_path="npc_memory.db"):
        self.conn = sqlite3.connect(db_path, check_same_thread=False)
        self.init_database()
    
    def init_database(self):
        """สร้างตารางสำหรับเก็บความทรงจำ NPC"""
        cursor = self.conn.cursor()
        
        # ตารางความทรงจำระยะสั้น
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS working_memory (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                session_id TEXT,
                npc_id TEXT,
                role TEXT,
                content TEXT,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        # ตารางความทรงจำเหตุการณ์
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS episodic_memory (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                npc_id TEXT,
                player_id TEXT,
                event_type TEXT,
                event_description TEXT,
                emotional_impact INTEGER,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        # ตารางสถานะ NPC
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS npc_state (
                npc_id TEXT PRIMARY KEY,
                trust_level INTEGER DEFAULT 0,
                mood TEXT DEFAULT 'neutral',
                last_interaction DATETIME
            )
        ''')
        
        self.conn.commit()
    
    def save_working_memory(self, session_id, npc_id, role, content):
        """บันทึกข้อความสนทนาปัจจุบัน"""
        cursor = self.conn.cursor()
        cursor.execute('''
แหล่งข้อมูลที่เกี่ยวข้อง
📚 บทช่วยสอน AI API
💰 ดูราคา
📖 เอกสารสำหรับนักพัฒนา
🚀 สมัครฟรี
บทความที่เกี่ยวข้อง
AI API SLA คืออะไร? คู่มือเจรจาสัญญาระดับบริการสำหรับนักพัฒน
สร้างรายงานข้อมูลอัตโนมัติด้วย Natural Language Generation A
AI กับการจัดการห่วงโซ่อุปทาน: การคาดการณ์ความต้องการและสินค้