Finish enemy and weapon customization, removal, Disable debug stuff, remove bottom movement, add set speed/size

Author: csd4ni3l

assets/graphics/enemy/red_rectangle.png renamed to assets/graphics/default_enemy.png

@@ -1,16 +1,16 @@
 from ursina import *
-from utils.constants import min_enemy_speed, max_enemy_speed, enemy_health, min_enemy_movement, max_enemy_movement
+from utils.constants import enemy_health, min_enemy_movement, max_enemy_movement
 from ursina.shaders import lit_with_shadows_shader
 
 class Enemy(Entity):
-    def __init__(self, player, shootables_parent, x, y, z, texture):
-        super().__init__(parent=shootables_parent, model='cube', collider='box', texture=texture, x=x, y=y, z=z, shader=lit_with_shadows_shader)
+    def __init__(self, speed, size, player, shootables_parent, x, y, z, texture):
+        super().__init__(parent=shootables_parent, model='cube', collider='box', texture=texture, x=x, y=y, z=z, shader=lit_with_shadows_shader, scale=size)
         self.health_bar = Entity(parent=self, y=1.2, model='cube', color=color.red, world_scale=(1.5,.1,.1))
         self.max_hp = enemy_health
         self.hp = self.max_hp
-        self.type = random.choice(["left", "right", "top", "bottom"])
+        self.movement_type = random.choice(["left", "right", "top"])
         self.movement_done = 0
-        self.speed = random.uniform(min_enemy_speed, max_enemy_speed)
+        self.speed = speed
         self.movement_amount = random.uniform(min_enemy_movement, max_enemy_movement)
         self.player = player
 
@@ -26,16 +26,16 @@ def update_path_line(self):
         start = self.position
         end = self.position
 
-        if self.type == "left":
+        if self.movement_type == "left":
             end -= Vec3(max(0.05, remaining), 0, 0)
             scale = Vec3(max(0.05, remaining), 0.05, 0.05)
-        elif self.type == "right":
+        elif self.movement_type == "right":
             end += Vec3(max(0.05, remaining), 0, 0)
             scale = Vec3(max(0.05, remaining), 0.05, 0.05)
-        elif self.type == "top":
+        elif self.movement_type == "top":
             end += Vec3(0, max(0.05, remaining), 0)
             scale = Vec3(0.05, max(0.05, remaining), 0.05)
-        elif self.type == "bottom":
+        elif self.movement_type == "bottom":
             end -= Vec3(0, max(0.05, remaining), 0)
             scale = Vec3(0.05, max(0.05, remaining), 0.05)
 
@@ -49,33 +49,33 @@ def update(self):
         self.health_bar.look_at_2d(self.player, axis="x")
         self.look_at_2d(self.player, axis="y")
 
-        if self.type == "left":
+        if self.movement_type == "left":
             if self.movement_done < self.movement_amount:
                 self.x -= self.speed
                 self.movement_done += self.speed
             else:
-                self.type = "right"
+                self.movement_type = "right"
                 self.movement_done = 0
-        elif self.type == "right":
+        elif self.movement_type == "right":
             if self.movement_done < self.movement_amount:
                 self.x += self.speed
                 self.movement_done += self.speed
             else:
-                self.type = "left"
+                self.movement_type = "left"
                 self.movement_done = 0
-        elif self.type == "top":
+        elif self.movement_type == "top":
             if self.movement_done < self.movement_amount:
                 self.y += self.speed
                 self.movement_done += self.speed
             else:
-                self.type = "bottom"
+                self.movement_type = "bottom"
                 self.movement_done = 0
-        elif self.type == "bottom":
+        elif self.movement_type == "bottom":
             if self.movement_done < self.movement_amount:
                 self.y -= self.speed
                 self.movement_done += self.speed
             else:
-                self.type = "top"
+                self.movement_type = "top"
                 self.movement_done = 0
 
         self.update_path_line()

game/enemy.py

