Add game modes: default as training, waves and a 1 minute test, adjust for better scoring

README.md

@@ -1 +1,8 @@
-An aim trainer made in Ursina engine.
+A very customizable aim trainer made in Ursina engine.
+
+Features:
+- You can edit/create any enemy with any speed, size, and image
+- You can edit/create any gun with any damage, attack speed and image
+- Training Game Mode: You can experiment with your aim here, no time limit or anything, and you can create infinite targets.
+- Waves Game Mode: Kill enemies in time, while getting as many points as you can.
+- 1 Minute Test Game Mode: See how many shots you can hit, how many enemies you can kill in just a minute.

game/game.py

@@ -12,8 +12,11 @@ from pathlib import Path
 import os, json
 
 class Game():
-    def __init__(self, pypresence_client) -> None:
+    def __init__(self, pypresence_client, game_mode) -> None:
         self.pypresence_client = pypresence_client
+        self.game_mode = game_mode
+        self.game_over_triggered = False
+        self.enemies = []
 
         if os.path.exists("data.json"):
             with open("data.json", "r") as file:
@@ -21,65 +24,91 @@ class Game():
         else:
             self.high_score = 0
 
-        pypresence_client.update(state='Training Aim', details=f'Hits: 0/0 Accuracy: 0%')
-
         with open("settings.json", "r") as file:
             self.settings_dict = json.load(file)
 
+        pypresence_client.update(state='Training Aim', details=f'Hits: 0/0 Accuracy: 0%')
+
         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)
-
-        self.info_label = Text("Score: 0 Hits: 0/0 Accuracy: 0%", parent=camera.ui, position=(-0.1, 0.475))
-
+        self.info_label = Text("Score: 0 Hits: 0/0 Accuracy: 0%", parent=camera.ui, position=(-0.1 if self.game_mode == "training" else -0.4, 0.475))
         self.inventory = Inventory(slots=len(self.settings_dict.get("weapons")))
 
         for n, weapon in enumerate(self.settings_dict.get("weapons")):
             self.inventory.append(self.settings_dict.get("weapons")[weapon]["image"], weapon, n)
 
-        self.player = Player(self.settings_dict, self.high_score, self.info_label, self.inventory, pypresence_client)
+        self.player = Player(self.game_mode, self.settings_dict, self.high_score, self.info_label, self.inventory, pypresence_client)
+        self.player.summon_enemy = self.summon_enemy
 
         self.shootables_parent = Entity()
         mouse.traverse_target = self.shootables_parent
+        
+        if self.game_mode == "1 minute test":
+            enemy_num = 10
+        elif self.game_mode == "training":
+            enemy_num = 25
+        else:
+            enemy_num = self.player.wave_enemies_left
 
-        self.enemies = []
-
-        for i in range(15):
+        for _ in range(enemy_num):
             self.summon_enemy()
 
-        self.player.summon_enemy = self.summon_enemy
-
         self.sun = DirectionalLight()
         self.sun.look_at(Vec3(1,-1,-1))
 
         self.sky = Sky()
         self.sky.update = self.update
-        
+        self.sky.input = self.input
+
+        if self.game_mode == "training":
+            self.create_enemies_label = Text("Use n to create new targets.", parent=camera.ui, position=(-0.85, -0.4), scale=1.3)
+
     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(image_path))
-                )
+        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(image_path))
             )
+        )
 
     def update(self):
         Sky.update(self.sky)
 
-        if held_keys["escape"]:
+        if self.game_mode == "waves" and time.perf_counter() - self.player.last_wave_time >= self.player.wave_time:
+            self.game_over()
+        
+        if self.game_mode == "1 minute test" and time.perf_counter() - self.player.test_start >= 1:
+            self.game_over()
+
+    def input(self, key):
+        if key == "escape":
             self.back_to_main_menu()
-        elif held_keys["n"]:
+        elif key == "n" and not self.game_mode == "1 minute test":
             self.summon_enemy()
 
