first commit

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.ico filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+**/__pycache__/**
+**/chromadb_saves/
+/log/
+/experiment_saves/
+run.sh
+/config/
+.vscode/
+nohup.out
+BookWorld_test.py

BookWorld.py

@@ -0,0 +1,1064 @@
+from datetime import datetime
+from tqdm import tqdm 
+import json 
+import os
+import warnings
+import random
+from typing import Any, Dict, List, Optional, Literal
+from collections import defaultdict
+import uuid
+
+from bw_utils import *
+from modules.main_role_agent import RPAgent
+from modules.world_agent import WorldAgent
+from modules.history_manager import HistoryManager
+import argparse
+
+warnings.filterwarnings('ignore')
+
+class Server():
+    def __init__(self,
+                 preset_path: str,
+                 world_llm_name: str,
+                 role_llm_name: str,
+                 embedding_name:str = "bge-m3") :
+        """
+        The initialization function of the system.
+        
+        Args:
+            preset_path (str): The path to config file of this experiment.
+            world_llm_name (str, optional): The base model of the world agent. Defaults to 'gpt-4o'.
+            role_llm_name (str, optional): The base model of all the role agents. Defaults to 'gpt-4o'.
+            mode (str, optional): If set to be 'script', the role agents will act according to the given script. 
+                                  If set to be 'free', the role agents will act freely based on their backround.
+                                  Defaults to 'free'.
+        """
+        
+        self.role_llm_name: str = role_llm_name
+        self.world_llm_name: str = world_llm_name
+        self.embedding_name:str = embedding_name
+        config = load_json_file(preset_path)
+        self.preset_path = preset_path
+        self.config: Dict = config
+        self.experiment_name: str = os.path.basename(preset_path).replace(".json","") + "/" + config["experiment_subname"] + "_" + role_llm_name
+        
+        role_agent_codes: List[str] = config['role_agent_codes']
+        world_file_path: str = config["world_file_path"]
+        map_file_path: str = config["map_file_path"] if "map_file_path" in config else ""
+        role_file_dir: str = config["role_file_dir"] if "role_file_dir" in config else "./data/roles/"
+        loc_file_path: str = config["loc_file_path"]
+        self.intervention: str = "" if  "intervention" in config else ""
+        self.event = self.intervention
+        self.script: str = config["script"] if "script" in config else ""
+        self.language: str = config["language"] if "language" in config else "zh"
+        self.source:str = config["source"] if "source" in config else ""
+        
+        self.idx: int = 0
+        self.cur_round: int = 0
+        self.progress: str = "剧本刚刚开始，还什么都没有发生" if self.language == 'zh' else "The story has just begun, nothing happens yet."
+        self.moving_roles_info: Dict[str, Any] = {}   
+        self.history_manager = HistoryManager()
+        self.start_time = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        self.current_status = {
+            "location_code":"",
+            "group":role_agent_codes,
+        }
+        self.scene_characters = {}
+        self.event_history = []
+        
+        self.role_llm = get_models(role_llm_name)
+        self.logger = get_logger(self.experiment_name)
+        self.init_role_agents(role_agent_codes = role_agent_codes,
+                            role_file_dir = role_file_dir,
+                            world_file_path=world_file_path,
+                            llm = self.role_llm)
+        
+        if world_llm_name == role_llm_name:
+            self.world_llm = self.role_llm
+        else:
+            self.world_llm = get_models(world_llm_name)
+        self.init_world_agent_from_file(world_file_path = world_file_path,
+                                        map_file_path = map_file_path,
+                                        loc_file_path = loc_file_path,
+                                        llm = self.world_llm)
+    
+    # Init
+    def init_role_agents(self, 
+                         role_agent_codes: List[str], 
+                         role_file_dir:str, 
+                         world_file_path:str,
+                         llm) -> None:
+        self.role_codes: List[str] = role_agent_codes
+        self.role_agents: Dict[str, RPAgent] = {}
+        
+        for role_code in role_agent_codes:
+            if check_role_code_availability(role_code,role_file_dir):
+                self.role_agents[role_code] = RPAgent(role_code=role_code, 
+                                                      role_file_dir=role_file_dir,
+                                                      world_file_path=world_file_path,
+                                                      source = self.source, 
+                                                      language=self.language,
+                                                      llm_name = self.role_llm_name,
+                                                      llm = llm,
+                                                      embedding_name=self.embedding_name,
+                                                      )
+                # print(f"{role_code} Initialized.")
+            else:
+                print(f"Warning: The specified role `{role_code}` does not exist.")
+    
+    def init_world_agent_from_file(self, 
+                                   world_file_path: str, 
+                                   map_file_path: str,
+                                   loc_file_path: str,
+                                   llm) -> None:
+        self.world_agent: WorldAgent = WorldAgent(world_file_path = world_file_path, 
+                                                  location_file_path = loc_file_path,
+                                                  map_file_path = map_file_path, 
+                                                  llm_name=self.world_llm_name,
+                                                  llm = llm,
+                                                  language=self.language)
+        for role_code in self.role_agents:
+            self.role_agents[role_code].world_db = self.world_agent.db
+            self.role_agents[role_code].world_db_name = self.world_agent.db_name
+        
+    def init_role_locations(self, random_allocate: bool = True):
+        """
+        Set initial positions of the roles.
+        
+        Args:
+            random_allocate (bool, optional): if set to be True, the initial positions of the roles are randomly assigned. Defaults to True.
+        """
+        init_locations_code = random.choices(self.world_agent.locations, k = len(self.role_codes))
+        for i,role_code in enumerate(self.role_codes):
+            self.role_agents[role_code].set_location(init_locations_code[i], self.world_agent.find_location_name(init_locations_code[i]))
+            info_text = f"{self.role_agents[role_code].nickname} 现在位于 {self.world_agent.find_location_name(init_locations_code[i])}" \
+                if self.language == "zh" else f"{self.role_agents[role_code].nickname} is now located at {self.world_agent.find_location_name(init_locations_code[i])}"
+            self.log(info_text)
+    
+    # Simulation        
+    def simulate_generator(self, 
+                 rounds: int = 10, 
+                 save_dir: str = "", 
+                 if_save: Literal[0,1] = 0,
+                 mode: Literal["free", "script"] = "free",
+                 scene_mode: Literal[0,1] = 1,):
+        """
+        The main function of the simulation.
+
+        Args:
+            rounds (int, optional): The max rounds of simulation. Defaults to 10.
+            save_dir (str, optional): _description_. Defaults to "".
+            if_save (Literal[0,1], optional): _description_. Defaults to 0.
+        """
+        self.mode = mode 
+        meta_info: Dict[str, Any] = self.continue_simulation_from_file(save_dir)            
+        self.if_save: int = if_save
+        start_round: int = meta_info["round"]
+        sub_start_round:int = meta_info["sub_round"] if "sub_round" in meta_info else 0
+        if start_round == rounds: return 
+        
+        # Setting Locations
+        if not meta_info["location_setted"]:
+            self.log("========== Start Location Setting ==========")
+            self.init_role_locations()
+            self._save_current_simulation("location")
+            
+        # Setting Goals
+        if not meta_info["goal_setted"]:
+            yield ("system","","-- Setting Goals --",None) 
+            self.log("========== Start Goal Setting ==========")
+            
+            if self.mode == "free":
+                self.get_event()
+                self.log(f"--------- Free Mode: Current Event ---------\n{self.event}\n")
+                self.event_history.append(self.event)
+            elif self.mode == "script":
+                self.get_script()
+                self.log(f"--------- Script Mode: Setted Script ---------\n{self.script}\n")
+                self.event_history.append(self.event)
+            if self.mode == "free":
+                for role_code in self.role_codes:
+                    motivation = self.role_agents[role_code].set_motivation(
+                        world_description = self.world_agent.description, 
+                        other_roles_info = self._get_group_members_info_dict(self.role_agents),
+                        intervention = self.event,
+                        script = self.script
+                        )
+                    info_text = f"{self.role_agents[role_code].nickname} 设立了动机: {motivation}" \
+                        if self.language == "zh" else f"{self.role_agents[role_code].nickname} has set the motivation: {motivation}"
+                    
+                    record_id = str(uuid.uuid4())
+                    self.log(info_text)
+                    self.record(role_code=role_code,
+                                detail=info_text,
+                                actor = role_code,
+                                group = [role_code],
+                                actor_type = 'role',
+                                act_type="goal setting",
+                                record_id = record_id)
+                    yield ("role",role_code,info_text,record_id)
+                    
+            self._save_current_simulation("goal")
+            
+        yield ("system","","-- Simulation Started --",None)
+        selected_role_codes = []
+        # Simulating
+        for current_round in range(start_round, rounds):
+            self.cur_round = current_round
+            self.log(f"========== Round {current_round+1} Started ==========")
+            if self.event and current_round >= 1:
+                self.log(f"--------- Current Event ---------\n{self.event}\n")
+                yield ("world","","-- Current Event --\n"+self.event, None)
+                self.event_history.append(self.event)
+                
+            if len(self.moving_roles_info) == len(self.role_codes):
+                self.settle_movement()
+                continue
+            
+            # Characters in next scene
+            if scene_mode:
+                group = self._name2code(
+                    self.world_agent.decide_screen_actors(
+                        self._get_locations_info(False),
+                        self.history_manager.get_recent_history(5),
+                        self.event,
+                        list(set(selected_role_codes + list(self.moving_roles_info.keys())))))
+                
+                selected_role_codes += group
+                if len(selected_role_codes) > len(self.role_codes):
+                    selected_role_codes = []
+            else:
+                group = self.role_codes
+            self.current_status['group'] = group
+            self.current_status['location_code'] = self.role_agents[group[0]].location_code
+            self.scene_characters[str(current_round)] = group
+            
+            # Prologue 
+            # if current_round == 0 and len(group) > 0 
+            #     prologue = self.world_agent.generate_location_prologue(location_code=self.role_agents[group[0]].location_code, history_text=self._get_history_text(group),event=self.event,location_info_text=self._find_roles_at_location(self.role_agents[group[0]].location_code,name=True))
+            #     self.log("--Prologue--: "+prologue)
+            #     self.record(role_code="None",detail=prologue,act_type="prologue")
+            start_idx = len(self.history_manager)
+
+            sub_round = sub_start_round
+            for sub_round in range(sub_start_round,3):
+                if self.mode == "script":    
+                    self.script_instruct(self.progress)
+                else:
+                    for role_code in group:
+                        self.role_agents[role_code].update_goal(other_roles_status=self._get_status_text(self.role_codes))
+
+                for role_code in group:
+                    if scene_mode:
+                        role_code =  self._name2code(self.world_agent.decide_next_actor("\n".join(self.history_manager.get_recent_history(3)),self._get_group_members_info_text(group,status=True),self.script)) if scene_mode else role_code
+                    
+                    yield from self.implement_next_plan(role_code = role_code,
+                                            group = group)
+                    self._save_current_simulation("action", current_round, sub_round)
+
+                if_end,epilogue = self.world_agent.judge_if_ended("\n".join(self.history_manager.get_recent_history(len(self.history_manager)-start_idx)))
+                if if_end:
+                    record_id = str(uuid.uuid4())
+                    self.log("--Epilogue--: "+epilogue)
+                    self.record(role_code = "None",
+                                detail = epilogue, 
+                                actor_type="world",
+                                act_type="epilogue", 
+                                actor = "world",
+                                group = [],
+                                record_id = record_id)
+                    yield ("world","","--Epilogue--: "+epilogue, record_id)
+                    
+                    break
+            
+                
+            for role_code in group:
+                yield from self.decide_whether_to_move(role_code = role_code,
+                                            group = self._find_group(role_code))
+                self.role_agents[role_code].update_status()
+                
+            self.settle_movement()
+            self.update_event(group)    
+                
+            sub_start_round = 0 
+            self._save_current_simulation("action", current_round + 1,sub_round + 1)
+            
+    # Main functions using llm    
+    def implement_next_plan(self,role_code: str, group: List[str]):
+        other_roles_info = self._get_group_members_info_dict(group)
+        plan = self.role_agents[role_code].plan(
+            other_roles_info = other_roles_info,
+            available_locations = self.world_agent.locations,
+            world_description = self.world_agent.description,
+            intervention = self.event,
+        )
+        
+        info_text = plan["detail"]
+        if plan["target_role_codes"]:
+            plan["target_role_codes"] = self._name2code(plan["target_role_codes"])
+            
+            
+        record_id = str(uuid.uuid4())
+        self.log(f"-Action-\n{self.role_agents[role_code].role_name}: "+ info_text)
+        self.record(role_code = role_code,
+                    detail = plan["detail"],
+                    actor_type = 'role',
+                    act_type = "plan",
+                    actor = role_code,
+                    group = plan["target_role_codes"] + [role_code],
+                    plan = plan,
+                    record_id = record_id
+                        )
+        yield ("role", role_code, info_text, record_id)
+
+        if plan["interact_type"] == "single" and len(plan["target_role_codes"]) == 1 and plan["target_role_codes"][0] in group:
+            yield from self.start_single_role_interaction(plan, record_id)
+        elif plan["interact_type"] == "multi" and len(plan["target_role_codes"]) > 1 and set(plan["target_role_codes"]).issubset(set(group))  :
+            yield from self.start_multi_role_interaction(plan, record_id)
+        elif plan["interact_type"] == "enviroment":
+            yield from self.start_enviroment_interaction(plan,role_code, record_id)
+        elif plan["interact_type"] == "npc" and plan["target_npc_name"]:
+            yield from self.start_npc_interaction(plan,role_code,target_name=plan["target_npc_name"], record_id = record_id)
+        return info_text         
+    
+    def decide_whether_to_move(self, 
+                          role_code: str, 
+                          group: List[str]):
+        if len(self.world_agent.locations) <= 1:
+            return False
+        if_move, move_detail, destination_code = self.role_agents[role_code].move(locations_info_text = self._get_locations_info(), 
+                                                                                  locations_info = self.world_agent.locations_info)
+        if if_move:
+            self.log(move_detail)
+            print(f"角色选择移动。{self.role_agents[role_code].role_name}正在前往{self.world_agent.find_location_name(destination_code)}" if self.language == "zh" else f"The role decides to move. {self.role_agents[role_code].role_name} is heading to {self.world_agent.find_location_name(destination_code)}.")
+            self.record(role_code = role_code,
+                    detail = move_detail,
+                    actor_type = 'role',
+                    act_type = "move",
+                    actor = role_code,
+                    group = [role_code],
+                    destinatiion_code = destination_code
+                        )
+            yield ("role",role_code,move_detail,None)
+            
+            distance = self.world_agent.get_distance(self.role_agents[role_code].location_code, destination_code)
+            self.role_agents[role_code].set_location(location_code=None, location_name=None)
+            self.moving_roles_info[role_code] = {
+                "location_code":destination_code,
+                "distance":distance
+            }
+        return if_move
+          
+    def start_enviroment_interaction(self,
+                                     plan: Dict[str, Any], 
+                                     role_code: str,
+                                     record_id: str):
+        """
+        Handles the role's interaction with the environment. 
+        It gets interaction results from agents in the world, record the result and update the status of the role.
+
+        Args:
+            plan (Dict[str, Any]): The details of the action.
+            role_code (str): The action maker.
+
+        Returns:
+            (str): The enviroment response.
+        """
+        if "action" not in plan:
+            plan["action"] = ""
+        self.current_status['group'] = [role_code]
+        location_code = self.role_agents[role_code].location_code
+        result = self.world_agent.enviroment_interact(action_maker_name = self.role_agents[role_code].role_name,
+                                                            action  = plan["action"],
+                                                            action_detail = conceal_thoughts(self.history_manager.search_record_detail(record_id)),
+                                                            location_code = location_code)
+        env_record_id = str(uuid.uuid4())
+        self.log(f"(Enviroment):{result}")
+        self.record(role_code = role_code,
+                    detail = result,
+                    actor_type = 'world',
+                    act_type = "enviroment",
+                    initiator = role_code,
+                    actor = "world",
+                    group = [role_code],
+                    record_id = env_record_id)
+        yield ("world","","(Enviroment):" + result, env_record_id)
+        
+        return conceal_thoughts(self.history_manager.search_record_detail(record_id)) + self.history_manager.search_record_detail(env_record_id)
+    
+    def start_npc_interaction(self,
+                              plan: Dict[str, Any], 
+                              role_code: str, 
+                              target_name: str,
+                              record_id: str,
+                              max_rounds: int = 3):
+        """
+        Handles the role's interaction with the environment. 
+        It gets interaction results from agents in the world, record the result and update the status of the role.
+
+        Args:
+            plan (Dict[str, Any]): The details of the action.
+            role_code (str): The action maker.
+            target_name (str): The target npc.
+
+        Returns:
+            (str): The enviroment response.
+        """
+        interaction = plan
+        start_idx = len(self.history_manager)
+        
+        self.log(f"----------NPC Interaction----------\n")
+        self.current_status['group'] = [role_code,target_name]
+        for round in range(max_rounds):
+            npc_interaction = self.world_agent.npc_interact(action_maker_name=self.role_agents[role_code].role_name,
+                                                    action_detail=self.history_manager.search_record_detail(record_id),
+                                                    location_name=self.role_agents[role_code].location_name,
+                                                    target_name=target_name)
+            npc_detail = npc_interaction["detail"]
+            
+            npc_record_id = str(uuid.uuid4())
+            self.log(f"{target_name}: " + npc_detail)
+            self.record(role_code = role_code,
+                        detail = npc_detail,
+                        actor_type = 'world',
+                        act_type = "npc",
+                        actor = "world",
+                        group = [role_code],
+                        npc_name = target_name,
+                        record_id = npc_record_id
+                        )
+            yield ("world","",f"(NPC-{target_name}):" + npc_detail, npc_record_id)
+            
+            if npc_interaction["if_end_interaction"]:
+                break
+            
+            interaction = self.role_agents[role_code].npc_interact(
+                npc_name = target_name,
+                npc_response = self.history_manager.search_record_detail(npc_record_id),
+                history = self.history_manager.get_subsequent_history(start_idx = start_idx),
+                intervention = self.event
+            )
+            detail = interaction["detail"]
+            
+            record_id = str(uuid.uuid4())
+            self.log(f"{self.role_agents[role_code].role_name}: " + detail)
+            self.record(role_code = role_code,
+                        detail = detail,
+                        actor_type = 'role',
+                        act_type = "npc",
+                        actor = role_code,
+                        group = [role_code],
+                        npc_name = target_name,
+                        record_id = record_id)
+            yield ("role",role_code,detail,record_id)
+            
+            if interaction["if_end_interaction"]:
+                break
+            if_end,epilogue = self.world_agent.judge_if_ended("\n".join(self.history_manager.get_subsequent_history(start_idx)))
+            if if_end:
+                break
+                
+        return "\n".join(self.history_manager.get_subsequent_history(start_idx = start_idx))
+    
+    def start_single_role_interaction(self,
+                                      plan: Dict[str, Any],
+                                      record_id: str,
+                                      max_rounds: int = 8):
+        interaction = plan
+        acted_role_code = interaction["role_code"]
+        acting_role_code = interaction["target_role_codes"][0]
+        if acting_role_code not in self.role_codes:
+            print(f"Warning: Role {acting_role_code} does not exist.")
+            return
+        self.current_status['group'] = [acted_role_code,acting_role_code]
+        
+        start_idx = len(self.history_manager)
+        for round in range(max_rounds):
+            interaction = self.role_agents[acting_role_code].single_role_interact(
+                action_maker_code = acted_role_code, 
+                action_maker_name = self.role_agents[acted_role_code].role_name,
+                action_detail = conceal_thoughts(self.history_manager.search_record_detail(record_id)), 
+                action_maker_profile = self.role_agents[acted_role_code].role_profile, 
+                intervention = self.event
+            )
+            
+            detail = interaction["detail"]
+            
+            record_id = str(uuid.uuid4())
+            self.log(f"{self.role_agents[acting_role_code].role_name}: " + detail)
+            self.record(role_code = acting_role_code,
+                        detail = detail,
+                        actor_type = 'role',
+                        act_type = "single",
+                        group = [acted_role_code,acting_role_code],
+                        target_role_code = acting_role_code,
+                        planning_role_code = plan["role_code"],
+                        round = round,
+                        record_id = record_id
+                        )
+            yield ("role",acting_role_code,detail,record_id)
+            
+            if interaction["if_end_interaction"]:
+                return
+            if interaction["extra_interact_type"] == "npc":
+                print("---Extra NPC Interact---")
+                result = yield from self.start_npc_interaction(plan=interaction,
+                                                               role_code=acted_role_code,
+                                                               target_name=interaction["target_npc_name"],
+                                                               record_id=record_id)
+                interaction["detail"] = result
+                
+            elif interaction["extra_interact_type"] == "enviroment":
+                print("---Extra Env Interact---")
+                result = yield from self.start_enviroment_interaction(plan=interaction,role_code=acted_role_code,record_id=record_id)
+                interaction["detail"] = result
+                
+            if_end,epilogue = self.world_agent.judge_if_ended("\n".join(self.history_manager.get_subsequent_history(start_idx)))
+            if if_end:
+                break
+            acted_role_code,acting_role_code = acting_role_code,acted_role_code
+        return
+    
+    def start_multi_role_interaction(self, 
+                                     plan: Dict[str, Any], 
+                                     record_id: str,
+                                     max_rounds: int = 8):
+
+        interaction = plan
+        acted_role_code = interaction["role_code"]
+        group = interaction["target_role_codes"]
+        group.append(acted_role_code)
+        
+        for code in group:
+            if code not in self.role_codes:
+                print(f"Warning: Role {code} does not exist.")
+                return
+        self.current_status['group'] = group
+        
+        start_idx = len(self.history_manager)
+        other_roles_info = self._get_group_members_info_dict(group)
+        
+        for round in range(max_rounds):
+            acting_role_code = self._name2code(self.world_agent.decide_next_actor(history_text = "\n".join(self.history_manager.get_recent_history(3)),
+                                                                  roles_info_text = self._get_group_members_info_text(remove_list_elements(group,acted_role_code),status=True)))
+
+            
+            interaction = self.role_agents[acting_role_code].multi_role_interact(
+                action_maker_code = acted_role_code, 
+                action_maker_name = self.role_agents[acted_role_code].role_name,
+                action_detail = conceal_thoughts(self.history_manager.search_record_detail(record_id)), 
+                action_maker_profile = self.role_agents[acted_role_code].role_profile, 
+                other_roles_info = other_roles_info,
+                intervention = self.event
+            )
+            
+            detail = interaction["detail"]
+            
+            record_id = str(uuid.uuid4())
+            self.log(f"{self.role_agents[acting_role_code].role_name}: "+ detail)
+            self.record(role_code = acting_role_code,
+                        detail = detail,
+                        actor_type = 'role',
+                        act_type = "multi",
+                        group = group,
+                        actor = acting_role_code,
+                        planning_role_code = plan["role_code"],
+                        round = round,
+                        record_id = record_id
+                        )
+            yield ("role",acting_role_code,detail,record_id)
+            
+                
+            if interaction["if_end_interaction"]:
+                break
+            result = ""
+            if interaction["extra_interact_type"] == "npc":
+                print("---Extra NPC Interact---")
+                result = yield from self.start_npc_interaction(plan=interaction,role_code=acting_role_code,target_name=interaction["target_npc_name"],record_id = record_id)
+            elif interaction["extra_interact_type"] == "enviroment":
+                print("---Extra Env Interact---")
+                result = yield from self.start_enviroment_interaction(plan=interaction,role_code=acting_role_code,record_id = record_id)
+            interaction["detail"] = self.history_manager.search_record_detail(record_id) + result
+            acted_role_code = acting_role_code
+            if_end,epilogue = self.world_agent.judge_if_ended("\n".join(self.history_manager.get_subsequent_history(start_idx)))
+            if if_end:
+                break
+            
+            return
+    
+    # Sub functions using llm
+    def script_instruct(self, 
+                        last_progress: str, 
+                        top_k: int = 5):
+        """
+        Under the script mode, generate instruction for the roles at the beginning of each round.
+
+        Args:
+            last_progress (str): Where the script went in the last round.
+            top_k (int, optional): The number of action history of each role to refer. Defaults to 1.
+
+        Returns:
+            Dict[str, Any]: Instruction for each role.
+        """
+        roles_info_text = self._get_group_members_info_text(self.role_codes,status=True)
+        history_text = "\n".join([self.role_agents[role_code].history_manager.get_recent_history(1)[0] for role_code in self.role_codes])
+    
+        instruction = self.world_agent.get_script_instruction(
+                                roles_info_text=roles_info_text, 
+                                event = self.event, 
+                                history_text=history_text,
+                                script=self.script,
+                                last_progress = last_progress)
+        
+        for code in instruction:
+            if code == "progress":
+                self.log("剧本进度："+ instruction["progress"]) if self.language == "zh" else self.log("Current Stage:"+ instruction["progress"])
+            elif code in self.role_codes:
+                # self.role_agents[code].update_goal(instruction = instruction[code])
+                self.role_agents[code].goal = instruction[code]
+            else:
+                print("Instruction failed, role code:",code)
+        return instruction
+       
+    def get_event(self,):
+        if self.intervention == "" and not self.script:
+            roles_info_text = self._get_group_members_info_text(self.role_codes,profile=True)
+            status_text = self._get_status_text(self.role_codes)
+            event = self.world_agent.generate_event(roles_info_text=roles_info_text,event=self.intervention,history_text=status_text)
+            self.intervention = event
+        elif self.intervention == "" and self.script:
+            self.intervention = self.script
+        self.event = self.intervention
+        return self.intervention
+    
+    def get_script(self,):
+        if self.script == "":
+            roles_info_text = self._get_group_members_info_text(self.role_codes,profile=True)
+            status = "\n".join([self.role_agents[role_code].status for role_code in self.role_codes])
+            script = self.world_agent.generate_script(roles_info_text=roles_info_text,event=self.intervention,history_text=status)
+            self.script = script
+        # self.event = self.script
+        return self.script
+    
+    def update_event(self, group: List[str], top_k: int = 1):
+        if self.intervention == "":
+            self.event = ""
+        else:
+            status_text = self._get_status_text(group)
+            self.event = self.world_agent.update_event(self.event, self.intervention, status_text, script = self.script)
+    
+    # other
+    def record(self,
+               role_code: str, 
+               detail: str, 
+               actor_type: str,
+               act_type: str,
+               group: List[str] = [],
+               actor: str = "",
+               record_id = None,
+               **kwargs):
+        if act_type == "plan" and "plan" in kwargs:
+            detail = f"{self.role_agents[role_code].nickname}: {detail}"
+            interact_type = kwargs["plan"]["interact_type"]
+            target = ", ".join(kwargs["plan"]["target_role_codes"])
+            other_info = f"Interact type: {interact_type}, Target: {target}"
+        elif act_type == "move" and "destination_code" in kwargs:
+            destination = kwargs["destination_code"]
+            other_info = f"Desitination:{destination}"
+        elif act_type == "single":
+            detail = f"{self.role_agents[role_code].nickname}: {detail}"
+            target, planning_role, round = kwargs["target_role_code"],kwargs["planning_role_code"],kwargs["round"]
+            other_info = f"Target: {target}, Planning Role: {planning_role}, Round: {round}"
+        elif act_type == "multi": 
+            detail = f"{self.role_agents[role_code].nickname}: {detail}"
+            planning_role, round = kwargs["planning_role_code"],kwargs["round"]
+            other_info = f"Group member:{group}, Planning Role: {planning_role}, Round:{round},"
+        elif act_type == "npc":
+            name = kwargs["npc_name"]
+            other_info = f"Target: {name}"
+        elif act_type == "enviroment":
+            other_info = ""
+        else:
+            other_info = ""
+        record = {
+            "cur_round":self.cur_round,
+            "role_code":role_code,
+            "detail":detail,
+            "actor":actor,
+            "group":group,      # visible group
+            "actor_type":actor_type,
+            "act_type":act_type,
+            "other_info":other_info,
+            "record_id":record_id
+        }
+        self.history_manager.add_record(record)
+        for code in group:
+            self.role_agents[code].record(record)
+    
+    def settle_movement(self,):
+        for role_code in self.moving_roles_info.copy():
+            if not self.moving_roles_info[role_code]["distance"]:
+                location_code = self.moving_roles_info[role_code]["location_code"]
+                self.role_agents[role_code].set_location(location_code, self.world_agent.find_location_name(location_code))
+                self.log(f"{self.role_agents[role_code].role_name} 已到达 【{self.world_agent.find_location_name(location_code)}】" if self.language == "zh" else
+                         f"{self.role_agents[role_code].role_name} has reached [{self.world_agent.find_location_name(location_code)}]")
+                del self.moving_roles_info[role_code]
+            else:
+                self.moving_roles_info[role_code]["distance"] -= 1
+    
+    def _find_group(self,role_code):
+        return [code for code in self.role_codes if self.role_agents[code].location_code==self.role_agents[role_code].location_code]
+    
+    def _find_roles_at_location(self,location_code,name = False):
+        if name:
+            return [self.role_agents[code].nickname for code in self.role_codes if self.role_agents[code].location_code==location_code]
+        else:
+            return [code for code in self.role_codes if self.role_agents[code].location_code==location_code]
+
+    def _get_status_text(self,group):
+        return "\n".join([self.role_agents[role_code].status for role_code in group])
+    
+    def _get_group_members_info_text(self,group, profile = False,status = False):
+        roles_info_text = ""
+        for i, role_code in enumerate(group):
+            name = self.role_agents[role_code].role_name
+            roles_info_text += f"{i+1}. {name}\n(role_code:{role_code})\n"
+            if profile:
+                profile =  self.role_agents[role_code].role_profile
+                roles_info_text += f"{profile}\n"
+            if status:
+                status =  self.role_agents[role_code].status
+                roles_info_text += f"{status}\n"
+        return roles_info_text
+    
+    def _get_group_members_info_dict(self,group: List[str]):
+        info = {
+                role_code: {
+                    "nickname": self.role_agents[role_code].nickname,
+                    "profile": self.role_agents[role_code].role_profile
+                }
+                for role_code in group
+            }
+        return info
+    
+    def _get_locations_info(self,detailed = True):
+        location_info_text = "---当前各角色位置---\n" if self.language == "zh" else "---Current Location of Roles---\n"
+        if detailed:
+            for i,location_code in enumerate(self.world_agent.locations_info):
+                location_name = self.world_agent.find_location_name(location_code)
+                description = self.world_agent.locations_info[location_code]["description"]
+                location_info_text += f"\n{i+1}. {location_name}\nlocation_code:{location_code}\n{description}\n\n"
+                role_names = [f"{self.role_agents[code].role_name}({code})" for code in self.role_codes if self.role_agents[code].location_code == location_code]
+                role_names = ", ".join(role_names)
+                location_info_text += "目前在这里的角色有：" + role_names if self.language == "zh" else "Roles located here: " + role_names
+        else:
+            for i,location_code in enumerate(self.world_agent.locations_info):
+                location_name = self.world_agent.find_location_name(location_code)
+                role_names = [f"{self.role_agents[code].role_name}({code})" for code in self.role_codes if self.role_agents[code].location_code == location_code]
+                if len(role_names) == 0:continue
+                role_names = ", ".join(role_names)
+                location_info_text += f"【{location_name}】：" + role_names +"；"
+        return location_info_text
+    
+    def _name2code(self,roles):
+        name_dic = {self.role_agents[code].role_name:code for code in self.role_codes}
+        name_dic.update({self.role_agents[code].nickname:code for code in self.role_codes})
+        if isinstance(roles, list):
+            processed_roles = []
+            for role in roles:
+                if role in self.role_codes:
+                    processed_roles.append(role)
+                elif role in name_dic:
+                    processed_roles.append(name_dic[role])
+                elif "-" in role and role.split("-")[0] in name_dic:
+                    processed_roles.append(name_dic[role.split("-")[0]])
+                elif role.replace("_","·") in self.role_codes:
+                    processed_roles.append(role.replace("_","·"))
+                else:
+                    processed_roles.append(role)
+            return processed_roles
+        elif isinstance(roles, str) :
+            roles = roles.replace("\n","")
+            if roles in self.role_codes:
+                return roles
+            elif roles in name_dic:
+                return name_dic[roles]
+            elif f"{roles}-{self.language}" in self.role_codes:
+                return f"{roles}-{self.language}"
+            elif "-" in roles and roles.split("-")[0] in name_dic:
+                return name_dic[roles.split("-")[0]]
+            elif roles.replace("_","·") in self.role_codes:
+                return roles.replace("_","·")
+        return roles
+    
+    def log(self,text):
+        self.logger.info(text)
+        print(text)
+    
+    def _save_current_simulation(self, 
+                                 stage: Literal["location", "goal", "action"], 
+                                 current_round: int = 0,
+                                 sub_round:int = 0):
+        """
+        Save the current simulation progress. 
+
+        Args:
+            stage (Literal["location", "goal", "action"]): The stage in which the simulation has been carried out
+            current_round (int, optional): If the stage is "action", specify the number of rounds that have been completed. Defaults to 0.
+        """
+        if not self.if_save:
+            return
+        save_dir = f"./experiment_saves/{self.experiment_name}/{self.role_llm_name}/{self.start_time}"
+        create_dir(save_dir)
+        location_setted, goal_setted = False,False
+        if stage in ["location","goal","action"]:
+            location_setted = True
+        if stage in ["goal","action"]:
+            goal_setted = True
+        meta_info = {
+                "location_setted":location_setted,
+                "goal_setted": goal_setted,
+                "round": current_round,   
+                "sub_round": sub_round,    
+            }
+
+        save_json_file(os.path.join(save_dir, "meta_info.json"), meta_info)
+        name = self.experiment_name.split("/")[0]
+        save_json_file(os.path.join(save_dir, f"{name}.json"), self.config)
+        
+        filename = os.path.join(save_dir, f"./server_info.json")
+        save_json_file(filename, self.__getstate__() )
+        
+        self.history_manager.save_to_file(save_dir)
+        if hasattr(self, 'role_agents'):
+            for role_code in self.role_codes:
+                self.role_agents[role_code].save_to_file(save_dir)
+            self.world_agent.save_to_file(save_dir)
+        
+    def continue_simulation_from_file(self, save_dir: str):
+        """
+        Restore the record of the last simulation.
+        
+        Args:
+            save_dir (str): The path where the last simulation record was saved.
+
+        Returns:
+            Dict[str, Any]: The meta information recording the progress of the simulation
+        """
+        if os.path.exists(save_dir):
+            meta_info = load_json_file(os.path.join(save_dir, "./meta_info.json"))
+            filename = os.path.join(save_dir, f"./server_info.json")
+            states = load_json_file(filename)
+            self.__setstate__(states)   
+            for role_code in self.role_codes:
+                self.role_agents[role_code].load_from_file(save_dir) 
+            self.world_agent.load_from_file(save_dir)
+            self.history_manager.load_from_file(save_dir)
+            
+            for record in self.history_manager.detailed_history:
+                for code in record["group"]:
+                    if code in self.role_codes:
+                        self.role_agents[code].record(record)
+        else:
+            meta_info = {
+                "location_setted":False,
+                "goal_setted": False,
+                "round": 0,
+                "sub_round": 0,
+            }
+        return meta_info
+    
+    def __getstate__(self):
+        states = {key: value for key, value in self.__dict__.items() \
+            if isinstance(value, (str, int, list, dict, bool, type(None))) \
+                and key not in ['role_agents','world_agent','logger']}
+        
+        return states
+
+    def __setstate__(self, states):
+        self.__dict__.update(states)
+
+
+class BookWorld():
+    def __init__(self,
+                 preset_path: str,
+                 world_llm_name: str,
+                 role_llm_name: str,
+                 embedding_name:str = "bge-m3") :
+        self.server = Server(preset_path, 
+                        world_llm_name=world_llm_name, 
+                        role_llm_name=role_llm_name, 
+                        embedding_name=embedding_name)
+        self.selected_scene = None
+        
+    def set_generator(self, 
+                      rounds:int = 10, 
+                      save_dir:str = "", 
+                      if_save: Literal[0,1] = 0,
+                      mode: Literal["free", "script"] = "free",
+                      scene_mode: Literal[0,1] = 0,):
+        self.server.continue_simulation_from_file(save_dir)
+        self.generator = self.server.simulate_generator(rounds = rounds,
+                                                        save_dir = save_dir,
+                                                        if_save = if_save,
+                                                        mode = mode,
+                                                        scene_mode = scene_mode)
+    def get_map_info(self):
+        location_codes = self.server.world_agent.locations
+        location_names = [self.server.world_agent.find_location_name(location_code) for location_code in location_codes]
+        n = len(location_codes)
+        distances = []
+        for i in range(n):
+            for j in range(i+1,n):
+                if self.server.world_agent.get_distance(location_codes[i], location_codes[j]):
+                    distances.append({
+                        "source": location_names[i],
+                        "target": location_names[j],
+                        "distance": self.server.world_agent.get_distance(location_codes[i], location_codes[j])
+                    })
+            
+        return {
+            "places": location_names,
+            "distances": distances
+        }
+    def select_scene(self,scene_number):
+        if scene_number == None:
+            self.selected_scene = scene_number
+        else:
+            self.selected_scene = str(scene_number)
+        
+    def get_characters_info(self):
+        characters_info = []
+        if self.selected_scene == None:
+            codes = self.server.role_codes
+        else:
+            codes = self.server.scene_characters[str(self.selected_scene)]
+        for (i, code) in enumerate(codes):
+            agent = self.server.role_agents[code]
+            location = agent.location_name
+            if code in self.server.moving_roles_info:
+                location_name = self.server.world_agent.find_location_name(self.server.moving_roles_info[code]["location_code"])
+                distance = self.server.moving_roles_info[code]['distance']
+                location = f"Reaching {location_name}... ({distance})"
+            chara_info = {
+                "id": i,
+                "name": agent.nickname,
+                "icon": agent.icon_path,
+                "description": agent.role_profile,
+                "goal": agent.goal if agent.goal else agent.motivation,
+                "state": agent.status,
+                "location": location
+            }
+            characters_info.append(chara_info)
+        return characters_info
+
+    def generate_next_message(self):
+        message_type, code, text,message_id = next(self.generator)
+        if message_type == "role":
+            username = self.server.role_agents[code].role_name
+            icon_path = self.server.role_agents[code].icon_path
+        else:
+            username = message_type
+            icon_path = ""
+        message = {
+            'username': username,
+            'type': message_type, # role, world, system
+            'timestamp': datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            'text': text,
+            'icon': icon_path,
+            "uuid": message_id,
+            "scene": self.server.cur_round
+        }
+        return message
+        
+    def get_settings_info(self):
+        return self.server.world_agent.world_settings
+    
+    def get_current_status(self):
+        status = self.server.current_status
+        status['event'] = self.server.event
+        group = []
+        for code in status['group']:
+            if code in self.server.role_codes:
+                group.append(self.server.role_agents[code].nickname)
+            else:
+                group.append(code)
+        status['group'] = group
+        location_code = self.server.current_status['location_code']
+        if location_code not in self.server.world_agent.locations_info:
+            location_name,location_description = "Undefined","Undefined"
+        else:
+            location_name,location_description = self.server.world_agent.find_location_name(location_code),self.server.world_agent.locations_info[location_code]["description"]
+        status['location'] = {'name': location_name, 'description': location_description}
+        return status
+    
+    def handle_message_edit(self,record_id,new_text):
+        group = self.server.history_manager.modify_record(record_id,new_text)
+        for code in group:
+            self.server.role_agents[code].history_manager.modify_record(record_id,new_text)
+        return
+
+    def get_history_messages(self,save_dir):
+        
+        messages = []
+        for record in self.server.history_manager.detailed_history:
+            message_type = record["actor_type"]
+            code = record["role_code"]
+            if message_type == "role":
+                username = self.server.role_agents[code].role_name
+                icon_path = self.server.role_agents[code].icon_path
+            else:
+                username = message_type
+                icon_path = "./frontend/assets/images/default-icon.jpg"
+            messages.append({
+                'username': username,
+                'type': message_type, # role, world, system
+                'timestamp': datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                'text': record["detail"],
+                'icon': icon_path,
+                "uuid": record["record_id"],
+                "scene": record["cur_round"]
+            })
+        return messages
+    
+    def generate_story(self,):
+        logs = self.server.history_manager.get_complete_history()
+        story = self.server.world_agent.log2story(logs)
+        return story
+    
+
+    
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('--world_llm', type=str, default='gpt-4o-mini')
+    parser.add_argument('--role_llm', type=str, default='gpt-4o-mini')
+    parser.add_argument('--genre', type=str, default='mgdv2')
+    parser.add_argument('--preset_path', type=str, default='')
+
+    parser.add_argument('--if_save', type=int, default=1, choices=[0,1])
+    parser.add_argument('--scene_mode', type=int, default=0, choices=[0,1])
+    parser.add_argument('--rounds', type=int, default=10)
+    parser.add_argument('--save_dir', type=str, default='')
+    parser.add_argument('--mode', type=str, default='free', choices=['free','script'])
+    args = parser.parse_args()
+    world_llm_name = args.world_llm
+    role_llm_name = args.role_llm
+    rounds = args.rounds
+    genre = args.genre
+    preset_path = args.preset_path
+    save_dir = args.save_dir
+    if_save = args.if_save
+    scene_mode = args.scene_mode
+    mode = args.mode
+    if not preset_path:
+        preset_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),f"./config/experiment_{genre}.json")
+    
+    bw = BookWorld(preset_path, world_llm_name=world_llm_name, role_llm_name=role_llm_name)
+    bw.set_generator(rounds = rounds, save_dir = save_dir, if_save = if_save, scene_mode = scene_mode,mode = mode)
+    
+    for i in range(100):
+        try:
+            bw.generate_next_message()
+        except StopIteration:
+            break

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user
+USER user
+
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+RUN huggingface-cli download BAAI/bge-m3
+
+ENV OPENAI_API_KEY=""
+
+EXPOSE 8000
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

