示例#1
0
    def endstep(self, game, state, frametime):
        
        player = self.get_player(game, state)
        # check if we are on the ground before moving (for walking over 1 unit walls)
        onground = True

        # first we move, ignoring walls
        self.x += self.hspeed * frametime
        # if we are in a wall now, we must move back

        if game.map.collision_mask.overlap(self.collision_mask, (int(self.x), int(self.y))):
            # but if we just walked onto a one-unit wall it's ok
            # but we had to be on the ground
            if onground and not game.map.collision_mask.overlap(self.collision_mask, (int(self.x), int(self.y - 6))):
                while game.map.collision_mask.overlap(self.collision_mask, (int(self.x), int(self.y))):
                    self.y -= 1
            # but sometimes we are so fast we will need to take two stairs at the same time
            elif onground and not game.map.collision_mask.overlap(self.collision_mask, (int(self.x), int(self.y - 12))) and game.map.collision_mask.overlap(self.collision_mask, (int(self.x - 6 * function.sign(self.hspeed)), int(self.y))):
                while game.map.collision_mask.overlap(self.collision_mask, (int(self.x), int(self.y))):
                    self.y -= 1
            else:
                self.x = math.floor(self.x) # move back to a whole pixel - TODO math.floor/math.ceil depending on direction

                # and if one pixel wasn't enough
                while game.map.collision_mask.overlap(self.collision_mask, (int(self.x), int(self.y))):
                    self.x -= function.sign(self.hspeed)

                self.hspeed = 0
            
            
        #downward stairscript with hspeed checks
        if onground and not game.map.collision_mask.overlap(self.collision_mask, (int(self.x), int(self.y + 6))):
            if game.map.collision_mask.overlap(self.collision_mask, (int(self.x), int(self.y + 7))):
                self.y += 6
            elif game.map.collision_mask.overlap(self.collision_mask, (int(self.x), int(self.y + 13))):
                if (self.hspeed !=0):
                    if game.map.collision_mask.overlap(self.collision_mask, (int(self.x + function.sign(self.hspeed)*-6), int(self.y + 7))) and not game.map.collision_mask.overlap(self.collision_mask, (int(self.x + 6), int(self.y + 1))):
                        self.y += 12

        # same stuff, but now vertically
        self.y += self.vspeed * frametime

        if game.map.collision_mask.overlap(self.collision_mask, (int(self.x), int(self.y))):
            self.y = float(int(self.y))

            while game.map.collision_mask.overlap(self.collision_mask, (int(self.x), int(self.y))):
                self.y -= function.sign(self.vspeed)

            self.vspeed = 0

        player.last_left = player.left;
        player.last_right = player.right;
示例#2
0
文件: projectile.py 项目: PyGG2/PyGG2
    def step(self, game, state, frametime):
        # FIXME: MAKE THIS WORK FOR NEGATIVE frametime!
        # GMK-GG2 tried to emulate basic acceleration and air resistance with two simple instructions:
        #   [execute 30 times per second]
        #   speed += 1
        #   speed *= 0.92
        # Underneath is the same thing converted to work with frametime.
        # PS: If you ever have the chance, please bash whoever had the idea of a non-standard exponential function for a rocket in an 8-bit game on the head. Thank you.
        self.speed /= 30
        n = 30 * frametime
        self.speed = (0.92**n) * self.speed + 0.92*((1 - (0.92**n))/(1 - 0.92))
        self.speed *= 30

        self.hspeed = math.cos(math.radians(self.direction)) * self.speed * function.sign(frametime)
        self.vspeed = math.sin(math.radians(self.direction)) * (-self.speed) * function.sign(frametime)
