Animação funcionando sem trocar caracteres quando mortos

renzon · renzon · commit be1cca35b0ea · 2014-07-18T14:51:23.000-03:00
diff --git a/atores.py b/atores.py
@@ -17,10 +17,9 @@ def caracter(self, tempo):
         else:
             return self._caracter_destruido
 
-    def __init__(self, x=0, y=0, canvas=None):
+    def __init__(self, x=0, y=0):
         self.y = y
         self.x = x
-        self.canvas = canvas
         self._tempo_de_colisao = None
 
     def status(self, tempo):
@@ -59,14 +58,14 @@ class Porco(Ator):
     _caracter_ativo = '@'
 
 
-GRAVIDADE = 30  # m/s^2
+GRAVIDADE = 10  # m/s^2
 
 
 class Passaro(Ator):
     _velocidade_scalar = None
 
-    def __init__(self, x=0, y=0, canvas=None):
-        super().__init__(x, y, canvas)
+    def __init__(self, x=0, y=0):
+        super().__init__(x, y)
         self._x_inicial = x
         self._y_inicial = y
         self._tempo_de_lancamento = None
diff --git a/fase.py b/fase.py
@@ -23,14 +23,17 @@ def __init__(self):
         self._porcos = []
         self._obstaculos = []
 
+    def _adicionar_ator(self, lista, *atores):
+        lista.extend(atores)
+
     def adicionar_obstaculo(self, *obstaculos):
-        self._obstaculos.extend(obstaculos)
+        self._adicionar_ator(self._obstaculos, *obstaculos)
 
     def adicionar_porco(self, *porcos):
-        self._porcos.extend(porcos)
+        self._adicionar_ator(self._porcos, *porcos)
 
     def adicionar_passaro(self, *passaros):
-        self._passaros.extend(passaros)
+        self._adicionar_ator(self._passaros, *passaros)
 
     def acabou(self, tempo):
         return not self._existe_porco_ativo(tempo) or not self._existe_passaro_ativo(tempo)
@@ -55,7 +58,7 @@ def calcular_pontos(self, tempo):
         return pontos
 
     def _transformar_em_ponto(self, ator, tempo):
-        return Ponto(ator.x, ator.y, ator.caracter(tempo), ator.canvas)
+        return Ponto(ator.x, ator.y, ator.caracter(tempo))
 
     def _calcular_ponto_de_passaro(self, passaro, tempo, ):
         passaro.calcular_posicao(tempo)
diff --git a/fase_tkinter.py b/fase_tkinter.py
@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+from itertools import chain
+from tkinter import PhotoImage, NW
+from atores import ATIVO
+from fase import Ponto, Fase
+
+PASSARO_VERMELHO = "images/passaro_vermelho.gif"
+PASSARO_AMARELHO = "images/passaro_amarelo.gif"
+PORCO = "images/porco.gif"
+PORCO_MORTO = "images/porco_morto.gif"
+OBSTACULO = "images/obstaculo.gif"
+TRANSPARENTE = "images/transparente.gif"
+
+CARACTER_PARA_CAMINHO_IMG_DCT = {'D': PASSARO_VERMELHO, '>': PASSARO_AMARELHO, '@': PORCO, 'O': OBSTACULO,
+                                 '+': PORCO_MORTO}
+
+caracter_para_img = {}
+
+
+def get_imagem(caracter):
+    # img = caracter_para_img.get(caracter)
+    # if img is None:
+    #     caracter_para_img[caracter] = PhotoImage(file=CARACTER_PARA_CAMINHO_IMG_DCT.get(caracter, TRANSPARENTE))
+    return PhotoImage(file=CARACTER_PARA_CAMINHO_IMG_DCT.get(caracter, TRANSPARENTE))
+    # return img
+
+
+def ator_para_cooredenadas(ator):
+    return ator.x, ator.y
+
+
+def criar_imagem(canvas, ator):
+    imagem = get_imagem(ator.caracter(0))
+    return imagem, canvas.create_image(ator_para_cooredenadas(ator),
+                                       image=imagem,
+                                       anchor=NW)
+
+
+class FaseTk(Fase):
+    def __init__(self, canvas):
+        super().__init__()
+        self.canvas = canvas
+
+    def _adicionar_ator(self, lista, *atores):
+        super()._adicionar_ator(lista, *atores)
+        for ator in atores:
+            ator.img, ator.img_id = criar_imagem(self.canvas, ator)
+
+    def _transformar_em_ponto(self, ator, tempo):
+        ponto = super()._transformar_em_ponto(ator, tempo)
+        ponto.canvas_img = ator.img
+        ponto.canvas_img_id = ator.img_id
+        ponto.new_photo_img = get_imagem(ponto.caracter)
+        return ponto
+
diff --git a/images/transparente.gif b/images/transparente.gif
diff --git a/placa_grafica.py b/placa_grafica.py
@@ -3,6 +3,7 @@
 import platform
 import time
 import sys
+from templates import FIM
 
 try:
     import msvcrt
diff --git a/placa_grafica_tkinter.py b/placa_grafica_tkinter.py
@@ -1,10 +1,11 @@
-#coding: utf-8
+# coding: utf-8
 import time
 
 from tkinter import *
 from tkinter import ttk
 from fase import Fase
 from atores import PassaroVermelho, PassaroAmarelo, Porco, Obstaculo