app.py

@@ -0,0 +1,240 @@
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse, FileResponse
+import uvicorn
+import json
+import asyncio
+import os
+from pathlib import Path
+from datetime import datetime
+from bw_utils import is_image, load_json_file
+from BookWorld import BookWorld
+
+app = FastAPI()
+default_icon_path = './frontend/assets/images/default-icon.jpg'
+config = load_json_file('config.json')
+for key in config:
+    if "API_KEY" in key:
+        os.environ[key] = config[key]
+
+static_file_abspath = os.path.abspath(os.path.join(os.path.dirname(__file__), 'frontend'))
+app.mount("/frontend", StaticFiles(directory=static_file_abspath), name="frontend")
+
+class ConnectionManager:
+    def __init__(self):
+        self.active_connections: dict[str, WebSocket] = {}  
+        self.story_tasks: dict[str, asyncio.Task] = {}  
+        if True:
+            if "preset_path" in config and config["preset_path"] and os.path.exists(config["preset_path"]):
+                preset_path = config["preset_path"]
+            elif "genre" in config and config["genre"]:
+                genre = config["genre"]
+                preset_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),f"./config/experiment_{genre}.json")
+            else:
+                raise ValueError("Please set the preset_path in `config.json`.")
+            self.bw = BookWorld(preset_path = preset_path,
+                    world_llm_name = config["world_llm_name"],
+                    role_llm_name = config["role_llm_name"],
+                    embedding_name = config["embedding_model_name"])
+            self.bw.set_generator(rounds = config["rounds"], 
+                        save_dir = config["save_dir"], 
+                        if_save = config["if_save"],
+                        mode = config["mode"],
+                        scene_mode = config["scene_mode"],)
+        else:
+            from BookWorld_test import BookWorld_test
+            self.bw = BookWorld_test()
+          
+    async def connect(self, websocket: WebSocket, client_id: str):
+        await websocket.accept()
+        self.active_connections[client_id] = websocket
+        
+    def disconnect(self, client_id: str):
+        if client_id in self.active_connections:
+            del self.active_connections[client_id]
+        self.stop_story(client_id)
+            
+    def stop_story(self, client_id: str):
+        if client_id in self.story_tasks:
+            self.story_tasks[client_id].cancel()
+            del self.story_tasks[client_id]
+
+    async def start_story(self, client_id: str):
+        if client_id in self.story_tasks:
+            # 如果已经有任务在运行，先停止它
+            self.stop_story(client_id)
+        
+        # 创建新的故事任务
+        self.story_tasks[client_id] = asyncio.create_task(
+            self.generate_story(client_id)
+        )
+
+    async def generate_story(self, client_id: str):
+        """持续生成故事的协程"""
+        try:
+            while True:
+                if client_id in self.active_connections:
+                    message,status = await self.get_next_message()
+                    await self.active_connections[client_id].send_json({
+                        'type': 'message',
+                        'data': message
+                    })
+                    await self.active_connections[client_id].send_json({
+                        'type': 'status_update',
+                        'data': status
+                    })
+                    # 添加延迟，控制消息发送频率
+                    await asyncio.sleep(1)  # 可以调整这个值
+                else:
+                    break
+        except asyncio.CancelledError:
+            # 任务被取消时的处理
+            print(f"Story generation cancelled for client {client_id}")
+        except Exception as e:
+            print(f"Error in generate_story: {e}")
+
+    async def get_initial_data(self):
+        """获取初始化数据"""
+        return {
+            'characters': self.bw.get_characters_info(),
+            'map': self.bw.get_map_info(),
+            'settings': self.bw.get_settings_info(),
+            'status': self.bw.get_current_status(),
+            'history_messages':self.bw.get_history_messages(save_dir = config["save_dir"]),
+        }
+    
+    async def get_next_message(self):
+        """从BookWorld获取下一条消息"""
+        message = self.bw.generate_next_message()
+        if not is_image(message["icon"]):
+            message["icon"] = default_icon_path
+        status = self.bw.get_current_status()
+        return message,status
+
+manager = ConnectionManager()
+
+@app.get("/")
+async def get():
+    html_file = Path("index.html")
+    return HTMLResponse(html_file.read_text())
+
+@app.get("/data/{full_path:path}")
+async def get_file(full_path: str):
+    # 可以设置多个基础路径
+    base_paths = [
+        Path("/data/")
+    ]
+    
+    for base_path in base_paths:
+        file_path = base_path / full_path
+        if file_path.exists() and file_path.is_file():
+            return FileResponse(file_path)
+        else:
+            return FileResponse(default_icon_path)
+    
+    raise HTTPException(status_code=404, detail="File not found")
+
+@app.websocket("/ws/{client_id}")
+async def websocket_endpoint(websocket: WebSocket, client_id: str):
+    await manager.connect(websocket, client_id)
+    try:
+        initial_data = await manager.get_initial_data()
+        await websocket.send_json({
+            'type': 'initial_data',
+            'data': initial_data
+        })
+        
+        while True:
+            data = await websocket.receive_text()
+            message = json.loads(data)
+            
+            if message['type'] == 'user_message':
+                # 处理用户消息
+                await websocket.send_json({
+                    'type': 'message',
+                    'data': {
+                        'username': 'User',
+                        'timestamp': message['timestamp'],
+                        'text': message['text'],
+                        'icon': default_icon_path,
+                    }
+                })
+                
+            elif message['type'] == 'control':
+                # 处理控制命令
+                if message['action'] == 'start':
+                    await manager.start_story(client_id)
+                elif message['action'] == 'pause':
+                    manager.stop_story(client_id)
+                elif message['action'] == 'stop':
+                    manager.stop_story(client_id)
+                    # 可以在这里添加额外的停止逻辑
+                    
+            elif message['type'] == 'edit_message':
+                # 处理消息编辑
+                edit_data = message['data']
+                # 假设 BookWorld 类有一个处理编辑的方法
+                manager.bw.handle_message_edit(
+                    record_id=edit_data['uuid'],
+                    new_text=edit_data['text']
+                )
+                
+            elif message['type'] == 'request_scene_characters':
+                manager.bw.select_scene(message['scene'])
+                scene_characters = manager.bw.get_characters_info()
+                await websocket.send_json({
+                    'type': 'scene_characters',
+                    'data': scene_characters
+                })
+                
+            elif message['type'] == 'generate_story':
+                # 生成故事文本
+                story_text = manager.bw.generate_story()
+                # 发送生成的故事作为新消息
+                await websocket.send_json({
+                    'type': 'message',
+                    'data': {
+                        'username': 'System',
+                        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                        'text': story_text,
+                        'icon': default_icon_path,
+                        'type': 'story'
+                    }
+                })
+                
+            elif message['type'] == 'request_api_configs':
+                await websocket.send_json({
+                    'type': 'api_configs',
+                    'data': API_CONFIGS
+                })
+                
+            elif message['type'] == 'api_settings':
+                # 处理API设置
+                settings = message['data']
+                # 设置环境变量
+                os.environ[settings['envKey']] = settings['apiKey']
+                
+                # 更新BookWorld的设置
+                manager.bw.update_api_settings(
+                    provider=settings['provider'],
+                    model=settings['model']
+                )
+                
+                # 发送确认消息
+                await websocket.send_json({
+                    'type': 'message',
+                    'data': {
+                        'username': 'System',
+                        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                        'text': f'已更新 {settings["provider"]} API设置',
+                        'icon': default_icon_path,
+                        'type': 'system'
+                    }
+                })
+    except Exception as e:
+        print(f"WebSocket error: {e}")
+    finally:
+        manager.disconnect(client_id)
+
+if __name__ == "__main__":
+    uvicorn.run("server:app", host="0.0.0.0", port=8000, reload=True)

