Merge pull request #16 from mdcdxcvi/fb-#15-respawn

Add respawn to player. #6 #12 #15

reflexy/constants.py

@@ -4,13 +4,17 @@
 SCREEN_WIDTH = 680
 SCREEN_HEIGHT = 420
 PLAYER_SPEED = 10
-SPIDER_SPEED = 2
-COOLDOWN_FIRE = 2
-COOLDOWN_HIT = 1
+PLAYER_WIDTH = 87
+PLAYER_HEIGHT = 70
+SPIDER_SPEED = 1.7
+SPAWN_SPIDER = 5
+COOLDOWN_FIRE = 2.5
+COOLDOWN_IMMUNE = 1
+COOLDOWN_SWORD = 0.5
 FREEZE_TIME = 1
 
 SPIDER_VISION = 200
 
-FONT_SIZE = 60
+FONT_SIZE = 32
 
 CAPTION = "Reflexy"

reflexy/models/player.py

@@ -1,31 +1,72 @@
 import pygame
+import time
 from reflexy.helpers import get_image_path
 from reflexy.constants import (
     SCREEN_WIDTH,
     SCREEN_HEIGHT,
     PLAYER_SPEED,
+    PLAYER_WIDTH,
+    PLAYER_HEIGHT,
+    COOLDOWN_SWORD,
 )
 
 
 class Player(pygame.sprite.Sprite):
     def __init__(self):
         pygame.sprite.Sprite.__init__(self)
 
-        self.image = self.get_surface("player-down.png")
-        self.x = SCREEN_WIDTH / 2
-        self.y = SCREEN_HEIGHT / 2
+        self.images = [
+            self.get_surface(filename)
+            for filename in (
+                [
+                    "player-w-sword-00.png",
+                    "player-w-sword-01.png",
+                    "player-w-sword-02.png",
+                    "player-w-sword-03.png",
+                    "player-w-sword-04.png",
+                    "player-w-sword-05.png",
+                    "player-w-sword-06.png",
+                    "player-w-sword-07.png",
+                ]
+            )
+        ]
+        self.current_image = 0
+        self.image = self.images[self.current_image]
 
-        self.rect = pygame.Rect(self.x, self.y, 128, 64)
+        self.set_spawn()
 
         self.mouse = pygame.mouse.get_pos()
         self.hp = 3
         self.score = 0
 
+        self.cd_attack = 0
+
+        self.dead = False
+        self.attacking = False
+
         self.moveLeft = False
         self.moveRight = False
         self.moveUp = False
         self.moveDown = False
 
+    def set_spawn(self):
+        self.x = SCREEN_WIDTH / 2
+        self.y = SCREEN_HEIGHT / 2
+        self.center = (PLAYER_WIDTH / 2, PLAYER_HEIGHT / 2)
+        self.rect = pygame.Rect(self.x, self.y, self.center[0], self.center[1])
+
+    def attack(self):
+        if self.attacking or time.time() - self.cd_attack > COOLDOWN_SWORD:
+            self.attacking = True
+            self.current_image += 1
+
+            if self.current_image > len(self.images) - 1:
+                self.current_image = 0
+                self.attacking = False
+                self.cd_attack = time.time()
+
+            self.image = self.images[self.current_image]
+
     def update(self):
         if self.moveDown and self.rect.bottom < SCREEN_HEIGHT:
             self.rect.top += PLAYER_SPEED
@@ -36,7 +77,15 @@ def update(self):
         if self.moveRight and self.rect.right < SCREEN_WIDTH:
             self.rect.right += PLAYER_SPEED
 
-    def get_surface(self, filename, angle=0, scale=1):
+        self.center = (
+            self.rect[0] + PLAYER_WIDTH / 2,
+            self.rect[1] + PLAYER_HEIGHT / 2,
+        )
+
+        if self.attacking:
+            self.attack()
+
+    def get_surface(self, filename, angle=0, scale=1.2):
         return pygame.transform.rotozoom(
             pygame.image.load(get_image_path(filename)).convert_alpha(),
             angle,

reflexy/models/ray.py

@@ -10,7 +10,6 @@ def __init__(self, screen, spider_coordenates, direction, aim_angle):
             self.get_surface(filename)
             for filename in (["ray-0.png", "ray-1.png", "ray-2.png", "ray-3.png"])
         ]
