update 0.1.2.2

Author: SkyNeon22

core/additions/utils.py

@@ -13,9 +13,7 @@ def is_negative(num: int):
     return True if num % -1 else False
 
 def get_angle(target_pos, object_pos):
-    pos1 = pg.math.Vector2(target_pos)
-    pos2 = pg.math.Vector2(object_pos)
-    return math.degrees(math.atan2(target_pos.y - object_pos.y, target_pos.x - object_pos.x))
+    return math.degrees(math.atan2(target_pos[1] - object_pos[1], target_pos[0] - object_pos[0]))
 
 # don't even try to understand this func (it's useless)
 def speed_compensation(direction: list, speed: float): 

core/game/colliders/colliders.py

@@ -25,7 +25,7 @@ def colliderect(self, rect):
             return False
 
     def collidecircle(self, circle):
-        if dist(self.position, circle.position) <= self.radius + circle.radius - 1:
+        if dist(self.position, circle.position) < (self.radius + circle.radius) - 1:
             return True
         else:
             return False

core/game/dialogue.py

@@ -65,7 +65,7 @@ def fromdict(cls, asset, game=None): # method for loading an enemy object from a
         return cls(asset["game"] or game,asset["pos"], asset["time"], behavioregistry.rglist.get(asset["behavior"]), asset["behavior_args"])
 
     def check_despawn(self): # despawn when outside of the fight area (you can change the values for more outside room of despawn)
-        if self.pos[0] < -20 or self.pos[0] > 400 or self.pos[1] < -20 or self.pos[1] > 498:
+        if self.pos[0] < -80 or self.pos[0] > 400 or self.pos[1] < -80 or self.pos[1] > 498:
             self.kill = True
 
     def check_bullet(self): # check for player projectiles
@@ -76,6 +76,12 @@ def check_bullet(self): # check for player projectiles
                     self.game.score += 10
                     bul.kill = True 
 
+    def shoot(self):
+        self.game.proj_list.append(Projectile(self.game, (self.pos[0], self.pos[1] + 25), team="en", direction=(0, 1), speed=0.4))
+
+    def draw(self): # draw function
+        pg.draw.rect(self.game.fight_area, (200, 0, 0), pg.Rect(self.pos, self.size))
+
     def drop(self):
         drop = random.randint(1, 100)
         if drop >= 60 and drop <= 84:
@@ -85,13 +91,10 @@ def drop(self):
         elif drop >= 100:
             self.game.pickup_list.append(Big_Power_pickup(self.game, pos=self.pos))
 
-    def draw(self): # draw function
-        pg.draw.rect(self.game.fight_area, (200, 0, 0), pg.Rect(self.pos, self.size))
-
     def update(self): # update the enemy
         if self.game.frametime >= self.time:
             if self.cooldown <= 0:
-                self.game.proj_list.append(Projectile(self.game, (self.pos[0], self.pos[1] + 25), team="en", direction=(0, 1), speed=0.4))
+                self.shoot()
                 self.cooldown = self.shot_cooldown
             self.cooldown -= 0.01
             if self.bh_enabled:
@@ -105,12 +108,12 @@ def update(self): # update the enemy
             self.check_despawn()
             self.draw()
 
-class Boss(Enemy): # fork of the enemy class to make a boss (if you want to make a boss fork this class)
+class Testboss(Enemy): # fork of the enemy class to make a boss (if you want to make a boss fork this class)
     # commenting this shit another time
     def __init__(self, game, pos=(190, 400), time=0, behavior=None, behavior_args=[]):
         super().__init__(game, pos, time, behavior, behavior_args)
         self.game = game 
-        self.type = "Boss"
+        self.type = "testboss"
         self.col_dmg = False
         self.dmg_resist = 1
         self.behavior = behavior
@@ -166,11 +169,11 @@ def update(self):
                 self.game.musicregistry.rglist[self.theme_id].play(self.game.musicvolume)
                 self.music_done = True
             self.game.soundregistry.rglist["damage00"].reload()
+            if self.attorder[self.active_attack] !=  None:
+                self.game.active_spell = self.attorder[self.active_attack].in_game_display_name
+            else:
+                self.game.active_spell = None
             try:
-                if self.attorder[self.active_attack] != None:
-                    self.game.active_spell = self.attorder[self.active_attack].in_game_display_name
-                else:
-                    self.game.active_spell = None
                 if self.active_attack <= len(self.attorder):
                     self.attorder[self.active_attack].update()
                 else:
@@ -188,13 +191,7 @@ def update(self):
                     proj.destroy()
                 self.kill = True
                 self.game.active_spell = None
