e2D 1.4.9__py3-none-any.whl → 1.4.11__py3-none-any.whl

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.
@@ -1165,15 +1168,14 @@ def get_points(position:Vector2D, size:Vector2D, rotation:int|float=0, pos_in_mi
         clockwise order (A, B, D, C), otherwise, they will be returned in counterclockwise order (A, B, C, D).
     """
     if pos_in_middle:
-        A, B, C, D = [position.point_from_degs(rotation + V2z.angle_to(size/-2),                 V2z.distance_to(size/-2)),
-                      position.point_from_degs(rotation + V2z.angle_to(Vector2D(size.x, -1*size.y)/2), V2z.distance_to(Vector2D(size.x, -1*size.y)/2)),
-                      position.point_from_degs(rotation + V2z.angle_to(Vector2D(-1*size.x, size.y)/2), V2z.distance_to(Vector2D(-1*size.x, size.y)/2)),
-                      position.point_from_degs(rotation + V2z.angle_to(size/2),                  V2z.distance_to(size/2))]
+        d,a = size.length()/2, size.angle()
+        d1, d2 = V2z.point_from_rads(rotation+a, d), V2z.point_from_rads(rotation-a, d)
+        A, B, C, D = position+d1, position+d2, position-d2, position-d1
     else:
-        A, B, C, D = [position.copy(),
-                      position.point_from_degs(rotation + V2z.angle_to(Vector2D(size.x, 0)), V2z.distance_to(Vector2D(size.x, 0))),
-                      position.point_from_degs(rotation + V2z.angle_to(Vector2D(0, size.y)), V2z.distance_to(Vector2D(0, size.y))),
-                      position.point_from_degs(rotation + V2z.angle_to(size),                V2z.distance_to(size))]
+        A, B, C, D = position.copy(),\
+                     position.point_from_rads(rotation + V2z.angle_to(Vector2D(size.x, 0)), V2z.distance_to(Vector2D(size.x, 0))),\
+                     position.point_from_rads(rotation + V2z.angle_to(Vector2D(0, size.y)), V2z.distance_to(Vector2D(0, size.y))),\
+                     position.point_from_rads(rotation + V2z.angle_to(size),                V2z.distance_to(size))
     points = (A, B, C, D) if not clockwise_return else (A, B, D, C)
     return points if not return_list else tuple(x() for x in points)
 

e2D/envs.py

@@ -1,7 +1,10 @@
 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 *
@@ -26,7 +29,7 @@ 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)
+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
@@ -38,8 +41,105 @@ 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:
-    __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
@@ -52,11 +152,22 @@ class RootEnv:
         self.clock = pg.time.Clock()
         self.keyboard = Keyboard(self)
         self.mouse = Mouse(self)
-        self.events :list= []
+        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 = __tm__()
+        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
@@ -70,10 +181,10 @@ class RootEnv:
     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:
+    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 * self.__fixed_sides_multiplier[fixed_sides] + margin
+        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:
@@ -88,21 +199,23 @@ class RootEnv:
         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__()
 
-        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
+            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/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:
@@ -492,7 +509,7 @@ class Plot:
                 self.update_grid()
                 self.render()
         
-    def get_humanoid_zoom(self) -> None:
+    def get_humanoid_zoom(self) -> V2|Vector2D:
         return 2 ** (-.1*self.current_zoom)
         
     def focus(self, center:V2|Vector2D|None=None, zoom:float|Vector2D|V2|None=None) -> None:

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.dist-info → e2D-1.4.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e2D
-Version: 1.4.9
+Version: 1.4.11
 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.11.dist-info/RECORD

@@ -0,0 +1,11 @@
+e2D/__init__.py,sha256=m7BKK9r6t8csv9k_Rmm5sTegvvyx-6-2xPof85Y5BI4,56244
+e2D/cvb.py,sha256=xMpwUBE1G2TOdah-x62W_6yXZey-n1p0OkvfiijZfNY,37445
+e2D/envs.py,sha256=9T5COi1mwbEXOSXOBtZWBYr48WnqJQWhVny8U0g2ql0,9771
+e2D/plots.py,sha256=hLib9scdz10pXgiimaqdg7A363h1TP1X8KpIGRpM1cw,33111
+e2D/utils.py,sha256=0BBnUygsLp-fx5cVgKhxe-WGZNj0YZvJz1ejlD7Emfc,5534
+e2D/winrec.py,sha256=WBdRJELP4ia_xPinBbY5AfHrFqRRkehqCPLDq5wH2s4,1218
+e2D-1.4.11.dist-info/LICENSE,sha256=wymkNVDvj3qmjdO_rAhkRPM4t5y3_SqffGsFdgfvznU,1066
+e2D-1.4.11.dist-info/METADATA,sha256=6R1oYvr4cFOrbW_AWj2Hs0q3toGZfCNUv6r92OR6ya4,9609
+e2D-1.4.11.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+e2D-1.4.11.dist-info/top_level.txt,sha256=3vKZ-CGzNlTCpzVMmM0Ht76krCofKw7hZ0wBf-dnKdM,4
+e2D-1.4.11.dist-info/RECORD,,

{e2D-1.4.9.dist-info → e2D-1.4.11.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (72.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

e2D-1.4.9.dist-info/RECORD

@@ -1,11 +0,0 @@
-e2D/__init__.py,sha256=c0HhpDXXFr7PaocUGz4VLcNFrDsdDl0jqhGWWADW05Q,56506
-e2D/cvb.py,sha256=xMpwUBE1G2TOdah-x62W_6yXZey-n1p0OkvfiijZfNY,37445
-e2D/envs.py,sha256=G-jmjuEsPjEPp6OO3FWcAUJ3bggzsUK2IS1yEKfQH0M,4396
-e2D/plots.py,sha256=zuA9lbdQfKStxcd_0HNzryHgrtlf_1Qtu-B-LcZhvNE,31542
-e2D/utils.py,sha256=hGO9WhvDvE6wDDw0vIEjVCis64aTOMgrssx-P0_znhI,5513
-e2D/winrec.py,sha256=WBdRJELP4ia_xPinBbY5AfHrFqRRkehqCPLDq5wH2s4,1218
-e2D-1.4.9.dist-info/LICENSE,sha256=wymkNVDvj3qmjdO_rAhkRPM4t5y3_SqffGsFdgfvznU,1066
-e2D-1.4.9.dist-info/METADATA,sha256=r3xAnGpp9ONp7i0Q0ch7uQNylyZ6P1TuCfsL4QFGte0,9608
-e2D-1.4.9.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-e2D-1.4.9.dist-info/top_level.txt,sha256=3vKZ-CGzNlTCpzVMmM0Ht76krCofKw7hZ0wBf-dnKdM,4
-e2D-1.4.9.dist-info/RECORD,,