Add application file

.gitignore

@@ -0,0 +1 @@
+__pycache__

Character.py

@@ -0,0 +1,242 @@
+import random
+import math
+from utils import get_random_name, get_random_clan_name
+from config import P_DIE_WHEN_LOSE, IMMORTAL_RANK
+
+cultivation_rank_map = ["炼气期", "筑基期", "结丹期", "元婴期", "化神期", "成仙者"]
+class Character:
+    def __init__(self, name, gender, special_constitution, spiritual_roots, clan=None, partner=None, parents=None):
+        self.name = name
+        self.gender = gender
+        self.real_age = 0
+        self.apparent_age = 0
+        self.cultivation_level = 0  # 等级
+        self.cultivation_rank = 0   # 层次
+        self.special_constitution = special_constitution
+        self.spiritual_roots = spiritual_roots
+        self.experience_points = 0
+        self.combat_power = self.calculate_combat_power()
+        self.partner = partner
+        self.is_alive = True
+        self.buff = False
+        self.history = []
+        self.special_history = []
+        self.consume_spiritual_energy = 0
+        self.parents = parents
+        self.children = []
+        self.clan = clan # 宗族
+
+    def die(self):
+        self.history.append(f"{self.real_age}岁，死亡")
+        self.special_history.append(f"{self.real_age}岁，死亡")
+        self.is_alive = False
+
+    def cultivate(self, experience_points):
+        if not self.is_alive:
+            print("角色已经死亡，无法进行修炼。")
+            return
+        # 成仙者不再修炼
+        if self.cultivation_rank >= IMMORTAL_RANK:
+            return
+        
+        self.experience_points += experience_points
+
+        # 根据经验值计算等级，等级越高，升级需要的经验值就越多
+        self.cultivation_level = math.floor(self.experience_points / ((1 + self.cultivation_rank) * 1000 + (1 + self.cultivation_level) * 100))
+
+        # 判断是否达到突破修为层次的条件
+        if self.cultivation_level >= 10:
+            # 使用一个随机数来表示突破的概率，当前rank越高，则突破成功的概率越低
+            success_probability = 0.9 / (self.cultivation_rank * 2 + 1)
+            if random.random() < success_probability:
+                cultivation_level = self.cultivation_level
+                self.cultivation_rank += 1
+                self.cultivation_level = 0
+                self.experience_points = 0
+                self.history.append(f"{self.real_age}岁，突破成功，在{cultivation_level}级, 到达{self.view_rank()}")
+                self.special_history.append(f"{self.real_age}岁，突破成功，在{cultivation_level}级, 到达{self.view_rank()}")
+            else:
+                self.history.append(f"{self.real_age}岁，突破失败，在{self.cultivation_level}级")
+
+    def marry(self, partner):
+        # 成仙者不再结婚
+        if self.cultivation_rank >= IMMORTAL_RANK:
+            return
+        if not self.is_alive:
+            print("角色已经死亡，无法结婚。")
+            return
+        self.partner = partner
+        partner.partner = self
+
+        # 结婚合并宗族
+        if self.clan and partner.clan:
+            if random.random() < 0.5:
+              partner.clan = self.clan
+            else:
+              self.clan = partner.clan
+        else:
+              self.clan = self.clan or partner.clan or get_random_clan_name()
+              partner.clan = self.clan
+
+        self.history.append(f"{self.real_age}岁，结婚了")
+        self.partner.history.append(f"{self.partner.real_age}岁，结婚了")
+        self.special_history.append(f"{self.real_age}岁，结婚了")
+        self.partner.special_history.append(f"{self.partner.real_age}岁，结婚了")
+
+    def give_birth(self):
+        # 成仙者不会生育
+        if self.cultivation_rank >= IMMORTAL_RANK:
+            return
+        if not self.is_alive:
+            print("角色已经死亡，无法生育。")
+            return
+        if not self.partner:
+            print("角色没有结婚，无法生育。")
+            return
+
+        # 合欢体质加buff
+        if self.special_constitution[1] == 1:
+            self.buff = True
+
+
+        # 小孩有一定几率遗传父亲或母亲的特殊体质和灵根
+        special_constitution = [a if random.random() < 0.5 else b for (a, b) in zip(self.special_constitution, self.partner.special_constitution)]
+        spiritual_roots = [a if random.random() < 0.5 else b for (a, b) in zip(self.spiritual_roots, self.partner.spiritual_roots)]
+
+        # spiritual_roots 一定几率突变
+        spiritual_roots = [random.choice([0, 1]) if random.random() < 0.01 else v for v in spiritual_roots]
+
+        child = Character(get_random_name(), random.choice(["男", "女"]), special_constitution, spiritual_roots, clan=self.clan, parents=[self, self.partner])
+        self.history.append(f"{self.real_age}岁，生下小孩{child.name}")
+        self.partner.history.append(f"{self.partner.real_age}岁，生下小孩{child.name}")
+        self.children.append(child)
+        self.partner.children.append(child)
+        return child
+
+    def grow(self):
+        # 成仙者不会衰老
+        if self.cultivation_rank >= IMMORTAL_RANK:
+            return
+        self.real_age += 1
+
+        # 根据修为层次 和 是否拥有木灵根 计算表观年龄
+        # 修为层次越高，外表看起来越年轻
+        ratio = 1 + self.cultivation_rank
+
+        # 灵龟和蜉蝣体质
+        if self.special_constitution[2] == 1:  # 灵龟体质
+            ratio *= 2
+        elif self.special_constitution[3] == 1:  # 蜉蝣体质
+            ratio *= 0.5
+
+        # 根据修为层次计算加成比例，初始加成为10%
+        bonus = 0.1 * (self.cultivation_rank * 0 + 1)
+        if self.spiritual_roots[1] == 1: # 拥有木灵根（灵根的第二位），最大寿命有加成
+            ratio *= 1 + bonus
+
+        self.apparent_age = math.floor(self.real_age / ratio)
+
+    def calculate_combat_power(self):
+        # 根据修为层次和修为等级计算战斗力参数：等级越高，各数值都越高；层次对等级是碾压效果
+        attack_power = (self.cultivation_rank + 1) * 30 + 1 * (1 + self.cultivation_level)
+        defense_power = (self.cultivation_rank + 1) * 30 + 1 * (1 + self.cultivation_level)
+        attack_speed = (self.cultivation_rank + 1) * 30 + 1 * (1 + self.cultivation_level)
+        health_points =  (self.cultivation_rank + 1) * 60 + 2 * (1 + self.cultivation_level)
+
+        # 根据修为层次计算加成比例，初始加成为10%
+        bonus = 0.1 * (self.cultivation_rank * 0 + 1)
+
+        # 根据灵根调整战斗力参数，灵根分别为：[金木水火土], 分别对以下属性有加成：攻击速度, 最大寿命, 生命值, 攻击力, 防御力
+        if self.spiritual_roots[0] == 1: # 金
+            attack_speed *= 1 + bonus
+
+        if self.spiritual_roots[2] == 1: # 水
+            health_points *= 1 + bonus
+
+        if self.spiritual_roots[3] == 1: # 火
+            attack_power *= 1 + bonus
+
+        if self.spiritual_roots[4] == 1: # 土
+            defense_power *= 1 + bonus
+
+        return {
+            'attack_power': attack_power,
+            'defense_power': defense_power,
+            'attack_speed': attack_speed,
+            'health_points': health_points
+        }
+
+    def before_battle(self):
+        self.combat_power = self.calculate_combat_power()
+
+    def attack(self, opponent):
+        # 成仙者不会打架
+        if self.cultivation_rank >= IMMORTAL_RANK:
+            return
+        if not self.is_alive:
+            print("角色已经死亡，无法攻击。")
+            return
+
+        # 战斗体质加buff
+        if self.special_constitution[0] == 1:
+            self.buff = True
+
+        # TODO: 考虑攻击速度
+        damage = self.combat_power['attack_power'] - opponent.combat_power['defense_power']
+        if damage > 0:
+            opponent.combat_power['health_points'] -= damage
+
+    def check_is_alive(self):
+        if self.combat_power['health_points'] <= 0:
+          # 一定概率会死亡
+          if random.random() < P_DIE_WHEN_LOSE:
+            self.die()
+          return False
+        return True
+
+    def __str__(self):
+        # Display current attributes
+        history = "\n".join(self.history)
+        attributes = [
+            f"Name: {self.name}",
+            f"Gender: {self.gender}",
+            f"Real Age: {self.real_age}",
+            f"Apparent Age: {self.apparent_age}",
+            f"Cultivation Level: {self.cultivation_level}",
+            f"Cultivation Rank: ({self.cultivation_rank}){self.view_rank()}",
+            f"Special Constitution: {self.special_constitution}",
+            f"Spiritual Roots: {self.spiritual_roots}",
+            f"Experience Points: {self.experience_points}",
+            f"Combat Power: {self.combat_power}",
+            f"Partner: {self.partner.name if self.partner is not None else ''}",
+            f"Is Alive: {self.is_alive}",
+            f"Buff: {self.buff}",
+            f"Children: {[child.name for child in self.children]}",
+            f"History: {history}",
+        ]
+        return "\n".join(attributes)
+
+    def view_rank(self):
+        if self.cultivation_rank <= len(cultivation_rank_map):
+            return f"{cultivation_rank_map[self.cultivation_rank]}({self.cultivation_level})"
+        else:
+            return "天外飞仙"
+
+    def to_list(self):
+        numerical_attributes = [
+            self.real_age,
+            self.apparent_age,
+            self.cultivation_level,
+            self.cultivation_rank,
+            self.experience_points,
+            self.combat_power["attack_power"],
+            self.combat_power["defense_power"],
+            self.combat_power["attack_speed"],
+            self.combat_power["health_points"],
+            *self.special_constitution,  # [1, 0, 0, 0], 数组解构拼接
+            *self.spiritual_roots,   # [1, 0, 0, 0, 0], 数组解构拼接
+            1 if self.is_alive else 0,  # bool转int
+            1 if self.buff else 0,  # bool转int
+            len(self.children),
+        ]
+        return numerical_attributes

