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!