如何用deepseek写游戏（思路教程分享）【附图文】

先看成品《用Python+PyGame开发双人生存游戏！源码解析+完整开发思路分享》-CSDN博客

总计四百多行，以前自己写个这种类吸血鬼的游戏要一整天，现在只需要一小时即可。

1.先对自己的环境进行确认

2.对他说出你想做的游戏

 3.让他在这基础上修改

4.如果你自己没有思路，还可以提问，让他来给出意见

 5.在这个基础上不断的修改

 在这基础上不断地修改，例如加入双人模式，精英怪经验条等需求。

最后就可以得到这样一个游戏
代码如下

# -*- coding: utf-8 -*-
import os
import pygame
import random
import math
from datetime import datetime

# 初始化路径
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
IMAGE_DIR = os.path.join(BASE_DIR, 'image')

RESOURCES = {
    'role1': os.path.join(IMAGE_DIR, 'role1.png'),
    'role2': os.path.join(IMAGE_DIR, 'role2.png'),
    'enemy': os.path.join(IMAGE_DIR, 'enemy.png'),
    'bullet': os.path.join(IMAGE_DIR, 'bullet.png'),
    'exp_orb': os.path.join(IMAGE_DIR, 'exp_orb.png'),
    'background': os.path.join(IMAGE_DIR, 'background.png')
}

pygame.init()
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
clock = pygame.time.Clock()

# 颜色定义
WHITE = (255, 255, 255)
GRAY = (100, 100, 100)
BUTTON_COLOR = (50, 150, 50)
HOVER_COLOR = (70, 170, 70)
RED = (255, 0, 0)
YELLOW = (255, 255, 0)

font = pygame.font.Font(None, 24)

def load_image(path, default_size=(30, 30)):
    try:
        image = pygame.image.load(path).convert_alpha()
        return pygame.transform.scale(image, default_size)
    except:
        surf = pygame.Surface(default_size)
        surf.fill(RED)
        return surf

GAME_IMAGES = {
    'role1': load_image(RESOURCES['role1']),
    'role2': load_image(RESOURCES['role2']),
    'enemy': load_image(RESOURCES['enemy'], (20, 20)),
    'bullet': load_image(RESOURCES['bullet'], (10, 10)),
    'exp_orb': load_image(RESOURCES['exp_orb'], (10, 10)),
    'background': load_image(RESOURCES['background'], (WIDTH, HEIGHT))
}

class Button:
    def __init__(self, text, x, y, w, h):
        self.rect = pygame.Rect(x, y, w, h)
        self.text = text
        self.color = BUTTON_COLOR
        self.hover = False

    def draw(self, surface):
        color = HOVER_COLOR if self.hover else BUTTON_COLOR
        pygame.draw.rect(surface, color, self.rect, border_radius=5)
        text_surf = font.render(self.text, True, WHITE)
        text_rect = text_surf.get_rect(center=self.rect.center)
        surface.blit(text_surf, text_rect)

    def check_hover(self, mouse_pos):
        self.hover = self.rect.collidepoint(mouse_pos)

