Das deutsche Python-Forum

Code: Alles auswählen

#In der Klasse Hud, self.test.raining soll geändert werden
	#....
	self.rainSlider = Slider((120, 500), self.test.rain.raining, test)

        def update(self):
       		self.test.rain.raining = self.rainSlider.update()
       		
#In der Klasse Slider
#  self.test.rain.raining heißt hier self.stateToChange
	def update(self):
	#.....
		return self.stateToChange
       

Code: Alles auswählen

def mouse_collision(rect):
    return (
        rect[0] < pygame.mouse.get_pos()[0] < (rect[0] + rect[2])
        and rect[1] < pygame.mouse.get_pos()[1] < (rect[1] + rect[3])
    )

Code: Alles auswählen

def mouse_collision(rect):
    return rect.collidepoint(pygame.mouse.get_pos())

Code: Alles auswählen

#!/usr/bin/env python3
import random

import pygame

SIZE = (1024, 786)  # Set to `None` for fullscreen.

MTOP = 50  # TODO Needs a better name.
FPS = 60

WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
BLUE = (0, 0, 255)
LIGHTGREY = (160, 160, 160)


class Switch:
    COLORS = [BLACK, BLUE]
    
    def __init__(self, position, state=False, callback=lambda state: None):
        self.state = state
        self.callback = callback
        self.rect = pygame.Rect(position, (50, 20))

    @property
    def color(self):
        return self.COLORS[self.state]

    def update(self, click_position):
        if click_position and self.rect.collidepoint(click_position):
            self.state = not self.state
            self.callback(self.state)

    def draw(self, screen):
        pygame.draw.rect(screen, self.color, self.rect)


class Hud:
    
    def __init__(self, width, height):
        self.width = width
        self.height = height
        self.rain_switch = Switch((120, 500))

    def update(self, click_position):
        self.rain_switch.update(click_position)

    def draw(self, screen):
        # pygame.draw.rect(screen, LIGHTGREY, [0, 0, self.width, self.height])
        self.rain_switch.draw(screen)


class Particle:
    
    def __init__(self, position, velocity):
        self.position = list(position)
        self.velocity = velocity
    
    def update(self):
        self.position[0] += self.velocity[0]
        self.position[1] += self.velocity[1]
    
    def draw(self, screen):
        pygame.draw.line(screen, BLUE, self.position, self.position, 1)


class Raindrop:
    
    def __init__(self, x, y, max_y):
        self.x = x
        self.y = y
        self.max_y = max_y
        self.particles = []
        # Tropfendurchmesser in mm * 2 = m/s
        # 1m = 100pxl
        diameter = 4 # eigentlich mm, wäre zu klein
        self.velocity = (
            random.uniform(-0.2, 0.2) / FPS * MTOP,
            (diameter * 2  + random.random()) / FPS * MTOP
        )
        self.particles = []

    def update(self):
        self.y += self.velocity[1]
        self.x += self.velocity[0]
        if self.y >= self.max_y:
            for particle in self.particles:
                particle.update()
            self.particles.append(
                Particle(
                    (self.x, self.max_y),
                    (
                        random.uniform(-50, 50) / FPS,
                        random.uniform(-50, 0) / FPS)
                    )
            )
            if self.y > self.max_y + 140:
                return False
        
        return True

    def draw(self, screen):
        pygame.draw.line(
            screen, BLUE, [self.x, self.y], [self.x, self.y + 4], 1
        )
        for particle in self.particles:
            particle.draw(screen)


class Rain:
    
    def __init__(self, size):
        self.width, self.height = size
        self.raindrops = []
        self.raining = False

    def switch(self, state):
        self.raining = state

    def update(self):
        if self.raining:
            for _ in range(3):
                self.raindrops.append(
                    Raindrop(random.randint(0, self.width), 0, self.height)
                )
        raindrops = []
        for raindrop in self.raindrops:
            if raindrop.update():
                raindrops.append(raindrop)
        self.raindrops = raindrops

    def draw(self, screen):
        for raindrop in self.raindrops:
            raindrop.draw(screen)


class Simulation:
    
    def __init__(self, screen):
        self.screen = screen
        self.running = True
        self.click_position = None
        self.clock = pygame.time.Clock()
        self.rain = Rain(self.screen.get_size())
        self.hud = Hud(300, self.screen.get_height())
        self.hud.rain_switch.callback = self.rain.switch

    def input(self):
        for event in pygame.event.get():
            if (
                event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
                or event.type == pygame.QUIT
            ):
                self.running = False
            elif event.type == pygame.MOUSEBUTTONUP:
                self.click_position = pygame.mouse.get_pos()

    def update(self):
        self.rain.update()
        self.hud.update(self.click_position)
        self.click_position = None

    def draw(self):
        self.screen.fill(WHITE)
        self.rain.draw(self.screen)
        self.hud.draw(self.screen)
        pygame.display.flip()

    def run(self):
        while self.running:
            self.clock.tick(FPS)
            self.input()
            self.update()
            self.draw()

   
def main():
    pygame.init()
    try:
        if SIZE:
            screen = pygame.display.set_mode(SIZE)
        else:
            screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
        pygame.display.set_caption('Rain')
        simulation = Simulation(screen)
        simulation.run()
    finally:
        pygame.quit()


if __name__ == '__main__':
    main()