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

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 = [] #Speichert die Position des Chunks
		self.speed = 5 #Geschwindigkeit
		self.stamina = 250 #Ausdauer
		self.angle = angle #Laufwinkel        
		self.sight = 10 #Sichtweite
		self.rect=pygame.Rect(int(self.x),int(self.y),self.size,self.size)#Rechteck in Pygame        
		self.name=name #ID        
		self.vx = 0#??
		self.vy = 0
		self.v = False
		self.viewangle = 60
		self.objangle = 0
		self.runlength=[]
		self.runangle=[]
	
    #Löscht den Spieler
	def __del__(self):
		
		a=0
	
	
	def sightcheck(self,dist,alpha):
		self.objangle = alpha
		#print(dist)
		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.v = True
					self.angle=alpha
					#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.v = True
					#print(self.v)
					self.angle=alpha
			else:
				if self.angle%360-self.viewangle <= alpha <= self.angle+self.viewangle:
					self.v = True
					#print(self.v)
					self.angle=alpha
    #bewegt den Spieler
	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
		if self.v == False:
			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:
			self.speed=random.randint(0,5)
			self.x+=self.speed*math.sin(self.angle/180*math.pi)
			self.y+=self.speed*math.cos(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)

class object:

    #Initialisiert den Spieler
	def __init__(self,x,y,sizex,sizey,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 = 5 #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.7 #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,numb,length,height,name):
			for i in range(numb):
				if random.random()<=self.density:
					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))

#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,listobj,playerlist,size,sizechunk):
		self.objects = listobj
		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.playerinitiate()
	
    #Initilisiert die Grundmap, sowie weist jedem Chunk die Objekte hinzu
	def initiate(self):
		preobject = self.objects.copy()
		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
				for qq in range(len(preobject)):

					#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)
			del line
		print("Objects ready!")
		print("")
	
    #weist jedem Spieler den Chunk hinzu in welchem dieser sich befindet
	def playerinitiate(self):
		#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
		for q in range(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 = self.maplist[0][0].x #kleinste x-Pos der Chunks
				y0 = self.maplist[0][0].y #kleinste y-Pos der Chunks
				xn = self.maplist[0][len(self.maplist[0])-1].getendx() #größte x-Pos der Chunks
				yn = self.maplist[len(self.maplist)-1][0].getendy() #größte x-Pos der Chunks

                #Falls der Spieler außerhalb der Map ist, wird diese erweitert.
				if x < x0:
					#self.map_increase(q)
					x = int(self.worldsize/2)
					x0 = self.maplist[0][0].x
				elif xn < x:
					#self.map_increase(q)
					x = int(self.worldsize/2)
					xn = self.maplist[0][len(self.maplist[0])-1].x
				if y < y0:                    
					#self.map_increase(q)
					y = int(self.worldsize/2)
					y0 = self.maplist[0][0].y
				elif yn < y:
					#self.map_increase(q)
					y = int(self.worldsize/2)
					yn = self.maplist[len(self.maplist)-1][0].y

				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-1-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-1-int(y0/10)

    #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
			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[i].generate(2,random.randint(0,5),random.randint(0,5),len(self.objects))
			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[len(self.maplist)-1])):
				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))
			self.maplist.append(list)
			value = True
			print("Map wird nach oben erweitert.")

mapsize=1000 #Mapsize
listobj = [] #Objektliste
playerl = [] #Spielerliste

clock = pygame.time.Clock()



for i in range(500):#erstellt X Spieler
	playerl.append(player(random.randint(0,mapsize),random.randint(0,mapsize),0,0,i))

for i in range(500):#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

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

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
	while e <len(map01.player) and e>=0:
		if map01.player[e].stamina>0:
			map01.player[e].move()
			e+=1
		else:
			del map01.player[e]
			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