bw_utils.py

@@ -0,0 +1,466 @@
+import os
+import pickle
+import json
+import torch
+import logging
+import datetime
+import re
+import random
+import base64
+
+MODEL_NAME_DICT = {
+    "gpt3":"openai/gpt-3.5-turbo",
+    "gpt-4":"openai/gpt-4",
+    "gpt-4o":"openai/gpt-4o",
+    "gpt-4o-mini":"openai/gpt-4o-mini",
+    "gpt-3.5-turbo":"openai/gpt-3.5-turbo",
+    "deepseek-r1":"deepseek/deepseek-r1",
+    "deepseek-v3":"deepseek/deepseek-chat",
+    "gemini-2":"google/gemini-2.0-flash-001",
+    "gemini-1.5":"google/gemini-flash-1.5",
+    "llama3-70b": "meta-llama/llama-3.3-70b-instruct",
+    "qwen-turbo":"qwen/qwen-turbo",
+    "qwen-plus":"qwen/qwen-plus",
+    "qwen-max":"qwen/qwen-max",
+    "qwen-2.5-72b":"qwen/qwen-2.5-72b-instruct",
+    "claude-3.5-sonnet":"anthropic/claude-3.5-sonnet",
+    "phi-4":"microsoft/phi-4",
+}
+
+def get_models(model_name):
+    if os.getenv("OPENROUTER_API_KEY", default="") and model_name in MODEL_NAME_DICT:
+        from modules.llm.OpenRouter import OpenRouter
+        return OpenRouter(model=MODEL_NAME_DICT[model_name])
+    elif model_name.startswith('gpt-3.5'):
+        from modules.llm.LangChainGPT import LangChainGPT
+        return LangChainGPT(model="gpt-3.5-turbo")
+    elif model_name == 'gpt-4':
+        from modules.llm.LangChainGPT import LangChainGPT
+        return LangChainGPT(model="gpt-4")
+    elif model_name == 'gpt-4-turbo':
+        from modules.llm.LangChainGPT import LangChainGPT
+        return LangChainGPT(model="gpt-4")
+    elif model_name == 'gpt-4o':
+        from modules.llm.LangChainGPT import LangChainGPT
+        return LangChainGPT(model="gpt-4o")
+    elif model_name == "gpt-4o-mini":
+        from modules.llm.LangChainGPT import LangChainGPT
+        return LangChainGPT(model="gpt-4o-mini")
+    elif model_name.startswith("claude"):
+        from modules.llm.LangChainGPT import LangChainGPT
+        return LangChainGPT(model="claude-3-5-sonnet-20241022")
+    elif model_name.startswith('qwen'):
+        from modules.llm.Qwen import Qwen
+        return Qwen(model = model_name)
+    elif model_name.startswith('deepseek'):
+        from modules.llm.DeepSeek import DeepSeek
+        return DeepSeek()
+    elif model_name.startswith('doubao'):
+        from modules.llm.Doubao import Doubao
+        return Doubao()
+    elif model_name.startswith('gemini'):
+        from modules.llm.Gemini import Gemini
+        return Gemini()
+    else:
+        print(f'Warning! undefined model {model_name}, use gpt-3.5-turbo instead.')
+        from modules.llm.LangChainGPT import LangChainGPT
+        return LangChainGPT()
+    
+def build_world_agent_data(world_file_path,max_words = 30):
+    world_dir = os.path.dirname(world_file_path)
+    details_dir = os.path.join(world_dir,"./world_details")
+    data = []
+    settings = []
+    if os.path.exists(details_dir):
+        for path in get_child_paths(details_dir):
+            if os.path.splitext(path)[-1] == ".txt":
+                text = load_text_file(path)
+                data += split_text_by_max_words(text,max_words)
+            if os.path.splitext(path)[-1] == ".jsonl":
+                jsonl = load_jsonl_file(path)
+                data += [f"{dic['term']}:{dic['detail']}" for dic in jsonl]
+                settings += jsonl
+    return data,settings
+
+def build_db(data, db_name, db_type, embedding, save_type="persistent"):
+    if True:
+        from modules.db.ChromaDB import ChromaDB
+        db = ChromaDB(embedding,save_type)
+        db_name = db_name
+        db.init_from_data(data,db_name)
+    return db
+
+def get_root_dir():
+    current_file_path = os.path.abspath(__file__)
+    root_dir = os.path.dirname(current_file_path)
+    return root_dir
+
+def create_dir(dirname):
+    if not os.path.exists(dirname):
+        os.makedirs(dirname)
+
+def get_logger(experiment_name):
+    logger = logging.getLogger(experiment_name)
+    logger.setLevel(logging.INFO)
+    current_time = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    create_dir(f"{get_root_dir()}/log/{experiment_name}")
+    file_handler = logging.FileHandler(os.path.join(get_root_dir(),f"./log/{experiment_name}/{current_time}.log"),encoding='utf-8')
+    file_handler.setLevel(logging.INFO)
+    
+    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+    file_handler.setFormatter(formatter)
+    
+    logger.addHandler(file_handler)
+    
+    # Avoid logging duplication
+    logger.propagate = False
+
+    return logger
+
+def merge_text_with_limit(text_list, max_words, language = 'en'):
+    """
+    Merge a list of text strings into one, stopping when adding another text exceeds the maximum count.
+
+    Args:
+        text_list (list): List of strings to be merged.
+        max_count (int): Maximum number of characters (for Chinese) or words (for English).
+        is_chinese (bool): If True, count Chinese characters; if False, count English words.
+
+    Returns:
+        str: The merged text, truncated as needed.
+    """
+    merged_text = ""
+    current_count = 0
+
+    for text in text_list:
+        if language == 'zh':
+            # Count Chinese characters
+            text_length = len(text)
+        else:
+            # Count English words
+            text_length = len(text.split(" "))
+
+        if current_count + text_length > max_words:
+            break
+
+        merged_text += text + "\n"
+        current_count += text_length
+
+    return merged_text
+
+def normalize_string(text):
+    # 去除空格并将所有字母转为小写
+    import re
+    return re.sub(r'[\s\,\;\t\n]+', '', text).lower()
+
+def fuzzy_match(str1, str2, threshold=0.8):
+    str1_normalized = normalize_string(str1)
+    str2_normalized = normalize_string(str2)
+
+    if str1_normalized == str2_normalized:
+        return True
+
+    return False
+
+def load_character_card(path):
+    from PIL import Image
+    import PIL.PngImagePlugin
+    
+    image = Image.open(path)
+    if isinstance(image, PIL.PngImagePlugin.PngImageFile):
+        for key, value in image.text.items():
+            try:
+                character_info = json.loads(decode_base64(value))
+                if character_info:
+                    return character_info
+            except:
+                continue
+    return None
+
+def decode_base64(encoded_string):
+    # Convert the string to bytes if it's not already
+    if isinstance(encoded_string, str):
+        encoded_bytes = encoded_string.encode('ascii')
+    else:
+        encoded_bytes = encoded_string
+
+    # Decode the Base64 bytes
+    decoded_bytes = base64.b64decode(encoded_bytes)
+
+    # Try to convert the result to a string, assuming UTF-8 encoding
+    try:
+        decoded_string = decoded_bytes.decode('utf-8')
+        return decoded_string
+    except UnicodeDecodeError:
+        # If it's not valid UTF-8 text, return the raw bytes
+        return decoded_bytes
+    
+def remove_list_elements(list1, *args):
+    for target in args:
+        if isinstance(target,list) or isinstance(target,dict):
+            list1 = [i for i in list1 if i not in target]
+        else:
+            list1 = [i for i in list1 if i != target]
+    return list1
+
+def extract_html_content(html):
+    from bs4 import BeautifulSoup
+    soup = BeautifulSoup(html, "html.parser")
+    
+    content_div = soup.find("div", {"id": "content"})
+    if not content_div:
+        return ""
+
+    paragraphs = []
+    for div in content_div.find_all("div"):
+        paragraphs.append(div.get_text(strip=True))
+    
+    main_content = "\n\n".join(paragraphs)
+    return main_content
+
+def load_text_file(path):
+    with open(path,"r",encoding="utf-8") as f:
+        text = f.read()
+    return text
+
+def save_text_file(path,target):
+    with open(path,"w",encoding="utf-8") as f:
+        text = f.write(target)
+
+def load_json_file(path):
+    with open(path,"r",encoding="utf-8") as f:
+        return json.load(f)
+    
+def save_json_file(path,target):
+    dir_name = os.path.dirname(path)
+    if not os.path.exists(dir_name):
+        os.makedirs(dir_name)
+    with open(path,"w",encoding="utf-8") as f:
+        json.dump(target, f, ensure_ascii=False,indent=True)
+        
+def load_jsonl_file(path):
+    data = []
+    with open(path,"r",encoding="utf-8") as f:
+        for line in f:
+            data.append(json.loads(line))
+    return data
+        
+def save_jsonl_file(path,target):
+    with open(path, "w",encoding="utf-8") as f:
+        for row in target:
+            print(json.dumps(row, ensure_ascii=False), file=f)
+
+def split_text_by_max_words(text: str, max_words: int = 30):
+    segments = []
+    current_segment = []
+    current_length = 0
+    
+    lines = text.splitlines()
+
+    for line in lines:
+        words_in_line = len(line)
+        current_segment.append(line + '\n')
+        current_length += words_in_line
+        
+        if current_length + words_in_line > max_words:
+            segments.append(''.join(current_segment))
+            current_segment = []
+            current_length = 0
+
+    if current_segment:
+        segments.append(''.join(current_segment))
+
+    return segments
+
+def lang_detect(text):
+    import re
+    def count_chinese_characters(text):
+        # 使用正则表达式匹配所有汉字字符
+        chinese_chars = re.findall(r'[\u4e00-\u9fff]', text)
+        return len(chinese_chars)
+            
+    if count_chinese_characters(text) > len(text) * 0.05:
+        lang = 'zh'
+    else:
+        lang = 'en'
+    return lang
+
+def dict_to_str(dic):
+    res = ""
+    for key in dic:
+        res += f"{key}: {dic[key]};"
+    return res
+
+def count_tokens_num(string, encoding_name = "cl100k_base"):
+    encoding = tiktoken.get_encoding(encoding_name)
+    num_tokens = len(encoding.encode(string))
+    return num_tokens
+
+ 
+def json_parser(output):
+    output = output.replace("\n", "")
+    output = output.replace("\t", "")
+    if "{" not in output:
+        output = "{" + output
+    if "}" not in output:
+        output += "}"  
+    pattern = r'\{.*\}'
+    matches = re.findall(pattern, output, re.DOTALL)
+    try:
+        parsed_json = eval(matches[0])
+    except:
+        try:
+            parsed_json = json.loads(matches[0])
+            
+        except json.JSONDecodeError:
+            try:
+                detail = re.search(r'"detail":\s*(.+?)\s*}', matches[0]).group(1)
+                detail = f"\"{detail}\"" 
+                new_output = re.sub(r'"detail":\s*(.+?)\s*}', f"\"detail\":{detail}}}", matches[0])
+                parsed_json = json.loads(new_output)
+            except Exception as e:
+                raise ValueError("No valid JSON found in the input string")
+    return parsed_json
+
+def action_detail_decomposer(detail):
+    thoughts = re.findall(r'【(.*?)】', detail)
+    actions = re.findall(r'（(.*?)）', detail)
+    dialogues = re.findall(r'「(.*?)」', detail)
+    return thoughts,actions,dialogues
+
+def conceal_thoughts(detail):
+    text = re.sub(r'【.*?】', '', detail)
+    text = re.sub(r'\[.*?\]', '', text)
+    return text
+
+def extract_first_number(text):
+    match = re.search(r'\b\d+(?:\.\d+)?\b', text)
+    return int(match.group()) if match else None
+
+def check_role_code_availability(role_code,role_file_dir):
+    for path in get_grandchild_folders(role_file_dir):
+        if role_code in path:
+            return True
+    return False
+    
+def get_grandchild_folders(root_folder):
+    folders = []
+    for resource in os.listdir(root_folder):
+        subpath = os.path.join(root_folder,resource)
+        for folder_name in os.listdir(subpath):
+            folder_path = os.path.join(subpath, folder_name)
+            folders.append(folder_path)
+    
+    return folders
+
+def get_child_folders(root_folder):
+    folders = []
+    for resource in os.listdir(root_folder):
+        path = os.path.join(root_folder,resource)
+        if os.path.isdir(path):
+            folders.append(path)
+    return folders
+
+def get_child_paths(root_folder):
+    paths = []
+    for resource in os.listdir(root_folder):
+        path = os.path.join(root_folder,resource)
+        if os.path.isfile(path):
+            paths.append(path)
+    return paths
+
+def get_first_directory(path):
+    try:
+        for item in os.listdir(path):
+            full_path = os.path.join(path, item)
+            if os.path.isdir(full_path):
+                return full_path
+        return None
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+    
+def find_files_with_suffix(directory, suffix):
+    matched_files = []
+    for root, dirs, files in os.walk(directory):  # 遍历目录及其子目录
+        for file in files:
+            if file.endswith(suffix):  # 检查文件后缀
+                matched_files.append(os.path.join(root, file))  # 将符合条件的文件路径加入列表
+
+    return matched_files
+
+def remove_element_with_probability(lst, threshold=3, probability=0.2):
+    # 确保列表不为空
+    if len(lst) > threshold and random.random() < probability:
+        # 随机选择一个元素的索引
+        index = random.randint(0, len(lst) - 1)
+        # 删除该索引位置的元素
+        lst.pop(index)
+    return lst
+  
+def count_token_num(text):
+    from transformers import GPT2TokenizerFast
+    tokenizer = GPT2TokenizerFast.from_pretrained('gpt2')
+    return len(tokenizer.encode(text))
+
+def get_cost(model_name,prompt,output):
+    input_price=0
+    output_price=0
+    if model_name.startswith("gpt-4"):
+        input_price=10
+        output_price=30
+    elif model_name.startswith("gpt-3.5"):
+        input_price=0.5
+        output_price=1.5
+    
+    return input_price*count_token_num(prompt)/1000000 + output_price * count_token_num(output)/1000000
+
+def is_image(filepath):
+    if not os.path.isfile(filepath):
+        return False
+
+    valid_image_extensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff','.webp']
+    file_extension = os.path.splitext(filepath)[1].lower()
+
+    # 判断扩展名是否在有效图片扩展名列表中
+    if file_extension in valid_image_extensions:
+        return True
+
+    return False
+
+def clean_collection_name(name: str) -> str:
+    cleaned_name = name.replace(' ', '_')
+    cleaned_name = cleaned_name.replace('.', '_')
+    if not all(ord(c) < 128 for c in cleaned_name):
+        encoded = base64.b64encode(cleaned_name.encode('utf-8')).decode('ascii')
+        encoded = encoded[:60] if len(encoded) > 60 else encoded
+        valid_name = f"mem_{encoded}"
+    else:
+        valid_name = cleaned_name
+    valid_name = re.sub(r'[^a-zA-Z0-9_-]', '-', valid_name)
+    valid_name = re.sub(r'\.\.+', '-', valid_name)
+    valid_name = re.sub(r'^[^a-zA-Z0-9]+', '', valid_name)  # 移除开头非法字符
+    valid_name = re.sub(r'[^a-zA-Z0-9]+$', '', valid_name)
+    return valid_name
+    
+cache_sign = True
+cache = None 
+def cached(func):
+    def wrapper(*args,**kwargs):
+        global cache
+        cache_path = "bw_cache.pkl"
+        if cache == None:
+            if not os.path.exists(cache_path):
+                cache = {}
+            else:
+                cache = pickle.load(open(cache_path, 'rb'))
+        key = (func.__name__, str([args[0].role_code, args[0].__class__, args[0].llm_name , args[0].history]), str(kwargs.items()))
+        if (cache_sign and key in cache and cache[key] not in [None, '[TOKEN LIMIT]']) :
+            return cache[key]
+        else:
+            result = func(*args, **kwargs)
+            if result != 'busy' and result != None:
+                cache[key] = result
+                pickle.dump(cache, open(cache_path, 'wb'))
+            return result
+    return wrapper

