Como não perder nenhum compromisso: Meu App Agenda

No nosso dia a dia a agenda é um instrumento de grande importância que as pessoas utilizam para fazer anotações de compromissos ou informações. Além disso, permite organizar as suas tarefas e ajuda as pessoas a não esquecerem de seus compromissos.  Também é utilizado para fazer lista de compras, lista para arrumar as malas, lista de aniversários e outros. Mas que tal construir uma agenda ou lista como um aplicativo de celular, utilizando o MIT AppInventor2?

Para iniciar essa construção sugerimos que você conheça um projeto de agenda que possui uma estrutura pronta no AppInventor2 e explore suas configurações no seguinte link: Clique Aqui. Após fazer os primeiros testes e compreender o seu funcionamento será o momento de começar a criar a sua própria Agenda ou Lista.

Quando acessamos o projeto, na aba designer, podemos perceber diversos componentes sendo utilizados, como ilustra a imagem abaixo:

O componente intitulado “LB_Título” se refere a uma caixa de texto que possui um título referente página visualizada. O componente “BTN_agenda” é um botão e utilizamos “BTN” como uma forma de abreviar o nome. Já o componente “ORG_botoes” é um organizador utilizado para posicionar os botões e utilizamos “ORG” como forma de abreviar a palavra organizador. 

Nesse projeto utilizamos um componente novo chamado “Variável Global”, com ele você pode criar uma variável para acompanhar a pontuação do jogador, um valor que pode ficar alternando, ou uma informação. Você pode criar essa variável e conforme precisar pode importar as informações ou pontuações dela sem precisar se preocupar em realmente acompanhar o que havia registrado anteriormente. 

Na tela Cadastro, você irá encontrar algumas variáveis globais. Os blocos conforme a figura abaixo, representam a definição de variáveis globais “dados”, “info” e “tags”. A primeira variável global se trata de informações escritas pelo usuário referente a caixa de título, caixa de descrição, data, e grau de prioridade. A segunda variável global pega informações armazenadas no TinyDB (componente que iremos explicar mais adiante) e importa como lista permitindo a visualização em ordem dos eventos cadastrados. A terceira variável global tem o objetivo de registrar o título do evento cadastrado.

O TinyDB é um componente que funciona como banco de dados, permitindo armazenar informações no seu aplicativo para não perde-la quando o aplicativo é fechado. Geralmente é utilizado em conjunto com as variáveis globais que contem informações registradas pelo usuário ou realiza contagens. 

Na figura abaixo podemos observar um conjunto de blocos que são responsáveis pela ação de “salvar informações”. Quando selecionado o botão “Salvar”, será reproduzido um som e todas as informações preenchidas no campo da agenda (título do evento, descrição, data e grau de prioridade) serão adicionadas em uma lista na variável global Dados e armazenados no TinyDB. Por fim você será redirecionado para a tela inicial.

O conjunto de blocos abaixo são referente a visualização dos eventos cadastrados. Quando pressionado um evento, na tela do seu aplicativo, o organizador irá se tornar visível e mostrará todos os eventos cadastrados. Em seguida irá importar todas as informações armazenadas no TinyDB anteriormente e irá organiza-las. 

Entretanto a programação, conforme a imagem abaixo, contém um bug desafio para você refazer. Sempre que selecionado um item da lista da agenda ele irá deletar o item de 1ª posição e não o item selecionado. Portanto a proposta é identificar o bloco responsável por isso e substituir por outro bloco que remova o evento selecionado na tela do celular. Dica: use um bloco que é referente ao Visualizador de Listas.

Agora que você conhece um pouco melhor sobre a programação desse aplicativo, que tal corrigir o bug mencionado acima e criar a agenda do seu próprio jeito? É possível criar lista de aniversário de seus amigos, lista de compra, lista de viagem, agenda do trabalho, agenda de estudos e outros. Faça customização na imagem de fundo, altere os sons, adicione mais variável global se necessário e construa um aplicativo que possa te ajudar no dia a dia! Finalizando, por meio desse aplicativo foi possível mobilizar conhecimentos matemáticos relacionados a lógica, medidas, variáveis e proporcionalidade.

Jogo da Forca

Quem nunca pegou uma folha de caderno e brincou com os amigos do jogo da forca?! E é esse o tema do post de hoje, iremos desenvolver um pequeno jogo da forca que rode direto na shell do python (portanto não usa a biblioteca Pygames) e cujo código você encontra aqui: Clique Aqui.

O primeiro passo é entender que estamos trabalhando com dois arquivos, um com a lista de palavras e ou outro onde acontecem as execuções do código. O arquivo de lista de palavras é bem simples, contendo apenas uma definição com uma lista de palavras, como podemos ver abaixo:

Esse arquivo é carregado pelo "from palavras import lista_palavras" logo no começo do outro arquivo de execução (o arquivo de execução, onde estão os códigos principais). Logo abaixo temos uma série de definições e o executor do arquivo. No "get_palavra()" temos a forma randômica de como as palavras são escolhidas para o jogo da forca:

def get_palavra(): palavra = random.choice(lista_palavras) return palavra.upper()

Em "play(palavra)" é onde estão as estruturas lógicas responsáveis pela verificação da letra ou da palavra digitada corresponde ao que é para ser descoberta mediante uma lista. Note que para esse processo, exige-se uma "while not" (enquanto não) contínuo com diversos "if", "elif" e "else" (se, enquanto se, senão) que servem para dividir uma série de ações e possibilidades, mas principalmente reconhecer se a palavra/letra digitada pertence ou não a palavra a ser descoberta.

O primeiro "if" está associado ao reconhecimento do que foi digitado se é um letra/palavra (usa-se "isalpha" para isso) e se tem tamanho 1 para o caso de ser uma letra digitada ou se está na lista de palavras caso seja digitado a palavra inteira. Após essa verificação inicial, temos a verificação (elif) se o palpite (letra ou palavra digitada) está presente na palavra a ser descoberta. Para letras e palavras digitadas os processos são diferentes, no caso da letra é necessário fazer um índice de letras já que uma letra pode aparecer mais do que uma vez, enquanto uma palavra digitada é só comparar com a palavra a ser descoberta:

def play(palavra): palavra_completa = "_" * len(palavra) adivinhar = False adivinhar_letras = [] adivinhar_palavras = [] tentativas = 6 print("Hora de jogar o game da forca!") print(display_enforcamento(tentativas)) print(palavra_completa) print("\n") while not adivinhar and tentativas > 0: palpite = input("Adivinhe uma letra ou a palavra inteira:").upper() if len(palpite) == 1 and palpite.isalpha(): if palpite in adivinhar_letras: print("Você já adivinhou essa letra", palpite) elif palpite not in palavra: print(palpite, "Essa letra não é dessa palavra") tentativas -= 1 adivinhar_letras.append(palpite) else: print("Bom trabalho campeão,", palpite, "é uma letra da palavra!") #Programação e frase quando uma letra pertence a palavra. adivinhar_letras.append(palpite) palavra_as_list = list(palavra_completa) indices = [i for i, letra in enumerate(palavra) if letra == palpite] for index in indices: palavra_as_list[index] = palpite palavra_completa = "".join(palavra_as_list) if "_" not in palavra_completa: adivinhar = True elif len(palpite) == len(palavra) and palpite.isalpha(): if palpite in adivinhar_palavras: print("Você já adivinhou essa palavra", palpite) elif palpite != palavra: print(palpite, "isso não é uma palavra") tentativas -= 1 adivinhar_palavras.append(palpite) else: adivinhar = True palavra_completa = palavra else: print("Não é um palpite válido!") print(display_enforcamento(tentativas)) print(palavra_completa) print("\n") if adivinhar: print("Parabéns, você adivinhou corretamente a palavra! Você venceu!") #Programação e frase quando venceu a partida. else: print("Desculpa ae, mas você perdeu. A palavra era " + palavra + ". Quem sabe na próxima!")

Sempre após cada um desses casos é dado um print de tela com um amensagem referente a situação e mostrando um desenho pré-pronto da forca que está associado ao número de tentativas e que está presente na definição "display_enforcamento(tentativas)":