-
         self.current_image = 0
         self.image = self.images[self.current_image]
 

reflexy/runner.py

@@ -10,13 +10,13 @@
     CLOCK_TICK,
     FONT_SIZE,
     SPIDER_VISION,
+    SPAWN_SPIDER,
     PLAYER_SPEED,
-    COOLDOWN_HIT,
+    COOLDOWN_IMMUNE,
 )
 from reflexy.helpers import get_image_path, create_pygame_font
 from reflexy.models.player import Player
 from reflexy.models.laser_spider import LaserSpider
-from reflexy.logic.brain import brain, calc_angle
 
 
 class Runner:
@@ -41,16 +41,31 @@ def __init__(self):
         self.player_group.add(self.player)
         self.player_hit = False
         self.cd_player_hit = time.time()
+        self.cd_spawn_spider = time.time()
 
     @staticmethod
     def create_background():
         bg = pygame.image.load(get_image_path("background-field.png"))
         return pygame.transform.scale(bg, (SCREEN_WIDTH, SCREEN_HEIGHT))
 
-    def create_score_text(self, score):
-        return self.text.render(score, True, (255, 255, 255))
+    def create_text(self, text):
+        return self.text.render(text, True, (255, 255, 255))
 
     def has_collision(self):
+        if self.player.attacking:
+            [
+                self.kill_spider(sprite)
+                for sprite in self.enemy_group.sprites()
+                if pygame.sprite.spritecollide(
+                    sprite,
+                    self.player_group,
+                    False,
+                    pygame.sprite.collide_mask,
+                )
+            ]
+
+            return False
+
         return pygame.sprite.groupcollide(
             self.player_group,
             self.enemy_group,
@@ -60,7 +75,10 @@ def has_collision(self):
         )
 
     def has_hit(self):
-        if not self.enemy_group.sprites()[0].ray:
+        if not self.enemy_group.sprites():
+            return False
+
+        if not self.player.attacking or not self.enemy_group.sprites()[0].ray:
             return False
 
         ray = self.enemy_group.sprites()[0].ray
@@ -77,14 +95,20 @@ def has_hit(self):
         )
 
     def hp(self):
-        if (self.has_collision() or self.has_hit()) and not self.player_hit:
-            self.player.hp -= 1
-            self.player_hit = True
-            self.cd_player_hit = time.time()
-            self.player.rect = pygame.Rect(SCREEN_WIDTH / 2, SCREEN_WIDTH / 2, 128, 64)
+        if self.enemy_group.sprites():
+            if (self.has_collision() or self.has_hit()) and not self.player_hit:
+                self.player.hp -= 1
+                self.player_hit = True
+                self.cd_player_hit = time.time()
+                self.player.set_spawn()
+                self.dead = True
+
+            if self.player_hit and time.time() - self.cd_player_hit > COOLDOWN_IMMUNE:
+                self.player_hit = False
 
-        if self.player_hit and time.time() - self.cd_player_hit > COOLDOWN_HIT:
-            self.player_hit = False
+    def kill_spider(self, sprite):
+        sprite.kill()
+        self.player.score += 1
 
     def handle_keys(self, player):
         """Handles keys."""
@@ -123,6 +147,8 @@ def check_events(self):
             if event.type == pygame.KEYUP:
                 if event.key == pygame.K_ESCAPE:
                     pygame.quit()
+                if event.key == pygame.K_SPACE:
+                    self.player.attack()
                 if event.key == pygame.K_LEFT or event.key == pygame.K_a:
                     self.player.moveLeft = False
                 if event.key == pygame.K_RIGHT or event.key == pygame.K_d:
@@ -141,13 +167,17 @@ def update_frame(self):
         for group in [self.enemy_group, self.player_group]:
             group.draw(self.screen)
 
-        self.enemy_group.update(self.screen, self.player.rect)
+        self.enemy_group.update(self.screen, self.player.center)
         self.player_group.update()
 
         self.update_score()
 
         self.screen.blit(
-            self.create_score_text(str(self.player.hp)),
+            self.create_text("Lifes = " + str(self.player.hp)),
+            (FONT_SIZE, SCREEN_HEIGHT / 8),
+        )
+        self.screen.blit(
+            self.create_text(str(self.player.score)),
             ((SCREEN_WIDTH - (FONT_SIZE / 2)) / 2, SCREEN_HEIGHT / 8),
         )
         pygame.display.update()