GUI python e desenvolvimento de jogos_day010

interface gráfica de usuário python e desenvolvimento de jogos_day010

2024-07-12

interface gráfica de usuário python e desenvolvimento de jogos

GUI baseada no módulo tkinter
Desenvolvimento de jogos usando Pygame

GUI baseada no módulo tkinter

GUI é a abreviatura de Graphical User Interface. Qualquer pessoa que tenha usado um computador deve estar familiarizada com a interface gráfica do usuário, portanto não há necessidade de entrar em detalhes aqui. O módulo de desenvolvimento GUI padrão do Python é tkinter (chamado Tkinter em versões anteriores ao Python 3). A partir desse nome, você pode dizer que ele é baseado em Tk é um kit de ferramentas que foi originalmente projetado para Tcl e posteriormente portado para muitos outros scripts. linguagens, ele fornece controles GUI multiplataforma. Claro, Tk não é a melhor e mais recente escolha e não possui controles GUI particularmente poderosos. Na verdade, desenvolver aplicativos GUI não é o que o Python faz melhor. Se você realmente precisa usar Python para desenvolver aplicativos GUI, wxPython. Módulos PyQt, PyGTK, etc. são uma boa escolha.

Basicamente, usar o tkinter para desenvolver aplicativos GUI requer as 5 etapas a seguir:

Importe o que precisamos no módulo tkinter.
Crie um objeto de janela de nível superior e use-o para hospedar todo o aplicativo GUI.
Adicione componentes GUI ao objeto de janela de nível superior.
As funções desses componentes GUI são organizadas por meio de código.
Entre no loop de eventos principal (loop principal).

O código a seguir demonstra como usar o tkinter para criar um aplicativo GUI simples.

import tkinter
import tkinter.messagebox


def main():
    flag = True

    # 修改标签上的文字
    def change_label_text():
        nonlocal flag
        flag = not flag
        color, msg = ('red', 'Hello, world!')
            if flag else ('blue', 'Goodbye, world!')
        label.config(text=msg, fg=color)

    # 确认退出
    def confirm_to_quit():
        if tkinter.messagebox.askokcancel('温馨提示', '确定要退出吗?'):
            top.quit()

    # 创建顶层窗口
    top = tkinter.Tk()
    # 设置窗口大小
    top.geometry('240x160')
    # 设置窗口标题
    top.title('小游戏')
    # 创建标签对象并添加到顶层窗口
    label = tkinter.Label(top, text='Hello, world!', font='Arial -32', fg='red')
    label.pack(expand=1)
    # 创建一个装按钮的容器
    panel = tkinter.Frame(top)
    # 创建按钮对象 指定添加到哪个容器中 通过command参数绑定事件回调函数
    button1 = tkinter.Button(panel, text='修改', command=change_label_text)
    button1.pack(side='left')
    button2 = tkinter.Button(panel, text='退出', command=confirm_to_quit)
    button2.pack(side='right')
    panel.pack(side='bottom')
    # 开启主事件循环
    tkinter.mainloop()


if __name__ == '__main__':
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

Deve-se notar que os aplicativos GUI geralmente são orientados a eventos. O motivo para entrar no loop de eventos principal é monitorar a ocorrência de vários eventos, como mouse e teclado, e executar o código correspondente para processar os eventos, porque os eventos continuarão a ocorrer. . Portanto, esse loop precisa estar em execução o tempo todo, aguardando a ocorrência do próximo evento. Por outro lado, Tk fornece três gerenciadores de layout para a colocação de controles que podem ser posicionados através dos gerenciadores de layout.Placer(O desenvolvedor fornece o tamanho e o posicionamento do controle),Packer(preencher automaticamente os controles nas posições apropriadas) eGrid(Coloque os controles com base nas coordenadas da grade), que não serão descritos aqui.

Desenvolvimento de jogos usando Pygame

Pygame é um módulo Python de código aberto usado especificamente para o desenvolvimento de aplicações multimídia (como videogames), que inclui suporte para imagens, sons, vídeos, eventos, colisões, etc. Pygame é construído em SDL, que é um conjunto de bibliotecas de desenvolvimento multimídia multiplataforma implementadas em linguagem C e amplamente utilizadas no desenvolvimento de jogos, simuladores, jogadores, etc. Pygame permite que os desenvolvedores de jogos não fiquem mais vinculados à linguagem subjacente e possam se concentrar mais nas funções e na lógica do jogo.

