please thanks

.gitignore

@@ -1,4 +1,2 @@
-
-*.pyc
-*.pyc
 *.pyc
+__pycache__/classes.cpython-311.pyc

.python-version

@@ -0,0 +1 @@
+3.14

classes.py

@@ -2,11 +2,13 @@
 import math
 import pygame
 import random
+from typing import Tuple, Union
+
 class plane:
 
     g = 9.8
 
-    def __init__(self, size:tuple[int,int], skewX:int = 0, skewY:int = 0, contents:list = []) -> None:
+    def __init__(self, size:tuple[int,int], screen, skewX:int = 0, skewY:int = 0, contents:list = []) -> None:
 
         self.skewX = 0
         self.skewY = 0
@@ -15,6 +17,9 @@ def __init__(self, size:tuple[int,int], skewX:int = 0, skewY:int = 0, contents:l
         self.forceY = 0
 
         self.sizeX, self.sizeY = size[0]/10, size[1]/10
+        self.screenW, self.screenH = pygame.display.Info().current_w, pygame.display.Info().current_h
+        self.screen = screen
+
         self.contents = contents
         self.positions = []
 
@@ -33,35 +38,51 @@ def addAngle(self, x, y):
         self.skewX += y
         self.maxAngle()
 
-    def followMouse(self,screen):
-        w, h = pygame.display.Info().current_w, pygame.display.Info().current_h
-        unitX, unitY = (2*math.pi)/w, (2*math.pi)/w
+    def followMouse(self):
+        unitX, unitY = (2*math.pi)/self.screenW, (2*math.pi)/self.screenH
 
-        x = pygame.mouse.get_pos()[0] - w/2
-        y = pygame.mouse.get_pos()[1] - h/2
+        x = pygame.mouse.get_pos()[0] - self.screenW/2
+        y = pygame.mouse.get_pos()[1] - self.screenH/2
 
         self.setAngle(x * unitX, y * unitY)
-
+
+    def update(self, deltaTime, force):
+        for particle in self.contents:
+            particle.updatePos(deltaTime, force)
+            particle.draw(self.screen)     
 
     def force(self):
         self.forceX = plane.g * math.sin(self.skewX)
         self.forceY = plane.g * math.sin(self.skewY)
 
         return (self.forceX, self.forceY)
 
-    def indicator(self,screen):
+    def indicator(self):
         w, h = pygame.display.Info().current_w, pygame.display.Info().current_h
         unitX, unitY = w/(2*math.pi), h/(2*math.pi)
         center = (round(w/2),round(h/2))
         end_pos = (round( self.skewX * unitX + w/2 ), round( self.skewY * unitY + h/2 ))
-        pygame.draw.line(screen,(110,100,110), center, (end_pos))
+        pygame.draw.line(self.screen,(110,100,110), center, (end_pos))
+
+    def drawGrid(self):
+        for i in range(0,self.screenW, 10):
+            pygame.draw.line(self.screen, (0,10,30), (i,0), (i,self.screenH))
 
-    def updateSize(self, screen):
+        for i in range(0,self.screenH, 10):
+            pygame.draw.line(self.screen, (0,10,30), (0, i), (self.screenW, i))
+
+    def updateSize(self):
         self.sizeX, self.sizeY = pygame.display.Info().current_w/10 , pygame.display.Info().current_h/10
 
+    def clear(self):
+        self.contents = []
+        self.positions = []
+        dust.id = 0
+
 class dust:
 
     id = 0
+    dampCollisions = 5
 
     def __init__(self, plane, pos:tuple[int,int], mass:int = 1, color:str = False, vel:tuple[int,int] = (0, 0)) -> None:
 
@@ -78,10 +99,8 @@ def __init__(self, plane, pos:tuple[int,int], mass:int = 1, color:str = False, v
         else:
             self.color = (random.randint(30,255),random.randint(30,255),random.randint(30,255))
 
-        if self.pos() not in self.plane.positions:
-            self.plane.contents.append(self)
-        else:
-            del self
+        self.plane.contents.append(self)
+        self.plane.positions.append(self.pos())
 
         if not (0<self.posX<self.plane.sizeX or 0<self.posY<self.plane.sizeY):
             raise ValueError('dust must be inside your plane!!!')
@@ -95,22 +114,27 @@ def pos(self):
 
     def updatePos(self, deltaTime, force):
 
-        velX = self.velX + force[0]*deltaTime/self.mass * 1000
-        velY = self.velY + force[1]*deltaTime/self.mass * 1000
-
-        x = self.posX + velX * deltaTime
-        y = self.posY + velY * deltaTime
+        velX = self.velX + force[0]*deltaTime/self.mass * 300
+        velY = self.velY + force[1]*deltaTime/self.mass * 300
 
+        x = self.posX + velX * deltaTime * 10
+        y = self.posY + velY * deltaTime * 10
+
         if not 0.1<x<self.plane.sizeX-0.1: #i wasted 4 hours here trying to fix collission and all i had to do was use 0.01 instead of 0.1 kms
                 x = self.posX
+                self.velX *= -1 * dust.dampCollisions
 
         if not 0.01<y<self.plane.sizeY-0.01:
                 y = self.posY
+                self.velY *= -1 * dust.dampCollisions
 
         newPos = self.gridPos(x,y)
-
-        if newPos in self.plane.positions:
-            x, y = self.posX, self.posY
+        for id, pos in enumerate(self.plane.positions):
+            if newPos == pos and id != self.id:
+
+                x, y = self.posX, self.posY
+                self.velX *= -1 * dust.dampCollisions
+                self.velY *= -1 * dust.dampCollisions
 
             # if (dust.gridPos(newPos[0], self.posY)) not in self.plane.positions:
             #     x = self.posX
@@ -123,8 +147,53 @@ def updatePos(self, deltaTime, force):
         self.posX, self.posY = x, y
 
 
-        self.plane.positions.append(self.pos())
+        self.plane.positions[self.id] = self.pos()
+
 
     def draw(self,screen):
         x,y = self.pos()
-        pygame.draw.rect(screen, self.color,(x,y,10,10))
+        pygame.draw.rect(screen, self.color,(x,y,10,10),5,2)
+
+
+class Button:
+    def __init__(
+        self,
+        pos: Tuple[int, int],
+        size: Tuple[int, int],
+        text: str,
+        text_color: Union[str, Tuple[int, int, int]],
+        bg_color: Union[str, Tuple[int, int, int]],
+        method: callable = lambda: None,
+    ) -> None:
+        self.rect = pygame.Rect(pos, size)
+        self.font = pygame.font.SysFont("Arial", size[1])
+        self.text_surf = self.font.render(text, False, text_color)
+
+        self.color = bg_color
+        self.text = text
+        self.func = method
+
+        self._text_pos = self.text_surf.get_rect(center=self.rect.center).topleft
+
+        self._is_pressed = False
+
+    def draw(self, surface: pygame.Surface) -> None:
+        """Draws the pygame.Rect and font"""
+        pygame.draw.rect(surface, self.color, self.rect)
+        surface.blit(
+            self.text_surf,
+            self._text_pos,
+        )
+
+    def handle_events(self, event: pygame.event.Event) -> None:
+        """Put this inside of your event loop"""
+        if event.type == pygame.MOUSEBUTTONDOWN:
+            if event.button == 1 and self.rect.collidepoint(event.pos):
+                self._is_pressed = True
+            else:
+                self._is_pressed = False
+
+        elif event.type == pygame.MOUSEBUTTONUP:
+            if self._is_pressed and self.rect.collidepoint(event.pos):
+                self.func()
+            self._is_pressed = False

main.py

@@ -1,69 +1,91 @@
+# /// script
+# dependencies = [
+#  "plyer",
+# ]
+# ///
+
 from classes import *
 import time
 import pygame
 import asyncio
-import plyer
-
-
 
 try:
+    import plyer
     plyer.accelerometer.enable()
-    if plyer.accelerometer.acceleration[0] is None:
-        accel = False
-        raise ValueError
-
-    accel = True
+    accel = False
+    for _ in range(25):
+        if plyer.accelerometer.get_acceleration()[0] != plyer.accelerometer.get_acceleration()[1]:
+            accel = True
+            break
+
 except Exception as e:
     accel = False
 
+#F this i quit
+accel = True
+
 pygame.init()
 clock = pygame.time.Clock()
 
 previous_time = time.time()
 height, width = 700,700
-screen = pygame.display.set_mode((width,height), flags= pygame.RESIZABLE)
-surface = plane((width/10,height/10))
+screen = pygame.display.set_mode((width,height), flags = pygame.RESIZABLE)
+surface = plane((width/10,height/10), screen = screen)
 
+clear_button = Button((50,10),(80,40),"clear", (150,150,150), (5,10,30), surface.clear)
 
+
+
+pygame.mouse.set_pos((height/2, width/2))
+
+last_touched = time.time()
 async def main():
-    global previous_time, accel
+
+    global accel, previous_time
+
     while True:
 
         clock.tick()
         for event in pygame.event.get():
+
             if event.type == pygame.QUIT:
                 pygame.quit()
                 break
 
+
             if event.type == pygame.KEYDOWN:
-                surface.contents = []
+                surface.clear()
 
-        if pygame.mouse.get_pressed()[0]:
-            mX, mY = pygame.mouse.get_pos()
-            surface.contents.append(dust(surface, (mX/10, mY/10)))
+            clear_button.handle_events(event)
 
-        if accel:
-            surface.setAngle(plyer.accelerometer.acceleration[:-1])
-        else:
-            surface.followMouse(surface)
+        if pygame.mouse.get_pressed()[0]:
+            if time.time() - last_touched >= 0.03:
+                mX, mY = pygame.mouse.get_pos()
+                surface.contents.append(dust(surface, (mX/10, mY/10),mass = random.randint(10, 30)/10))
+                last_touched = time.time()
 
         #Loop variables
         deltaTime = time.time() - previous_time
         previous_time = time.time()
-        force = surface.force()
 
-        #Particle updates
-        for particle in surface.contents:
-            particle.updatePos(deltaTime, force)
-            particle.draw(screen)
+        if accel:
+           force = (-1 * plyer.accelerometer.get_acceleration()[0], plyer.accelerometer.get_acceleration()[1])
+        else:
+            surface.followMouse()
+            force = surface.force()
+
+        clear_button.draw(screen)
+        surface.drawGrid()
+        surface.indicator()
 
+        #Particle updates
+        surface.update(deltaTime , force)
+
         pygame.display.set_caption(f"pixel-dust | trimpta | FPS: {clock.get_fps():.0f} | PC: {len(surface.contents)}")
-        surface.indicator(screen)
-        surface.updateSize(screen)
         pygame.display.update()
-        screen.fill((0,0,0))
+        screen.fill((5,1,20))
 
-        surface.positions = []
+        surface.updateSize()
 
         await asyncio.sleep(0)
 

pyproject.toml

@@ -0,0 +1,10 @@
+[project]
+name = "pixel-dust"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "plyer>=2.1.0",
+    "pygame-ce>=2.5.7",
+]