+from fase_tkinter import FaseTk
 
 
 def get_angulo(event):
@@ -13,31 +14,10 @@ def get_angulo(event):
     popup_angulo.destroy()
 
 
-root = Tk()
-root.title("Python Birds")
-root.geometry("800x600")
-root.resizable(0, 0)
+ALTURA_DA_TELA = 600  # px
 
-stage = Canvas(root, width=800, height=600)
-bg_image = PhotoImage(file="images/background.gif")
-stage.create_image((0, 0), image=bg_image, anchor=NW)
-stage.pack()
 
-passaro_vermelho_img = PhotoImage(file="images/passaro_vermelho.gif")
-passaro_vermelho = stage.create_image((40, 482), image=passaro_vermelho_img, anchor=NW)
 
-passaro_amarelo_img = PhotoImage(file="images/passaro_amarelo.gif")
-passaro_amarelo = stage.create_image((30, 482), image=passaro_amarelo_img, anchor=NW)
-
-passaro_amarelo2 = stage.create_image((20, 482), image=passaro_amarelo_img, anchor=NW)
-
-porco_img = PhotoImage(file="images/porco.gif")
-porco = stage.create_image((700, 482), image=porco_img, anchor=NW)
-
-porco2 = stage.create_image((480, 482), image=porco_img, anchor=NW)
-
-obstaculo_img = PhotoImage(file="images/obstaculo.gif")
-obstaculo = stage.create_image((300, 300), image=obstaculo_img, anchor=NW)
 
 
 # popup_angulo = Toplevel(root)
@@ -48,59 +28,56 @@ def get_angulo(event):
 # b.pack(pady=5)
 
 
-def mover(obj, x, y):
-    stage.move(obj, x, y)
-    stage.update()
 
-tempo = 0
-passo = 0.1
-delta_t = 0.1
 
-passaros = [passaro_vermelho, passaro_amarelo]
-fase = None
 
-ultima_posicao = {}
 
-def mover(canvas_id, posicao_atual, proxima_posicao):
-    if proxima_posicao.y == 0: 
-        return
+def plotar(canvas, ponto):
+    multiplicador = 10  # 10 px/m
+    x = multiplicador * ponto.x
+    y = ALTURA_DA_TELA - ponto.y * multiplicador - 11 * multiplicador
+    canvas.coords(ponto.canvas_img_id, (x, y))
 
-    x = posicao_atual.x - proxima_posicao.x
-    y = posicao_atual.y - proxima_posicao.y
-    stage.move(canvas_id, -x * 30, y * 30)
 
-def animar():
-    global tempo, delta_t, fase       
-    tempo += delta_t
-    time.sleep(passo)
-    pontos_cartesianos = fase.calcular_pontos(tempo)
-    for ponto in pontos_cartesianos:
-        canvas_id = ponto.canvas
-        ultima_posicao[canvas_id] = ultima_posicao.get(canvas_id, ponto)
-        mover(canvas_id, ultima_posicao[canvas_id], ponto)
-        #verificar aqui colisão
+def animar(tela,fase,passo=0.1, delta_t=0.1):
+    tempo=0
+    def _animar():
+        nonlocal tempo
+        tempo += delta_t
+        time.sleep(passo)
+        for ponto in fase.calcular_pontos(tempo):
+            plotar(fase.canvas, ponto)
+        tela.after(1, _animar)
 
 
-        ultima_posicao[canvas_id] = ponto
 
-    root.after(1, animar)
+    tela.after(1, _animar)
+    tela.mainloop()
 
 
-fase = Fase()
-passaros = [PassaroVermelho(3, 3, passaro_vermelho), PassaroAmarelo(3, 3, passaro_amarelo), PassaroAmarelo(3, 3, passaro_amarelo2)]
-porcos = [Porco(78, 1, porco), Porco(78, 1, porco2)]
-obstaculos = [Obstaculo(31, 10, obstaculo)]
+if __name__ == '__main__':
+    root = Tk()
+    root.title("Python Birds")
+    root.geometry("800x600")
+    root.resizable(0, 0)
 
-fase.adicionar_passaro(*passaros)
-fase.adicionar_porco(*porcos)
-fase.adicionar_obstaculo(*obstaculos)
+    stage = Canvas(root, width=800, height=ALTURA_DA_TELA)
+    bg_image = PhotoImage(file="images/background.gif")
+    stage.create_image((0, 0), image=bg_image, anchor=NW)
+    stage.pack()
+    fase = FaseTk(stage)
+    passaros = [PassaroVermelho(3, 3), PassaroAmarelo(3, 3), PassaroAmarelo(3, 3)]
+    porcos = [Porco(75, 1), Porco(70, 1)]
+    obstaculos = [Obstaculo(31, 10)]
 
+    fase.adicionar_passaro(*passaros)
+    fase.adicionar_porco(*porcos)
+    fase.adicionar_obstaculo(*obstaculos)
 
-fase.lancar(45, 1)
-fase.lancar(64, 2)
-fase.lancar(23, 3)
+    fase.lancar(45, 1)
+    fase.lancar(64, 2)
+    fase.lancar(23, 3)
 
-root.after(1, animar)
-root.mainloop()
+    animar(root,fase)
 
-# root.wait_window(popup_angulo)
+    # root.wait_window(popup_angulo)
