Overflown/gamedata/objects/combat/player.py

from gamedata.objects.base import BaseObject

class Player(BaseObject):

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

        self.sprite = game.sprite_lib["icon.png"]

        super().__init__(x,y,game,self.sprite.get_width(),self.sprite.get_height())

        tileset = game.gameloop.findname("TilesetRenderer")[0]
        self.grid = tileset.collisiongrid
        self.tilew = tileset.tilew
        self.tileh = tileset.tileh

        self.speed = 300

        self.gravity = 800
        self.maxgrav = 400
        self.jump = -400
        self.vertical = self.maxgrav

    def step(self):
        keys = self.game.inputs["keys"]
        hor=keys["right"]["pressed"]-keys["left"]["pressed"]

        # Check if on ground
        self.onground = False
        targetpos = self.getgridpos(0,1)
        pos = [targetpos["dl"],targetpos["dr"]]
        for x in range(pos[0]["x"],pos[1]["x"]+1):
            if pos[0]["y"]>=0 and pos[0]["y"]<len(self.grid):
                if x>=0 and x<len(self.grid[pos[0]["y"]]):
                    if self.grid[pos[0]["y"]][x]==1:
                        self.onground = True
                        break

        # Check if under ceiling
        self.onceiling = False
        targetpos = self.getgridpos(0,-1)
        pos = [targetpos["ul"],targetpos["ur"]]
        for x in range(pos[0]["x"],pos[1]["x"]+1):
            if pos[0]["y"]>=0 and pos[0]["y"]<len(self.grid):
                if x>=0 and x<len(self.grid[pos[0]["y"]]):
                    if self.grid[pos[0]["y"]][x]==1:
                        self.onceiling= True
                        break

        if not self.onground:
            self.vertical += self.gravity*self.game.dt
            self.vertical = min(self.maxgrav,self.vertical)
        else:
            if keys["up"]["timer"]==1:
                self.vertical = self.jump
            else:
                self.vertical = 0

        if self.onceiling and self.vertical < 0:
            self.vertical = 0

        self.move(hor*self.speed*self.game.dt,self.vertical*self.game.dt)

    def getgridpos(self,modx=0,mody=0):
        result = {}

        result["ul"] = {}
        result["ul"]["y"] = int((self.rect[1]+mody)/self.tileh)
        result["ul"]["x"] = int((self.rect[0]+modx)/self.tilew)

        result["ur"] = {}
        result["ur"]["y"] = result["ul"]["y"]
        result["ur"]["x"] = int((self.rect[0]+self.rect[2]+modx)/self.tilew)

        result["dl"] = {}
        result["dl"]["y"] = int((self.rect[1]+self.rect[3]+mody)/self.tileh)
        result["dl"]["x"] = result["ul"]["x"]

        result["dr"] = {}
        result["dr"]["y"] = result["dl"]["y"]
        result["dr"]["x"] = result["ur"]["x"]

        return result

    def move(self,hor,ver):
        if hor>0:
            colpoints = ["ur","dr"]
        elif hor<0:
            colpoints = ["ul","dl"]
        hstoped = False
        while abs(hor)>0:
            if abs(hor)>self.tilew:
                diffx = self.tilew*abs(hor)/hor
            else:
                diffx = hor
            newpos = self.getgridpos(diffx,0) # Future position
            canmove = True
            upy = newpos[colpoints[0]]["y"]
            downy = newpos[colpoints[1]]["y"]
            for posy in range(upy,downy+1): # Je vérifie qu'elle n'est pas en colision
                x = newpos[colpoints[0]]["x"]
                if posy>=0 and posy < len(self.grid):
                    if x>=0 and x < len(self.grid[posy]):
                        if self.grid[posy][x]==1:
                            canmove = False
                            break
            if canmove:
                hor-=diffx
                self.rect[0]+=diffx
            else:
                hstoped = True
                hor = 0

        if ver>0:
            colpoints = ["dl","dr"]
        elif ver<0:
            colpoints = ["ul","ur"]
        vstoped = False
        while abs(ver)>0:
            if abs(ver)>self.tileh:
                diffy = self.tileh*abs(ver)/ver
            else:
                diffy = ver
            newpos = self.getgridpos(0,diffy) # Future position
            canmove = True
            leftx = newpos[colpoints[0]]["x"]
            rightx = newpos[colpoints[1]]["x"]
            for posx in range(leftx,rightx+1): # Je vérifie qu'elle n'est pas en colision
                y = newpos[colpoints[0]]["y"]
                if y>=0 and y<len(self.grid):
                    if posx>=0 and posx<len(self.grid[y]):
                        if self.grid[y][posx]==1:
                            canmove = False
                            break
            if canmove:
                ver-=diffy
                self.rect[1]+=diffy
            else:
                vstoped = True
                ver = 0