yexuejc/cultivation-world-simulator
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add root

Browse Source
This commit is contained in:
bridge
2025-08-23 20:53:03 +08:00
parent 9ee2230234
commit f72bccf0d3
5 changed files with 561 additions and 273 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/classes/avatar.py
View File

@@ -7,6 +7,8 @@ from src.classes.calendar import Month, Year
from src.classes.action import Action
from src.classes.world import World
from src.classes.tile import Tile
from src.classes.cultivation import CultivationProgress
from src.classes.root import Root
from src.utils.strings import to_snake_case
class Gender(Enum):
@@ -34,10 +36,12 @@ class Avatar:
birth_year: Year
age: int
gender: Gender
cultivation_progress: CultivationProgress = field(default_factory=lambda: CultivationProgress(0))
pos_x: int = 0
pos_y: int = 0
tile: Optional[Tile] = None
actions: dict[str, Action] = field(default_factory=dict)
root: Root = field(default_factory=lambda: random.choice(list(Root)))
def bind_action(self, action_class: type[Action]):

130
src/classes/cultivation.py Normal file
View File

@@ -0,0 +1,130 @@
from enum import Enum
class Realm(Enum):
Qi_Refinement = "练气"
Foundation_Establishment = "筑基"
Core_Formation = "金丹"
Nascent_Soul = "元婴"
class Stage(Enum):
Early_Stage = "前期"
Middle_Stage = "中期"
Late_Stage = "后期"
levels_per_realm = 30
levels_per_stage = 10
level_to_realm = {
0: Realm.Qi_Refinement,
30: Realm.Foundation_Establishment,
60: Realm.Core_Formation,
90: Realm.Nascent_Soul,
}
level_to_stage = {
0: Stage.Early_Stage,
10: Stage.Middle_Stage,
20: Stage.Late_Stage,
}
class CultivationProgress:
"""
修仙进度(包含等级、境界和经验值)
目前一个四个大境界，每个境界分前期、中期、后期。每一期对应10级。
所以每一个境界对应30级。境界的级别满了之后，需要突破才能进入下一个境界与升级。
所以有：
练气(Qi Refinement)：前期(1-10)、中期(11-20)、后期(21-30)、突破(31)
筑基(Foundation Establishment)：前期(31-40)、中期(41-50)、后期(51-60)、突破(61)
金丹(Core Formation)：前期(61-70)、中期(71-80)、后期(81-90)、突破(91)
元婴(Nascent Soul)：前期(91-100)、中期(101-110)、后期(111-120)、突破(121)
"""
def __init__(self, level: int, exp: int = 0):
self.level = level
self.exp = exp
self.realm = self.get_realm(level)
self.stage = self.get_stage(level)
def get_realm(self, level: int) -> str:
"""获取境界"""
for level_threshold, realm in reversed(list(level_to_realm.items())):
if level >= level_threshold:
return realm
return Realm.Qi_Refinement
def get_stage(self, level: int) -> str:
"""获取阶段"""
_level = self.level % levels_per_realm
for level_threshold, stage in reversed(list(level_to_stage.items())):
if _level >= level_threshold:
return stage
return Stage.Early_Stage
def __str__(self) -> str:
return f"{self.realm.value}{self.stage.value}({self.level}级)"
def get_exp_required(self, target_level: int) -> int:
"""
计算升级到指定等级需要的经验值
使用指数增长公式：base_exp * (growth_rate ^ level) * realm_multiplier
参数:
target_level: 目标等级
返回:
需要的经验值
"""
if target_level <= 0 or target_level > 120:
return 0
base_exp = 100 # 基础经验值
growth_rate = 1.15 # 每级增长15%
# 境界加成倍数：每跨越一个境界，经验需求增加50%
realm_multiplier = 1 + (target_level // 30) * 0.5
exp_required = int(base_exp * (growth_rate ** target_level) * realm_multiplier)
return exp_required
def can_level_up(self) -> bool:
"""
检查是否可以升级
返回:
如果经验值足够升级则返回True
"""
required_exp = self.get_exp_required(self.level + 1)
return self.exp >= required_exp
def get_exp_progress(self) -> tuple[int, int]:
"""
获取当前经验值进度
返回:
(当前经验值, 升级所需经验值)
"""
required_exp = self.get_exp_required(self.level + 1)
return self.exp, required_exp
def add_exp(self, exp_amount: int) -> bool:
"""
增加经验值
参数:
exp_amount: 要增加的经验值数量
返回:
如果升级了则返回True
"""
self.exp += exp_amount
# 检查是否可以升级
while self.can_level_up():
required_exp = self.get_exp_required()
self.exp -= required_exp
self.level += 1
# 更新境界和阶段
self.realm = self.get_realm(self.level)
self.stage = self.get_stage(self.level)
return True
return False

17
src/classes/root.py Normal file
View File

@@ -0,0 +1,17 @@
"""
灵根
目前只有五行灵根，金木水火土。
"""
from enum import Enum
class Root(Enum):
"""
灵根
"""
Metal = "金"
Wood = "木"
Water = "水"
Fire = "火"
Earth = "土"

337
src/front/front.py
View File

@@ -11,15 +11,16 @@ from src.classes.avatar import Avatar, Gender
class Front:
"""
基于 pygame 的前端展示。
- 渲染地图 `World.map` 与其中的 `Avatar`
- 以固定节奏调用 `simulator.step()`，画面随之更新
- 鼠标悬停在 avatar 上时显示信息
功能：
- 渲染地图与Avatar
- 自动/手动步进模拟
- 鼠标悬停显示信息
按键：
- A：切换自动步进（默认开启）
- 空格：手动执行一步（在自动关闭时有用）
- ESC / 关闭窗口：退出
- A：切换自动步进
- 空格：手动执行一步
- ESC：退出
"""
def __init__(
@@ -45,9 +46,8 @@ class Front:
self._auto_step = True
self._last_step_ms = 0
# 延迟导入 pygame：避免未安装 pygame 时影响非可视化运行/测试
import pygame # type: ignore
# 初始化pygame
import pygame
self.pygame = pygame
pygame.init()
pygame.font.init()
@@ -58,14 +58,13 @@ class Front:
self.screen = pygame.display.set_mode((width_px, height_px))
pygame.display.set_caption(window_title)
# 字体（优先中文友好字体；可显式传入 TTF 路径）
# 字体和缓存
self.font = self._create_font(16)
self.tooltip_font = self._create_font(14)
# 区域名字体缓存：按需动态放大（随区域面积和格子大小自适应）
self._region_font_cache: Dict[int, object] = {}
# 配色
self.colors: Dict[str, Tuple[int, int, int]] = {
# 配色方案
self.colors = {
"bg": (18, 18, 18),
"grid": (40, 40, 40),
"text": (230, 230, 230),
@@ -75,30 +74,33 @@ class Front:
}
# 加载tile图像
self.tile_images: Dict[TileType, object] = {}
self.tile_images = {}
self._load_tile_images()
self.clock = pygame.time.Clock()
# --------------------------- 主循环 ---------------------------
def run(self):
"""主循环"""
pygame = self.pygame
running = True
while running:
dt_ms = self.clock.tick(60)
self._last_step_ms += dt_ms
# 事件处理
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key in (pygame.K_ESCAPE,):
if event.key == pygame.K_ESCAPE:
running = False
elif event.key == pygame.K_a:
self._auto_step = not self._auto_step
elif event.key == pygame.K_SPACE:
self._step_once()
# 自动步进
if self._auto_step and self._last_step_ms >= self.step_interval_ms:
self._step_once()
@@ -107,99 +109,115 @@ class Front:
pygame.quit()
def _step_once(self):
"""执行一步模拟"""
self.simulator.step()
self._last_step_ms = 0
# --------------------------- 渲染 ---------------------------
def _render(self):
"""渲染主画面"""
pygame = self.pygame
# 清屏
self.screen.fill(self.colors["bg"])
# 绘制地图和标签
self._draw_map()
hovered_region = self._draw_region_labels()
hovered_avatar = self._draw_avatars_and_pick_hover()
# 优先显示region tooltip，如果没有region tooltip才显示avatar tooltip
# 显示tooltip
if hovered_region is not None:
mouse_x, mouse_y = self.pygame.mouse.get_pos()
mouse_x, mouse_y = pygame.mouse.get_pos()
self._draw_tooltip_for_region(hovered_region, mouse_x, mouse_y)
elif hovered_avatar is not None:
self._draw_tooltip_for_avatar(hovered_avatar)
# 状态条
# 状态信息
self._draw_status_bar()
self._draw_date_info()
pygame.display.flip()
def _draw_status_bar(self):
"""绘制状态栏"""
hint = f"A:自动步进({'开' if self._auto_step else '关'}) SPACE:单步 ESC:退出"
text_surf = self.font.render(hint, True, self.colors["text"])
self.screen.blit(text_surf, (self.margin, 4))
# 年月（右上角显示：YYYY年MM月）
def _draw_date_info(self):
"""绘制日期信息"""
try:
month_num = list(type(self.simulator.month)).index(self.simulator.month) + 1
except Exception:
month_num = 1
ym_text = f"{int(self.simulator.year)}年{month_num:02d}月"
ym_surf = self.font.render(ym_text, True, self.colors["text"])
screen_w, _ = self.screen.get_size()
self.screen.blit(ym_surf, (screen_w - self.margin - ym_surf.get_width(), 4))
pygame.display.flip()
def _draw_map(self):
"""绘制地图"""
pygame = self.pygame
map_obj = self.world.map
ts = self.tile_size
m = self.margin
# 先画tile图像
# 绘制tile图像
for y in range(map_obj.height):
for x in range(map_obj.width):
tile = map_obj.get_tile(x, y)
tile_image = self.tile_images.get(tile.type)
if tile_image:
# 使用tile图像
pos = (m + x * ts, m + y * ts)
self.screen.blit(tile_image, pos)
else:
# 如果没有图像，使用默认颜色块
color = (80, 80, 80) # 默认灰色
# 默认颜色块
color = (80, 80, 80)
rect = pygame.Rect(m + x * ts, m + y * ts, ts, ts)
pygame.draw.rect(self.screen, color, rect)
# 画网格线
# 绘制网格线
self._draw_grid(map_obj, ts, m)
def _draw_grid(self, map_obj, ts, m):
"""绘制网格线"""
pygame = self.pygame
grid_color = self.colors["grid"]
# 垂直线
for gx in range(map_obj.width + 1):
start_pos = (m + gx * ts, m)
end_pos = (m + gx * ts, m + map_obj.height * ts)
pygame.draw.line(self.screen, grid_color, start_pos, end_pos, 1)
# 水平线
for gy in range(map_obj.height + 1):
start_pos = (m, m + gy * ts)
end_pos = (m + map_obj.width * ts, m + gy * ts)
pygame.draw.line(self.screen, grid_color, start_pos, end_pos, 1)
def _draw_region_labels(self):
"""绘制区域标签"""
pygame = self.pygame
map_obj = self.world.map
ts = self.tile_size
m = self.margin
mouse_x, mouse_y = pygame.mouse.get_pos()
# 聚合每个 region 的所有地块中心点：Region 以自身 id 为哈希键
region_to_points: Dict[object, List[Tuple[int, int]]] = {}
# 直接遍历底层 tiles 字典更高效
for (x, y), tile in getattr(map_obj, "tiles", {}).items():
if getattr(tile, "region", None) is None:
continue
region_obj = tile.region
cx = m + x * ts + ts // 2
cy = m + y * ts + ts // 2
region_to_points.setdefault(region_obj, []).append((cx, cy))
# 收集每个region的所有地块中心点
region_to_points = self._collect_region_points(map_obj, ts, m)
if not region_to_points:
return
return None
# 绘制每个region的标签
hovered_region = None
for region, points in region_to_points.items():
if not points:
continue
# 计算质心
avg_x = sum(p[0] for p in points) // len(points)
avg_y = sum(p[1] for p in points) // len(points)
@@ -208,17 +226,15 @@ class Front:
if not name:
continue
# 按区域大小与格子尺寸决定字体大小
area = len(points)
base = int(self.tile_size * 1.1)
growth = int(max(0, min(24, (area ** 0.5))))
font_size = max(16, min(40, base + growth))
# 计算字体大小
font_size = self._calculate_font_size(len(points))
region_font = self._get_region_font(font_size)
# 渲染带轻微阴影的文字
text_surface = region_font.render(str(name), True, self.colors["text"]) # 主文字
shadow_surface = region_font.render(str(name), True, (0, 0, 0)) # 阴影
# 渲染文字
text_surface = region_font.render(str(name), True, self.colors["text"])
shadow_surface = region_font.render(str(name), True, (0, 0, 0))
# 计算位置
text_w = text_surface.get_width()
text_h = text_surface.get_height()
x = int(avg_x - text_w / 2)
@@ -228,35 +244,55 @@ class Front:
if (x <= mouse_x <= x + text_w and y <= mouse_y <= y + text_h):
hovered_region = region
# 先画阴影，略微偏移
# 绘制文字（先阴影后主文字）
self.screen.blit(shadow_surface, (x + 1, y + 1))
# 再画主文字
self.screen.blit(text_surface, (x, y))
# 返回悬停的region
return hovered_region
def _collect_region_points(self, map_obj, ts, m):
"""收集region的点位信息"""
region_to_points = {}
for (x, y), tile in getattr(map_obj, "tiles", {}).items():
if getattr(tile, "region", None) is None:
continue
region_obj = tile.region
cx = m + x * ts + ts // 2
cy = m + y * ts + ts // 2
region_to_points.setdefault(region_obj, []).append((cx, cy))
return region_to_points
def _calculate_font_size(self, area):
"""根据区域大小计算字体大小"""
base = int(self.tile_size * 1.1)
growth = int(max(0, min(24, (area ** 0.5))))
return max(16, min(40, base + growth))
def _get_region_font(self, size: int):
# 缓存不同大小的字体，避免每帧重复创建
f = self._region_font_cache.get(size)
if f is None:
f = self._create_font(size)
self._region_font_cache[size] = f
return f
"""获取指定大小的字体（带缓存）"""
if size not in self._region_font_cache:
self._region_font_cache[size] = self._create_font(size)
return self._region_font_cache[size]
def _draw_avatars_and_pick_hover(self) -> Optional[Avatar]:
"""绘制Avatar并检测悬停"""
pygame = self.pygame
mouse_x, mouse_y = pygame.mouse.get_pos()
hovered: Optional[Avatar] = None
hovered = None
min_dist = float("inf")
for avatar in self.simulator.avatars:
cx, cy = self._avatar_center_pixel(avatar)
radius = max(8, self.tile_size // 3)
# 绘制Avatar
pygame.draw.circle(self.screen, self.colors["avatar"], (cx, cy), radius)
# 简单的 hover：鼠标与圆心距离
# 检测悬停
dist = math.hypot(mouse_x - cx, mouse_y - cy)
if dist <= radius and dist < min_dist:
hovered = avatar
@@ -264,27 +300,61 @@ class Front:
return hovered
# --------------------------- 工具/辅助 ---------------------------
def _avatar_center_pixel(self, avatar: Avatar) -> Tuple[int, int]:
"""计算Avatar的像素中心位置"""
ts = self.tile_size
m = self.margin
px = m + avatar.pos_x * ts + ts // 2
py = m + avatar.pos_y * ts + ts // 2
return px, py
def _avatar_tooltip_lines(self, avatar: Avatar) -> List[str]:
gender = str(avatar.gender)
def _draw_tooltip(self, lines: List[str], mouse_x: int, mouse_y: int, font):
"""绘制通用tooltip"""
pygame = self.pygame
# 计算尺寸
padding = 6
spacing = 2
surf_lines = [font.render(t, True, self.colors["text"]) for t in lines]
width = max(s.get_width() for s in surf_lines) + padding * 2
height = sum(s.get_height() for s in surf_lines) + padding * 2 + spacing * (len(surf_lines) - 1)
pos = f"({avatar.pos_x}, {avatar.pos_y})"
# 计算位置
x = mouse_x + 12
y = mouse_y + 12
# 边界修正
screen_w, screen_h = self.screen.get_size()
if x + width > screen_w:
x = mouse_x - width - 12
if y + height > screen_h:
y = mouse_y - height - 12
# 绘制背景
bg_rect = pygame.Rect(x, y, width, height)
pygame.draw.rect(self.screen, self.colors["tooltip_bg"], bg_rect, border_radius=6)
pygame.draw.rect(self.screen, self.colors["tooltip_bd"], bg_rect, 1, border_radius=6)
# 绘制文字
cursor_y = y + padding
for s in surf_lines:
self.screen.blit(s, (x + padding, cursor_y))
cursor_y += s.get_height() + spacing
def _draw_tooltip_for_avatar(self, avatar: Avatar):
"""绘制Avatar的tooltip"""
lines = [
f"{avatar.name}#{avatar.id}",
f"性别: {gender}",
f"性别: {avatar.gender}",
f"年龄: {avatar.age}",
f"位置: {pos}",
f"境界: {str(avatar.cultivation_progress)}",
f"灵根: {avatar.root.value}",
f"位置: ({avatar.pos_x}, {avatar.pos_y})",
]
return lines
self._draw_tooltip(lines, *self.pygame.mouse.get_pos(), self.tooltip_font)
def _region_tooltip_lines(self, region) -> List[str]:
def _draw_tooltip_for_region(self, region, mouse_x: int, mouse_y: int):
"""绘制Region的tooltip"""
lines = [
f"区域: {region.name}",
f"描述: {region.description}",
@@ -292,92 +362,23 @@ class Front:
# 添加灵气信息
if hasattr(region, 'essence') and region.essence:
# 按密度排序，显示最重要的灵气
essence_items = []
for essence_type, density in region.essence.density.items():
if density > 0:
essence_name = str(essence_type)
essence_name = str(essence_type)
essence_items.append((density, essence_name))
if essence_items:
# 按密度降序排序
essence_items.sort(reverse=True)
lines.append("灵气分布:")
for density, name in essence_items:
# 用星号表示密度等级
stars = "★" * density + "☆" * (10 - density)
lines.append(f" {name}: {stars}")
return lines
def _draw_tooltip_for_avatar(self, avatar: Avatar):
pygame = self.pygame
lines = self._avatar_tooltip_lines(avatar)
# 计算尺寸
padding = 6
spacing = 2
surf_lines = [self.tooltip_font.render(t, True, self.colors["text"]) for t in lines]
width = max(s.get_width() for s in surf_lines) + padding * 2
height = sum(s.get_height() for s in surf_lines) + padding * 2 + spacing * (len(surf_lines) - 1)
mx, my = pygame.mouse.get_pos()
x = mx + 12
y = my + 12
# 边界修正：尽量不出屏幕
screen_w, screen_h = self.screen.get_size()
if x + width > screen_w:
x = mx - width - 12
if y + height > screen_h:
y = my - height - 12
bg_rect = pygame.Rect(x, y, width, height)
pygame.draw.rect(self.screen, self.colors["tooltip_bg"], bg_rect, border_radius=6)
pygame.draw.rect(self.screen, self.colors["tooltip_bd"], bg_rect, 1, border_radius=6)
# 绘制文字
cursor_y = y + padding
for s in surf_lines:
self.screen.blit(s, (x + padding, cursor_y))
cursor_y += s.get_height() + spacing
def _draw_tooltip_for_region(self, region, mouse_x: int, mouse_y: int):
pygame = self.pygame
lines = self._region_tooltip_lines(region)
# 计算尺寸
padding = 6
spacing = 2
surf_lines = [self.tooltip_font.render(t, True, self.colors["text"]) for t in lines]
width = max(s.get_width() for s in surf_lines) + padding * 2
height = sum(s.get_height() for s in surf_lines) + padding * 2 + spacing * (len(surf_lines) - 1)
x = mouse_x + 12
y = mouse_y + 12
# 边界修正：尽量不出屏幕
screen_w, screen_h = self.screen.get_size()
if x + width > screen_w:
x = mouse_x - width - 12
if y + height > screen_h:
y = mouse_y - height - 12
bg_rect = pygame.Rect(x, y, width, height)
pygame.draw.rect(self.screen, self.colors["tooltip_bg"], bg_rect, border_radius=6)
pygame.draw.rect(self.screen, self.colors["tooltip_bd"], bg_rect, 1, border_radius=6)
# 绘制文字
cursor_y = y + padding
for s in surf_lines:
self.screen.blit(s, (x + padding, cursor_y))
cursor_y += s.get_height() + spacing
self._draw_tooltip(lines, mouse_x, mouse_y, self.tooltip_font)
def _load_tile_images(self):
"""
加载所有tile类型的图像
"""
"""加载所有tile类型的图像"""
import os
pygame = self.pygame
@@ -391,65 +392,55 @@ class Front:
for tile_type in tile_types:
image_path = f"assets/tiles/{tile_type.value}.png"
if os.path.exists(image_path):
try:
# 加载图像并缩放到tile_size
image = pygame.image.load(image_path)
scaled_image = pygame.transform.scale(image, (self.tile_size, self.tile_size))
self.tile_images[tile_type] = scaled_image
print(f"已加载tile图像: {image_path}")
except Exception as e:
print(f"加载tile图像失败 {image_path}: {e}")
# 如果加载失败，创建一个默认的颜色块
fallback_surface = pygame.Surface((self.tile_size, self.tile_size))
fallback_surface.fill((128, 128, 128)) # 灰色作为默认
self.tile_images[tile_type] = fallback_surface
self._create_fallback_surface(tile_type)
else:
print(f"tile图像文件不存在: {image_path}")
# 创建默认颜色块
fallback_surface = pygame.Surface((self.tile_size, self.tile_size))
fallback_surface.fill((128, 128, 128))
self.tile_images[tile_type] = fallback_surface
self._create_fallback_surface(tile_type)
def _create_fallback_surface(self, tile_type):
"""创建默认的fallback surface"""
fallback_surface = self.pygame.Surface((self.tile_size, self.tile_size))
fallback_surface.fill((128, 128, 128)) # 灰色
self.tile_images[tile_type] = fallback_surface
def _create_font(self, size: int):
pygame = self.pygame
"""创建字体"""
if self.font_path:
try:
return pygame.font.Font(self.font_path, size)
return self.pygame.font.Font(self.font_path, size)
except Exception:
# 回退到自动匹配
pass
return self._load_font_with_fallback(size)
def _load_font_with_fallback(self, size: int):
"""
在不同平台上尝试加载常见等宽或中文字体，避免中文渲染为方块。
"""
"""加载字体，带fallback机制"""
pygame = self.pygame
# 字体候选列表
candidates = [
# Windows 常见中文字体
"Microsoft YaHei UI",
"Microsoft YaHei",
"SimHei",
"SimSun",
# 常见等宽/通用字体
"Consolas",
"DejaVu Sans",
"DejaVu Sans Mono",
"Arial Unicode MS",
"Noto Sans CJK SC",
"Noto Sans CJK",
"Microsoft YaHei UI", "Microsoft YaHei", "SimHei", "SimSun",
"Consolas", "DejaVu Sans", "DejaVu Sans Mono", "Arial Unicode MS",
"Noto Sans CJK SC", "Noto Sans CJK",
]
for name in candidates:
try:
f = pygame.font.SysFont(name, size)
# 简单验证一下是否能渲染中文（有些字体返回成功但渲染为空）
test = f.render("测试中文AaBb123", True, (255, 255, 255))
font = pygame.font.SysFont(name, size)
# 验证字体是否能渲染中文
test = font.render("测试中文AaBb123", True, (255, 255, 255))
if test.get_width() > 0:
return f
return font
except Exception:
pass
continue
# 退回默认字体
return pygame.font.SysFont(None, size)