CharacterStatistics.py

@@ -0,0 +1,245 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+class CharacterStatistics:
+    def __init__(self, characters):
+        self.characters = characters
+        self.characters_array = np.array([c.to_list() for c in characters])
+
+    # 前n名排行榜
+    def find_highest_cultivation(self, n=1):
+        sorted_characters = sorted(self.characters, key=lambda c: (c.cultivation_rank, c.cultivation_level), reverse=True)
+        return sorted_characters[:n]
+
+    # 宗族人数排行榜
+    def rank_top_clans(self, top_n=4):
+      clan_size = {}
+      for c in self.characters:
+        clan_size[c.clan] = clan_size.get(c.clan, 0) + 1
+
+      sorted_clans = sorted(clan_size.items(), key=lambda x: x[1], reverse=True)[:top_n]
+
+      return sorted_clans
+
+    # real_age、apparent_age、cultivation_level、cultivation_rank 分布图
+    def plot_attribute_distribution(self):
+        attributes = ['Real Age', 'Apparent Age', 'Cultivation Level', 'Cultivation Rank']
+        attribute_indices = [0, 1, 2, 3]
+        fig, axs = plt.subplots(2, 2, figsize=(10, 8))
+        axs = axs.flatten()
+        for i, ax in enumerate(axs):
+            ax.hist(self.characters_array[:, attribute_indices[i]], bins=20, edgecolor='black')
+            ax.set_xlabel(attributes[i])
+            ax.set_ylabel('Frequency')
+        plt.tight_layout()
+        plt.show()
+
+    # real_age、apparent_age、cultivation_level、cultivation_rank、孩子数量 统计平均数
+    def calculate_average_attributes(self):
+        real_age_mean = np.mean(self.characters_array[:, 0])
+        apparent_age_mean = np.mean(self.characters_array[:, 1])
+        cultivation_level_mean = np.mean(self.characters_array[:, 2])
+        cultivation_rank_mean = np.mean(self.characters_array[:, 3])
+        child_count_mean = np.mean(self.characters_array[:, 19])
+        return real_age_mean, apparent_age_mean, cultivation_level_mean, cultivation_rank_mean, child_count_mean
+
+    # 画出 cultivation_rank （x轴） 和 4项combat_power的关系（y轴）
+    def plot_combat_power_vs_cultivation_rank(self):
+
+      fig, axs = plt.subplots(2, 2, figsize=(10, 8))
+      axs = axs.flatten()
+
+      for i, combat_power in enumerate(['Attack Power', 'Defense Power', 'Attack Speed', 'Health Points']):
+
+        combat_power_data = []
+        for rank in range(6):
+          rank_data = self.characters_array[self.characters_array[:,3]==rank, i+5]
+          combat_power_data.append(rank_data)
+
+        axs[i].boxplot(combat_power_data)
+        axs[i].set_title(combat_power)
+        axs[i].set_xlabel('Cultivation Rank')
+        axs[i].set_ylabel('Value')
+
+      plt.tight_layout()
+      plt.show()
+
+    def calculate_average_special_constitution(self):
+        special_constitution_mean = np.mean(self.characters_array[:, 9:13], axis=0)
+        return special_constitution_mean
+
+    def calculate_average_spiritual_roots(self):
+        spiritual_roots_mean = np.mean(self.characters_array[:, 13:18], axis=0)
+        return spiritual_roots_mean
+
+    # 统计无灵根者的数量
+    def count_zero_spiritual_roots(self):
+        zero_spiritual_roots_count = np.sum(np.all(self.characters_array[:, 13:18] == 0, axis=1))
+        return zero_spiritual_roots_count
+
+    # 灵根数量分布图
+    def plot_sum_spiritual_root_distribution(self):
+      spiritual_roots_sum = np.sum(self.characters_array[:, 13:18], axis=1)
+
+      plt.hist(spiritual_roots_sum, bins=5, range=(0,5))
+      plt.xlabel('Number of Spiritual Roots')
+      plt.ylabel('Number of Characters')
+      plt.title('Distribution of Spiritual Roots')
+
+      plt.show()
+
+    # 各灵根人口分布（x轴：5种灵根，y轴：人数）
+    def plot_spiritual_roots_distribution(self):
+
+      spiritual_roots = self.characters_array[:, 13:18]
+
+      means = np.mean(spiritual_roots, axis=0)
+      roots = ['Metal', 'Wood', 'Water', 'Fire', 'Earth']
+
+      plt.bar(roots, means)
+      plt.xlabel('Spiritual Roots')
+      plt.ylabel('Percentage of Characters')
+      plt.title('Distribution of Spiritual Roots in Population')
+
+      plt.show()
+
+    # 宗族人数分布图
+    def plot_clan_size_distribution(self):
+      clan_size = {}
+      for c in self.characters:
+        clan_size[c.clan] = clan_size.get(c.clan, 0) + 1
+
+      sizes = list(clan_size.values())
+      plt.hist(sizes, bins=20)
+      plt.xlabel('Clan Size')
+      plt.ylabel('Number of Clans')
+      plt.show()
+
+    def summarize(self):
+      print("===== Character Statistics Summary =====")
+
+      # 打印平均属性
+      print("Average Attributes:")
+      real_age, apparent_age, cultivation_level, cultivation_rank, child_count = self.calculate_average_attributes()
+      print(f"Real Age: {real_age:.2f}")
+      print(f"Apparent Age: {apparent_age:.2f}")
+      print(f"Cultivation Level: {cultivation_level:.2f}")
+      print(f"Cultivation Rank: {cultivation_rank:.2f}")
+      print(f"Child Count: {child_count:.2f}")
+
+      # 打印平均特质
+      print("\nAverage Special Constitutions:")
+      special_names = ['战斗', '合欢', '灵龟', '蜉蝣']
+      for i, v in enumerate(self.calculate_average_special_constitution()):
+        print(f"{special_names[i]}: {v:.2%}")
+
+      # 打印平均灵根
+      print("\nAverage Spiritual Roots:")
+      root_names = ['金', '木', '水', '火', '土']
+      for i, v in enumerate(self.calculate_average_spiritual_roots()):
+        print(f"{root_names[i]}: {v:.2%}")
+
+      # 打印统计图
+      print("\nPlotting graphs...")
+      self.plot_attribute_distribution()
+      # self.plot_combat_power_vs_cultivation_rank()
+      self.plot_spiritual_roots_distribution()
+      self.plot_sum_spiritual_root_distribution()
+      self.plot_clan_size_distribution()
+      self.print_top_cultivators()
+      # 攻击力排行榜
+      self.print_rank('attack_power', name='Attack Power')
+      # 防御力排行榜
+      self.print_rank('defense_power', name='Defense Power')
+      self.print_top_clans()
+
+      print("\n===== End Summary =====\n")
+
+    # 返回Markdown字符串的总结输出
+    def summarize_markdown(self):
+      md = "## Character Statistics Summary\n\n"
+      md += "### Average Attributes:\n\n"
+      real_age, apparent_age, cultivation_level, cultivation_rank, child_count = self.calculate_average_attributes()
+      md += f"Real Age: {real_age:.2f}\n\n"
+      md += f"Apparent Age: {apparent_age:.2f}\n\n"
+      md += f"Cultivation Level: {cultivation_level:.2f}\n\n"
+      md += f"Cultivation Rank: {cultivation_rank:.2f}\n\n"
+      md += f"Child Count: {child_count:.2f}\n\n"
+
+      md += "### Average Special Constitutions:\n\n"
+      special_names = ['战斗', '合欢', '灵龟', '蜉蝣']
+      for i, v in enumerate(self.calculate_average_special_constitution()):
+        md += f"{special_names[i]}: {v:.2%}\n\n"
+
+      md += "### Average Spiritual Roots:\n\n"
+      root_names = ['金', '木', '水', '火', '土']
+      for i, v in enumerate(self.calculate_average_spiritual_roots()):
+        md += f"{root_names[i]}: {v:.2%}\n\n"
+      
+      # md += "### Plotting graphs...\n\n"
+      # md += "#### Attribute Distribution\n\n"
+      # md += "![Attribute Distribution](./attribute_distribution.png)\n\n"
+      # md += "#### Spiritual Roots Distribution\n\n"
+      # md += "![Spiritual Roots Distribution](./spiritual_roots_distribution.png)\n\n"
+      # md += "#### Sum Spiritual Roots Distribution\n\n"
+      # md += "![Sum Spiritual Roots Distribution](./sum_spiritual_roots_distribution.png)\n\n"
+      # md += "#### Clan Size Distribution\n\n"
+      # md += "![Clan Size Distribution](./clan_size_distribution.png)\n\n"
+      md += "#### Top Cultivators\n\n"
+      md += self.print_top_cultivators_markdown()
+      md += "#### Attack Power Ranking\n\n"
+      md += self.print_rank_markdown('attack_power', name='Attack Power')
+      md += "#### Defense Power Ranking\n\n"
+      md += self.print_rank_markdown('defense_power', name='Defense Power')
+      md += "#### Top Clans\n\n"
+      md += self.print_top_clans_markdown()
+
+      return md
+    
+    def print_top_cultivators(self, top_n=10):
+
+      print("\n== Top Cultivators ==")
+      print("{:<10} {:>10} {:>10} {:>10} {:>10}".format('Name', 'Clan', 'Rank', 'Level', '境界'))
+      for c in self.find_highest_cultivation(top_n):
+        print("{:<10} {:>10} {:>10} {:>10} {:>10}".format(c.name, c.clan, c.cultivation_rank, c.cultivation_level, c.view_rank()))
+
+    def print_top_cultivators_markdown(self, n=10):
+      md = f"| Name | Clan | Cultivation Rank | Cultivation Level | 境界\n"
+      md += "| ---- | ---- | ---------------- | ---------------- | ----\n"
+      for c in self.find_highest_cultivation(n):
+        md += f"| {c.name} | {c.clan} | {c.cultivation_rank:.2f} | {c.cultivation_level:.2f} | {c.view_rank()}\n"
+      return md
+    
+    def print_rank(self, rank_key, top_n=10, name=None):
+
+      print(f"\n== {'Name' if name is None else name} Rank ==")
+
+      sorted_characters = sorted(self.characters, key=lambda c: c.combat_power[rank_key], reverse=True)
+
+      print("{:<10} {:>10} {:>10} {:>10} {:>10}".format('Name', rank_key if name is None else name, 'Rank', 'Level', '境界'))
+
+      for c in sorted_characters[:top_n]:
+        print("{:<10} {:>10}{:>10} {:>10} {:>10}".format(c.name, c.combat_power[rank_key], c.cultivation_rank, c.cultivation_level, c.view_rank()))
+
+    def print_rank_markdown(self, attr, name=None, n=10):
+      md = f"| Name | {attr if name is None else name} | Cultivation Rank | Cultivation Level | 境界\n"
+      md += "| ---- | ---- | ---------------- | ---------------- | ----\n"
+      sorted_characters = sorted(self.characters, key=lambda c: c.combat_power[attr], reverse=True)
+      for c in sorted_characters[:n]:
+        md += f"| {c.name} | {c.combat_power[attr]:.2f} | {c.cultivation_rank:.2f} | {c.cultivation_level:.2f} | {c.view_rank()}\n"
+      return md
+    
+    def print_top_clans(self, top_n=4):
+
+      print("\n== Top Clans ==")
+      print("{:<10} {:>10}".format('Clan', 'Members'))
+
+      for clan, size in self.rank_top_clans(top_n):
+        print("{:<10} {:>10}".format(clan, size))
+
+    def print_top_clans_markdown(self, n=10):
+      md = "|   Clan   | Clan Size |\n"
+      md += "| -------- | --------- |\n"
+      for clan, size in self.rank_top_clans(n):
+        md += f"| {clan} | {size} |\n"
+      return md

