import random

#Klasse Objekt. Zunächst für alle Objekte auf der Map
class object:

    def __init__(self,x,y,sizex,sizey,name):
        self.x=x
        self.y=y
        self.sizex=sizex
        self.status = True
        self.sizey=sizey
        self.name=name
        self.chunkpos = []
        
    
    def __del__(self):
        a=0

#Klasse Chunk
class chunk:
    x = 0
    y = 0
    length = 0
    height = 0
    overlay = 0 #Wie stark sich die verschiedenen Chunks überlappen
    name = 0
    
    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.name = name
        self.objects = [] 
        self.density = 0.7
    
    def newobj(self,obj):
        self.objects.append(obj)  
        
    def hello(self):
        print("Hello")

    def getendx(self):
        return self.x+self.length

    def getendy(self):
        return self.y+self.height

    def __del__(self):
        a = 0
        
    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
    
    def __init__(self,listobj,playerlist,size,sizechunk):
        self.objects = listobj
        self.worldsize = size
        self.chunksize = sizechunk
        self.overlay = sizechunk*0.1
        self.player = playerlist
        self.faktor = int(size/sizechunk)
        self.maplist = []
        self.initiate()
        self.playerinitiate()
        
    
    def initiate(self):
        preobject = self.objects.copy()
        factor = int(self.worldsize/self.chunksize)
        print(factor)
        line = []
        R = 0
        #Durchläuft die y-Richtung der Chunks
        for i in range(factor):
            

            #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+i*factor].x) <= preobject[qq].x <= (line[e+i*factor].getendx()) and (line[e+i*factor].y) <= preobject[qq].y <= (line[e+i*factor].getendy()):
                        R+=1
                        #print((line[e+i*factor].x)," <= ",preobject[qq].x," <= ",(line[e+i*factor].getendx())," and ",(line[e+i*factor].y)," <= ",preobject[qq].y," <= ",(line[e+i*factor].getendy()))
                        line[e+i*factor].newobj(preobject[qq])
                        print("Zahl:",e+i*factor,"/",R,"/",len(line[e+i*factor].objects))
                        #print(a)
                        preobject[qq].status = False
                    
                #Entfernt alle Objekteaus der Liste, die in einem Chunk sind
                for ee in range(len(preobject)):
                    for eee in range(len(preobject)):
                        if preobject[eee].status == False:
                            del preobject[eee]
                            break

                #line.append(a)

                #Fehlersucheprints
                #print("Anzahl der restlichen Objekte:",len(preobject))
                #print("e:",e+i*factor)                
                #print("Anzahl der Objekte im Chunk:",len(line[e+i*factor].objects))
                #print(line[e].objects)    
                #print("------------------------")
                #del a
                #print("R:",R)
        print("Ende:",len(line))                
        for i in range(int(len(line)/factor)):
            line2 = []
            for e in range(int((len(line)/factor))):
                #print(len(line[int(e+i*len(line)/factor)].objects))
                line2.append(line[int(e+i*len(line)/factor)])
            
            #print(len(line2))
            self.maplist.append(line2)    
        #self.maplist.append(line)
        del line
            
        print("")
            
    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])):
                    #print(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())
                    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
    
    def playerupdate(self):
        #Durchläuft die Liste der Player
        for q in range(len(self.player)):
            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].x+self.maplist[i][e].length and self.maplist[i][e].y <= self.player[q].y <= self.maplist[i][e].y+self.maplist[i][e].height:
                break
            #sonst schaut er in allen nächstliegenden Chunks nach dem Spieler.
            else:
                for w in range(-1,2):
                    j = False
                    for r in range(-1,2):
                        if self.maplist[i-w][e-r].x <= self.player[q].x <= self.maplist[i-w][e-r].x+self.maplist[i-w][e-r].length and self.maplist[i-w][e-r].y <= self.player[q].y <= self.maplist[i-w][e-r].y+self.maplist[i-w][e-r].height:
                            self.player[q].chunkpos[0] = i-w
                            self.player[q].chunkpos[1] = e-r
                            j = True
                            break
                    if j == True:
                        break
                    
    def hitbox(self):
        #Durchläuft jeden Spieler
        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
            for t in range(len(self.maplist[q][w].objects)):                
                #Wenn ein Objekt gelöscht wird, geht er die Liste nochmal durch
                for e in range(len(self.maplist[q][w].objects)):
                    if self.maplist[q][w].objects[e].x <= self.player[i].x <= self.maplist[q][w].objects[e].x+self.maplist[q][w].objects[e].length and self.maplist[q][w].objects[e].y <= self.player[i].y <= self.maplist[q][w].objects[e].y+self.maplist[q][w].objects[e].height:
                        del self.maplist[q][w].objects[e]#Veränderbare Hitbox
                        break
                if a == len(self.maplist[q][w].objects):
                    break
                else:
                    a-=1

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

    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))
                    #print(self.maplist[i][e].objects[q])
                #a=0
           #print("-----")
           #print("")
           
    def map_increase(self,pos):
        print(len(self.maplist))
        print(len(self.maplist[0]))
        print("------------------------")
        if (self.player[pos].x>self.maplist[0][0].x):
            line = []
            for i in range(len(self.maplist[0])):
                q = chunk(-self.maplist[0][0].x,self.maplist[0][0].y+i*self.chunksize,self.chunksize,self.chunksize,self.overlay,5)
                q.generate(10,random.randint(0,5),random.randint(0,5),len(self.objects))
                line.append(q)
            a = []
            a.append(line)
            for i in range(len(self.maplist)):
                a.append(self.maplist[i])
            self.maplist = a
        print(len(self.maplist))
        print(len(self.maplist[0]))
        print("------------------------")
        if (self.player[pos].x<self.maplist[0][len(self.maplist[0])-1].x):
            line = []
            for i in range(len(self.maplist[0])):
                q = chunk(self.maplist[0][len(self.maplist[0])-1].x,self.maplist[0][0].y+i*self.chunksize,self.chunksize,self.chunksize,self.overlay,5)
                q.generate(100,random.randint(0,5),random.randint(0,5),len(self.objects))
                line.append(q)
            self.maplist.append(line)
            a.append(line)
        print(len(self.maplist))
        print(len(self.maplist[0]))
        print("------------------------")
        if (self.player[pos].y>self.maplist[0][0].y):
            line = []
            for i in range(len(self.maplist[0])):
                q = chunk(self.maplist[0][0].x+i*self.chunksize,-self.maplist[0][0].y,self.chunksize,self.chunksize,self.overlay,5)
                q.generate(100,random.randint(0,5),random.randint(0,5),len(self.objects))
                line.append(q)
            a = []
            c = []
            for i in range(len(self.maplist[0])):
                a.append(line[i])
                print(a)
                print("----")
                a.append(self.maplist[i])
            c.append(a)
            self.maplist = c
        print(len(self.maplist))
        print(len(self.maplist[0]))
        print("------------------------")
        if (self.player[pos].y<self.maplist[0][len(self.maplist[0])-1].y):
            line = []
            for i in range(len(self.maplist[0])):
                q = chunk(self.maplist[0][0].x+i*self.chunksize,self.maplist[0][len(self.maplist[0])-1].y,self.chunksize,self.chunksize,self.overlay,5)
                q.generate(100,random.randint(0,5),random.randint(0,5),len(self.objects))
                line.append(q)
                self.maplist[i].append(q)
        print(len(self.maplist))
        print(len(self.maplist[0]))
        print("------------------------")


mapsize=1000    
listobj = []
playerl = []

for i in range(5):
    playerl.append(object(random.randint(0,mapsize),random.randint(0,mapsize),0,0,i))
    listobj.append(object(random.randint(0,mapsize),random.randint(0,mapsize),random.randint(0,5),random.randint(0,5),i))
 
map01 = map(listobj,playerl,mapsize,int(0.1*mapsize))
#map01.showp()
map01.map_increase(0)