sand/main.py

#!/usr/bin/python3
import pygame
import pygame.gfxdraw
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):
    # print(feld)
    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 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):
    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]
                bellowr = 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 + 1) % feldy][x] = feld[y][x]

                elif bellowr == " " and not bellowr == "#":
                    feld2[y][x] = feld[(y + 1) % feldy][(x + direction) % feldx]
                    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 + 1) % feldy][(x + direction) % feldx] = feld[y][x]
    return feld2


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


## 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"
feld, feldx, feldy = make_feld(20, display_mode)

acolor = (255, 0, 0)
wechselfarbe = "r"
using_element = "a"
pixelsize = 20

show_debug = False
running = True
if __name__ == "__main__":
    while running:
        ## key managment
        pressed_keys = pygame.key.get_pressed()

        if pressed_keys[pygame.K_ESCAPE]:
            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)
        if pressed_keys[pygame.K_MINUS] and not preview_pressed_keys[pygame.K_MINUS]:
            pixelsize -= 2
            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]:
            if using_element == "a":
                using_element = "#"
            else:
                using_element = "a"
        if pressed_keys[pygame.K_r] and not preview_pressed_keys[pygame.K_r]:
            if display_mode == "border":
                display_mode = "loop"
            else:
                display_mode = "border"
            feld, feldx, feldy = make_feld(pixelsize, display_mode)

        preview_pressed_keys = pressed_keys
        ## 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()
                feld, feldx, feldy = make_feld(pixelsize, display_mode)
        r, g, b = acolor
        if wechselfarbe == "r":
            r -= 1
            g += 1
            if r == 0:
                wechselfarbe = "g"
        if wechselfarbe == "g":
            g -= 1
            b += 1
            if g == 0:
                wechselfarbe = "b"
        if wechselfarbe == "b":
            b -= 1
            r += 1
            if b == 0:
                wechselfarbe = "r"
        acolor = r, g, b
        color_key = {"#": (100, 100, 100), "a": acolor}
        draw_feld(feld, color_key, pixelsize)
        mx, my = pygame.mouse.get_pos()
        mousepressed = pygame.mouse.get_pressed()[0]
        if mousepressed:
            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))