PluginManager.py

@@ -0,0 +1,13 @@
+class PluginManager:
+    def __init__(self):
+        self.plugins = []
+
+    def add_plugin(self, plugin):
+        self.plugins.append(plugin)
+
+    def remove_plugin(self, plugin):
+        self.plugins.remove(plugin)
+
+    def execute_plugins(self, *args, **kwargs):
+        for plugin in self.plugins:
+            plugin.execute(*args, **kwargs)

WorldSimulation.py

@@ -0,0 +1,100 @@
+from config import DISASTER_FREQUENCY, MARRIAGE_RATE, DISASTER_PROB, NORMAL_BIRTH_RATE, LOW_BIRTH_RATE, NORMAL_BATTLE_RATE, HIGH_BATTLE_RATE
+from Character import Character
+from plugins.CharacterCreationPlugin import CharacterCreationPlugin
+from plugins.CultivationPlugin import CultivationPlugin
+from plugins.MarriagePlugin import MarriagePlugin
+from plugins.BirthPlugin import BirthPlugin
+from plugins.CharacterGrowthPlugin import CharacterGrowthPlugin
+from plugins.DisasterPlugin import DisasterPlugin
+from plugins.BattlePlugin import BattlePlugin
+from plugins.ResourceDepletionPlugin import ResourceDepletionPlugin
+
+class WorldSimulation:
+    def __init__(self, special_constitution_ratio, spiritual_roots_ratio, initial_population, world_spiritual_energy, resources = 100000, resources_threshold = 10):
+        # 初始化插件
+        self.character_creation_plugin = CharacterCreationPlugin(special_constitution_ratio, spiritual_roots_ratio)
+        self.cultivation_plugin = CultivationPlugin()
+        self.marriage_plugin = MarriagePlugin(MARRIAGE_RATE)
+        self.birth_plugin = BirthPlugin(NORMAL_BIRTH_RATE)
+        self.character_growth_plugin = CharacterGrowthPlugin(100)
+        self.disaster_plugin = DisasterPlugin(DISASTER_FREQUENCY, DISASTER_PROB)
+        self.battle_plugin = BattlePlugin(NORMAL_BATTLE_RATE)
+        self.resource_depletion_plugin = ResourceDepletionPlugin(resources_threshold)
+
+        # 初始化参数
+        self.initial_population = initial_population
+        self.resources = resources # 总资源量
+        self.resources_threshold = resources_threshold  # 人均最少资源需求
+        self.init_world_spiritual_energy = world_spiritual_energy
+        self.world_spiritual_energy = world_spiritual_energy
+        self.characters = []
+        self.dead_characters = []
+        self.nth_round = 0
+        self.world_log = []
+
+    def log(self, msg):
+        self.world_log.append(msg)
+
+    def simulate_round(self):
+        self.character_growth_plugin.execute(self.characters, self.character_die)
+        self.disaster_plugin.execute(self.characters, self.nth_round, self.character_die)
+
+        # 每人可用资源
+        per_capita_resources = self.resources / len(self.characters)
+        if per_capita_resources < self.resources_threshold:
+            self.birth_plugin.set_birth_rate(LOW_BIRTH_RATE)
+            self.battle_plugin.set_battle_rate(HIGH_BATTLE_RATE)
+        else:
+            self.birth_plugin.set_birth_rate(NORMAL_BIRTH_RATE)
+            self.battle_plugin.set_battle_rate(NORMAL_BATTLE_RATE)
+
+        self.resource_depletion_plugin.execute(per_capita_resources, self.characters, self.character_die)
+
+        self.battle_plugin.execute(self.characters, self.character_die)
+        self.birth_plugin.execute(self.characters)
+        self.marriage_plugin.execute(self.characters)
+        self.cultivation_plugin.execute(self.characters, self.world_spiritual_energy, self.init_world_spiritual_energy, self.consume_spiritual_energy)
+
+    def start_simulation(self):
+        self.nth_round = 0
+        self.create_initial_population()
+
+    def run_simulation(self, num_rounds):
+        md = ""
+        for _ in range(num_rounds):
+            self.nth_round += 1
+            print(f"第{self.nth_round}轮模拟：")
+            md += f"第{self.nth_round}轮模拟：\n"
+            self.simulate_round()
+            print(f"当前世界灵气总量：{self.world_spiritual_energy}")
+            print(f"当前存活角色数量：{len(self.characters)}")
+            print("")
+            md += f"当前世界灵气总量：{self.world_spiritual_energy}\n"
+            md += f"当前存活角色数量：{len(self.characters)}\n\n"
+            if len(self.characters) == 0:
+                print("所有角色死亡，模拟结束")
+                md += "所有角色死亡，模拟结束\n"
+                break
+        return md
+
+    def add_custom_character(self, name, gender, special_constitution, spiritual_roots):
+        character = Character(name, gender, special_constitution, spiritual_roots)
+        self.characters.append(character)
+
+    def create_initial_population(self):
+        # 创建角色
+        for _ in range((self.initial_population - len(self.characters))):
+            character = self.character_creation_plugin.create_character()
+            self.characters.append(character)
+
+    def character_die(self, character):
+        character.die()
+        self.world_spiritual_energy += character.consume_spiritual_energy  # 灵气回归
+        if character.partner:
+            character.partner.history.append(f"{character.partner.real_age}岁，配偶{character.name}({character.real_age}岁)死亡")
+            character.partner.partner = None  # 解除配偶关系
+        self.characters.remove(character)
+        self.dead_characters.append(character)
+
+    def consume_spiritual_energy(self, amount):
+        self.world_spiritual_energy -= amount