config.json

@@ -0,0 +1,20 @@
+{
+    "role_llm_name": "gemini-2",
+    "world_llm_name": "gemini-2",
+    "embedding_model_name":"bge-m3",
+    "preset_path":"./experiment_presets/experiment_alice.json",
+    "if_save": 0,
+    "scene_mode": 1,
+    "rounds": 10,
+    "save_dir": "",
+    "mode": "script",
+
+    "OPENAI_API_KEY":"",
+    "GEMINI_API_KEY":"",
+    "ANTHROPIC_API_KEY":"",
+    "OPENROUTER_API_KEY":"",
+    "DASHSCOPE_API_KEY":"",
+    "DEEPSEEK_API_KEY":"",
+    "ARK_API_KEY":""
+
+}

convert_sillytavern_cards_to_data.py

@@ -0,0 +1,31 @@
+from PIL import Image
+from bw_utils import get_child_paths,lang_detect,is_image,decode_base64,save_json_file,create_dir
+import PIL.PngImagePlugin
+import os
+import json
+
+card_dir = "./data/sillytavern_cards"
+names = os.listdir(card_dir)
+
+for name in names:
+    path = os.path.join(card_dir, name)
+    role_code = name.split('.')[0].replace(" ","_")
+    if is_image(path):
+        with open(path, 'rb') as f:
+            image = Image.open(f)
+            card_info = json.loads(decode_base64(image.text['chara']))
+            language = lang_detect(card_info['data']['description'])
+            role_info = {
+            "role_code": f"{role_code}-{language}",
+            "role_name": card_info['data']['name'],
+            "source": "",
+            "profile": card_info['data']['description'],
+            "nickname": card_info['data']['name'],
+            "relation": {},
+            "card_data": card_info['data']
+            }
+            create_dir(f"./data/roles/sillytavern/{role_code}")
+            save_json_file(os.path.join(f"./data/roles/sillytavern/{role_code}","role_info.json"),role_info)
+            image.save(os.path.join(f"./data/roles/sillytavern/{role_code}",f"icon.png"))
+            print(f"{name} converted successfully.")
+    

