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!