示例#3
0
    def step(self, game, state, frametime):
        player = self.get_player(game, state)

        # this is quite important, if hspeed / 20 drops below 1 self.animoffset will rapidly change and cause very fast moving legs (while we are moving very slow)
        if abs(self.hspeed) > 20:
            self.animoffset += frametime * abs(self.hspeed) / 20
            self.animoffset %= 2
        if abs(self.hspeed) == 0:
            self.animoffset =0

        self.flip = not (player.aimdirection < 90 or player.aimdirection > 270)

        # if we are holding down movement keys, move
        if player.left: self.hspeed -= self.acceleration * frametime
        if player.right: self.hspeed += self.acceleration * frametime

        # Friction:
        if abs(self.hspeed) < 10: self.hspeed = 0
        else: self.hspeed -= function.sign(self.hspeed) * min(abs(self.hspeed), 600 * frametime)

        if player.up:
            self.jump(game, state)

        # gravitational force
        self.vspeed += 300 * frametime

        # TODO: air resistance, not hard limit
        self.vspeed = min(800, self.vspeed)

        self.hspeed = min(self.max_speed, max(-self.max_speed, self.hspeed))
示例#4
0
文件: character.py 项目: PyGG2/PyGG2
    def endstep(self, game, state, frametime):

        player = self.get_player(state)
        # check if we are on the ground before moving (for walking over 1 unit walls)
        onground = True

        # first we move, ignoring walls
        self.x += self.hspeed * frametime
        # if we are in a wall now, we must move back

        if state.map.collision_mask.overlap(self.collision_mask, (int(round(self.x)), int(round(self.y)))):
            # but if we just walked onto a one-unit wall it's ok
            # but we had to be on the ground
            if onground and not state.map.collision_mask.overlap(self.collision_mask, (int(round(self.x)), int(round(self.y - 6)))):
                while state.map.collision_mask.overlap(self.collision_mask, (int(round(self.x)), int(round(self.y)))):
                    self.y -= 1
            # but sometimes we are so fast we will need to take two stairs at the same time
            elif onground and not state.map.collision_mask.overlap(self.collision_mask, (int(round(self.x)), int(round(self.y - 12)))) and state.map.collision_mask.overlap(self.collision_mask, (int(round(self.x - 6 * function.sign(self.hspeed))), int(round(self.y)))):
                while state.map.collision_mask.overlap(self.collision_mask, (int(round(self.x)), int(round(self.y)))):
                    self.y -= 1
            else:
                if self.hspeed < 0:
                    self.x = math.floor(self.x) # move back to a whole pixel
                else:
                    self.x = math.ceil(self.x)
                # and if one pixel wasn't enough
                while state.map.collision_mask.overlap(self.collision_mask, (int(round(self.x)), int(round(self.y)))):
                    self.x -= function.sign(self.hspeed) * function.sign(frametime)

                self.hspeed = 0

        # same stuff, but now vertically
        self.y += self.vspeed * frametime

        if state.map.collision_mask.overlap(self.collision_mask, (int(round(self.x)), int(round(self.y)))):
            self.y = float(round(self.y))

            while state.map.collision_mask.overlap(self.collision_mask, (int(round(self.x)), int(round(self.y)))):
                self.y -= function.sign(self.vspeed) * function.sign(frametime)

            self.vspeed = 0
        
        player.last_left = player.left
        player.last_right = player.right
示例#5
0
    def destroy(self, game, state, frametime):
        if not self.max_flight_time - self.flight_time < self.fade_time:
            for obj in state.entities.values():
                if (
                    isinstance(obj, character.Character)
                    and math.hypot(self.x - obj.x, self.y - obj.y) < self.blastradius
                ):

                    # w and h are the width and height of the collision mask of the character
                    w, h = obj.collision_mask.get_size()

                    # x and y are here a vector from the rocket to the character
                    x = self.x - obj.x
                    y = self.y - obj.y

                    # we try to find out the crosspoint of that vector with the collision rectangle
                    f = w / (2 * x)
                    if abs(f * y) < h / 2:
                        # the vector crosses the rectangle at the sides
                        x = function.sign(x) * w / 2
                        y *= f
                    else:
                        # the vector crosses the rectangle at the bottom or top
                        f = h / (2 * y)
                        x *= f
                        y = function.sign(y) * h / 2

                    # x and y are now the positions of the point on the edge of the collision rectangle nearest to the rocket

                    # now get the vector from the rocket to that point, and store it in x and y
                    x = (obj.x + x) - self.x
                    y = (obj.y + y) - self.y

                    length = math.hypot(x, y)
                    force = (1 - (length / self.blastradius)) * self.knockback
                    obj.hspeed += force * (x / length)
                    obj.vspeed += force * (y / length)

        super(Rocket, self).destroy(state)