pyrtugues

Posted on Oct 11

Criando um dragão em Pyrtugues

#python #gamedev #beginners #tutorial

Criando um dragão que segue o mouse com Pyrtugues e Pygame 🐉

Já imaginou criar um jogo usando comandos de programação em português?

Neste tutorial, vamos criar um pequeno projeto gráfico com Pyrtugues e Pygame: um dragão esmeralda que segue o mouse, com corpo sinuoso, asas roxas, chifres dourados e olhos brilhantes. ✨

A ideia é aprender programação fazendo algo visual, sem depender de imagens prontas. O dragão será desenhado usando formas geométricas, cores e coordenadas.

🐍 O que é o Pyrtugues?

O Pyrtugues é um projeto educacional de programação baseado na lógica do Python. Ele permite escrever código com comandos em português e traduzi-lo para Python.

Por exemplo:

mostrar("Olá, mundo!")

É traduzido para:

print("Olá, mundo!")

Isso permite aprender conceitos de programação em português enquanto você acompanha como eles aparecem no Python.

🎮 O que vamos criar?

Nosso projeto terá:

Um dragão verde com detalhes brilhantes.
Um corpo que acompanha o caminho percorrido pelo mouse.
Asas roxas e espinhos ao longo do corpo.
Olhos dourados e chifres.
Um céu escuro com estrelas.
Um controle simples para fechar a janela.

Tudo será desenhado pelo Pygame, então não precisamos baixar sprites ou imagens externas.

🛠️ Antes de começar

Este exemplo é voltado à versão Desktop do Pyrtugues, utilizando a integração com Pygame.

Você pode encontrar o código-fonte e as instruções de instalação no repositório oficial do Pyrtugues.

A disponibilidade dos recursos pode variar conforme a versão do tradutor e o ambiente. O exemplo utiliza os aliases de Pygame documentados no código do projeto.

💻 Código completo

Crie um arquivo de código no Pyrtugues Desktop e experimente o seguinte exemplo:

importar jogo

jogo.iniciar()

janela = jogo.display.criar_janela((1000, 700))
jogo.display.definir_título("Dragão Esmeralda — Pyrtugues")

relogio = jogo.tempo.relógio()

x, y = jogo.mouse.posição()

# Criamos os pontos iniciais do corpo.
rastro = []

para i em intervalo(130):
    rastro.adicionar((x - i * 3, y))

# Estrelas fixas no fundo.
estrelas = [
    (38, 45), (120, 90), (210, 55), (310, 120),
    (430, 65), (540, 100), (650, 45), (750, 115),
    (870, 70), (960, 140), (80, 220), (190, 300),
    (340, 250), (500, 190), (680, 280), (820, 220),
    (930, 350), (100, 460), (260, 520), (430, 610),
    (600, 520), (770, 600), (900, 500), (970, 610)
]

executando = verdadeiro

