1. #!/usr/bin/env python
2. # -*- coding: utf-8 -*-
4. import pygame
5. from scheduler import Scheduler
8. WHITE = 255, 255, 255
9. RED = 255, 0, 0
10. BLUE = 0, 0, 255
13. class AnimatedScale(object):
15. def __init__(self, surface, size):
16. self.surface = surface
17. self.size = size
18. self.positions = self._get_pos_path(surface.get_size(), size)
20. def _get_pos_addends(self, a, b):
21. dist_x = float(a[0] - b[0]) * -1
22. dist_y = float(a[1] - b[1]) * -1
23. loops = max(abs(dist_x), abs(dist_y))
24. return (loops, (dist_x / loops if loops > 0 else 0,
25. dist_y / loops if loops > 0 else 0))
27. def _get_pos_path(self, a, b):
28. loops, (add_x, add_y) = self._get_pos_addends(a, b)
29. for i in range(1, int(loops + 1)):
30. yield int(a[0] + round(add_x*i)), int(a[1] + round(add_y*i))
32. def update(self):
33. return pygame.transform.smoothscale(
34. self.surface, next(self.positions))
37. class Main(object):
39. def __init__(self):
40. pygame.init()
42. self.screen = pygame.display.set_mode((600, 400))
43. pygame.display.set_caption("Transformación del panadero")
44. run = True
45. self.moving = False
46. self.stage = 0
47. self.scaling = False
48. self.scaling_sprites = []
50. self.create_surfaces()
51. pygame.draw.rect(self.first, RED, [0, 0, 252, 252 / 2])
52. pygame.draw.rect(self.second, BLUE, [0, 0, 252, 252 / 2])
54. self.screen.fill(WHITE)
56. scheduler = Scheduler()
57. scheduler.add(0.01, 0, self.animate_sprite_movement)
58. scheduler.add(2, 0, self.handle_stage)
60. from time import sleep
61. sleep(15)
63. while run:
64. for event in pygame.event.get():
65. if event.type == pygame.QUIT:
66. run = False
67. break
68. scheduler.run()
69. pygame.display.flip()
71. pygame.quit()
73. def animate_sprite_movement(self):
74. if self.scaling:
75. for i, animated_scale in enumerate(self.scaling_sprites):
76. try:
77. surface = animated_scale.update()
78. except StopIteration:
79. self.scaling = False
80. if i == len(self.scaling_sprites) - 1:
81. self.stage += 1
82. self.scaling_sprites = []
83. else:
84. self.surface = surface
85. if not i:
86. self.clean()
87. self.screen.blit(self.surface,
88. (0, self.surface.get_size()[1] * i))
89. elif self.moving:
90. if self.offset[1] < 252 / 2:
91. self.offset[1] += 1
92. else:
93. self.offset[0] -= 1
95. self.clean()
96. self.screen.blit(self.first, (0, 0))
97. self.screen.blit(self.second, self.offset)
99. if self.offset[0] == 0:
100. self.moving = False
101. self.stage = 0
103. def clean(self):
104. pygame.draw.rect(self.screen, WHITE, [0, 0, 504, 504])
106. def create_surfaces(self):
107. self.first = pygame.Surface((252, 252 / 2))
108. self.second = self.first.copy()
110. def handle_stage(self):
111. if self.stage == 0:
112. self.clean()
113. self.screen.blit(self.first, (0, 0))
114. self.screen.blit(self.second, (0, 252 / 2))
115. self.stage += 1
117. elif self.stage == 1 and not self.scaling:
118. self.scaling = True
119. for sprite in (self.first, self.second):
120. self.scaling_sprites.append(
121. AnimatedScale(sprite, (252 * 2, 252 / 4))
122. )
123. self.screen.blit(self.first, (0, 0))
124. self.screen.blit(self.second, (0, 252 / 4))
126. elif self.stage == 2 and not self.moving:
127. self.offset = [252, 0]
128. self.moving = True
129. self.create_surfaces()
130. self.first.blit(
131. self.screen, (0, 0), [0, 0, 252, 252 / 2])
132. self.second.blit(
133. self.screen, (0, 0), [252, 0, 252, 252 / 2])
136. if __name__ == "__main__":
137. Main()

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import pygame
from scheduler import Scheduler