app.py

@@ -0,0 +1,125 @@
+import gradio as gr
+from CharacterStatistics import CharacterStatistics
+from WorldSimulation import WorldSimulation
+
+# 创建一个世界模拟对象
+simulation = None
+num_rounds = 0
+
+def initialize_world(c1, c2, c3, c4, r1, r2, r3, r4, r5, initial_population=3000, world_spiritual_energy=1000000):
+    global simulation
+    special_constitution_ratio = [c1, c2, c3, c4]
+    spiritual_roots_ratio = [r1, r2, r3, r4, r5]
+    initial_population = int(initial_population)
+    simulation = WorldSimulation(special_constitution_ratio, spiritual_roots_ratio, initial_population, world_spiritual_energy)
+
+    return f"世界初始化成功：\n\n初始人口：{initial_population}\n\n世界灵气能量：{world_spiritual_energy}"
+
+
+def add_custom_character(name, gender, special_constitution, spiritual_roots):
+    special_constitution = [1 if i in special_constitution else 0 for i in range(4)]
+    spiritual_roots = [1 if i in spiritual_roots else 0 for i in range(5)]
+    simulation.add_custom_character(name, gender, special_constitution, spiritual_roots)
+    return str(simulation.characters[-1])
+
+def start_simulation():
+    simulation.start_simulation()
+    return f"世界人口数量达到{len(simulation.characters)}，可以运行模拟了。"
+
+def run_simulation(rounds):
+    global num_rounds
+    num_rounds = rounds
+    if simulation is None:
+        return "请先初始化世界"
+    return simulation.run_simulation(num_rounds)
+
+def get_character_info(character_index):
+    if character_index < len(simulation.characters):
+        return str(simulation.characters[character_index])
+    else:
+        return f"没有第{character_index}个角色，目前共有{len(simulation.characters)}个存活角色"
+
+def get_dead_character_info(character_index):
+    if character_index < len(simulation.dead_characters):
+        return str(simulation.dead_characters[character_index])
+    else:
+        return f"没有第{character_index}个死亡角色，目前共有{len(simulation.dead_characters)}个死亡角色"
+
+def get_world_stats():
+    stats = CharacterStatistics(simulation.characters)
+    return stats.summarize_markdown()
+
+with gr.Blocks() as demo:
+    # 初始化世界
+    gr.Markdown("## 初始化世界")
+    with gr.Row():
+        initial_population_input = gr.Number(label="初始人口", value=3000, precision=0)
+        world_spiritual_energy_input = gr.Number(label="世界灵气能量", value=1000000)
+    # 特殊体质
+    gr.Markdown("特殊体质比例")
+    with gr.Row():
+        special_constitution_ratio_input = [
+            gr.Number(label="战斗体质", minimum=0, maximum=1, value=0.001),
+            gr.Number(label="合欢体质", minimum=0, maximum=1, value=0.001),
+            gr.Number(label="灵龟体质", minimum=0, maximum=1, value=0.001), 
+            gr.Number(label="蜉蝣体质", minimum=0, maximum=1, value=0.001)]
+    # 灵根
+    gr.Markdown("灵根比例")
+    with gr.Row():
+        spiritual_roots_ratio_input = [
+            gr.Number(label="金", minimum=0, maximum=1, value=0.04), 
+            gr.Number(label="木", minimum=0, maximum=1, value=0.04), 
+            gr.Number(label="水", minimum=0, maximum=1, value=0.04), 
+            gr.Number(label="火", minimum=0, maximum=1, value=0.04), 
+            gr.Number(label="土", minimum=0, maximum=1, value=0.04)]
+    initialize_button = gr.Button("初始化世界")
+    output_text = gr.Markdown(label="初始化结果")
+    initialize_button.click(fn=initialize_world, inputs=[*special_constitution_ratio_input, *spiritual_roots_ratio_input, initial_population_input, world_spiritual_energy_input], outputs=output_text)
+
+    # 添加角色
+    with gr.Accordion("添加角色"):
+        gr.Markdown("每次添加一个，添加完可以继续添加。")
+        name_input = gr.Textbox(label="姓名")
+        gender_input = gr.Radio(["男", "女"], label="性别")
+        special_constitution_input = gr.CheckboxGroup(["战斗体质", "合欢体质", "灵龟体质", "蜉蝣体质"], label="特殊体质", type="index")
+        spiritual_roots_input = gr.CheckboxGroup(["金", "木", "水", "火", "土"], label="灵根", type="index")
+        add_character_button = gr.Button("添加角色")
+        new_character_info_output = gr.Textbox(label="新角色信息")
+        add_character_button.click(fn=add_custom_character, inputs=[name_input,
+                gender_input,
+                special_constitution_input, spiritual_roots_input], outputs=new_character_info_output)
+    
+    # 开始模拟
+    start_simulation_button = gr.Button("生成初始人口")
+    output_text = gr.Markdown("")
+    start_simulation_button.click(fn=start_simulation, inputs=[], outputs=output_text)
+
+    # 运行模拟
+    gr.Markdown("## 运行模拟\n\n输入轮数，运行模拟，可以多次运行。")
+    with gr.Row():
+        rounds_input = gr.Number(label="轮数", precision=0, value=1)
+        run_simulation_button = gr.Button("运行模拟")
+    simulation_result_output = gr.Textbox(label="模拟结果")
+    run_simulation_button.click(fn=run_simulation, inputs=[rounds_input], outputs=[simulation_result_output])
+
+    # 查看统计信息
+    gr.Markdown("## 查看统计信息")
+    get_stats_button = gr.Button("查看统计信息")
+    with gr.Box():
+        world_stats_output = gr.Markdown("")
+    get_stats_button.click(fn=get_world_stats, inputs=[], outputs=[world_stats_output])
+
+    # 查看角色信息
+    with gr.Row():
+        character_info_output = gr.Number(label="角色信息", info="输入角色编号", precision=0)
+        get_character_info_button = gr.Button("查看角色信息")
+    character_info_output_display = gr.Textbox(label="角色信息")
+    get_character_info_button.click(fn=get_character_info, inputs=[character_info_output], outputs=[character_info_output_display])
+
+    with gr.Row():
+        dead_character_info_output = gr.Number(label="死亡角色信息", info="输入死亡角色编号", precision=0)
+        get_dead_character_info_button = gr.Button("查看死亡角色信息")
+    dead_character_info_output_display = gr.Textbox(label="死亡角色信息")
+    get_dead_character_info_button.click(fn=get_dead_character_info, inputs=[dead_character_info_output], outputs=[dead_character_info_output_display])
+    
+demo.launch(debug=True)

