command line interaction

.gitignore

@@ -0,0 +1 @@
+*.pyc

Evaluate_langchain.py

@@ -17,61 +17,50 @@ from utils.utils import convert_choice
 
 def evaluate_langchain():
     print('--------------------------评估优化中--------------------------')
-    llm = OpenAI(temperature=0)
-
     chat = ChatOpenAI(temperature=0)
-
-    tools = load_tools(["serpapi", "llm-math"], llm=llm)
-
-    agent = initialize_agent(tools,
-                             chat,
-                             agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,
-                             verbose=True)
-
     model = global_model()
+    # llm = OpenAI(temperature=0)
+    # tools = load_tools(["serpapi", "llm-math"], llm=llm)
+    # agent = initialize_agent(tools,
+    #                          chat,
+    #                          agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,
+    #                          verbose=True)
 
-    output_declare = {
-        '事件':
-        '字符串格式，这是展示给玩家的，讲述了玩家当前遇到的事件，例如“0岁，你出生于颍川一个富贵之家...”。出现新的人物时需要在事件中对新的人物进行描写，并在当前角色设定中添加新的角色',
-        '是否需要玩家选择下一步操作': 'Boolean格式',
-        '玩家可以做出的选择': '数组格式，玩家可以做出的有限个选择，如果不需要玩家做选择则返回空数组',
-        '当前角色设定': '数组格式，游戏中的npc角色设定，包括角色的名字、特征',
-        '当前数值系统':
-        '数组格式，数值系统包括游戏中的数值名称、数值范围、数值含义，例如装备系统、官职系统等；允许由于故事的发展而添加新的数值',
-        '游戏是否结束': 'Boolean格式，游戏是否结束',
-    }
+    output_type = str(model.evaluate_declare)
+    events = model.get_events()
+    event_for_now = events[-1]
 
-    output_type = ""
-    for key, value in output_declare.items():
-        output_type += key + ":" + value + ","
-
-    event_for_now = model.events[-1]
-
-    system_template = "我在生成一个文字冒险游戏，我在使用另一个gpt生成游戏的事件，需要你根据游戏当前信息对其生成内容进行检查与修改，保证生成内容没有逻辑错误，以如下格式输出JSON：{output_type},严禁输出其他内容,只输出json字符串"
+    system_template = model.evaluate_system_template
     system_message_prompt = SystemMessagePromptTemplate.from_template(
         system_template)
-    human_template = "另一个gpt生成的内容：{event_for_now},严禁输出其他内容,只输出json字符串"
+    human_template = model.evaluate_human_template
     human_message_prompt = HumanMessagePromptTemplate.from_template(
         human_template)
-
     chat_prompt = ChatPromptTemplate.from_messages(
         [system_message_prompt, human_message_prompt])
+
     # rsp = agent.run(
     #     chat_prompt.format_prompt(output_type=output_type,
     #                               event_for_now=event_for_now).to_messages())
     rsp = chat(
         chat_prompt.format_prompt(output_type=output_type,
                                   event_for_now=event_for_now).to_messages())
+    print('[优化]--------------------------GPT得到--------------------------')
     print(rsp.content)
     try:
         game_event = json.loads(rsp.content, object_hook=convert_choice)
     except:
         print('格式错误，修复中')
         game_event = format_langchain(rsp.content, output_type)