Agora vamos completar um jogo simples. O nome do jogo é "Big Ball Eats Small Ball". Claro, aprender a usar o Pygame também não é o foco. entenda como usar as etapas anteriores do processo. Explique a programação orientada a objetos e aprenda a usar essa ideia de programação para resolver problemas da vida real.

import pygame


def main():
    # 初始化导入的pygame中的模块
    pygame.init()
    # 初始化用于显示的窗口并设置窗口尺寸
    screen = pygame.display.set_mode((800, 600))
    # 设置当前窗口的标题
    pygame.display.set_caption('大球吃小球')
    running = True
    # 开启一个事件循环处理发生的事件
    while running:
        # 从消息队列中获取事件并对事件进行处理
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False


if __name__ == '__main__':
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Desenhar na janela

Você pode desenhar na janela através da função do módulo draw no pygame. Os gráficos que podem ser desenhados incluem: linhas, retângulos, polígonos, círculos, elipses, arcos, etc. Deve-se notar que o sistema de coordenadas da tela define o canto superior esquerdo da tela como a origem da coordenada (0, 0). Para a direita está a direção positiva do eixo x e para baixo está a direção positiva do eixo y. eixo Ao expressar a posição ou definir o tamanho, nossas unidades padrão são pixels. O chamado pixel é um ponto na tela. Você pode usar um software de navegação de imagens para tentar ampliar uma imagem várias vezes para ver esses pontos. A representação de cores em pygame utiliza o método de representação de três cores primárias, ou seja, o valor RGB da cor é especificado através de uma tupla ou lista. Cada valor está entre 0 e 255, pois cada cor primária utiliza um valor de 8 bits (bit). Para representar o valor, as três cores equivalem a um total de 24 bits, o que costuma ser chamado de "representação de cores de 24 bits".

import pygame


def main():
    # 初始化导入的pygame中的模块
    pygame.init()
    # 初始化用于显示的窗口并设置窗口尺寸
    screen = pygame.display.set_mode((800, 600))
    # 设置当前窗口的标题
    pygame.display.set_caption('大球吃小球')
    # 设置窗口的背景色(颜色是由红绿蓝三原色构成的元组)
    screen.fill((242, 242, 242))
    # 绘制一个圆(参数分别是: 屏幕, 颜色, 圆心位置, 半径, 0表示填充圆)
    pygame.draw.circle(screen, (255, 0, 0,), (100, 100), 30, 0)
    # 刷新当前窗口(渲染窗口将绘制的图像呈现出来)
    pygame.display.flip()
    running = True
    # 开启一个事件循环处理发生的事件
    while running:
        # 从消息队列中获取事件并对事件进行处理
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False


if __name__ == '__main__':
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Carregar imagem

Se precisar carregar a imagem diretamente na janela, você pode usar a função do módulo de imagem no pygame para carregar a imagem e, em seguida, renderizar a imagem através do método blit do objeto de janela obtido anteriormente.

import pygame


def main():
    # 初始化导入的pygame中的模块
    pygame.init()
    # 初始化用于显示的窗口并设置窗口尺寸
    screen = pygame.display.set_mode((800, 600))
    # 设置当前窗口的标题
    pygame.display.set_caption('大球吃小球')
    # 设置窗口的背景色(颜色是由红绿蓝三原色构成的元组)
    screen.fill((255, 255, 255))
    # 通过指定的文件名加载图像
    ball_image = pygame.image.load('./res/ball.png')
    # 在窗口上渲染图像
    screen.blit(ball_image, (50, 50))
    # 刷新当前窗口(渲染窗口将绘制的图像呈现出来)
    pygame.display.flip()
    running = True
    # 开启一个事件循环处理发生的事件
    while running:
        # 从消息队列中获取事件并对事件进行处理
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False


if __name__ == '__main__':
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

Obtenha efeitos de animação

Quando se trata da palavra animação, todos a conhecem. Na verdade, para obter efeitos de animação, o princípio em si é muito simples, que é reproduzir imagens descontínuas continuamente, desde que seja atingido um certo número de quadros por segundo. então isso pode ser feito. Produza um efeito de animação mais suave. Se quiser que a bola no código acima se mova, você pode usar uma variável para representar a posição da bola, modificar a posição da bola no loop e, em seguida, atualizar a janela inteira.

import pygame