enquanto executando:

    # Verificamos os eventos da janela.
    para evento em jogo.eventos.obter():

        se evento.type == jogo.sair_evento:
            executando = falso

        se evento.type == jogo.tecla_pressionada_evento e evento.key == jogo.esc:
            executando = falso

    # Posição atual do mouse.
    x, y = jogo.mouse.posição()

    # Adicionamos posições ao rastro quando o mouse se move.
    antigo_x, antigo_y = rastro[0]

    dx = x - antigo_x
    dy = y - antigo_y

    se dx * dx + dy * dy >= 9:
        rastro.inserir(0, (x, y))
        rastro = rastro[:130]

    # Fundo noturno.
    janela.preencher((8, 12, 29))

    # Estrelas do cenário.
    para estrela em estrelas:
        jogo.desenho.círculo(
            janela,
            (100, 160, 210),
            estrela,
            2
        )

    # Desenhamos as asas atrás do corpo.
    asa_x, asa_y = rastro[18]

    # Asa superior: contorno e membrana.
    jogo.desenho.polígono(
        janela,
        (7, 22, 45),
        [
            (asa_x, asa_y),
            (asa_x - 14, asa_y - 19),
            (asa_x - 38, asa_y - 49),
            (asa_x - 36, asa_y - 17),
            (asa_x - 55, asa_y - 29),
            (asa_x - 38, asa_y + 2),
            (asa_x - 10, asa_y + 8)
        ]
    )

    jogo.desenho.polígono(
        janela,
        (116, 64, 184),
        [
            (asa_x - 5, asa_y - 3),
            (asa_x - 14, asa_y - 19),
            (asa_x - 34, asa_y - 39),
            (asa_x - 31, asa_y - 14),
            (asa_x - 46, asa_y - 21),
            (asa_x - 32, asa_y + 1)
        ]
    )

    # Asa inferior.
    jogo.desenho.polígono(
        janela,
        (7, 22, 45),
        [
            (asa_x, asa_y),
            (asa_x - 14, asa_y + 19),
            (asa_x - 38, asa_y + 49),
            (asa_x - 36, asa_y + 17),
            (asa_x - 55, asa_y + 29),
            (asa_x - 38, asa_y - 2),
            (asa_x - 10, asa_y - 8)
        ]
    )

    jogo.desenho.polígono(
        janela,
        (91, 49, 157),
        [
            (asa_x - 5, asa_y + 3),
            (asa_x - 14, asa_y + 19),
            (asa_x - 34, asa_y + 39),
            (asa_x - 31, asa_y + 14),
            (asa_x - 46, asa_y + 21),
            (asa_x - 32, asa_y - 1)
        ]
    )

    # Corpo sinuoso: desenhamos da cauda até a cabeça.
    # A largura aumenta conforme nos aproximamos da cabeça.
    para i em intervalo(120, 0, -1):

        corpo_x, corpo_y = rastro[i]
        proximo_x, proximo_y = rastro[i - 1]

        largura = 8 + (120 - i) // 5

        # Contorno escuro.
        jogo.desenho.linha(
            janela,
            (5, 31, 43),
            (corpo_x, corpo_y),
            (proximo_x, proximo_y),
            largura + 8
        )

        # Corpo esmeralda.
        jogo.desenho.linha(
            janela,
            (25, 170, 112),
            (corpo_x, corpo_y),
            (proximo_x, proximo_y),
            largura
        )

        # Reflexo verde-claro.
        jogo.desenho.linha(
            janela,
            (108, 255, 192),
            (corpo_x, corpo_y),
            (proximo_x, proximo_y),
            2
        )

    # Escamas brilhantes.
    para i em intervalo(10, 112, 10):

        escama_x, escama_y = rastro[i]

        jogo.desenho.círculo(
            janela,
            (153, 255, 192),
            (escama_x, escama_y - 6),
            3
        )

        jogo.desenho.círculo(
            janela,
            (231, 244, 153),
            (escama_x, escama_y - 6),
            1
        )

    # Espinhos ao longo das costas.
    para i em intervalo(20, 110, 18):

        espinho_x, espinho_y = rastro[i]

        jogo.desenho.polígono(
            janela,
            (5, 52, 54),
            [
                (espinho_x, espinho_y - 20),
                (espinho_x - 9, espinho_y - 2),
                (espinho_x + 9, espinho_y - 2)
            ]
        )

        jogo.desenho.polígono(
            janela,
            (93, 255, 165),
            [
                (espinho_x, espinho_y - 15),
                (espinho_x - 5, espinho_y - 4),
                (espinho_x + 5, espinho_y - 4)
            ]
        )

    # Pequenas partículas mágicas pelo caminho.
    para i em intervalo(8, 100, 23):

        brilho_x, brilho_y = rastro[i]

        jogo.desenho.círculo(
            janela,
            (100, 255, 230),
            (brilho_x, brilho_y + 13),
            2
        )

    # Cabeça: base escura.
    jogo.desenho.círculo(
        janela,
        (5, 28, 37),
        (x - 2, y - 1),
        24
    )

    # Formato externo da cabeça.
    jogo.desenho.polígono(
        janela,
        (5, 36, 43),
        [
            (x - 22, y - 14),
            (x - 8, y - 23),
            (x + 13, y - 18),
            (x + 24, y - 8),
            (x + 37, y - 5),
            (x + 30, y + 7),
            (x + 12, y + 10),
            (x - 10, y + 7),
            (x - 22, y + 3)
        ]
    )

    # Cor principal da cabeça.
    jogo.desenho.polígono(
        janela,
        (38, 205, 125),
        [
            (x - 17, y - 12),
            (x - 7, y - 18),
            (x + 11, y - 14),
            (x + 20, y - 7),
            (x + 31, y - 5),
            (x + 25, y + 2),
            (x + 10, y + 5),
            (x - 8, y + 4),
            (x - 17, y)
        ]
    )

    # Chifres dourados.
    jogo.desenho.polígono(
        janela,
        (239, 191, 81),
        [
            (x - 15, y - 15),
            (x - 23, y - 34),
            (x - 5, y - 20)
        ]
    )

    jogo.desenho.polígono(
        janela,
        (255, 224, 130),
        [
            (x - 13, y - 19),
            (x - 20, y - 30),
            (x - 9, y - 21)
        ]
    )

    jogo.desenho.polígono(
        janela,
        (239, 191, 81),
        [
            (x - 4, y - 17),
            (x + 2, y - 35),
            (x + 8, y - 15)
        ]
    )

    # Olho dourado e pupila.
    jogo.desenho.círculo(
        janela,
        (255, 221, 110),
        (x + 10, y - 10),
        6
    )

    jogo.desenho.círculo(
        janela,
        (12, 25, 32),
        (x + 12, y - 10),
        3
    )

    jogo.desenho.círculo(
        janela,
        (255, 255, 255),
        (x + 11, y - 12),
        1
    )

    # Narinas e boca.
    jogo.desenho.círculo(
        janela,
        (5, 52, 48),
        (x + 25, y - 5),
        2
    )

    jogo.desenho.círculo(
        janela,
        (5, 52, 48),
        (x + 30, y - 3),
        2
    )

    jogo.desenho.linha(
        janela,
        (5, 52, 48),
        (x + 12, y + 5),
        (x + 27, y + 4),
        3
    )

    # Mantém a animação fluida.
    relogio.marcar_fps(60)

    jogo.display.atualizar_tela()

