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

game/enemy.py

@@ -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 @@ class Enemy(Entity):
         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 @@ class Enemy(Entity):
         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/game.py

@@ -2,7 +2,7 @@ from game.inventory import Inventory
 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 @@ class Game():
         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 @@ class Game():
         
     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/player.py

@@ -5,7 +5,7 @@ from ursina.prefabs.ursfx import ursfx
 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 @@ class Player(FirstPersonController):
 
         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 @@ class Player(FirstPersonController):
 
         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 @@ class Player(FirstPersonController):
                 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
 

menus/settings.py

@@ -4,7 +4,7 @@ from ursina.prefabs.dropdown_menu import DropdownMenuButton
 from ursina.prefabs.button_group import ButtonGroup
 
 import pypresence, json, copy
-from utils.utils import FakePyPresence, Dropdown, FileManager
+from utils.utils import FakePyPresence, Dropdown, FileManager, is_float
 from utils.constants import discord_presence_id, settings, settings_start_category
 from utils.preload import music_sound
 
@@ -28,11 +28,17 @@ class Settings:
 
         self.ui += [self.main, self.back, self.category_group]
 
-        self.dmg_inputs = {}
-        self.atk_speed_inputs = {}
+        self.weapon_dmg_inputs = {}
+        self.weapon_atk_speed_inputs = {}
         self.weapon_img_paths = {}
-        self.img_path_buttons = {}
-        self.save_buttons = {}
+        self.weapon_img_path_buttons = {}
+        self.weapon_remove_buttons = {}
+
+        self.enemy_speed_inputs = {}
+        self.enemy_size_inputs = {}
+        self.enemy_img_paths = {}
+        self.enemy_img_path_buttons = {}
+        self.enemy_remove_buttons = {}
 
         self.show(self.category)
 
@@ -46,6 +52,9 @@ class Settings:
         elif category == "Weapons":
             self.weapons()
             return
+        elif category == "Enemies":
+            self.enemies()
+            return
 
         y = .2
 
@@ -101,13 +110,16 @@ class Settings:
         self.dir_file_manager = FileManager(return_folders=True, z=-1)
         self.dir_file_manager.on_submit = lambda value, btn=btn, name=name: self.directory_selected(btn, name, str(value[0]))
 
-    def image_file_selected(self, btn, name, value):
+    def image_file_selected(self, btn, item_type, name, value):
         btn.text = f"Select File ({value})"
-        self.weapon_img_paths[name] = value
+        if item_type == "weapon":
+            self.weapon_img_paths[name] = value
+        elif item_type == "enemy":
+            self.enemy_img_paths[name] = value
 
-    def select_image_file(self, btn, name):
+    def select_image_file(self, btn, name, item_type):
         self.file_manager = FileManager(z=-1)
-        self.file_manager.on_submit = lambda value, btn=btn, name=name: self.image_file_selected(btn, name, str(value[0]))
+        self.file_manager.on_submit = lambda value, btn=btn, name=name: self.image_file_selected(btn, item_type, name, str(value[0]))
 
     def dropdown_update(self, n, dropdown_menu, btn):
         dropdown_menu.text = btn.text
@@ -152,11 +164,135 @@ class Settings:
         else:
             music_sound.stop()
 
+        if self.category == "Weapons" and self.data["weapons"]:
+            for name in self.data["weapons"]:
+                dmg, attack_speed, image = self.weapon_dmg_inputs[name].text, self.weapon_atk_speed_inputs[name].text, self.weapon_img_paths[name]
+                self.data["weapons"][name] = {"dmg": float(dmg), "atk_speed": float(attack_speed), "image": image}
+
+        if self.category == "Enemies" and self.data["enemies"]:
+            for name in self.data["enemies"]:
+                speed, size, image = self.enemy_speed_inputs[name].text, self.enemy_size_inputs[name].text, self.enemy_img_paths[name]
+                self.data["enemies"][name] = {"speed": float(speed), "size": float(size), "image": image}
+
         json.dump(self.data, open('settings.json', 'w'), indent=4)
 
         self.hide()
         self.__init__(self.rpc)
 
