Mathesis Wiki

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
<code>
import random
import pygame
import time
import math
pygame.init()

#Klasse Objekt. Zunächst für alle Objekte auf der Map
importlist = []
parentlist = []

class player:

    #Initialisiert den Spieler
    def __init__(self,x,y,angle,speed,name):
        self.x=x #x-Pos
        self.y=y #y-Pos
        self.size = 5 #Größe
        self.status = True #Aktiv oder nicht
        self.chunkpos = [0,0] #Speichert die Position des Chunks
        self.speed = 5 #Geschwindigkeit
        self.stamina = 250 #Ausdauer
        self.angle = angle #Laufwinkel        
        self.sight = 1 #Sichtweite
        self.rect=pygame.Rect(int(self.x)-int(self.size),int(self.y)-int(self.size),self.size*2+self.size,self.size*2+self.size)#Rechteck in Pygame        
        self.name=name #ID        
        self.vx = 0#??
        self.vy = 0
        self.v = False
        self.percent = []
        self.lists = []
        self.viewangle = 60
        self.objangle = 0
        self.runlength=[]
        self.runangle=[]
        self.status = True
    #Löscht den Spieler
    
    def __del__(self):
        a=0
    
    def sightcheck(self,dist,alpha):
        self.objangle = alpha
        #print(dist)
        self.v = False
        if dist<=self.sight:
            #print(self.angle%360,alpha)
            if self.angle-self.viewangle<0:
                if (self.angle%360-self.viewangle)+360 <= alpha or alpha <= self.angle+self.viewangle:
                    self.percent.append(1)
                    self.angle=alpha
                    self.v = True
                    #print("2",self.v)
            elif self.angle-self.viewangle>360:
                if (self.angle%360-self.viewangle)-360 <= alpha or alpha <= self.angle+self.viewangle:
                    self.percent.append(1)
                    self.v = True
                    #print(self.v)
                    self.angle=alpha
            else:
                if self.angle%360-self.viewangle <= alpha <= self.angle+self.viewangle:
                    self.percent.append(1)
                    #print(self.v)
                    self.v = True
                    self.angle=alpha
    #bewegt den Spieler
    
    def move(self):
        if not parentlist:
            self.angle+=random.randint(-45,45)%360
            self.speed=random.randint(0,5)
            self.x+=self.speed*math.cos(self.angle/180*math.pi)
            self.y+=self.speed*math.sin(self.angle/180*math.pi)
            self.rect=pygame.Rect(int(self.x),int(self.y),self.size,self.size)
            pygame.draw.rect(screen, (255, 0, 0),self.rect)
            self.stamina-=1
            self.runlength.append(self.speed)
            self.runangle.append(self.angle)
        else:
            a = random.randint(0,len(parentlist)-1)
            if self.v == True:
                b = random.randint(0,1)
                c = random.randint(0,len(parentlist[a][0])-1)
                #print(parentlist[0][a][0])
                #print(parentlist[0][a][1])
                #print(a)                
                self.x+=parentlist[a][0][c][0]*math.cos(parentlist[a][0][c][1]/180*math.pi)
                self.y+=parentlist[a][0][c][0]*math.sin(parentlist[a][0][c][1]/180*math.pi)
                self.rect=pygame.Rect(int(self.x),int(self.y),self.size,self.size)
                pygame.draw.rect(screen, (255, 0, 0),self.rect)
                self.stamina-=1
                self.runlength.append(self.speed)
                self.runangle.append(self.angle)
            else :
                c = random.randint(0,len(parentlist[a][0])-1)
                self.x+=parentlist[a][1][c][0]*math.cos(parentlist[a][1][c][1]/180*math.pi)
                self.y+=parentlist[a][1][c][0]*math.sin(parentlist[a][1][c][1]/180*math.pi)
                self.rect=pygame.Rect(int(self.x),int(self.y),self.size,self.size)
                pygame.draw.rect(screen, (255, 0, 0),self.rect)
                self.stamina-=1
                self.runlength.append(self.speed)
                self.runangle.append(self.angle)

    def exportlist(self):
        l=[self.runlength,self.runangle,self.percent]
        return l
    
    #def move2(self):
        
    def parents(self,lists):
        self.lists = lists

