sand/main.py

#!/usr/bin/python3
import pygame
from button import *
import copy
import random

pygame.init()


## funktionen
def get_debug_text():
    def text(text, line_counter):
        debug_text = default_font.render(str(text), True, (255, 255, 255))
        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)
        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 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(
                    screen,
                    color_key[feld[b][a]],
                    (a * block_size, b * block_size, block_size, block_size),
                )


def finde_nachbarn(matrix, x, y):
    feldx, feldy = len(feld[0]), len(feld)

    over  = (y - 1) % feldy , x % feldx
    overr = (y - 1) % feldy , (x + 1) % feldx
    overl = (y - 1) % feldy , (x - 1) % feldx

    r = y , (x + 1) % feldx
    l = y , (x - 1) % feldx

    bellow  = (y + 1) % feldy , x % feldx
    bellowr = (y + 1) % feldy , (x + 1) % feldx
    bellowl = (y + 1) % feldy , (x - 1) % feldx
    return [overl,over, overr, r, l, bellowl, bellow, bellowr]

def verarbeite_feld(feld):
    feldx, feldy = len(feld[0]), len(feld) # bekomme feld größe
    feld2 = copy.deepcopy(feld) # mache neue kopie
    for y in range(feldy): # spalte
        for x in range(feldx): # zeile
            poschar = feld[y][x]
            if poschar == "a": # fals aktuelles checkendes element = "a"
                # bekomme alle benötigten nachtbaren
                nachtbaren = finde_nachbarn(feld, x ,y)
                bellow  =  feld[nachtbaren[6][0]][nachtbaren[6][1]]
                bellowr =  feld[nachtbaren[7][0]][nachtbaren[7][1]] 
                bellowl =  feld[nachtbaren[5][0]][nachtbaren[5][1]] 
                direction = random.choice([-1, 1])  # Zufällige Auswahl der Richtung
                if bellow == " " and not bellow == "#": # checke unten
                    feld2[y][x] = feld[(y + 1) % feldy][x]
                    feld2[(y + 1) % feldy][x] = feld[y][x]

                elif bellowr == " " and not bellowr == "#" and direction == 1: # checke unten rechts fals richtung nach rechts
                    feld2[y][x] = feld[(y + 1) % feldy][(x + direction) % feldx] # tausche in kopie aktuelle position mit "a"
                    feld2[(y + 1) % feldy][(x + direction) % feldx] = feld[y][x] # tausche in kopie neue position mit bevorigen element

                elif bellowl == " " and not bellowl == "#" and direction == -1: # checke unten links fals richtung nach links
                    feld2[y][x] = feld[(y + 1) % feldy][(x + direction) % feldx]
                    feld2[(y + 1) % feldy][(x + direction) % feldx] = feld[y][x]
    return feld2 # gib kopie zurück

## Funktion zum Verarbeiten des Feldes

def make_feld(size, mode):
    x = screensize[0] // 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] = "#"
    return feld, x, y

def remake_feld():
    global feld,feldx,feldy
    feld, feldx, feldy = make_feld(pixelsize, display_mode)
    for i, button in enumerate(buttons):
        i += 1
        button.pos = (screensize[0] - 70, button_abstandy * i)
## klassen


## variablen
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" # loop oder border # durchfallen oder mit boden
feld, feldx, feldy = make_feld(20, display_mode)

using_element = "a"
pixelsize = 20 # größe eines pixels
button_abstandy = 30 # abstand von buttons

buttons = [
    Button(screen, (200, 200, 200), (screensize[0] - 70, 50), 25, 25, "\/"),
    Button(screen, (200, 200, 200), (screensize[0] - 70, 50), 100, 25, "Debug"),
    Button(screen, (200, 200, 200), (screensize[0] - 70, 50), 100, 25, "Reset"),
    Button(screen, (200, 200, 200), (screensize[0] - 70, 50), 100, 25, "Element"),
    Button(screen, (200, 200, 200), (screensize[0] - 70, 50), 100, 25, "Zoom +"),
    Button(screen, (200, 200, 200), (screensize[0] - 70, 50), 100, 25, "Zoom -"),
]
buttona = {"dropdown": 0, "debug": 1, "reset": 2, "element": 3, "plus": 4, "minus": 5}
for i, button in enumerate(buttons):
    i += 1
    button.pos = (screensize[0] - 70, button_abstandy * i)
