Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-r1-0528· DeepSeekHugging Face LMArena Human Preference 140K

帮我生成一个人机大战的游戏

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-3-7-sonnet-20250219’s answer.
  1. User

    帮我生成一个人机大战的游戏

  2. DeepSeek Assistant

    人机大战:数字对决

    下面是一个基于Python和Pygame的"人机大战"游戏,玩家需要猜测计算机生成的随机数字,而计算机也会尝试猜测玩家设定的数字,比赛谁先猜中对方的数字。

    import pygame
    import sys
    import random
    import math
    from pygame.locals import *
    
    # 初始化pygame
    pygame.init()
    
    # 屏幕设置
    WIDTH, HEIGHT = 900, 600
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("人机大战:数字对决")
    
    # 颜色定义
    BACKGROUND = (15, 25, 45)
    PLAYER_COLOR = (70, 130, 180)
    AI_COLOR = (220, 60, 80)
    HIGHLIGHT = (255, 215, 0)
    TEXT_COLOR = (240, 240, 240)
    BUTTON_COLOR = (50, 150, 100)
    BUTTON_HOVER = (70, 180, 120)
    INPUT_BOX = (60, 70, 90)
    INPUT_HIGHLIGHT = (90, 110, 130)
    
    # 字体
    title_font = pygame.font.SysFont("microsoftyahei", 48, bold=True)
    header_font = pygame.font.SysFont("microsoftyahei", 32, bold=True)
    main_font = pygame.font.SysFont("microsoftyahei", 28)
    small_font = pygame.font.SysFont("microsoftyahei", 22)
    
    # 游戏状态
    class GameState:
        def __init__(self):
            self.reset()
            
        def reset(self):
            self.player_secret = random.randint(1, 100)
            self.ai_secret = random.randint(1, 100)
            self.player_guesses = []
            self.ai_guesses = []
            self.player_hints = []
            self.ai_hints = []
            self.player_input = ""
            self.ai_low = 1
            self.ai_high = 100
            self.game_over = False
            self.winner = None
            self.message = ""
            self.player_turn = True
            self.input_active = False
            self.ai_thinking = 0
            
        def player_guess(self, guess):
            try:
                num = int(guess)
                if num < 1 or num > 100:
                    self.message = "请输入1-100之间的数字!"
                    return
                    
                self.player_guesses.append(num)
                
                # 检查是否猜中
                if num == self.ai_secret:
                    self.game_over = True
                    self.winner = "玩家"
                    self.message = f"恭喜!你猜中了数字 {self.ai_secret}!"
                elif num < self.ai_secret:
                    self.player_hints.append(f"{num} → 太小了")
                    self.message = f"{num} 太小了!"
                else:
                    self.player_hints.append(f"{num} → 太大了")
                    self.message = f"{num} 太大了!"
                    
                self.player_input = ""
                self.player_turn = False
                self.ai_thinking = 30  # AI思考时间
                
            except ValueError:
                self.message = "请输入有效的数字!"
        
        def ai_guess(self):
            # AI使用二分搜索算法
            if self.ai_low == self.ai_high:
                guess = self.ai_low
            else:
                guess = random.randint(self.ai_low, self.ai_high)
                # 增加一些随机性,使AI不那么完美
                if len(self.ai_guesses) > 3 and random.random() < 0.3:
                    offset = random.randint(-5, 5)
                    guess = min(max(guess + offset, self.ai_low), self.ai_high)
            
            self.ai_guesses.append(guess)
            
            # 检查是否猜中
            if guess == self.player_secret:
                self.game_over = True
                self.winner = "AI"
                self.message = f"AI猜中了你的数字 {self.player_secret}!"
            elif guess < self.player_secret:
                self.ai_hints.append(f"{guess} → 太小了")
                self.ai_low = guess + 1
            else:
                self.ai_hints.append(f"{guess} → 太大了")
                self.ai_high = guess - 1
                
            self.player_turn = True
    
    # 创建游戏状态
    game = GameState()
    
    # 按钮类
    class Button:
        def __init__(self, x, y, width, height, text, color=BUTTON_COLOR, hover_color=BUTTON_HOVER):
            self.rect = pygame.Rect(x, y, width, height)
            self.text = text
            self.color = color
            self.hover_color = hover_color
            self.current_color = color
            self.text_surf = main_font.render(text, True, TEXT_COLOR)
            self.text_rect = self.text_surf.get_rect(center=self.rect.center)
            
        def draw(self, surface):
            pygame.draw.rect(surface, self.current_color, self.rect, border_radius=8)
            pygame.draw.rect(surface, HIGHLIGHT, self.rect, 2, border_radius=8)
            surface.blit(self.text_surf, self.text_rect)
            
        def check_hover(self, pos):
            if self.rect.collidepoint(pos):
                self.current_color = self.hover_color
                return True
            self.current_color = self.color
            return False
            
        def is_clicked(self, pos, event):
            if event.type == MOUSEBUTTONDOWN and event.button == 1:
                return self.rect.collidepoint(pos)
            return False
    
    # 创建按钮
    guess_button = Button(WIDTH//2 - 100, 400, 200, 50, "猜数字")
    reset_button = Button(WIDTH//2 - 100, 470, 200, 50, "重新开始")
    
    # 输入框
    input_box = pygame.Rect(WIDTH//2 - 100, 350, 200, 45)
    
    # 绘制进度条
    def draw_progress_bar(surface, x, y, width, height, progress, color):
        pygame.draw.rect(surface, (40, 40, 60), (x, y, width, height), border_radius=5)
        inner_width = max(0, min(width, int(width * progress)))
        pygame.draw.rect(surface, color, (x, y, inner_width, height), border_radius=5)
        pygame.draw.rect(surface, HIGHLIGHT, (x, y, width, height), 2, border_radius=5)
        
        # 绘制进度文本
        progress_text = small_font.render(f"{int(progress*100)}%", True, TEXT_COLOR)
        surface.blit(progress_text, (x + width//2 - progress_text.get_width()//2, 
                                    y + height//2 - progress_text.get_height()//2))
    
    # 绘制游戏界面
    def draw_game():
        # 绘制背景
        screen.fill(BACKGROUND)
        
        # 绘制星空背景
        for i in range(100):
            x = random.randint(0, WIDTH)
            y = random.randint(0, HEIGHT)
            size = random.randint(1, 3)
            brightness = random.randint(150, 255)
            pygame.draw.circle(screen, (brightness, brightness, brightness), (x, y), size)
        
        # 绘制标题
        title = title_font.render("人机大战:数字对决", True, HIGHLIGHT)
        screen.blit(title, (WIDTH//2 - title.get_width()//2, 20))
        
        # 绘制分隔线
        pygame.draw.line(screen, (80, 100, 130), (WIDTH//2, 80), (WIDTH//2, HEIGHT-50), 2)
        
        # 绘制玩家区域
        player_header = header_font.render("玩家区域", True, PLAYER_COLOR)
        screen.blit(player_header, (WIDTH//4 - player_header.get_width()//2, 90))
        
        ai_header = header_font.render("AI区域", True, AI_COLOR)
        screen.blit(ai_header, (3*WIDTH//4 - ai_header.get_width()//2, 90))
        
        # 绘制提示信息
        if game.message:
            msg_surf = main_font.render(game.message, True, HIGHLIGHT)
            screen.blit(msg_surf, (WIDTH//2 - msg_surf.get_width()//2, 300))
        
        # 绘制游戏结束信息
        if game.game_over:
            result_color = PLAYER_COLOR if game.winner == "玩家" else AI_COLOR
            result_text = header_font.render(f"{game.winner}获胜!", True, result_color)
            screen.blit(result_text, (WIDTH//2 - result_text.get_width()//2, 250))
        
        # 绘制输入框
        color = INPUT_HIGHLIGHT if game.input_active else INPUT_BOX
        pygame.draw.rect(screen, color, input_box, border_radius=5)
        pygame.draw.rect(screen, HIGHLIGHT, input_box, 2, border_radius=5)
        
        input_surf = main_font.render(game.player_input, True, TEXT_COLOR)
        screen.blit(input_surf, (input_box.x + 10, input_box.y + 10))
        
        # 绘制按钮
        guess_button.draw(screen)
        reset_button.draw(screen)
        
        # 绘制猜测信息
        player_text = main_font.render(f"你的数字: {game.player_secret}", True, PLAYER_COLOR)
        screen.blit(player_text, (WIDTH//4 - player_text.get_width()//2, 140))
        
        ai_text = main_font.render(f"AI的数字: ???", True, AI_COLOR)
        screen.blit(ai_text, (3*WIDTH//4 - ai_text.get_width()//2, 140))
        
        # 绘制猜测历史
        player_history = main_font.render("你的猜测历史:", True, PLAYER_COLOR)
        screen.blit(player_history, (WIDTH//4 - player_history.get_width()//2, 180))
        
        ai_history = main_font.render("AI的猜测历史:", True, AI_COLOR)
        screen.blit(ai_history, (3*WIDTH//4 - ai_history.get_width()//2, 180))
        
        # 绘制历史记录
        for i, hint in enumerate(game.player_hints[-5:]):
            hint_surf = small_font.render(hint, True, TEXT_COLOR)
            screen.blit(hint_surf, (WIDTH//4 - hint_surf.get_width()//2, 220 + i*30))
        
        for i, hint in enumerate(game.ai_hints[-5:]):
            hint_surf = small_font.render(hint, True, TEXT_COLOR)
            screen.blit(hint_surf, (3*WIDTH//4 - hint_surf.get_width()//2, 220 + i*30))
        
        # 绘制进度条
        player_progress = min(1.0, len(game.player_guesses) / 10)
        ai_progress = min(1.0, len(game.ai_guesses) / 7)
        
        draw_progress_bar(screen, WIDTH//4 - 80, 380, 160, 20, player_progress, PLAYER_COLOR)
        draw_progress_bar(screen, 3*WIDTH//4 - 80, 380, 160, 20, ai_progress, AI_COLOR)
        
        # 绘制进度标签
        player_label = small_font.render("分析进度", True, PLAYER_COLOR)
        screen.blit(player_label, (WIDTH//4 - player_label.get_width()//2, 360))
        
        ai_label = small_font.render("破解进度", True, AI_COLOR)
        screen.blit(ai_label, (3*WIDTH//4 - ai_label.get_width()//2, 360))
        
        # 绘制回合指示器
        turn_text = "你的回合" if game.player_turn else "AI思考中..."
        turn_color = PLAYER_COLOR if game.player_turn else AI_COLOR
        turn_surf = main_font.render(turn_text, True, turn_color)
        screen.blit(turn_surf, (WIDTH//2 - turn_surf.get_width()//2, 530))
    
    # 主游戏循环
    clock = pygame.time.Clock()
    
    while True:
        mouse_pos = pygame.mouse.get_pos()
        
        # 事件处理
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
                sys.exit()
                
            # 输入框激活
            if event.type == MOUSEBUTTONDOWN:
                if input_box.collidepoint(event.pos):
                    game.input_active = True
                else:
                    game.input_active = False
                    
            # 键盘输入
            if event.type == KEYDOWN and game.input_active:
                if event.key == K_RETURN and game.player_input:
                    game.player_guess(game.player_input)
                elif event.key == K_BACKSPACE:
                    game.player_input = game.player_input[:-1]
                elif event.key in (K_0, K_KP0) and game.player_input != "":
                    game.player_input += "0"
                elif event.key in (K_1, K_KP1):
                    game.player_input += "1"
                elif event.key in (K_2, K_KP2):
                    game.player_input += "2"
                elif event.key in (K_3, K_KP3):
                    game.player_input += "3"
                elif event.key in (K_4, K_KP4):
                    game.player_input += "4"
                elif event.key in (K_5, K_KP5):
                    game.player_input += "5"
                elif event.key in (K_6, K_KP6):
                    game.player_input += "6"
                elif event.key in (K_7, K_KP7):
                    game.player_input += "7"
                elif event.key in (K_8, K_KP8):
                    game.player_input += "8"
                elif event.key in (K_9, K_KP9):
                    game.player_input += "9"
            
            # 按钮点击
            if guess_button.is_clicked(mouse_pos, event) and game.player_input and not game.game_over:
                game.player_guess(game.player_input)
                
            if reset_button.is_clicked(mouse_pos, event):
                game.reset()
        
        # 按钮悬停效果
        guess_button.check_hover(mouse_pos)
        reset_button.check_hover(mouse_pos)
        
        # AI回合
        if not game.player_turn and not game.game_over:
            if game.ai_thinking > 0:
                game.ai_thinking -= 1
            else:
                game.ai_guess()
        
        # 绘制游戏
        draw_game()
        
        # 更新屏幕
        pygame.display.flip()
        clock.tick(60)
    

    游戏说明

    这个"人机大战:数字对决"游戏具有以下特点:

    游戏规则

    1. 玩家和AI各自在1-100之间选择一个秘密数字
    2. 玩家和AI轮流猜测对方的数字
    3. 每次猜测后会得到"太大"或"太小"的提示
    4. 率先猜中对方数字的一方获胜

    游戏界面

    • 左侧为玩家区域,显示玩家的秘密数字和猜测历史
    • 右侧为AI区域,显示AI的猜测历史
    • 中央是输入框和控制按钮
    • 顶部显示游戏状态和提示信息
    • 底部有分析进度条显示双方的分析进度

    操作方式

    1. 在输入框中输入1-100之间的数字
    2. 点击"猜数字"按钮或按回车键提交猜测
    3. 游戏结束后点击"重新开始"按钮开始新游戏

    技术特点

    • AI使用二分搜索算法,但加入了随机性使其不那么完美
    • 精美的星空背景和现代化的UI设计
    • 清晰的游戏状态提示和历史记录
    • 响应式按钮和输入框设计

    运行要求

    • Python 3.x
    • Pygame库(可通过pip install pygame安装)

    这个游戏展示了人机对战的核心概念,玩家需要运用逻辑推理来猜测AI的数字,同时AI也在不断分析玩家的数字。游戏界面设计现代且直观,提供了良好的游戏体验。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.