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
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
<code\>
Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
