Code

    global running
    global state
    #wichtige Variblen --> Intervall für Matplotlib
    startzeit = time.time()
    zeitintervall = 0
 
    #Gameloop:
    while running:
        '''
            Der Eventmanager ist für alle möglichen Eingaben über die Tastatur verantwortlich:
            - Mit 'p' wird die Simulation entweder pausiert oder fortgesetzt
            Glechzeitig wird schliessen der Simulation ohne Fehlermeldung ermoeglicht.
        '''
        #eventmanager 
        for event in pygame.event.get():
            #Quit
            if event.type == pygame.QUIT:
                running = False
            if event.type == pygame.KEYDOWN:
                #'p'-Taste gedrueckt
                if event.key == pygame.K_p:
                    #Pause
                    if state == config.MAIN:
                        state = config.PAUSE
                    #Continue
                    elif state == config.PAUSE:
                        state = config.MAIN
        #RUNNING
        if state == config.MAIN:
            screen.fill(config.BACKGROUND_COLOR)
            #malen für jede Biene --> draw() funktioniert nicht mit bees-Gruppe
            for bee in bees:
                bee.draw(screen)
 
            #update für jede Blume
            for flower in flowers:
                bees.update(flower,bees)
            #restliche Sprite-Gruppen updaten und darstellen
            flowers.update(screen) 
            flowers.draw(screen)
            hives.draw(screen)
 
            '''
                In einem Intervall von einer Sekunde wird von jedem Hive in der Sprite-Gruppe Hives 
                die Anzahl der lebenden Bienen und der Zeitpunkt in einen Array uebergeben und gespeichert
            '''
            curTime = time.time()#aktuelle Zeit
            if ((curTime-startzeit)>1):#wird jede Sekunde aufgerufen
                print("update")
                for hive in hives:#methode für jedes Hive aufgerufen
                    hive.dataUpdate(zeitintervall)
                    print(hive)
                startzeit = curTime#Zeit wird aktualisiert
                zeitintervall += 1
        #PAUSE
        else:
            screen.blit(pause_text, (config.WIDTH - 100, 20))
        pygame.display.flip()
        clock.tick(60)
    #END
    '''
        Hive-Daten werden mit Matplotlib auf das selbe Koordinatensystem geplottet
    '''
    #Matplotlib/Auswertung 
    for hive in hives:
        print(hive.name,hive.data)
        l1 = [x[0] for x in hive.data]
        l2 = [x[1] for x in hive.data]
        plt.plot(l1,l2)#plotten jeweiliger Daten
    pygame.quit()#Pygame wird geschlossen
    plt.show()#Graphen anzeigen

    def update(self, flower, bees):
        scale = 3.0
 
        radius_repel = 3.0 * scale
        radius_align = 25.0 * scale
        radius_attract = 100.0 * scale
 
        social_strength = 0.5
 
        nearestBeeDistTo = float("inf")
        NearestBeeVecTo = pygame.Vector2(0.0, 0.0)
        NearestBeeDir = pygame.Vector2(0.0, 0.0)
        ToFlower_vec = pygame.Vector2(0.0, 0.0)
        ToHive_vec = pygame.Vector2(0.0, 0.0)
        social_vec = pygame.Vector2(0.0, 0.0)
 
        NearestBeeStatus = None
 
        # Der Vektor von der Biene zur Blume
        flower_pos = pygame.math.Vector2(flower.rect.center[0], flower.rect.center[1])
        # TODO solange blumen radius auch nicht über torus verläfut macht das keinen Unterschied
        # ob Biene über torus oder nicht
        to_flower = utils.nearest_vector(self.float_rect, flower_pos)
        # if(flower != self.lastflower):
        _len = to_flower.length()
        # else:
        #    _len = Bee.RADIUS+1
        # Biene stirbt nach gewisser Zeit
        if time.time() - self.STARTTIME >= self.lebensdauer:
            self.die()
            print("die", self.hive.name, self.hive.livingBees)
 
        # alle bienen durchgehen um nächste zu finden
        for bee in bees:
            BeeVecTo = (
                bee.float_rect - self.float_rect
            )  # Vector zur gerade betrachteten Biene
            BeeDistTo = BeeVecTo.length()
            if BeeDistTo < nearestBeeDistTo and BeeDistTo > 0:
                NearestBeeVecTo = BeeVecTo
                nearestBeeDistTo = BeeDistTo
                NearestBeeDir = bee.dir
                NearestBeeStatus = bee.status
 
        # ich weiß das ist voll schlecht so aber mir fällt grad nichts besseres ein
        # ignoriert bienen anderen typs wenn IGNOREOTHERS = True
        # imo etwas sinnvoller denn, warum sollten suchende bienen anderen zum hive folgen
        # keine so großes Chaos bei hoher social_strength
        if config.IGNOREOTHERS:
            if self.status == NearestBeeStatus:
                if (
                    nearestBeeDistTo < radius_attract
                    and nearestBeeDistTo > radius_align
                ):
                    social_vec = NearestBeeVecTo.normalize()
 
                if nearestBeeDistTo < radius_align and nearestBeeDistTo > radius_repel:
                    social_vec = NearestBeeDir
 
        else:
            if nearestBeeDistTo < radius_attract and nearestBeeDistTo > radius_align:
                social_vec = NearestBeeVecTo.normalize()
 
            if nearestBeeDistTo < radius_align and nearestBeeDistTo > radius_repel:
                social_vec = NearestBeeDir
 
        if nearestBeeDistTo < radius_repel:
            social_vec = -NearestBeeVecTo.normalize()
        # falls der Vektor zur Blume <= des Blumen Radius entspricht
        # und die Biene neutral ist, fliegt die Biene zur Blume
        if _len <= Bee.RADIUS and self.status == "neutral":
            ToFlower_vec = to_flower / _len * min(_len, Bee.SPEED)
            # print(ToFlower_vec)
            self.image.fill(Bee.ATTRACTED_COLOR)
 
            # Ist sie nah genug dran, ändere den status und die Biene fliegt
            # zurück zum hive
            if _len < 20:
                self.status = "return"
                # Biene erhält Nahrung --> lebensdauer verlängern
                self.lebensdauer += 5
                self.lastflower = flower
 
        # Die Bewegung der Biene entschieden durch übergebene Argumente
        # während sie neutral ist
        # elif self.status == "neutral":
 
        # Hier ist de Status return und die Biene fliegt zu ihrem hive zurück:
        # ['self.hive']
 
        # ist config.ENDLESS = True ist status "neutral" wenn Bienen Hive erreichen
        elif self.status == "return":
            self.image.fill(Bee.RETURN_COLOR)
            to_hive = pygame.math.Vector2((self.hive.rect.center) - self.float_rect)
            if to_hive.length() > 5:
                ToHive_vec = (
                    to_hive / to_hive.length() * min(to_hive.length(), Bee.SPEED)
                )
            elif config.ENDLESS:
                self.status = "neutral"
                self.image.fill(Bee.NEUTRAL_COLOR)
                self.hive.pollen += 1
                self.dir = pygame.math.Vector2(
                    uniform(-1.0, -1.0), uniform(-1.0, -1.0)
                ).normalize()
 
        # Move Bee
        social_vec *= social_strength
        self.dir = (self.dir + social_vec + ToFlower_vec + ToHive_vec).normalize()
 
        self.float_rect += Bee.SPEED * self.dir
        self.tp()