-                drop = random.randint(1, 100)
-                if drop >= 60 and drop <= 84:
-                    self.game.pickup_list.append(Point_pickup(self.game, pos=self.pos))
-                if drop >= 85 and drop <= 99:
-                    self.game.pickup_list.append(Power_pickup(self.game, pos=self.pos))
-                elif drop >= 100:
-                    self.game.pickup_list.append(Big_Power_pickup(self.game, pos=self.pos))
+                self.drop()
             self.center = (self.pos[0] + (self.size[0] // 2), self.pos[1] + (self.size[1] // 2))
             self.hitbox.update(self.center)
             self.check_bullet()

core/game/enemy.py

@@ -1,5 +1,6 @@
 import pygame as pg
 import numpy as np
+from math import radians
 import sys
 from core.visuals.ui import *
 
@@ -22,12 +23,14 @@ def change_menu_ui_selected_down(self):
         if len(self.menus[self.current_menu_item].selectable_elements) != 0:
             if self.menu_ui_selected != len(self.menus[self.current_menu_item].selectable_elements):
                 self.previous_menu_ui_select = self.menu_ui_selected
+                self.menus[self.current_menu_item].selectable_elements[self.previous_menu_ui_select].is_selected = False
                 self.menu_ui_selected += 1
 
     def change_menu_ui_selected_up(self):
         if len(self.menus[self.current_menu_item].selectable_elements) != 0:
             if self.menu_ui_selected != 0:
                 self.previous_menu_ui_select = self.menu_ui_selected
+                self.menus[self.current_menu_item].selectable_elements[self.previous_menu_ui_select].is_selected = False
                 self.menu_ui_selected -= 1
 
 
@@ -66,11 +69,71 @@ def update(self):
         for elem in self.elements:
             elem.update()
 
-        if len(self.selectable_elements) != 0:
-            for elem in self.selectable_elements:
-                elem.update()
-                self.selectable_elements[self.menumanager.previous_menu_ui_select].is_selected = False
-                self.selectable_elements[self.menumanager.menu_ui_selected].is_selected = True
+        for elem in self.selectable_elements:
+            elem.update()
+            #self.selectable_elements[self.menumanager.previous_menu_ui_select].is_selected = False
+            self.selectable_elements[self.menumanager.menu_ui_selected].is_selected = True
+
+class ShotTypeSelectMenu(Menu):
+    def __init__(self, game, menumanager):
+        super().__init__(game, menumanager)
+        self.ssc_angle = 0
+        self.selected_shottype_circle = MenuLabel(self.game, (480, 320), "assets\\img\\sprites\\ui\\test.png", sprite_size=[300, 300])
+        self.elements = [MenuText(self.game, [50, 50], size=40), MenuText(self.game, [50, 90], size=25), MenuText(self.game, [50, 120], size=25)]
+        self.elements[0].text = JapaneseFontText(self.game, self.elements[0].pos, self.elements[0].size, text="博麗　霊夢")
+        self.elements[1].text = JapaneseFontText(self.game, self.elements[1].pos, self.elements[1].size, text="広範囲をカバーショットタイプ")
+        self.elements[2].text = JapaneseFontText(self.game, self.elements[2].pos, self.elements[2].size, text="速度: 中")
+        self.selectable_elements = [
+            MenuSelectableText(self.game, execute=self.game.new_game_reimu),            
+            MenuSelectableText(self.game, execute=self.game.new_game_marisa),            
+            MenuSelectableText(self.game, execute=self.game.new_game_alice),            
+            MenuSelectableText(self.game, execute=self.menumanager.change_current_menu, args=["mainmenu"]),
+        ]
+    
+    def rotate_clockwise(self):
+        self.ssc_angle -= 3
+    def rotate_counterclockwise(self):
+        self.ssc_angle += 3
+    
+    def _update(self):
+        self.selected_shottype_circle.draw_with_rot(self.ssc_angle)
+        if self.menumanager.menu_ui_selected == 0 and self.ssc_angle != 0:
+            self.elements[0].text_str = "博麗　霊夢"
+            self.elements[1].text_str = "広範囲をカバーショットタイプ"
+            self.elements[2].text_str = "速度: 中"
+            if self.ssc_angle >= 0:
+                self.rotate_clockwise()
+            else:
+                self.rotate_counterclockwise()
+        if self.menumanager.menu_ui_selected == 1 and self.ssc_angle != 90:
+            self.elements[0].text_str = "霧雨　魔理沙"
+            self.elements[1].text_str = "前方中心のショットタイプ"
+            self.elements[2].text_str = "速度: 速い"
+            if self.ssc_angle >= 90:
+                self.rotate_clockwise()
+            else:
+                self.rotate_counterclockwise()
+        if self.menumanager.menu_ui_selected == 2 and self.ssc_angle != 180:
+            self.elements[0].text_str = "上海アリス幻樂団"
+            self.elements[1].text_str = "ハイブリッドショットタイプ"
+            self.elements[2].text_str = "速度: 中"
+            if self.ssc_angle >= 180:
+                self.rotate_clockwise()
+            else:
+                self.rotate_counterclockwise()
+        if self.menumanager.menu_ui_selected == 3 and self.ssc_angle != 270:
+            self.elements[0].text_str = "ＥＸＩＴ"
+            self.elements[1].text_str = ""
+            self.elements[2].text_str = ""
+            if self.ssc_angle >= 270:
+                self.rotate_clockwise()
+            else:
+                self.rotate_counterclockwise()
+            
+    
+    def update(self):
+        self._update()
+        return super().update()
 
 class MenuBar:
     def __init__(self, game, pos:list = [0, 0], text = None, textcolor = None, barcolor = None, textsize = None, size = None):
@@ -164,7 +227,7 @@ def on_use(self):
             else:
                 self.text.on_use(*self.args)
         except Exception:
-            self.game.soundregistry.rglist["cancel"].play()
+            self.game.soundregistry.rglist["cancel"].play(self.game.soundvolume)
         self.game.soundregistry.rglist["cancel"].reload()
 
     def update_status(self):
@@ -184,16 +247,20 @@ def update(self):
 
 
 class MenuLabel: 
-    def __init__(self, game, pos: list = [0, 0], img_path: pg.Surface = None):
+    def __init__(self, game, pos: list = [0, 0], img_path: str = "", sprite_size=[]):
         self.game = game
         self.pos = pos
         try:
-            if img_path is not str or img_path is not None:
-                self.img = pg.image.load(img_path).convert_alpha()
+            if img_path:
+                self.img = pg.image.load(img_path)#.convert_alpha()
             else:
                 self.img = pg.image.load("assets/img/guesswhatismissing.png")
         except FileNotFoundError:
             self.img = pg.image.load("assets/img/guesswhatismissing.png")
+        if sprite_size == []:
+            self.sprite_size = list(self.img.get_size())
+        else:
+            self.sprite_size = sprite_size
 
     def no(self): ... # reserved
     def no(self): ... # reserved
@@ -204,8 +271,6 @@ def no(self): ... # reserved
     def no(self): ... # reserved
     def no(self): ... # reserved
     def no(self): ... # reserved
-    def update(self):
-        self.game.screen.blit(self.img, self.pos)
     def change_img(self, img_path):
         try:
             if img_path is not str or img_path is not None:
@@ -220,7 +285,10 @@ def update(self):
         self.draw()
 
     def draw(self):
-        self.game.screen.blit(self.img, self.pos)
+        self.game.screen.blit(pg.transform.scale(self.img, self.sprite_size), self.pos)
+    
+    def draw_with_rot(self, angle):
+       self.game.screen.blit(pg.transform.rotate(pg.transform.scale(self.img, self.sprite_size), angle), self.pos)
 
 class MenuRect:
     '''optional args: \n

core/game/menusystem.py

@@ -19,9 +19,15 @@ def __init__(self, game, inflictor=None, difficulty=None):
         self.cooldown = 0
         self.difficulty = difficulty
         self.inflictor = inflictor
-
+    
+    def shoot(self, name="ball_white", pos=(0, 0), angle=0, speed=10):
+        self.game.projregistry.shoot(name, pos, angle, speed)
+    
+    def shoottest(self, name="ball_white", pos=(0, 0), angle=0, speed=[10, 10]):
+        self.game.projregistry.shoottest(name, pos, angle, speed)
+        
     def do(self):
-        self.game.projregistry.shoot("ball_red", self.inflictor.hitbox.position, get_angle(self.game.player.hitbox.position ,self.inflictor.hitbox.position), 3)
+        pass
 
     def update(self):
         if not self.active:

core/game/nonspells.py

@@ -1,5 +1,7 @@
 import pygame as pg
 from core.game.colliders import CircleCollider
+from math import cos, sin, radians
+from core.additions.utils import get_angle
 
 
 class Power_pickup:
@@ -20,16 +22,35 @@ def __init__(self, game, pos=(10, 300), vel=-0.2):
         self.vel = vel
 
         self.kill = False
+        self.follow = False
 
-        self.hitbox = CircleCollider(15, self.center)
+        self.hitbox = CircleCollider(5, self.center)
+
+        self.angle = radians(get_angle(self.game.player.graze_hitbox.position, self.pos))
+        self.launch()
+    
+    def start_follow(self):
+        self.follow = True
+    
+    def launch(self):
+        self.dx, self.dy = cos(self.angle) * 5, sin(self.angle) * 5
 
     def draw(self):
         pg.draw.rect(self.game.fight_area, (255, 255, 255), pg.Rect(self.pos[0] - 2, self.pos[1] - 2, self.size[0] + 4, self.size[1] + 4))
         pg.draw.rect(self.game.fight_area, (255, 0, 0), pg.Rect(self.pos[0], self.pos[1], self.size[0], self.size[1]))
 
     def update(self):
-        self.pos[1] += self.vel
-        self.vel += 0.0062
+        if self.follow:
+            self.angle = radians(get_angle(self.game.player.graze_hitbox.position, self.pos))
+            self.launch()
+            self.pos[0] += self.dx
+            self.pos[1] += self.dy
+        else:
+            self.pos[1] += self.vel
+            self.vel += 0.0062
+        if self.pos[0] >= 800:
+            self.kill = True
+        self.center = (self.pos[0] + (self.size[0] // 2), self.pos[1] + (self.size[1] // 2))
         self.hitbox.update(self.center)
         self.draw()
 
@@ -52,7 +73,7 @@ def __init__(self, game, pos=(10, 300), vel=-0.2):
 
         self.kill = False
 
-        self.hitbox = CircleCollider(15, self.center)
+        self.hitbox = CircleCollider(5, self.center)
 
     def draw(self):
         pg.draw.rect(self.game.fight_area, (255, 255, 255), pg.Rect(self.pos[0] - 2, self.pos[1] - 2, self.size[0] + 4, self.size[1] + 4))
@@ -61,6 +82,8 @@ def draw(self):
     def update(self):
         self.pos[1] += self.vel
         self.vel += 0.0062
+        if self.pos[0] >= 800:
+            self.kill = True
         self.center = (self.pos[0] + (self.size[0] // 2), self.pos[1] + (self.size[1] // 2))
         self.hitbox.update(self.center)
         self.draw()
@@ -79,33 +102,50 @@ def __init__(self, game, pos=(10, 300), vel=-0.2):
 
 class Point_pickup(Power_pickup):
     def __init__(self, game, pos=(10, 300), vel=-0.2):
+        super().__init__(game, pos, vel)
         self.game = game
         self.size = [20, 20]
         self.pos = list(pos)
         self.center = (self.pos[0] + (self.size[0] // 2), self.pos[1] + (self.size[1] // 2))
 
         self.type = "col"
 
-        self.points = 56550
+        self.points = 50000
         self.power = 1
 
         self.vel = vel
 
         self.kill = False
 
-        self.hitbox = CircleCollider(15, self.center)
+        self.hitbox = CircleCollider(5, self.center)
 
     def draw(self):
         pg.draw.rect(self.game.fight_area, (255, 255, 255), pg.Rect(self.pos[0] - 2, self.pos[1] - 2, self.size[0] + 4, self.size[1] + 4))
         pg.draw.rect(self.game.fight_area, (0, 0, 255), pg.Rect(self.pos[0], self.pos[1], self.size[0], self.size[1]))
+
+class Score_Pickup(Point_pickup):
+    def __init__(self, game, pos=(10, 300), vel=-0.2):
+        super().__init__(game, pos, vel)
+        self.size = [10, 10]
+        self.points = 100
+    
+    def draw(self):
+        pg.draw.rect(self.game.fight_area, (255, 255, 255), pg.Rect(self.pos[0] - 2, self.pos[1] - 2, self.size[0] + 4, self.size[1] + 4))
+        pg.draw.rect(self.game.fight_area, (0, 150, 0), pg.Rect(self.pos[0], self.pos[1], self.size[0], self.size[1]))
 
     def update(self):
-        if self.pos[1] >= 1000:
+        self.follow = True
+        if self.pos[1] >= 800:
             self.kill = True
-        self.pos[1] += self.vel
-        self.vel += 0.0062
+        if self.follow:
+            self.launch()
+            self.pos[0] += self.dx
+            self.pos[1] += self.dy
+        else:
+            self.pos[1] += self.vel
+            self.vel += 0.0062
         self.center = (self.pos[0] + (self.size[0] // 2), self.pos[1] + (self.size[1] // 2))
-        self.hitbox.update()
+        self.hitbox.update(self.center)
         self.draw()
 
 class Life_pickup(Power_pickup):