Benutzer-Werkzeuge
ss19:test
Unterschiede
Hier werden die Unterschiede zwischen zwei Versionen gezeigt.
| Beide Seiten der vorigen Revision Vorhergehende Überarbeitung Nächste Überarbeitung | Vorhergehende Überarbeitung | ||
|
ss19:test [2019/06/20 16:44] eric_m |
ss19:test [2019/06/25 14:07] (aktuell) eric_m |
||
|---|---|---|---|
| Zeile 3: | Zeile 3: | ||
| import pygame | import pygame | ||
| import time | import time | ||
| + | import math | ||
| pygame.init() | pygame.init() | ||
| Zeile 12: | Zeile 13: | ||
| #Initialisiert den Spieler | #Initialisiert den Spieler | ||
| - | def __init__(self,x,y,angle,speed,name): | + | def __init__(self,x,y,angle,speed,name): |
| - | self.x=x #x-Pos | + | self.x=x #x-Pos |
| - | self.y=y #y-Pos | + | self.y=y #y-Pos |
| - | self.size = 1 #Größe | + | self.size = 5 #Größe |
| - | self.status = True #Aktiv oder nicht | + | self.status = True #Aktiv oder nicht |
| - | self.chunkpos = [0,0] #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.size),int(self.y)-int(self.size),self.size*2+self.size,self.size*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.v = False | + | self.v = False |
| - | self.percent = [] | + | self.percent = [] |
| - | self.lists = [] | + | self.lists = [] |
| - | self.runlength=[] | + | self.viewangle = 60 |
| - | self.runangle=[] | + | self.objangle = 0 |
| - | self.status = True | + | self.runlength=[] |
| + | self.runangle=[] | ||
| + | self.status = True | ||
| + | self.parent = [] | ||
| + | self.ppos = 0 | ||
| #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") | + | def sightcheck(self,dist,alpha): |
| - | time.sleep(2) | + | self.objangle = alpha |
| - | + | #print(dist) | |
| - | def sightcheck(self,dist,alpha): | + | self.v = False |
| - | self.objangle = alpha | + | if dist<=self.sight: |
| - | #print(dist) | + | #print(self.angle%360,alpha) |
| - | self.v = False | + | if self.angle-self.viewangle<0: |
| - | if dist<=self.sight: | + | if (self.angle%360-self.viewangle)+360 <= alpha or alpha <= self.angle+self.viewangle: |
| - | #print(self.angle%360,alpha) | + | self.percent.append(1) |
| - | if self.angle-self.viewangle<0: | + | self.angle=alpha |
| - | if (self.angle%360-self.viewangle)+360 <= alpha or alpha <= self.angle+self.viewangle: | + | self.v = True |
| - | self.percent.append(1) | + | #print("2",self.v) |
| - | self.angle=alpha | + | elif self.angle-self.viewangle>360: |
| - | self.v = True | + | if (self.angle%360-self.viewangle)-360 <= alpha or alpha <= self.angle+self.viewangle: |
| - | #print("2",self.v) | + | self.percent.append(1) |
| - | elif self.angle-self.viewangle>360: | + | self.v = True |
| - | if (self.angle%360-self.viewangle)-360 <= alpha or alpha <= self.angle+self.viewangle: | + | #print(self.v) |
| - | self.percent.append(1) | + | self.angle=alpha |
| - | self.v = True | + | else: |
| - | #print(self.v) | + | if self.angle%360-self.viewangle <= alpha <= self.angle+self.viewangle: |
| - | self.angle=alpha | + | self.percent.append(1) |
| - | else: | + | #print(self.v) |
| - | if self.angle%360-self.viewangle <= alpha <= self.angle+self.viewangle: | + | self.v = True |
| - | self.percent.append(1) | + | self.angle=alpha |
| - | #print(self.v) | + | |
| - | self.v = True | + | |
| - | self.angle=alpha | + | |
| #bewegt den Spieler | #bewegt den Spieler | ||
| - | + | | |
| - | def move(self): | + | def move(self): |
| - | if not parentlist: | + | if not self.parent: |
| - | self.angle+=random.randint(-45,45)%360 | + | self.angle+=random.randint(-45,45) |
| - | self.speed=random.randint(0,5) | + | self.angle = self.angle%360 |
| - | self.x+=self.speed*math.cos(self.angle/180*math.pi) | + | self.speed=random.randint(0,5) |
| - | self.y+=self.speed*math.sin(self.angle/180*math.pi) | + | self.x+=self.speed*math.cos(self.angle/180*math.pi) |
| - | self.rect=pygame.Rect(int(self.x),int(self.y),self.size,self.size) | + | self.y+=self.speed*math.sin(self.angle/180*math.pi) |
| - | pygame.draw.rect(screen, (255, 0, 0),self.rect) | + | self.rect=pygame.Rect(int(self.x),int(self.y),self.size,self.size) |
| - | self.stamina-=1 | + | pygame.draw.rect(screen, (255, 0, 0),self.rect) |
| - | self.runlength.append(self.speed) | + | self.stamina-=1 |
| - | self.runangle.append(self.angle) | + | self.runlength.append(self.speed) |
| - | else: | + | self.runangle.append(self.angle) |
| - | if self.v == True: | + | else: |
| - | a = random.randint(0,len(parentlist[0])) | + | #print(self.parent) |
| - | else : | + | self.angle+=self.parent[0][self.ppos]%360 |
| - | a = random.randint(0,len(parentlist[1])) | + | self.angle = self.angle%360 |
| - | self.x+=parentlist[a][0]*math.cos(parentlist[a][1]/180*math.pi) | + | self.speed=self.parent[1][self.ppos] |
| - | self.y+=parentlist[a][0]*math.sin(parentlist[a][1]/180*math.pi) | + | self.x+=self.speed*math.cos(self.angle/180*math.pi) |
| - | self.rect=pygame.Rect(int(self.x),int(self.y),self.size,self.size) | + | self.y+=self.speed*math.sin(self.angle/180*math.pi) |
| - | pygame.draw.rect(screen, (255, 0, 0),self.rect) | + | self.rect=pygame.Rect(int(self.x),int(self.y),self.size,self.size) |
| - | self.stamina-=1 | + | pygame.draw.rect(screen, (255, 0, 0),self.rect) |
| - | self.runlength.append(self.speed) | + | self.stamina-=1 |
| - | self.runangle.append(self.angle) | + | self.runlength.append(self.speed) |
| + | self.runangle.append(self.angle) | ||
| + | self.ppos+=1 | ||
| + | # else : | ||
| + | # c = random.randint(0,len(parentlist[a][1])-1) | ||
| + | # self.x+=parentlist[a][1][0]*math.cos(parentlist[a][1][1]/180*math.pi) | ||
| + | # self.y+=parentlist[a][1][0]*math.sin(parentlist[a][1][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): | def exportlist(self): | ||
| - | return [self.runlength,self.runangle,self.percent] | + | l=[self.runlength,self.runangle,self.percent] |
| + | return l | ||
| | | ||
| - | def move2(self): | + | #def move2(self): |
| - | | + | |
| - | def parents(self,lists): | + | def parents(self,lists): |
| - | self.lists = lists | + | self.parent = lists |
| class object: | class object: | ||
| #Initialisiert den Spieler | #Initialisiert den Spieler | ||
| - | def __init__(self,x,y,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 |
| - | self.status = True #Aktiv oder nicht | + | self.status = True #Aktiv oder nicht |
| - | self.name = name #ID | + | self.name = name #ID |
| - | self.chunkpos = [] #Speichert die Koordinaten des Chunks | + | self.chunkpos = [] #Speichert die Koordinaten des Chunks |
| - | self.size = 3 #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 |
| - | + | ||
| #Löscht das Objekt | #Löscht das Objekt | ||
| - | def __del__(self): | + | def __del__(self): |
| - | a=0 | + | a=0 |
| #Klasse Chunk | #Klasse Chunk | ||
| class chunk: | class chunk: | ||
| - | x = 0 #x-Position | + | x = 0 #x-Position |
| - | y = 0 #y-Position | + | y = 0 #y-Position |
| - | food=0 #??? | + | food=0 #??? |
| - | length = 0 #Länge(x-Richtung) | + | length = 0 #Länge(x-Richtung) |
| - | height = 0 #Breite(y-Richtung | + | height = 0 #Breite(y-Richtung |
| - | overlay = 0 #Wie stark sich die verschiedenen Chunks überlappen | + | overlay = 0 #Wie stark sich die verschiedenen Chunks überlappen |
| - | name = 0 # ID | + | name = 0 # ID |
| - | + | ||
| #Initilisiert den Chunk | #Initilisiert den Chunk | ||
| - | def __init__(self,x,y,length,height,overlay,name): | + | def __init__(self,x,y,length,height,overlay,name): |
| - | self.x = x | + | self.x = x |
| - | self.y = y | + | self.y = y |
| - | self.length = length | + | self.length = length |
| - | self.height = height | + | self.height = height |
| - | self.overlay = overlay | + | self.overlay = overlay |
| - | self.objects = [] #Liste der festen Objekte | + | self.objects = [] #Liste der festen Objekte |
| - | self.density = 0.00125 #Wahrscheinlichkeit für neue Objekte | + | self.density = 0.00125 #Wahrscheinlichkeit für neue Objekte |
| - | self.name = name | + | self.name = name |
| - | + | ||
| #Fügt der Objektliste ein neues Element hinzu | #Fügt der Objektliste ein neues Element hinzu | ||
| - | def newobj(self,obj): | + | def newobj(self,obj): |
| - | self.objects.append(obj) | + | self.objects.append(obj) |
| #Übergibt die maximale x-Position | #Übergibt die maximale x-Position | ||
| - | def getendx(self): | + | def getendx(self): |
| - | return self.x+self.length | + | return self.x+self.length |
| #Übergibt die maximale y-Position | #Übergibt die maximale y-Position | ||
| - | def getendy(self): | + | def getendy(self): |
| - | return self.y+self.height | + | return self.y+self.height |
| #löscht das Objekt | #löscht das Objekt | ||
| - | def __del__(self): | + | def __del__(self): |
| - | a = 0 | + | a = 0 |
| - | + | ||
| #generiert zufällig verteilte Objekte in dem Chunk | #generiert zufällig verteilte Objekte in dem Chunk | ||
| - | def generate(self): | + | def generate(self): |
| - | a = object(0,0,0) | + | a = object(0,0,0) |
| - | numb = self.length*self.height*self.density/a.size | + | numb = self.length*self.height*self.density/a.size |
| - | for i in range(int(numb)): | + | 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)) | + | 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)) | + | #print(len(self.objects)) |
| #Gesamte Map | #Gesamte Map | ||
| class map: | class map: | ||
| - | objects = 0 | + | objects = 0 |
| - | worldsize = 0 | + | worldsize = 0 |
| - | chunksize = 0 | + | chunksize = 0 |
| - | overlay = 0 | + | overlay = 0 |
| - | + | ||
| #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,playerlist,size,sizechunk): | + | def __init__(self,playerlist,size,sizechunk): |
| - | self.worldsize = size #Worldsize | + | self.worldsize = size #Worldsize |
| - | self.chunksize = sizechunk #Chunksize wird später static | + | self.chunksize = sizechunk #Chunksize wird später static |
| - | self.overlay = sizechunk*0.1 #Overlay der Chunks(10%) | + | self.overlay = sizechunk*0.1 #Overlay der Chunks(10%) |
| - | self.player = playerlist #Spielerliste | + | self.player = playerlist #Spielerliste |
| - | self.faktor = int(size/sizechunk) #Faktor(für einige Berechnungen) | + | self.faktor = int(size/sizechunk) #Faktor(für einige Berechnungen) |
| - | self.maplist = [] #2-Dim Liste der Chunks | + | self.maplist = [] #2-Dim Liste der Chunks |
| - | self.initiate() | + | self.initiate() |
| - | self.playerupdate() | + | 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): |
| - | factor = int(self.worldsize/self.chunksize) | + | factor = int(self.worldsize/self.chunksize) |
| - | print(factor) | + | print(factor) |
| - | R = 0 | + | R = 0 |
| - | #Durchläuft die y-Richtung der Chunks | + | #Durchläuft die y-Richtung der Chunks |
| - | 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 |
| - | line[e].generate() | + | line[e].generate() |
| - | #print("(",line[e].x,"/",line[e].y,")",end="") | + | #print("(",line[e].x,"/",line[e].y,")",end="") |
| - | self.maplist.append(line) | + | self.maplist.append(line) |
| - | #print("") | + | #print("") |
| - | del line | + | del line |
| - | print("Objects ready!") | + | print("Objects ready!") |
| - | print("") | + | print("") |
| - | + | ||
| #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,playerlist): | + | def playerinitiate(self,playerlist): |
| - | self.player = 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)): |
| - | #Durchläuft die x-Richtung der Chunks | + | #Durchläuft die x-Richtung der Chunks |
| - | for i in range(len(self.maplist)): | + | for i in range(len(self.maplist)): |
| - | qq = False | + | qq = False |
| - | #Durchläuft die y-Richtung der Chunks | + | #Durchläuft die y-Richtung der Chunks |
| - | for e in range(len(self.maplist[i])): | + | 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(): | + | 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(i) |
| - | self.player[q].chunkpos.append(e) | + | self.player[q].chunkpos.append(e) |
| - | qq = True | + | qq = True |
| - | break | + | break |
| - | if qq == True: | + | if qq == True: |
| - | break | + | break |
| - | print("Player Ready!") | + | print("Player Ready!") |
| - | + | ||
| #überprüft die Chunkposition des Spielers | #überprüft die Chunkposition des Spielers | ||
| - | def playerupdate(self): | + | def playerupdate(self): |
| - | #Durchläuft die Liste der Player | + | #Durchläuft die Liste der Player |
| - | q=0 | + | q=0 |
| - | while q < len(self.player): | + | while q < len(self.player): |
| #Chunkposition in der Liste | #Chunkposition in der Liste | ||
| - | i = self.player[q].chunkpos[0] | + | i = self.player[q].chunkpos[0] |
| - | e = self.player[q].chunkpos[1] | + | e = self.player[q].chunkpos[1] |
| - | #Wenn der Player immernoch im gleichen Chunk ist, passiert nichts,... | + | #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(): | + | 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 | + | a=0 |
| - | #...sonst berechnet er den Chunk. | + | #...sonst berechnet er den Chunk. |
| - | else: | + | else: |
| - | 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 = 0 #kleinste x-Pos der Chunks | + | x0 = 0 #kleinste x-Pos der Chunks |
| - | y0 = 0 #kleinste y-Pos der Chunks | + | y0 = 0 #kleinste y-Pos der Chunks |
| - | xn = self.worldsize #größte x-Pos der Chunks | + | xn = self.worldsize #größte x-Pos der Chunks |
| - | yn = 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 x <= x0 or x >= xn or y <= y0 or y >= yn: |
| - | if len(self.player)<=20: | + | if len(self.player)<=20: |
| - | impotlist.append(self.player[q].eportlist()) | + | importlist.append(self.player[q].exportlist()) |
| - | del self.player[q] | + | del self.player[q] |
| - | q-=1 | + | q-=1 |
| - | else: | + | else: |
| - | #Da sich die Map auch in den negativen Bereich erweitert, erhalten alle Chunks einen Shift. | + | #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[1] = int(x/self.chunksize) |
| - | self.player[q].chunkpos[0] = int(y/self.chunksize) | + | self.player[q].chunkpos[0] = int(y/self.chunksize) |
| - | #print(x,"/",y) | + | #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(self.maplist[int(y/self.chunksize)][int(x/self.chunksize)].x,"/",self.maplist[int(y/self.chunksize)][int(x/self.chunksize)].y) |
| - | #print("---------") | + | #print("---------") |
| - | #time.sleep(2) | + | #time.sleep(2) |
| - | q+=1 | + | q+=1 |
| - | + | ||
| #Hitboxberechung der Objekte und den Spielern | #Hitboxberechung der Objekte und den Spielern | ||
| - | def hitbox(self): | + | def hitbox(self): |
| - | #Durchläuft jeden Spieler | + | #Durchläuft jeden Spieler |
| - | for i in range(len(self.player)): | + | for i in range(len(self.player)): |
| #Chunkposition in der Liste | #Chunkposition in der Liste | ||
| - | q = self.player[i].chunkpos[0] | + | q = self.player[i].chunkpos[0] |
| - | w = self.player[i].chunkpos[1] | + | w = self.player[i].chunkpos[1] |
| #Falls die Liste leer ist | #Falls die Liste leer ist | ||
| | | ||
| - | #print(q,w) | + | #print(q,w) |
| - | if not self.maplist[q][w].objects: | + | if not self.maplist[q][w].objects: |
| - | a = 0 | + | a = 0 |
| - | else: | + | else: |
| - | a=len(self.maplist[q][w].objects) | + | a=len(self.maplist[q][w].objects) |
| - | #Durchläuft die Liste der Objekte im Chunk mit den der Spieler kollidieren kann | + | #Durchläuft die Liste der Objekte im Chunk mit den der Spieler kollidieren kann |
| - | e=0 | + | e=0 |
| - | while e<(len(self.maplist[q][w].objects)): | + | 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) | + | 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(dist) |
| - | #print((self.player[i].y-self.maplist[q][w].objects[e].y)) | + | #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)) | + | alpha = math.acos(((self.player[i].y-self.maplist[q][w].objects[e].y)/dist)) |
| - | self.player[i].sightcheck(dist,alpha) | + | self.player[i].sightcheck(dist,alpha) |
| - | 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] |
| - | #print(self.player[i].v) | + | #print(self.player[i].v) |
| - | self.player[i].v = False | + | self.player[i].v = False |
| - | e-=1 | + | e-=1 |
| - | self.player[i].stamina+=250 | + | self.player[i].stamina+=250 |
| - | e+=1 | + | e+=1 |
| - | + | ||
| #Gibt die Liste der Spieler aus | #Gibt die Liste der Spieler aus | ||
| | | ||
| - | def showp(self): | + | def showp(self): |
| - | for i in range(len(self.player)): | + | for i in range(len(self.player)): |
| - | q = self.player[i].chunkpos[0] | + | q = self.player[i].chunkpos[0] |
| - | w = self.player[i].chunkpos[1] | + | w = self.player[i].chunkpos[1] |
| - | a=len(self.maplist[q][w].objects) | + | a=len(self.maplist[q][w].objects) |
| - | #Durchläuft die Liste der Objekte im Chunk mit den der Spieler kollidieren kann | + | #Durchläuft die Liste der Objekte im Chunk mit den der Spieler kollidieren kann |
| - | print("Player",i) | + | print("Player",i) |
| - | #print("Anzahl der Objekte:",len(self.maplist[q][w].objects)) | + | #print("Anzahl der Objekte:",len(self.maplist[q][w].objects)) |
| - | for t in range(len(self.maplist[q][w].objects)): | + | for t in range(len(self.maplist[q][w].objects)): |
| - | #Gibt die Koordinaten des Objektes aus | + | #Gibt die Koordinaten des Objektes aus |
| - | print("(",self.maplist[q][w].objects[t].x,"/",self.maplist[q][w].objects[t].y,")") | + | print("(",self.maplist[q][w].objects[t].x,"/",self.maplist[q][w].objects[t].y,")") |
| - | print("-----") | + | print("-----") |
| #Gibt die Liste der Objekte aus | #Gibt die Liste der Objekte aus | ||
| - | def showc(self): | + | def showc(self): |
| - | #Durchläuft die Liste der Chunks | + | #Durchläuft die Liste der Chunks |
| - | print(len(self.maplist)) | + | print(len(self.maplist)) |
| - | for i in range(len(self.maplist)): | + | for i in range(len(self.maplist)): |
| - | print(len(self.maplist[i])) | + | print(len(self.maplist[i])) |
| - | for e in range(len(self.maplist[i])): | + | for e in range(len(self.maplist[i])): |
| - | #Gibt die Koordinaten des Objektes aus | + | #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("(",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)) | + | print(len(self.maplist[i][e].objects)) |
| #Zeichnet alle Objekte auf dem Hauptbildschirm | #Zeichnet alle Objekte auf dem Hauptbildschirm | ||
| - | def drawobj(self): | + | def drawobj(self): |
| - | for q in self.maplist: | + | for q in self.maplist: |
| - | for w in q: | + | for w in q: |
| - | for i in w.objects: | + | for i in w.objects: |
| - | pygame.draw.rect(screen, (255, 0, 255), i.rect) | + | pygame.draw.rect(screen, (255, 0, 255), i.rect) |
| #Zeichnet die Chunks in einem weiteren Bildschirm | #Zeichnet die Chunks in einem weiteren Bildschirm | ||
| - | def drawchunks(self): | + | def drawchunks(self): |
| - | for q in self.maplist: | + | for q in self.maplist: |
| - | for w in q: | + | for w in q: |
| - | pygame.draw.rect(screen, (255, 0, 255), i.rect) | + | pygame.draw.rect(screen, (255, 0, 255), i.rect) |
| #erweitert die Karte falls ein Spieler außerhalb der derzeitigen Karte ist | #erweitert die Karte falls ein Spieler außerhalb der derzeitigen Karte ist | ||
| - | def map_increase(self,pos): | + | def map_increase(self,pos): |
| #erweitert die Karte nach links | #erweitert die Karte nach links | ||
| - | if (self.player[pos].x<self.maplist[0][0].x): | + | if (self.player[pos].x<self.maplist[0][0].x): |
| - | #print(self.player[pos].x,"<",self.maplist[0][0].x) | + | #print(self.player[pos].x,"<",self.maplist[0][0].x) |
| - | i = 0 | + | i = 0 |
| - | k = self.maplist[0][0].x-self.chunksize | + | k = self.maplist[0][0].x-self.chunksize |
| - | l = self.maplist[0][0].y | + | l = self.maplist[0][0].y |
| - | for list in self.maplist: | + | for list in self.maplist: |
| - | list.insert(0,chunk(k,l+i*self.chunksize,self.chunksize,self.chunksize,self.overlay,5))#neuer Chunk | + | 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 | + | list[0].generate(2,random.randint(0,5),random.randint(0,5),len(self.objects)) #chunk generiert |
| - | value = True | + | value = True |
| - | print("Map wird nach links erweitert.") | + | print("Map wird nach links erweitert.") |
| #erweitert die Karte nach rechts | #erweitert die Karte nach rechts | ||
| - | if (self.player[pos].x>self.maplist[0][len(self.maplist[0])-1].getendx()): | + | 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()) | + | #print(self.player[pos].x,">",self.maplist[0][len(self.maplist[0])-1].getendx()) |
| - | i = 0 | + | i = 0 |
| - | k = self.maplist[0][len(self.maplist[0])-1].x+self.chunksize | + | k = self.maplist[0][len(self.maplist[0])-1].x+self.chunksize |
| - | l = self.maplist[0][0].y | + | l = self.maplist[0][0].y |
| - | for list in self.maplist: | + | for list in self.maplist: |
| - | list.append(chunk(k,l+i*self.chunksize,self.chunksize,self.chunksize,self.overlay,5)) | + | 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)) | + | list[len(list)-1].generate(2,random.randint(0,5),random.randint(0,5),len(self.objects)) |
| - | i+=1 | + | i+=1 |
| - | self.maplist.append(list) | + | self.maplist.append(list) |
| - | value = True | + | value = True |
| - | print("Map wird nach rechts erweitert.") | + | print("Map wird nach rechts erweitert.") |
| #erweitert die Karte nach unten | #erweitert die Karte nach unten | ||
| - | if (self.player[pos].y<self.maplist[0][0].y): | + | if (self.player[pos].y<self.maplist[0][0].y): |
| - | #print(self.player[pos].y,"<",self.maplist[0][0].y) | + | #print(self.player[pos].y,"<",self.maplist[0][0].y) |
| - | i = 0 | + | i = 0 |
| - | k = self.maplist[0][0].x | + | k = self.maplist[0][0].x |
| - | l = self.maplist[0][0].y-self.chunksize | + | l = self.maplist[0][0].y-self.chunksize |
| - | list = [] | + | list = [] |
| - | for i in range(len(self.maplist[0])): | + | 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.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)) | + | list[0].generate(2,random.randint(0,5),random.randint(0,5),len(self.objects)) |
| - | i+=1 | + | i+=1 |
| - | value = True | + | value = True |
| - | self.maplist.insert(0,list) | + | self.maplist.insert(0,list) |
| - | print("Map wird nach unten erweitert.") | + | print("Map wird nach unten erweitert.") |
| #erweitert die Karte nach oben | #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()): | + | 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()) | + | #print(self.player[pos].y,">",self.maplist[len(self.maplist)-1][len(self.maplist[len(self.maplist)-1])-1].getendy()) |
| - | i = 0 | + | i = 0 |
| - | k = self.maplist[0][0].x | + | k = self.maplist[0][0].x |
| - | l = self.maplist[len(self.maplist)-1][len(self.maplist[len(self.maplist)-1])-1].y+self.chunksize | + | l = self.maplist[len(self.maplist)-1][len(self.maplist[len(self.maplist)-1])-1].y+self.chunksize |
| - | list = [] | + | list = [] |
| - | for i in range(len(self.maplist[0])): | + | for i in range(len(self.maplist[0])): |
| - | list.append(chunk(k+i*self.chunksize,l,self.chunksize,self.chunksize,self.overlay,5)) | + | 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)) | + | list[i].generate(2,random.randint(0,5),random.randint(0,5),len(self.objects)) |
| - | i+=1 | + | i+=1 |
| - | self.maplist.append(list) | + | self.maplist.append(list) |
| - | value = True | + | value = True |
| - | print("Map wird nach oben erweitert.") | + | print("Map wird nach oben erweitert.") |
| - | + | ||
| - | #Reset für die nächste Generation | + | #Reset für die nächste Generation |
| - | def nextstage(self,playerlist): | + | def nextstage(self,playerlist): |
| - | self.maplist.clear() | + | self.maplist.clear() |
| - | self.player.clear() | + | self.player.clear() |
| - | self.initiate() | + | self.initiate() |
| - | self.playerinitiate(playerlist) | + | self.playerinitiate(playerlist) |
| def werte(liste): | def werte(liste): | ||
| Zeile 445: | Zeile 459: | ||
| for oo in range(50): | for oo in range(50): | ||
| - | for i in range(playercount):#erstellt X Spieler | + | done = False |
| - | playerl.append(player(random.randint(mapsize*0.1,mapsize*0.9),random.randint(mapsize*0.1,mapsize*0.9),0,0,i)) | + | print("Generation:",oo) |
| + | time.sleep(5) | ||
| + | for i in range(500):#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)) | ||
| + | if not importlist: | ||
| + | q=0 | ||
| + | else: | ||
| + | playerl[i].parents((importlist[int(i%len(importlist))])) | ||
| + | map01.nextstage(playerl) | ||
| + | importlist.clear() | ||
| while not done: | while not done: | ||
| - | clock.tick(50) #Für größere Pausen zwischen den Runden | + | print("True") |
| + | 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(): |
| - | if event.type == pygame.QUIT: | + | if event.type == pygame.QUIT: |
| - | done =True | + | done =True |
| | | ||
| - | screen.fill((255,255,255)) #Setzt die Hintergrundfarbe | + | screen.fill((255,255,255)) #Setzt die Hintergrundfarbe |
| | | ||
| #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 | + | 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() |
| - | else: | + | else: |
| - | if len(map01.player)<=20: | + | if len(map01.player)<=20: |
| - | importlist.append(map01.player[e]) | + | importlist.append(map01.player[e].exportlist()) |
| - | #if len(map01.player)==1: | + | #parentlist.append(map01.player[e].exportlist()) |
| - | #print("Runde:",i) | + | #if len(map01.player)==1: |
| - | del map01.player[e] | + | #print("Runde:",i) |
| - | e-=1 | + | del map01.player[e] |
| - | e+=1 | + | e-=1 |
| + | e+=1 | ||
| | | ||
| - | print("------------") | + | print("------------") |
| #Falls nur noch ein Spieler existiert, wird seine Lebensdauer ausgegeben | #Falls nur noch ein Spieler existiert, wird seine Lebensdauer ausgegeben | ||
| - | if len(map01.player)==1: | + | if len(map01.player)==1: |
| - | print("Stamina:", map01.player[0].stamina) | + | print("Stamina:", map01.player[0].stamina) |
| - | time.sleep(0.1) | + | #time.sleep(0.1) |
| #Bei keine Spieler wird das Programm beendet | #Bei keine Spieler wird das Programm beendet | ||
| - | if len(map01.player)==0: | + | if len(map01.player)==0: |
| - | break | + | break |
| #Für die Map reichen diese drei Funktionen | #Für die Map reichen diese drei Funktionen | ||
| - | map01.playerupdate() #Überprüft alle Spieler auf ihren Chunk | + | map01.playerupdate() #Überprüft alle Spieler auf ihren Chunk |
| - | map01.hitbox() #Überprüft die Hitbox zu allen Objekten in diesem Chunk | + | map01.hitbox() #Überprüft die Hitbox zu allen Objekten in diesem Chunk |
| - | map01.drawobj() #Zeichnet alle Objekte | + | map01.drawobj() #Zeichnet alle Objekte |
| | | ||
| - | pygame.display.flip() | + | pygame.display.flip() |
| | | ||
| - | #print("Runde: ",i) #Gibt die Rundenanzahl aus | + | print("Runde: ",i) #Gibt die Rundenanzahl aus |
| - | i+=1 | + | i+=1 |
| - | parentlist = werte(importlist) | + | |
| print("Finished") #Programm ist beendet | print("Finished") #Programm ist beendet | ||
| </code> | </code> | ||
ss19/test.1561041894.txt.gz · Zuletzt geändert: 2019/06/20 16:44 von eric_m
Seiten-Werkzeuge