+    def add_enemy(self):
+        name, speed, size, image = self.new_enemy_name_input.text, self.enemy_speed_inputs["New"].text, self.enemy_size_inputs["New"].text, self.enemy_img_paths["New"]
+        self.data["enemies"] = self.data.get("enemies", settings["Enemies"]["default"])
+        
+        if name in self.data["enemies"] or not name or not speed or not is_float(speed) or not size or not is_float(size) or not image:
+            return
+
+        self.data["enemies"][name] = {"speed": float(speed), "size": float(size), "image": image}
+        self.clear()
+        self.enemies()
+
+    def add_weapon(self):
+        name, dmg, atk_speed, image = self.new_weapon_name_input.text, self.weapon_dmg_inputs["New"].text, self.weapon_atk_speed_inputs["New"].text, self.weapon_img_paths["New"]
+        self.data["weapons"] = self.data.get("weapons", settings["Weapons"]["default"])
+        
+        if name in self.data["weapons"] or not name or not dmg or not is_float(dmg) or not atk_speed or not is_float(atk_speed) or not image:
+            return
+        
+        self.data["weapons"][name] = {"dmg": float(dmg), "atk_speed": float(atk_speed), "image": image}
+        self.clear()
+        self.weapons()
+
+    def remove_enemy(self, name):
+        self.data["enemies"] = self.data.get("enemies", settings["Enemies"]["default"])
+        del self.data["enemies"][name]
+        self.clear()
+        self.enemies()
+
+    def remove_weapon(self, name):
+        self.data["weapons"] = self.data.get("weapons", settings["Weapons"]["default"])
+        del self.data["weapons"][name]
+        self.clear()
+        self.weapons()
+
+    def enemies(self):
+        y = .3
+
+        for enemy_name, enemy_dict in list(self.data.get("enemies", settings["Enemies"]["default"]).items()) + list({"New": {"speed": 0.12, "size": 1.0, "image": None}}.items()):
+            speed, size, image = enemy_dict["speed"], enemy_dict["size"], enemy_dict["image"]
+            self.enemy_img_paths[enemy_name] = image
+
+            if not image is None:
+                self.ui.append(Text(enemy_name, parent=camera.ui, position=(-.8, y), scale=1.2))
+            else:
+                self.new_enemy_name_input = InputField(default_value="New", parent=camera.ui, position=(-.75, y - .01), scale_x=0.125, scale_y=.05)
+                self.ui.append(self.new_enemy_name_input)
+
+            self.ui.append(Text("Speed: ", parent=camera.ui, position=(-.6, y), scale=1.2))
+            self.enemy_speed_inputs[enemy_name] = InputField(default_value=str(round(speed, 2)), parent=camera.ui, position=(-.4, y - .01), scale_x=0.125, scale_y=.05)
+            self.ui.append(self.enemy_speed_inputs[enemy_name])
+
+            self.ui.append(Text("Size: ", parent=camera.ui, position=(-.3, y), scale=1.2))
+            self.enemy_size_inputs[enemy_name] = InputField(default_value=str(round(size, 2)), parent=camera.ui, position=(-.15, y - .01), scale_x=0.125, scale_y=.05)
+            self.ui.append(self.enemy_size_inputs[enemy_name])
+
+            self.ui.append(Text("Image Path: ", parent=camera.ui, position=(-.05, y), scale=1.2))
+            self.enemy_img_path_buttons[enemy_name] = Button(text=f"Select File ({image})", scale_x=.6, scale_y=0.05, text_size=.75, position=(0.43, y - .01))
+            self.enemy_img_path_buttons[enemy_name].on_click = lambda name=enemy_name, btn=self.enemy_img_path_buttons[enemy_name]: self.select_image_file(btn, name, "enemy")
+            self.ui.append(self.enemy_img_path_buttons[enemy_name])
+
+            if image is None:
+                self.enemy_add_button = Button(text="Add", scale_x=.1, scale_y=0.05, text_size=.7, position=(0.8, y - .01))
+                self.enemy_add_button.on_click = lambda: self.add_enemy()
+                self.ui.append(self.enemy_add_button)
+            else:
+                self.enemy_remove_buttons[enemy_name] = Button(text="Remove", scale_x=.1, scale_y=0.05, text_size=.7, position=(0.8, y - .01))
+                self.enemy_remove_buttons[enemy_name].on_click = lambda name=enemy_name: self.remove_enemy(name)
+                self.ui.append(self.enemy_remove_buttons[enemy_name])                
+
+            y -= 0.08
+        
+        self.apply_button = Button('Apply', parent=camera.ui, color=color.green, scale=(.15, .08), position=(.6, -.4), on_click=self.apply_changes)
+        self.ui.append(self.apply_button)
+
+    def weapons(self):
+        y = .3
+
+        for weapon_name, weapon_dict in list(self.data.get("weapons", settings["Weapons"]["default"]).items()) + list({"New": {"dmg": 10, "atk_speed": 0.1, "image": None}}.items()):
+            dmg, atk_speed, image = weapon_dict["dmg"], weapon_dict["atk_speed"], weapon_dict["image"]
+            self.weapon_img_paths[weapon_name] = image
+
+            if not image is None:
+                self.ui.append(Text(weapon_name, parent=camera.ui, position=(-.8, y), scale=1.2))
+            else:
+                self.new_weapon_name_input = InputField(default_value="New", parent=camera.ui, position=(-.75, y - .01), scale_x=0.125, scale_y=.05)
+                self.ui.append(self.new_weapon_name_input)
+
+            self.ui.append(Text("DMG: ", parent=camera.ui, position=(-.6, y), scale=1.2))
+            self.weapon_dmg_inputs[weapon_name] = InputField(default_value=str(round(dmg, 2)), parent=camera.ui, position=(-.45, y - .01), scale_x=0.125, scale_y=.05)
+            self.ui.append(self.weapon_dmg_inputs[weapon_name])
+
+            self.ui.append(Text("Attack Speed: ", parent=camera.ui, position=(-.35, y), scale=1.2))
+            self.weapon_atk_speed_inputs[weapon_name] = InputField(default_value=str(round(atk_speed, 2)), parent=camera.ui, position=(-0.075, y - .01), scale_x=0.125, scale_y=.05)
+            self.ui.append(self.weapon_atk_speed_inputs[weapon_name])
+
+            self.ui.append(Text("Image Path: ", parent=camera.ui, position=(0.025, y), scale=1.2))
+            self.weapon_img_path_buttons[weapon_name] = Button(text=f"Select File ({image})", scale_x=.5, scale_y=0.05, text_size=.5, position=(0.475, y - .01))
+            self.weapon_img_path_buttons[weapon_name].on_click = lambda name=weapon_name, btn=self.weapon_img_path_buttons[weapon_name]: self.select_image_file(btn, name, "weapon")
+            self.ui.append(self.weapon_img_path_buttons[weapon_name])
+
+            if image is None:
+                self.weapon_add_button = Button(text="Add", scale_x=.1, scale_y=0.05, text_size=.7, position=(0.8, y - .01))
+                self.weapon_add_button.on_click = lambda: self.add_weapon()
+                self.ui.append(self.weapon_add_button)
+            else:
+                self.weapon_remove_buttons[weapon_name] = Button(text="Remove", scale_x=.1, scale_y=0.05, text_size=.7, position=(0.8, y - .01))
+                self.weapon_remove_buttons[weapon_name].on_click = lambda name=weapon_name: self.remove_weapon(name)
+                self.ui.append(self.weapon_remove_buttons[weapon_name])
+
+            y -= 0.08 
+
+        self.apply_button = Button('Apply', parent=camera.ui, color=color.green, scale=(.15, .08), position=(.6, -.4), on_click=self.apply_changes)
+        self.ui.append(self.apply_button)
+
     def clear(self):
         for e in list(self.ui):
             if e not in (self.main, self.back, self.category_group):