class object:

    #Initialisiert den Spieler
    def __init__(self,x,y,name):
        self.x=x #x-Pos
        self.y=y #y-Pos
        self.status = True #Aktiv oder nicht
        self.name = name #ID
        self.chunkpos = [] #Speichert die Koordinaten des Chunks
        self.size = 3 #Größe
        self.rect = pygame.Rect(x, y, self.size,self.size) #Rechteck in Pygame
    
    #Löscht das Objekt
    def __del__(self):
        a=0

#Klasse Chunk
class chunk:
    x = 0 #x-Position
    y = 0 #y-Position
    food=0 #???
    length = 0 #Länge(x-Richtung)
    height = 0 #Breite(y-Richtung
    overlay = 0 #Wie stark sich die verschiedenen Chunks überlappen
    name = 0 # ID
    
    #Initilisiert den Chunk
    def __init__(self,x,y,length,height,overlay,name):
        self.x = x
        self.y = y
        self.length = length
        self.height = height
        self.overlay = overlay
        self.objects = [] #Liste der festen Objekte
        self.density = 0.000125 #Wahrscheinlichkeit für neue Objekte        
        self.name = name
    
    #Fügt der Objektliste ein neues Element hinzu
    def newobj(self,obj):
        self.objects.append(obj)        

    #Übergibt die maximale x-Position
    def getendx(self):
        return self.x+self.length

    #Übergibt die maximale y-Position
    def getendy(self):
        return self.y+self.height

    #löscht das Objekt
    def __del__(self):
        a = 0
    
    #generiert zufällig verteilte Objekte in dem Chunk
    def generate(self):
        a = object(0,0,0)
        numb = self.length*self.height*self.density/a.size
        for i in range(int(numb)):
                    self.objects.append(object(random.randint(self.x,self.getendx()-a.size),random.randint(self.y,self.getendy()-a.size),i))
        #print(len(self.objects))