-    model.events[-1] = {
+    events[-1] = {
         "事件": game_event["事件"],
         "是否需要玩家选择下一步操作": game_event["是否需要玩家选择下一步操作"],
         "玩家可以做出的选择": game_event["玩家可以做出的选择"],
+        "当前场景角色": game_event["当前场景角色"],
+        "当前场景数值系统": game_event["当前场景数值系统"],
     }
+    model.update_events(events)
+    print(
+        '[优化]--------------------------json.loads得到--------------------------')
     print(game_event)
     return game_event

config/evaluate_config.json

@@ -0,0 +1,12 @@
+{
+    "evaluate_declare": {
+        "事件": "字符串格式，这是展示给玩家的，讲述了玩家当前遇到的事件，例如“0岁，你出生于颍川一个富贵之家...”。出现新的人物时需要在事件中对新的人物进行描写，并在当前角色设定中添加新的角色",
+        "是否需要玩家选择下一步操作": "Boolean格式",
+        "玩家可以做出的选择": "数组格式，玩家可以做出的有限个选择，如果不需要玩家做选择则返回空数组",
+        "当前场景角色": "数组格式，游戏中的npc角色设定，包括角色的名字、特征",
+        "当前场景数值系统": "数组格式，数值系统包括游戏中的数值名称、数值范围、数值含义，例如装备系统、官职系统等；允许由于故事的发展而添加新的数值",
+        "游戏是否结束": "Boolean格式，游戏是否结束"
+    },
+    "system_template": "我在生成一个文字冒险游戏，我在使用另一个gpt生成游戏的事件，需要你根据游戏当前信息对其生成内容进行检查与修改，保证生成内容没有逻辑错误，以如下格式输出JSON：{output_type},严禁输出其他内容,只输出json字符串",
+    "human_template": "另一个gpt生成的内容：{event_for_now},严禁输出其他内容,只输出json字符串"
+}

config/event_config.json

@@ -0,0 +1,12 @@
+{
+    "event_declare": {
+        "事件": "字符串格式，这是展示给玩家的，讲述了玩家当前遇到的事件，例如“0岁，你出生于颍川一个富贵之家...”。出现新的人物时需要在事件中对新的人物进行描写，并在当前角色设定中添加新的角色",
+        "是否需要玩家选择下一步操作": "Boolean格式",
+        "玩家可以做出的选择": "数组格式，玩家可以做出的有限个选择，如果不需要玩家做选择则返回空数组",
+        "当前场景角色": "数组格式，游戏中的npc角色设定，包括角色的名字、特征",
+        "当前场景数值系统": "数组格式，数值系统包括游戏中的数值名称、数值范围、数值含义，例如装备系统、官职系统等；允许由于故事的发展而添加新的数值",
+        "游戏是否结束": "Boolean格式，游戏是否结束"
+    },
+    "system_template": "我正在生成一个文字冒险游戏，我将输入游戏当前信息与当前游戏的风格、简介，需要你根据游戏当前信息生成玩家接下来遇到的下一个事件，以如下格式输出JSON：{output_type}，严格按照格式输出，不要输出除了json字符串之外的其他内容",
+    "human_template": "游戏风格：{style}，游戏参考：{story}，当前信息：{intro}"
+}

config/format_config.json

@@ -0,0 +1,4 @@
+{
+    "system_template": "将输入字符串转为可以使用json.load读取的字符串,格式如下{output_type}，key值和value的类型以上述格式为准，不要输出除了json字符串之外的其他内容",
+    "human_template": "{text}"
+}

config/input_config.json

@@ -0,0 +1,12 @@
+{
+    "story": "三国，搞笑",
+    "style": "始于黄巾起义的混乱时代，我叫摸鱼，是黄巾军的一员，也是一名墨家子弟，年龄16岁",
+    "intro_declare": {
+        "故事简介": "字符串格式，这是展示给玩家的故事简介与游戏目标",
+        "角色设定": "数组格式，游戏中的npc角色设定，包括角色的名字、特征;不包含玩家所操控的角色",
+        "数值系统": "数组格式，数值系统包括游戏中的数值名称、数值范围、数值含义，例如装备系统、官职系统等",
+        "游戏通关所需条件": "字符串格式，游戏结束的条件，例如“成为了诸侯王”"
+    },
+    "system_template": "以如下格式输出可以被json.load读取的JSON字符串：{output_type}",
+    "human_template": "我希望生成一个文字冒险游戏，以下是对游戏故事的要求：故事风格：{style}，故事参考：{story}"
+}

config/value_config.json

@@ -0,0 +1,5 @@
+{
+    "value_declare": "数组格式，数组中的元素为int,分别对应数值系统中的数值",
+    "system_template": "以如下格式输出JSON：{output_type}",
+    "human_template": "我正在生成一个文字游戏，我将输入游戏当前信息，需要你根据游戏当前信息生成玩家当前数值，如果当前玩家数值为空，则进行初始化;如果不为空，则根据已经发生的最后一个事件对数值进行修改，游戏信息：{intro};严禁输出除了数值数组之外的其他内容，输出示例：[100,50,1,1],你的输出为："
+}

event_langchain.py

@@ -16,30 +16,17 @@ def event_langchain():
     print('--------------------------生成事件中--------------------------')
     chat = ChatOpenAI(temperature=0)
     model = global_model()
-    output_declare = {
-        '事件':
-        '字符串格式，这是展示给玩家的，讲述了玩家当前遇到的事件，例如“0岁，你出生于颍川一个富贵之家...”。出现新的人物时需要在事件中对新的人物进行描写，并在当前角色设定中添加新的角色',
-        '是否需要玩家选择下一步操作': 'Boolean格式',
-        '玩家可以做出的选择': '数组格式，玩家可以做出的有限个选择，如果不需要玩家做选择则返回空数组',
-        '当前角色设定': '数组格式，游戏中的npc角色设定，包括角色的名字、特征',
-        '当前数值系统':
-        '数组格式，数值系统包括游戏中的数值名称、数值范围、数值含义，例如装备系统、官职系统等；允许由于故事的发展而添加新的数值',
-        '游戏是否结束': 'Boolean格式，游戏是否结束',
-    }
 
-    output_type = ""
-    for key, value in output_declare.items():
-        output_type += key + ":" + value + ","
+    output_type = str(model.event_declare)
+    intro = model.get_intro_str()
 
-    intro = model.get_intro()
+    style = model.style
+    story = model.story
 
-    style = '三国，TAVG，搞笑'
-    story = '始于黄巾起义的混乱时代，我叫摸鱼，是黄巾军的一员，也是一名墨家子弟，年龄16岁'
-
-    system_template = "我正在生成一个文字冒险游戏，我将输入游戏当前信息与当前游戏的风格、简介，需要你根据游戏当前信息生成玩家接下来遇到的下一个事件，以如下格式输出JSON：{output_type}，严格按照格式输出，不要输出除了json字符串之外的其他内容"
+    system_template = model.event_system_template
     system_message_prompt = SystemMessagePromptTemplate.from_template(
         system_template)
-    human_template = "游戏风格：{style}，游戏参考：{story}，当前信息：{intro}"
+    human_template = model.event_human_template
     human_message_prompt = HumanMessagePromptTemplate.from_template(
         human_template)
 
@@ -58,13 +45,14 @@ def event_langchain():
         print('格式错误，修复中')
         game_event = format_langchain(rsp.content, output_type)
     print(game_event)
-    model.events.append({
+    model.add_event({
         "事件": game_event["事件"],
         "是否需要玩家选择下一步操作": game_event["是否需要玩家选择下一步操作"],
         "玩家可以做出的选择": game_event["玩家可以做出的选择"],
+        "当前场景角色": game_event["当前场景角色"],
+        "当前场景数值系统": game_event["当前场景数值系统"],
+        "游戏是否结束": game_event["游戏是否结束"],
     })
-    model.npc = game_event["当前角色设定"]
-    model.value_system = game_event["当前数值系统"]
-    model.if_end = game_event["游戏是否结束"]
+    model.update_if_end(game_event["游戏是否结束"])
     value = value_langchain()
     return game_event

format_langchain.py

@@ -5,18 +5,20 @@ from langchain.prompts.chat import (
     SystemMessagePromptTemplate,
     HumanMessagePromptTemplate,
 )
+from global_langchain import global_model
 
 from utils.utils import convert_choice
 
 
 def format_langchain(text, output_type):
-    print('--------------------------修复格式中--------------------------')
+    print('[修复]--------------------------修复格式中--------------------------')
     chat = ChatOpenAI(temperature=0)
+    model = global_model()
 
-    system_template = "将输入字符串转为可以使用json.load读取的字符串,格式如下{output_type}，key值和value的类型以上述格式为准，不要输出除了json字符串之外的其他内容"
+    system_template = model.format_system_template
     system_message_prompt = SystemMessagePromptTemplate.from_template(
         system_template)
-    human_template = "{text}"
+    human_template = model.format_human_template
     human_message_prompt = HumanMessagePromptTemplate.from_template(
         human_template)
 
@@ -26,10 +28,13 @@ def format_langchain(text, output_type):
     rsp = chat(
         chat_prompt.format_prompt(output_type=output_type,
                                   text=text).to_messages())
+    print('[修复]--------------------------GPT得到--------------------------')
     print(rsp.content)
     try:
         result = json.loads(rsp.content, object_hook=convert_choice)
     except:
         result = format_langchain(text, output_type)
+    print(
+        '[修复]--------------------------json.loads得到--------------------------')
     print(result)
     return result

global_langchain.py

@@ -1,9 +1,13 @@
+from peewee import *
+import json
+
+
 def singleton(cls):
     _instance = {}
 
-    def inner():
+    def inner(id=0, config_flag=True):
         if cls not in _instance:
-            _instance[cls] = cls()
+            _instance[cls] = cls(id, config_flag)
         return _instance[cls]
 
     return inner
@@ -11,22 +15,232 @@ def singleton(cls):
 
 @singleton
 class global_model():
-    intro = ''
-    npc = []
-    value_system = []
-    win_condition = ''
-    value_for_now = []
-    events = []
-    if_end=False
+    def __init__(self, id=0, config_flag=True):
+        '''
+        Database
+        '''
+        print("[Model]Global_model has been created!")
+        self.db = SqliteDatabase('my_database.db')
+        self.id = 0
 
-    def get_intro(self):
+        class BaseModel(Model):
+            class Meta:
+                database = self.db
+
+        class GameData(BaseModel):
+            id = AutoField(primary_key=True)
+            intro = TextField()
+            npc = TextField()
+            value_system = TextField()
+            win_condition = TextField()
+            value_for_now = TextField()
+            events = TextField()
+            if_end = BooleanField()
+            story = TextField()
+            style = TextField()
+            intro_declare = TextField()
+            input_system_template = TextField()
+            input_human_template = TextField()
+            event_declare = TextField()
+            event_system_template = TextField()
+            event_human_template = TextField()
+            value_declare = TextField()
+            value_system_template = TextField()
+            value_human_template = TextField()
+            evaluate_declare = TextField()
+            evaluate_system_template = TextField()
+            evaluate_human_template = TextField()
+            format_system_template = TextField()
+            format_human_template = TextField()
+
+        self.db.connect()
+        self.db.create_tables([GameData])
+        self.GameData = GameData
+        print("[Model]Database initialized!")
+        '''
+        Input Config
+        '''
+        with open('config/input_config.json', 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        self.story = data[
+            "story"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).story
+        self.style = data[
+            "style"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).style
+        self.intro_declare = data[
+            "intro_declare"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).intro_declare
+        self.input_system_template = data[
+            "system_template"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).input_system_template
+        self.input_human_template = data[
+            "human_template"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).input_human_template
+        '''
+        Event Config
+        '''
+        with open('config/event_config.json', 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        self.event_declare = data[
+            "event_declare"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).event_declare
+        self.event_system_template = data[
+            "system_template"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).event_system_template
+        self.event_human_template = data[
+            "human_template"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).event_human_template
+        '''
+        Value Config
+        '''
+        with open('config/value_config.json', 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        self.value_declare = data[
+            "value_declare"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).value_declare
+        self.value_system_template = data[
+            "system_template"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).value_system_template
+        self.value_human_template = data[
+            "human_template"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).value_human_template
+        '''
+        Evaluate Config
+        '''
+        with open('config/evaluate_config.json', 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        self.evaluate_declare = data[
+            "evaluate_declare"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).evaluate_declare
+        self.evaluate_system_template = data[
+            "system_template"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).evaluate_system_template
+        self.evaluate_human_template = data[
+            "human_template"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).evaluate_human_template
+        '''
+        Format Config
+        '''
+        with open('config/format_config.json', 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        self.format_system_template = data[
+            "system_template"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).format_system_template
+        self.format_human_template = data[
+            "human_template"] if id == 0 and config_flag else self.GameData.get_by_id(
+                id).format_human_template
+        if id != 0:
+            self.id = id
+
+    def get_intro_str(self):
         intro = ""
-        intro += "故事简介:" + self.intro + ","
-        intro += "角色设定:" + str(self.npc) + ","
-        intro += "数值系统:" + str(self.value_system) + ","
-        intro += "游戏通关所需条件:" + self.win_condition + ","
-        intro += "玩家当前数值:" + str(self.value_for_now) + ","
-        intro += "已经发生的事件:" + str(self.events)
-        print('获取intro:')
-        print(intro)
+        intro += "故事简介:" + self.get_intro() + ","
+        intro += "角色设定:" + str(self.get_npc()) + ","
+        intro += "数值系统:" + str(self.get_value_system()) + ","
+        intro += "游戏通关所需条件:" + self.get_win_condition() + ","
+        intro += "玩家当前数值:" + str(self.get_value_for_now()) + ","
+        intro += "已经发生的事件:" + str(self.get_events())
+        return intro
+
+    def input_init(self, intro, npc, value_system, win_condition):
+        new_model = self.GameData.create(
+            intro=intro,
+            npc=str(npc),
+            value_system=str(value_system),
+            win_condition=win_condition,
+            value_for_now=str([]),
+            events=str([]),
+            if_end=False,
+            story=self.story,
+            style=self.style,
+            intro_declare=str(self.intro_declare),
+            input_system_template=self.input_system_template,
+            input_human_template=self.input_human_template,
+            event_declare=str(self.event_declare),
+            event_system_template=self.event_system_template,
+            event_human_template=self.event_human_template,
+            value_declare=str(self.value_declare),
+            value_system_template=self.value_system_template,
+            value_human_template=self.value_human_template,
+            evaluate_declare=str(self.evaluate_declare),
+            evaluate_system_template=self.evaluate_system_template,
+            evaluate_human_template=self.evaluate_human_template,
+            format_system_template=self.format_system_template,
+            format_human_template=self.format_human_template)
+        self.id = new_model.id
+
+    def get_intro(self):
+        try:
+            intro = self.GameData.get(self.GameData.id == self.id).intro
+        except:
+            intro = ""
         return intro
+
+    def get_npc(self):
+        try:
+            npc = eval(self.GameData.get(self.GameData.id == self.id).npc)
+        except:
+            npc = []
+        return npc
+
+    def get_value_system(self):
+        try:
+            value_system = eval(
+                self.GameData.get(self.GameData.id == self.id).value_system)
+        except:
+            value_system = []
+        return value_system
+
+    def get_win_condition(self):
+        try:
+            win_condition = self.GameData.get(
+                self.GameData.id == self.id).win_condition
+        except:
+            win_condition = ""
+        return win_condition
+
+    def get_value_for_now(self):
+        try:
+            value_for_now = eval(
+                self.GameData.get(self.GameData.id == self.id).value_for_now)
+        except:
+            value_for_now = []
+        return value_for_now
+
+    def get_events(self):
+        try:
+            events = eval(
+                self.GameData.get(self.GameData.id == self.id).events)
+        except:
+            events = []
+        return events
+
+    def add_event(self, event):
+        try:
+            events = eval(
+                self.GameData.get(self.GameData.id == self.id).events)
+        except:
+            events = []
+        events.append(event)
+        self.GameData.update(events=str(events)).where(
+            self.GameData.id == self.id).execute()
+
+    def update_events(self, events):
+        self.GameData.update(events=str(events)).where(
+            self.GameData.id == self.id).execute()
+
+    def update_value_for_now(self, value_for_now):
+        self.GameData.update(value_for_now=str(value_for_now)).where(
+            self.GameData.id == self.id).execute()
+
+    def update_if_end(self, if_end):
+        self.GameData.update(if_end=if_end).where(
+            self.GameData.id == self.id).execute()
+
+    def get_if_end(self):
+        try:
+            if_end = self.GameData.get(self.GameData.id == self.id).if_end
+        except:
+            if_end = False
+        return if_end

input_main.py

@@ -13,46 +13,40 @@ from global_langchain import global_model
 from value_langchain import value_langchain
 
 
-def input_langchain(style, story,output_type,system_template,human_template):
-    print('--------------------------初始化中--------------------------')
+def input_langchain():
+    print('[初始化]--------------------------初始化中--------------------------')
     chat = ChatOpenAI(temperature=0)
-
-    # output_declare = {
-    #     '故事简介': '字符串格式，这是展示给玩家的故事简介与游戏目标',
-    #     '角色设定': '数组格式，游戏中的npc角色设定，包括角色的名字、特征;不包含玩家所操控的角色',
-    #     '数值系统': '数组格式，数值系统包括游戏中的数值名称、数值范围、数值含义，例如装备系统、官职系统等',
-    #     '游戏通关所需条件': '字符串格式，游戏结束的条件，例如“成为了诸侯王”'
-    # }
+    model = global_model()
 
     # output_type = ""
     # for key, value in output_declare.items():
     #     output_type += key + ":" + value + ","
-
-    # system_template = "以如下格式输出JSON：{output_type}"
+    output_type = str(model.intro_declare)
+    system_template = model.input_system_template
     system_message_prompt = SystemMessagePromptTemplate.from_template(
         system_template)
-    # human_template = "我希望生成一个文字冒险游戏，以下是对游戏故事的要求：故事风格：{style}，故事参考：{story}"
+    human_template = model.input_human_template
     human_message_prompt = HumanMessagePromptTemplate.from_template(
         human_template)
-
     chat_prompt = ChatPromptTemplate.from_messages(
         [system_message_prompt, human_message_prompt])
-
     rsp = chat(
         chat_prompt.format_prompt(output_type=output_type,
-                                  style=style,
-                                  story=story).to_messages())
+                                  style=model.style,
+                                  story=model.story).to_messages())
+
+    print('[初始化]--------------------------GPT得到--------------------------')
     print(rsp.content)
     try:
         game_intro = json.loads(rsp.content)
     except:
         print('格式错误，修复中')
         game_intro = format_langchain(rsp.content, output_type)
+    print(
+        '[初始化]--------------------------json.loads得到--------------------------'
+    )
     print(game_intro)
-    model = global_model()
-    model.intro = game_intro["故事简介"]
-    model.npc = game_intro["角色设定"]
-    model.value_system = game_intro["数值系统"]
-    model.win_condition = game_intro["游戏通关所需条件"]
+    model.input_init(game_intro["故事简介"], game_intro["角色设定"],
+                     game_intro["数值系统"], game_intro["游戏通关所需条件"])
     value_langchain()
     return game_intro

main_langchain.py

@@ -4,48 +4,33 @@ from Evaluate_langchain import evaluate_langchain
 from event_langchain import event_langchain
 from global_langchain import global_model
 from input_main import input_langchain
-# import gradio as gr
 
-# def run_model(style, story, output_type, system_template, human_template):
-#     model = global_model()
-#     input_langchain(style, story, output_type, system_template, human_template)
-#     return model.intro
-
-# iface = gr.Interface(
-#     fn=run_model,
-#     inputs=[
-#         gr.inputs.Textbox(lines=2, label="故事风格", default="三国，TAVG"),
-#         gr.inputs.Textbox(lines=2,
-#                           label="故事参考",
-#                           default="始于黄巾起义的混乱时代，我叫摸鱼，是黄巾军的一员，也是一名墨家子弟，年龄16岁"),
-#         gr.inputs.Textbox(lines=2,
-#                           label="系统模板",
-#                           default="以如下格式输出JSON：{output_type}"),
-#         gr.inputs.Textbox(
-#             lines=2,
-#             label="用户模板",
-#             default="我希望生成一个文字冒险游戏，以下是对游戏故事的要求：故事风格：{style}，故事参考：{story}"),
-#         gr.inputs.Textbox(
-#             lines=2,
-#             label="输出模板",
-#             default=
-#             "故事简介:字符串格式，这是展示给玩家的故事简介与游戏目标;角色设定:数组格式，游戏中的npc角色设定，包括角色的名字、特征,不包含玩家所操控的角色;数值系统:数组格式，数值系统包括游戏中的数值名称、数值范围、数值含义，例如装备系统、官职系统等;游戏通关所需条件:字符串格式，游戏结束的条件，例如成为了诸侯王"
-#         ),
-#     ],
-#     outputs=[
-#         gr.outputs.Textbox(label="故事简介"),
-#     ])
-
-# iface.launch()
-
-# model = global_model()
-# input_langchain()
-# while True:
-#     event = event_langchain()
-#     event_after_evaluate = evaluate_langchain()
-#     if model.if_end == True:
-#         break
-#     if model.events[-1]["是否需要玩家选择下一步操作"] == True:
-#         print(model.events[-1]["玩家可以做出的选择"])
-#         choose = int(input("请选择："))
-#         model.events[-1]["玩家选择"] = model.events[-1]["玩家可以做出的选择"][choose]
+if_new = int(input("[选择]是否使用数据库中的记录：①新游戏 ②读取存档------"))
+if if_new == 2:
+    record_id = int(input("[选择]输入存档id------"))
+    config_flag = int(input("[选择]是否使用数据库中的配置：①使用 ②不使用------"))
+    model = global_model(record_id, True if config_flag == 1 else False)
+else:
+    model = global_model()
+    input_langchain()
+if_evaluate = int(input("[选择]是否在每次生成事件后进行优化诊断：①是 ②否------"))
+while True:
+    events = model.get_events()
+    if len(events) != 0:
+        if events[-1]["是否需要玩家选择下一步操作"] == True:
+            if "玩家选择" not in events[-1]:
+                print("[玩家选择]当前事件：" + events[-1]["事件"])
+                available_chooses = events[-1]["玩家可以做出的选择"]
+                formatted_choices = ""
+                for i, choice in enumerate(available_chooses, start=1):
+                    formatted_choices += f"{i}. {choice} "
+                print("[玩家选择]可供选择的选项：" + formatted_choices)
+                choose = int(input("[玩家选择]请选择："))
+                events[-1]["玩家选择"] = events[-1]["玩家可以做出的选择"][choose - 1]
+                print("[玩家选择]玩家选择了：" + events[-1]["玩家可以做出的选择"][choose - 1])
+                model.update_events(events)
+    event_langchain()
+    if if_evaluate == 1:
+        evaluate_langchain()
+    if model.get_if_end() == True:
+        break

value_langchain.py

@@ -11,24 +11,17 @@ from global_langchain import global_model
 
 
 def value_langchain():
-    print('--------------------------修改数值中--------------------------')
+    print('[数值]--------------------------修改数值中--------------------------')
     chat = ChatOpenAI(temperature=0)
     model = global_model()
 
-    output_declare = {
-        '玩家当前数值': '数组格式，数组中的元素为int,分别对应数值系统中的数值',
-    }
+    output_type = str(model.value_declare)
+    intro = model.get_intro_str()
 
-    output_type = ""
-    for key, value in output_declare.items():
-        output_type += key + ":" + value + ","
-
-    intro = model.get_intro()
-
-    system_template = "以如下格式输出JSON：{output_type},严禁输出除了数值数组之外的其他内容，输出示例：[100,50,1,1]"
+    system_template = model.value_system_template
     system_message_prompt = SystemMessagePromptTemplate.from_template(
         system_template)
-    human_template = "我正在生成一个文字游戏，我将输入游戏当前信息，需要你根据游戏当前信息生成玩家当前数值，如果当前玩家数值为空，则进行初始化;如果不为空，则根据已经发生的最后一个事件对数值进行修改，游戏信息：{intro}"
+    human_template = model.value_human_template
     human_message_prompt = HumanMessagePromptTemplate.from_template(
         human_template)
 
@@ -40,12 +33,15 @@ def value_langchain():
             output_type=output_type,
             intro=intro,
         ).to_messages())
+    print('[数值]--------------------------GPT得到--------------------------')
     print(rsp.content)
     try:
         value_for_now = json.loads(rsp.content)
     except:
         print('格式错误，修复中')
         value_for_now = format_langchain(rsp.content, output_type)
+    print(
+        '[数值]--------------------------json.loads得到--------------------------')
     print(value_for_now)
-    model.value_for_now = value_for_now
+    model.update_value_for_now(value_for_now)
     return value_for_now