WHITE = 255, 255, 255
RED = 255, 0, 0
BLUE = 0, 0, 255


class AnimatedScale(object):
    
    def __init__(self, surface, size):
        self.surface = surface
        self.size = size
        self.positions = self._get_pos_path(surface.get_size(), size)
    
    def _get_pos_addends(self, a, b):
        dist_x = float(a[0] - b[0]) * -1
        dist_y = float(a[1] - b[1]) * -1
        loops = max(abs(dist_x), abs(dist_y))
        return (loops, (dist_x / loops if loops > 0 else 0,
                        dist_y / loops if loops > 0 else 0))

    def _get_pos_path(self, a, b):
        loops, (add_x, add_y) = self._get_pos_addends(a, b)
        for i in range(1, int(loops + 1)):
            yield int(a[0] + round(add_x*i)), int(a[1] + round(add_y*i))
    
    def update(self):
        return pygame.transform.smoothscale(
            self.surface, next(self.positions))


class Main(object):
    
    def __init__(self):
        pygame.init()

        self.screen = pygame.display.set_mode((600, 400))
        pygame.display.set_caption("Transformación del panadero")
        run = True
        self.moving = False
        self.stage = 0
        self.scaling = False
        self.scaling_sprites = []
        
        self.create_surfaces()
        pygame.draw.rect(self.first, RED, [0, 0, 252, 252 / 2])
        pygame.draw.rect(self.second, BLUE, [0, 0, 252, 252 / 2])
        
        self.screen.fill(WHITE)
        
        scheduler = Scheduler()
        scheduler.add(0.01, 0, self.animate_sprite_movement)
        scheduler.add(2, 0, self.handle_stage)
        
        from time import sleep
        sleep(15)
        
        while run:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    run = False
                    break
            scheduler.run()
            pygame.display.flip()

        pygame.quit()
        
    def animate_sprite_movement(self):
        if self.scaling:
            for i, animated_scale in enumerate(self.scaling_sprites):
                try:
                    surface = animated_scale.update()
                except StopIteration:
                    self.scaling = False
                    if i == len(self.scaling_sprites) - 1:
                        self.stage += 1
                        self.scaling_sprites = []
                else:
                    self.surface = surface
                    if not i:
                        self.clean()
                    self.screen.blit(self.surface,
                        (0, self.surface.get_size()[1] * i))
        elif self.moving:
            if self.offset[1] < 252 / 2:
                self.offset[1] += 1
            else:
                self.offset[0] -= 1
            
            self.clean()
            self.screen.blit(self.first, (0, 0))
            self.screen.blit(self.second, self.offset)
            
            if self.offset[0] == 0:
                self.moving = False
                self.stage = 0
    
    def clean(self):
        pygame.draw.rect(self.screen, WHITE, [0, 0, 504, 504])
    
    def create_surfaces(self):
        self.first = pygame.Surface((252, 252 / 2))
        self.second = self.first.copy()
    
    def handle_stage(self):
        if self.stage == 0:
            self.clean()
            self.screen.blit(self.first, (0, 0))
            self.screen.blit(self.second, (0, 252 / 2))
            self.stage += 1
        
        elif self.stage == 1 and not self.scaling:
            self.scaling = True
            for sprite in (self.first, self.second):
                self.scaling_sprites.append(
                    AnimatedScale(sprite, (252 * 2, 252 / 4))
                )
            self.screen.blit(self.first, (0, 0))
            self.screen.blit(self.second, (0, 252 / 4))
        
        elif self.stage == 2 and not self.moving:
            self.offset = [252, 0]
            self.moving = True
            self.create_surfaces()
            self.first.blit(
                self.screen, (0, 0), [0, 0, 252, 252 / 2])
            self.second.blit(
                self.screen, (0, 0), [252, 0, 252, 252 / 2])


if __name__ == "__main__":
    Main()