class Player(pygame.sprite.Sprite):
    def __init__(self, controls, role_type, pos_offset=0, is_player2=False):
        pygame.sprite.Sprite.__init__(self)
        self.role_type = role_type
        self.image = GAME_IMAGES['role2' if role_type == 2 else 'role1']
        self.rect = self.image.get_rect(center=(WIDTH//2 + pos_offset, HEIGHT//2))
        self.speed = 5
        self.health = 100
        self.exp = 0
        self.level = 1
        self.max_exp = 100
        self.kills = 0
        self.controls = controls

    def update(self, keys):
        if keys[self.controls['up']]:
            self.rect.y -= self.speed
        if keys[self.controls['down']]:
            self.rect.y += self.speed
        if keys[self.controls['left']]:
            self.rect.x -= self.speed
        if keys[self.controls['right']]:
            self.rect.x += self.speed
        self.rect.clamp_ip(screen.get_rect())

    def get_attack_directions(self):
        if self.role_type == 1:
            return ["up", "down", "left", "right"]
        else:
            return ["up_left", "up_right", "down_left", "down_right"]

class Bullet(pygame.sprite.Sprite):
    def __init__(self, x, y, direction):
        pygame.sprite.Sprite.__init__(self)
        self.image = GAME_IMAGES['bullet']
        self.rect = self.image.get_rect(center=(x, y))
        self.speed = 8
        self.start_pos = (x, y)
        self.max_distance = 300
        self.penetration = 2

        self.dx, self.dy = 0, 0
        dir_mapping = {
            "up": (0, -1),
            "down": (0, 1),
            "left": (-1, 0),
            "right": (1, 0),
            "up_left": (-math.sqrt(0.5), -math.sqrt(0.5)),
            "up_right": (math.sqrt(0.5), -math.sqrt(0.5)),
            "down_left": (-math.sqrt(0.5), math.sqrt(0.5)),
            "down_right": (math.sqrt(0.5), math.sqrt(0.5))
        }
        dx_mult, dy_mult = dir_mapping[direction]
        self.dx = dx_mult * self.speed
        self.dy = dy_mult * self.speed

    def update(self):
        self.rect.x += self.dx
        self.rect.y += self.dy
        if math.hypot(self.rect.x - self.start_pos[0], self.rect.y - self.start_pos[1]) > self.max_distance:
            self.kill()

class Enemy(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = GAME_IMAGES['enemy']
        self.rect = self.image.get_rect(
            center=(random.choice([-100, WIDTH+100]), random.randint(0, HEIGHT))
        )
        self.speed = 2

    def update(self, targets):
        if not targets: return
        nearest = min(targets, key=lambda t: math.hypot(t.rect.x-self.rect.x, t.rect.y-self.rect.y))
        dx = nearest.rect.x - self.rect.x
        dy = nearest.rect.y - self.rect.y
        dist = math.hypot(dx, dy)
        if dist != 0:
            self.rect.x += dx / dist * self.speed
            self.rect.y += dy / dist * self.speed

class ExpOrb(pygame.sprite.Sprite):
    def __init__(self, x, y):
        pygame.sprite.Sprite.__init__(self)
        self.image = GAME_IMAGES['exp_orb']
        self.rect = self.image.get_rect(center=(x, y))
        self.float_timer = 0

    def update(self):
        self.float_timer += 1
        self.rect.y += math.sin(self.float_timer * 0.1) * 0.5

def draw_hud(surface, players, time_left):
    time_text = font.render("Time: {:02}:{:02}".format(time_left//60, time_left%60), True, WHITE)
    surface.blit(time_text, (WIDTH//2 - 60, 10))
    
    for i, player in enumerate(players):
        y_offset = 40 + i*80
        pygame.draw.rect(surface, GRAY, (10, y_offset, 100, 10))
        health_width = int((player.health / 100.0) * 100)
        pygame.draw.rect(surface, RED, (10, y_offset, health_width, 10))
        
        pygame.draw.rect(surface, GRAY, (10, y_offset+20, 100, 10))
        exp_width = int((player.exp / float(player.max_exp)) * 100)
        pygame.draw.rect(surface, YELLOW, (10, y_offset+20, exp_width, 10))
        
        info_text = font.render("P{} Lv{} K{}".format(i+1, player.level, player.kills), True, WHITE)
        surface.blit(info_text, (10, y_offset+40))

def role_selection_menu(player_count):
    roles = []
    buttons = []
    descriptions = [
        "Role 1: 4-Direction Attack",
        "Role 2: Diagonal Attack"
    ]
    
    for i in range(player_count):
        y_base = 150 + i*150
        buttons.append([
            Button("Player{} Role1".format(i+1), WIDTH//2-250, y_base, 200, 50),
            Button("Player{} Role2".format(i+1), WIDTH//2+50, y_base, 200, 50)
        ])
    
    confirm_btn = Button("Start Game", WIDTH//2-100, HEIGHT-100, 200, 50)
    
    while True:
        screen.fill((30, 30, 30))
        mouse_pos = pygame.mouse.get_pos()
        
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                return []
            if event.type == pygame.MOUSEBUTTONDOWN:
                for i, pair in enumerate(buttons):
                    for j, btn in enumerate(pair):
                        if btn.rect.collidepoint(mouse_pos):
                            if len(roles) <= i:
                                roles.append(j+1)
                            else:
                                roles[i] = j+1
                if confirm_btn.rect.collidepoint(mouse_pos) and len(roles) == player_count:
                    return roles
        
        desc_y = 100
        for desc in descriptions:
            text = font.render(desc, True, WHITE)
            screen.blit(text, (WIDTH//2 - text.get_width()//2, desc_y))
            desc_y += 30
        
        for i, pair in enumerate(buttons):
            for j, btn in enumerate(pair):
                btn.check_hover(mouse_pos)
                btn.draw(screen)
                if i < len(roles) and roles[i] == j+1:
                    pygame.draw.rect(screen, YELLOW, btn.rect.inflate(10,10), 3, border_radius=7)
        
        confirm_btn.check_hover(mouse_pos)
        confirm_btn.draw(screen)
        
        pygame.display.flip()
        clock.tick(30)

def main_menu():
    buttons = [
        Button("1 Player", WIDTH//2-100, HEIGHT//2-50, 200, 50),
        Button("2 Players", WIDTH//2-100, HEIGHT//2+20, 200, 50)
    ]
    
    while True:
        screen.fill((30, 30, 30))
        mouse_pos = pygame.mouse.get_pos()
        
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                return (0, [])
            if event.type == pygame.MOUSEBUTTONDOWN:
                for i, btn in enumerate(buttons):
                    if btn.rect.collidepoint(mouse_pos):
                        selected = i+1
                        roles = role_selection_menu(selected)
                        if roles:
                            return (selected, roles)
        
        title = font.render("Vampire Survivors", True, WHITE)
        screen.blit(title, (WIDTH//2 - title.get_width()//2, 100))
        
        for btn in buttons:
            btn.check_hover(mouse_pos)
            btn.draw(screen)
        
        pygame.display.flip()
        clock.tick(30)

def game_loop(player_count, roles):
    background = GAME_IMAGES['background']
    controls = [
        {'up': pygame.K_w, 'down': pygame.K_s, 'left': pygame.K_a, 'right': pygame.K_d},
        {'up': pygame.K_UP, 'down': pygame.K_DOWN, 'left': pygame.K_LEFT, 'right': pygame.K_RIGHT}
    ]
    
    players = pygame.sprite.Group()
    for i in range(player_count):
        player = Player(
            controls=controls[i],
            role_type=roles[i],
            pos_offset=-50 + i*100,
            is_player2=(i==1)
        )
        players.add(player)
    
    all_sprites = pygame.sprite.Group(players)
    enemies = pygame.sprite.Group()
    bullets = pygame.sprite.Group()
    exp_orbs = pygame.sprite.Group()
    
    enemy_spawn_timer = 0
    attack_timer = 0
    start_ticks = pygame.time.get_ticks()
    time_limit = 300

    running = True
    while running:
        screen.blit(background, (0, 0))
        keys = pygame.key.get_pressed()
        
        elapsed_seconds = (pygame.time.get_ticks() - start_ticks) // 1000
        time_left = max(time_limit - elapsed_seconds, 0)
        if time_left <= 0:
            running = False

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False

        enemy_spawn_timer += 1
        if enemy_spawn_timer >= 60 - (sum(p.level for p in players)*2):
            enemy = Enemy()
            enemies.add(enemy)
            all_sprites.add(enemy)
            enemy_spawn_timer = 0

        attack_timer += 1
        if attack_timer >= 30:
            for player in players:
                directions = player.get_attack_directions()
                for direction in directions:
                    bullet = Bullet(player.rect.centerx, player.rect.centery, direction)
                    bullets.add(bullet)
                    all_sprites.add(bullet)
            attack_timer = 0

        for player in players:
            player.update(keys)
        enemies.update(players)
        bullets.update()
        exp_orbs.update()

        for bullet in bullets:
            hits = pygame.sprite.spritecollide(bullet, enemies, False)
            if hits:
                bullet.penetration -= 1
                for enemy in hits:
                    enemy.kill()
                    exp_orb = ExpOrb(enemy.rect.centerx, enemy.rect.centery)
                    exp_orbs.add(exp_orb)
                    all_sprites.add(exp_orb)
                    for player in players:
                        if math.hypot(player.rect.x-enemy.rect.x, player.rect.y-enemy.rect.y) < 100:
                            player.kills += 1
                if bullet.penetration <= 0:
                    bullet.kill()

        for player in players:
            hits = pygame.sprite.spritecollide(player, exp_orbs, True)
            if hits:
                player.exp += 10 * len(hits)
                if player.exp >= player.max_exp:
                    player.level += 1
                    player.exp -= player.max_exp
                    player.max_exp = int(player.max_exp * 1.5)
                    player.speed += 0.5

        alive_players = [p for p in players if p.health > 0]
        for player in alive_players:
            if pygame.sprite.spritecollide(player, enemies, True):
                player.health -= 10

        if len(alive_players) == 0 or time_left <= 0:
            running = False

        all_sprites.draw(screen)
        draw_hud(screen, players, time_left)
        pygame.display.flip()
        clock.tick(30)

    pygame.quit()

if __name__ == "__main__":
    player_count, roles = main_menu()
    if player_count > 0:
        game_loop(player_count, roles) 

 仅供学习参考，用于前期快速给出框架，后续的细节可以自己来做，增加参与感