config.py

@@ -0,0 +1,22 @@
+P_DIE_WHEN_LOSE = 0.6  # 战败死亡的概率
+MAX_BATTLE_ROUND = 100  # 战斗最大回合数
+MARRIAGE_RATE = 0.3       # 每名适龄青年每次模拟找对象的概率
+
+# 当每人资源大于阈值时,生育率正常,战斗率正常
+NORMAL_BIRTH_RATE = 0.2
+NORMAL_BATTLE_RATE = 0.3
+
+# 当每人资源低于阈值时,生育率线性下降,战斗率线性上升
+LOW_BIRTH_RATE = 0.05
+HIGH_BATTLE_RATE = 0.8
+
+# 每10轮有5%概率发生灾难
+DISASTER_PROB = 0.05
+DISASTER_FREQUENCY = 10
+
+# 每50轮有10%概率发生战争
+WAR_PROB = 0.1
+WAR_FREQUENCY = 50
+
+# 成仙等级
+IMMORTAL_RANK = 5

plugins/BattlePlugin.py

@@ -0,0 +1,60 @@
+import random
+
+class BattlePlugin:
+    def __init__(self, probability, min_battle_age=10, max_battle_round=100):
+        self.probability = probability
+        self.min_battle_age = min_battle_age # 最小参战年龄
+        self.max_battle_round = max_battle_round # 最大战斗回合数
+
+    def simulate_battle(self, character, opponent):
+        battle_round = 0
+
+        character.before_battle()
+        opponent.before_battle()
+        while character.check_is_alive() and opponent.check_is_alive() and battle_round < self.max_battle_round:
+            battle_round += 1
+
+            # 根据攻击速度确定行动顺序
+            if character.combat_power["attack_speed"] >= opponent.combat_power["attack_speed"]:
+                character.attack(opponent)
+                if opponent.check_is_alive():
+                    opponent.attack(character)
+            else:
+                opponent.attack(character)
+                if character.check_is_alive():
+                    character.attack(opponent)
+
+        # 胜利或平手判断
+        if character.check_is_alive() and opponent.check_is_alive():
+            # print(f"{character.name}和{opponent.name}打成平手！")
+            return None
+        elif character.check_is_alive():
+            print(f"{character.name}战胜了{opponent.name}！")
+            return (character, opponent)
+        elif opponent.check_is_alive():
+            print(f"{opponent.name}战胜了{character.name}！")
+            return (opponent, character)
+
+    def perform_battles(self, characters, character_die):
+        eligible_characters = [character for character in characters if character.apparent_age > self.min_battle_age]
+        for _ in range(int(len(eligible_characters) * self.probability)):
+            character = random.choice(eligible_characters)
+            opponent = random.choice(eligible_characters)
+            if character != opponent and character.clan != opponent.clan:
+                result = self.simulate_battle(character, opponent)
+                if result is not None:
+                    (winner, loser) = result
+                    winner.cultivate(100)
+                    winner.history.append(f"{winner.real_age}岁（{winner.view_rank()}），战胜了{loser.name}（{loser.view_rank()}）")
+                    loser.history.append(f"{loser.real_age}岁（{loser.view_rank()}），被{winner.name}（{winner.view_rank()}）打败了")
+                    if not loser.is_alive:
+                      print(f"{loser.name}因失血过多死亡了！")
+                      character_die(loser)
+                      return
+
+    def set_battle_rate(self, probability):
+        self.probability = probability
+
+    # 统一插件接口
+    def execute(self, *args, **kwargs):
+        self.perform_battles(*args, **kwargs)

