Benutzer-Werkzeuge
ss19:mapgeneration_fuer_grosse_populationen_eric
Unterschiede
Hier werden die Unterschiede zwischen zwei Versionen gezeigt.
| Beide Seiten der vorigen Revision Vorhergehende Überarbeitung Nächste Überarbeitung | Vorhergehende Überarbeitung | ||
|
ss19:mapgeneration_fuer_grosse_populationen_eric [2019/06/10 22:50] eric_m |
ss19:mapgeneration_fuer_grosse_populationen_eric [2019/06/20 13:19] (aktuell) eric_m |
||
|---|---|---|---|
| Zeile 15: | Zeile 15: | ||
| self.size = 1 #Größe | self.size = 1 #Größe | ||
| self.status = True #Aktiv oder nicht | self.status = True #Aktiv oder nicht | ||
| - | self.chunkpos = [] #Speichert die Position des Chunks | + | self.chunkpos = [0,0] #Speichert die Position des Chunks |
| self.speed = 5 #Geschwindigkeit | self.speed = 5 #Geschwindigkeit | ||
| self.stamina = 250 #Ausdauer | self.stamina = 250 #Ausdauer | ||
| self.angle = angle #Laufwinkel | self.angle = angle #Laufwinkel | ||
| self.sight = 1 #Sichtweite | self.sight = 1 #Sichtweite | ||
| - | self.rect=pygame.Rect(int(self.x)-int(self.sight),int(self.y)-int(self.sight),self.sight*2+self.size,self.sight*2+self.size)#Rechteck in Pygame | + | 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.name=name #ID | ||
| self.vx = 0#?? | self.vx = 0#?? | ||
| self.vy = 0 | self.vy = 0 | ||
| - | + | self.list = [] | |
| + | self.status = True | ||
| #Löscht den Spieler | #Löscht den Spieler | ||
| def __del__(self): | def __del__(self): | ||
| - | + | if self.status == True: | |
| - | a=0 | + | return self.list |
| + | print("Player died") | ||
| + | time.sleep(2) | ||
| #bewegt den Spieler | #bewegt den Spieler | ||
| def move(self): | def move(self): | ||
| - | #if self.name == 0 : | ||
| - | #self.x+=5 | ||
| - | #if self.name == 1 : | ||
| - | # self.x-=5 | ||
| - | #if self.name == 2 : | ||
| - | # self.y+=5 | ||
| - | #if self.name == 3 : | ||
| - | #self.y-=5 | ||
| self.x+=random.randint(-self.speed,self.speed) | self.x+=random.randint(-self.speed,self.speed) | ||
| self.y+=random.randint(-self.speed,self.speed) | self.y+=random.randint(-self.speed,self.speed) | ||
| self.rect=pygame.Rect(int(self.x)-int(self.sight),int(self.y)-int(self.sight),self.sight*2+self.size,self.sight*2+self.size) | self.rect=pygame.Rect(int(self.x)-int(self.sight),int(self.y)-int(self.sight),self.sight*2+self.size,self.sight*2+self.size) | ||
| - | pygame.draw.rect(screen, (255, 0, 0),self.rect) | + | pygame.draw.rect(screen, (255,0, 0),self.rect) |
| self.stamina-=1 | self.stamina-=1 | ||
| + | |||
| + | def parents(self,list): | ||
| + | self.list = list | ||
| class object: | class object: | ||
| #Initialisiert den Spieler | #Initialisiert den Spieler | ||
| - | def __init__(self,x,y,sizex,sizey,name): | + | def __init__(self,x,y,name): |
| self.x=x #x-Pos | self.x=x #x-Pos | ||
| self.y=y #y-Pos | self.y=y #y-Pos | ||
| Zeile 55: | Zeile 53: | ||
| self.name = name #ID | self.name = name #ID | ||
| self.chunkpos = [] #Speichert die Koordinaten des Chunks | self.chunkpos = [] #Speichert die Koordinaten des Chunks | ||
| - | self.size = 5 #Größe | + | self.size = 3 #Größe |
| self.rect = pygame.Rect(x, y, self.size,self.size) #Rechteck in Pygame | self.rect = pygame.Rect(x, y, self.size,self.size) #Rechteck in Pygame | ||
| Zeile 80: | Zeile 78: | ||
| self.overlay = overlay | self.overlay = overlay | ||
| self.objects = [] #Liste der festen Objekte | self.objects = [] #Liste der festen Objekte | ||
| - | self.density = 0.7 #Wahrscheinlichkeit für neue Objekte | + | self.density = 0.00125 #Wahrscheinlichkeit für neue Objekte |
| self.name = name | self.name = name | ||
| Zeile 100: | Zeile 98: | ||
| #generiert zufällig verteilte Objekte in dem Chunk | #generiert zufällig verteilte Objekte in dem Chunk | ||
| - | def generate(self,numb,length,height,name): | + | def generate(self): |
| - | for i in range(numb): | + | a = object(0,0,0) |
| - | if random.random()<=self.density: | + | numb = self.length*self.height*self.density/a.size |
| - | self.objects.append(object(random.randint(self.x,self.getendx()),random.randint(self.y,self.getendy()),random.randint(0,length),random.randint(0,height),name)) | + | 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 | #Gesamte Map | ||
| class map: | class map: | ||
| Zeile 114: | Zeile 113: | ||
| #Initilisiert die Map | #Initilisiert die Map | ||
| #def__init__(Liste der Objekte,Liste der Spieler,Gesamtgröße der Map,Größe der Chunks) | #def__init__(Liste der Objekte,Liste der Spieler,Gesamtgröße der Map,Größe der Chunks) | ||
| - | def __init__(self,listobj,playerlist,size,sizechunk): | + | def __init__(self,playerlist,size,sizechunk): |
| - | self.objects = listobj | + | |
| self.worldsize = size #Worldsize | self.worldsize = size #Worldsize | ||
| self.chunksize = sizechunk #Chunksize wird später static | self.chunksize = sizechunk #Chunksize wird später static | ||
| Zeile 123: | Zeile 121: | ||
| self.maplist = [] #2-Dim Liste der Chunks | self.maplist = [] #2-Dim Liste der Chunks | ||
| self.initiate() | self.initiate() | ||
| - | self.playerinitiate() | + | self.playerupdate() |
| #Initilisiert die Grundmap, sowie weist jedem Chunk die Objekte hinzu | #Initilisiert die Grundmap, sowie weist jedem Chunk die Objekte hinzu | ||
| def initiate(self): | def initiate(self): | ||
| - | preobject = self.objects.copy() | ||
| factor = int(self.worldsize/self.chunksize) | factor = int(self.worldsize/self.chunksize) | ||
| print(factor) | print(factor) | ||
| Zeile 134: | Zeile 131: | ||
| for i in range(factor): | for i in range(factor): | ||
| line = [] | line = [] | ||
| - | |||
| - | |||
| #Durchläuft die x-Richtung der Chunks | #Durchläuft die x-Richtung der Chunks | ||
| for e in range(factor): | for e in range(factor): | ||
| line.append(chunk(self.chunksize*e,self.chunksize*i,self.chunksize,self.chunksize,self.overlay,e+i*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(),")") | #print("(",a.x,"/",a.y,") - ","(",a.getendx(),"/",a.getendy(),")") | ||
| - | #Durchläuft alle festen Objekte | + | #Durchläuft alle festen Objekte |
| - | for qq in range(len(preobject)): | + | line[e].generate() |
| - | + | #print("(",line[e].x,"/",line[e].y,")",end="") | |
| - | #Wenn die Objekte in einem bestimmten Chunk sind, werden diese in dem Chunk gespeichert | + | |
| - | + | ||
| - | if (line[e].x) <= preobject[qq].x <= (line[e].getendx()) and (line[e].y) <= preobject[qq].y <= (line[e].getendy()): | + | |
| - | R+=1 | + | |
| - | line[e].newobj(preobject[qq]) | + | |
| - | preobject[qq].status = False | + | |
| - | + | ||
| - | #Entfernt alle Objekteaus der Liste, die in einem Chunk sind | + | |
| - | for qq in range(len(preobject)): | + | |
| - | k = len(preobject) | + | |
| - | J = True | + | |
| - | for qqq in range(len(preobject)): | + | |
| - | k-=1 | + | |
| - | if preobject[qqq].status == False: | + | |
| - | del preobject[qqq] | + | |
| - | break | + | |
| - | if k==0: | + | |
| - | J = False | + | |
| - | break | + | |
| - | if J == False: | + | |
| - | break | + | |
| self.maplist.append(line) | self.maplist.append(line) | ||
| + | #print("") | ||
| del line | del line | ||
| print("Objects ready!") | print("Objects ready!") | ||
| Zeile 171: | Zeile 145: | ||
| #weist jedem Spieler den Chunk hinzu in welchem dieser sich befindet | #weist jedem Spieler den Chunk hinzu in welchem dieser sich befindet | ||
| - | def playerinitiate(self): | + | def playerinitiate(self,playerlist): |
| + | self.player = playerlist | ||
| #Durchläuft die Liste der Player | #Durchläuft die Liste der Player | ||
| for q in range(len(self.player)): | for q in range(len(self.player)): | ||
| Zeile 192: | Zeile 167: | ||
| #Durchläuft die Liste der Player | #Durchläuft die Liste der Player | ||
| - | for q in range(len(self.player)): | + | q=0 |
| + | while q < len(self.player): | ||
| #Chunkposition in der Liste | #Chunkposition in der Liste | ||
| Zeile 204: | Zeile 180: | ||
| x = self.player[q].x #x-Pos des Spielers | x = self.player[q].x #x-Pos des Spielers | ||
| y = self.player[q].y #y-Pos des Spielers | y = self.player[q].y #y-Pos des Spielers | ||
| - | x0 = self.maplist[0][0].x #kleinste x-Pos der Chunks | + | x0 = 0 #kleinste x-Pos der Chunks |
| - | y0 = self.maplist[0][0].y #kleinste y-Pos der Chunks | + | y0 = 0 #kleinste y-Pos der Chunks |
| - | xn = self.maplist[0][len(self.maplist[0])-1].getendx() #größte x-Pos der Chunks | + | xn = self.worldsize #größte x-Pos der Chunks |
| - | yn = self.maplist[len(self.maplist)-1][0].getendy() #größte x-Pos der Chunks | + | yn = self.worldsize #größte x-Pos der Chunks |
| - | + | ||
| - | #Falls der Spieler außerhalb der Map ist, wird diese erweitert. | + | |
| - | if x < x0: | + | if x <= x0 or x >= xn or y <= y0 or y >= yn: |
| - | self.map_increase(q) | + | del self.player[q] |
| - | x0 = self.maplist[0][0].x | + | q-=1 |
| - | elif xn < x: | + | else: |
| - | self.map_increase(q) | + | #Da sich die Map auch in den negativen Bereich erweitert, erhalten alle Chunks einen Shift. |
| - | xn = self.maplist[0][len(self.maplist[0])-1].x | + | self.player[q].chunkpos[1] = int(x/self.chunksize) |
| - | if y < y0: | + | self.player[q].chunkpos[0] = int(y/self.chunksize) |
| - | self.map_increase(q) | + | #print(x,"/",y) |
| - | y0 = self.maplist[0][0].y | + | #print(self.maplist[int(y/self.chunksize)][int(x/self.chunksize)].x,"/",self.maplist[int(y/self.chunksize)][int(x/self.chunksize)].y) |
| - | elif yn < y: | + | #print("---------") |
| - | self.map_increase(q) | + | #time.sleep(2) |
| - | yn = self.maplist[len(self.maplist)-1][0].y | + | q+=1 |
| - | + | ||
| - | x_neu=int(x/10) #neue x-Chunkposition | + | |
| - | y_neu=int(y/10) #neue y-Chunkposition | + | |
| - | #Da sich die Map auch in den negativen Bereich erweitert, erhalten alle Chunks einen Shift. | + | |
| - | if x<0: | + | |
| - | self.player[q].chunkpos[1] = x_neu-1-int(x0/10) | + | |
| - | elif x>=0: | + | |
| - | self.player[q].chunkpos[1] = x_neu-int(x0/10) | + | |
| - | if y<0: | + | |
| - | self.player[q].chunkpos[0] = y_neu-1-int(y0/10) | + | |
| - | elif y>=0: | + | |
| - | self.player[q].chunkpos[0] = y_neu-int(y0/10) | + | |
| #Hitboxberechung der Objekte und den Spielern | #Hitboxberechung der Objekte und den Spielern | ||
| def hitbox(self): | def hitbox(self): | ||
| Zeile 253: | Zeile 217: | ||
| #(bis jetzt) löscht das Objekt und erhöt Stamina um 250 | #(bis jetzt) löscht das Objekt und erhöt Stamina um 250 | ||
| if self.player[i].rect.collidelist(self.maplist[q][w].objects)>-1: | if self.player[i].rect.collidelist(self.maplist[q][w].objects)>-1: | ||
| - | print("Treffer!") | + | #print("Treffer!") |
| - | print("Position: (",self.player[i].x,"/",self.player[i].y,")") | + | #print("Position: (",self.player[i].x,"/",self.player[i].y,")") |
| del self.maplist[q][w].objects[e] | del self.maplist[q][w].objects[e] | ||
| e-=1 | e-=1 | ||
| Zeile 356: | Zeile 320: | ||
| value = True | value = True | ||
| print("Map wird nach oben erweitert.") | 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) | ||
| mapsize=1000 #Mapsize | mapsize=1000 #Mapsize | ||
| - | listobj = [] #Objektliste | + | |
| playerl = [] #Spielerliste | playerl = [] #Spielerliste | ||
| clock = pygame.time.Clock() | clock = pygame.time.Clock() | ||
| + | playercount = int(0.1*mapsize) | ||
| + | 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)) | ||
| - | for i in range(50):#erstellt X Spieler | + | map01 = map(playerl,mapsize,50) #erstellt die Map |
| - | playerl.append(player(random.randint(0,mapsize),random.randint(0,mapsize),0,0,i)) | + | |
| - | + | ||
| - | for i in range(50):#erstellt Y Objekte(Futter) | + | |
| - | listobj.append(object(random.randint(0,mapsize),random.randint(0,mapsize),random.randint(0,5),random.randint(0,5),i)) | + | |
| - | + | ||
| - | listobj.sort(key=lambda k: k.x, reverse = True) #sortiert die Objekte | + | |
| - | + | ||
| - | map01 = map(listobj,playerl,mapsize,int(0.01*mapsize)) #erstellt die Map | + | |
| - | screen = pygame.display.set_mode((500,500)) #erstellt den Hauptbildschirm | + | screen = pygame.display.set_mode((1000,1000)) #erstellt den Hauptbildschirm |
| moveframes = 5 #Anzahl der Frames | moveframes = 5 #Anzahl der Frames | ||
| i=0 #Zählt die Schleifendurchläufe | i=0 #Zählt die Schleifendurchläufe | ||
| done = False #Falls True beendet das Programm | done = False #Falls True beendet das Programm | ||
| + | winner = [] | ||
| while not done: | while not done: | ||
| - | #clock.tick(50) #Für größere Pausen zwischen den Runden | + | clock.tick(50) #Für größere Pausen zwischen den Runden |
| - | + | ||
| #Beendet das Programm falls ... | #Beendet das Programm falls ... | ||
| for event in pygame.event.get(): | for event in pygame.event.get(): | ||
| Zeile 393: | Zeile 359: | ||
| #Lässt die Spieler einen move machen oder löscht diese | #Lässt die Spieler einen move machen oder löscht diese | ||
| e = 0 | e = 0 | ||
| + | status = False | ||
| while e <len(map01.player) and e>=0: | while e <len(map01.player) and e>=0: | ||
| if map01.player[e].stamina>0: | if map01.player[e].stamina>0: | ||
| map01.player[e].move() | map01.player[e].move() | ||
| - | e+=1 | + | else: |
| - | else: | + | if len(map01.player)<=int(playercount*0.1): |
| + | winner.append(map01.player[e]) | ||
| + | #if len(map01.player)==1: | ||
| + | #print("Runde:",i) | ||
| del map01.player[e] | del map01.player[e] | ||
| e-=1 | e-=1 | ||
| + | e+=1 | ||
| print("------------") | print("------------") | ||
| Zeile 417: | Zeile 387: | ||
| pygame.display.flip() | pygame.display.flip() | ||
| - | print("Runde: ",i) #Gibt die Rundenanzahl aus | + | #print("Runde: ",i) #Gibt die Rundenanzahl aus |
| i+=1 | i+=1 | ||
| print("Finished") #Programm ist beendet | print("Finished") #Programm ist beendet | ||
| - | |||
| </code> | </code> | ||
ss19/mapgeneration_fuer_grosse_populationen_eric.1560199825.txt.gz · Zuletzt geändert: 2019/06/10 22:50 von eric_m
Seiten-Werkzeuge