#Gesamte Map
class map:
    objects = 0
    worldsize = 0 
    chunksize = 0
    overlay = 0
    
    #Initilisiert die Map
    #def__init__(Liste der Objekte,Liste der Spieler,Gesamtgröße der Map,Größe der Chunks)
    def __init__(self,playerlist,size,sizechunk):
        self.worldsize = size #Worldsize
        self.chunksize = sizechunk #Chunksize wird später static
        self.overlay = sizechunk*0.1 #Overlay der Chunks(10%)
        self.player = playerlist #Spielerliste
        self.faktor = int(size/sizechunk) #Faktor(für einige Berechnungen)
        self.maplist = [] #2-Dim Liste der Chunks
        self.initiate()
        self.playerupdate()
    
    #Initilisiert die Grundmap, sowie weist jedem Chunk die Objekte hinzu
    def initiate(self):
        factor = int(self.worldsize/self.chunksize)
        print(factor)
        R = 0
        #Durchläuft die y-Richtung der Chunks
        for i in range(factor):
            line = []
            #Durchläuft die x-Richtung der Chunks
            for e in range(factor): 
                line.append(chunk(self.chunksize*e,self.chunksize*i,self.chunksize,self.chunksize,self.overlay,e+i*factor))
                #print("(",a.x,"/",a.y,") - ","(",a.getendx(),"/",a.getendy(),")")
                #Durchläuft alle festen Objekte             
                line[e].generate()
                #print("(",line[e].x,"/",line[e].y,")",end="")
            self.maplist.append(line)
            #print("")
            del line
        print("Objects ready!")
        print("")
    
    #weist jedem Spieler den Chunk hinzu in welchem dieser sich befindet
    def playerinitiate(self,playerlist):
        self.player = playerlist
        #Durchläuft die Liste der Player
        for q in range(len(self.player)):
            #Durchläuft die x-Richtung der Chunks
            for i in range(len(self.maplist)):
                qq = False
                #Durchläuft die y-Richtung der Chunks
                for e in range(len(self.maplist[i])):
                    if self.maplist[i][e].x <= self.player[q].x <= self.maplist[i][e].getendx() and self.maplist[i][e].y <= self.player[q].y <= self.maplist[i][e].getendy():
                        self.player[q].chunkpos.append(i)
                        self.player[q].chunkpos.append(e)
                        qq = True
                        break
                if qq == True:
                    break
        print("Player Ready!")
    
    #überprüft die Chunkposition des Spielers
    def playerupdate(self):

        #Durchläuft die Liste der Player
        q=0
        while q < len(self.player):

            #Chunkposition in der Liste
            i = self.player[q].chunkpos[0]
            e = self.player[q].chunkpos[1]
            #Wenn der Player immernoch im gleichen Chunk ist, passiert nichts,...
            if self.maplist[i][e].x <= self.player[q].x <= self.maplist[i][e].getendx() and self.maplist[i][e].y <= self.player[q].y <= self.maplist[i][e].getendy():
                a=0
            #...sonst berechnet er den Chunk.
            else:
                x = self.player[q].x #x-Pos des Spielers
                y = self.player[q].y #y-Pos des Spielers
                x0 = 0 #kleinste x-Pos der Chunks
                y0 = 0 #kleinste y-Pos der Chunks
                xn = self.worldsize #größte x-Pos der Chunks
                yn = self.worldsize #größte x-Pos der Chunks
                
                
                if x <= x0 or x >= xn or y <= y0 or y >= yn:
                    if len(self.player)<=20:
                        importlist.append(self.player[q].exportlist())
                        parentlist.append(self.player[e].exportlist())
                    del self.player[q]
                    q-=1
                else:
                    #Da sich die Map auch in den negativen Bereich erweitert, erhalten alle Chunks einen Shift.
                    self.player[q].chunkpos[1] = int(x/self.chunksize)
                    self.player[q].chunkpos[0] = int(y/self.chunksize)
                    #print(x,"/",y)             
                    #print(self.maplist[int(y/self.chunksize)][int(x/self.chunksize)].x,"/",self.maplist[int(y/self.chunksize)][int(x/self.chunksize)].y)
                    #print("---------")
                    #time.sleep(2)
            q+=1
            
    #Hitboxberechung der Objekte und den Spielern
    def hitbox(self):
        #Durchläuft jeden Spieler
        for i in range(len(self.player)):
            #Chunkposition in der Liste
            q = self.player[i].chunkpos[0]
            w = self.player[i].chunkpos[1]
            #Falls die Liste leer ist
            

            #print(q,w)
            if not self.maplist[q][w].objects:
                    a = 0
            else:
                a=len(self.maplist[q][w].objects)
                #Durchläuft die Liste der Objekte im Chunk mit den der Spieler kollidieren kann
                e=0
                while e<(len(self.maplist[q][w].objects)):
                    dist = ((self.player[i].x-self.maplist[q][w].objects[e].x)**2+(self.player[i].y-self.maplist[q][w].objects[e].y)**2)**(1/2)
                    #print(dist)
                    #print((self.player[i].y-self.maplist[q][w].objects[e].y))
                    alpha = math.acos(((self.player[i].y-self.maplist[q][w].objects[e].y)/dist))
                    self.player[i].sightcheck(dist,alpha)
                    if self.player[i].rect.collidelist(self.maplist[q][w].objects)>-1:
                        print("Treffer!")
                        print("Position: (",self.player[i].x,"/",self.player[i].y,")")                  
                        del self.maplist[q][w].objects[e]
                        #print(self.player[i].v)
                        self.player[i].v = False
                        e-=1
                        self.player[i].stamina+=250
                    e+=1
    
    #Gibt die Liste der Spieler aus
    
    def showp(self):
        for i in range(len(self.player)):
            q = self.player[i].chunkpos[0]
            w = self.player[i].chunkpos[1]
            a=len(self.maplist[q][w].objects)
            #Durchläuft die Liste der Objekte im Chunk mit den der Spieler kollidieren kann
            print("Player",i)
            #print("Anzahl der Objekte:",len(self.maplist[q][w].objects))
            for t in range(len(self.maplist[q][w].objects)):                
                #Gibt die Koordinaten des Objektes aus
                print("(",self.maplist[q][w].objects[t].x,"/",self.maplist[q][w].objects[t].y,")")
            print("-----")

    #Gibt die Liste der Objekte aus
    def showc(self):
        #Durchläuft die Liste der Chunks
        print(len(self.maplist))
        for i in range(len(self.maplist)):
            print(len(self.maplist[i]))
            for e in range(len(self.maplist[i])):
                #Gibt die Koordinaten des Objektes aus
                print("(",self.maplist[i][e].x,"/",self.maplist[i][e].y,") - ","(",self.maplist[i][e].getendx(),"/",self.maplist[i][e].getendy(),")")
                print(len(self.maplist[i][e].objects))

    #Zeichnet alle Objekte auf dem Hauptbildschirm 
    def drawobj(self):
        for q in self.maplist:
            for w in q:
                for i in w.objects:
                    pygame.draw.rect(screen, (255, 0, 255), i.rect)

    #Zeichnet die Chunks in einem weiteren Bildschirm
    def drawchunks(self):
        for q in self.maplist:
            for w in q:
                pygame.draw.rect(screen, (255, 0, 255), i.rect)

    #erweitert die Karte falls ein Spieler außerhalb der derzeitigen Karte ist
    def map_increase(self,pos):

        #erweitert die Karte nach links
        if (self.player[pos].x<self.maplist[0][0].x):
            #print(self.player[pos].x,"<",self.maplist[0][0].x)
            i = 0
            k = self.maplist[0][0].x-self.chunksize
            l = self.maplist[0][0].y
            for list in self.maplist:
                list.insert(0,chunk(k,l+i*self.chunksize,self.chunksize,self.chunksize,self.overlay,5))#neuer Chunk
                list[0].generate(2,random.randint(0,5),random.randint(0,5),len(self.objects)) #chunk generiert
            value = True
            print("Map wird nach links erweitert.")

        #erweitert die Karte nach rechts
        if (self.player[pos].x>self.maplist[0][len(self.maplist[0])-1].getendx()):
            #print(self.player[pos].x,">",self.maplist[0][len(self.maplist[0])-1].getendx())
            i = 0
            k = self.maplist[0][len(self.maplist[0])-1].x+self.chunksize
            l = self.maplist[0][0].y
            for list in self.maplist:
                list.append(chunk(k,l+i*self.chunksize,self.chunksize,self.chunksize,self.overlay,5))
                list[len(list)-1].generate(2,random.randint(0,5),random.randint(0,5),len(self.objects))
                i+=1
            self.maplist.append(list)
            value = True
            print("Map wird nach rechts erweitert.")

        #erweitert die Karte nach unten
        if (self.player[pos].y<self.maplist[0][0].y):
            #print(self.player[pos].y,"<",self.maplist[0][0].y)
            i = 0
            k = self.maplist[0][0].x
            l = self.maplist[0][0].y-self.chunksize
            list = []
            for i in range(len(self.maplist[0])):
                list.append(chunk(k+i*self.chunksize,l,self.chunksize,self.chunksize,self.overlay,5))#neuer Chunk
                list[0].generate(2,random.randint(0,5),random.randint(0,5),len(self.objects))
                i+=1
            value = True
            self.maplist.insert(0,list)
            print("Map wird nach unten erweitert.")

        #erweitert die Karte nach oben
        if (self.player[pos].y>self.maplist[len(self.maplist)-1][len(self.maplist[len(self.maplist)-1])-1].getendy()):
            #print(self.player[pos].y,">",self.maplist[len(self.maplist)-1][len(self.maplist[len(self.maplist)-1])-1].getendy())
            i = 0
            k = self.maplist[0][0].x
            l = self.maplist[len(self.maplist)-1][len(self.maplist[len(self.maplist)-1])-1].y+self.chunksize
            list = []
            for i in range(len(self.maplist[0])):
                list.append(chunk(k+i*self.chunksize,l,self.chunksize,self.chunksize,self.overlay,5))
                list[i].generate(2,random.randint(0,5),random.randint(0,5),len(self.objects))
                i+=1
            self.maplist.append(list)
            value = True
            print("Map wird nach oben erweitert.")
    
    #Reset für die nächste Generation
    def nextstage(self,playerlist):
        self.maplist.clear()
        self.player.clear()
        self.initiate()
        self.playerinitiate(playerlist)

