Overflown/gamedata/objects/ingame/tileset.py

from gamedata.objects.base import BaseObject
from gamedata.objects.ingame.ennemies.robot import Robot
from gamedata.objects.ingame.ennemies.crate import Crate
from gamedata.objects.ingame.ennemies.balloon import Balloon
from gamedata.objects.ingame.ennemies.spring import Spring
from gamedata.objects.ingame.ennemies.waterchange import WaterChange
from gamedata.objects.levels import Levels

class TilesetRenderer(BaseObject):

    def __init__(self,x,y,game,mapfoldername):

        super().__init__(x,y,game)

        self.tilew = 64
        self.tileh = 64

        self.level = game.levels_lib[mapfoldername]
        self.reinit(self.level)

        self.bgs = [game.sprite_lib["fallbackground.png"]]
        if len(self.level["backgrounds"]):
            self.bgs = self.level["backgrounds"]

        self.bgoffset = self.layers[0]["surface"].get_height()/2-self.game.globals["camerah"]

        # Prescale backgrounds
        self.sep = self.game.pygame.transform.scale(self.game.sprite_lib["backgroundseparator.png"],[self.game.globals["cameraw"],self.game.globals["camerah"]])
        self.scaledbgs = []
        wratio = self.game.globals["cameraw"]/self.bgs[0]["sprite"].get_width()
        hratio = self.game.globals["camerah"]/self.bgs[0]["sprite"].get_height()
        for bg in self.bgs:
            width, height = round(bg["sprite"].get_width()*wratio),round(bg["sprite"].get_height()*hratio)
            sprite = self.game.pygame.transform.scale(bg["sprite"],(width,height))
            self.scaledbgs.append(sprite)


    def step(self):
        # Spawning ennemies
        while len(self.queue)>0:
            props = self.queue.pop()
            e = props[0](props[1],props[2],self.game,props[3],props[4])
            self.game.gameloop.summon(e)

    def draw(self):
        lastoffset = 0
        for i,bg in enumerate(self.scaledbgs):
            ratio = 1-(len(self.bgs)-i)/len(self.bgs)
            width = bg.get_width()
            height = bg.get_height()
            nbs = self.game.globals["cameraw"]/width
            lastoffset = self.rect[1]+(self.bgoffset-self.game.globals["cameray"])*ratio
            for i in range(round(nbs+0.5)):
                self.game.window.blit(bg,[(-self.game.globals["camerax"]*ratio)%width+(i-1)*width,lastoffset])
        # Draw filler
        if self.level["filler"]:
            filleroffset = lastoffset+height
            self.game.window.blit(self.level["filler"],[0,filleroffset])
        # Separator
        self.game.window.blit(self.sep,[0,0])
        # Layers
        for layer in self.layers:
            self.game.window.blit(layer["surface"],(layer["offsets"][0]-self.game.globals["camerax"],layer["offsets"][1]-self.game.globals["cameray"]))

    def reinit(self,level):
        json = level["data"]
        name = level["name"]
        self.rects = []
        self.semirects = []
        self.layers = []
        self.spawns = []
        spawnlists = {"Spawns":self.spawns}
        ennemies = {"Robot":Robot,"Crate":Crate,"Balloon":Balloon,"Spring":Spring,"WaterChange":WaterChange,"Levels":Levels}
        self.queue = [] # For spawning ennemies after beeing initialized
        if "layers" in json.keys() and type(json["layers"]).__name__=="list":
            solidlayer = False
            for layer in json["layers"]:
                #try:
                if True:
                    if layer["name"] == "Solids" and "entities" in layer.keys() : # Je trouve les collisions
                        solidlayer = layer
                    elif layer["name"] == "Spawns" and "entities" in layer.keys() : # Je trouve les spawns
                        for entity in layer["entities"]:
                            x,y = entity["x"],entity["y"]
                            w,h = layer["gridCellWidth"],layer["gridCellHeight"]
                            if "width" in entity.keys():
                                w = entity["width"]
                            if "height" in entity.keys():
                                h = entity["height"]
                            spawnlists[entity["name"]].append(self.game.pygame.Rect((x,y,w,h)))

                    elif layer["name"] == "Ennemies" and "entities" in layer.keys():
                        for entity in layer["entities"]:
                            x,y = entity["x"],entity["y"]
                            nodes = []
                            customvalues = {}
                            if "nodes" in entity.keys():
                                nodes = entity["nodes"]
                            if "values" in entity.keys():
                                customvalues = entity["values"]
                            self.queue.append((ennemies[entity["name"]],x,y,nodes,customvalues))


                    else: # J'ajoute un layer de tiles
                        tileset = level["tilesets"][layer["tileset"]]
                        tilew,tileh = layer["gridCellWidth"],layer["gridCellHeight"]
                        tileoffx,tileoffy = layer["offsetX"],layer["offsetY"]
                        nbtilesx,nbtilesy = layer["gridCellsX"],layer["gridCellsY"]
                        storedlayer = {"offsets":[tileoffx,tileoffy],"name":layer["name"]}
                        surface = self.game.pygame.Surface((tilew*nbtilesx,tileh*nbtilesy),flags=self.game.pygame.SRCALPHA)
                        for y in range(len(layer["dataCoords2D"])):
                            for x in range(len(layer["dataCoords2D"][y])):
                                coords = layer["dataCoords2D"][y][x]
                                if len(coords)>1:
                                    areatocopy = [coords[0]*tilew,coords[1]*tileh,tilew,tileh]
                                    surface.blit(tileset,(x*tilew,y*tileh),area=areatocopy)
                        storedlayer["surface"] = surface
                        self.layers.append(storedlayer)
                #except:
                else:
                    self.game.log("Erreur",name,"Les layers sont invalides")
            if solidlayer: # Je crée les collisions
                if "gridCellWidth" in solidlayer.keys() and "gridCellHeight" in solidlayer.keys():
                    self.solidtilew = solidlayer["gridCellWidth"]
                    self.solidtileh = solidlayer["gridCellHeight"]
                else:
                    self.solidtilew,self.solidtileh = 32,32
                    self.game.log("Erreur",name,"Pas de taille de tiles précisée, défaut à 32x32")
                for entity in solidlayer["entities"]:
                    try:
                        x,y = entity["x"],entity["y"]
                        w,h = self.solidtilew,self.solidtileh
                        if "width" in entity.keys():
                            w = entity["width"]
                        if "height" in entity.keys():
                            h = entity["height"]
                        lists = {"Solid":self.rects,"SemiSolid":self.semirects}
                        lists[entity["name"]].append(self.game.pygame.Rect(x,y,w,h))
                    except:
                        self.game.log("Erreur",name,entity,"Propriétés invalides")
            else:
                self.game.log("Erreur",name,"Il manque les collisions, Entity Layer nommé Solids")

            self.layers.sort(key=lambda x: x["name"])
            self.layers.reverse()
        else:
            self.game.log("Erreur",name,"Pas de layers")