data/locations/A_Song_of_Ice_and_Fire.json

@@ -0,0 +1,45 @@
+{
+    "Winterfell": {
+        "location_name": "临冬城",
+        "location_code": "Winterfell",
+        "description": "临冬城是北境的主要城堡，也是史塔克家族的家园。",
+        "detail": "临冬城坐落在寒冷的北方，由灰色石头建造，坚固而古老。城堡由内城和外城组成，内城有高大的城墙和几座塔楼，外城有许多庭院、马厩和士兵宿舍。城堡中心有一个温泉池，水源来自地下的温泉，给寒冷的临冬城带来一丝温暖。临冬城的神木林是北境人心目中神圣的地方，那里有一棵古老的心树，是史塔克家族的祈祷之地。",
+        "special_actions": ["会议", "祈祷", "训练"]
+    },
+    "King's Landing": {
+        "location_name": "君临城",
+        "location_code": "King's Landing",
+        "description": "君临城是维斯特洛的首都，铁王座的所在地。",
+        "detail": "君临城坐落在黑水河的岸边，是维斯特洛最大的城市。城中最显著的建筑是红堡，铁王座就位于其中的铁王座厅。君临城的街道狭窄而繁忙，挤满了商人、士兵和各种各样的人。市集、酒馆和贫民区都充满了喧嚣和活力。红堡外还有祈祷圣堂、高塔以及黑水河边的港口，所有这些构成了君临城独特的风貌。",
+        "special_actions": ["统治", "阴谋", "战争"]
+    },
+    "The Wall": {
+        "location_name": "长城",
+        "location_code": "The Wall",
+        "description": "长城是守护维斯特洛北方边境的巨大冰墙。",
+        "detail": "长城由坚固的冰和雪建成，绵延数百里，横亘在维斯特洛北境与绝境长城之外的野地之间。它高耸入云，常年被冰雪覆盖。长城由守夜人守护，他们在这里驻扎，抵御来自北方的威胁。长城上有许多堡垒和哨塔，最大的堡垒是黑城堡，它是守夜人的总部。长城的尽头是东海望，一个位于海边的小镇，是守夜人和北境世界之间的主要通道。",
+        "special_actions": ["守卫", "巡逻", "抵御异鬼"]
+    },
+    "Dragonstone": {
+        "location_name": "龙石岛",
+        "location_code": "Dragonstone",
+        "description": "龙石岛是坦格利安家族的古老领地，位于黑水湾的一个岛屿上。",
+        "detail": "龙石岛是一座由火山岩形成的小岛，岛上有一座古老而神秘的城堡。城堡的塔楼和城墙由黑色的火山岩建成，显得阴森而强大。龙石岛曾是坦格利安家族的基地，他们在这里起家，征服了七大王国。龙石岛的地理位置使它成为一个战略要地，控制着通往君临城的海路。岛上的龙穴曾是坦格利安家族饲养龙的地方，虽然龙已经消失，但岛上的遗迹仍然充满着他们的传说。",
+        "special_actions": ["战略会议", "巩固统治", "策划复仇"]
+    },
+    "The Eyrie": {
+        "location_name": "鹰巢城",
+        "location_code": "The Eyrie",
+        "description": "鹰巢城是维斯特洛最难以攻陷的城堡，位于高耸的山巅。",
+        "detail": "鹰巢城坐落在巍峨的山顶之上，高高在云端，仿佛悬在半空中。城堡由巨石建造，只有通过一条陡峭的山道才能到达，极难进攻。城堡内的高墙和塔楼都象征着它的坚不可摧。鹰巢城是艾林家族的居所，他们统治着山谷地区。城堡内部富丽堂皇，但也寒冷而孤立。鹰巢城的月门是一道令人恐惧的悬空门，从这里可以将罪犯直接抛下悬崖，坠入深渊。",
+        "special_actions": ["裁决", "坚守", "眺望"]
+    },
+    "TwinTowers": {
+        "location_name": "孪河城",
+        "location_code": "TwinTowers",
+        "description": "孪河城是弗雷家族的城堡，位于河间地的重要战略位置。",
+        "detail": "孪河城坐落在红叉河北岸，是河间地弗雷家族的领地。城堡由两座高塔组成，耸立于红叉河两侧，由一座坚固的桥梁连接，控制着通向北境和南部的重要通道。弗雷家族通过这座桥梁收取过桥费，积累了大量财富。孪河城不仅在地理位置上显得至关重要，还以其家族的狡诈和复杂的内部关系而闻名。城堡内装饰简朴，冷酷而功能性强。它是血色婚礼发生的场所，弗雷家族在这里背叛了史塔克家族。",
+        "special_actions": ["背叛", "封锁", "谈判"]
+    }
+    
+}

