Controller.py

import time
import random

import Stockwerke
import Aufzuege
import Personen
import Statistik
import View
import AufzuegeAI
import Plotting

from config import *

class Controller():
    def __init__(self) -> None:
        self.Stockwerke = []
        self.Aufzuege = []
        self.FreieAufzuege = []
        self.Personen = []
        self.now = time.time()
        self.stat = Statistik.Statistik()
        self.ai = AufzuegeAI.KommunizierteAufzugAI(STOCKWERKE) # AufzuegeAI.AufzugAI(STOCKWERKE)

        #stockwerke spawnen:
        for i in range(STOCKWERKE):
            s = Stockwerke.Funktionalstockwerk(ai=self.ai, stat=self.stat, index=i)
            if i == EG:
                s.set_name('EG')
            elif i == STOCKWERKE-1 and i > EG and PENTHOUSE:
                s.set_name('Penthouse')
            elif i == 0 and i < EG and BUNKER:
                s.set_name('Bunker')
            else:
                s.set_name(str(i-EG)+'OG')
            self.Stockwerke.append(s)
        # kellergeschosse benennen:
        for i in [i for i in range(STOCKWERKE) if i<EG and not ( i==0 and BUNKER) ]:
            self.Stockwerke[i].set_name('K'+str((EG-i)))

        #Aufzüge im EG spawnen
        for i in range(AUFZUEGE):
            a = None
            #a= self.Stockwerke[0].spawnAufzug(x_rang=i, stockwerkindex=0)
            if i != 0:
                a = self.Stockwerke[EG].spawnKleinerAufzug(x_rang=i, stockwerkindex=EG)
            if i == 0:
                a = self.Stockwerke[EG].spawnGrosserAufzug(x_rang=i, stockwerkindex=EG)
            if i == AUFZUEGE-1:
                a = self.Stockwerke[EG].spawnPenthouseAufzug(x_rang=i, stockwerkindex=EG)
            self.Aufzuege.append(a)

        # initialisiere die View:
        self.view = View.view(stockwerkliste=self.Stockwerke, aufzugliste=self.Aufzuege, personenliste=self.Personen)
        self.stockwerkbreite = self.view.berechne_Breite()
        self.slidervalue = self.view.slider.getValue()
        # Aufzug x-positionen in metern:
        for i, a in enumerate(self.Aufzuege):
            a.set_x(self.view.get_aufzuglinkspos(i))
        
        #Eine Person pro Stockwerk spawnen
        for i in range(STOCKWERKE if not PENTHOUSE else STOCKWERKE-1):
            p = self.Stockwerke[i].spawnPerson(stockwerkezahl=STOCKWERKE)
            signal = p.aufzugrufknopf_druecken()
            self.view.signal_on(index=i, personensignal=signal)
            self.Personen.append(p)

    def to_sting(self, full) -> str:
        s = ''
        if full:
            for i in range(STOCKWERKE):
                s += self.Stockwerke[i].to_string()
                s += '\n'
        s += self.stat.to_string()
        return s

    def one_sec_loop(self, laufzeit):
            for frame in range(laufzeit):
                self.now = time.time()
                #print(self.now)
                #print(frame)
                
                #alle 1 sekunden, Personen zufällig spawnen:
                if frame % int(FPS/self.slidervalue) == 0:
                    i = random.choice([i for i in range(STOCKWERKE if not PENTHOUSE else STOCKWERKE-1)])
                    p = self.Stockwerke[i].spawnPerson(STOCKWERKE)
                    signal = p.aufzugrufknopf_druecken()
                    self.view.signal_on(index=i, personensignal=signal)
                    self.Personen.append(p)
                #alle 1.5 sekunden, im 'EG' noch mehr Personen spawnen:
                if frame % int(1.5*FPS/self.slidervalue) == 0:
                    for i in [s.index for s in self.Stockwerke if s.name =='EG']:
                        p = self.Stockwerke[i].spawnPerson(STOCKWERKE)
                        signal = p.aufzugrufknopf_druecken()
                        self.view.signal_on(index=i, personensignal=signal)
                        self.Personen.append(p)
                #alle 1 sekunden, im 'EG' noch mehr VIPs spawnen:
                """if frame % int(1*FPS/self.slidervalue) == 0:
                    for i in [s.index for s in self.Stockwerke if s.name =='EG']:
                        p = self.Stockwerke[i].spawnVIP(STOCKWERKE)
                        signal = p.aufzugrufknopf_druecken()
                        self.view.signal_on(index=i, personensignal=signal)
                        self.Personen.append(p)"""
                
                #Aufzüge, die nicht an Stockwerk angedockt sind:
                for i, a in enumerate(self.FreieAufzuege):
                    if a.tuer_offen:
                        a.closeDoor()
                    else:
                        if a.checkFloor():
                            # quick and dirty enterFloor function: assume well-ordered floors, 0=EG, 1=1st etc.
                            a.enterTargetFloor(i, self.FreieAufzuege, self.Stockwerke)
                        a.move()

                #Stockwerke mit angedockten Aufzügen und wartenden Personen:
                for i, s in enumerate(self.Stockwerke):

                    # angedockte Aufzüge im Stockwerk:
                    for j, a in enumerate(s.aufzugliste):
                        if not a.tuer_offen:
                            a.openDoor()
                        else:
                            if len(a.personenliste) > 0:
                                a.personenrauslassen(s)
                            signal = a.personenaufnehmen(s)
                            # Signal-leuchtfelder zurücksetzen:
                            self.view.signal_off(index=i, aufzugsignal=signal)
                            # falls die letzte person der personenliste schon weit genug rein gelaufen ist:
                            check = True
                            for p in a.personenliste:
                                p.walk_in(aufzugpos=a.x_real, aufzugbreite=a.breite)
                                check = check and p.check_aufzugx()
                            if ( len(a.personenliste) > 0 and check) or ( len(a.personenliste) == 0 and len(s.personenliste)== 0):
                                # Die Priorität dieses Stockwerks senken
                                self.ai.clearFloor(i)
                                # Neues Zielstockwerk für den Aufzug bestimmen:
                                a.chooseTarget(startstockwerk=i, stockwerkliste=[s for s in range(STOCKWERKE)])
                                # Aufzug aus dem Stockwerk nehmen:
                                self.FreieAufzuege.append(a.exitFloor(j, s))
                    
                    # wartende Personen im Stockwerk:
                    for p in s.personenliste:
                        # nach 10 sec warten alle 2 sekunden die Taste betätigen.
                        if p.wartet and (self.now > p.startzeit+10) and (self.now - p.startzeit)%(FPS*2)==0:
                            signal = p.aufzugrufknopf_druecken()
                            self.view.signal_on(index=i, personensignal=signal)
                        # bei zulangem Warten genervt werden:
                        if p.wartet and self.now > p.genervtzeit_modifiziert:
                            p.despawn_genervt()
                        if not p.wartet and not p.genervt:
                            p.walk_out(gesamtbreite=self.stockwerkbreite)
                        if not p.wartet and p.genervt:
                            p.walk_away()


                # abgefertigete (despawnte) Personen:
                self.slidervalue = max(self.view.slider.getValue(), 0.000000001)
                for p in self.Personen:
                    if not p.wartet:
                        p.fade()
                    p.modify_speed(self.slidervalue)
                
                for a in self.Aufzuege:
                    a.modify_speed(self.slidervalue)

                self.view.draw()
                time.sleep(1/FPS)
            
            self.view.quit()


    def draw():
        pass
    
if __name__ == "__main__":
    c = Controller()
    c.one_sec_loop(laufzeit=LAUFZEIT)
    print(c.to_sting(full=False))
    Plotting.barplot(strategie=STRATEGIE, stats=c.stat)
    Plotting.histogram(strategie=STRATEGIE, stats=c.stat)