众所周知，claude发布了最新的opus5模型，下表则是两者的对比：
简单来说，Fable 5是追求极致性能的“天花板”，而Opus 5是兼顾顶级性能与一半价格的“性价比之王”
尽管Fable 5定位更高，但在一些关键基准测试中，Opus 5凭借其优化，表现甚至更为优异。
- Opus 5领先的领域：
- Fable 5保持优势的领域：
值得注意的是，Claude Opus 5 对免费用户不可用。
下面我以经典游戏马里奥医生，给相同的提示词，横向对比一下claude与deepseek的编程能力：
两个问题均是
深刻分析马里奥医生这个游戏，写一个产品分析的文档
根据这个分析，用python写一个exe游戏软件来实现该功能和效果
这是deepseek的：
根据上面的分析文档写的python源码：
import pygame
import random
import sys
# 初始化 Pygame
pygame.init()
# ---------------------------- 游戏常量 ----------------------------
# 网格尺寸 (经典 8x16)
GRID_WIDTH = 8
GRID_HEIGHT = 16
CELL_SIZE = 30 # 像素
# 窗口尺寸 (左边界留白用于显示药品瓶, 右侧留白显示信息)
MARGIN_LEFT = 30
MARGIN_TOP = 30
WINDOW_WIDTH = MARGIN_LEFT + GRID_WIDTH * CELL_SIZE + 200
WINDOW_HEIGHT = MARGIN_TOP + GRID_HEIGHT * CELL_SIZE + 30
# 颜色映射 (0=空, 1=红, 2=黄, 3=蓝)
COLORS = {
0: (20, 20, 30), # 黑色背景
1: (255, 60, 60), # 红色病毒
2: (255, 235, 60), # 黄色病毒
3: (60, 180, 255), # 蓝色病毒
4: (200, 200, 200) # 胶囊白色边框
}
# 游戏速度 (帧数间隔, 数值越大下落越慢)
BASE_SPEED = 30
SPEED_LEVELS = {1: 30, 2: 25, 3: 20, 4: 15, 5: 10, 6: 6, 7: 4, 8: 2}
# ---------------------------- 游戏类 ----------------------------
class DrMarioGame:
def __init__(self):
self.screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption("马里奥医生 - Python版")
self.clock = pygame.time.Clock()
self.font = pygame.font.SysFont("simhei", 20, bold=True)
self.reset_game()
def reset_game(self):
"""重置游戏状态"""
# ⚠️ 所有属性必须在这时定义，因为 _spawn_capsule 会用到它们
self.game_over = False
self.win = False
self.score = 0
self.level = 1
self.lines_cleared = 0
self.fall_counter = 0
self.current_capsule = None
self.clearing_cells = []
self.clear_timer = 0
# 网格数据
self.grid = [[0 for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)]
# 生成病毒 (随机分布在底部 8 行)
self.virus_count = 0
for r in range(8, GRID_HEIGHT):
for c in range(GRID_WIDTH):
if random.random() < 0.70:
color = random.choice([1, 2, 3])
self.grid[r][c] = color
self.virus_count += 1
if self.virus_count < 15:
for _ in range(20):
r = random.randint(8, GRID_HEIGHT - 1)
c = random.randint(0, GRID_WIDTH - 1)
if self.grid[r][c] == 0:
self.grid[r][c] = random.choice([1, 2, 3])
self.virus_count += 1
# 生成第一个胶囊
self.next_colors = self._generate_capsule_colors()
self._spawn_capsule() # 此时 self.game_over 等已经定义好了
def _generate_capsule_colors(self):
"""生成胶囊的两个颜色 (红黄蓝随机组合)"""
c1 = random.choice([1, 2, 3])
c2 = random.choice([1, 2, 3])
# 避免生成两个完全一样的颜色 (让游戏更有策略性)
while c2 == c1:
c2 = random.choice([1, 2, 3])
return [c1, c2]
def _spawn_capsule(self):
"""在顶部中间生成新胶囊"""
if self.game_over or self.win:
return
colors = self.next_colors
self.next_colors = self._generate_capsule_colors()
# 初始位置: 第0行, 第3列和第4列 (水平放置)
c1 = (0, 3, colors[0])
c2 = (0, 4, colors[1])
self.current_capsule = [c1, c2]
# 检测是否碰撞 (生成即死)
if self._check_collision(self.current_capsule):
self.game_over = True
self.current_capsule = None
def _check_collision(self, capsule_parts):
"""检测胶囊是否与边界或已有方块重叠"""
for r, c, color in capsule_parts:
if c < 0 or c >= GRID_WIDTH or r >= GRID_HEIGHT:
return True
if r >= 0 and self.grid[r][c] != 0:
return True
return False
def _rotate_capsule(self):
"""旋转胶囊 (顺时针旋转, 以第一个块为轴心)"""
if not self.current_capsule or self.game_over or self.win:
return
# 获取轴心 (第一个块)
r0, c0, color0 = self.current_capsule[0]
r1, c1, color1 = self.current_capsule[1]
# 计算相对位置
dr = r1 - r0
dc = c1 - c0
# 顺时针旋转: (dr, dc) -> (dc, -dr)
new_dr = dc
new_dc = -dr
new_r1 = r0 + new_dr
new_c1 = c0 + new_dc
new_capsule = [(r0, c0, color0), (new_r1, new_c1, color1)]
# 如果旋转后不碰撞, 则应用
if not self._check_collision(new_capsule):
self.current_capsule = new_capsule
def _move_capsule(self, dc):
"""左右移动胶囊"""
if not self.current_capsule or self.game_over or self.win:
return
new_capsule = [(r, c + dc, color) for r, c, color in self.current_capsule]
if not self._check_collision(new_capsule):
self.current_capsule = new_capsule
def _drop_capsule(self):
"""硬降: 直接落到底"""
if not self.current_capsule or self.game_over or self.win:
return
while not self._check_collision([(r + 1, c, color) for r, c, color in self.current_capsule]):
self.current_capsule = [(r + 1, c, color) for r, c, color in self.current_capsule]
self._lock_capsule()
def _move_down(self):
"""下落一格 (由计时器调用)"""
if not self.current_capsule or self.game_over or self.win:
return
new_capsule = [(r + 1, c, color) for r, c, color in self.current_capsule]
if not self._check_collision(new_capsule):
self.current_capsule = new_capsule
else:
self._lock_capsule()
def _lock_capsule(self):
"""将胶囊固定到网格, 然后触发消除检测"""
if not self.current_capsule:
return
for r, c, color in self.current_capsule:
if 0 <= r < GRID_HEIGHT and 0 <= c < GRID_WIDTH:
self.grid[r][c] = color
self.current_capsule = None
# 执行消除和连锁
self._clear_matches()
def _clear_matches(self):
"""消除所有4连以上的同色块 (包含连锁)"""
cleared_any = False
while True:
to_clear = set()
# 1. 水平扫描 (检查每行连续4个同色)
for r in range(GRID_HEIGHT):
c = 0
while c < GRID_WIDTH:
if self.grid[r][c] == 0:
c += 1
continue
color = self.grid[r][c]
count = 0
# 向右数
while c + count < GRID_WIDTH and self.grid[r][c + count] == color:
count += 1
if count >= 4:
for i in range(count):
to_clear.add((r, c + i))
c += count if count > 1 else 1
# 2. 垂直扫描 (检查每列连续4个同色)
for c in range(GRID_WIDTH):
r = 0
while r < GRID_HEIGHT:
if self.grid[r][c] == 0:
r += 1
continue
color = self.grid[r][c]
count = 0
while r + count < GRID_HEIGHT and self.grid[r + count][c] == color:
count += 1
if count >= 4:
for i in range(count):
to_clear.add((r + i, c))
r += count if count > 1 else 1
# 如果没有可消除的, 退出循环
if not to_clear:
break
# 消除方块并计数
cleared_any = True
virus_eliminated = 0
for r, c in to_clear:
if self.grid[r][c] in [1, 2, 3]:
virus_eliminated += 1
self.grid[r][c] = 0
self.virus_count -= virus_eliminated
self.lines_cleared += len(to_clear) // 4 # 粗略计行
self.score += virus_eliminated * 10 * self.level
# 更新等级 (每消除 20 个病毒升1级)
self.level = min(8, 1 + self.lines_cleared // 4)
# 3. 物理下落 (填补空洞)
for c in range(GRID_WIDTH):
# 从下往上
write_row = GRID_HEIGHT - 1
for r in range(GRID_HEIGHT - 1, -1, -1):
if self.grid[r][c] != 0:
self.grid[write_row][c] = self.grid[r][c]
if write_row != r:
self.grid[r][c] = 0
write_row -= 1
# 检查胜利条件
if self.virus_count == 0:
self.win = True
self.current_capsule = None
return
# 消除结束后, 生成下一个胶囊
if not cleared_any:
# 如果没有消除任何东西, 但锁定了胶囊, 继续生成
pass
# 生成新胶囊 (如果游戏未结束)
if not self.game_over and not self.win:
self._spawn_capsule()
# 生成时检查是否碰撞 (游戏结束)
if self.current_capsule and self._check_collision(self.current_capsule):
self.game_over = True
self.current_capsule = None
# ---------------------------- 渲染 ----------------------------
def draw(self):
self.screen.fill((10, 10, 20))
# 绘制药瓶背景 (圆角矩形感觉)
pygame.draw.rect(self.screen, (30, 40, 50),
(MARGIN_LEFT - 10, MARGIN_TOP - 10,
GRID_WIDTH * CELL_SIZE + 20, GRID_HEIGHT * CELL_SIZE + 20),
border_radius=15)
# 绘制网格线 (淡淡的)
for r in range(GRID_HEIGHT):
for c in range(GRID_WIDTH):
x = MARGIN_LEFT + c * CELL_SIZE
y = MARGIN_TOP + r * CELL_SIZE
# 格子背景
pygame.draw.rect(self.screen, (25, 30, 40),
(x, y, CELL_SIZE - 1, CELL_SIZE - 1),
border_radius=2)
# 绘制病毒和固定胶囊
for r in range(GRID_HEIGHT):
for c in range(GRID_WIDTH):
val = self.grid[r][c]
if val != 0:
x = MARGIN_LEFT + c * CELL_SIZE + 2
y = MARGIN_TOP + r * CELL_SIZE + 2
color = COLORS[val]
# 画圆角方块 (带高光效果)
pygame.draw.rect(self.screen, color,
(x, y, CELL_SIZE - 4, CELL_SIZE - 4),
border_radius=6)
# 高光
pygame.draw.rect(self.screen,
(min(255, color[0] + 60), min(255, color[1] + 60), min(255, color[2] + 60)),
(x + 2, y + 2, (CELL_SIZE - 4) // 2, 2),
border_radius=2)
# 绘制当前活动胶囊
if self.current_capsule:
for r, c, color in self.current_capsule:
if r >= 0:
x = MARGIN_LEFT + c * CELL_SIZE + 2
y = MARGIN_TOP + r * CELL_SIZE + 2
pygame.draw.rect(self.screen, COLORS[color],
(x, y, CELL_SIZE - 4, CELL_SIZE - 4),
border_radius=6)
# 胶囊连接线 (让两个方块看起来是一体的)
# 绘制下一个胶囊预览
preview_x = MARGIN_LEFT + GRID_WIDTH * CELL_SIZE + 30
preview_y = MARGIN_TOP + 50
self.screen.blit(self.font.render("下一个:", True, (200, 200, 200)), (preview_x, preview_y))
if self.next_colors:
for i, col in enumerate(self.next_colors):
px = preview_x + i * 35
py = preview_y + 30
pygame.draw.rect(self.screen, COLORS[col], (px, py, 25, 25), border_radius=5)
# 显示分数和等级
info_y = preview_y + 100
self.screen.blit(self.font.render(f"分数: {self.score}", True, (255, 255, 200)), (preview_x, info_y))
self.screen.blit(self.font.render(f"等级: {self.level}", True, (255, 255, 200)), (preview_x, info_y + 30))
self.screen.blit(self.font.render(f"病毒: {self.virus_count}", True, (255, 255, 200)), (preview_x, info_y + 60))
self.screen.blit(self.font.render(f"消除: {self.lines_cleared}", True, (255, 255, 200)),
(preview_x, info_y + 90))
# 操作提示
tip_y = info_y + 150
tips = ["↑/X: 旋转", "←/→: 移动", "↓: 加速", "空格: 硬降"]
for i, tip in enumerate(tips):
self.screen.blit(self.font.render(tip, True, (150, 150, 180)), (preview_x, tip_y + i * 25))
# 游戏结束 / 胜利 画面
if self.game_over:
overlay = pygame.Surface((WINDOW_WIDTH, WINDOW_HEIGHT), pygame.SRCALPHA)
overlay.fill((0, 0, 0, 180))
self.screen.blit(overlay, (0, 0))
text = self.font.render("💊 游戏结束! 按 R 重新开始", True, (255, 100, 100))
self.screen.blit(text, (WINDOW_WIDTH // 2 - 150, WINDOW_HEIGHT // 2))
elif self.win:
overlay = pygame.Surface((WINDOW_WIDTH, WINDOW_HEIGHT), pygame.SRCALPHA)
overlay.fill((0, 0, 0, 180))
self.screen.blit(overlay, (0, 0))
text = self.font.render("🎉 恭喜! 病毒全部消灭! 按 R 重新开始", True, (100, 255, 100))
self.screen.blit(text, (WINDOW_WIDTH // 2 - 170, WINDOW_HEIGHT // 2))
pygame.display.flip()
# ---------------------------- 主循环 ----------------------------
def run(self):
running = True
while running:
# 获取下落速度
speed = SPEED_LEVELS.get(self.level, 2)
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
pygame.quit()
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_r:
self.reset_game()
continue
if self.game_over or self.win:
continue
if event.key == pygame.K_LEFT:
self._move_capsule(-1)
elif event.key == pygame.K_RIGHT:
self._move_capsule(1)
elif event.key == pygame.K_UP or event.key == pygame.K_x:
self._rotate_capsule()
elif event.key == pygame.K_DOWN:
self._move_down() # 软降一步
elif event.key == pygame.K_SPACE:
self._drop_capsule()
# 自动下落 (非游戏结束/胜利状态)
if not self.game_over and not self.win:
self.fall_counter += 1
if self.fall_counter >= speed:
self.fall_counter = 0
self._move_down()
self.draw()
self.clock.tick(60) # 60帧
# ---------------------------- 启动 ----------------------------
if __name__ == "__main__":
game = DrMarioGame()
game.run()通过在命令行执行
pip install pygame pyinstaller
安装打包软件
执行打包命令
pyinstaller --onefile --windowed --name="马里奥医生" dr_mario.py
最后打开dist中的exe文件即可。下面是生成的界面。
从源码来看deepseek最主要通过算法逻辑实现了同色4个连续的消除功能，并随着时间的推移下落速度逐渐加快。除此之外再无其他。想读简单
我给claude opus5同样的提示词：
经过大概40分钟的分析才给出结果这是生成的游戏首页图：
游戏模式分为了单人闯关、双人模式、对战电脑、对战双人、每日挑战，下面是单人闯关的截图：
游戏的画面性非常还原了原有游戏界面，还有动态的效果和音效，也非常契合。当然也可以调整难度和关卡，难度越高下落速度越快，关卡越高，病毒数量越多，这是20关的病毒分布，密密麻麻：
估计知道你过不去，claude还”贴心“的给你提供了作弊面板，通过双击shift调出。包括直接过关、清掉5只病毒、清空胶囊垃圾等。
感兴趣的同学可以在我的GitHub主页复刻该项目：ghostgorge/DrMarioClone