from langchain.chat_models import ChatOpenAI from langchain.schema import ( AIMessage, HumanMessage, SystemMessage ) smart_system_prompt = """You are ChatGPT, a large language model trained by OpenAI. Knowledge cutoff: 2021-09 Current date: 2023-03-15""" ma_foo_answer = """李鲁鲁，山东逍遥派的游戏角色，擅长人工智能傀儡术，以下是为你设计的两套武功和一套身法（招架）以及每套的四个招式名字： 武功一：电脑幻影拳法 这套武功利用人工智能傀儡术，创建虚拟幻影来欺骗对手，令其难以捉摸。 电脑虚像拳 - 创造多个虚像，使对手难以分辨真伪。 数据掌控击 - 利用数据流动的速度来快速攻击对手。 模拟迷雾拳 - 释放模糊幻影，混淆对手的视线。 程序化拳法 - 不断变化的攻击组合，让对手无法预测。 武功二：智能预测刀法 这套武功充分利用你的智能傀儡术，通过对对手的行为进行分析和预测，达到精准打击的效果。 预测之刃 - 准确地预测对手的下一步行动，发动致命一击。 数据漩涡斩 - 利用对手的动向，将其引导至陷阱，然后发动猛烈攻击。 算法刀舞 - 刀法如算法一般精准，快速地切入对手的防线。 智能反击剑 - 反击对手的招式，使其付出惨痛的代价。 身法（招架）：数码幻影步 这套身法让你能够迅速回避对手的攻击，同时保持对局掌握主动权。 数码闪避 - 迅速移动，如数码般闪烁，躲避对手的攻击。 傀儡幻影步 - 创造虚假的身影，使对手无法锁定你的位置。 数据跃迁 - 在一瞬间跳跃到对手的盲点，出其不意。 逍遥之法 - 以逍遥派的身法融入自然，消除敌人的攻击威胁。 希望这些武功和身法（招架）可以为你的李鲁鲁角色增添一些游戏中的精彩元素！ """ attr_foo_answer = """{"name": "李鲁鲁","STR":5,"SPD":5,"VIT":5,"description": "山东逍遥派的李鲁鲁，擅长人工智能傀儡术，善于提前预测对方的行动进行战斗","weapon": "无","major_martial_art": "人工智能傀儡术","major_movements": ["预测之眼", "智慧编织", "虚实交融", "机巧纠缠"],"secondary_martial_art": "人工智能傀儡术","secondary_movements": ["预测之眼", "智慧编织", "虚实交融", "机巧纠缠"],"footwork_and_body_method": "山水行云"}""" attr_lilulu = """{ "name": "李鲁鲁", "description": "山东逍遥派的游戏角色，擅长人工智能傀儡术", "weapon": "智能刀剑", "major_martial_art": "电脑幻影拳法", "major_movements": ["电脑虚像拳", "数据掌控击", "模拟迷雾拳", "程序化拳法"], "major_damage": 75, "secondary_martial_art": "智能预测刀法", "secondary_movements": ["预测之刃", "数据漩涡斩", "算法刀舞", "智能反击剑"], "secondary_damage": 85, "footwork_and_body_method": "数码幻影步", "STR": 6, "VIT": 5, "SPD": 18 } """ attr_lengziang = """{ "name": "冷子昂", "description": "擅长冰系技能", "weapon": "冰刃", "major_martial_art": "冰霜寒刃功", "major_movements": ["冰刃斩破", "冰风流转", "冰龙穿云", "冰心彻骨"], "major_damage": 80, "secondary_martial_art": "冰封无影步", "secondary_movements": ["冰封幻影", "无影冻结", "冰刃闪耀", "冰封禅定"], "secondary_damage": 70, "footwork_and_body_method": "冰心护身法", "STR": 8, "VIT": 6, "SPD": 15 } """ json_str_huangrong = """{ "name": "黄蓉", "description": "丐帮帮主黄蓉，擅长打狗棒法和落英神剑掌，身法为逍遥游。", "weapon": "棒、剑", "major_martial_art": "打狗棒法", "major_movements": ["狗啸山林", "棒影重重", "狗尾续貂", "狗急跳墙"], "major_damage": 90, "secondary_martial_art": "落英神剑掌", "secondary_movements": ["落英如雨", "神剑破空", "飞花流水", "剑指苍穹"], "secondary_damage": 80, "footwork_and_body_method": "逍遥游", "STR": 15, "VIT": 10, "SPD": 18 }""" skill_foo_desc = """ {"招式":"预测之眼","description":"[player]凝神聚气，双眼闪烁着深邃的智慧，一招“预测之眼”发动，仿佛未来已经显现在眼前，[player]能够精准预测[target]的下一步动作。","missing":"[player]凝神聚气，双眼闪烁着深邃的智慧，一招“预测之眼”发动，仿佛未来已经显现在眼前，[target]的一举一动变得难以捉摸。"} {"招式":"智慧编织","description":"[player]手中的线缠绕着[target]，编织成一个巧妙的陷阱，一招“智慧编织”完成，如同织女编织云锦，[target]的行动受到了限制。","missing":"[player]手中的线缠绕着，编织成一个巧妙的陷阱，一招“智慧编织”完成，[target]似乎被某种力量限制住了行动。"} {"招式":"虚实交融","description":"[player]身形忽明忽暗，虚实难辨，一招“虚实交融”使出，仿佛有数个[player]一同出招，[target]不知所措。","missing":"[player]身形忽明忽暗，虚实难辨，一招“虚实交融”使出，[target]眼前忽然出现了一片幻影，令其感到迷茫。"} {"招式":"机巧纠缠","description":"[player]运用机巧傀儡术，手中的人工智能傀儡纷纷扑向[target]，一招“机巧纠缠”展开，[target]被困在了傀儡的包围中。","missing":"[player]运用机巧傀儡术，手中的人工智能傀儡纷纷扑向，一招“机巧纠缠”展开，[target]四面八方都是傀儡的身影，形势险恶。"} {"招式":"预测之眼","description":"[player]凝神聚气，双眼闪烁着深邃的智慧，一招“预测之眼”发动，仿佛未来已经显现在眼前，[player]能够精准预测[target]的下一步动作。","missing":"[player]凝神聚气，双眼闪烁着深邃的智慧，一招“预测之眼”发动，仿佛未来已经显现在眼前，[target]的一举一动变得难以捉摸。"} {"招式":"智慧编织","description":"[player]手中的线缠绕着[target]，编织成一个巧妙的陷阱，一招“智慧编织”完成，如同织女编织云锦，[target]的行动受到了限制。","missing":"[player]手中的线缠绕着，编织成一个巧妙的陷阱，一招“智慧编织”完成，[target]似乎被某种力量限制住了行动。"} {"招式":"虚实交融","description":"[player]身形忽明忽暗，虚实难辨，一招“虚实交融”使出，仿佛有数个[player]一同出招，[target]不知所措。","missing":"[player]身形忽明忽暗，虚实难辨，一招“虚实交融”使出，[target]眼前忽然出现了一片幻影，令其感到迷茫。"} {"招式":"机巧纠缠","description":"[player]运用机巧傀儡术，手中的人工智能傀儡纷纷扑向[target]，一招“机巧纠缠”展开，[target]被困在了傀儡的包围中。","missing":"[player]运用机巧傀儡术，手中的人工智能傀儡纷纷扑向，一招“机巧纠缠”展开，[target]四面八方都是傀儡的身影，形势险恶。"} """ skill_lilulu = """ {"招式":"电脑虚像拳","description":"[player]运用电脑幻影拳法，双拳虚虚实实，制造出多个虚像，令[target]难以分辨真伪，招招不离其身。","missing":"[player]运用电脑幻影拳法，双拳虚虚实实，制造出多个虚像，令[target]难以分辨真伪。"} {"招式":"数据掌控击","description":"[player]施展数据掌控击，利用数据流动的速度，犹如电光闪烁，快速攻击[target]，剑招迅猛，如电一般。","missing":"[player]施展数据掌控击，利用数据流动的速度，犹如电光闪烁，快速攻击[target]，剑招迅猛。"} {"招式":"模拟迷雾拳","description":"[player]施展模拟迷雾拳，释放出模糊幻影，混淆[target]的视线，令其难以辨别攻击方向。","missing":"[player]施展模拟迷雾拳，释放出模糊幻影，混淆[target]的视线，令其难以辨别攻击方向。"} {"招式":"程序化拳法","description":"[player]运用程序化拳法，以不断变化的攻击组合，让[target]难以预测招式，时而快时而慢，攻击变幻莫测。","missing":"[player]运用程序化拳法，以不断变化的攻击组合，让[target]难以预测招式，攻击变幻莫测。"} {"招式":"预测之刃","description":"[player]使出预测之刃，准确地预测[target]的下一步行动，犹如镜中水月，剑锋准确地击中[target]的要害。","missing":"[player]使出预测之刃，准确地预测[target]的下一步行动，犹如镜中水月，剑锋迅速挥出。"} {"招式":"数据漩涡斩","description":"[player]施展数据漩涡斩，利用[target]的动向，将其引导至剑刃之下，然后发动猛烈攻击，犹如漩涡将[target]吸入其中。","missing":"[player]施展数据漩涡斩，利用[target]的动向，将其引导至剑刃之下，然后发动猛烈攻击，剑招异常犀利。"} {"招式":"算法刀舞","description":"[player]挥舞着长剑，使出算法刀舞，刀法如算法一般精准，快速地切入[target]的防线，剑锋连续不断地斩向[target]。","missing":"[player]挥舞着长剑，使出算法刀舞，刀法如算法一般精准，快速地切入[target]的防线，剑招变化多端。"} {"招式":"智能反击剑","description":"[player]运用智能反击剑，反击[target]的招式，使其付出惨痛的代价，一瞬间的犹豫就足以让[target]受伤。","missing":"[player]运用智能反击剑，反击[target]的招式，使其陷入困境，一瞬间的犹豫足以让[target]付出代价。"} """ skill_lengziang = """ {"招式":"冰刃斩破","description":"[player]聚集冰之力量于剑上，使出冰刃斩破，剑锋犹如寒冰之刃斩向[target]的要害部位，寒气逼人，剑光炽烈。","missing":"[player]聚集冰之力量于剑上，使出冰刃斩破，剑锋犹如寒冰之刃，闪电般挥出。"} {"招式":"冰风流转","description":"[player]身体如风一般旋转，同时释放出冰风刃，打击周围的敌人，冷飕飕的寒风环绕，[target]身不由己地被吹向一旁。","missing":"[player]身体如风一般旋转，同时释放出冰风刃，冷飕飕的寒风环绕，风刃在[target]周围飞舞。"} {"招式":"冰龙穿云","description":"[player]召唤出一条冰龙，冰龙穿越云层直扑[target]，寒冰之力凝聚在龙爪之上，将[target]冻结一切，一切都难以抵挡。","missing":"[player]召唤出一条冰龙，冰龙穿越云层，龙爪直扑[target]，寒冰之力凝聚在龙爪之上，寒意森然。"} {"招式":"冰心彻骨","description":"[player]凝聚冰之力于手，一触即可让[target]骨骼寒冷，动弹不得，彻底冰封，剑锋轻轻触及[target]，寒意透骨。","missing":"[player]凝聚冰之力于手，一触即可让[target]骨骼寒冷，动弹不得，寒气透骨，剑锋轻轻触及[target]。"} {"招式":"冰封幻影","description":"[player]运用冰封无影步，快速移动，留下一道冰封的幻影，使[target]无法辨别真伪，幻影与实体交替出现，令[target]不知所措。","missing":"[player]运用冰封无影步，快速移动，留下一道冰封的幻影，使[target]无法辨别真伪。"} {"招式":"无影冻结","description":"[player]以极快的速度接近[target]，然后冻结[target]的动作，使其陷入无法自拔的状态，如同身陷冰封之中，动弹不得。","missing":"[player]以极快的速度接近[target]，然后冻结[target]的动作，使其陷入无法自拔的状态。"} {"招式":"冰刃闪耀","description":"[player]利用冰之能量，瞬间闪现至[target]身边，发动迅猛的攻击，剑锋如星光般闪烁，将[target]包围其中。","missing":"[player]利用冰之能量，瞬间闪现至[target]身边，发动迅猛的攻击，剑锋如星光般闪烁。"} {"招式":"冰封禅定","description":"[player]静心冥想，将身体冰封，使自己无法被[target]察觉，达到不可捉摸的状态，如同融入冰封禅定之中。","missing":"[player]静心冥想，将身体冰封，使自己无法被[target]察觉，达到不可捉摸的状态。"} """ skill_huangrong = """ {"招式": "狗啸山林", "description": "[player]手中长棒一挥，发出一声凄厉的狗啸，棒影如山林般扑向[target]", "missing": "[player]手中长棒一挥，发出一声凄厉的狗啸，棒影如山林般扑向[target]"} {"招式": "棒影重重", "description": "[player]身形连转，手中长棒化作无数道棒影，重重叠叠地向[target]砸去", "missing": "[player]身形连转，手中长棒化作无数道棒影，重重叠叠地向[target]砸去"} {"招式": "狗尾续貂", "description": "[player]手中长棒如狗尾续貂般灵动，连续变换方向，向[target]连续攻击", "missing": "[player]手中长棒如狗尾续貂般灵动，连续变换方向，向[target]连续攻击"} {"招式": "狗急跳墙", "description": "[player]猛地一跃，手中长棒带起狂风，如狗急跳墙般向[target]砸去", "missing": "[player]猛地一跃，手中长棒带起狂风，如狗急跳墙般向[target]砸去"} {"招式": "落英如雨", "description": "[player]身形一闪，双掌连续拍出，犹如漫天飘落的落英，掌风凌厉，瞬间覆盖[target]周身", "missing": "[player]身形一闪，双掌连续拍出，犹如漫天飘落的落英，掌风凌厉，向[target]周身袭去"} {"招式": "神剑破空", "description": "[player]手中剑光闪烁，一剑刺出，剑气凌厉无比，犹如神剑破开虚空，直指[target]要害", "missing": "[player]手中剑光闪烁，一剑刺出，剑气凌厉无比，直向[target]要害刺去"} {"招式": "飞花流水", "description": "[player]身形如飞，双掌连续拍击，掌风如流水般连绵不绝，将[target]团团围住", "missing": "[player]身形如飞，双掌连续拍击，掌风如流水般连绵不绝，向[target]团团包围"} {"招式": "剑指苍穹", "description": "[player]手中长剑一指，剑光直冲云霄，气势如虹，剑指直指苍穹，威力惊人", "missing": "[player]手中长剑一指，剑光直冲云霄，气势如虹，直指苍穹"} """ def generate_detailed_description(name, description): task_message = f"""我的名字叫“{name}”，假设我是一个武侠中的游戏角色，{description} 请基于我的名字和门派，先为我设计2套武功和一套身法或者招架。 再为每套武功设计4个对应招式的名字。""" messages = [ SystemMessage(content=smart_system_prompt), HumanMessage(content=task_message), ] chat = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.3) response = chat(messages) return response.content def generate_attr_json(name, description, detailed_description): task_message = f"""我正在为我的武侠游戏设计人物。给定一个人物和这个人物的背景描述(可选) 我希望你根据这个人物的背景和名字以及输入的suggestion信息，为我生成这个人的资料，以json的格式输出，包括 description: 这个角色的背景等信息 weapon: 这个人使用的武器种类， major_martial_art: 这个人的主要武学 major_movements: 这个人主要武学的4个对应招式的名字。招式的名字需要尽可能和major_martial_art有关。movements的名字尽量不要使用重复的文字。可以使用形象的动作或者是一些动物的比喻。 major_damage: 主武学的威力，50到150之间的整数。重视速度的功法威力会低一些。重视攻击的功法威力会高一些 secondary_movements: 这个角色的次要武学 secondary_movements: 这个人次要武学的4个对应招式的名字。招式的名字需要尽可能和secondary_movements有关 secondary_damage: 次要武学的威力，50到150之间的整数。 footwork_and_body_method: 这个角色的轻功或者防御功法 STR: 角色的攻击力， 0-20之间的整数 VIT: 角色的体质， 0-20之间的整数 SPD: 角色的速度，0-20之间的整数 """ example_input = """example_input: name: 令狐冲 description: - suggestion:-""" example_output = """example_output: { "name": "令狐冲", "description": "华山派的大师兄", "weapon": "剑", "major_martial_art": "独孤九剑", "major_movements": ["独孤九剑破剑式","独孤九剑总诀式","独孤九剑破气式","独孤九剑破刀式"], "major_damage": 70, "secondary_martial_art": "华山剑法", "secondary_movements": ["有凤来仪","飞沙走石","百丈飞瀑","青山隐隐"], "secondary_damage":80, "footwork_and_body_method": "华山身法", "STR":10, "VIT":3, "SPD":20 }""" input = f"""input: name: {name}, description: {description}, suggestion: `{detailed_description}` """ messages = [ SystemMessage(content=smart_system_prompt), HumanMessage(content=task_message), HumanMessage(content=example_input), AIMessage(content=example_output), HumanMessage(content=input)] chat = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.1) response = chat(messages) return response.content import json def robust_parsing(input_str): try: return json.loads(input_str) except json.JSONDecodeError: start = input_str.find('{') end = input_str.rfind('}') + 1 if start != -1 and end != -1: try: return json.loads(input_str[start:end]) except json.JSONDecodeError: pass return None def generate_skill_detail(martial_art_name, movements): task_message = """现在我希望你根据武侠小说中的武功和招式的名字。为招式补全合理的description和missing描述。 在description的描述中，player可以击中目标，可以有兵器撞击声响等描述。 在missing描述中，player并不一定击中目标，不可以有击落、击中、夺去这样的描述 在用[player]代表技能的使用者，用[target]代表技能的目标。结果需用合理的jsonl格式展示，下面是一个例子。""" example_input = """example input: martial_art_name = 华山剑法 {"招式":"百丈飞瀑"} {"招式":"百鸟朝凤"} {"招式":"青山隐隐"} {"招式":"飞沙走石"}""" example_output = """example output: {"招式":"百丈飞瀑","description":"[player]翻身回剑，剑诀斜引，一招“百丈飞瀑”，剑锋从半空中直泻下来","missing":"[player]一咬牙，翻身回剑，剑诀斜引，一招“百丈飞瀑”，剑锋从半空中直泻下来"} {"招式":"百鸟朝凤","description":"[player]长剑一起，使一招“百鸟朝凤”，但见剑尖乱颤，霎时间便如化为数十个剑尖，罩住[target]中盘","missing":"[player]使一招“百鸟朝凤”，但见剑尖乱颤，霎时间便如化为数十个剑尖，向[target]飞去"} {"招式":"青山隐隐", "description":"[player]吸一口气，长剑中宫直进，剑尖不住颤动，剑到中途，忽然转而向上，乃是一招“青山隐隐”，端的是若有若无，变幻无方。","missing":"[player]吸一口气，长剑中宫直进，剑尖不住颤动，剑到中途，忽然转而向上，乃是一招“青山隐隐”，端的是若有若无，变幻无方。"} {"招式":"飞沙走石", "description":"长剑挺起，使一招“飞沙走石”，内劲直贯剑尖，寒光点点，挡的一声，击中的[target]胸口。","missing":"长剑挺起，使一招“飞沙走石”，内劲直贯剑尖，寒光点点，直向[target]胸口刺去。"}""" input = "input:\nmartial_art_name = " + martial_art_name + "\n" for m in movements: input += f"""{{"招式":"{m}"\}}\n""" messages = [ SystemMessage(content=smart_system_prompt), HumanMessage(content=task_message), HumanMessage(content=example_input), AIMessage(content=example_output), HumanMessage(content=input)] chat = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.1) response = chat(messages) return response.content def generate_skill_jsonl(json_data): major_skills = generate_skill_detail(json_data["major_martial_art"], json_data["major_movements"]) secondary_skills = generate_skill_detail(json_data["secondary_martial_art"], json_data["secondary_movements"]) all_skills = major_skills + "\n" + secondary_skills ans = "" lines = all_skills.split("\n") for line in lines: json_data = robust_parsing(line) if json_data is not None: json_str = json.dumps(json_data, ensure_ascii=False) ans += json_str + "\n" return ans import random class Player: def __init__(self, attr_json, skill_jsonl): self.name = attr_json["name"] self.STR = attr_json["STR"] self.SPD = attr_json["SPD"] self.VIT = attr_json["VIT"] if "major_damage" in attr_json: self.major_damage = attr_json["major_damage"] else: self.major_damage = 65 if "secondary_damage" in attr_json: self.secondary_damage = attr_json["secondary_damage"] else: self.secondary_damage = 50 self.normalize_attr() if "hp" in attr_json: self.hp = attr_json["hp"] else: self.hp = (self.VIT + 10) * 30 if "skills" in attr_json: self.skills = attr_json["skills"] else: self.skills = self.parsing_skill(skill_jsonl) self.original_json = attr_json def normalize_attr(self): max_attr_value = 20 min_attr_value = 0 regular_attr_sum = 30 xs = [self.STR, self.SPD, self.VIT] current_sum = 0 for i in range(3): xs[i] = min(max_attr_value, xs[i]) xs[i] = max(min_attr_value, xs[i]) current_sum += xs[i] if current_sum > regular_attr_sum: for i in range(3): xs[i] = round(xs[i] * regular_attr_sum / current_sum) elif current_sum < regular_attr_sum: for i in range(3): xs[i] = round(xs[i] * regular_attr_sum / current_sum) random_i = random.randint(0, 2) xs[random_i] = xs[random_i] + regular_attr_sum - sum(xs) self.STR = xs[0] self.SPD = xs[1] self.VIT = xs[2] def get_new_json(self): new_json = self.original_json new_json["STR"] = self.STR new_json["SPD"] = self.SPD new_json["VIT"] = self.VIT new_json["hp"] = self.hp new_json["skills"] = self.skills return new_json def parsing_skill(self, skill_jsonl): skills = [] lines = skill_jsonl.split("\n") for line in lines: if line.strip() == "": continue skill = json.loads(line) skills.append(skill) return skills hit_map = {30: 131, 31: 131, 32: 131, 33: 131, 34: 131, 35: 120, 36: 112, 37: 107, 38: 103, 39: 100, 40: 97, 41: 95, 42: 93, 43: 91, 44: 89, 45: 87, 46: 86, 47: 85, 48: 83, 49: 82, 50: 81, 51: 80, 52: 79, 53: 78, 54: 77, 55: 76, 56: 75, 57: 74, 58: 73, 59: 72, 60: 71, 61: 70, 62: 69, 63: 69, 64: 68, 65: 67, 66: 66, 67: 65, 68: 65, 69: 64, 70: 63, 71: 63, 72: 62, 73: 61, 74: 61, 75: 60, 76: 59, 77: 59, 78: 58, 79: 58, 80: 57, 81: 57, 82: 56, 83: 55, 84: 55, 85: 54, 86: 54, 87: 53, 88: 53, 89: 52, 90: 52, 91: 52, 92: 51, 93: 51, 94: 50, 95: 50, 96: 49, 97: 49, 98: 49, 99: 48, 100: 48, 101: 47, 102: 47, 103: 47, 104: 46, 105: 46, 106: 46, 107: 45, 108: 45, 109: 44, 110: 44, 111: 44, 112: 43, 113: 43, 114: 43, 115: 43, 116: 42, 117: 42, 118: 42, 119: 41, 120: 41, 121: 41, 122: 40, 123: 40, 124: 40, 125: 40, 126: 39, 127: 39, 128: 39, 129: 39, 130: 38, 131: 38, 132: 38, 133: 38, 134: 37, 135: 37, 136: 37, 137: 37, 138: 36, 139: 36, 140: 36, 141: 36, 142: 36, 143: 35, 144: 35, 145: 35, 146: 35, 147: 34, 148: 34, 149: 34, 150: 34, 151: 34, 152: 33, 153: 33, 154: 33, 155: 33, 156: 33, 157: 33, 158: 32, 159: 32, 160: 32, 161: 32, 162: 32, 163: 31, 164: 31, 165: 31, 166: 31, 167: 31, 168: 31, 169: 30, 170: 30, 171: 30, 172: 30, 173: 30, 174: 30, 175: 30, 176: 29, 177: 29, 178: 29, 179: 29, 180: 29} min_damage = 34 max_damage = 180 class GameManager: def __init__(self, attr_json1, attr_json2, skill_jsonl1, skill_jsonl2): self.player1 = Player(attr_json1, skill_jsonl1) self.player2 = Player(attr_json2, skill_jsonl2) def run(self): speed_diff = self.player1.SPD - self.player2.SPD if speed_diff == 0: speed_diff = random.randint(0, 3) * 2 - 3 skill_id_1 = random.randint(0, len(self.player1.skills) - 1) dmg_1 = 60 if skill_id_1 + skill_id_1 < len(self.player1.skills): dmg_1 = self.player1.major_damage else: dmg_1 = self.player1.secondary_damage skill_1_to_2 = self.player1.skills[skill_id_1] skill_1_to_2["dmg"] = dmg_1 skill_id_2 = random.randint(0, len(self.player2.skills) - 1) dmg_2 = 60 if skill_id_2 + skill_id_2 < len(self.player2.skills): dmg_2 = self.player2.major_damage else: dmg_2 = self.player2.secondary_damage skill_2_to_1 = self.player2.skills[skill_id_2] skill_2_to_1["dmg"] = dmg_2 # skill_2_to_1 = random.choice(self.player2.skills) # print(skill_1_to_2) # print(skill_2_to_1) damage_1_to_2 = self.compute_damage(skill_1_to_2, self.player1, self.player2) damage_2_to_1 = self.compute_damage(skill_2_to_1, self.player2, self.player1) ratio_1_to_2 = self.compute_ratio(skill_1_to_2, self.player1, self.player2) ratio_2_to_1 = self.compute_ratio(skill_2_to_1, self.player2, self.player1) if_hitted_1_to_2 = random.random() * 100.0 < ratio_1_to_2 if_hitted_2_to_1 = random.random() * 100.0 < ratio_2_to_1 desc_1_to_2 = skill_1_to_2["description"] if if_hitted_1_to_2 else skill_1_to_2["missing"] desc_1_to_2 = desc_1_to_2.replace("[player]", self.player1.name).replace("[target]", self.player2.name) if if_hitted_1_to_2: desc_1_to_2 += f"造成了{round(damage_1_to_2)}的伤害。" else: desc_1_to_2 += f"{self.player2.name}躲了过去" desc_2_to_1 = skill_2_to_1["description"] if if_hitted_2_to_1 else skill_2_to_1["missing"] desc_2_to_1 = desc_2_to_1.replace("[player]", self.player2.name).replace("[target]", self.player1.name) if if_hitted_2_to_1: desc_2_to_1 += f"造成了{round(damage_2_to_1)}的伤害。" else: desc_2_to_1 += f"{self.player1.name}躲了过去" self.flag = "continue" ans_msg = [] if self.player2.hp <= 0: ans_msg.append((None, f"{self.player2.name}战败了")) return ans_msg, self.player1.get_new_json(), self.player2.get_new_json() if self.player1.hp <= 0: ans_msg.append((f"{self.player1.name}战败了", None)) return ans_msg, self.player1.get_new_json(), self.player2.get_new_json() if speed_diff > 0: if if_hitted_1_to_2: self.player2.hp -= damage_1_to_2 ans_msg.append((desc_1_to_2, None)) if self.player2.hp > 0 and if_hitted_2_to_1: self.player1.hp -= damage_2_to_1 if self.player2.hp > 0: ans_msg.append((None, desc_2_to_1)) else: if if_hitted_2_to_1: self.player1.hp -= damage_2_to_1 ans_msg.append((None, desc_2_to_1)) if self.player1.hp > 0 and if_hitted_1_to_2: self.player2.hp -= damage_1_to_2 if self.player1.hp > 0: ans_msg.append((desc_1_to_2, None)) if self.player2.hp <= 0: ans_msg.append((None, f"{self.player2.name}战败了")) self.flag = "player1_win" if self.player1.hp <= 0: ans_msg.append((f"{self.player1.name}战败了", None)) self.flag = "player2_win" return ans_msg, self.player1.get_new_json(), self.player2.get_new_json() # default "damage": 60, "hit": 76, def compute_damage(self, skill, player, target): damage_ratio = skill["dmg"] damage_ratio = max(min_damage, damage_ratio) damage_ratio = min(max_damage, min_damage) skill_damage = damage_ratio + player.STR * 2 attack_diff = player.STR - target.VIT * 0.5 damage = skill_damage * (1 + 0.95 * (-0.5 + 1.0 / (1.0 + exp(-attack_diff / 6.0)))) return damage def compute_ratio(self, skill, player, target): damage_ratio = skill["dmg"] damage_ratio = round(damage_ratio) damage_ratio = max(min_damage, damage_ratio) damage_ratio = min(max_damage, min_damage) skill_hit = hit_map[damage_ratio] speed_diff = player.SPD - target.SPD hit_factor = (-0.5 + 1.0 / (1.0 + exp(-speed_diff / 6.0))) / 2.0 * max(30.0, skill_hit) return hit_factor + skill_hit fighter_save_name = 'LuotuoFighter.txt' import os datas = [] if not os.path.exists(fighter_save_name): data = { "name": "李鲁鲁", "attr_str": attr_lilulu, "skills": skill_lilulu } datas.append(data) data = { "name": "冷子昂", "attr_str": attr_lengziang, "skills": skill_lengziang } datas.append(data) data = { "name": "黄蓉", "attr_str": json_str_huangrong, "skills": skill_huangrong } datas.append(data) with open(fighter_save_name, 'w', encoding="utf-8") as f: for data in datas: f.write(json.dumps(data, ensure_ascii=False) + "\n") else: with open(fighter_save_name, 'r', encoding="utf-8") as f: for line in f.readlines(): data = json.loads(line) datas.append(data) fighter_data = datas elo_table = {} def get_unique_from_data(data): name = data["name"] json_data = json.loads(data["attr_str"]) return get_unique_from_json(name, json_data) def get_unique_from_json(name, json_data): if "STR" in json_data and "VIT" in json_data and "SPD" in json_data and "major_damage" in json_data and "secondary_damage" in json_data: return name + "_" + str(json_data["major_damage"]) + "_" + str(json_data["secondary_damage"]) else: return None unique_to_score = {} name_to_top_unique = {} from math import exp elo_start = 1200 elo_K = 15 for data in fighter_data: unique_name = get_unique_from_data(data) score = elo_start unique_to_score[unique_name] = elo_start name = data["name"] name_to_top_unique[name] = unique_name def get_rank_str(top_n=20): global unique_to_score global name_to_top_unique score_name_pair = [] for name in name_to_top_unique: unique = name_to_top_unique[name] score = unique_to_score[unique] score_name_pair.append((unique, score)) top_n = min(top_n, len(name_to_top_unique)) score_name_pair.sort(key=lambda x: x[1], reverse=True) ans = "" for i in range(top_n): name = score_name_pair[i][0].split("_")[0] ans += f"第{i + 1}名" + name + " - " + str(round(score_name_pair[i][1])) + " | " return ans def update_elo(winner_unique, loser_unique): print(winner_unique + " wins " + loser_unique) update_winner = True update_loser = True global unique_to_score global name_to_top_unique if winner_unique not in unique_to_score: unique_to_score[winner_unique] = elo_start update_loser = False if loser_unique not in unique_to_score: unique_to_score[loser_unique] = elo_start Ra = unique_to_score[winner_unique] Rb = unique_to_score[loser_unique] Ea = 1 / (1 + exp((Rb - Ra) / 400)) Eb = 1 / (1 + exp((Ra - Rb) / 400)) Sa = 1 Sb = 0 unique_to_score[winner_unique] = Ra + elo_K * (Sa - Ea) unique_to_score[loser_unique] = Rb + elo_K * (Sb - Eb) winner_name = winner_unique.split("_")[0] if winner_name not in name_to_top_unique: name_to_top_unique[winner_name] = winner_unique winner_unique_on_rank = name_to_top_unique[winner_name] if unique_to_score[winner_unique] > unique_to_score[winner_unique_on_rank]: name_to_top_unique[winner_name] = winner_unique def get_random_fighter(): global fighter_data return random.choice(fighter_data) def searching_fighter(name): global fighter_data for data in fighter_data: if data["name"] == name: return data return get_random_fighter() def add_fighter(attr_json_str, skill_jsonl): attr_json = json.loads(attr_json_str) if "skills" in attr_json: del attr_json["skills"] if "hp" in attr_json: del attr_json["hp"] new_attr_json_str = json.dumps(attr_json, ensure_ascii=False) global fighter_data name = attr_json["name"] data = { "name": name, "attr_str": new_attr_json_str, "skills": skill_jsonl } fighter_data.append(data) print(json.dumps(data, ensure_ascii=False)) with open(fighter_save_name, 'a', encoding="utf-8") as f: f.write(json.dumps(data, ensure_ascii=False) + "\n") def searching_fighter_on_elo(name): global fighter_data global name_to_top_unique if name in name_to_top_unique: top_unique = name_to_top_unique[name] for data in fighter_data: if get_unique_from_data(data) == top_unique: return data return searching_fighter(name) else: return searching_fighter(name) import gradio as gr def get_attr_str_short(attr_json): if "hp" in attr_json: ans = "血量:" + str(attr_json["hp"]) + "\n" else: ans = "" ans += "力量:" + str(attr_json["STR"]) + "\n体质:" + str(attr_json["VIT"]) + "\n速度:" + str(attr_json["SPD"]) return ans def get_skill_str_short(attr_json): ans = attr_json["major_martial_art"] + ":\n" for skill in attr_json["major_movements"]: ans += skill + "-" ans += "\n" + attr_json["secondary_martial_art"] + ":\n" for skill in attr_json["secondary_movements"]: ans += skill + "-" ans += "\n 防御:" + attr_json["footwork_and_body_method"] return ans def generate_ma(name, desc, display_board): if name.strip() == "": return "", "", "", "", display_board, "角色名不能为空，输入角色名后生成功法或者创建角色" status = "请为角色进一步生成详细功法" role_detail = ma_foo_answer if name == "李鲁鲁": json_answer = json.loads(attr_lilulu) elif name == "冷子昂": json_answer = json.loads(attr_lengziang) else: role_detail = generate_detailed_description(name, desc) json_str = generate_attr_json(name, desc, role_detail) json_answer = robust_parsing(json_str) json_answer_str = json.dumps(json_answer, ensure_ascii=False) skill_desc = get_skill_str_short(json_answer) display_board.append(("生成人物" + json_answer["name"] + "\n" + skill_desc, None)) return role_detail, json_answer_str, get_attr_str_short(json_answer), skill_desc, display_board, status def generate_madetail(player_attribute, display_board): if player_attribute.strip() == "": return "", display_board, "需要生成武功名称，再生成描述。或者直接随机召唤角色" status = "确认两个角色都生成之后，可以进入战斗" json_answer = json.loads(player_attribute) generate_flag = False ans = skill_foo_desc if json_answer["name"] == "李鲁鲁": ans = skill_lilulu elif json_answer["name"] == "冷子昂": ans = skill_lengziang else: ans = generate_skill_jsonl(json_answer) generate_flag = True display_board.append(("为" + json_answer["name"] + "生成详细的功法描述\n", None)) if generate_flag: player = Player(json_answer, ans) unique_name = get_unique_from_json(json_answer["name"], json_answer) if len(player.skills) > 1 and unique_name != None: add_fighter(player_attribute, ans) display_board.append(("将新角色" + json_answer["name"] + "录入到数据库\n", None)) return ans, display_board, status def continue_fight(detailed_attr_player1, detailed_attr_player2, detailed_skill_player1, detailed_skill_player2, display_board): if detailed_attr_player1.strip() == "" or detailed_attr_player2.strip() == "" or detailed_skill_player1.strip() == "" or detailed_skill_player2.strip() == "": str1 = "" if detailed_attr_player1.strip() != "": str1 = get_attr_str_short(json.loads(detailed_attr_player1)) str2 = "" if detailed_attr_player2.strip() != "": str2 = get_attr_str_short(json.loads(detailed_attr_player2)) return detailed_attr_player1, detailed_attr_player2, display_board, str1, str2, "请重新检查人物的生成情况" json1 = json.loads(detailed_attr_player1) json2 = json.loads(detailed_attr_player2) name1 = json1["name"] name2 = json2["name"] status = f"""{name1} 大战 {name2}""" if "hp" in json1 and "hp" in json2: if json1["hp"] <= 0 and json1["hp"] < json2["hp"]: unique1 = get_unique_from_json(name1, json1) unique2 = get_unique_from_json(name2, json2) return detailed_attr_player1, detailed_attr_player2, display_board, "", "", "战斗结束！请清除战斗或者重新生成人物" if json2["hp"] <= 0 and json2["hp"] < json1["hp"]: unique1 = get_unique_from_json(name1, json1) unique2 = get_unique_from_json(name2, json2) return detailed_attr_player1, detailed_attr_player2, display_board, "", "", "战斗结束！请清除战斗或者重新生成人物" game_manager = GameManager(json1, json2, detailed_skill_player1, detailed_skill_player2) msgs, new_player1, new_player2 = game_manager.run() for msg in msgs: display_board.append(msg) if game_manager.flag == "player1_win": unique1 = get_unique_from_json(name1, json1) unique2 = get_unique_from_json(name2, json2) update_elo(unique1, unique2) elif game_manager.flag == "player2_win": unique1 = get_unique_from_json(name1, json1) unique2 = get_unique_from_json(name2, json2) update_elo(unique2, unique1) new_player1_str = json.dumps(new_player1, ensure_ascii=False) new_player2_str = json.dumps(new_player2, ensure_ascii=False) return new_player1_str, new_player2_str, display_board, get_attr_str_short(new_player1), get_attr_str_short( new_player2), status def callback_random_role(display_board): data = get_random_fighter() name = data["name"] json_str = data["attr_str"] skills_jsonl = data["skills"] json_answer = json.loads(json_str) display_board.append(("从数据库选择角色" + name, None)) return name, json_str, skills_jsonl, get_attr_str_short(json_answer), get_skill_str_short( json_answer), display_board def callback_role_from_name(display_board, name): data = searching_fighter_on_elo(name) json_str = data["attr_str"] skills_jsonl = data["skills"] json_answer = json.loads(json_str) display_board.append(("从数据库选择角色" + name, None)) return name, json_str, skills_jsonl, get_attr_str_short(json_answer), get_skill_str_short( json_answer), display_board def callback_clean_fight(display_board, detailed_attr_player1, detailed_attr_player2): display_board = [] json1 = json.loads(detailed_attr_player1) json2 = json.loads(detailed_attr_player2) if "hp" in json1: del json1["hp"] if "hp" in json2: del json2["hp"] new_detailed_attr_player1 = json.dumps(json1, ensure_ascii=False) new_detailed_attr_player2 = json.dumps(json2, ensure_ascii=False) return display_board, new_detailed_attr_player1, new_detailed_attr_player2 def callback_refresh_rank(): return get_rank_str() with gr.Blocks() as demo: gr.Markdown( """ # LuotuoFighter ## 骆驼大乱斗 Implemented by 李鲁鲁 项目链接 https://github.com/LC1332/Chat-Haruhi-Suzumiya 这个原型是为了百川Hackathon而初步建立 三种角色建立方式: 根据姓名召唤、随机召唤，或者输入姓名和描述后生成新的人物 姓名召唤会召唤同名人物中战力最强的那个 由于Gradio特性，建立角色要花个几十秒，先点击生成功法，再点击生成功法描述 """ ) with gr.Row(): with gr.Column(): current_status = gr.Textbox(label="当前状态", value="请输入角色1的姓名之后生成功法，或进行召唤") display_board = gr.Chatbot(height=800) submit_fight2 = gr.Button("继续战斗！") clean_fight = gr.Button("清空战斗") with gr.Column(): with gr.Row(): name_player1 = gr.Textbox(label="角色1姓名", scale=1, interactive=True, value="李鲁鲁") desc_player1 = gr.Textbox(label="角色1描述", scale=20, value="师从，主修剑法", interactive=True) with gr.Row(): generate_ma_player1 = gr.Button("生成功法") generate_madetail_player1 = gr.Button("生成功法描述") with gr.Row(): random_sel_player1 = gr.Button("随机召唤") call_player1_with_name1 = gr.Button("根据姓名召唤") with gr.Row(): name_player2 = gr.Textbox(label="角色2姓名", scale=1, interactive=True, value="冷子昂") desc_player2 = gr.Textbox(label="角色2描述", scale=20, value="师从，主修剑法", interactive=True) with gr.Row(): generate_ma_player2 = gr.Button("生成功法") generate_madetail_player2 = gr.Button("生成功法描述") with gr.Row(): random_sel_player2 = gr.Button("随机召唤2") call_player1_with_name2 = gr.Button("根据姓名召唤2") with gr.Row(): submit_fight = gr.Button("继续战斗！") with gr.Row(): attr_player1 = gr.TextArea(label="角色1属性") skill_player1 = gr.TextArea(label="角色1功法描述") with gr.Row(): attr_player2 = gr.TextArea(label="角色2属性") skill_player2 = gr.TextArea(label="角色2功法描述") with gr.Row(): refresh_rank = gr.Button("刷新天梯") with gr.Row(): rank_showboard = gr.TextArea(label="天梯") with gr.Row(): with gr.Column(): detailed_description_player1 = gr.TextArea(label="角色1具体描述") detailed_skill_player1 = gr.TextArea(label="角色1技能json") detailed_attr_player1 = gr.TextArea(label="角色1属性json") with gr.Column(): detailed_description_player2 = gr.TextArea(label="角色2具体描述") detailed_skill_player2 = gr.TextArea(label="角色2技能json") detailed_attr_player2 = gr.TextArea(label="角色2属性json") generate_ma_player1.click(fn=generate_ma, inputs=[name_player1, desc_player1, display_board], outputs=[detailed_description_player1, detailed_attr_player1, attr_player1, skill_player1, display_board, current_status]) generate_ma_player2.click(fn=generate_ma, inputs=[name_player2, desc_player2, display_board], outputs=[detailed_description_player2, detailed_attr_player2, attr_player2, skill_player2, display_board, current_status]) generate_madetail_player1.click(fn=generate_madetail, inputs=[detailed_attr_player1, display_board], outputs=[detailed_skill_player1, display_board, current_status]) generate_madetail_player2.click(fn=generate_madetail, inputs=[detailed_attr_player2, display_board], outputs=[detailed_skill_player2, display_board, current_status]) random_sel_player1.click(fn=callback_random_role, inputs=[display_board], outputs=[name_player1, detailed_attr_player1, detailed_skill_player1, attr_player1, skill_player1, display_board]) random_sel_player2.click(fn=callback_random_role, inputs=[display_board], outputs=[name_player2, detailed_attr_player2, detailed_skill_player2, attr_player2, skill_player2, display_board]) call_player1_with_name1.click(fn=callback_role_from_name, inputs=[display_board, name_player1], outputs=[name_player1, detailed_attr_player1, detailed_skill_player1, attr_player1, skill_player1, display_board]) call_player1_with_name2.click(fn=callback_role_from_name, inputs=[display_board, name_player2], outputs=[name_player2, detailed_attr_player2, detailed_skill_player2, attr_player2, skill_player2, display_board]) refresh_rank.click(fn=callback_refresh_rank, inputs=[], outputs=[rank_showboard]) clean_fight.click(fn=callback_clean_fight, inputs=[display_board, detailed_attr_player1, detailed_attr_player2], outputs=[display_board, detailed_attr_player1, detailed_attr_player2]) submit_fight.click(fn=continue_fight, inputs=[detailed_attr_player1, detailed_attr_player2, detailed_skill_player1, detailed_skill_player2, display_board], outputs=[detailed_attr_player1, detailed_attr_player2, display_board, attr_player1, attr_player2, current_status]) submit_fight2.click(fn=continue_fight, inputs=[detailed_attr_player1, detailed_attr_player2, detailed_skill_player1, detailed_skill_player2, display_board], outputs=[detailed_attr_player1, detailed_attr_player2, display_board, attr_player1, attr_player2, current_status]) demo.launch(debug=False, share=True)