Mathesis Wiki

Dies ist eine alte Version des Dokuments!

<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¹⁾ #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>

¹⁾ 1000,1000

Mathesis Wiki

Seitenleiste

Navigation

Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seitenleiste

Navigation

Seiten-Werkzeuge