def main():
    # 初始化导入的pygame中的模块
    pygame.init()
    # 初始化用于显示的窗口并设置窗口尺寸
    screen = pygame.display.set_mode((800, 600))
    # 设置当前窗口的标题
    pygame.display.set_caption('大球吃小球')
    # 定义变量来表示小球在屏幕上的位置
    x, y = 50, 50
    running = True
    # 开启一个事件循环处理发生的事件
    while running:
        # 从消息队列中获取事件并对事件进行处理
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
        screen.fill((255, 255, 255))
        pygame.draw.circle(screen, (255, 0, 0,), (x, y), 30, 0)
        pygame.display.flip()
        # 每隔50毫秒就改变小球的位置再刷新窗口
        pygame.time.delay(50)
        x, y = x + 5, y + 5


if __name__ == '__main__':
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

Verificação de impacto

Normalmente haverá muitos objetos em um jogo, e a "colisão" entre esses objetos é inevitável, como uma bala de canhão atingindo um avião, uma caixa atingindo o solo, etc. A detecção de colisão é uma questão crucial que deve ser tratada na maioria dos jogos. O módulo sprite (sprite animado) do pygame fornece suporte para detecção de colisão. Não apresentaremos as funções fornecidas pelo módulo sprite aqui. detectar se duas bolas pequenas colidem Você só precisa verificar se a distância entre os centros das bolas é menor que a soma dos raios das duas bolas. Para criar mais bolas pequenas, podemos processar eventos do mouse para criar pequenas bolas com cores, tamanhos e velocidades de movimento aleatórios no local onde o mouse é clicado. Claro, para fazer isso, podemos usar o que aprendemos antes de Aplicar. conhecimento orientado a objetos.

Manipulação de eventos

Os eventos do mouse podem ser processados no loop de eventos. O tipo de evento pode ser determinado através do atributo type do objeto de evento, e a posição do clique do mouse pode ser obtida através do atributo pos. Se você deseja manipular eventos de teclado, este também é o lugar. O método é semelhante ao tratamento de eventos de mouse.

def main():
    # 定义用来装所有球的容器
    balls = []
    # 初始化导入的pygame中的模块
    pygame.init()
    # 初始化用于显示的窗口并设置窗口尺寸
    screen = pygame.display.set_mode((800, 600))
    # 设置当前窗口的标题
    pygame.display.set_caption('大球吃小球')
    running = True
    # 开启一个事件循环处理发生的事件
    while running:
        # 从消息队列中获取事件并对事件进行处理
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            # 处理鼠标事件的代码
            if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
                # 获得点击鼠标的位置
                x, y = event.pos
                radius = randint(10, 100)
                sx, sy = randint(-10, 10), randint(-10, 10)
                color = Color.random_color()
                # 在点击鼠标的位置创建一个球(大小、速度和颜色随机)
                ball = Ball(x, y, radius, sx, sy, color)
                # 将球添加到列表容器中
                balls.append(ball)
        screen.fill((255, 255, 255))
        # 取出容器中的球 如果没被吃掉就绘制 被吃掉了就移除
        for ball in balls:
            if ball.alive:
                ball.draw(screen)
            else:
                balls.remove(ball)
        pygame.display.flip()
        # 每隔50毫秒就改变球的位置再刷新窗口
        pygame.time.delay(50)
        for ball in balls:
            ball.move(screen)
            # 检查球有没有吃到其他的球
            for other in balls:
                ball.eat(other)


if __name__ == '__main__':
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

Juntando os dois trechos de código acima, concluímos o jogo "bola grande come bola pequena" (como mostrado na imagem abaixo, não é um jogo, mas passamos o conhecimento básico de como fazer um). pequeno jogo. Este exemplo diz a todos que com esse conhecimento você pode iniciar sua jornada de desenvolvimento de minijogos. Na verdade, há muitas áreas que valem a pena melhorar no código acima. Por exemplo, o código para atualizar a janela e mover a bola não deve ser colocado no loop de eventos. Depois de aprender o conhecimento de multithreading, é possível usá-lo. um thread em segundo plano para lidar com essas coisas é uma escolha melhor. Se quisermos obter uma melhor experiência do usuário, também podemos adicionar música de fundo ao jogo e reproduzir efeitos sonoros quando a bola colide com a bola. Usando o mixer e os módulos de música do pygame, podemos fazer isso facilmente. esse. Na verdade, se você quiser saber mais sobre o pygame, o melhor tutorial é o site oficial do pygame. Se você não tem problemas com o inglês, pode dar uma olhada. Se você deseja desenvolver jogos 3D, o pygame parece ser insuficiente. Os leitores interessados no desenvolvimento de jogos 3D podem dar uma olhada no Panda3D.

Compartilhamento de tecnologia