@@ -2,7 +2,7 @@
 from game.player import Player
 from game.enemy import Enemy
 
-from utils.constants import min_enemy_y, max_enemy_y
+from utils.constants import min_enemy_y, max_enemy_y, enemies
 
 from ursina import *
 from ursina.shaders import lit_with_shadows_shader
@@ -26,8 +26,7 @@ def __init__(self, pypresence_client) -> None:
         with open("settings.json", "r") as file:
             self.settings_dict = json.load(file)
 
-        self.enemy_image_dir = self.settings_dict.get("enemy_image_directory", "assets/graphics/enemy")
-        self.enemy_file_names = [file_name for file_name in os.listdir(self.enemy_image_dir) if file_name.split(".")[1] in ["png", "jpg", "JPG"]]
+        self.enemy_types = self.settings_dict.get("enemies", enemies)
 
         self.ground = Entity(model='plane', collider='box', scale=64, texture='grass', texture_scale=(4,4), shader=lit_with_shadows_shader)
 
@@ -58,14 +57,18 @@ def __init__(self, pypresence_client) -> None:
 
     def summon_enemy(self):
         if not len(self.enemies) >= 50:
+            enemy_stats = random.choice(list(self.enemy_types.items()))[1]
+            speed, size, image_path = enemy_stats["speed"], enemy_stats["size"], enemy_stats["image"]
             self.enemies.append(
                 Enemy(
+                    speed,
+                    size,
                     self.player, 
                     self.shootables_parent,
                     self.player.x + (random.randint(12, 24) * random.choice([1, -1])),
                     random.randint(min_enemy_y, max_enemy_y),
                     self.player.z + (random.randint(12, 24) * random.choice([1, -1])),
-                    Texture(Path(os.path.join(self.enemy_image_dir, random.choice(self.enemy_file_names))))
+                    Texture(Path(image_path))
                 )
             )
 

game/game.py

@@ -5,7 +5,7 @@
 from ursina.prefabs.first_person_controller import FirstPersonController
 
 from utils.preload import death_sound
-from utils.constants import max_enemy_speed, weapons
+from utils.constants import weapons
 
 import json
 
@@ -46,7 +46,7 @@ def update(self):
 
         self.x = max(-16, min(self.x, 16))
         self.z = max(-16, min(self.z, 16))
-        self.info_label.text = f"High Score: {self.high_score} Score: {self.score} Hits: {self.shots_fired}/{self.shots_hit} Accuracy: {round(self.accuracy, 2)}%"
+        self.info_label.text = f"Score: {self.score} High Score: {self.high_score} Hits: {self.shots_fired}/{self.shots_hit} Accuracy: {round(self.accuracy, 2)}%"
 
         weapon_name = self.inventory.slot_names[self.inventory.current_slot]
         self.gun.texture = Texture(Path(self.settings_dict.get("weapons", weapons)[weapon_name]["image"]))
@@ -58,7 +58,7 @@ def update(self):
 
         if time.perf_counter() - self.last_presence_update >= 3:
             self.last_presence_update = time.perf_counter()
-            self.pypresence_client.update(state='Training Aim', details=f"High Score: {self.high_score} Score: {self.score} Hits: {self.shots_fired}/{self.shots_hit} Accuracy: {round(self.accuracy, 2)}%")
+            self.pypresence_client.update(state='Training Aim', details=f"Score: {self.score} High Score: {self.high_score} Hits: {self.shots_fired}/{self.shots_hit} Accuracy: {round(self.accuracy, 2)}%")
 
     def summon_enemy(self):
         pass
@@ -79,7 +79,7 @@ def shoot(self):
                 mouse.hovered_entity.hp -= self.weapon_dmg
                 mouse.hovered_entity.blink(color.red)
 
-                self.score += int(distance(mouse.hovered_entity, self) * (mouse.hovered_entity.speed / max_enemy_speed))
+                self.score += int(distance(mouse.hovered_entity, self))
 
                 self.shots_hit += 1