python自制小游戏

以下是一个使用pygame框架制作的2048小游戏的示例代码：

import pygame
from pygame.locals import *
import random

# 游戏界面大小
screen_width = 640
screen_height = 480

# 游戏板块大小
board_size = 4

# 游戏板块间距
gap_size = 10

# 游戏板块边框大小
border_size = 5

# 游戏板块字体大小
font_size = 32

# 游戏板块颜色
background_color = (187, 173, 160)
board_color = (205, 193, 180)
text_color = (255, 255, 255)

# 初始化pygame
pygame.init()

# 设置游戏界面
fps_clock = pygame.time.Clock()
display = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption('2048')
basic_font = pygame.font.Font('freesansbold.ttf', font_size)

# 定义游戏板块类
class Tile:
    def __init__(self, value=0):
        self.value = value

    def draw(self, x, y):
        tile_color = {
            0: (205, 193, 180),
            2: (238, 228, 218),
            4: (237, 224, 200),
            8: (242, 177, 121),
            16: (245, 149, 99),
            32: (246, 124, 95),
            64: (246, 94, 59),
            128: (237, 207, 114),
            256: (237, 204, 97),
            512: (237, 200, 80),
            1024: (237, 197, 63),
            2048: (237, 194, 46),
        }
        text_color = {
            0: (205, 193, 180),
            2: (119, 110, 101),
            4: (119, 110, 101),
            8: (249, 246, 242),
            16: (249, 246, 242),
            32: (249, 246, 242),
            64: (249, 246, 242),
            128: (249, 246, 242),
            256: (249, 246, 242),
            512: (249, 246, 242),
            1024: (249, 246, 242),
            2048: (249, 246, 242),
        }
        rect = pygame.Rect(x, y, board_size, board_size)
        pygame.draw.rect(display, tile_color[self.value], rect)
        if self.value:
            text_surface = basic_font.render(str(self.value), True, text_color[self.value])
            text_rect = text_surface.get_rect()
            text_rect.center = rect.center
            display.blit(text_surface, text_rect)

# 定义游戏板块数组类
class Board:
    def __init__(self):
        self.tiles = [[Tile() for _ in range(board_size)] for _ in range(board_size)]
        self.add_random_tile()
        self.add_random_tile()

    def add_random_tile(self):
        x, y = random.choice([(i, j) for i in range(board_size) for j in range(board_size) if self.tiles[i][j].value == 0])
        self.tiles[x][y] = Tile(2 if random.random() < 0.9 else 4)

    def transpose(self):
        self.tiles = [list(row) for row in zip(*self.tiles)]

    def invert(self):
        self.tiles = [row[::-1] for row in self.tiles]

    def move(self, direction):
        for i in range(direction):
            self.transpose()
        for i in range(len(self.tiles)):
            self.tiles[i] = self.move_row(self.tiles[i])
        for i in range(4 - direction):
            self.transpose()

    def move_row(self, row):
        def tighten(row):
            new_row = [i for i in row if i]
            new_row += [0 for i in range(len(row) - len(new_row))]
            return new_row

        def merge(row):
            pair = False
            new_row = []
            for i in range(len(row)):
                if pair:
                    new_row.append(2 * row[i])
                    pair = False
                else:
                    if i + 1 < len(row) and row[i] == row[i + 1]:
                        pair = True
                        new_row.append(0)
                    else:
                        new_row.append(row[i])
            assert len(new_row) == len(row)
            return new_row

        return tighten(merge(tighten(row)))

    def get_empty_tiles(self):
        return [(i, j) for i in range(board_size) for j in range(board_size) if self.tiles[i][j].value == 0]

    def get_max_tile(self):
        return max([max(row) for row in self.tiles])

    def draw(self):
        for i in range(board_size):
            for j in range(board_size):
                x = j * (board_size + gap_size) + border_size
                y = i * (board_size + gap_size) + border_size
                self.tiles[i][j].draw(x, y)

# 定义游戏主循环
def main():
    board = Board()
    while True:
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN:
                if event.key == K_UP:
                    board.move(0)
                elif event.key == K_RIGHT:
                    board.move(1)
                elif event.key == K_DOWN:
                    board.move(2)
                elif event.key == K_LEFT:
                    board.move(3)
                board.add_random_tile()
                if board.get_max_tile() == 2048:
                    print('You win!')
        display.fill(background_color)
        board.draw()
        pygame.display.update()
        fps_clock.tick(30)

if __name__ == '__main__':
    main()