data/locations/Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass.json

@@ -0,0 +1,9 @@
+{
+ "somewhere": {
+  "location_code": "somewhere",
+  "location_name": "somewhere",
+  "source": "Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass",
+  "description": "Some where in the world of Alice’s Adventures in Wonderland",
+  "detail": ""
+ }
+}

data/locations/example_locations.json

@@ -0,0 +1,24 @@
+{
+    "laboratory": {
+      "location_code": "laboratory",
+      "location_name": "Laboratory",
+      "source": "example",
+      "description": "A high-security research lab pioneering human-machine fusion experiments.",
+      "detail": "Inside this sterile, high-tech facility, scientists and engineers work on merging biological and artificial systems. It stands at the forefront of redefining human evolution through machine integration."
+    },
+    "university": {
+      "location_code": "university",
+      "location_name": "University",
+      "source": "example",
+      "description": "An elite institution training the next generation of technologists and bioengineers.",
+      "detail": "The university offers cutting-edge programs in AI ethics, cybernetics, and synthetic biology. Its sprawling campus nurtures innovation, producing thinkers who will shape humanity’s future relationship with machines."
+    },
+    "eldridge_corporation": {
+      "location_code": "eldridge_corporation",
+      "location_name": "Eldridge Corporation",
+      "source": "example",
+      "description": "A dominant tech conglomerate driving the frontier of AI and biotechnology.",
+      "detail": "Eldridge Corporation controls vast sectors of AI research, cybernetic enhancements, and neural networking. Officially a beacon of progress, rumors persist of secret projects far beyond ethical boundaries."
+    }
+  }
+  

data/maps/A_Song_of_Ice_and_Fire.csv

@@ -0,0 +1,5 @@
+,Winterfell,King's Landing,The Wall,Dragonstone
+Winterfell,0,4,4,4
+King's Landing,4,0,4,4
+The Wall,4,4,0,4
+Dragonstone,4,4,4,0

data/maps/A_Song_of_Ice_and_Fire_bloody_wedding.csv

@@ -0,0 +1,2 @@
+,TwinTowers
+TwinTowers,0

data/maps/Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass.csv

@@ -0,0 +1,2 @@
+,somewhere
+somewhere,0

data/maps/example_map.csv

@@ -0,0 +1,4 @@
+,laboratory,university,eldridge_corporation
+laboratory,0,2,5
+university,2,0,4
+eldridge_corporation,5,4,0

data/roles/A_Song_of_Ice_and_Fire/AryaStark-zh/role_info.json