+    def game_over(self):
+        self.hide()
+
+        self.game_over_triggered = True
+
+        self.main = Entity(parent=camera.ui, model='cube', color=color.dark_gray, scale=(1.8, 1.2), z=1)
+        
+        info_text = f"Wave: {self.player.wave_number}\n" if self.game_mode == "waves" else ""
+        info_text += f"Score: {self.player.score}\nHits: {self.player.shots_fired}/{self.player.shots_hit}\nAccuracy: {round(self.player.accuracy, 2)}%"
+
+        self.game_over_label = Text(text=f"Game Over\n\n{info_text}", scale=3, position=(-0.2, 0.3))
+
+        self.exit_button = Button(text="Exit", scale_x=0.4, scale_y=0.1, position=(0, -0.3), on_click=self.back_to_main_menu)
+
     def back_to_main_menu(self):
         self.hide()
         from menus.main import Main
@@ -89,11 +118,22 @@ class Game():
         destroy(self.ground)
         destroy(self.sun)
         destroy(self.sky)
-        Sky.instances.remove(self.sky)
         destroy(self.info_label)
+        destroy(self.shootables_parent)
+
+        if self.sky in Sky.instances:
+            Sky.instances.remove(self.sky)
+
         self.inventory.hide()
         self.player.hide()
-        destroy(self.shootables_parent)
+        
+        if self.game_over_triggered:
+            destroy(self.main)
+            destroy(self.game_over_label)
+            destroy(self.exit_button)
+
+        if self.game_mode == "training":
+            destroy(self.create_enemies_label)
 
         for enemy in self.enemies:
             destroy(enemy)

game/player.py

@@ -8,11 +8,10 @@ from utils.preload import death_sound
 from utils.constants import weapons
 
 import json
-
 from pathlib import Path
 
 class Player(FirstPersonController):
-    def __init__(self, settings_dict, high_score, info_label, inventory, pypresence_client) -> None:
+    def __init__(self, game_mode, settings_dict, high_score, info_label, inventory, pypresence_client) -> None:
         super().__init__(model='cube', z=16, color=color.orange, origin_y=-.5, speed=8, collider='box', gravity=True, shader=lit_with_shadows_shader)
 
         self.collider = BoxCollider(self, Vec3(0,1,0), Vec3(1,2,1))
@@ -22,7 +21,16 @@ class Player(FirstPersonController):
         self.pypresence_client = pypresence_client
         self.high_score = high_score
         self.settings_dict = settings_dict
+        self.game_mode = game_mode
         
+        if self.game_mode == "waves":
+            self.wave_number = 1
+            self.wave_enemies_left = 20
+            self.wave_time = 90
+            self.last_wave_time = time.perf_counter()
+        elif self.game_mode == "1 minute test":
+            self.test_start = time.perf_counter()
+
         self.last_presence_update = time.perf_counter()
         self.shots_fired = 0
         self.shots_hit = 0
@@ -46,7 +54,16 @@ class Player(FirstPersonController):
 
         self.x = max(-16, min(self.x, 16))
         self.z = max(-16, min(self.z, 16))
-        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)}%"
+
+        if self.game_mode == "waves":
+            info_text = f"Wave: {self.wave_number} Enemies Left: {self.wave_enemies_left} Time Left: {round(self.wave_time - (time.perf_counter() - self.last_wave_time), 2)}s "
+        elif self.game_mode == "1 minute test":
+            info_text = f"Time Left: {round(60 - (time.perf_counter() - self.test_start))} "
+        else:
+            info_text = ""
+
+        info_text += f"Score: {self.score} High Score: {self.high_score} Hits: {self.shots_fired}/{self.shots_hit} Accuracy: {round(self.accuracy, 2)}%"
+        self.info_label.text = info_text
 
         weapon_name = self.inventory.slot_names[self.inventory.current_slot]
         self.gun.texture = Texture(Path(self.settings_dict.get("weapons", weapons)[weapon_name]["image"]))
@@ -59,7 +76,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"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 +96,10 @@ class Player(FirstPersonController):
                 mouse.hovered_entity.hp -= self.weapon_dmg
                 mouse.hovered_entity.blink(color.red)
 
-                self.score += int(distance(mouse.hovered_entity, self))
+                base_distance_score = distance(mouse.hovered_entity, self) * 10
+                damage_multiplier = self.weapon_dmg / mouse.hovered_entity.max_hp
+                attack_speed_multiplier = ((1 / self.weapon_attack_speed) ** 0.5) / 10
+                self.score += int(base_distance_score * damage_multiplier * attack_speed_multiplier)
 
                 self.shots_hit += 1
 
@@ -90,7 +110,20 @@ class Player(FirstPersonController):
 
                     death_sound.play()
 
