e2D 1.4.22__tar.gz → 1.4.24__tar.gz

{e2d-1.4.22 → e2d-1.4.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: e2D
-Version: 1.4.22
+Version: 1.4.24
 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.22 → e2d-1.4.24}/e2D/__init__.py

@@ -52,7 +52,6 @@ class Vector2D:
     def aspect_y(self, new_aspect) -> None:
         self.y = self.x * new_aspect
 
-    @property
     def copy(self) -> "Vector2D":
         return Vector2D(self.x, self.y)
 
@@ -70,7 +69,7 @@ class Vector2D:
     @property
     def normalized(self) -> "Vector2D":
         if (mag:=self.length) == 0:
-            return self.copy
+            return self.copy()
         return Vector2D(self.x / mag, self.y / mag)
 
     @property
@@ -471,47 +470,47 @@ class Vector2D:
     def down_left_norm(cls) -> "Vector2D": return V2down_left_norm
 
     @classmethod
-    def new_zero(cls) -> "Vector2D": return V2zero.copy
+    def new_zero(cls) -> "Vector2D": return V2zero.copy()
     @classmethod
-    def new_one(cls) -> "Vector2D": return V2one.copy
+    def new_one(cls) -> "Vector2D": return V2one.copy()
     @classmethod
-    def new_two(cls) -> "Vector2D": return V2two.copy
+    def new_two(cls) -> "Vector2D": return V2two.copy()
     @classmethod
-    def new_pi(cls) -> "Vector2D": return V2pi.copy
+    def new_pi(cls) -> "Vector2D": return V2pi.copy()
     @classmethod
-    def new_inf(cls) -> "Vector2D": return V2inf.copy
+    def new_inf(cls) -> "Vector2D": return V2inf.copy()
     @classmethod
-    def new_neg_one(cls) -> "Vector2D": return V2neg_one.copy
+    def new_neg_one(cls) -> "Vector2D": return V2neg_one.copy()
     @classmethod
-    def new_neg_two(cls) -> "Vector2D": return V2neg_two.copy
+    def new_neg_two(cls) -> "Vector2D": return V2neg_two.copy()
     @classmethod
-    def new_neg_pi(cls) -> "Vector2D": return V2neg_pi.copy
+    def new_neg_pi(cls) -> "Vector2D": return V2neg_pi.copy()
     @classmethod
-    def new_neg_inf(cls) -> "Vector2D": return V2neg_inf.copy
+    def new_neg_inf(cls) -> "Vector2D": return V2neg_inf.copy()
     @classmethod
-    def new_up(cls) -> "Vector2D": return V2up.copy
+    def new_up(cls) -> "Vector2D": return V2up.copy()
     @classmethod
-    def new_right(cls) -> "Vector2D": return V2right.copy
+    def new_right(cls) -> "Vector2D": return V2right.copy()
     @classmethod
-    def new_down(cls) -> "Vector2D": return V2down.copy
+    def new_down(cls) -> "Vector2D": return V2down.copy()
     @classmethod
-    def new_left(cls) -> "Vector2D": return V2left.copy
+    def new_left(cls) -> "Vector2D": return V2left.copy()
     @classmethod
-    def new_up_right(cls) -> "Vector2D": return V2up_right.copy
+    def new_up_right(cls) -> "Vector2D": return V2up_right.copy()
     @classmethod
-    def new_down_right(cls) -> "Vector2D": return V2down_right.copy
+    def new_down_right(cls) -> "Vector2D": return V2down_right.copy()
     @classmethod
-    def new_up_left(cls) -> "Vector2D": return V2up_left.copy
+    def new_up_left(cls) -> "Vector2D": return V2up_left.copy()
     @classmethod
-    def new_down_left(cls) -> "Vector2D": return V2down_left.copy
+    def new_down_left(cls) -> "Vector2D": return V2down_left.copy()
     @classmethod
-    def new_up_right_norm(cls) -> "Vector2D": return V2up_right_norm.copy
+    def new_up_right_norm(cls) -> "Vector2D": return V2up_right_norm.copy()
     @classmethod
