button.py

@@ -1,31 +0,0 @@
-import pygame
-
-class Button():
-    def __init__(self, screen, color, x, y, width, height, text) -> None:
-        self.pos = x,y
-        self.größe = width,height
-        self.color = color
-        self.screen = screen
-        self.text = text
-    def draw(self):
-        pygame.draw.rect(self.screen,
-                         self.color, 
-                        (self.pos[0]-self.größe[0]//2, 
-                         self.pos[1]-self.größe[1]//2, 
-                         self.größe[0], 
-                         self.größe[1])
-        )
-    
-        font = pygame.font.Font(None, 36)
-        text_surface = font.render(self.text, True, (0,0,0))
-        text_rect = text_surface.get_rect()
-        text_rect.center = (self.pos[0], 
-                            self.pos[1])
-        self.screen.blit(text_surface, text_rect)
-    def check_press(self, mouse):
-        if (self.pos[0] - self.größe[0]//2 <= mouse[0] <= self.pos[0] + self.größe[0]//2 and
-            self.pos[1] - self.größe[1]//2 <= mouse[1] <= self.pos[1] + self.größe[1]//2):
-            return True
-        else:
-            return False
-

main.py

@@ -1,95 +1,95 @@
 #!/usr/bin/python3
 import pygame
-from button import *
+import pygame.gfxdraw
 import copy
 import random
-
 pygame.init()
-
-
 ## funktionen
 def get_debug_text():
-    def text(text, line_counter):
+    def text(text,line_counter):
-        debug_text = default_font.render(str(text), True, (255, 255, 255))
+        debug_text = default_font.render(str(text), True, (255,255,255))
-        screen.blit(debug_text, (0, line_counter * default_font.get_height()))
+        screen.blit(debug_text,(0,line_counter*default_font.get_height()))
 
     line_counter = 1
     globalvars = globals()
     for a in globalvars:
-        text(f"{str(a)} = {str(globalvars[a])}", line_counter)
+        text(f"{str(a)} = {str(globalvars[a])}",line_counter)
         line_counter += 1
 
+def centered_text(text=str,pos=tuple,color=tuple):
+    text = default_font.render(str(text), True, color,(255,255,255))
+    screen.blit(text,(pos[0]-text.get_width()/2,pos[1]))
 
-def centered_text(text=str, pos=tuple, color=tuple):
+def draw_feld(feld,color_key,block_size):
-    text = default_font.render(str(text), True, color, (255, 255, 255))
+    #print(feld)
-    screen.blit(text, (pos[0] - text.get_width() / 2, pos[1]))
-
-
-def draw_feld(feld, color_key, block_size):
     for a in range(len(feld[0])):
         for b in range(len(feld)):
             if feld[b][a] != " ":
-                pygame.draw.rect(
+                pygame.draw.rect(screen,color_key[feld[b][a]],
-                    screen,
+                                 (a*block_size,
-                    color_key[feld[b][a]],
+                                  b*block_size,
-                    (a * block_size, b * block_size, block_size, block_size),
+                                  block_size,
-                )
+                                  block_size))
-
+def get_block_size():
+    return 20,20
+def get_meightboars(feld,position):
+    nachtbaren = []
+    return nachtbaren
+def save_list(liste,index1,index2):
+    if index2 > len(liste[0]) and index1 > len(liste):
+        return liste[index1][index2]
+    else:
+        return "a"
 def verarbeite_feld(feld):
-    feldx,feldy = len(feld[0]),len(feld)
     feld2 = copy.deepcopy(feld)
     for y in range(len(feld)):
         for x in range(len(feld[0])):
             poschar = feld[y][x]
             if poschar == "a":
                 # uberprüfe unteren block
-                bellow = feld[(y + 1) % feldy][x]
+                bellow = feld[(y+1)%feldy][x]
-                bellowr = feld2[(y + 1) % feldy][(x + 1) % feldx]
+                bellowr = feld2[(y+1)%feldy][(x+1)%feldx]
-                bellowl = feld2[(y + 1) % feldy][(x - 1) % feldx]
+                bellowl = feld2[(y+1)%feldy][(x-1)%feldx]
                 direction = random.choice([-1, 1])  # Zufällige Auswahl der Richtung
                 if bellow == " " and not bellow == "#":
-                    feld2[y][x] = feld[(y + 1) % feldy][x]
+                    feld2[y][x] = feld[(y+1)%feldy][x]
-                    feld2[(y + 1) % feldy][x] = feld[y][x]
+                    feld2[(y+1)%feldy][x] = feld[y][x]
 
                 elif bellowr == " " and not bellowr == "#":
-                    feld2[y][x] = feld[(y + 1) % feldy][(x + direction) % feldx]
+                    feld2[y][x] = feld[(y+1)%feldy][(x+direction)%feldx]
-                    feld2[(y + 1) % feldy][(x + direction) % feldx] = feld[y][x]
+                    feld2[(y+1)%feldy][(x+direction)%feldx] = feld[y][x]
 
                 elif bellowl == " " and not bellowl == "#":
-                    feld2[y][x] = feld[(y + 1) % feldy][(x + direction) % feldx]
+                    feld2[y][x] = feld[(y+1)%feldy][(x+direction)%feldx]
-                    feld2[(y + 1) % feldy][(x + direction) % feldx] = feld[y][x]
+                    feld2[(y+1)%feldy][(x+direction)%feldx] = feld[y][x]
     return feld2
 
-
+def make_feld(size,mode):
-def make_feld(size, mode):
+    x = screensize[0]//size
-    x = screensize[0] // size
+    y = screensize[1]//size
-    y = screensize[1] // size
     feld = [[" " for _ in range(x)] for _ in range(y)]
     if mode == "border":
         for x in range(x):
-            feld[y - 1][x] = "#"
+            feld[y-1][x] = "#"
-    return feld, x, y
+    return feld ,x,y
-
-
 ## klassen
 
         
 ## variablen
-screen = pygame.display.set_mode((800, 500), pygame.RESIZABLE)
+screen = pygame.display.set_mode((800,500),pygame.RESIZABLE)
 pygame.display.set_caption("SAND")
 screensize = pygame.display.get_window_size()
 clock = pygame.time.Clock()
 default_font = pygame.font.SysFont("sans", 14)
 
 display_mode = "border"
-feld, feldx, feldy = make_feld(20, display_mode)
+feld,feldx,feldy = make_feld(20,display_mode)
 
-acolor = (255, 0, 0)
+acolor = (255,0,0)
 wechselfarbe = "r"
 using_element = "a"
 pixelsize = 20
 
-buttons = [Button(screen,(200,200,200),100,100,30,30,"*")]
 show_debug = False
 running = True
 if __name__ == "__main__":
@@ -101,10 +101,10 @@ if __name__ == "__main__":
             exit()
         if pressed_keys[pygame.K_PLUS] and not preview_pressed_keys[pygame.K_PLUS]:
             pixelsize += 2
-            feld, feldx, feldy = make_feld(pixelsize, display_mode)
+            feld,feldx,feldy = make_feld(pixelsize,display_mode)
         if pressed_keys[pygame.K_MINUS] and not preview_pressed_keys[pygame.K_MINUS]:
             pixelsize -= 2
-            feld, feldx, feldy = make_feld(pixelsize, display_mode)
+            feld,feldx,feldy = make_feld(pixelsize,display_mode)
         if pressed_keys[pygame.K_d] and not preview_pressed_keys[pygame.K_d]:
             show_debug = not show_debug
         if pressed_keys[pygame.K_SPACE] and not preview_pressed_keys[pygame.K_SPACE]:
@@ -117,7 +117,7 @@ if __name__ == "__main__":
                 display_mode = "loop"
             else:
                 display_mode = "border"
-            feld, feldx, feldy = make_feld(pixelsize, display_mode)
+            feld,feldx,feldy = make_feld(pixelsize,display_mode)
 
         preview_pressed_keys = pressed_keys
         ## event managment
@@ -126,8 +126,8 @@ if __name__ == "__main__":
                 exit()
             if event.type == pygame.WINDOWRESIZED:
                 screensize = pygame.display.get_window_size()
-                feld, feldx, feldy = make_feld(pixelsize, display_mode)
+                feld,feldx,feldy = make_feld(pixelsize,display_mode)
-        r, g, b = acolor
+        r,g,b = acolor
         if wechselfarbe == "r":
             r -= 1
             g += 1
@@ -143,27 +143,21 @@ if __name__ == "__main__":
             r += 1
             if b == 0:
                 wechselfarbe = "r"
-        acolor = r, g, b
+        acolor = r,g,b
-        color_key = {"#": (100, 100, 100), "a": acolor}
+        color_key = {"#":(100,100,100),
-        draw_feld(feld, color_key, pixelsize)
+                     "a":acolor}
-
+        draw_feld(feld,color_key,pixelsize)
-        mx, my = pygame.mouse.get_pos()
+        mx,my = pygame.mouse.get_pos()
         mousepressed = pygame.mouse.get_pressed()[0]
-        for button in buttons:
+        if mousepressed :
-            button.draw()
+            feld[my//pixelsize][mx//pixelsize] = using_element
-            
-        if mousepressed:
-            for button in buttons:
-                if button.check_press((mx,my)):
-                    show_debug = not show_debug
-                else:
-                    feld[my // pixelsize][mx // pixelsize] = using_element
         
         preview_mousepressed = pygame.mouse.get_pressed()[0]
         feld = verarbeite_feld(feld)
+
         if show_debug:
             get_debug_text()
         ## bildschirm aktuallisierung
         pygame.display.flip()
         clock.tick(30)
-        screen.fill((0, 0, 0))
+        screen.fill((0,0,0))