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.ingame.ennemies.trashbag import TrashBag
from gamedata.objects.ingame.ennemies.squid import Squid
from gamedata.objects.ingame.ennemies.shooter import Shooter
from gamedata.objects.ingame.endflag import EndFlag
from gamedata.objects.levels import Levels
from gamedata.objects.ripple import Ripple

class TilesetRenderer(BaseObject):

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

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

        self.tilew = 64
        self.tileh = 64
        self.depth = -2

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

        self.game.globals["totaltrashes"] = 0
        self.game.globals["trashes"] = 0
        self.game.globals["timer"] = 0

        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(max(nbs+0.5,2))):
                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.spikes = []
        self.layers = []
        self.spawns = []
        self.bgm = None
        if self.game.globals["levelname"]!=None and not self.game.globals["overworld"]:
            self.bgm = self.game.sound_lib["bgm/"+self.game.globals["bgms"][self.game.globals["levelname"]]]
        if self.bgm:
            self.bgm.play(-1)
        spawnlists = {"Spawns":self.spawns}
        ennemies = {"Robot":Robot,"Crate":Crate,"Balloon":Balloon,"Spring":Spring,"WaterChange":WaterChange,"Levels":Levels,"End":EndFlag,"TrashBag":TrashBag,"Ripple":Ripple,"Squid":Squid,"Shooter":Shooter}
        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,"Spikes":self.spikes}
                        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")