plugins/BirthPlugin.py

@@ -0,0 +1,26 @@
+import random
+
+class BirthPlugin:
+    def __init__(self, birth_rate, min_birth_age=20, birth_age_range=15):
+        self.birth_rate = birth_rate
+        self.birth_age = min_birth_age
+        self.birth_age_range = birth_age_range
+
+    def perform_births(self, characters):
+        new_birth_count = 0
+        for character in characters:
+            if character.partner and character.apparent_age > self.birth_age and character.apparent_age < self.birth_age + self.birth_age_range and character.partner.apparent_age > self.birth_age and character.partner.apparent_age < self.birth_age + self.birth_age_range:
+                if random.random() < self.birth_rate / 2:
+                    child = character.give_birth()
+                    if child:
+                        characters.append(child)
+                        new_birth_count += 1
+
+        print(f"共{new_birth_count}对夫妻生了孩子！")
+
+    def set_birth_rate(self, birth_rate):
+        self.birth_rate = birth_rate
+
+    # 统一插件接口
+    def execute(self, *args, **kwargs):
+        self.perform_births(*args, **kwargs)

plugins/CharacterCreationPlugin.py

@@ -0,0 +1,18 @@
+import random
+from Character import Character
+from utils import get_random_name
+
+class CharacterCreationPlugin:
+    def __init__(self, special_constitution_ratio, spiritual_roots_ratio):
+        self.special_constitution_ratio = special_constitution_ratio
+        self.spiritual_roots_ratio = spiritual_roots_ratio
+
+    def create_character(self):
+        # 根据 special_constitution_ratio 随机确定这个角色拥有哪些特殊体质
+        special_constitution = [1 if random.random() < ratio else 0 for ratio in self.special_constitution_ratio]
+
+        # 根据 spiritual_roots_ratio 随机确定这个角色拥有哪些灵根
+        spiritual_roots = [1 if random.random() < ratio else 0 for ratio in self.spiritual_roots_ratio]
+
+        character = Character(get_random_name(), random.choice(["男", "女"]), special_constitution, spiritual_roots)
+        return character