@@ -201,39 +337,4 @@ class Settings:
 
         self.credits_label = Text(text=text, parent=camera.ui, position=(0, 0), origin=(0, 0), scale=font_size, color=color.white)
         self.credits_label.type = 'credits_text'
-        self.ui.append(self.credits_label)
-
-    def save_weapon(self, name):
-        dmg, attack_speed, image = self.dmg_inputs[name].text, self.atk_speed_inputs[name].text, self.weapon_img_paths[name]
-
-        self.edits["weapons"] = self.edits.get("weapons", settings["Weapons"]["default"])
-        self.edits["weapons"][name] = {"dmg": float(dmg), "atk_speed": float(attack_speed), "image": image}
-
-        self.apply_changes()
-
-    def weapons(self):
-        y = .2
-
-        for weapon_name, weapon_dict in self.data.get("weapons", settings["Weapons"]["default"]).items():
-            dmg, atk_speed, image = weapon_dict["dmg"], weapon_dict["atk_speed"], weapon_dict["image"]
-
-            self.ui.append(Text(weapon_name, parent=camera.ui, position=(-.8, y), scale=1.2))
-
-            self.ui.append(Text("DMG: ", parent=camera.ui, position=(-.6, y), scale=1.2))
-            self.dmg_inputs[weapon_name] = InputField(default_value=str(round(dmg, 2)), parent=camera.ui, position=(-.45, y - .01), scale_x=0.125, scale_y=.05)
-            self.ui.append(self.dmg_inputs[weapon_name])
-
-            self.ui.append(Text("Attack Speed: ", parent=camera.ui, position=(-.35, y), scale=1.2))
-            self.atk_speed_inputs[weapon_name] = InputField(default_value=str(round(atk_speed, 2)), parent=camera.ui, position=(-0.075, y - .01), scale_x=0.125, scale_y=.05)
-            self.ui.append(self.atk_speed_inputs[weapon_name])
-
-            self.ui.append(Text("Image Path: ", parent=camera.ui, position=(0.05, y), scale=1.2))
-            self.img_path_buttons[weapon_name] = Button(text=f"Select File ({image})", scale_x=.3, scale_y=0.05, text_size=.5, position=(0.4, y - .01))
-            self.img_path_buttons[weapon_name].on_click = lambda name=weapon_name, btn=self.img_path_buttons[weapon_name]: self.select_image_file(btn, name)
-            self.ui.append(self.img_path_buttons[weapon_name])
-
-            self.save_buttons[weapon_name] = Button(text="Save", scale_x=.1, scale_y=0.05, text_size=.7, position=(0.7, y - .01))
-            self.save_buttons[weapon_name].on_click = lambda name=weapon_name: self.save_weapon(name)
-            self.ui.append(self.save_buttons[weapon_name])
-
-            y -= 0.08 
+        self.ui.append(self.credits_label)