def werte(liste):
    lnofood = []
    lfood = []
    a = 0
    b = 0
    
    while a<len(liste):
        
        if a+1==len(liste):
            l = []
            while b<a+1:
                l.append([liste[b][0],liste[b][1]])
                b=b+1
            if l != []:
                if liste[a][2] == 0:
                    lnofood.append(l)
                else:
                    lfood.append(l)
                    
        else:
            if liste[a][2]!=liste[a+1][2]:
                l = []
                while b<a+1:
                    l.append([liste[b][0],liste[b][1]])
                    b=b+1
                if l != []:
                    if liste[a][2] == 0:
                        lnofood.append(l)
                    else:
                        lfood.append(l)
                        
        a=a+1    
    return [lnofood,lfood]

mapsize=1000 #Mapsize

playerl = [] #Spielerliste

clock = pygame.time.Clock()
playercount = int(0.1*mapsize)


map01 = map(playerl,mapsize,50) #erstellt die Map

screen = pygame.display.set_mode((1000,1000)) #erstellt den Hauptbildschirm

moveframes = 5 #Anzahl der Frames
i=0 #Zählt die Schleifendurchläufe
done = False #Falls True beendet das Programm

for oo in range(50):
    print("Generation:",oo)
    time.sleep(5)
    for i in range(playercount):#erstellt X Spieler
        playerl.append(player(random.randint(mapsize*0.1,mapsize*0.9),random.randint(mapsize*0.1,mapsize*0.9),0,0,i))

    while not done:
        clock.tick(50) #Für größere Pausen zwischen den Runden
    
        #Beendet das Programm falls ...
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                done =True
    
        screen.fill((255,255,255)) #Setzt die Hintergrundfarbe
    
        #Lässt die Spieler einen move machen oder löscht diese
        e = 0
        status = False
        while e <len(map01.player) and e>=0:
            if map01.player[e].stamina>0:
                map01.player[e].move()
            else:           
                if len(map01.player)<=20:
                    importlist.append(map01.player[e].exportlist())
                    parentlist.append(map01.player[e].exportlist())
                #if len(map01.player)==1:
                    #print("Runde:",i)
                del map01.player[e]
                e-=1
            e+=1
    
        print("------------")
        #Falls nur noch ein Spieler existiert, wird seine Lebensdauer ausgegeben
        if len(map01.player)==1:
            print("Stamina:", map01.player[0].stamina)
            #time.sleep(0.1)
        #Bei keine Spieler wird das Programm beendet
        if len(map01.player)==0:
            break
            #Für die Map reichen diese drei Funktionen
        map01.playerupdate() #Überprüft alle Spieler auf ihren Chunk
        map01.hitbox() #Überprüft die Hitbox zu allen Objekten in diesem Chunk
        map01.drawobj() #Zeichnet alle Objekte
    
        pygame.display.flip()
    
        print("Runde: ",i) #Gibt die Rundenanzahl aus
        i+=1
print("Finished") #Programm ist beendet
</code>
Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