-                    self.summon_enemy()
+                    if self.game_mode == "waves":
+                        self.wave_enemies_left -= 1
+
+                        if self.wave_enemies_left <= 0:
+                            self.wave_time += 20
+                            self.wave_number += 1 
+                            self.wave_enemies_left = 20 + (self.wave_number * 5)
+                            self.last_wave_time = time.perf_counter()
+
+                            for _ in range(self.wave_enemies_left):
+                                self.summon_enemy()
+                    
+                    else:
+                        self.summon_enemy()
 
             self.accuracy = (self.shots_hit / self.shots_fired) * 100
 

menus/game_modes.py

@@ -0,0 +1,38 @@
+import json
+from utils.constants import game_modes
+from ursina import *
+
+class GameModeSelector:
+    def __init__(self, rpc):
+        self.rpc = rpc
+        rpc.update(state='In Game Mode Selector', details='Selecting Game Mode Selector', start=rpc.start_time)
+
+        self.data = json.load(open('settings.json'))
+        
+        self.main = Entity(parent=camera.ui, model='cube', color=color.dark_gray, scale=(1.8, 1.2), z=1)
+        self.back_button = Button('Back', parent=camera.ui, color=color.gray, scale=(.1, .05), position=(-.8, .45), on_click=self.exit)
+        self.title_label = Text(text="Select a mode to play.", position=(-0.4, 0.35), scale=3)
+
+        self.ui = [self.main, self.back_button, self.title_label]
+
+        y = 0.1
+
+        for game_mode in game_modes:
+            button = Button(text=game_mode, scale_x=1, scale_y=0.2, text_size=2, position=(0, y), on_click=lambda game_mode=game_mode: self.play(game_mode))
+            self.ui.append(button)
+            y -= 0.21
+
+    def play(self, game_mode):
+        self.hide()
+        from game.game import Game
+        Game(self.rpc, game_mode.lower())
+
+    def hide(self):
+        for e in self.ui:
+            destroy(e)
+        self.ui.clear()
+
+    def exit(self):
+        self.hide()
+        from menus.main import Main
+        Main(pypresence_client=self.rpc)

menus/main.py

@@ -67,8 +67,8 @@ class Main():
 
     def play(self):
         self.hide()
-        from game.game import Game
-        Game(self.pypresence_client)
+        from menus.game_modes import GameModeSelector
+        GameModeSelector(self.pypresence_client)
 
     def settings(self):
         self.hide()

menus/settings.py

@@ -16,17 +16,16 @@ class Settings:
         self.data = json.load(open('settings.json'))
         self.edits = {}
         self.category = settings_start_category
-        self.ui = []
-
+    
         self.main = Entity(parent=camera.ui, model='cube', color=color.dark_gray, scale=(1.8, 1.2), z=1)
 
-        self.back = Button('Back', parent=camera.ui, color=color.gray, scale=(.1, .05), position=(-.8, .45), on_click=self.exit)
+        self.back_button = Button('Back', parent=camera.ui, color=color.gray, scale=(.1, .05), position=(-.8, .45), on_click=self.exit)
 
         self.category_group = ButtonGroup(tuple(settings.keys()), default=self.category, spacing=(.25, 0, 0))
         self.category_group.on_value_changed = lambda: self.show(self.category_group.value)
         self.category_group.position = (-.6, .4)
 
-        self.ui += [self.main, self.back, self.category_group]
+        self.ui = [self.main, self.back_button, self.category_group]
 
         self.weapon_dmg_inputs = {}
         self.weapon_atk_speed_inputs = {}
@@ -298,7 +297,7 @@ class Settings:
 
     def clear(self):
         for e in list(self.ui):
-            if e not in (self.main, self.back, self.category_group):
+            if e not in (self.main, self.back_button, self.category_group):
                 destroy(e)
                 self.ui.remove(e)
 

utils/constants.py

@@ -4,6 +4,8 @@ min_enemy_movement = 7
 max_enemy_movement = 10
 enemy_health = 100
 
+game_modes = ["Training", "Waves", "1 Minute Test"]
+
 weapons = {
     "assault_rifle": {"dmg": 20, "atk_speed": 0.2, "image": "assets/graphics/assaultrifle.png"},
     "smg": {"dmg": 10, "atk_speed": 0.1, "image": "assets/graphics/smg.png"},