jogo.sair()

🧠 Como o dragão segue o mouse?

A parte mais importante é o rastro.

se dx * dx + dy * dy >= 9:
    rastro.inserir(0, (x, y))
    rastro = rastro[:130]

Cada vez que o mouse se desloca o suficiente, guardamos a nova posição no começo da lista. As posições antigas continuam atrás dela.

Depois, o código desenha linhas entre esses pontos. Como o corpo é desenhado da cauda para a cabeça, podemos aumentar sua largura conforme nos aproximamos do cursor.

É isso que cria a sensação de um dragão serpentino acompanhando o movimento, em vez de uma figura estática que apenas muda de posição.

🐍 O que o Pyrtugues traduz?

O código usa aliases documentados no projeto para operações do Pygame. Por exemplo:

Pyrtugues	Pygame
`jogo.iniciar()`	`pygame.init()`
`jogo.display.criar_janela()`	`pygame.display.set_mode()`
`jogo.mouse.posição()`	`pygame.mouse.get_pos()`
`jogo.desenho.círculo()`	`pygame.draw.circle()`
`jogo.desenho.linha()`	`pygame.draw.line()`
`jogo.display.atualizar_tela()`	`pygame.display.flip()`

O objetivo é manter a lógica de programação próxima do Python, permitindo escrever comandos em português e observar suas correspondências.

Você pode consultar os aliases e a implementação na documentação e no código do Pyrtugues.

🚀 Ideias para continuar

Agora que temos o dragão seguindo o mouse, existem várias formas de evoluir o projeto:

Fazer as asas baterem durante o movimento.
Adicionar partículas de fogo pela boca.
Criar obstáculos e colisões.
Fazer o dragão perseguir um objeto.
Adicionar sons e música.
Criar pontos e uma pontuação.

Cada melhoria pode ensinar um novo conceito, como animação, eventos, condições, colisões ou controle de tempo.

📚 Conheça o Pyrtugues

🐙 GitHub: https://github.com/pyrtugues/Pyrtugues

🌐 Site de apresentação: https://pyrtugues-apre.pages.dev/

📚 Curso: https://pyrtugues.pages.dev/

💻 Editor Web: https://pyrtugues-editor.pages.dev/

🧩 Extensão para VS Code: https://open-vsx.org/extension/pyrtugues/pyrtugues

O Pyrtugues é um projeto educacional em evolução. Consulte a documentação e a licença oficial antes de utilizar o projeto.

Programar não precisa começar com uma barreira de idioma. Você pode começar com uma ideia, transformá-la em código e aprender cada vez mais enquanto constrói.

Qual criatura você criaria com Pyrtugues? 🐉💚

python #pygame #beginners #programming

DEV Community