Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen gezeigt.

--- ss19:erstes_pygame_simulation_alex [2019/06/04 14:30]
alexanderdross angelegt
+++ ss19:erstes_pygame_simulation_alex [2019/06/20 14:45] (aktuell)
alexanderdross
@@ Zeile 1: / Zeile 1: @@
 <code>
-import pygame
 import random
+import pygame
+import time
 import math
 pygame.init()
-screen = pygame.display.set_mode((400, 300))
-done = False
-is_blue = True
-x = 30
-y = 30
-clock = pygame.time.Clock()
-walls=[]
-class Wall(object):
+#Klasse Objekt. Zunächst für alle Objekte auf der Map
-    size=5
-    def __init__(self, pos):
+class player:
-        walls.append(self)
-        self.x=pos[0]
+    #Initialisiert den Spieler
-        self.y=pos[1]
+	def __init__(self,x,y,angle,speed,name):
-        self.rect = pygame.Rect(pos[0], pos[1], self.size,self.size)
+		self.x=x #x-Pos
-animals=[]
+		self.y=y #y-Pos
-class Creature(object):
+		self.size = 5 #Größe
-    size=5
+		self.status = True #Aktiv oder nicht
-    sight=5
+		self.chunkpos = [] #Speichert die Position des Chunks
-    food=0
+		self.speed = 5 #Geschwindigkeit
-    veränderungx=0
+		self.stamina = 250 #Ausdauer
-    veränderungy=0
+		self.angle = angle #Laufwinkel
-    def __init__(self,x,y,angle,speed):
+		self.sight = 10 #Sichtweite
-        animals.append(self)
+		self.rect=pygame.Rect(int(self.x),int(self.y),self.size,self.size)#Rechteck in Pygame
-        self.x1=x
+		self.name=name #ID
-        self.y1=y
+		self.vx = 0#??
-        self.speed=5
+		self.vy = 0
-        self.stamina=250
+		self.v = False
-        self.angle=angle
+		self.viewangle = 60
-    def inrange(self):
+		self.objangle = 0
-        self.rect=pygame.Rect(int(self.x1)-int(self.sight),int(self.y1)-int(self.sight),self.sight*2+self.size,self.sight*2+self.size)
+		self.runlength=[]
-        if(self.rect.collidelist(walls)>-1):
+		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)
-            self.veränderungx=walls[self.rect.collidelist(walls)].x-self.x1
+		else:
-            self.veränderungy=walls[self.rect.collidelist(walls)].y-self.y1
+			self.speed=random.randint(0,5)
-            #self.x1=walls[self.rect.collidelist(walls)].x
+			self.x+=self.speed*math.sin(self.angle/180*math.pi)
-            #self.y1=walls[self.rect.collidelist(walls)].y
+			self.y+=self.speed*math.cos(self.angle/180*math.pi)
-i=0
+			self.rect=pygame.Rect(int(self.x),int(self.y),self.size,self.size)
-anzahlrect=150
+			pygame.draw.rect(screen, (255, 0, 0),self.rect)
-while(i<anzahlrect):
+			self.stamina-=1
-	x=random.randint(0,398)
+			self.runlength.append(self.speed)
-	y=random.randint(0,298)
+			self.runangle.append(self.angle)
-	Wall((x,y))
-	i+=1
-j=0
-anzahlanimal=50
-while(j<anzahlanimal):
-    x=200
-    y=150
-    speed=5
-    angle=random.randint(0,360)
-    Creature(x,y,angle,speed)
-    j+=1
-moveframes=5
+class object:
-while not done:
-        clock.tick(50)
-        for event in pygame.event.get():
-                if event.type == pygame.QUIT:
-                        done = True
-        i=0
-        durchlaeufe=0
-        screen.fill((0,100,50))
-        while(i<1):
-            for animal in animals:
-                animal.angle=random.randint(animal.angle-45,animal.angle+45)
-                #if(moveframes==5):
-                #    moveframes=0
-                if(durchlaeufe%5==0):
-                    x2=animal.x1+animal.speed*math.sin((animal.angle/180)*math.pi)
-                    y2=animal.y1+animal.speed*math.cos((animal.angle/180)*math.pi)
-                    animal.veränderungx=x2-animal.x1
-                    animal.veränderungy=y2-animal.y1
-                    animal.inrange()
-                #pygame.draw.line(screen,(255,0,0),(animal.x1,animal.y1),(x2,y2))
-                animal.x1+=animal.veränderungx/moveframes
-                animal.y1+=animal.veränderungy/moveframes
-                #pygame.draw.circle(screen,(255,0,0),(int(animal.x1),int(animal.y1)),5)
-                arect=pygame.Rect(int(animal.x1),int(animal.y1),animal.size,animal.size)
-                if arect.collidelist(walls)>=0:
-                    animal.food+=1
-                    del(walls[arect.collidelist(walls)])
-                    animal.stamina+=50
-                    if(animal.food%2==0):
-                        Creature(animal.x1,y,animal.angle,animal.speed)
-                pygame.draw.rect(screen,(255,0,0),arect)
-                animal.stamina-=animal.speed/5
-            j=0
-            durchlaeufe+=1
-            while j< len(animals):
-                if(animals[j].stamina<=0):
-                    del(animals[j])
-                j+=1
-            i+=1
-        for wall in walls:
-            pygame.draw.rect(screen, (255, 0, 255), wall.rect)
+    #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
-        pygame.display.flip()
+			#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

Unterschiede

Seiten-Werkzeuge