Neste segundo post, vamos melhorar nosso jogo.Embora a nova versao rode em Python, ainda esta muito anos 80.A primeira coisa a corrigir e a animacao. Como estamos usando um sistema de coordenadas de 280 por 192 pontos para simular as coordenadas do Apple, multiplicamos cada coordenada por 4 na hora de desenhar. Para deixar parecido com o Apple, eu reduzi o numero de frames a 8 frames por segundo. Por isso a animacao da tantos saltos! Para fazer com que rode a 60 frames, temos que multiplicar as velocidades pela razao entre o numero de frames antigos e o novo: 8/60. A nova versao define algumas constantes para isso:FRAMES_ORIGINAL = 8FRAMES_NOVO = 60RATIO = FRAMES_ORIGINAL / FRAMES_NOVOOlhando o codigo, fica facil perceber que o tiro, o aviao e as bases sao objetos. Vamos extrair o codigo do jogo e dividir as operacoes em atualiza e desenha. No caso, atualiza calcula a nova posicao do objeto e desenha realiza o desenho em si.class Aviao: def __init__(self, jogo, cor=3): self.cor = cor self.velocidade_aviao = (random.randint(0, 6) + 4) * RATIO self.altura_do_aviao = 159 - (random.randint(0, 135) + 11) self.posicao_do_aviao = self.velocidade_aviao self.ativo = True self.jogo = jogo def desenha(self): y = self.altura_do_aviao x = self.posicao_do_aviao set_color(self.cor) pyglet.graphics.draw(6, pyglet.gl.GL_LINE_LOOP, ('v2f', (x, y, x, y - 8, x + 3, y - 2, x + 12, y - 2, x + 14, y, x, y))) def desativa(self): self.ativo = False self.jogo.desativa(self) def atualiza(self): self.posicao_do_aviao += self.velocidade_aviao if self.posicao_do_aviao > 265: self.desativa() O codigo completo pode ser visto aqui:Tente entender como a forma de desenhar em etapas, separando o desenho da atualizacao, permite que exibamos a mensagem com a imagem do jogo no fundo, ao inves da tela preta..Os proximos passos sao:Limpar as classesVarios avioesMultiplos tiros.Generalizar os objetos do jogo em uma super classe.Exibir um placarAtribuir teclas para atirar e jogar de novo ou sair.Ate o proximo! Continuando a serie sobre o modulo asyncio do Python 3.4, vou apresentar as corotinas e como elas simplificam a escrita de nossos programas com o loop de eventos. Com a saida do Python 3.4, eu atualizei o livro de Introducao a Programacao com Python. Alguns assuntos fogem ao escopo do livro que e destinado a iniciantes. Eu estou continuando uma serie de posts curtos sobre alguns topicos que acho interessantes e quem sabe ate podem virar base para um novo livro. Clique aqui para ler o primeiro artigo.No artigo anterior, apresentamos uma chamada ao loop de eventos bem simples:import asynciodef print_and_repeat(loop): print('Hello World') loop.call_later(2, print_and_repeat, loop)loop = asyncio.get_event_loop()loop.call_soon(print_and_repeat, loop)loop.run_forever()Vejamos como reescrever este exemplo simples usando corotinas:import asyncio@asyncio.coroutinedef print_and_repeat(loop): while True: print('Hello World') yield from asyncio.sleep(2)loop = asyncio.get_event_loop()try: loop.run_until_complete(print_and_repeat(loop))finally: loop.close()Este exemplo foi extraido da documentacao do Python, vamos ver o que mudou. A principal mudanca no inicio do programa e o uso do decorador @asyncio.coroutine. Este decorador transforma nossa funcao em uma corotina e permite a utilizacao do yield from, como definido na PEP380. Veja que o cabecalho da funcao nao foi alterado, mas que substituimos a chamada de loop.call_later pela combinacao de um while True com um yield from no