buttonhovered = [False, False, False, False, False, False]
buttons_to_render = 6 # button begrenzung
dropdown = True
before_buttonhovered = False
key_counter = 0
pressed_keys = pygame.key.get_pressed()
show_debug = False
running = True
if __name__ == "__main__":
    while running:
        ## key managment
        key_counter += 1
        if key_counter == 5:
            key_counter = 0
            pressed_keys = pygame.key.get_pressed()
            if True in pressed_keys:
                if pressed_keys[pygame.K_ESCAPE]:
                    exit()
                if pressed_keys[pygame.K_PLUS] and not before_pressed_keys[pygame.K_PLUS]:
                    pixelsize += 2
                    remake_feld()
                if pressed_keys[pygame.K_MINUS] and not before_pressed_keys[pygame.K_MINUS]:
                    pixelsize -= 2
                    remake_feld()
                if pressed_keys[pygame.K_d] and not before_pressed_keys[pygame.K_d]:
                    show_debug = not show_debug
                if pressed_keys[pygame.K_SPACE] and not before_pressed_keys[pygame.K_SPACE]:
                    if using_element == "a":
                        using_element = "#"
                    else:
                        using_element = "a"
                if pressed_keys[pygame.K_r] and not before_pressed_keys[pygame.K_r]:
                    if display_mode == "border":
                        display_mode = "loop"
                    else:
                        display_mode = "border"
                    remake_feld()

        ## event managment
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                exit()
            if event.type == pygame.WINDOWRESIZED:
                screensize = pygame.display.get_window_size()
                remake_feld()
        color_key = {"#": (100, 100, 100), "a": (200,200,80)} # element:farbe
        draw_feld(feld, color_key, pixelsize) # male feld mit color_key

        mx, my = pygame.mouse.get_pos()
        mousepressed = pygame.mouse.get_pressed()[0]

        for button in buttons[:buttons_to_render]: # male jeden button
            button.draw()

        if mousepressed:
            for i, button in enumerate(buttons[:buttons_to_render]): 
                # checke alle button ob die maus auf einen ist und schreibe es in die liste buttonhovered
                if button.check_hovered((mx, my)):
                    buttonhovered[i] = True
                else:
                    buttonhovered[i] = False
            if not True in buttonhovered: # wenn nicht maus über button
                feld[my // pixelsize][mx // pixelsize] = using_element

            if mousepressed and not before_mousepressed: # einmalklick von maus erfassen
                if buttonhovered[buttona["dropdown"]]: # falls button "dropdown" mit index von buttona = True
                    dropdown = not dropdown
                    if dropdown:
                        buttons_to_render = len(buttons) # dropdown menü begrenzen indem man nicht alle buttons verarbeitet
                        buttons[buttona["dropdown"]].text = "\/"
                    else:
                        buttons_to_render = 1
                        buttons[buttona["dropdown"]].text = "/\\"
                if buttonhovered[buttona["debug"]]:
                    show_debug = not show_debug
                if buttonhovered[buttona["reset"]]:
                    if display_mode == "border":
                        display_mode = "loop"
                    else:
                        display_mode = "border"
                    feld, feldx, feldy = make_feld(pixelsize, display_mode)
                if buttonhovered[buttona["plus"]]:
                    pixelsize += 2
                    feld, feldx, feldy = make_feld(pixelsize, display_mode)
                if buttonhovered[buttona["minus"]]:
                    pixelsize -= 2
                    feld, feldx, feldy = make_feld(pixelsize, display_mode)
                if buttonhovered[buttona["element"]]:
                    if using_element == "a":
                        using_element = "#"
                    else:
                        using_element = "a"

        before_buttonhovered = buttonhovered # bevorige maus und button hover daten erfassen
        before_mousepressed = mousepressed
        before_pressed_keys = pressed_keys
        feld = verarbeite_feld(feld) # feld neu machen
        if show_debug: # debug text zeichnen
            get_debug_text()
        ## bildschirm aktuallisierung
        pygame.display.flip()
        clock.tick(60)
        screen.fill((0, 0, 0))