-    def new_down_right_norm(cls) -> "Vector2D": return V2down_right_norm.copy
+    def new_down_right_norm(cls) -> "Vector2D": return V2down_right_norm.copy()
     @classmethod
-    def new_up_left_norm(cls) -> "Vector2D": return V2up_left_norm.copy
+    def new_up_left_norm(cls) -> "Vector2D": return V2up_left_norm.copy()
     @classmethod
-    def new_down_left_norm(cls) -> "Vector2D": return V2down_left_norm.copy
+    def new_down_left_norm(cls) -> "Vector2D": return V2down_left_norm.copy()
 
 
 V2 = Vector2D

{e2d-1.4.22 → e2d-1.4.24}/e2D/__init__.pyi

@@ -195,7 +195,6 @@ class Vector2D:
     @aspect_y.setter
     def aspect_y(self: "Vector2D", new_aspect) -> None: ...
 
-    @property
     def copy(self:"Vector2D") -> "Vector2D":
         """
         # Create a copy of the current Vector2D other.

{e2d-1.4.22 → e2d-1.4.24}/e2D/envs.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Literal
+from typing import Literal, Optional
 
 from .utils import *
 import pygame as pg
@@ -63,7 +63,10 @@ class RootEnv:
         self.show_fps = show_fps
         self.events :list[pg.event.Event]= []
         
-        self.__background_color__ :Color= BLACK_COLOR_PYG
+        # Track start time for accurate runtime calculation (excluding compilation time)
+        self.set_starting_timer()
+        
+        self.__background_color__ :pg.Color= BLACK_COLOR_PYG
         
         self.clear_screen_each_frame = clear_screen_each_frame
         self.utils :dict[int|str, Util]= {}
@@ -73,9 +76,12 @@ class RootEnv:
         self.fps_label = Label(str(round(self.current_fps,2)), self.screen_size * .01, V2(250, 50), BLACK_COLOR_PYG, TRANSPARENT_COLOR_PYG, WHITE_COLOR_PYG, border_width=0, starting_hidden=(not self.show_fps), pivot_position="top_left", font=FONT_ARIAL_32)
         self.add_utils(self.fps_label)
 
-    def init_rec(self, fps:int=30, path:str='output.mp4') -> None:
+    def set_starting_timer(self) -> None:
+        self.__start_time__ = pg.time.get_ticks()
+
+    def init_rec(self, fps:int=30, draw_on_screen:bool=True, path:str='output.mp4', font:pg.font.Font=FONT_MONOSPACE_16) -> None:
         from .winrec import WinRec
-        self.__winrecorder__ = WinRec(self, fps=fps, path=path)
+        self.__winrecorder__ = WinRec(self, fps=fps, draw_on_screen=draw_on_screen, path=path, font=font)
 
     @property
     def background_color(self) -> Color:
@@ -97,24 +103,24 @@ class RootEnv:
         self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__, display=self.__display_index__)
 
     @property
-    def delta(self) -> int:
+    def delta(self) -> float:
         return self.__dt__
 
     def get_teoric_max_fps(self) -> float:
         rawdelta = self.clock.get_rawtime()
         return (1000 / rawdelta) if rawdelta != 0 else 1
 
-    def update_screen_mode(self, vsync:None|bool=None, flags=None, display_index=None) -> None:
-        self.__vsync__ = vsync
-        self.__flags__ = flags
-        self.__display_index__ = display_index
+    def update_screen_mode(self, vsync:Optional[bool]=None, flags:Optional[int]=None, display_index:Optional[int]=None) -> None:
+        if vsync is not None: self.__vsync__ = vsync
+        if flags is not None: self.__flags__ = flags
+        if display_index is not None: self.__display_index__ = display_index
         self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__, display=self.__display_index__)
 
     def sleep(self, seconds:int|float, precise_delay=False) -> None:
         if precise_delay:
-            pg.time.delay(seconds * 1000)
+            pg.time.delay(int(seconds * 1000))
         else:
-            pg.time.wait(seconds * 1000)
+            pg.time.wait(int(seconds * 1000))
 
     def add_utils(self, *utils:Util) -> None:
         for util in utils:
@@ -126,16 +132,16 @@ class RootEnv:
 
     def remove_utils(self, *utils:int|str|Util) -> None:
         for uid in utils:
-            if uid in self.utils:
-                del self.utils[uid]
-            elif isinstance(uid, Util):
+            if isinstance(uid, Util):
                 del self.utils[uid.id]
+            elif uid in self.utils:
+                del self.utils[uid]
             else:
                 raise Exception(f"Unknown util type: {uid}")
     
     def __new_util_id__(self) -> int:
         if not self.utils: return 0
-        else: return max(self.utils.keys()) + 1
+        else: return len(self.utils.keys()) + 1
 
     def get_util(self, uid:int|str) -> Util|None:
         if isinstance(uid, Util):
@@ -147,7 +153,7 @@ class RootEnv:
 
     @property
     def runtime_seconds(self) -> float:
-        return pg.time.get_ticks() / 1e3
+        return (pg.time.get_ticks() - self.__start_time__) / 1e3
 
     def init(self, sub_env:DefEnv) -> None:
         self.env = sub_env
@@ -170,18 +176,19 @@ class RootEnv:
               border_radius : int|list[int]|tuple[int,int,int,int] = -1,
               margin : Vector2D = Vector2D.zero(),
               personalized_surface : pg.Surface|None = None
-            ) -> None:
+            ) -> Vector2D:
 
         text_box = font.render(text, True, color)
         size = Vector2D(*text_box.get_size()) + margin * 2
         pivotted_position = position - size * __PIVOT_POSITIONS_MULTIPLIER__[pivot_position] + margin
-        if not any(isinstance(border_radius, cls) for cls in {tuple, list}): border_radius = [border_radius]*4
+        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, (pivotted_position - margin)() + size(), 0, -1, *border_radius)
         if border_width:
             pg.draw.rect(surface, border_color, (pivotted_position - margin)() + size(), border_width, -1, *border_radius)
         surface.blit(text_box, pivotted_position())
+        return size
 
     def __draw__(self) -> None:
         self.__dt__ = self.clock.tick(self.target_fps) / 1000.0
@@ -193,6 +200,11 @@ class RootEnv:
         self.env.draw()
         for util in self.utils.values(): util.__draw__()
 
+        # Save frame first (clean), then draw info overlay (not saved)
+        if hasattr(self, "__winrecorder__"):
+            self.__winrecorder__.update()  # Captures frame without stats
+            self.__winrecorder__.draw()     # Draws stats on screen only
+
         pg.display.flip()
 
     def __update__(self) -> None:
@@ -201,10 +213,6 @@ class RootEnv:
         self.env.update()
         for util in self.utils.values(): util.__update__()
 
-        if hasattr(self, "__winrecorder__"):
-            self.__winrecorder__.update()
-            self.__winrecorder__.draw()
-
     def frame(self) -> None:
         try:
             self.events = pg.event.get()

{e2d-1.4.22 → e2d-1.4.24}/e2D/utils.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 from typing import Any, Callable, Literal
 import pygame as pg
-from e2D import *
-from e2D.colors import *
+from e2D import * # type: ignore
+from e2D.colors import * # type: ignore
 
 import math as _mt
 
@@ -18,6 +18,10 @@ def NEW_FONT(size, name:__LITERAL_FONTS__="arial", bold:bool=False, italic:bool=
 FONT_ARIAL_16 = NEW_FONT(16)
 FONT_ARIAL_32 = NEW_FONT(32)
 FONT_ARIAL_64 = NEW_FONT(64)
+FONT_MONOSPACE_16 = NEW_FONT(16, "cascadiamonoregular")
+FONT_MONOSPACE_32 = NEW_FONT(32, "cascadiamonoregular")
+FONT_MONOSPACE_64 = NEW_FONT(64, "cascadiamonoregular")
+
 
 
 __LITERAL_PIVOT_POSITIONS__ = Literal["top_left", "top_center", "top_right", "center_left", "center_center", "center_right", "bottom_left", "bottom_center", "bottom_right"]

e2d-1.4.24/e2D/winrec.py

@@ -0,0 +1,211 @@
+from typing import Optional, TYPE_CHECKING
+from e2D import V2
+from e2D.envs import RootEnv, FONT_MONOSPACE_16
+from e2D.colors import BLACK_COLOR_PYG
+import pygame as pg
+import numpy as np
+import cv2
+import threading
+import queue
+import time
+
+class WinRec:
+    def __init__(self, rootEnv:RootEnv, fps:int=30, draw_on_screen:bool=True, path:str='output.mp4', font:pg.font.Font=FONT_MONOSPACE_16) -> None:
+        self.rootEnv = rootEnv
+        self.path = path
+        self.fps = fps
+        self.draw_on_screen = draw_on_screen
+        self.font = font
+        self.is_recording = True  # Recording state (pause/resume)
+        self.screenshot_counter = 0  # Counter for screenshot filenames
+        self.recording_frames = 0  # Frames actually recorded (excludes paused frames)
+        self.pause_start_time = None  # Track when recording was paused
+        self.total_pause_duration = 0.0  # Cumulative pause time
+        size = self.rootEnv.screen_size
+        self.video_writer = cv2.VideoWriter(self.path, cv2.VideoWriter_fourcc(*'mp4v'), self.fps, size()) #type: ignore
+        
+        # Pre-allocate buffers for zero-copy operations
+        self.frame_buffer = np.empty(shape=(int(size.y), int(size.x), 3), dtype=np.uint8)
+        
+        # Setup async video writing
+        self.frame_queue = queue.Queue(maxsize=120)  # Buffer up to 4 seconds at 30fps
+        self.running = True
+        
+        # Statistics tracking
+        self.frames_written = 0
+        self.frames_dropped = 0
+        self.write_start_time = time.time()
+        self.last_stat_update = time.time()
+        self.current_write_fps = 0.0
+        
+        self.write_thread = threading.Thread(target=self._write_worker, daemon=False)
+        self.write_thread.start()
+    
+    def _write_worker(self) -> None:
+        """Background thread that writes frames to video file."""
+        while self.running or not self.frame_queue.empty():
+            try:
+                frame = self.frame_queue.get(timeout=0.1)
+                self.video_writer.write(frame)
+                self.frames_written += 1
+                self.frame_queue.task_done()
+                
+                # Update write FPS every second
+                current_time = time.time()
+                if current_time - self.last_stat_update >= 1.0:
+                    elapsed = current_time - self.write_start_time
+                    self.current_write_fps = self.frames_written / elapsed if elapsed > 0 else 0
+                    self.last_stat_update = current_time
+            except queue.Empty:
+                continue
+    
+    def handle_input(self) -> None:
+        """Handle recording control keyboard inputs (F9-F12)."""
+        # F9: Toggle pause/resume recording
+        if self.rootEnv.keyboard.get_key(pg.K_F9, "just_pressed"):
+            self.toggle_recording()
+            status = "REC" if self.is_recording else "PAUSED"
+            print(f"[Recording] {status}")
+        
+        # F10: Restart recording (reset all and resume)
+        if self.rootEnv.keyboard.get_key(pg.K_F10, "just_pressed"):
+            self.restart()
+            print("[Recording] Restarted (buffer cleared, timers reset)")
+        
+        # F12: Take screenshot
+        if self.rootEnv.keyboard.get_key(pg.K_F12, "just_pressed"):
+            screenshot_path = self.take_screenshot()
+            print(f"[Screenshot] Saved: {screenshot_path}")
+    
+    def update(self) -> None:
+        # Handle keyboard input first
+        self.handle_input()
+        
+        # Skip frame capture if recording is paused
+        if not self.is_recording:
+            return
+        
+        # Increment recording frame counter
+        self.recording_frames += 1
+            
+        # Use pixels3d for zero-copy view, then transpose (creates view, not copy)
+        pixels = pg.surfarray.pixels3d(self.rootEnv.screen)
+        transposed = np.transpose(pixels, (1, 0, 2))
+        
+        # Convert color in-place to pre-allocated buffer
+        cv2.cvtColor(transposed, cv2.COLOR_RGB2BGR, dst=self.frame_buffer)
+        
+        # Queue frame copy for async writing (non-blocking)
+        try:
+            self.frame_queue.put_nowait(self.frame_buffer.copy())
+        except queue.Full:
+            self.frames_dropped += 1  # Track dropped frames
+    
+    def get_rec_seconds(self) -> float:
+        """Get recorded time in seconds (excludes paused time)."""
+        return self.recording_frames / self.fps
+
+    def draw(self) -> None:
+        # Calculate statistics
+        buffer_size = self.frame_queue.qsize()
+        buffer_percent = (buffer_size / self.frame_queue.maxsize) * 100
+        buffer_seconds = buffer_size / self.fps if self.fps > 0 else 0
+        
+        # Estimate optimal buffer size based on write performance
+        if self.current_write_fps > 0 and self.fps > 0:
+            write_lag = self.fps / self.current_write_fps
+            estimated_buffer = int(self.fps * 2 * write_lag)  # 2 seconds of lag compensation
+        else:
+            estimated_buffer = self.frame_queue.maxsize
+        
+        # Recording state indicator
+        rec_status = "REC" if self.is_recording else "PAUSED"
+        
+        # Format with fixed width for stable display (monospace-friendly)
+        row1 = (f"[{rec_status}] RecFrames:{self.recording_frames:>6} | "
+            f"RecTime:{self.get_rec_seconds():>6.2f}s | "
+            f"AppTime:{self.rootEnv.runtime_seconds:>6.2f}s")
+        row2 = (f"Buffer:{buffer_size:>3}/{self.frame_queue.maxsize:<3} ({buffer_percent:>5.1f}%, {buffer_seconds:>4.1f}s) | "
+            f"WriteFPS:{self.current_write_fps:>5.1f}")
+        row3 = (f"Written:{self.frames_written:>6} | Dropped:{self.frames_dropped:>4} | OptBuf:{estimated_buffer:>3}")
+        row4 = "[F9]Pause/Resume [F10]Restart [F12]Screenshot"
+
+        if self.draw_on_screen:
+            size = self.rootEnv.print(row4, self.rootEnv.screen_size - V2(16, 16), pivot_position='bottom_right', font=self.font, margin=V2(10, 10), bg_color=BLACK_COLOR_PYG, border_radius=10)
+            self.rootEnv.print(row3, self.rootEnv.screen_size - V2(16, 16 + size.y), pivot_position='bottom_right', font=self.font, margin=V2(10, 10), bg_color=BLACK_COLOR_PYG, border_radius=10)
+            self.rootEnv.print(row2, self.rootEnv.screen_size - V2(16, 16 + size.y * 2), pivot_position='bottom_right', font=self.font, margin=V2(10, 10), bg_color=BLACK_COLOR_PYG, border_radius=10)
+            self.rootEnv.print(row1, self.rootEnv.screen_size - V2(16, 16 + size.y * 3), pivot_position='bottom_right', font=self.font, margin=V2(10, 10), bg_color=BLACK_COLOR_PYG, border_radius=10)
+    
+    def pause(self) -> None:
+        """Pause recording (stop capturing frames)."""
+        if self.is_recording:
+            self.is_recording = False
+            self.pause_start_time = time.time()
+    
+    def resume(self) -> None:
+        """Resume recording (continue capturing frames)."""
+        if not self.is_recording and self.pause_start_time is not None:
+            self.total_pause_duration += time.time() - self.pause_start_time
+            self.pause_start_time = None
+        self.is_recording = True
+    
+    def toggle_recording(self) -> None:
+        """Toggle between pause and resume."""
+        self.is_recording = not self.is_recording
+    
+    def restart(self) -> None:
+        """Restart recording: clear buffer, reset all counters and timers, resume recording."""
+        self.clear_buffer()
+        self.recording_frames = 0
+        self.total_pause_duration = 0.0
+        self.pause_start_time = None
+        self.is_recording = True
+    
+    def clear_buffer(self) -> None:
+        """Clear the frame queue and reset write statistics."""
+        # Clear the queue
+        while not self.frame_queue.empty():
+            try:
+                self.frame_queue.get_nowait()
+                self.frame_queue.task_done()
+            except queue.Empty:
+                break
+        
+        # Reset write counters (but keep recording frames)
+        self.frames_written = 0
+        self.frames_dropped = 0
+        self.write_start_time = time.time()
+        self.last_stat_update = time.time()
+        self.current_write_fps = 0.0
+    
+    def take_screenshot(self, filename:Optional[str]=None) -> str:
+        """Save current screen as PNG screenshot.
+        
+        Args:
+            filename: Optional custom filename. If None, auto-generates with counter.
+        
+        Returns:
+            str: Path to saved screenshot
+        """
+        if filename is None:
+            # Auto-generate filename with counter
+            base_path = self.path.rsplit('.', 1)[0]  # Remove .mp4 extension
+            filename = f"{base_path}_screenshot_{self.screenshot_counter:04d}.png"
+            self.screenshot_counter += 1
+        
+        # Capture current screen
+        pixels = pg.surfarray.pixels3d(self.rootEnv.screen)
+        transposed = np.transpose(pixels, (1, 0, 2))
+        screenshot_buffer = np.empty(shape=(int(self.rootEnv.screen_size.y), int(self.rootEnv.screen_size.x), 3), dtype=np.uint8)
+        cv2.cvtColor(transposed, cv2.COLOR_RGB2BGR, dst=screenshot_buffer)
+        
+        # Save as PNG
+        cv2.imwrite(filename, screenshot_buffer)
+        return filename
+    
+    def quit(self) -> None:
+        # Stop accepting new frames and wait for queue to flush
+        self.running = False
+        self.frame_queue.join()  # Wait for all queued frames to be written
+        self.write_thread.join(timeout=5.0)  # Wait for thread to finish
+        self.video_writer.release()

{e2d-1.4.22 → e2d-1.4.24}/e2D.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: e2D
-Version: 1.4.22
+Version: 1.4.24
 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.22 → e2d-1.4.24}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = e2D
-version = 1.4.22
+version = 1.4.24
 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.22/e2D/winrec.py

@@ -1,27 +0,0 @@
-from e2D.envs import *
-import pygame as pg
-import numpy as np
-import cv2
-
-class WinRec:
-    def __init__(self, rootEnv:RootEnv, fps:int=30, path:str='output.mp4') -> None:
-        self.rootEnv = rootEnv
-        self.path = path
-        self.fps = fps
-        self.video_writer = cv2.VideoWriter(self.path, cv2.VideoWriter_fourcc(*'mp4v'), self.fps, self.rootEnv.screen_size()) #type: ignore
-    
-    def update(self) -> None:
-        frame = cv2.cvtColor(np.swapaxes(pg.surfarray.array3d(self.rootEnv.screen), 0, 1), cv2.COLOR_RGB2BGR)
-        self.video_writer.write(frame)
-    
-    def get_rec_seconds(self) -> float:
-        return self.rootEnv.current_frame/self.fps
-
-    def draw(self, draw_on_screen=False) -> None:
-        text = f"[cfps:{self.rootEnv.current_frame} || realtime:{round(self.get_rec_seconds(),2)} || apptime:{round(self.rootEnv.runtime_seconds,2)}]"
-        pg.display.set_caption(text)
-        if draw_on_screen: self.rootEnv.print(text, self.rootEnv.screen_size, pivot_position='bottom_right')
-    
-    def quit(self) -> None:
-        self.video_writer.release()
-