Mathesis Wiki

import random
import pygame
import time
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 = 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.list = []
		self.status = True
    #Löscht den Spieler
	def __del__(self):
		if self.status == True:
			return self.list
		print("Player died")
		time.sleep(2)
	
    #bewegt den Spieler
	def move(self):
		self.x+=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)
		pygame.draw.rect(screen, (255,0, 0),self.rect)
		self.stamina-=1

	def parents(self,list):
		self.list = list

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:
					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
			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)):

                    #(bis jetzt) löscht das Objekt und erhöt Stamina um 250
					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]
					    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)

mapsize=1000 #Mapsize

playerl = [] #Spielerliste

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))

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
winner = []
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)<=int(playercount*0.1):
				winner.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


print("Finished") #Programm ist beendet