plugins/CharacterGrowthPlugin.py

@@ -0,0 +1,28 @@
+import random
+class CharacterGrowthPlugin:
+    def __init__(self, max_apparent_age):
+        self.max_apparent_age = max_apparent_age
+
+    def grow_characters(self, characters, character_die_callback):
+        die_count = 0
+        for character in characters:
+            # 检查角色是否存活
+            if not character.is_alive:
+                print(f"{character.name}死亡了！")
+                character_die_callback(character)
+                continue
+
+            # 角色成长
+            character.grow()
+
+            # 表观年龄>60岁的角色有死亡风险，年纪越大风险越高，>100岁99%会死亡
+            if character.apparent_age > 60:
+                death_probability = min(0.01 * (character.apparent_age - 60), 0.99)
+                if random.random() < death_probability:
+                    character_die_callback(character)
+                    die_count += 1
+        print(f"{die_count}人寿终正寝了")
+
+    def execute(self, *args, **kwargs):
+        self.grow_characters(*args, **kwargs)
+

plugins/CultivationPlugin.py

@@ -0,0 +1,31 @@
+import random
+class CultivationPlugin:
+    def __init__(self, cultivation_speed=1.0):
+        self.cultivation_speed = cultivation_speed
+
+    def cultivate_characters(self, characters, world_spiritual_energy, init_world_spiritual_energy, consume_spiritual_energy_callback):
+        for character in characters:
+            if sum(character.spiritual_roots) > 0:
+                cultivation_speed = self.cultivation_speed * [0, 1.2, 1, 0.8, 0.6, 0.5][sum(character.spiritual_roots)]  # 灵根数量惩罚
+
+                # 根据特殊体质修炼速度进行调整
+                if character.special_constitution[2] == 1:  # 灵龟体质
+                    cultivation_speed *= 0.5
+                elif character.special_constitution[3] == 1:  # 蜉蝣体质
+                    cultivation_speed *= 2
+
+                if world_spiritual_energy > 0:
+                    cultivation_speed *= world_spiritual_energy / init_world_spiritual_energy
+                    success_rate = 1 - 0.2 * random.random()
+                    character.cultivate(1000 * cultivation_speed * success_rate)
+
+                    consume_amount = 10 * cultivation_speed * success_rate
+                    consume_spiritual_energy_callback(consume_amount) # 消耗灵气
+                    character.consume_spiritual_energy += consume_amount
+                    
+                else:
+                    # 没有灵气，无法修炼了
+                    pass
+
+    def execute(self, characters, world_spiritual_energy, init_world_spiritual_energy, consume_spiritual_energy):
+        self.cultivate_characters(characters, world_spiritual_energy, init_world_spiritual_energy, consume_spiritual_energy)

