Benutzer-Werkzeuge
Seitenleiste
ss19:test
Dies ist eine alte Version des Dokuments!
import random
import pygame
import time
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 = 1 #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.runlength=[]
self.runangle=[]
self.status = True
#Löscht den Spieler
def __del__(self):
if self.status == True:
return self.list
print("Player died")
time.sleep(2)
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:
if self.v == True:
a = random.randint(0,len(parentlist[0]))
else :
a = random.randint(0,len(parentlist[1]))
self.x+=parentlist[a][0]*math.cos(parentlist[a][1]/180*math.pi)
self.y+=parentlist[a][0]*math.sin(parentlist[a][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):
return [self.runlength,self.runangle,self.percent]
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.00125 #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:
impotlist.append(self.player[q].eportlist())
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):
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])
#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
parentlist = werte(importlist)
print("Finished") #Programm ist beendet
ss19/test.1561041894.txt.gz · Zuletzt geändert: 2019/06/20 16:44 von eric_m
Seiten-Werkzeuge