def display_enforcamento(tentativas): stages = [ # estágio final: cabeça, tronco, ambas as mãos, e ambas as pernas """ -------- | | | O | \\|/ | | | / \\ - """, # cabeça, tronco, ambas as mãos e uma perna """ -------- | | | O | \\|/ | | | / - """, # cabeça, tronco e ambas as mãos """ -------- | | | O | \\|/ | | | - """, # cabeça, tronco e uma mão """ -------- | | | O | \\| | | | - """, # cabeça e tronco """ -------- | | | O | | | | | - """, # cabeça """ -------- | | | O | | | - """, # estágio incial: vazio """ -------- | | | | | | - """ ] return stages[tentativas]

No fim dor arquivo estão as programações reponsáveis pela primeira execução e pela reinicialização do game. Com isso fechamos as explicações sobre o Jogo da Forca, porém é possível fazer diversos melhoramentos, tais como, um maior número de tentativas, uma execução via biblioteca pygames ou colocar níveis de dificuldade. Pronto para o desafio? Deixe nos comentários suas descobertas e até a próxima!

Pygames: Jogo da cobrinha

No post de hoje vamos desenvolver o famoso game da cobrinha usando o Pygames, cujo o nome oficial é Serpente ou Snake e esteve presente desde o final dos anos 90 em celulares e computadores da época. Você pode baixar o exemplo desenvolvido aqui no seguinte link do GDrive: Clique Aqui

Assim como em posts anteriores, diversos comandos e conjunto de códigos já foram mostrados em postagens anteriores e iremos focar nas novidades que são a formação matricial da cobrinha, como ela é gerada e se movimenta, como é gerado o pontinho e por fim como detectar a colisão entre a cobrinha e o pontinho. 

O primeiro passo é entender como a cobrinha é gerada e isso vai nos remeter ao conceito de matriz, onde podemos entender que a cobrinha é uma matriz linha com entradas cartesianas (x, y). Poderia ser uma matriz coluna também, só mudaria a orientação inicial que em vez de ser no sentido horizontal, seria no vertical (para os posteriores movimentos tem como trocar a posição dela). Observe na figura abaixo, como é desenvolvido a partir do conhecimento matemático, a programação para dar origem ao formato da cobrinha:

Agora você deve estar se perguntando, mas como a cobrinha se desloca pela tela? A resposta está no código abaixo:

for i in range(len(cobra) - 1, 0, -1): cobra[i] = (cobra[i-1][0], cobra[i-1][1])

Temos que imaginar primeiramente a cobrinha como pontos cartesianos do qual o primeiro ponto (a cabeça da cobrinha) tem uma posição e o segundo (vamos pensar nele como um rabo, mas sendo que tem vários atrás dele na mesma situação) tem uma posição anterior que irá ocupar a posição do primeiro ponto, por isso podemos pensar que esse segundo ponto é sempre um -1 em relação ao primeiro ponto que orienta a movimentação e que será visto a seguir com o uso dos direcionais. Resumindo temos uma eterna superposição de posições orientadas pela cabeça e que com o uso do "for" vamos calculando essas posições anteriores (-1) a serem substituidas dentro do range de tamanho da cobrinha.

Agora que sabemos como a cobrinha consegue se deslocar, precisamos entender como controlar elas com as teclas direcionais. Na primeira parte do código abaixo, temos a programação tradicional de controle de teclas dentro do loop "while" e comandados por "if" que nos entrega os estados que a cobrinha deve estar (0,1,2,3). Você deve estar se perguntando porque entregar um estado ao invés de ir direto para a posição cartesiana e a resposta para isso é devido ao fato de estar em uma movimentação constante, os direcionais devem atuar pontualmente sobre o código senão, não teremos a movimentação adequada (faça uns testes para comprovar isso). Logo em seguida, temos como cada tecla atua na movimentação da cobrinha, lembrando que o código "cobra [0]" é referente a primeira posição matricial da cobrinha e é a que dá a direção da mesma. Se analisarmos o "cobra[0]", ele é composto por um par (x,y) da forma (cobra [0][0], cobra [0][1]), onde para haver uma mudança na direção da cobrinha deve-se ser somado ou subtraido valores numéricos ao par x,y correspondentes. Exemplificando, caso a cobrinha precise subir (Up) temos o valor -10 em y, devido ao fato do ponto zero do plano cartesiano no python estar no canto superior esquerdo e, caso queira descer (Down), é só somar +10 em y. Veja na figura abaixo a ilustração disso e o código utilizado:

 

Agora precisamos entender um pouco sobre como é gerado o pontinho a ser capturado. A geração do ponto aleatório é feita por meio da função "random.randint(0,tamanho máximo da tela)" para os pontos (x,y), porém precisamos ter em mente que ser totalmente aleatório pode causar um desencontro entre o ponto e a cobrinha, já que a cobrinha também tem um tamanho igual a 10 de largura. Tendo isso em mente, usamos um pequeno artifício matemático (por meio desse código x//10 * 10, y//10 * 10) para que sempre que é gerado um valor, ele é dividido por dez gerando um valor inteiro (// é a divisão que devolve um número inteiro, evitando números com vírgula) e ao multiplicar por dez novamente temos um número múltiplo de dez sempre. Com isso padronizamos a geração de números inteiros em intervalos regulares de dez, como podemos ver no código abaixo:

def on_grid_random(): x = random.randint(0,590) y = random.randint(0,590) return (x//10 * 10, y//10 * 10) pontinho_pos = on_grid_random() pontinho = pygame.Surface((10,10)) pontinho.fill((255,0,0))

Por fim, a última coisa a tratarmos é como é feita a detecção da colisão entre a cobrinha e o pontinho. Tenha em mente que estamos usando uma maneira mais sofisticada e pronta para detectar as colisões do que as apresentadas anteriormente que dependiam de compararção entre valores cartesianos dos pontos. Como estamos trabalhando matricialmente, temos apenas de criar uma comparação entre duas entradas consecutivas c1 e c2 (cobrinha e pontinho) e verificar se a posição zero e a posição um são iguais entre elas o que torna-se uma colisão. Após a colisão detectada, o pontinho é acrescentado a cobrinha, ganha uma nova posição aleatória na tela e soma-se um ao valor do placar, conforme podemos verificar abaixo:

def colisão(c1, c2): return (c1[0] == c2[0]) and (c1[1] == c2[1]) if colisão(cobra[0], pontinho_pos): pontinho_pos = on_grid_random() cobra.append((0,0)) placar = placar + 1

Com isso encerramos o post de hoje, porém existem outros aspectos que podem ser acrescentados tais como, programações que mantenham a cobrinha na tela visível, fim de jogo quando a cobrinha tocar em sí mesma e outras opções de níveis com maior velocidade ou tamanho inicial da cobra maior. Deixe nos comentários suas descobertas e novos códigos utilizados para o seu game da cobrinha e até a próxima!

Pygames: Desenvolvendo um sistema de quest.

Em muitos games estão presentes sistemas de jogo que te conduzem por uma história, na qual você precisa ter contato com um NPC (personagem não jogável) para cumprir a missão dada por ele para ganhar uma recompensa. Ese sistema é denominado de quest (missão) e é muito utilizado em jogos do tipo MMORPG, mas pode ser usados em outros tipos também. E esse é o foco desse post, desenvolver um layout padrão de um sistema de quest e que você pode encontrar o template usado em: Clique Aqui.

Em primeiro lugar, boa parte do código aqui utilizado já foi trabalhado em posts anteriores, o referente a colisão entre objetos: Clique Aqui e Clique Aqui e o referente a criação de balões de fala para um personagem: Clique Aqui. Portanto não será revisado nesse post detalhes referente a essa construções e sim, apenas ao modo de utilização e adaptação para a estrutura de um sistema de quest.

De modo geral, temos exemplificado a situação onde você conduz o seu personagem jogável (Mário) até o cogumelo (NPC) que ativará por meio de cliques do mouse as instruções para cumprir a missão. A missão consiste em o Mário buscar a moeda para o cogumelo, que finaliza a missão com as falas de agradecimento do cogumelo e uma recompensa.

O primeiro ponto a ser observado é o fato de termos três colisões distintas: entre o Mário e o cogumelo (colidiu()), entre o Mário e a moeda (colidiu2()) e por último entre o cogumelo e a moeda (colidiu3()). As colisões são a maneira mais eficazes para inciar um evento em uma sistema de quest (podem ser usadas outras possibilidades) e garantir que não ocorra situações não previstas. 

Na primeira colisão temos a programação responsável pelas falas do cogumelo (NPC) instruíndo o que deve ser feito. Note que as falas só iniciam quando Mário toca o cogumelo e com consequentes cliques do mouse. Caso não esteja em colisão ou não faça os cliques com o mouse nada acontece e isso é devido as condições colocadas no "if  event.type == pygame.MOUSEBUTTONDOWN and colidiu() == True and colidiu3()== False". Ainda dentro desse "if", encontramos o contador de fala relacionado as falas do cogumelo (falageral = 1) e que quando chega ao valor 5, ele reinicia propositalmente (é para o caso do usuário não ter prestado atenção aos detalhes, poder rever os pedidos do NPC).

if event.type == pygame.MOUSEBUTTONDOWN and colidiu() == True and colidiu3()== False: falageral = 1 contadordefala = contadordefala + 1 if contadordefala == 5: contadordefala = 1

A segunda colisão é orientada ao encontro entre o Mário e a moeda e que tem como objetivo o Mário carregar a moeda até o cogumelo. Uma forma disso acontecer é que após a colisão entre os dois, os valores de posição x e y (cartesianos) da moeda passem a ser os mesmos do Mário, assim cria-se o efeito de que ele está levando a moeda até o cogumelo [só tome cuidado para não apertar os direcionais muito rápido, pois a moeda escapa do verificador de colisão e não acompanha os valores cartesianos do Mário).

if colidiu2(): xmoeda = xmario - 50 ymoeda = ymario - 50 personagem3Img = pygame.transform.scale(personagem3, (50, 50))

A última colisão é a do encerramento da missão, onde o Mário carrega a moeda até o cogumelo e temos as falas de encerramento do cogumelo quando a moeda encosta no cogumelo (colisão3). Assim como na primeira colisão temos um contador de fala (no caso ativa as falas do "falageral = 2") que visualmente parece não se repetir, mas se analisar o código você irá notar que ele passa a exibir sempre a fala de agradecimento final (isso foi feito para não dar erro no contador por ter saido fora do quantitativo de falas).

if event.type == pygame.MOUSEBUTTONDOWN and colidiu3() == True: falageral = 2 contadordefala2 = contadordefala2 + 1 if contadordefala2 == 2: contadordefala2 = 1

A última modificação nesse layout de sistema de quest é relacionado as exibições de tela, que além dos usuais "tela.blit" ordenados para mostrar personagens e o cenário (precisa ser ordenado pois caso você coloque por exemplo o cenário após os personagens, irá cobrir toda a tela com a exibição do cenário e consequentemente apagando a exibição dos personagens e afins), mostra também as falas que foram organizadas com o "falas[contadordefala]" e "falas2[contadordefala2]" para serem exibidas pelo balão de fala do cogumelo. E por fim, a exibição do premio que só é ativada após a última fala do cogumelo (contadordefala2 >= 1) e exibe na tela um objeto que acompanha os valores cartesianos do Mário (devidamente ajustados para parecer que ele está segurando a bolsa com dinheiro).

tela.blit(cenario,(0,0)) tela.blit(questImg, (520, 330)) tela.blit(personagem2Img, (500, 400)) tela.blit(personagemImg, (x, y)) tela.blit(personagem3Img, (xmoeda, ymoeda)) if falageral == 1: tx,ty = xcogumelo,ycogumelo-50 balao(tela,falas[contadordefala],tx,ty) if falageral ==2: tx,ty = xcogumelo,ycogumelo-50 balao(tela,falas2[contadordefala2],tx,ty) if contadordefala2 >= 1: tela.blit(premioImg, (x+40, y+25)) pygame.display.update() clock.tick(60)

Com isso finalizamos esse layout de desenvolvimento de um sistema de quest (missão) e você pode inserir ele dentro da construção do seu game. Além disso ainda é possível fazer melhorias ou inserir novos elementos/missões a serem relizadas. Deixe nos comentários como você implementou esse layout no seu projeto e até a próxima!

Pygames: Criando um game de tiro (FPS)

No post de hoje iremos desenvolver um layout para um jogo de tiro (que também é conhecido como FPS - First-Person Shooters, em inglês - não confundor com FPS de um jogo que é Frames Per Second), onde o objetivo é acertar dez vezes o cogumelo (alvo) que se move aleatoriamente na tela.  Você pode encontrar o código aqui desenvolvido no seguinte link: Clique Aqui.

Em primeiro lugar é necessário entender o funcionamento geral desse game de tiro: iremos desenvolver uma área delimitada (que no caso é o alvo) em função de valores cartesianos x,y e valores da altura e largura, onde os cliques do mouse fora dessa área não contam e os cliques dentro dessa área contam na pontuação. Esse é o princípio básico desse layout, no qual depois acrescentamos alguns movimentos ao alvo para gerar um contexto aleatório e dificultar os acertos.

Para construir essa área de acerto usamos duas definições, a primeira do "cogumeloalvo" para inserir a figura e a segunda do "click" para as definições de delimitação de area do alvo (x, y, largura e altura) que estão vinculadas aos status "FORA" e "DENTRO" que são os indicadores dos cliques que são realizados fora e dentro da área construída do "cogumeloalvo":

def cogumeloalvo(cogumelox, cogumeloy, cogumelolargura, cogumeloaltura): cogumelo = (cogumelox, cogumeloy) tela.blit(cogumelofigura, cogumelo) def click(cogumelox, cogumeloy, cogumelolargura, cogumeloaltura): mouse = pygame.mouse.get_pos() if cogumelox < mouse[0] < cogumelox + cogumelolargura and cogumeloy < mouse[1] < cogumeloy + cogumeloaltura: print("Clique no cogumelo") status = PARE else: print("Clique fora do cogumelo") status = ANDE return cogumelox, status

Na sequência temos o loop de repetição (while True) que é responsável pelos cliques do mouse delimitados pelo contador maior que zero (exatamente para não contar mais cliques e parar o alvo) e do status "DENTRO" dentro dessa repetição, de tal modo que só retire valores do contador quando o clique do mouse estiver dentro da área delimitada do "cogumeloalvo" (status == DENTRO).

Também temos o uso da tecla "r" para reinicar o game que pega os valores de contador e status e os retorna para os valores definidos inicalmente. E por fim, tem-se as regras de movimentação do alvo, que usam o "sentido" para modificar o deslocamento do alvo no eixo x (esquerda e direita). Para o alvo não sair da tela, foi construída uma inequação com valores limitantes da tela com valores randomicos (randit) para alteranar entre direita e esquerda. O valor em y é definido também por um número randômico no intervalo 50 e 500 (random.randint(50, 500)).

while True: clock.tick(20) for event in pygame.event.get(): if event.type == QUIT: pygame.quit() if event.type == MOUSEBUTTONDOWN and contador >0: cogumelox, status = click(cogumelox, cogumeloy, cogumelolargura, cogumeloaltura) if status == DENTRO: contador = contador -1 status = FORA if event.type == pygame.KEYDOWN: if event.key == pygame.K_r: contador = 10 status = FORA if sentido == DIREITA and status == ANDE: cogumelox = cogumelox + 10 if sentido == ESQUERDA and status == ANDE: cogumelox = cogumelox - 10 if cogumelox < -80 or cogumelox > 620: sentido = random.randint(0, 2) if sentido == 0: sentido = ESQUERDA cogumelox = 610 if sentido == 1: sentido = DIREITA cogumelox = -60 cogumeloy = random.randint(50, 500)

Algo que é muito importante em jogos de tiro é a mira e é possível no pygames desabilitar o cursor do mouse com o comando "pygame.mouse.set_visible(False))" e no lugar dele colocar um figura em png de uma mira, que siga os movimentos do cursor usando nas posições x e y, o comando "pygame.mouse.get_pos()". O restante dos códigos que você encontra abaixo são definições de exibição na tela do cenário, personagem alvo, mira, barra de contador de mortes e uma exibição de texto para quando o game é vencido (contador igual a zero):

pygame.mouse.set_visible(False) tela.blit(cenario,(0,0)) cogumeloalvo(cogumelox, cogumeloy, cogumelolargura, cogumeloaltura) tela.blit(mira,(pygame.mouse.get_pos(),pygame.mouse.get_pos())) pygame.draw.rect(tela, preto, [145, 0, 310, 45]) pygame.draw.rect(tela, branco, [150, 0, 300, 40]) pygame.draw.rect(tela, vermelho, [150, 0,((300)/10)*contador, 40]) if contador <= 0: texto("Você venceu!", preto, 200, 200, 300) texto("Aperte r para reiniciar.", preto, 200, 140, 330) status = PARE pygame.display.update() pygame.display.update()

Com isso temos os elementos básicos para construir um game de tiro e é possível implementar diversos melhoramentos como: construir novos níveis de dificuldade, novos movimentos para o personagem que irá ser acertado, um possível modo de jogatina PVP (o cogumelo ser controlado por outra pessoa e não pela maquina), dentre outros.  Então agora é com você, desenvolva seu próprio game de tiro e deixe nos comentários as inovações que você implementou. Até a próxima!

Pygames: Sistema de batalhas de um game. (Parte: 02)

Continuando o desenvolvimento de um sistema de batalhas no Pygames (continuação direta do post: Sistema de Batalhas Parte 01), hoje iremos exibir na tela todos os valores desenvolvidos anteriormente sob duas formas: textual e barra de animação. Na imagem do game abaixo podemos conferir essas duas exibições, a textual com os pontos de vida (e também o turno do jogador) e a barra de animação correspondendo a quantidade de pontos para o ataque especial. Ambas irão mudar conforme os jogadores batalharem em tempo real:

Para haver a exibição dos valores textuais na tela é necessário uma definição de como será apresentado o texto, que aparece na parte inicial dos códigos e ele possui cinco entradas: mensagem (texto escrito), cor da mensagem, tamanho da fonte, coordenada X, coordenada Y. Ainda dentro da definição "texto", existe ainda algumas outras configurações como você pode ver abaixo:

def texto(msg, cor, tam, x, y): font = pygame.font.SysFont(None, 38) texto1 = font.render(msg, True, cor) tela.blit(texto1, [x, y])

Com uma série de "if" é feita uma verificação para as três situações dos pontos de vida dos jogadores (ambos maior que zero, um menor que zero e outro menor que zero) para em seguida, termos as codificações referentes ao desenho da área da escrita (pygame.draw.rect), exibição do texto (texto()) e a atualização da tela (pygame.display.update). A mesma coisa irá acontecer na exibição de vez do jogador, única diferença é que leva-se em consideração a variável "turno" e só apresenta o texto na tela nas duas situações (turno jogador 01 e jogador 02):

if vidapikachu >0 and vidacharmander >0: pygame.draw.rect(tela, branco, [0, altura_janela-40, largura_janela, 40]) texto("Pontos de Vida: "+str(vidapikachu), preto, 20, 10, altura_janela-30) texto("Pontos de Vida: "+str(vidacharmander), preto, 20, 500, altura_janela-30) pygame.display.update() if vidapikachu <= 0: print ('pikachu dead') pygame.draw.rect(tela, branco, [0, altura_janela-40, largura_janela, 40]) texto("Pontos de Vida: morto", preto, 20, 10, altura_janela-30) texto("Pontos de Vida: "+str(vidacharmander), preto, 20, 500, altura_janela-30) pygame.display.update() if vidacharmander <= 0: print ('charmander dead') pygame.draw.rect(tela, branco, [0, altura_janela-40, largura_janela, 40]) texto("Pontos de Vida: morto", preto, 20, 500, altura_janela-30) texto("Pontos de Vida: "+str(vidapikachu), preto, 20, 10, altura_janela-30) pygame.display.update()

Observe acima que usamos o comando "str()" que serve justamente para transformar os valores de batalha que são calculados numericamente em texto a ser exibido na tela.

Agora vamos falar sobre a barra de animação do especial dos personagens. Ela foi desenvolvida tendo como base o "pygame.draw.rect" (já usado acima) que possui as entradas de: tela (tela do game definida no começo), cor, posição X, posição Y, largura (em X), altura (em Y) e nos entrega retângulos que podem usar tamanhos numéricos ou valores proporcionais da tela, como por exemplo o "largura_janela" e "altura_janela" (ambos definidos na parte inicial). Sequencialmente é feito o desenho de cada retângulo branco (que são a base das barras de especial), para em seguida ser desenhado por cima a barra de progresso do especial em cores vermelho e verde com o texto por cima (note que é muito importante essa ordem, pois se fizermos o contrário, não obteremos o resultado desejado):

pygame.draw.rect(tela, branco, [0, 0, largura_janela, 40]) pygame.draw.rect(tela, vermelho, [0, 0,((largura_janela/2)/10)*especialpikachu, 40]) texto("Especial Pikachu", preto, 0, 10, 10) pygame.draw.rect(tela, branco, [largura_janela/2, 0, largura_janela/2, 40]) pygame.draw.rect(tela, verde, [largura_janela/2, 0, ((largura_janela/2)/10)*especialcharmander, 40]) texto("Especial Charmander", preto, 0, (largura_janela/2)+10, 10)

Perceba que precisamos vincular o valor de largura (em X) da barra ao valor numérico da variável do especial (especialpikachu e especialcharmander), pois só assim teremos o efeito dela variável conforme a batalha se prossegue. Usando a fórmula "(largura_janela/2)/10)*especialpikachu" (no caso do jogador 02 vai ser "especialcharmander") temos o cálculo de que metade do valor total da largura de tela (que é o tamanho da barra do especial) vai ser dividido em dez partes (para ativar o especial precisa do valor 10) vezes o valor do quantitativo de especial acumulado do jogador em questão. Com isso, teremos uma barra de progresso na tela do game vinculada ao valor do especial e que permite ao jogador saber quando ele pode usar essa habilidade especial.

Com isso finalizamos o post, é possível fazer inúmeras adaptações, trocar pontos de vida pela barra de progresso do especial, colocar animações dos personagens batalhando, trazer novos conceitos de batalha para dentro do game, desenhar novos estilos de exibição de valores na tela, dentro muitos outros. Agora a bola da vez passa para você e deixe nos comentários que inovações você conseguiu trazer para esse layout de game de batalha. Até a próxima!         

Pygames: Sistema de batalhas de um game. (Parte: 01)

No post de hoje iremos desenvolver um layout para um sistema de batalhas entre dois jogadores e que pode servir de modelo para outros tipos de batalhas PVP (player versus player). Você pode obter o arquivo fonte em: CLIQUE AQUI.

O primeiro passo é pensar na estrutura de batalha e quais tipos de poder os personagens devem ter. No exemplo que estamos trabalhando, temos poderes iguais para os dois personagens de modo a balancear a partida, mas vamos usar uma opção de números randômicos para uma das habilidades de modo a dar um diferencial. Tendo em mente isso, organizamos 3 tipos de ataques para cada personagem:

• Ataque Básico: é um ataque padrão que tem baixo valor de ataque (retira apenas 1 ponto de vida do adversário), mas que gera mais pontos para o ataque Especial (gera 3 pontos);
• Ataque Carregado: é um ataque mais forte (retira 2 pontos de vida do adversário), porém gera menos pontos para o ataque Especial (apenas 1 ponto);
• Especial (Ult): é um ataque que só funciona quando o personagem tem um contador (barra) com valor maior ou igual a 10 pontos, ou seja, ele não funciona a qualquer momento e exige estratégia, ainda mais que o valor do ataque dado pode variar de 0 a 5 pontos de uma única vez (sim, você vai depender de sorte nisso, por isso o risco).

Tendo isso em mente, é hora de começaramos a programar. O primeiro passo é pensar em quais variáveis serão necessárias para que esse sistema possa funcionar. A resposta são cinco:

• vidapikachu: é o total de vida do jogador 01 (no caso representado pelo Pikachu);
• vidacharmander: é o total de vida do jogador 02 (no caso representado pelo Charmander);
• especialpikachu: contador do especial do jogador 01;
• especialcharmander: contador do especial do jogador 02;
• turno: é a variável responsável por fazer a contagem 0 e 1 para indicar a vez de cada jogador. Na primeira vez sempre é sorteado a vez dos jogadores aleatoriamente usando o "randint (0, 1)"

Feito isso, agora é a hora de pensar na estrutura de programação. Usaremos o "pygame.KEYDOWN" com uma sequencia de "if" (se) acoplados com "and" (e) que irão listar as situações para o bom funcionamento do game, como podemos ver abaixo:

if event.type == pygame.KEYDOWN and vidapikachu >0 and vidacharmander >0: if event.key == pygame.K_1 and turno == 0: vidacharmander = vidacharmander - 1 especialpikachu = especialpikachu + 3 turno = 1 print (vidapikachu) if event.key == pygame.K_2 and turno == 0: vidacharmander = vidacharmander - 2 especialpikachu = especialpikachu + 1 turno = 1 print (vidapikachu) if event.key == pygame.K_3 and especialpikachu >= 10 and turno == 0: vidacharmander = vidacharmander - randint(0, 5) especialpikachu = especialpikachu - 10 turno = 1 print (vidapikachu) if event.key == pygame.K_8 and turno == 1: vidapikachu = vidapikachu - 1 especialcharmander = especialcharmander + 3 turno = 0 print (vidacharmander) if event.key == pygame.K_9 and turno == 1: vidapikachu = vidapikachu - 2 especialcharmander = especialcharmander + 1 turno = 0 print (vidacharmander) if event.key == pygame.K_0 and especialcharmander >= 10 and turno == 1: vidapikachu = vidapikachu - randint(0, 5) especialcharmander = especialcharmander - 10 turno = 0 print (vidacharmander)

Explicando rapidamente o que ocorre no código acima. Para as teclas de batalha ativar (são elas 1, 2, e 3 para jogador 01 e 8, 9 e 0 para jogador 02), a vida dos jogadores deve estar acima de zero. Em seguida, temos mais um verificador para cada tecla listada acima e apenas acionadas se o valor do turno é o correpondente (fica alternando entre 0 e 1), caso contrário não acontece nada (é para que cada jogador tenha a oportunidade de usar seu turno com calma e estratégia). O próximo passo é fazer as operações com as variáveis de modo a retirar o valor de vida correspondente a habilidade ativada, a geração de pontos para o especial e a mudança de turno. A única diferença é na habilidade referente a ativação do especial (teclas 3 e 0), que seguem uma lógica diferente, já que para ativar a tecla é necessário além do já mencionado, o poder do especial ser maior ou igual a dez e ao aplicar o dano, ele é aleatório (usa a função randint) e em seguida retira dez pontos do contador do especial. Cada um dos "if" tem um comando "print" que mostra o valor resultante das batalhas no shell do Python, vale a pena fazer testes para entender o funcionamento.

Para finalizar, é hora de criar uma opção para reiniciar o game (reset), ao qual foi atribuido a tecla "r" e basicamente ela copia os valores iniciais das variáveis que criamos e joga de volta na execução do game. Note que no código abaixo temos referência a criação de desenhos e textos, mas que serão melhor explicados em um próximo post:

if event.type == pygame.KEYDOWN: if event.key == pygame.K_r: vidapikachu = 20 vidacharmander = 20 especialpikachu = 10 especialcharmander = 10 turno = randint (0, 1) pygame.draw.rect(tela, branco, [0, altura_janela-40, largura_janela, 40]) texto("Pontos de Vida: "+str(vidapikachu), preto, 20, 10, altura_janela-30) texto("Pontos de Vida: "+str(vidacharmander), preto, 20, 500, altura_janela-30) pygame.display.update()

Com isso encerramos a criação do sistema de cálculos de batalha, que inclusive pode ser modificado (pode ser criadas novas habilidades, valores diferenciados, dentro outros), mas ainda precisamos exibir tudo isso na tela. No próximo post iremos mostrar como fazer isso. Até a próxima!

Pygames: Construindo a tela de entrada do seu game.

O post de hoje aborda o que é necessário para construir uma tela de entrada para seu game em Python e caso você queira usar o template que será abordado aqui, acesse: https://drive.google.com/drive/folders/1W-X02WU8iPB3URivEH1NHgTV45qKIioQ?usp=sharing.

Um layout de tela inicial padrão em jogo possui pelo menos 3 botões (Jogar, Opções e Sair) e uma interface inicial em que eles estão contidos. Na programação abaixo você confere a definição usada para a escrita do texto (draw_text) na tela inicial e nos submenus:

def draw_text(text, font, color, surface, x, y): textobj = font.render(text, 1, color) textrect = textobj.get_rect() textrect.topleft = (x, y) surface.blit(textobj, textrect)

O próximo passo é definir a construção dos botões e as opções de quando forem clicados, qual ação deve ser executada (nesse caso usamos o comando "if click:" para redirecionar para as definições que tem os comandos de cada uma das subtelas ou subprocessos). Caso seja necessário implementar mais botões, esse é um dos campos que deve ser modificado, com a definição de um novo botão (button_x=), de um "if" a mais com a definição que será executada e de um "pygame.draw.rect" para desenhar o botão. Por fim, os "draw_text" são usados para as escritas na tela e em cima dos botões (eles são colocados por último, pois precisam estar sobrepostos ao desenho do botão, caso contrário a escrita não aparece). É necessário usar valor cartesianos para posicionar as escritas na tela, o que é um bom exercício de abstração matemática.

def main_menu(): while True: screen.fill((0,0,0)) draw_text('Menu Principal', font, (255, 255, 255), screen, 330, 40) mx, my = pygame.mouse.get_pos() button_1 = pygame.Rect(300, 200, 200, 50) button_2 = pygame.Rect(300, 300, 200, 50) button_3 = pygame.Rect(300, 400, 200, 50) if button_1.collidepoint((mx, my)): if click: game() if button_2.collidepoint((mx, my)): if click: options() if button_3.collidepoint((mx, my)): if click: exite() pygame.draw.rect(screen, (255, 0, 0), button_1) pygame.draw.rect(screen, (255, 0, 0), button_2) pygame.draw.rect(screen, (255, 0, 0), button_3) draw_text('Jogar', font, (255, 255, 255), screen, 372, 215) draw_text('Opções', font, (255, 255, 255), screen, 363, 315) draw_text('Sair', font, (255, 255, 255), screen, 378, 415) click = False for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() if event.type == KEYDOWN: if event.key == K_ESCAPE: pygame.quit() sys.exit() if event.type == MOUSEBUTTONDOWN: if event.button == 1: click = True pygame.display.update() mainClock.tick(60)

Tendo as ações da tela inicial construída, agora é preciso definir o que acontece quando cada botão é executado. Para os botões "Jogar" e "Opções" criamos duas definições ("game" e "options") que redirecionam para uma nova tela. No caso do definição "game" (botão "Jogar") você deve inserir o código do seu game (não faremos aqui, pois iria aumentar muito os códigos e deixaria de ser um modelo didático mas, você pode encontrar aqui no blog inúmeros post sobre produção de games e acrescentar nessa definição). A definição "options" (botão "Opções") é uma tela nova onde deve ser inseridas as opções de customização do seu game (também a ser melhorada por você). E por fim a definição "exite" (botão "Sair") apresenta apenas os códigos para fechar a janela do game, que também pode ser fechado usando a tecla "ESC" (ela é usada também para voltar).

def game(): running = True while running: screen.fill((0,0,0)) draw_text('Meu Jogo', font, (255, 255, 255), screen, 20, 20) for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() if event.type == KEYDOWN: if event.key == K_ESCAPE: running = False pygame.display.update() mainClock.tick(60) def options(): running = True while running: screen.fill((0,0,0)) draw_text('Opções', font, (255, 255, 255), screen, 20, 20) for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() if event.type == KEYDOWN: if event.key == K_ESCAPE: running = False pygame.display.update() mainClock.tick(60) def exite(): pygame.quit() sys.exit()

Termina-se o post com a proposição de um desafio: melhore esse template e insira o seu game desenvolvido em Python nele! Muitas melhorias como adição de plano de fundo e música, inserção de botões para tutoriais, dentre outros são possíveis. O desafio está lançado e nos vemos em breve. Até a próxima!

Pygames: Programando falas entre personagens

O post de hoje é uma continuação direta do post: https://vemfazermatematicaegames.blogspot.com/2020/07/pygames-baloes-de-fala-de-um-personagem.html que trabalhou sobre a construção de falas em um balão para um personagem. Tendo isso como base, iremos avançar para como estabelecer um diálogo entre dois (ou mais personagens), generalizando assim a possibilidade de iterações via diálogos. O arquivo .py e seus complementos aqui utilizados podem ser encontrados no  GDrive: https://drive.google.com/drive/folders/1g20jvMDz-S5ieAMFnG5HDSa1NA_bcp7i?usp=sharing.

Para iniciar, estamos trabalhando com um exemplo com dois personagens diferentes, logo vamos precisar construir duas definições de balões, que irão se diferenciar justamente pelas coordenadas cartesianas de cada personagem (Mário com x e y, Luigi com a e b):

Assim, para cada personagem que for criado, necessita-se de uma definição nova de balão, com coordenadas referentes a ele. Agora, para a construção de falas, temos uma mudança na estrutura, na qual temos listas de falas dos personagens separadas em sequências e atreladas a contadores de iteração (itera, itera2, itera3), que estão em função do "clock.tick(30)" do jogo, que nada mais é do que a taxa de atualização de frames por segundo (FPS):

itera = 0 itera2 = 0 itera3 = 0 falas = ["Olá eu sou o Mário.","Como você está?"] falas2 = ["Olá, eu sou o Luigi.", "Eu estou bem!", "E você?", "O que me contas de interessante?"] falas3 = ["Eu estou muito bem! Só queria falar que","A Matemática está em TUDO!","E em breve em TODOS! Até mais."] if itera<180: tx,ty = x+25,y-2 itera2 = 0 itera3 = 0 balao(game_display,falas[int(itera/90)%len(falas)],tx,ty) if itera2>1 and itera2<360: ta,tb = a+45,b-2 itera3 = 0 balao2(game_display,falas2[int(itera2/90)%len(falas2)],ta,tb) if itera3>1 and itera3<270: tx,ty = x+25,y-2 balao(game_display,falas3[int(itera3/90)%len(falas3)],tx,ty) pygame.display.update() clock.tick(30) itera += 1 itera2 += 1 itera3 += 1

Como podemos ver acima, temos um conjunto de três "if" (se) que testam os valores do "itera", "itera2" e "itera3", com um somatório de valor 1 para cada um deles após o "clock.tick(30)". Esse valores testados nos "if" são todos múltiplos de 90, pois como o FPS está fixo em 30 frames por segundo e, como queremos que as falas do exemplo durem 3 segundos, temos 30 vezes 3 que dá os valores de 90, do qual serão utilizados os seus múltiplos em cada um dos "if" (uma fala dá o valor 90, duas falas dá o valor 180, três falas dá valor 270, e assim por diante). Caso queira mudar a duração da fala, será necessário reconfigurar esses valores, exemplificando, se for para durar 5 segundos, temos 30 vezes 5, que dá 150 e os múltiplos usados serão com base nesse valor (150, 300, 450, ...).

Agora vamos entender o funcionamento dos "if" em relação aos "itera" com a ajuda da imagem acima. Na primeira vez que entra-se na sequência de "if" (1º loop), o valor do itera é igual a zero e portanto ele executa a primeira frase da "fala1" e deixa zerado os demais "itera2" e "itera3", portanto os próximos "if" não se ativam. Ele fica nesse ciclo até atingir o valor 180, que é responsável por ter realizado 3 frases da "fala1" (são as falas do Mário). Em seguida, como ele não fica mais preso no loop do "itera", passa-se para o "itera2" (2º loop) graça ao contador +1 (valor mínimo de entrada "itera2>1") e inicia as frases da "fala2" (frases do Luigi), que sempre ao final, mantem o "itera3" zerado (até o valor máximo de 360, que corresponde a 4 frases da "fala2"). O próximo passo é o "itera3" (3º loop) e caso queira-se mais frases é necessário aumentar a quantidade de "if" e de "iteraN (N sendo valores numéricos para diferenciar os itera)". Note, que esse é um método que pode ser complicado de seguir caso exista muitas frases a serem faladas pelos personagens, por isso caso queira algo mais sofisticado, precisará trabalhar com arquivos separados para falas, afim de organizar melhor seus códigos.
Com isso finaliza-se a proposta do post e agora é a sua vez de colocar a mão na massa e dar um novo upgrade no seu game. Deixe nos comentários suas impressões e descobertas e até a próxima!

Pygames: Balões de fala de um personagem.

No post de hoje iremos construir uma definição para a exibição de diálogos do seu personagem em forma de balões, que é um recurso muito usado em games para contar histórias. Você pode acessar o layout que será desenvolvido nesse post no GDrive: https://drive.google.com/drive/folders/1QUgJUVskPBowRY244pmsmWMfSt3xRilY?usp=sharing.

Se você observar o código, temos uma definição para o desenho da função balão (def balao(screen,text, x0,y0)) com entradas de desenho de tela, texto a ser inserido e coordenadas X e Y. Dentro da definição temos uma série de parâmetros para configuração de fonte, coloração formato e tamanho do balão de fala, dentre outros. A ideia é que você altere esses parâmetros e vá testando novas possibilidades:
   

def balao(screen,text, x0,y0): font = pygame.font.SysFont('comicsansms', 12, bold=False, italic=False) #pygame.font.Font(font, 12) textSurf = font.render(text, True, (30,30,30)).convert_alpha() textSize = textSurf.get_size() bubbleSurf = pygame.Surface((textSize[0] + 31, textSize[1] + 15 + 30)) bubbleSurf.fill((0,0,0)) bubbleSurf.set_colorkey((0,0,0)) l = 6 x,y = textSize[0] + 30, textSize[1] + 15 points = [ [l,0], [x-l,0],[x,l],[x,y-l],[x-l,y], [x/2+6,y] ,[x/2,y+30], [x/2-6,y] ,[l,y],[0,y-l],[0,l]] pygame.draw.polygon(bubbleSurf, (255,255,255), points) pygame.draw.lines(bubbleSurf, (30,30,30), True, points) bubbleRect = bubbleSurf.get_rect() bubbleSurf.blit(textSurf, textSurf.get_rect(center = (x/2,y/2))) bubbleRect.center = (x0,y0-bubbleRect[3]/2) screen.blit(bubbleSurf, bubbleRect)

Para que as falas aconteçam e sejam exibidas na tela, os parâmetros da definição balão devem ser satisfeitos. O primeiro é a "screen" que é exibida com o uso do "game_display" que é basicamente é o desenho do balão na tela. O segundo parâmetro são as falas, que são acionadas via clique do mouse. Para isso acontecer, temos uma listagem de falas já construídas (definição falas = ['texto']) e que por meio do contador "itera = itera + 1" na função clique, temos essa sequência de frases sendo mostradas na tela (dentro do balão). E por fim o posicionamento do balão em relação ao personagem realizado por meio das variáveis "tx" e "ty" que são atreladas ao x e y do plano cartesiano. Inclusive, nessa opção das variáveis "tx" e "ty" você pode fazer o melhor ajuste do balão em relação ao seu personagem.

Com esse post abre-se uma nova gama de possibilidades com relação a enredos e diálogos dentro do seu game. É possível ainda implementar vozes gravadas, mudar o estilo de balões, fazer o balão desaparecer depois de alguns segundos da fala, usar diferentes inputs para acionar as falas (como se fosse um filme), dentre outras possibilidades. Então mãos na massa e hora de aprimorar o seu game!

Pygames: Coordenando múltiplos arquivos .py

No post de hoje vamos trabalhar com a integração de múltiplos arquivos de pygames (.py), pois a medida que os códigos começam a crescer, não basta apenas organização no arquivo de programação usando-se diversos class ou definições, afinal a programação começa a ficar muita extensa e de difícil leitura. Nesse caso, podemos criar arquivos .py secundários para cada um dos personagens executáveis pelo jogador, os controlados pela IA do game (NPC), bem como diversas customizações em separado e ao final, unir tudo em um único arquivo .py principal a ser executado. O exemplo que vamos utilizar está disponível no GDrive: https://drive.google.com/drive/folders/1U-_SQhtXz0Hpq1O4UYvK1plPOW3MGcya?usp=sharing e trabalha com quatro arquivos diferentes de personagens que são gerenciados pelo arquivo "jogo.py". Além disso, a grande maioria dos códigos aqui utilizado já foram vistos nos posts anteriores e podem ser acessados usando a tag "Pygames" do blog.

Vamos usar como exemplo de uma arquivo secundário o "morcego.py". Sua estrutura é baseada na que foi construída no post sobre construção de sprites e pode ser conferida em: https://vemfazermatematicaegames.blogspot.com/2020/07/pygames-usando-o-modulo-pygamesprite.html. Se você observar os comandos na figura abaixo, irá ver que foram retirados diversos comandos responsáveis pela execução da classe Morcego, que por sua vez estão presentes no arquivo principal "jogo.py" (esse é o arquivo que une os demais). Veja as diferenças na figura abaixo:

Na comparação acima dos arquivos "sprite" (versão com um único arquivo) e do "morcego" (versão com mais de um arquivo), pode ser constatado que comandos relacionados a iniciação, execução de loop (repetição) e finalização da programação não estão mais presentes. Eles serão adicionados no arquivo geral "jogo.py" que é responsável por carregar todos os arquivos auxiliares pygames (morcego,  quadrado, caramujo, caminhante).
Agora vamos focar no arquivo principal "jogo.py" e ver um pouco da sua programação. Nos comandos de inicialização (que não estão presentes nos outros arquivos secundários) temos a presença da definição "all_sprites =  pygame.sprite.Group"  que é o módulo que será responsável pela adição de cada um dos arquivos ''.py''. Em seguida, cada um dos arquivos é carregado via uma definição (exemplificando, "cami = caminhante()", nesse caso é o arquivo "caminhante.py" que está sendo definido como "cami") para em seguida com o comando "all_sprites.add(nome da definição do arquivo)" ele seja adicionado a linha de execução de comandos. Veja abaixo o que acabamos de explicar:

pygame.init() pygame.mixer.init() screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("Experimentando com Sprites") clock = pygame.time.Clock() all_sprites = pygame.sprite.Group() player = Quadro(10,RED) player2 = Quadro(6,GREEN) player3 = Quadro(4,BLUE) cami = Caminhante() bat = Morcego() cara = Caramujo() all_sprites.add(bat) all_sprites.add(player) all_sprites.add(player2) all_sprites.add(player3) all_sprites.add(cami) all_sprites.add(cara)

No decorrer do arquivo temos os comandos relacionados a repetição (loop), entrada do teclado (inputs) e desenho execução na tela, que já foram vistos em outros post com a tag Pygames (volte neles se for necessário uma revisão). Único ponto de atenção, é a forma como o Pygames executa todos os updates gráficos de todos os arquivos. Lembra da definição "all_sprites"? Ela retorna no fim do arquivo para fazer as atualizações (all_sprites.update) e execuções na tela (all_sprites.draw), fechando o ciclo da programação:

all_sprites.update() screen.fill(GRAY) all_sprites.draw(screen) pygame.display.flip() pygame.quit()

O post de hoje encerra-se com essa incrível possibilidade de construir diferentes arquivos e unir toda a execução dele em apenas um arquivo, facilitando a organização e leitura dos códigos, afinal, quanto maior a proposta do game, maior será o tamanho do código construído. Até a próxima!

Pygames: Usando o módulo pygame.sprite

A biblioteca Pygames da linguagem Python, tem como função trazer uma série de módulos prontos que podem ser utilizados para a construção de uma game. Hoje iremos conhecer o módulo "pygame.sprite" cuja função é reunir todas as configurações e comandos de manipulação de um objeto para a execução do mesmo dentro de um game. Basicamente nos posts anteriores já fizemos isso, mas de maneira mais simples e, a partir de agora teremos um novo grau de sofisticação que poderá substituir quando necessário os conhecimentos anteriores. Vamos usar como exemplo a animação do personagem que se move para a direita e esquerda (já construído no post: https://vemfazermatematicaegames.blogspot.com/2020/06/pygames-animando-os-movimentos.html), mas que ganha uma nova sofisticação que você pode encontrar o arquivo em: https://drive.google.com/drive/folders/1Hn5KWPGezHxi62a_rN0T5sz--86ON762?usp=sharing.

Em primeiro lugar vamos focar apenas na nova programação do módulo "pygame.sprite"(no arquivo existe um comentário com # que mostra onde inicia a parte do módulo "pygame.sprite"), pois os demais comandos já foram vistos nos posts anteriores. O módulo "pygame.sprite" está dentro de uma classe (class Caminhante) que basicamente é um organizador de um conjunto de definições que dão a identidade do sprite (isso permite criar diversas classes que poderão interagir entre si). Todas as definições são compostas de linhas de código e servem justamente para modificar alguma característica do Sprite correspondente a definição e a melhor forma de entender é justamente mudar os valores e ver o que acontece.
Na definição abaixo temos as opções correspondentes a inicialização do Sprite, tais como: adicionar imagens para a animação, posição em X e Y do sprite, ângulo e escalonamento de tamanho do sprite, dentre outras possibilidades:

def __init__(self): pygame.sprite.Sprite.__init__(self) self.images = [] self.addImage("Walk1.png") self.addImage("Walk2.png") self.addImage("Walk3.png") self.addImage("Walk4.png") self.addImage("Walk5.png") self.addImage("Walk6.png") self.addImage("Walk7.png") self.addImage("Walk8.png") self.image = pygame.Surface.copy(self.images[0]) self.currentImage = 0 self.rect = self.image.get_rect() self.rect.topleft = (0, 0) self.mask = pygame.mask.from_surface(self.image) self.angle = 0 self.scale = 1 self.xpos = 0 self.ypos = 100 self.originalWidth = self.rect.width self.originalHeight = self.rect.height self.indexns = 0 self.itera = 0

Na definição abaixo temos os comandos relacionados a forma de fazer a atualização das imagens em função do FPS (formula) e com um contador (itera). Além disso, estão mostrados os comandos "xpos" e "ypos" que são relacionados a movimentação no plano cartesiano e que podem ter ligação com inputs externos ou outras programações fora da definição:

def update(self): self.itera = self.itera + 1 self.indexns = int(self.itera/int((6*FPS)/60))%8 self.changeImage(self.indexns) if self.xpos > WIDTH : self.xpos = 0 self.move( self.xpos, self.ypos)

A definição abaixo é exclusiva para carregar as imagens e fazer elas aparecerem na tela:

def addImage(self, filename): self.images.append(loadImage(filename)) print(self.images)

Na definição abaixo temos os comandos relacionado ao movimento em função do "xpos" e "ypos":

def move(self, xpos, ypos, centre=False): if centre: self.rect.center = [xpos, ypos] else: self.rect.topleft = [xpos, ypos]

A definição a seguir é relacionada a como as imagens da animação são modificadas:

def changeImage(self, index): self.currentImage = index if self.angle == 0: self.image = self.images[index] else: self.image = pygame.transform.rotate(self.images[self.currentImage], -self.angle) oldcenter = self.rect.center self.rect = self.image.get_rect() self.originalWidth = self.rect.width self.originalHeight = self.rect.height self.rect.center = oldcenter self.mask = pygame.mask.from_surface(self.image)

Mais uma definição de carregamento (loading) de imagens que faz a checagem do arquivo:

def loadImage(fileName, useColorKey=False): if os.path.isfile(fileName): image = pygame.image.load(fileName) image = image.convert_alpha() # Return the image return image else: raise Exception("Error loading image: " + fileName + " - Check filename and path?")

Você não precisa mudar todos os comandos aqui listados, a grande maioria pode usar pronto e só modificar as entradas numéricas e textuais que se adequem a situação que você preferir. Existem ainda outros tipos de módulos voltados para games, como por exemplo o "sprite.group", do qual você pode entender um pouco mais acessando a documentação do Pygames: https://www.pygame.org/docs/ref/sprite.html.

Espero que esse post tenha aberto novas possibilidades para o seu projeto e até a próxima!

Pygames: Animando o pulo do seu personagem

Continuando a sequência de posts sobre animações (https://vemfazermatematicaegames.blogspot.com/2020/06/pygames-animando-os-movimentos.html), hoje iremos abordar como inserir a opção do pulo, na programação já desenvolvida.

A primeira modificação é relacionada a repetição (while running) já construída que terá dois estados: ANDANDO (focada no personagem que se movimentar para a direita e a esquerda) e PULANDO (onde o personagem irá pular com a tecla espaço).

pressionado = 0 ANDANDO = 0 PULANDO = 1 acao = ANDANDO tp = 0.7 running = True while running: if acao == ANDANDO: for event in pygame.event.get(): if event.type == pygame.KEYUP: if event.key == pygame.K_SPACE: pulo = 2 if event.key == pygame.K_LEFT: deltaX = 0 if event.key == pygame.K_RIGHT: deltaX = 0 if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE: acao = PULANDO t = 0 deltaX = 0 if event.key == pygame.K_LEFT: deltaX = -5 pressionado = 1 if event.key == pygame.K_RIGHT: deltaX = 5 pressionado = 2 if event.type == pygame.QUIT: running = False xpos = xpos + deltaX ypos = y0 if xpos < -25: xpos = WIDTH -1 if xpos > WIDTH: xpos = 0 if deltaX != 0 : itera = itera + 1 elif acao == PULANDO: t = t + 1 if t >= tp*FPS: acao = ANDANDO ypos = y0 - tp*FPS*t + t*t)

Observando o código acima, temos que a ação normal é estar ANDANDO (if) que executa as programações já vistas anteriormente. Porém, quando a tecla e Espaço é apertada, a ação é modificada para PULANDO (elif) que irá executar a programação do pulo. Note que com essa construção, o personagem pode só pular ou só andar, nunca as duas coisas ao mesmo tempo.

A programação do PULANDO possui uma fórmula adaptada da física (fórmula do lançamento oblíquo no eixo Y), que pode ser vista abaixo:

Essa fórmula física foi adaptada para o contexto do game, já que em um game é o programador que define qual a velocidade do personagem e qual a gravidade existe no modelo. Por isso temos valores baseados em tp (tamanho do pulo) e no FPS, pois existe uma relação entre a atualização de frames e os valores obtidos na equação. Você conseguiria descobrir o que é? Uma dica é que temos uma equação de 2º grau e que suas raízes tem influência na posição do pulo do personagem. 

t = t + 1 if t >= tp*FPS: acao = ANDANDO ypos = y0 - tp*FPS*t + t*t

Finalizando, você deve ter notado que o loading das imagens foi simplificado, ficando apenas as imagens em uma direção (direita) e ao usar o comando "pygame.transform.flip" é possível rebater a imagem como em um espelho, conseguindo-se a sequência de imagens para o lado esquerdo também.

screen.fill(GRAY) indexImg = int(itera/int((6*FPS)/60))%9 if deltaX > 0: screen.blit(imagesdireita[indexImg], (xpos,ypos)) elif deltaX < 0: screen.blit(pygame.transform.flip(imagesdireita[indexImg], True, False), (xpos,ypos)) elif deltaX == 0 and pressionado == 1: screen.blit(pygame.transform.flip(imagesdireita[indexImg], True, False), (xpos,ypos)) elif deltaX == 0 and pressionado == 2: screen.blit(imagesdireita[0], (xpos,ypos)) pygame.display.flip() clock.tick(FPS)

Com isso finalizamos esse post e o código aqui apresentado pode ser encontrado em: https://drive.google.com/drive/folders/1dC7GSPAVSizvtDhA1HMEHrkXSIbHz8UP?usp=sharing. Agora é a sua vez de customizar esse código para o seu game e adicionar novas funcionalidades. Seria possível um personagem andar e pular ao mesmo tempo? E se tivermos mais do que um personagem? Nos comentários abaixo conte um pouco da sua experiência e até a próxima!

Pygames: Animando os movimentos direcionais de um personagem

No post anterior (https://vemfazermatematicaegames.blogspot.com/2020/06/pygames-criando-animacoes.html) construímos uma animação pautada em diversas posições de um personagem que ficam se repetindo. Hoje iremos acrescentar as setas direcionais (direita e esquerda) para controlar o movimento desse personagem animado. Você pode conferir os arquivos e a programação aqui utilizados na seguinte pasta do GDrive: https://drive.google.com/drive/folders/18Tr4eOVSye8fzX8lNzHH_eqG_J9-DL8_?usp=sharing.

O primeiro detalhe é que precisamos duplicar as imagens do personagem que andava para direita e agora, temos de ter a opção para a esquerda (isso pode ser realizado usando o InkScape com a opção "inverter objetos horizontalmente [tecla H]). Na programação teremos o loading com os seguintes códigos:

imagesdireita = [] imagesdireita.append(pygame.image.load("direita1.png")) imagesdireita.append(pygame.image.load("direita2.png")) imagesdireita.append(pygame.image.load("direita3.png")) imagesdireita.append(pygame.image.load("direita4.png")) imagesdireita.append(pygame.image.load("direita5.png")) imagesdireita.append(pygame.image.load("direita6.png")) imagesdireita.append(pygame.image.load("direita7.png")) imagesdireita.append(pygame.image.load("direita8.png")) imagesdireita.append(pygame.image.load("direita9.png")) imagesesquerda = [] imagesesquerda.append(pygame.image.load("esquerda1.png")) imagesesquerda.append(pygame.image.load("esquerda2.png")) imagesesquerda.append(pygame.image.load("esquerda3.png")) imagesesquerda.append(pygame.image.load("esquerda4.png")) imagesesquerda.append(pygame.image.load("esquerda5.png")) imagesesquerda.append(pygame.image.load("esquerda6.png")) imagesesquerda.append(pygame.image.load("esquerda7.png")) imagesesquerda.append(pygame.image.load("esquerda8.png")) imagesesquerda.append(pygame.image.load("esquerda9.png"))

Para fazer que o personagem se movimente utilizamos as opções já vistas em post anteriores (event.type == pygame.KEYDOWN e event.type == pygame.KEYUP) com o uso do deltaX igual a zero quando a tecla está levantada e valor igual 5 ou -5 (direita e esquerda) para fazer o personagem deslizar pelo eixo X (Y está fixo nesse exemplo) e o "xpos" faz o calculo do quanto foi deslocado pelo eixo X:

for event in pygame.event.get(): if event.type == pygame.KEYUP: if event.key == pygame.K_LEFT: deltaX = 0 if event.key == pygame.K_RIGHT: deltaX = 0 if event.type == pygame.KEYDOWN: if event.key == pygame.K_LEFT: clock.tick(FPS) deltaX = -5 pressionado = 1 if event.key == pygame.K_RIGHT: clock.tick(FPS) deltaX = 5 pressionado = 2 xpos = xpos + deltaX ypos = ypos + deltaY

A seguir temos uma sequência de "if" (se) que delimita algumas situações:

if deltaX != 0 : itera = itera + 1 if xpos < -25: xpos = WIDTH -1 if xpos > WIDTH: xpos = 0 screen.fill(GRAY) indexImg = int(itera/int((6*FPS)/60))%3

O primeiro "if deltaX != 0" significa que se o deltaX é definido como zero", então ele inicia o cálculo de iterações responsáveis pelas animações (fica correndo direto) e tem ligação direta com o "indexImg" (fórmula para iteração das imagens que foram carregadas). Temos dois "if" (xpos maior e menor do que o tamanho da tela) responsáveis por delimitar o máximo que o personagem anda na tela. Agora vem a parte mais importante, a sequência de casos possíveis de deslocamento na tela e o que fazer em cada situação, que estão escritas no código abaixo:

elif deltaX < 0: screen.blit(imagesesquerda[indexImg], (xpos,ypos)) elif deltaX == 0 and pressionado == 1: screen.blit(imagesesquerda[0], (xpos,ypos)) elif deltaX == 0 and pressionado == 2: screen.blit(imagesdireita[0], (xpos,ypos)) pygame.display.flip() clock.tick(60)

Quando temos o valor do delta maior ou menor que zero (estritamente) significa que estamos apertando as teclas direcionais e movimentando o personagem para direita ou esquerda, por isso logo em seguida temos o código do "screen.blit" responsável pelas imagens da direita ou da esquerda, conforme a tecla que foi apertada. Mas quando for zero, significa ausência de tecla apertada e temos duas possibilidades: ter uma imagem específica carregada na posição de frente ou um contador de estado que guarde qual foi a última tecla utilizada (esse é a situação que utilizaremos no nosso exemplo). Com os dois "elif deltaX == 0 and pressionado == " temos além da verificação do deltaX igual a zero, a verificação do estado "pressionado", que se observamos no código das teclas acima, quando o valor de "pressionado" é igual a 1 era na tecla esquerda e 2 na tecla da direita, o que permite que se guarde essa memória e, exiba na tela o "screen.blit" de acordo com a posição correta que acabou de ser teclada. 

Agora é a sua vez, procure inserir novas imagens de outros personagens e tente fazer as adaptações. E se precisar utilizar outras teclas, como proceder? Deixe nos comentários suas descobertas e até a próxima.