plugins/DisasterPlugin.py

@@ -0,0 +1,18 @@
+import random
+
+class DisasterPlugin:
+    def __init__(self, disaster_frequency, disaster_prob):
+        self.disaster_frequency = disaster_frequency
+        self.disaster_prob = disaster_prob
+
+    def trigger_disaster(self, characters, character_die_callback):
+        print("发生自然灾难...")
+        num_killed = int(len(characters) * self.disaster_prob)
+        killed = random.sample(characters, num_killed)
+        for c in killed:
+            c.history.append(f"{c.real_age}岁，死于自然灾难")
+            character_die_callback(c)
+
+    def execute(self, characters, round_num, character_die_callback):
+        if round_num % self.disaster_frequency == 0 and random.random() < self.disaster_prob:
+            self.trigger_disaster(characters, character_die_callback)

plugins/MarriagePlugin.py

@@ -0,0 +1,23 @@
+import random
+class MarriagePlugin:
+    def __init__(self, marriage_rate):
+        self.marriage_rate = marriage_rate
+
+    def perform_marriages(self, characters):
+        # 随机一些表观年龄>20的角色结婚
+        eligible_characters = [character for character in characters if character.apparent_age > 20 and character.partner is None]
+        new_couple_count = 0
+        for _ in range(int(len(eligible_characters) * self.marriage_rate)):
+            character = random.choice(eligible_characters)
+            partner = random.choice(eligible_characters)
+            if character != partner and character.gender != partner.gender and character.partner is None and partner.partner is None:
+                character.marry(partner)
+                new_couple_count += 1
+        print(f"{new_couple_count}对新人结婚了")
+
+    def set_marriage_rate(self, marriage_rate):
+        self.marriage_rate = marriage_rate
+
+    # 统一插件接口
+    def execute(self, *args, **kwargs):
+        self.perform_marriages(*args, **kwargs)

plugins/ResourceDepletionPlugin.py

@@ -0,0 +1,34 @@
+import random
+class ResourceDepletionPlugin:
+    def __init__(self, depletion_threshold, death_rate = 0.3):
+        self.depletion_threshold = depletion_threshold
+        self.death_rate = death_rate
+
+    def trigger_disaster(self, characters, character_die_callback):
+        print("资源耗尽! 发生灾难...")
+
+        # 按照宗族大小排序
+        clan_size = {}
+        for c in characters:
+            clan_size[c.clan] = clan_size.get(c.clan, 0) + 1
+
+        clans = sorted(clan_size.items(), key=lambda x: x[1], reverse=True)
+
+        # 前 50% 大小的宗族,死亡 30%, 后 50% 大小的宗族,死亡 60%
+        for i, (clan, size) in enumerate(clans):
+            if i < len(clans) // 2:
+                num_killed = int(size * self.death_rate)
+            else:
+                num_killed = int(size * (self.death_rate * 2))
+
+            # 随机选择死亡成员
+            clan_members = [c for c in characters if c.clan == clan]
+            killed = random.sample(clan_members, num_killed)
+
+            for c in killed:
+                character_die_callback(c)
+
+    def execute(self, resources, characters, character_die_callback):
+        # 检查资源是否耗尽，如果耗尽则触发灾难
+        if resources < self.depletion_threshold:
+            self.trigger_disaster(characters, character_die_callback)

requirements.txt

@@ -0,0 +1,3 @@
+gradio
+numpy
+matplotlib

run.py

@@ -0,0 +1,22 @@
+from CharacterStatistics import CharacterStatistics
+from WorldSimulation import WorldSimulation
+
+# 创建一个世界模拟对象
+simulation = WorldSimulation(special_constitution_ratio=[0.001, 0.001, 0.001, 0.001], spiritual_roots_ratio=[0.04, 0.04, 0.04, 0.04, 0.04], initial_population=3000, world_spiritual_energy=1000000)
+
+# 运行模拟
+simulation.add_custom_character("CoraBaby1", "女", special_constitution=[1, 0, 0, 1], spiritual_roots=[1, 1, 1, 1, 1])
+simulation.add_custom_character("CoraBaby2", "女", special_constitution=[0, 1, 0, 1], spiritual_roots=[1, 1, 1, 1, 1])
+
+simulation.start_simulation()
+simulation.run_simulation(num_rounds=10)
+
+# 查看世界统计
+stats = CharacterStatistics(simulation.characters)
+print(stats.summarize_markdown())
+
+print(simulation.characters[0])
+print(simulation.characters[1])
+
+print(simulation.dead_characters[0])
+print(simulation.dead_characters[1])

utils.py

@@ -0,0 +1,26 @@
+import string
+import random
+
+def get_random_name():
+    vowels = "aeiou"
+    consonants = "".join(set(string.ascii_lowercase) - set(vowels))
+    name = random.choice(consonants).upper()
+    name += random.choice(vowels)
+    name += random.choice(consonants)
+    name += random.choice(vowels)
+
+    return name
+
+def get_random_clan_name():
+    vowels = "aeiou"
+    consonants = "".join(set(string.ascii_lowercase) - set(vowels))
+    name = random.choice(consonants).upper()
+    name += random.choice(vowels)
+    name += random.choice(consonants)
+    name += random.choice(vowels)
+    name += random.choice(consonants)
+    name += random.choice(vowels)
+    name += random.choice(consonants)
+    name += random.choice(vowels)
+
+    return name