e2D 1.4.9__tar.gz → 1.4.10__tar.gz

{e2D-1.4.9 → e2d-1.4.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e2D
-Version: 1.4.9
+Version: 1.4.10
 Summary: Python library for 2D games. Streamlines dev with keyboard/mouse input, vector calculations, color manipulation, and collision detection. Simplify game creation and unleash creativity!
 Home-page: https://github.com/marick-py/e2D
 Author: Riccardo Mariani

{e2D-1.4.9 → e2d-1.4.10}/e2D/__init__.py

@@ -105,6 +105,9 @@ class Vector2D:
         d = (self.x - other.x)**2 + (self.y - other.y)**2
         return (d**(1/2) if sqrd else d)
 
+    def angle(self:"Vector2D") -> int|float:
+        return _mt.atan2(self.y, self.x)
+
     def angle_to(self:"Vector2D", other:"float|int|Vector2D|list|tuple") -> int|float:
         """
         # Calculate the angle between the current Vector2D other and another other.

e2d-1.4.10/e2D/envs.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+from .utils import *
+import pygame as pg
+from pygame.event import Event
+from time import time as __tm__
+import math as _mt
+"""  CODE EXAMPLE FOR RootEnv
+from e2D.envs import *
+
+class Env:
+    def __init__(self) -> None:
+        pass
+
+    def draw(self) -> None:
+        pass
+
+    def update(self) -> None:
+        pass
+
+(rootEnv:=RootEnv()).init(Env())
+while not rootEnv.quit:
+    rootEnv.frame()
+"""
+
+pg.init()
+pg.font.init()
+FONT_ARIAL_16 = pg.font.SysFont("Arial", 16)
+FONT_ARIAL_32 = pg.font.SysFont("Arial", 32)
+FONT_ARIAL_64 = pg.font.SysFont("Arial", 64)
+new_font = lambda size, name="Arial", bold=False, italic=False: pg.font.SysFont(name, size, bold, italic)
+
+TEXT_FIXED_SIDES_TOP_LEFT = 0
+TEXT_FIXED_SIDES_TOP_MIDDLE = 1
+TEXT_FIXED_SIDES_TOP_RIGHT = 2
+TEXT_FIXED_SIDES_MIDDLE_LEFT = 3
+TEXT_FIXED_SIDES_MIDDLE_MIDDLE = 4
+TEXT_FIXED_SIDES_MIDDLE_RIGHT = 5
+TEXT_FIXED_SIDES_BOTTOM_LEFT = 6
+TEXT_FIXED_SIDES_BOTTOM_MIDDLE = 7
+TEXT_FIXED_SIDES_BOTTOM_RIGHT = 8
+
+FIXED_SIDES_MULTIPLIER = [V2(x,y) for y in [0, .5, 1] for x in [0, .5, 1]]
+
+INPUT_CELL_ASCII_TYPE = 0
+INPUT_CELL_ALPHANUM_TYPE = 1
+INPUT_CELL_ALPHA_TYPE = 2
+INPUT_CELL_NUM_TYPE = 3
+
+class Utils:
+    def __init__(self) -> None:
+        self.rootEnv : RootEnv = None # type: ignore
+        self.surface : pg.Surface
+    def draw(self) -> None: pass
+    def update(self) -> None: pass
+
+class InputCell(Utils):
+    def __init__(self,
+                initial_value:str,
+                position:V2|Vector2D,
+                size:V2|Vector2D,
+                prefix:str|None=None,
+                text_color:tuple[int,int,int]|list[int]=(255,255,255),
+                bg_color:None|tuple[int,int,int]|list[int]=None,
+                border_color:None|tuple[int,int,int]|list[int]=(255,255,255),
+                border_width:float=0,
+                border_radius:int|list[int]|tuple[int,int,int,int]=-1,
+                margin:V2|Vector2D=V2z,
+                fixed_sides:int=TEXT_FIXED_SIDES_MIDDLE_MIDDLE,
+                font:pg.font.Font=FONT_ARIAL_32,
+                personalized_surface:pg.Surface|None=None,
+                on_enter_pressed=None,
+                check_when_adding=None) -> None:
+        super().__init__()
+
+        self.on_enter_pressed = on_enter_pressed
+        self.check_when_adding = check_when_adding
+        self.prefix = prefix if prefix != None else ""
+    
+        self.text_color = text_color
+        self.font = font
+        self.surface = personalized_surface
+        self.bg_color = bg_color
+        # size = V2(*self.text_box.get_size()) + self.margin * 2
+        self.size = size
+        self.position = (position - size * FIXED_SIDES_MULTIPLIER[fixed_sides] + margin)
+        self.bg_rect = [0, 0] + size()
+        self.margin_rect = (margin * -1)() + size()
+        self.border_color = border_color
+        self.border_radius = [border_radius]*4 if not any(isinstance(border_radius, cls) for cls in {tuple, list}) else border_radius
+        self.border_width = border_width
+
+        self.value = initial_value
+        self.update_text()
+
+        self.text_surface = pg.Surface(self.size(), pg.SRCALPHA, 32).convert_alpha()
+        
+    def draw(self) -> None:
+        self.text_surface.fill((0,0,0,0))
+        if self.bg_color != None:
+            pg.draw.rect(self.text_surface, self.bg_color, self.bg_rect, 0, -1, *self.border_radius)
+        
+        self.text_surface.blit(self.text_box, self.text_position())
+        
+        if self.rootEnv.selected_util != self:
+            if self.border_width:
+                pg.draw.rect(self.text_surface, self.border_color, self.margin_rect, self.border_width, -1, *self.border_radius)
+        else:
+            pg.draw.rect(self.text_surface, [127 + 127 * _mt.sin(self.rootEnv.get_time_from_start() * 10)]*3, self.margin_rect, self.border_width if self.border_width else 10, -1, *self.border_radius)
+
+        self.surface.blit(self.text_surface, self.position())
+        
+    def update(self) -> None:
+        if self.rootEnv.mouse.just_pressed[0]:
+            if self.position.x < self.rootEnv.mouse.position.x < self.position.x + self.size.x and\
+               self.position.y < self.rootEnv.mouse.position.y < self.position.y + self.size.y:
+                self.rootEnv.selected_util = self if self.rootEnv.selected_util != self else None
+                self.update_text()
+        if self.rootEnv.selected_util == self:
+            for event in self.rootEnv.events:
+                if event.type == pg.TEXTINPUT:
+                    self.value += event.text if self.check_when_adding == None else self.check_when_adding(event.text)
+                elif event.type == pg.KEYDOWN and event.key == pg.K_BACKSPACE:
+                    self.value = self.value[:-1]
+            if self.rootEnv.keyboard.get_key(pg.K_DELETE):
+                self.value = self.value[:-1]
+            if self.rootEnv.keyboard.get_key(pg.K_RETURN, KEY_MODE_JUST_PRESSED):
+                if callable(self.on_enter_pressed): self.on_enter_pressed(self.value)
+            if self.rootEnv.keyboard.get_key(pg.K_ESCAPE, KEY_MODE_JUST_PRESSED):
+                self.rootEnv.selected_util = self if self.rootEnv.selected_util != self else None
+            self.update_text()
+
+    def update_text(self) -> None:
+        self.text_box = self.font.render(self.prefix + self.value, True, self.text_color)
+        if self.rootEnv != None and self.rootEnv.selected_util == self:
+            # self.text_position = self.position + self.size * V2(.85, .5) - V2(*self.text_box.get_size()) * V2(1, .5) - self.position
+            self.text_position = self.position + self.size * .5 - V2(*self.text_box.get_size()) * V2(.5, .5) - self.position
+        else:
+            self.text_position = self.position + self.size * .5 - V2(*self.text_box.get_size()) * V2(.5, .5) - self.position
+
+class RootEnv:
+    def __init__(self, screen_size:V2|Vector2D=V2(1920, 1080), vsync:bool=True, target_fps:int=60, show_fps=True, quit_on_key_pressed:None|int=pg.K_x, window_flag:int=0, clear_screen_each_frame:bool=True) -> None:
+        self.quit = False
+        self.screen_size :V2|Vector2D= screen_size
+        self.screen = pg.display.set_mode(self.screen_size(), vsync=vsync, flags=window_flag)
+        self.target_fps = target_fps
+        self.current_fps = self.target_fps if self.target_fps != 0 else 1
+        self.delta = 1 / self.current_fps
+        self.current_frame = 0
+        self.show_fps = show_fps
+        self.clock = pg.time.Clock()
+        self.keyboard = Keyboard(self)
+        self.mouse = Mouse(self)
+        self.events :list[Event]= []
+        self.background_color = rgb(0,0,0)
+        self._quit_on_key_pressed = quit_on_key_pressed
+        self.clear_screen_each_frame = clear_screen_each_frame
+        self.starting_time :float= __tm__()
+        self.utils :list[Utils]= []
+        self.selected_util :Utils|None = None
+    
+    def add_utils(self, *utils:Utils) -> None:
+        for util in utils:
+            if util.surface == None: util.surface = self.screen
+        util.rootEnv = self
+        self.utils.extend(utils)
+    
+    def remove_utils(self, *utils:list[Utils]) -> None:
+        for u in utils: self.utils.remove(u)
+    
+    def get_time_from_start(self) -> float:
+        return __tm__() - self.starting_time
+    
+    def init(self, sub_env) -> None:
+        self.env = sub_env
+    
+    def clear(self) -> None:
+        self.screen.fill(self.background_color)
+    
+    def clear_rect(self, position:V2|Vector2D, size:V2|Vector2D) -> None:
+        self.screen.fill(self.background_color, position() + size())
+    
+    def print(self, text:str, position:V2|Vector2D, color:tuple[float,float,float]=(255,255,255), fixed_sides=TEXT_FIXED_SIDES_TOP_LEFT, font:pg.font.Font=FONT_ARIAL_32, bg_color:None|tuple[int,int,int]|list[int]=None, border_color:None|tuple[int,int,int]|list[int]=(255,255,255), border_width:float=0, border_radius:int|list[int]|tuple[int,int,int,int]=-1, margin:V2|Vector2D=V2z, personalized_surface:pg.Surface|None=None) -> None:
+        text_box = font.render(text, True, color)
+        size = V2(*text_box.get_size()) + margin * 2
+        position = position - size * FIXED_SIDES_MULTIPLIER[fixed_sides] + margin
+        if not any(isinstance(border_radius, cls) for cls in {tuple, list}): border_radius = [border_radius]*4
+        surface = (self.screen if personalized_surface == None else personalized_surface)
+        if bg_color != None:
+            pg.draw.rect(surface, bg_color, (position - margin)() + size(), 0, -1, *border_radius)
+        if border_width:
+            pg.draw.rect(surface, border_color, (position - margin)() + size(), border_width, -1, *border_radius)
+        surface.blit(text_box, position())
+
+    def __draw__(self) -> None:
+        self.clock.tick(self.target_fps)
+        self.current_fps = self.clock.get_fps()
+        self.delta = 1 / (self.current_fps if self.current_fps != 0 else 1)
+        if self.clear_screen_each_frame: self.clear()
+        if self.show_fps: self.print(str(round(self.current_fps,2)), self.screen_size * .01, bg_color=(0,0,0))
+        
+        self.env.draw()
+        for util in self.utils: util.draw()
+        pg.display.update()
+    
+    def __update__(self) -> None:
+        self.mouse.update()
+        self.keyboard.update()
+        self.env.update()
+        for util in self.utils: util.update()
+
+    def frame(self) -> None:
+        self.events = pg.event.get()
+        self.current_frame += 1
+        self.__update__()
+        self.__draw__()
+
+        for event in self.events:
+            if event.type == pg.QUIT or ((event.type == pg.KEYDOWN and event.key == self._quit_on_key_pressed and self.selected_util == None) if self._quit_on_key_pressed != None else False):
+                self.quit = True

{e2D-1.4.9 → e2d-1.4.10}/e2D/plots.py

@@ -66,18 +66,30 @@ class Line(Object):
         pg.draw.line(self.__layer_surface__, self.color, self.point_a.center(), self.point_b.center(), self.width)
 
 class Point(Object):
-    def __init__(self, position, label:str="", radius:float=1, color:list[float]|tuple[float,float,float]=(255,255,255)) -> None:
+    def __init__(self, position, label:str="", radius:float=1, color:list[float]|tuple[float,float,float]=(255,255,255),
+                 label_color:tuple[float, float, float]=(255, 255, 255), label_position_offset:Vector2D|V2=V2z,  label_fixed_sides:int=TEXT_FIXED_SIDES_TOP_LEFT, label_font:pg.font.Font=FONT_ARIAL_32, label_bg_color:tuple[int,int,int]|list[int]|None=None, label_border_color:tuple[int,int,int]|list[int]|None=None, label_border_width:float=0, label_border_radius:int|list[int]|tuple[int,int,int,int]=-1, label_margin:V2=V2z) -> None:
         super().__init__()
         self.position = position
         self.radius = radius
         self.color = color
         self.label = label
+        self.label_color = label_color
+        self.label_position_offset = label_position_offset
+        self.label_fixed_sides = label_fixed_sides
+        self.label_font = label_font
+        self.label_bg_color = label_bg_color
+        self.label_border_color = label_border_color
+        self.label_border_width = label_border_width
+        self.label_border_radius = label_border_radius
+        self.label_margin = label_margin
+
         self.rect :list[float]= [0, 0, 0, 0]
         self.center = V2z.copy()
 
     def update(self) -> None:
         radius = self.radius * self.plot.size / (self.plot.bottom_right_plot_coord - self.plot.top_left_plot_coord) * self.plot.__y_axis_multiplier__
         self.center = self.plot.__plot2real__(self.position)
+        self.text_position = self.plot.__plot2real__(self.position + self.label_position_offset)
         position = self.center - radius * .5
         self.rect = position() + radius()
         self.__render__()
@@ -85,6 +97,7 @@ class Point(Object):
     def __render__(self) -> None:
         self.__layer_surface__.fill((0,0,0,0))
         pg.draw.ellipse(self.__layer_surface__, self.color, self.rect)
+        self.plot.rootEnv.print(self.label, self.text_position, color=self.label_color, fixed_sides=self.label_fixed_sides, font=self.label_font, bg_color=self.label_bg_color, border_color=self.label_border_color, border_width=self.label_border_width, border_radius=self.label_border_radius, margin=self.label_margin, personalized_surface=self.__layer_surface__)
 
 class MathFunction(Function):
     def __init__(self, function, domain:list[float]=[-np.inf, np.inf], codomain:list[float]=[-np.inf, np.inf], color:list[float]|tuple[float,float,float]=(255,255,255)) -> None:
@@ -250,6 +263,8 @@ class __PlotSettings__:
             # cursor
                 "zoom_on_center" : False,
                 "warp_mouse" : True,
+                "movable" : True,
+                "zoomable" : True,
 
             # plot visual options
                 # plot system
@@ -284,7 +299,7 @@ class __PlotSettings__:
                 # cursor
                     "show_cursor_coords" : False,
 
-                #rect
+                # rect
                     "render_bg" : True,
                     "bg_color" : rgb(28, 29, 34),
                     "draw_rect" : True,
@@ -296,7 +311,7 @@ class __PlotSettings__:
                     "show_zoom_info": True,
                     "top_left_info_position" : self.plot.position + V2(15, 75),
                     "info_interline_space" : V2(0, 24),
-                    "info_font" : create_arial_font_size(24),
+                    "info_font" : new_font(24),
                     "info_precision" : 2,
         }
 
@@ -401,7 +416,7 @@ class Plot:
             clamped_top_left = grid_step * (self.top_left_plot_coord / grid_step).__ceil__()
             clamped_bottom_right = grid_step * (self.bottom_right_plot_coord / grid_step).__ceil__()
             for x_value in np.arange(clamped_top_left.x, clamped_bottom_right.x, grid_step.x): #type: ignore
-                pg.draw.line( self.canvas, grid_color, self.__plot2real__((x_value, self.top_left_y))(), self.__plot2real__((x_value, self.bottom_right_y))(), grid_width) #type: ignore
+                pg.draw.line(self.canvas, grid_color, self.__plot2real__((x_value, self.top_left_y))(), self.__plot2real__((x_value, self.bottom_right_y))(), grid_width) #type: ignore
             for y_value in np.arange(clamped_bottom_right.y, clamped_top_left.y, grid_step.y): #type: ignore
                 pg.draw.line(self.canvas, grid_color, self.__plot2real__((self.top_left_x, y_value))(), self.__plot2real__((self.bottom_right_x, y_value))(), grid_width) #type: ignore
 
@@ -442,27 +457,29 @@ class Plot:
             self.focus()
 
         if self.is_mouse_in_rect:
-            # mouse scalar is needed for checking if the mouse is hovering an axis, in case it is the opposite one zoom value has to be multiplied by 0 so nullifying it.
-            self.mouse_scalar = V2(0 if abs(self.plot_center_real_position.x - self.rootEnv.mouse.position.x) < self.settings.get("distance_to_axis_for_scalar_zoom") else 1, 0 if abs(self.plot_center_real_position.y - self.rootEnv.mouse.position.y) < self.settings.get("distance_to_axis_for_scalar_zoom") else 1) #type: ignore
-            if self.mouse_scalar.x == self.mouse_scalar.y == 0: self.mouse_scalar = V2one
-            for event in self.rootEnv.events:
-                if event.type == pg.MOUSEWHEEL:
-                    if self.settings.get("zoom_on_center"):
-                        # this will always zoom exactly in the middle of the canvas, according to the current plot offset
-                        self.current_zoom += event.y * self.mouse_scalar
-                    else:
-                        # this will get the pre plot mouse position, calculate the zoom and with the "after" mouse position calculate the offset that i will add to the current plot offset
-                        pre = self.__real2plot__(self.rootEnv.mouse.position)
-                        self.current_zoom += event.y * self.mouse_scalar
-                        # i have to update the corners of the plot here to use the real2plot function correctly (i cant use shortcuts)
-                        self.update_grid(False)
-                        self.current_offset += pre - self.__real2plot__(self.rootEnv.mouse.position)
-                    self.focus()
+            if self.settings.get("zoomable"):
+                # mouse scalar is needed for checking if the mouse is hovering an axis, in case it is the opposite one zoom value has to be multiplied by 0 so nullifying it.
+                self.mouse_scalar = V2(0 if abs(self.plot_center_real_position.x - self.rootEnv.mouse.position.x) < self.settings.get("distance_to_axis_for_scalar_zoom") else 1, 0 if abs(self.plot_center_real_position.y - self.rootEnv.mouse.position.y) < self.settings.get("distance_to_axis_for_scalar_zoom") else 1) #type: ignore
+                if self.mouse_scalar.x == self.mouse_scalar.y == 0: self.mouse_scalar = V2one
+                for event in self.rootEnv.events:
+                    if event.type == pg.MOUSEWHEEL:
+                        if self.settings.get("zoom_on_center"):
+                            # this will always zoom exactly in the middle of the canvas, according to the current plot offset
+                            self.current_zoom += event.y * self.mouse_scalar
+                        else:
+                            # this will get the pre plot mouse position, calculate the zoom and with the "after" mouse position calculate the offset that i will add to the current plot offset
+                            pre = self.__real2plot__(self.rootEnv.mouse.position)
+                            self.current_zoom += event.y * self.mouse_scalar
+                            # i have to update the corners of the plot here to use the real2plot function correctly (i cant use shortcuts)
+                            self.update_grid(False)
+                            self.current_offset += pre - self.__real2plot__(self.rootEnv.mouse.position)
+                        self.focus()
             
-            # start dragging whenever mouse left button is just pressed
-            if self.rootEnv.mouse.just_pressed[0] and self.dragging == None:
-                self.dragging = self.rootEnv.mouse.position.copy()
-                self.start_dragging = self.dragging.copy()
+            if self.settings.get("movable"):
+                # start dragging whenever mouse left button is just pressed
+                if self.rootEnv.mouse.just_pressed[0] and self.dragging == None:
+                    self.dragging = self.rootEnv.mouse.position.copy()
+                    self.start_dragging = self.dragging.copy()
             
         # update the canvas if im dragging
         if self.dragging:

{e2D-1.4.9 → e2d-1.4.10}/e2D/utils.py

@@ -7,7 +7,7 @@ KEY_MODE_JUST_PRESSED = 1
 KEY_MODE_JUST_RELEASED = 2
 
 SCANCODES = {"":0,"backspace":8,"tab":9,"return":13,"escape":27,"space":32,"!":33,"\"":34,"#":35,"$":36,"%":37,"&":38,"'":39,"(":40,")":41,"*":42,"+":43,",":44,"-":45,".":46,"/":47,"0":48,"1":49,"2":50,"3":51,"4":52,"5":53,"6":54,"7":55,"8":56,"9":57,":":58,";":59,"<":60,"=":61,">":62,"?":63,"@":64,"[":91,"\\":92,"]":93,"^":94,"_":95,"`":96,"a":97,"b":98,"c":99,"d":100,"e":101,"f":102,"g":103,"h":104,"i":105,"j":106,"k":107,"l":108,"m":109,"n":110,"o":111,"p":112,"q":113,"r":114,"s":115,"t":116,"u":117,"v":118,"w":119,"x":120,"y":121,"z":122,"delete":127,"caps lock":1073741881,"f1":1073741882,"f2":1073741883,"f3":1073741884,"f4":1073741885,"f5":1073741886,"f6":1073741887,"f7":1073741888,"f8":1073741889,"f9":1073741890,"f10":1073741891,"f11":1073741892,"f12":1073741893,"print screen":1073741894,"scroll lock":1073741895,"break":1073741896,"insert":1073741897,"home":1073741898,"page up":1073741899,"end":1073741901,"page down":1073741902,"right":1073741903,"left":1073741904,"down":1073741905,"up":1073741906,"numlock":1073741907,"[/]":1073741908,"[*]":1073741909,"[-]":1073741910,"[+]":1073741911,"enter":1073741912,"[1]":1073741913,"[2]":1073741914,"[3]":1073741915,"[4]":1073741916,"[5]":1073741917,"[6]":1073741918,"[7]":1073741919,"[8]":1073741920,"[9]":1073741921,"[0]":1073741922,"[.]":1073741923,"power":1073741926,"equals":1073741927,"f13":1073741928,"f14":1073741929,"f15":1073741930,"help":1073741941,"menu":1073741942,"sys req":1073741978,"clear":1073741980,"euro":1073742004,"CurrencySubUnit":1073742005,"left ctrl":1073742048,"left shift":1073742049,"left alt":1073742050,"left meta":1073742051,"right ctrl":1073742052,"right shift":1073742053,"right alt":1073742054,"right meta":1073742055,"alt gr":1073742081,"AC Back":1073742094}
-SCANCODES_NUMS = [i for i in SCANCODES.values()]
+SCANCODES_NUMS = {SCANCODES[key]:i for i,key in enumerate(SCANCODES)}
 
 class Mouse:
     def __init__(self, parent) -> None:
@@ -37,13 +37,14 @@ class Keyboard:
     def __init__(self, parent) -> None:
         self.parent = parent
         self.__pressed__ :list= [False for _ in SCANCODES_NUMS]
-        self.__just_pressed__ :list= [False for _ in range(len(self.__pressed__))]
-        self.__just_released__ :list= [False for _ in range(len(self.__pressed__))]
+        self.__just_pressed__ :list= [False for _ in SCANCODES_NUMS]
+        self.__just_released__ :list= [False for _ in SCANCODES_NUMS]
         self.update()
     
     def update(self) -> None:
+        tmp_pressed = pg.key.get_pressed()
         last_pressed = self.__pressed__.copy()
-        self.__pressed__ :list= [pg.key.get_pressed()[i] for i in SCANCODES_NUMS] # type: ignore
+        self.__pressed__ :list= [tmp_pressed[i] for i in SCANCODES_NUMS] # type: ignore
         self.__just_pressed__ = [self.__pressed__[i] and not last_pressed[i] for i in range(len(SCANCODES_NUMS))]
         self.__just_released__ = [not self.__pressed__[i] and last_pressed[i] for i in range(len(SCANCODES_NUMS))]
     
@@ -82,4 +83,4 @@ class Keyboard:
             ll = self.__just_pressed__
         elif mode == KEY_MODE_JUST_RELEASED:
             ll = self.__just_released__
-        return ll[SCANCODES_NUMS.index(scan_code)]
+        return ll[SCANCODES_NUMS[scan_code]]

{e2D-1.4.9 → e2d-1.4.10}/e2D.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e2D
-Version: 1.4.9
+Version: 1.4.10
 Summary: Python library for 2D games. Streamlines dev with keyboard/mouse input, vector calculations, color manipulation, and collision detection. Simplify game creation and unleash creativity!
 Home-page: https://github.com/marick-py/e2D
 Author: Riccardo Mariani

{e2D-1.4.9 → e2d-1.4.10}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = e2D
-version = 1.4.9
+version = 1.4.10
 author = Riccardo Mariani
 author_email = ricomari2006@gmail.com
 description = Python library for 2D games. Streamlines dev with keyboard/mouse input, vector calculations, color manipulation, and collision detection. Simplify game creation and unleash creativity!

e2D-1.4.9/e2D/envs.py

@@ -1,108 +0,0 @@
-from __future__ import annotations
-from .utils import *
-import pygame as pg
-from time import time as __tm__
-
-"""  CODE EXAMPLE FOR RootEnv
-from e2D.envs import *
-
-class Env:
-    def __init__(self) -> None:
-        pass
-
-    def draw(self) -> None:
-        pass
-
-    def update(self) -> None:
-        pass
-
-(rootEnv:=RootEnv()).init(Env())
-while not rootEnv.quit:
-    rootEnv.frame()
-"""
-
-pg.init()
-pg.font.init()
-FONT_ARIAL_16 = pg.font.SysFont("Arial", 16)
-FONT_ARIAL_32 = pg.font.SysFont("Arial", 32)
-FONT_ARIAL_64 = pg.font.SysFont("Arial", 64)
-create_arial_font_size = lambda size: pg.font.SysFont("Arial", size)
-
-TEXT_FIXED_SIDES_TOP_LEFT = 0
-TEXT_FIXED_SIDES_TOP_MIDDLE = 1
-TEXT_FIXED_SIDES_TOP_RIGHT = 2
-TEXT_FIXED_SIDES_MIDDLE_LEFT = 3
-TEXT_FIXED_SIDES_MIDDLE_MIDDLE = 4
-TEXT_FIXED_SIDES_MIDDLE_RIGHT = 5
-TEXT_FIXED_SIDES_BOTTOM_LEFT = 6
-TEXT_FIXED_SIDES_BOTTOM_MIDDLE = 7
-TEXT_FIXED_SIDES_BOTTOM_RIGHT = 8
-
-class RootEnv:
-    __fixed_sides_multiplier = [V2(x,y) for y in [0, .5, 1] for x in [0, .5, 1]]
-    def __init__(self, screen_size:V2|Vector2D=V2(1920, 1080), vsync:bool=True, target_fps:int=60, show_fps=True, quit_on_key_pressed:None|int=pg.K_x, window_flag:int=0, clear_screen_each_frame:bool=True) -> None:
-        self.quit = False
-        self.screen_size :V2|Vector2D= screen_size
-        self.screen = pg.display.set_mode(self.screen_size(), vsync=vsync, flags=window_flag)
-        self.target_fps = target_fps
-        self.current_fps = self.target_fps if self.target_fps != 0 else 1
-        self.delta = 1 / self.current_fps
-        self.current_frame = 0
-        self.show_fps = show_fps
-        self.clock = pg.time.Clock()
-        self.keyboard = Keyboard(self)
-        self.mouse = Mouse(self)
-        self.events :list= []
-        self.background_color = rgb(0,0,0)
-        self._quit_on_key_pressed = quit_on_key_pressed
-        self.clear_screen_each_frame = clear_screen_each_frame
-        self.starting_time = __tm__()
-    
-    def get_time_from_start(self) -> float:
-        return __tm__() - self.starting_time
-    
-    def init(self, sub_env) -> None:
-        self.env = sub_env
-    
-    def clear(self) -> None:
-        self.screen.fill(self.background_color)
-    
-    def clear_rect(self, position:V2|Vector2D, size:V2|Vector2D) -> None:
-        self.screen.fill(self.background_color, position() + size())
-    
-    def print(self, text:str, position:V2|Vector2D, color:tuple[float,float,float]=(255,255,255), fixed_sides=TEXT_FIXED_SIDES_TOP_LEFT, font:pg.font.Font=FONT_ARIAL_32, bg_color:None|tuple[int,int,int]|list[int]=None, border_color:None|tuple[int,int,int]|list[int]=None, border_width:float=0, border_radius:int|list[int]|tuple[int,int,int,int]=-1, margin:V2|Vector2D=V2z, personalized_surface:pg.Surface|None=None) -> None:
-        text_box = font.render(text, True, color)
-        size = V2(*text_box.get_size()) + margin * 2
-        position = position - size * self.__fixed_sides_multiplier[fixed_sides] + margin
-        if not any(isinstance(border_radius, cls) for cls in {tuple, list}): border_radius = [border_radius]*4
-        surface = (self.screen if personalized_surface == None else personalized_surface)
-        if bg_color != None:
-            pg.draw.rect(surface, bg_color, (position - margin)() + size(), 0, -1, *border_radius)
-        if border_width:
-            pg.draw.rect(surface, border_color, (position - margin)() + size(), border_width, -1, *border_radius)
-        surface.blit(text_box, position())
-
-    def __draw__(self) -> None:
-        self.clock.tick(self.target_fps)
-        self.current_fps = self.clock.get_fps()
-        self.delta = 1 / (self.current_fps if self.current_fps != 0 else 1)
-        if self.clear_screen_each_frame: self.clear()
-        if self.show_fps: self.print(str(round(self.current_fps,2)), self.screen_size * .01, bg_color=(0,0,0))
-
-        self.env.draw()
-        pg.display.update()
-    
-    def __update__(self) -> None:
-        self.mouse.update()
-        self.keyboard.update()
-        self.env.update()
-
-    def frame(self) -> None:
-        self.__update__()
-        self.__draw__()
-
-        self.current_frame += 1
-        self.events = pg.event.get()
-        for event in self.events:
-            if event.type == pg.QUIT or ((event.type == pg.KEYDOWN and event.key == self._quit_on_key_pressed) if self._quit_on_key_pressed != None else False):
-                self.quit = True