run.py

@@ -34,8 +34,11 @@ if not args["fullscreen"]:
 
 app = Ursina(title="Aim Trainer", development_mode=False, **args)
 
+window.cog_button.enabled = False
 window.editor_ui.enabled = True
 window.fps_counter.enabled = True
+window.collider_counter.enabled = False
+window.entity_counter.enabled = False
 
 if settings.get("music", True):
     from utils.preload import music_sound

utils/constants.py

@@ -1,9 +1,7 @@
-min_enemy_y = 9
-max_enemy_y = 16
+min_enemy_y = 0
+max_enemy_y = 20
 min_enemy_movement = 7
 max_enemy_movement = 10
-min_enemy_speed = 0.08
-max_enemy_speed = 0.12
 enemy_health = 100
 
 weapons = {
@@ -15,12 +13,14 @@ weapons = {
     "sniper": {"dmg": 100, "atk_speed": 1, "image": "assets/graphics/sniper.png"},
 }
 
+enemies = {
+    "default": {"speed": 0.12, "size": 1, "image": "assets/graphics/default_enemy.png"} 
+}
+
 discord_presence_id = 1380237183352311838
 
 settings = {
-    "Gameplay": {
-        "Enemy Image Directory": {"type": "directory_select", "config_key": "enemy_image_directory", "default": "assets/graphics/enemy"}
-    },
+    "Enemies": {"default": enemies},
     "Weapons": {"default": weapons},
     "Graphics": {
         "Window Mode": {"type": "option", "options": ["Windowed", "Fullscreen", "Borderless"], "config_key": "window_mode", "default": "Windowed"},
@@ -40,4 +40,4 @@ settings = {
     "Credits": None
 }
 
-settings_start_category = "Gameplay"
+settings_start_category = "Enemies"

utils/utils.py

@@ -70,3 +70,10 @@ class FakePyPresence():
         ...
     def close(self, *args, **kwargs):
         ...
+
+def is_float(string):
+    try:
+        float(string)
+        return True
+    except ValueError:
+        return False