Added animation to the OmnidirectionalActor class.

actor.py

@@ -244,8 +244,12 @@ class OmnidirectionalActor(BaseActor):
         self.constraint_max_x = 1024
         self.constraint_max_y = 768
         
-        self.acc_fract_x = ((0.9 * float(pygame.display.Info().current_w)) / 1024.0)
+        self.acc_fract_x = ((0.6 * float(pygame.display.Info().current_w)) / 1024.0)
-        self.acc_fract_y = ((0.9 * float(pygame.display.Info().current_h)) / 768.0)
+        self.acc_fract_y = ((0.6 * float(pygame.display.Info().current_h)) / 768.0)
+
+        self.idle_frames = []
+        self.moving_frames = []
+        self.current_frame = 0
 
     def is_moving(self):
         return self.moving
@@ -301,3 +305,89 @@ class OmnidirectionalActor(BaseActor):
         self.rect.center = (self.position[0], self.position[1])
 
         self.then = now
+
+    def add_idle_frame(self, frame):
+        self.idle_frames.append(frame.copy())
+
+    def change_idle_frame(self, frame_index, frame):
+        if frame_index < 0 or frame_index >= len(self.idle_frames):
+            pass
+        else:
+            self.idle_frames[frame_index] = frame.copy()
+
+    def remove_idle_frame(self, frame_index):
+        if frame_index < 1 or frame_index >= len(self.idle_frames):
+            # The first frame (frame 0) cannot be removed.
+            pass
+        else:
+            self.idle_frames.pop(im_point)
+            if self.current_frame >= len(self.idle_frames):
+                self.current_frame = len(self.idle_frames) - 1
+
+    def add_moving_frame(self, frame):
+        self.moving_frames.append(frame.copy())
+
+    def change_moving_frame(self, frame_index, frame):
+        if frame_index < 0 or frame_index >= len(self.moving_frames):
+            pass
+        else:
+            self.moving_frames[frame_index] = frame.copy()
+
+    def remove_moving_frame(self, frame_index):
+        if frame_index < 1 or frame_index >= len(self.moving_frames):
+            # The first frame (frame 0) cannot be removed.
+            pass
+        else:
+            self.moving_frames.pop(im_point)
+            if self.current_frame >= len(self.moving_frames):
+                self.current_frame = len(self.moving_frames) - 1
+
+    def draw(self, canvas):
+        if self.image is not None:
+            if not self.animated:
+                canvas.blit(self.image, self.rect)
+            else:
+                frame = None
+                anim_now = pygame.time.get_ticks()
+                delta_t = anim_now - self.anim_then
+                if not self.stopped and delta_t >= self.time_per_frame:
+                    self.current_frame = (self.current_frame + (delta_t // self.time_per_frame)) % 2
+                    self.anim_then = anim_now
+                if not self.moving:
+                    if self.angle >= -(math_utils.PI / 4.0) and self.angle < math_utils.PI / 4.0:
+                        # Between -45 and 45 degrees.
+                        frame = self.idle_frames[0]
+                    elif self.angle >= math_utils.PI / 4.0 and self.angle < 3.0 * (math_utils.PI / 4.0):
+                        # Between 45 and 135 degrees.
+                        frame = self.idle_frames[1]
+                    elif self.angle >= 3.0 * (math_utils.PI / 4.0) and self.angle <= math_utils.PI:
+                        # Between 135 and 180 degrees.
+                        frame = self.idle_frames[2]
+                    elif self.angle >= -3.0 * (math_utils.PI / 4.0) and self.angle < -(math_utils.PI / 4.0):
+                        # Between -135 and -45 degrees.
+                        frame = self.idle_frames[3]
+                    else:
+                        # Between -180 and -135 degrees.
+                        frame = self.idle_frames[2]
+                else:
+                    if self.angle >= -(math_utils.PI / 4.0) and self.angle < math_utils.PI / 4.0:
+                        # Between -45 and 45 degrees.
+                        base_frame = 0
+                    elif self.angle >= math_utils.PI / 4.0 and self.angle < 3.0 * (math_utils.PI / 4.0):
+                        # Between 45 and 135 degrees.
+                        base_frame = 2
+                    elif self.angle >= 3.0 * (math_utils.PI / 4.0) and self.angle <= math_utils.PI:
+                        # Between 135 and 180 degrees.
+                        base_frame = 4
+                    elif self.angle >= -3.0 * (math_utils.PI / 4.0) and self.angle < -(math_utils.PI / 4.0):
+                        # Between -135 and -45 degrees.
+                        base_frame = 6
+                    else:
+                        # Between -180 and -135 degrees.
+                        base_frame = 4
+                    frame = self.moving_frames[self.current_frame + base_frame]
+                frame_rect = frame.get_rect()
+                frame_rect.center = (self.position[0], self.position[1])
+                canvas.blit(frame, frame_rect)
+        else:
+            pygame.draw.rect(canvas, self.color, self.rect)

ingame.py

@@ -36,10 +36,39 @@ class InGameState(BaseState):
        self.bckg_y = 0
 
        play_img = imloader.cached_image_loader.get_image_to_screen_percent('gfx/Player/player_idle_front.png')
-       self.player = actor.OmnidirectionalActor(0, play_img, "Player", False)
+       self.player = actor.OmnidirectionalActor(0, play_img, "Player", True)
-       self.player.set_angle(90)
+       self.player.set_fps(5)
+       self.player.set_angle(math_utils.PI / 2.0)
        self.player.set_velocity([0, 0])
 
+       # Add idle frames to the player:
+       play_img = imloader.cached_image_loader.get_image_to_screen_percent('gfx/Player/player_idle_side.png')
+       self.player.add_idle_frame(play_img)
+       play_img = imloader.cached_image_loader.get_image_to_screen_percent('gfx/Player/player_idle_front.png')
+       self.player.add_idle_frame(play_img)
+       play_img = imloader.cached_image_loader.get_image_to_screen_percent('gfx/Player/player_idle_side2.png')
+       self.player.add_idle_frame(play_img)
+       play_img = imloader.cached_image_loader.get_image_to_screen_percent('gfx/Player/player_idle_back.png')
+       self.player.add_idle_frame(play_img)
+
+       # Add moving frames to the player.
+       play_img = imloader.cached_image_loader.get_image_to_screen_percent('gfx/Player/player_walk_side_HUG_1.png')
+       self.player.add_moving_frame(play_img)
+       play_img = imloader.cached_image_loader.get_image_to_screen_percent('gfx/Player/player_walk_side_HUG_2.png')
+       self.player.add_moving_frame(play_img)
+       play_img = imloader.cached_image_loader.get_image_to_screen_percent('gfx/Player/player_walk_HUG_front_1.png')
+       self.player.add_moving_frame(play_img)
+       play_img = imloader.cached_image_loader.get_image_to_screen_percent('gfx/Player/player_walk_HUG_front_2.png')
+       self.player.add_moving_frame(play_img)
+       play_img = imloader.cached_image_loader.get_image_to_screen_percent('gfx/Player/player_walk_side_HUG_1_flipped.png')
+       self.player.add_moving_frame(play_img)
+       play_img = imloader.cached_image_loader.get_image_to_screen_percent('gfx/Player/player_walk_side_HUG_2_flipped.png')
+       self.player.add_moving_frame(play_img)
+       play_img = imloader.cached_image_loader.get_image_to_screen_percent('gfx/Player/player_walk_back_HUG_1.png')
+       self.player.add_moving_frame(play_img)
+       play_img = imloader.cached_image_loader.get_image_to_screen_percent('gfx/Player/player_walk_back_HUG_2.png')
+       self.player.add_moving_frame(play_img)
+
        # Create a surface for the background.
        bg_w = int(float(pygame.display.Info().current_w * 1280) / 1024.0)
        bg_h = int(float(pygame.display.Info().current_h * 1024) / 768.0)
@@ -163,7 +192,7 @@ class InGameState(BaseState):
              self.player.reset_then()
              self.then = pygame.time.get_ticks()
 
-          self.done = not player.PLAYERS[1].is_alive()
+          #self.done = not player.PLAYERS[1].is_alive()
 
           now = pygame.time.get_ticks()
           delta_t = now - self.then
@@ -172,6 +201,7 @@ class InGameState(BaseState):
              self.then = now
              if self.time_left <= 0:
                 player.PLAYERS[1].kill()
+                self.done = True
 
           if not self.done:
              if self.cursor_x != self.screen_center[0] or self.cursor_y != self.screen_center[1]:
@@ -184,28 +214,34 @@ class InGameState(BaseState):
                 vec_2 = math_utils.normalize_vector_2D(vec_2)
                 self.player.set_angle(math_utils.angle_vectors_2D(self.vec_1, vec_2))
 
-                self.player.update()
+             self.player.update()
 
-                self.score_text = self.font.render("Puntos:   " + str(player.PLAYERS[1].get_score()), True, (0, 0, 0))
+             self.score_text = self.font.render("Puntos:   " + str(player.PLAYERS[1].get_score()), True, (0, 0, 0))
-                if self.time_left > 30:
+             if self.time_left > 30:
-                   self.time_text = self.font.render("Tiempo:   " + str(self.time_left), True, (0, 0, 0))
+                self.time_text = self.font.render("Tiempo:   " + str(self.time_left), True, (0, 0, 0))
-                else:
+             else:
-                   self.time_text = self.font.render("Tiempo:   " + str(max(self.time_left, 0)), True, (255, 0, 0))
+                self.time_text = self.font.render("Tiempo:   " + str(max(self.time_left, 0)), True, (255, 0, 0))
-                self.wave_text = self.font.render("Oleada:   " + str(self.wave), True, (0, 0, 0))
+             self.wave_text = self.font.render("Oleada:   " + str(self.wave), True, (0, 0, 0))
 
              self.recenter_view()
 
           elif self.time_left < -3:
+             # Reset everything.
              self.time_left = 190
              self.wave = 0
-             self.player.set_angle(90)
-             self.player.set_velocity([0, 0])
              self.user_click = False
              self.done = False
+
+             # Reset the player.
+             self.player.set_angle(90)
+             self.player.set_velocity([0, 0])
              self.player.stop()
              bg_w = int(float(pygame.display.Info().current_w * 1280) / 1024.0)
              bg_h = int(float(pygame.display.Info().current_h * 1024) / 768.0)
              self.player.set_position([bg_w // 2, bg_h // 2])
+
+             # TODO: Destroy all NPC's.
+
              player.PLAYERS[1].revive()
              self.next_transition = VALID_STATES['SCORE']