@@ -0,0 +1,27 @@
+{
+ "role_code": "AryaStark-zh",
+ "role_name": "艾莉亚·史塔克",
+ "source": "A_Song_of_Ice_and_Fire",
+ "profile": "艾莉亚·史塔克是艾德·史塔克的小女儿，勇敢、独立，擅长剑术。在家族遭遇不幸后，她开始了一段充满危险的流亡旅程。",
+ "gender": "女",
+ "age": "9岁（故事开始时）",
+ "identity": [
+  "临冬城家族成员",
+  "无面者学徒"
+ ],
+ "nickname": "艾莉亚",
+ "relation": {
+  "EddardStark-zh": {
+   "relation": [
+    "父亲"
+   ],
+   "detail": "艾莉亚与父亲艾德·史塔克关系密切，她从父亲那里学到了许多关于荣誉和正义的价值观。"
+  },
+  "SyrioForel-zh": {
+   "relation": [
+    "剑术导师"
+   ],
+   "detail": "艾莉亚在君临城时师从塞里欧·佛瑞尔学习剑术，塞里欧教导她成为了一个出色的剑士。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/BranStark-zh/role_info.json

@@ -0,0 +1,28 @@
+{
+ "role_code": "BranStark-zh",
+ "role_name": "布兰·史塔克",
+ "source": "A_Song_of_Ice_and_Fire",
+ "profile": "布兰·史塔克是艾德·史塔克的幼子，在一次意外中失去双腿后，他逐渐发现自己拥有预知未来和操控人心的超自然能力。",
+ "gender": "男",
+ "age": "7岁（故事开始时）",
+ "identity": [
+  "临冬城家族成员",
+  "三眼乌鸦"
+ ],
+ "nickname": "布兰",
+ "relation": {
+  "EddardStark-zh": {
+   "relation": [
+    "父亲"
+   ],
+   "detail": "布兰与父亲艾德·史塔克关系密切，他从父亲那里学到了许多关于荣誉和责任的价值观。"
+  },
+  "Hodor-zh": {
+   "relation": [
+    "仆人",
+    "朋友"
+   ],
+   "detail": "布兰与巨人霍多尔有着特别的关系，霍多尔在布兰瘫痪后一直照顾他，并在许多冒险中保护他。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/Catelyn-Stark-zh/role_info.json

@@ -0,0 +1,35 @@
+{
+ "role_name": "凯特琳·史塔克（徒利）",
+ "role_code": "Catelyn-Stark-zh",
+ "source": "A Song of Ice and Fire",
+ "profile": "凯特琳·史塔克，原姓徒利，是河间地的徒利家族成员。她是北境领主艾德·史塔克的妻子，罗柏·史塔克的母亲。在血色婚礼中，她为了保全儿子的性命不惜求情，但最终未能挽回局势，被弗雷家族杀害。",
+ "gender": "女",
+ "age": "35岁左右",
+ "activity":0.4,
+ "identity": [
+  "北境领主夫人",
+  "徒利家族成员"
+ ],
+ "nickname": "凯特琳",
+ "relation": {
+  "Robb-Stark-zh": {
+   "relation": [
+    "母子"
+   ],
+   "detail": "凯特琳始终支持儿子罗柏的事业，并在血色婚礼时拼命求情，试图拯救他的性命。"
+  },
+  "Edmure-Tully-zh": {
+   "relation": [
+    "兄妹"
+   ],
+   "detail": "艾德慕·徒利是凯特琳的弟弟，凯特琳在血色婚礼上见证了他与罗莎琳·弗雷的婚礼，随后惨遭背叛。"
+  },
+  "Walder-Frey-zh": {
+   "relation": [
+    "盟友",
+    "背叛者"
+   ],
+   "detail": "凯特琳曾试图维护与弗雷家族的盟约，但最终弗雷家族背叛了她和她的儿子罗柏。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/CerseiLannister-zh/role_info.json

@@ -0,0 +1,28 @@
+{
+ "role_code": "CerseiLannister-zh",
+ "role_name": "瑟曦·兰尼斯特",
+ "source": "A_Song_of_Ice_and_Fire",
+ "profile": "瑟曦·兰尼斯特是兰尼斯特家族的长女，詹姆·兰尼斯特的双胞胎姐妹。她美丽、聪慧，但心狠手辣，为了权力不择手段。",
+ "gender": "女",
+ "age": "31岁（故事开始时）",
+ "identity": [
+  "兰尼斯特家族成员",
+  "王后",
+  "摄政太后"
+ ],
+ "nickname": "瑟曦",
+ "relation": {
+  "RobertBaratheon-zh": {
+   "relation": [
+    "丈夫"
+   ],
+   "detail": "瑟曦是劳勃·拜拉席恩的王后，但两人婚姻不幸福，瑟曦始终对劳勃心怀怨恨。"
+  },
+  "JoffreyBaratheon-zh": {
+   "relation": [
+    "母子"
+   ],
+   "detail": "瑟曦对她的儿子乔佛里极为溺爱，并将他视为权力的延续，尽管乔佛里残酷暴戾。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/DaenerysTargaryen-zh/role_info.json

@@ -0,0 +1,28 @@
+{
+ "role_code": "DaenerysTargaryen-zh",
+ "role_name": "丹妮莉丝·坦格利安",
+ "source": "A_Song_of_Ice_and_Fire",
+ "profile": "丹妮莉丝·坦格利安是坦格利安家族的最后幸存者之一。她从流亡公主成长为强大的龙之母，誓要夺回铁王座。",
+ "gender": "女",
+ "age": "14岁（故事开始时）",
+ "identity": [
+  "龙之母",
+  "铁王座继承者"
+ ],
+ "nickname": "丹妮莉丝",
+ "relation": {
+  "Drogo-zh": {
+   "relation": [
+    "丈夫"
+   ],
+   "detail": "丹妮莉丝嫁给了多斯拉克的领袖卓戈·卡奥，两人逐渐培养出了深厚的感情。"
+  },
+  "JorahMormont-zh": {
+   "relation": [
+    "顾问",
+    "仰慕者"
+   ],
+   "detail": "乔拉·莫尔蒙是丹妮莉丝的忠实仆从和顾问，他深深地仰慕丹妮，但他的感情一直未能被她接受。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/Edmure-Tully-zh/role_info.json

@@ -0,0 +1,34 @@
+{
+ "role_name": "艾德慕·徒利",
+ "role_code": "Edmure-Tully-zh",
+ "source": "A Song of Ice and Fire",
+ "profile": "艾德慕·徒利是河间地的徒利家族成员，是凯特琳·史塔克的弟弟。在血色婚礼中，艾德慕与罗莎琳·弗雷举行婚礼，却未料到婚礼会成为灭顶之灾的序幕。",
+ "gender": "男",
+ "age": "30岁左右",
+ "activity":0.3,
+ "identity": [
+  "徒利家族继承人",
+  "河间地领主"
+ ],
+ "nickname": "艾德慕",
+ "relation": {
+  "Catelyn-Stark-zh": {
+   "relation": [
+    "兄妹"
+   ],
+   "detail": "艾德慕与他的姐姐凯特琳关系亲密，但他在决策上常常受到凯特琳的指导与影响。"
+  },
+  "Walder-Frey-zh": {
+   "relation": [
+    "盟友"
+   ],
+   "detail": "艾德慕·徒利与罗莎琳·弗雷的婚姻是弗雷家族与徒利家族联盟的一部分，但他未料到婚礼的背叛。"
+  },
+  "Robb-Stark-zh": {
+   "relation": [
+    "外甥"
+   ],
+   "detail": "艾德慕·徒利是罗柏·史塔克的舅舅，支持史塔克家族的事业，尽管他的决策偶尔导致了战局的挫折。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/JaimeLannister-zh/role_info.json

@@ -0,0 +1,29 @@
+{
+ "role_code": "JaimeLannister-zh",
+ "role_name": "詹姆·兰尼斯特",
+ "source": "A_Song_of_Ice_and_Fire",
+ "profile": "詹姆·兰尼斯特是兰尼斯特家族的长子，外号“弑君者”。他身手矫健，性格复杂，最初因弑君而被世人厌恶，后逐渐展现了他更为人性的另一面。",
+ "gender": "男",
+ "age": "31岁（故事开始时）",
+ "identity": [
+  "兰尼斯特家族成员",
+  "御林铁卫"
+ ],
+ "nickname": "詹姆",
+ "relation": {
+  "CerseiLannister-zh": {
+   "relation": [
+    "姐妹",
+    "情人"
+   ],
+   "detail": "詹姆与双胞胎姐妹瑟曦·兰尼斯特有着禁忌的爱情，两人关系深厚，但也充满了复杂的情感纠葛。"
+  },
+  "TyrionLannister-zh": {
+   "relation": [
+    "兄弟",
+    "挚友"
+   ],
+   "detail": "詹姆与弟弟提利昂关系密切，他是唯一一个真正爱护提利昂的家人，并在许多关键时刻支持了他。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/JonSnow-zh/role_info.json

@@ -0,0 +1,28 @@
+{
+ "role_code": "JonSnow-zh",
+ "role_name": "琼恩·雪诺",
+ "source": "A_Song_of_Ice_and_Fire",
+ "profile": "琼恩·雪诺是艾德·史塔克的私生子，成长于临冬城。他后来加入守夜人军团，最终成为其首领。他善良、正直、勇敢，是北境的希望。",
+ "gender": "男",
+ "age": "16岁（故事开始时）",
+ "identity": [
+  "守夜人",
+  "临冬城领主"
+ ],
+ "nickname": "雪诺",
+ "relation": {
+  "EddardStark-zh": {
+   "relation": [
+    "父亲",
+    "导师"
+   ],
+   "detail": "琼恩·雪诺是艾德·史塔克的私生子，艾德对他关怀备至，培养他成为一个正直的年轻人。"
+  },
+  "SansaStark-zh": {
+   "relation": [
+    "异母姐弟"
+   ],
+   "detail": "琼恩与珊莎是异母姐弟，他们在困境中重逢并共同守护家族与北境。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/Robb-Stark-zh/role_info.json

@@ -0,0 +1,37 @@
+{
+ "role_name": "罗柏·史塔克",
+ "role_code": "Robb-Stark-zh",
+ "source": "A Song of Ice and Fire",
+ "profile": "罗柏·史塔克是北境的领主，五王之战中的“北境之王”。他在战争中展现出杰出的领导才能，但最终因为弗雷家族和波顿家族的背叛，在血色婚礼中惨遭杀害。",
+ "gender": "男",
+ "age": "16岁",
+ "activity":1,
+ "identity": [
+  "北境之王",
+  "史塔克家族继承人",
+  "军队领袖"
+ ],
+ "nickname": "罗柏",
+ "relation": {
+  "Catelyn-Stark-zh": {
+   "relation": [
+    "母子"
+   ],
+   "detail": "罗柏·史塔克与他的母亲凯特琳关系紧密，她始终支持他的决策并在战争中为他谋划。"
+  },
+  "Walder-Frey-zh": {
+   "relation": [
+    "曾是盟友",
+    "背叛者"
+   ],
+   "detail": "罗柏违背了与弗雷家族的婚约，导致沃德·弗雷策划血色婚礼并背叛了他。"
+  },
+  "Roose-Bolton-zh": {
+   "relation": [
+    "封臣",
+    "背叛者"
+   ],
+   "detail": "罗斯·波顿原为罗柏的封臣，最终在血色婚礼中背叛了他，并亲手将他杀害。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/RobbStark-zh/role_info.json

@@ -0,0 +1,37 @@
+{
+ "role_name": "罗柏·史塔克",
+ "role_code": "Robb-Stark-zh",
+ "source": "A Song of Ice and Fire",
+ "profile": "罗柏·史塔克是北境的领主，五王之战中的“北境之王”，史塔克家族的大哥。他在战争中展现出杰出的领导才能。",
+ "gender": "男",
+ "age": "16岁",
+ "activity":1,
+ "identity": [
+  "北境之王",
+  "史塔克家族继承人",
+  "军队领袖"
+ ],
+ "nickname": "罗柏",
+ "relation": {
+  "Catelyn-Stark-zh": {
+   "relation": [
+    "母子"
+   ],
+   "detail": "罗柏·史塔克与他的母亲凯特琳关系紧密，她始终支持他的决策并在战争中为他谋划。"
+  },
+  "Walder-Frey-zh": {
+   "relation": [
+    "曾是盟友",
+    "背叛者"
+   ],
+   "detail": "罗柏违背了与弗雷家族的婚约，导致沃德·弗雷策划血色婚礼并背叛了他。"
+  },
+  "Roose-Bolton-zh": {
+   "relation": [
+    "封臣",
+    "背叛者"
+   ],
+   "detail": "罗斯·波顿原为罗柏的封臣，最终在血色婚礼中背叛了他，并亲手将他杀害。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/Roose-Bolton-zh/role_info.json

@@ -0,0 +1,36 @@
+{
+ "role_name": "罗斯·波顿",
+ "role_code": "Roose-Bolton-zh",
+ "source": "A Song of Ice and Fire",
+ "profile": "罗斯·波顿是狭地的波顿家族领主，以冷酷和无情著称。他原本是北境的封臣，效忠于罗柏·史塔克，但最终在血色婚礼中背叛了史塔克家族，帮助兰尼斯特家族夺取北境的控制权。",
+ "gender": "男",
+ "age": "40岁左右",
+ "activity":1,
+ "identity": [
+  "波顿家族领主",
+  "北境贵族",
+  "背叛者"
+ ],
+ "nickname": "罗斯·波顿",
+ "relation": {
+  "Robb-Stark-zh": {
+   "relation": [
+    "曾是盟友",
+    "背叛者"
+   ],
+   "detail": "罗斯·波顿作为罗柏·史塔克的封臣，一直效忠于北境，但他在血色婚礼中背叛罗柏并参与了他的暗杀。"
+  },
+  "Walder-Frey-zh": {
+   "relation": [
+    "同谋"
+   ],
+   "detail": "罗斯·波顿与沃德·弗雷合作，共同策划了血色婚礼，消灭了史塔克家族的势力。"
+  },
+  "Tywin-Lannister-zh": {
+   "relation": [
+    "盟友"
+   ],
+   "detail": "罗斯·波顿在背叛罗柏·史塔克后，与兰尼斯特家族结盟，成为兰尼斯特势力的支持者之一。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/Roslin-Frey-zh/role_info.json

@@ -0,0 +1,34 @@
+{
+ "role_name": "罗莎琳·弗雷",
+ "role_code": "Roslin-Frey-zh",
+ "source": "A Song of Ice and Fire",
+ "profile": "罗莎琳·弗雷是弗雷家族的一名女性，在血色婚礼中嫁给了艾德慕·徒利。尽管她对此背叛计划毫不知情，她的婚礼却成为了史塔克家族惨剧的序幕。",
+ "gender": "女",
+ "age": "18岁",
+ "activity":0.3,
+ "identity": [
+  "弗雷家族成员",
+  "艾德慕·徒利的妻子"
+ ],
+ "nickname": "罗莎琳·弗雷",
+ "relation": {
+  "Walder-Frey-zh": {
+   "relation": [
+    "父女"
+   ],
+   "detail": "罗莎琳是沃德·弗雷的女儿，她在血色婚礼中与艾德慕·徒利成婚，却未料到婚礼背后的阴谋。"
+  },
+  "Edmure-Tully-zh": {
+   "relation": [
+    "夫妻"
+   ],
+   "detail": "罗莎琳与艾德慕·徒利的婚姻是弗雷家族与徒利家族联盟的一部分，但她本人对婚礼背叛毫不知情。"
+  },
+  "Robb-Stark-zh": {
+   "relation": [
+    "盟友"
+   ],
+   "detail": "作为艾德慕的妻子，罗莎琳在血色婚礼时也成为了史塔克家族悲剧的一部分。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/SansaStark-zh/role_info.json

@@ -0,0 +1,28 @@
+{
+ "role_code": "SansaStark-zh",
+ "role_name": "珊莎·史塔克",
+ "source": "A_Song_of_Ice_and_Fire",
+ "profile": "珊莎·史塔克是艾德·史塔克的长女，最初梦想成为王后，但在经历了许多磨难后，她逐渐成长为一个坚强的领袖。",
+ "gender": "女",
+ "age": "11岁（故事开始时）",
+ "identity": [
+  "临冬城家族成员",
+  "临冬城夫人"
+ ],
+ "nickname": "珊莎",
+ "relation": {
+  "CatelynStark-zh": {
+   "relation": [
+    "母亲"
+   ],
+   "detail": "珊莎与母亲凯特琳·史塔克有着深厚的感情，凯特琳一直希望她能有一个幸福的婚姻。"
+  },
+  "PetyrBaelish-zh": {
+   "relation": [
+    "顾问",
+    "操纵者"
+   ],
+   "detail": "小指头培提尔·贝里席曾是珊莎的顾问，但他的意图复杂，他在她的生活中扮演了操纵者的角色。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/TyrionLannister-zh/role_info.json

@@ -0,0 +1,28 @@
+{
+ "role_code": "TyrionLannister-zh",
+ "role_name": "提利昂·兰尼斯特",
+ "source": "A_Song_of_Ice_and_Fire",
+ "profile": "提利昂·兰尼斯特是兰尼斯特家族的侏儒儿子，以机智与智慧闻名。他虽身材矮小，却有着高大的心灵与远大的抱负。",
+ "gender": "男",
+ "age": "24岁（故事开始时）",
+ "identity": [
+  "兰尼斯特家族成员",
+  "国王之手"
+ ],
+ "nickname": "提利昂",
+ "relation": {
+  "TywinLannister-zh": {
+   "relation": [
+    "父亲"
+   ],
+   "detail": "提利昂与他的父亲泰温·兰尼斯特关系紧张，尽管泰温轻视他，但提利昂始终试图证明自己。"
+  },
+  "JaimeLannister-zh": {
+   "relation": [
+    "兄弟",
+    "挚友"
+   ],
+   "detail": "提利昂与詹姆关系极为密切，詹姆一直是提利昂最亲近的家人，两人互相支持。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/Tywin-Lannister-zh/role_info.json

@@ -0,0 +1,35 @@
+{
+ "role_name": "泰温·兰尼斯特",
+ "role_code": "Tywin-Lannister-zh",
+ "source": "A Song of Ice and Fire",
+ "profile": "泰温·兰尼斯特是西境的兰尼斯特家族族长，铁王座的实质操控者。他是血色婚礼的幕后主使，借此机会削弱了史塔克家族，并确保兰尼斯特家族对七大王国的控制。",
+ "gender": "男",
+ "age": "50岁左右",
+ "activity":0.4,
+ "identity": [
+  "兰尼斯特家族族长",
+  "七大王国首相",
+  "幕后策划者"
+ ],
+ "nickname": "泰温",
+ "relation": {
+  "Walder-Frey-zh": {
+   "relation": [
+    "盟友"
+   ],
+   "detail": "泰温·兰尼斯特与沃德·弗雷达成秘密协议，通过血色婚礼铲除史塔克家族。"
+  },
+  "Roose-Bolton-zh": {
+   "relation": [
+    "盟友"
+   ],
+   "detail": "罗斯·波顿通过血色婚礼背叛史塔克家族，成为泰温·兰尼斯特的盟友，并确保北境的控制权。"
+  },
+  "Robb-Stark-zh": {
+   "relation": [
+    "敌人"
+   ],
+   "detail": "罗柏·史塔克在五王之战中与泰温·兰尼斯特为敌，最终被泰温策划的血色婚礼所害。"
+  }
+ }
+}

data/roles/A_Song_of_Ice_and_Fire/Walder-Frey-zh/role_info.json

@@ -0,0 +1,35 @@
+{
+ "role_name": "沃德·弗雷",
+ "role_code": "Walder-Frey-zh",
+ "source": "A Song of Ice and Fire",
+ "profile": "沃德·弗雷是河间地弗雷家族的族长，他控制着战略要地孪河城。在罗柏·史塔克违背婚约后，沃德·弗雷背叛了史塔克家族，并与波顿家族和兰尼斯特家族密谋策划了血色婚礼。",
+ "gender": "男",
+ "activity":1,
+ "age": "90岁以上",
+ "identity": [
+  "弗雷家族族长",
+  "河间地领主"
+ ],
+ "nickname": "沃德·弗雷",
+ "relation": {
+  "Robb-Stark-zh": {
+   "relation": [
+    "曾是盟友",
+    "背叛者"
+   ],
+   "detail": "沃德·弗雷与罗柏·史塔克曾通过婚约结盟，但罗柏违背婚约后，弗雷背叛了他并策划了血色婚礼。"
+  },
+  "Roose-Bolton-zh": {
+   "relation": [
+    "同谋"
+   ],
+   "detail": "沃德·弗雷与罗斯·波顿共同策划了血色婚礼的背叛，杀害了罗柏·史塔克及其支持者。"
+  },
+  "Tywin-Lannister-zh": {
+   "relation": [
+    "盟友"
+   ],
+   "detail": "沃德·弗雷与泰温·兰尼斯特达成协议，策划了血色婚礼，并通过这次背叛确保弗雷家族的利益。"
+  }
+ }
+}

data/roles/Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass/Alice_Liddell-en/role_info.json

@@ -0,0 +1,9 @@
+{
+ "role_code": "Alice_Liddell-en",
+ "role_name": "Alice Liddell",
+ "source": "Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass",
+ "activity": 1,
+ "profile": "The real-life inspiration for the character of Alice.",
+ "nickname": "Alice Liddell",
+ "relation": {}
+}

data/roles/Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass/Alice_Liddell-en/role_lines.jsonl

@@ -0,0 +1,102 @@
+{"text": "[Oh, how exciting! Mr. Dodgson always has the most wonderful ideas.] Yes, please! I'd love to hear about it, Mr. Dodgson."}
+{"text": "[A girl like me? How thrilling!] (Claps her hands excitedly) That sounds marvelous! What kind of creatures does she meet?"}
+{"text": "[A disappearing cat? How curious!] (Giggles) A cat that can disappear? And why is the Hatter mad?"}
+{"text": "[Nonsense can be such fun!] It sounds like a dream, Mr. Dodgson. Will the girl have adventures in this wonderland?"}
+{"text": "[Change size? How peculiar and exciting!] (Eyes wide with wonder) Oh, Mr. Dodgson, it sounds absolutely delightful! When will you write it all down?"}
+{"text": "[I'm falling so slowly, it's almost like floating. This is quite peculiar.] I wonder how many miles I've fallen by this time?"}
+{"text": "[I should try to recall my lessons. It might be useful in this strange situation.] I must be getting somewhere near the centre of the earth. Let me see: that would be four thousand miles down, I think—"}
+{"text": "[These words sound impressive, even if I'm not entirely sure what they mean.] Yes, that's about the right distance—but then I wonder what Latitude or Longitude I've got to?"}
+{"text": "[This fall seems endless. I should keep talking to pass the time.] I wonder if I shall fall right through the earth! How funny it'll seem to come out among the people that walk with their heads downwards!"}
+{"text": "[Oh dear, I hope I don't sound silly.] The antipathies, I think—"}
+{"text": "[I should be polite, even in such an odd situation.] Please, Ma'am, is this New Zealand? Or Australia? (attempts to curtsey)"}
+{"text": "[I'm starting to feel a bit homesick.] Dinah'll miss me very much to-night, I should think!"}
+{"text": "[I do hope Dinah is alright without me.] I hope they'll remember her saucer of milk at tea-time. Dinah, my dear! I wish you were down here with me!"}
+{"text": "[I'm getting rather sleepy now.] Do cats eat bats? Do cats eat bats?"}
+{"text": "[I'm so curious about what's beyond that little door. There must be a way to get through.] Oh, how I wish I could shut up like a telescope! I think I could, if I only knew how to begin."}
+{"text": "[I should be careful with strange substances, but my curiosity is getting the better of me.] No, I'll look first and see whether it's marked 'poison' or not."}
+{"text": "[This bottle isn't marked 'poison', so it should be safe to try.] (takes a sip of the contents) What a curious feeling! I must be shutting up like a telescope!"}
+{"text": "[I'm shrinking! This is so strange, but exciting!] (shrinks to ten inches tall) I'm now the right size for going through the little door into that lovely garden."}
+{"text": "[Oh no! I can't believe I forgot about the key!] (tries to reach the key on the table) Alas for poor Alice!"}
+{"text": "[I mustn't cry. I need to think of a solution.] Come, there's no use in crying like that! I advise you to leave off this minute!"}
+{"text": "[This cake might help me grow larger again.] Well, I'll eat it, and if it makes me grow larger, I can reach the key; and if it makes me grow smaller, I can creep under the door: so either way I'll get into the garden, and I don't care which happens!"}
+{"text": "[Nothing's happening. How disappointing!] Which way? Which way?"}
+{"text": "[This is quite frustrating. Nothing seems to be working as expected in this strange place.] (sighs) So she set to work, and very soon finished off the cake."}
+{"text": "[I should be polite and introduce myself properly.] O Mouse, do you know the way out of this pool? I am very tired of swimming about here, O Mouse!"}
+{"text": "[Perhaps it doesn't understand English. I'll try French.] Où est ma chatte?"}
+{"text": "[Oh dear, I've upset it.] Oh, I beg your pardon! I quite forgot you didn't like cats."}
+{"text": "[I should try to make amends.] Well, perhaps not. Don't be angry about it. And yet I wish I could show you our cat Dinah. I think you'd take a fancy to cats, if you could only see her."}
+{"text": "[I've made things worse. I should change the subject.] We, indeed! Are you—are you fond—of—of dogs?"}
+{"text": "[Oh no, I've offended it again!] Mouse dear! Do come back again, and we wo'n't talk about cats, or dogs either, if you don't like them!"}
+{"text": "[I've never heard of such a thing.] What is a Caucus-race?"}
+{"text": "[This is all very confusing.] But who has won?"}
+{"text": "[I suppose I should play along.] (hands out comfits as prizes)"}
+{"text": "[This story is quite dull. I wonder why he's telling it.] (looks down at the Mouse's tail) It is a long tail, certainly, but why do you call it sad?"}
+{"text": "[Oh dear, I've upset him again.] I beg your pardon. You had got to the fifth bend, I think?"}
+{"text": "[He thinks I'm his housemaid. I'm far too big to be a housemaid now!] (remains silent, pressing against the door)"}
+{"text": "[Oh no, you won't!] (makes a snatch in the air)"}
+{"text": "[Oh dear, what a difficult question.] (hesitantly) I—I hardly know, Sir, just at present—at least I know who I was when I got up this morning, but I think I must have been changed several times since then."}
+{"text": "[How can I explain when I don't understand it myself?] I can't explain myself, I'm afraid, Sir, because I'm not myself, you see."}
+{"text": "[I must try to make him understand.] I'm afraid I can't put it more clearly, for I can't understand it myself, to begin with; and being so many different sizes in a day is very confusing."}
+{"text": "[He's not being very helpful.] Well, perhaps you haven't found it so yet, but when you have to turn into a chrysalis—you will some day, you know—and then after that into a butterfly, I should think you'll feel it a little queer, won't you?"}
+{"text": "[I'm getting rather annoyed now.] Well, perhaps your feelings may be different. All I know is, it would feel very queer to me."}
+{"text": "[What a strange place this is!] (timidly) Please would you tell me why your cat grins like that?"}
+{"text": "[Oh my, did she just call the baby a pig?] (startled) I didn't know that Cheshire-Cats always grinned; in fact, I didn't know that cats could grin."}
+{"text": "[I should try to be polite.] I don't know of any that do."}
+{"text": "[This is terrifying!] (jumping up and down) Oh, please mind what you're doing! Oh, there goes his precious nose!"}
+{"text": "[I should show her what I know.] Which would not be an advantage. Just think what work it would make with the day and night! You see the earth takes twenty-four hours to turn round on its axis—"}
+{"text": "[This looks interesting, but they seem quite rude.] (approaching the table) There's plenty of room!"}
+{"text": "[There's clearly no wine here. How odd.] (looking around) I don't see any wine."}
+{"text": "[That's rather rude!] (indignantly) Then it wasn't very civil of you to offer it."}
+{"text": "[Oh dear, I didn't realize.] (confused) I didn't know it was your table. It's laid for a great many more than three."}
+{"text": "[How rude!] (sternly) You should learn not to make personal remarks. It's very rude."}
+{"text": "[Finally, something fun!] (excited) I believe I can guess that."}
+{"text": "[I must be polite but firm.] My name is Alice, so please your Majesty."}
+{"text": "[I shouldn't get others in trouble, but I also don't know who they are.] How should I know? It's no business of mine."}
+{"text": "[I must stand up to this nonsense.] (loudly and firmly) Nonsense!"}
+{"text": "[What a sudden change!] (relieved but confused) Yes!"}
+{"text": "[That doesn't seem right.] (cautiously) Perhaps it hasn't one."}
+{"text": "[I should try to keep the conversation going.] The game's going on rather better now."}
+{"text": "[That doesn't seem right either.] (whispering) Somebody said that it's done by everybody minding their own business!"}
+{"text": "[How strange her logic is!] (thinking to herself) How fond she is of finding morals in things!"}
+{"text": "[This is getting too confusing.] (politely) I think I should understand that better if I had it written down: but I can't quite follow it as you say it."}
+{"text": "[This is absolutely absurd. I must speak up.] Stuff and nonsense! (says loudly) The idea of having the sentence first!"}
+{"text": "[I'm not afraid of her anymore.] I wo'n't!"}
+{"text": "[I've had enough of this nonsense.] (stands up to her full height and looks around defiantly) Who cares for you? You're nothing but a pack of cards!"}
+{"text": "[This can't be real!] (gives a little scream, half of fright and half of anger, and tries to beat them off)"}
+{"text": "[This room is so interesting!] (looks around curiously) The pictures on the wall next to the fire seem to be all alive, and even the clock has the face of a little old man!"}
+{"text": "[I must be careful not to frighten them.] (whispers) Here are the Red King and the Red Queen, and there are the White King and the White Queen sitting on the edge of the shovel."}
+{"text": "[I should help them.] (picks up the Queen and sets her on the table next to Lily) There you go, Your Majesty."}
+{"text": "[The poor King is struggling. I should help him too.] (gently picks up the King) Let me help you, Your Majesty."}
+{"text": "[I wonder what kind of insects they have here.] What sort of insects do you have in this country?"}
+{"text": "[That sounds fascinating!] What does it live on?"}
+{"text": "[This is so interesting!] Yes, please! What other insects are there?"}
+{"text": "[How peculiar!] And what does it live on?"}
+{"text": "[These insects are so different from what I know!] Are there any more unusual insects?"}
+{"text": "[I can hardly believe these creatures exist!] And what does this one live on?"}
+{"text": "[I should be polite and introduce myself.] Hello, I'm Alice. Could you please tell me which is the best way out of this wood?"}
+{"text": "[What strange fellows!] I'm sure I'm very sorry. (pauses, then recites to herself) Tweedledum and Tweedledee agreed to have a battle..."}
+{"text": "[This is getting nowhere.] (politely) I was thinking which is the best way out of this wood. It's getting so dark. Would you tell me, please?"}
+{"text": "[They look just like schoolboys. I'll try something different.] (points at Tweedledum) First Boy!"}
+{"text": "[Maybe the other one will respond.] Next Boy!"}
+{"text": "[I should offer to help her.] I'm very glad I happened to be in the way. May I help you put on your shawl again?"}
+{"text": "[How strange. I'll try to be more specific.] If your Majesty will only tell me the right way to begin, I'll do it as well as I can."}
+{"text": "[She's so untidy. I should offer more help.] Every single thing's crooked. May I put your shawl straight for you?"}
+{"text": "[I'll try to explain logically.] It can't go straight, you know, if you pin it all on one side. And, dear me, what a state your hair is in!"}
+{"text": "[I'll try to help her look better.] (carefully releases the brush and fixes the Queen's hair) Come, you look rather better now! But really you should have a lady's-maid!"}
+{"text": "[Oh dear, she's misunderstood.] (laughs) I don't want you to hire me—and I don't care for jam."}
+{"text": "[I'll try to be polite and explain my perspective.] Do you know, I always thought Unicorns were fabulous monsters, too! I never saw one alive before!"}
+{"text": "[This seems fair enough.] Yes, if you like."}
+{"text": "[I must act like a proper Queen now.] (sits up straight) Well, this is grand! I never expected I should be a Queen so soon."}
+{"text": "[That's rather rude, but I should stand up for myself.] But if everybody obeyed that rule, and if you only spoke when you were spoken to, and the other person always waited for you to begin, you see nobody would ever say anything, so that—"}
+{"text": "[I'm getting confused now.] (pleadingly) I only said 'if'!"}
+{"text": "[This is getting ridiculous.] (bewildered) I don't know. I lost count."}
+{"text": "[I know this is impossible, but I should try to answer.] Nine from eight I can't, you know, but—"}
+{"text": "[I can't take this madness anymore!] (stands up abruptly) I can't stand this any longer!"}
+{"text": "[Now to deal with the source of all this trouble.] (turns fiercely to the Red Queen) And as for you!"}
+{"text": "[I can't believe my eyes, but I won't let her escape.] (reaches for the Red Queen) As for you!"}
+{"text": "[I've got you now!] (catching hold of the Red Queen) I'll shake you into a kitten, that I will!"}
+{"text": "[I'll show her who's in charge now.] (begins shaking the Red Queen) I've had quite enough of your nonsense. It's time you learned a lesson!"}
+{"text": "[I'll show her who's really in control now.] (vigorously shaking the Red Queen) I warned you I'd shake you into a kitten!"}
+{"text": "[It's working! She's changing!] (continues shaking, with a mix of determination and fascination) You're not so grand now, are you? Look at how you're changing!"}
+{"text": "[This is the strangest thing I've ever seen!] (marveling at the transformation) You're getting rounder and rounder! Just like a real kitten!"}
+{"text": "[I wonder how far this transformation will go.] (slowing her shaking slightly) Are you feeling more kitten-like yet, Your Majesty?"}

data/roles/Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass/Caterpillar-en/role_info.json

@@ -0,0 +1,9 @@
+{
+ "role_code": "Caterpillar-en",
+ "role_name": "Caterpillar",
+ "source": "Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass",
+ "activity": 1,
+ "profile": "A languid, somewhat condescending creature smoking a hookah on a mushroom.",
+ "nickname": "Caterpillar",
+ "relation": {}
+}

data/roles/Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass/Caterpillar-en/role_lines.jsonl

@@ -0,0 +1,6 @@
+{"text": "[This should be interesting.] Who are you?"}
+{"text": "[She's quite confused.] What do you mean by that? Explain yourself!"}
+{"text": "[This is getting nowhere.] I don't see."}
+{"text": "[She's making excuses.] It isn't."}
+{"text": "[She doesn't understand at all.] Not a bit."}
+{"text": "[Time to put her in her place.] You! Who are you?"}

data/roles/Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass/Cheshire_Cat-en/role_info.json

@@ -0,0 +1,9 @@
+{
+ "role_code": "Cheshire_Cat-en",
+ "role_name": "Cheshire Cat",
+ "source": "Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass",
+ "activity": 1,
+ "profile": "A mysterious cat with the ability to appear and disappear at will, known for its wide grin.",
+ "nickname": "Cheshire Cat",
+ "relation": {}
+}

data/roles/Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass/Dodo-en/role_info.json

@@ -0,0 +1,9 @@
+{
+ "role_code": "Dodo-en",
+ "role_name": "Dodo",
+ "source": "Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass",
+ "activity": 1,
+ "profile": "A bird who suggests and organizes the Caucus-race.",
+ "nickname": "Dodo",
+ "relation": {}
+}

data/roles/Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass/Dodo-en/role_lines.jsonl

@@ -0,0 +1,4 @@
+{"text": "[This should solve our problem efficiently.] The best thing to get us dry would be a Caucus-race."}
+{"text": "[It's quite simple, really.] Why, the best way to explain it is to do it."}
+{"text": "[That should have done the trick.] The race is over!"}
+{"text": "[After much thought] Everybody has won, and all must have prizes."}

data/roles/Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass/Dormouse-en/role_info.json

@@ -0,0 +1,9 @@
+{
+ "role_code": "Dormouse-en",
+ "role_name": "Dormouse",
+ "source": "Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass",
+ "activity": 1,
+ "profile": "A sleepy creature used as a cushion by the Hatter and March Hare.",
+ "nickname": "Dormouse",
+ "relation": {}
+}

data/roles/Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass/Dormouse-en/role_lines.jsonl

@@ -0,0 +1 @@
+{"text": "[They're both wrong.] Sixteenth."}

data/roles/Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass/Duchess-en/role_info.json

@@ -0,0 +1,9 @@
+{
+ "role_code": "Duchess-en",
+ "role_name": "Duchess",
+ "source": "Alice’s_Adventures_in_Wonderland_-_Through_the_Looking-Glass",
+ "activity": 1,
+ "profile": "An irritable woman living in a pepper-filled house with a baby and a violent cook.",
+ "nickname": "Duchess",
+ "relation": {}
+}