Python Rect.move_ip方法代码示例

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import move_ip [as 别名]
class Select(Sprite):
    def __init__(self):
        Sprite.__init__(self)
        self.image = pygame.image.load('images/selector.png').convert()
        self.image.set_colorkey(PUCE, RLEACCEL)
        self.rect=Rect(10, 10, 30, 30)
        self.index = 0

    def setX(self, x):
        newpos = (self.rect.topleft[0] + x)
        if (newpos > 0) and (newpos < COLUMNS * 40 + 10):
            self.rect.move_ip(x,0)
            if x > 0:
                self.index += 1
            else:
                self.index -= 1

    def setY(self, y):
        newpos = (self.rect.topleft[1] + y)
        if (newpos > 0) and (newpos < ROWS * 40 + 10):
            self.rect.move_ip(0, y)
            if y > 0:
                self.index += COLUMNS
            else:
                self.index -= COLUMNS

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import move_ip [as 别名]
 def nearest_edge(self, x, y):
     """ The nearest lot boundary on which a fence might be erected """
     lot = self.nearest_lot(x, y)
     if not lot:
         return None
     proximities = [(y - lot.top,"north"),
                    (lot.bottom-y,"south"),
                    (lot.right-x,"east"),
                    (x-lot.left,"west")]
     proximities.sort()
     closest = proximities[0]
     dist,side = closest
     if dist > EDGE_TOLERANCE:
         return None
     horizontal = (side=="north" or side=="south")
     vertical = (side=="east" or side=="west")
     if horizontal:
         rect = Rect(lot.left, lot.top - FENCE_MARGIN_NORTH, lot.width, 2*FENCE_MARGIN_NORTH)
         if side == "south":
             rect.move_ip(0, LOT_DEPTH)
         if not WATER_RECT.colliderect(rect):
             return rect
     elif vertical:
         rect = Rect(lot.left - FENCE_MARGIN_WEST, lot.top, 2*FENCE_MARGIN_WEST, lot.height)
         if side == "east":
             rect.move_ip(LOT_WIDTH, 0)
         if not WATER_RECT.colliderect(rect):
             return rect

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import move_ip [as 别名]
class Player(Animated):
    """
    An instance is compatible with the level manager. Note that if
    :func:`rapidpg.levelmgr.collision.Level.update` is not used, a player
    instance doesn't have to be passed to the level manager
    """
    def __init__(self, surfs, interval):
        """
        :param surfs: A list of surfaces for animation
        :param interval: The interval between animation updates
        """
        super(Player, self).__init__({"right": Animation(surfs, interval)},
                                     lambda: "right", "right")
        self.jump_frames_left = 0
        self.jumping = False
        self.in_air = False
        self.up_speed = 20
        self.down_speed = 0
        self.dir = 'right'
        self.surfs = surfs
        self.rect = Rect(0, 0, 0, 0)
        if surfs:
            self.rect = surfs[0].get_rect()
        self.animation_interval = interval
        self.speed = 7

    def move(self, x, y):
        """
        Alias for ``plr.rect.move_ip``
        """
        self.rect.move_ip(x, y)

    def start_jump(self):
        """
        This method is used by the level manager to start the jump
        """
        if not self.jumping:
            self.jumping = True
            self.in_air = True

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import move_ip [as 别名]
class Hero(EventObserver):

    def __init__(self, x, y, rect_martix, container, evenent_handler):
        super().__init__(container, evenent_handler)
        self.rect_matrix = rect_martix
        self.map_point = (y, x) #cooridnates on map.txt
        self.x = x * 20 - 3 # coordinates used to paint object
        self.y = y * 20 - 3
        self.speed = 2
        self.active = True
        self.area_rect = Rect(self.x + 3, self.y + 3, 20, 20)
        self.direction = K_RIGHT
        self.new_direction = K_RIGHT
        self.movements = {K_UP: (0, -self.speed), K_RIGHT: (self.speed, 0),
                          K_DOWN: (0, self.speed), K_LEFT: (-self.speed, 0),
                          K_w: (0, -self.speed), K_d: (self.speed, 0),
                          K_s: (0, self.speed), K_a: (-self.speed, 0),
                          K_DELETE: (0, 0)}

    def move_hero(self, arguments):
        pass

    def move(self):
        self.x += self.movements[self.direction][0]
        self.y += self.movements[self.direction][1]
        self.area_rect.move_ip(self.movements[self.direction][0], self.movements[self.direction][1])

    def go_back(self):
        self.x -= self.movements[self.direction][0]
        self.y -= self.movements[self.direction][1]
        self.area_rect.move_ip(-self.movements[self.direction][0], -self.movements[self.direction][1])

    def get_proper_random_direction(self):
        directions = []
        if self.direction in PLAYER_ONE_KEYS:
            for direction in PLAYER_ONE_KEYS :
                if not self.is_this_the_wall(direction):
                    directions.append(direction)
            return directions[randint(0, len(directions) - 1)]
        else:
            for direction in PLAYER_TWO_KEYS:
                if not self.is_this_the_wall(direction):
                    directions.append(direction)
            return directions[randint(0, len(directions) - 1)]

    def in_place_to_change_direction(self):
        return self.rect_matrix.is_at_direction_change_place(self.area_rect)

    #checks if next point with givien direction to current hero map_point have wall on it
    def is_this_the_wall(self, direction):
         return self.rect_matrix.is_this_the_wall(self.area_rect, (int(self.movements[direction][0]/self.speed),
                                                             int(self.movements[direction][1]/self.speed)))

    def reload_movements(self):
        self.movements = {K_UP: (0, -self.speed), K_RIGHT: (self.speed, 0),
                          K_DOWN: (0, self.speed), K_LEFT: (-self.speed, 0),
                          K_DELETE: (0, 0)}

    def teleport(self, map_point):
        self.map_point = map_point #cooridnates on map.txt
        self.x = map_point[1] * 20 - 3 # coordinates used to paint object
        self.y = map_point[0] * 20 - 3
        self.area_rect = Rect(self.x + 3, self.y + 3, 20, 20)

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import move_ip [as 别名]
class Camera:
    """
    Class for keeping track of the camera position. In early stage of development
    """
    def __init__(self, screen_res, level_rect, x_speed=15, y_speed=15,
                 left_threshold=10, right_threshold=75, up_threshold=10,
                 down_threshold=75):
        """

        :param screen_res: A tuple of int. (w, h)
        :param level_rect: A rectangle that covers all of the level
        :param x_speed: The horizontal speed of the camera
        :param y_speed: The vertical speed of the camera
        :param left_threshold:
            The percentage of screen to reach in order for the camera to scroll
            left
        :param right_threshold:
            The percentage of screen to reach in order for the camera to scroll
            right
        :param up_threshold:
            The percentage of screen to reach in order for the camera to scroll
            up
        :param down_threshold:
            The percentage of screen to reach in order for the camera to scroll
            down
        """
        self.level_rect = level_rect
        self.horizontal_speed = x_speed
        self.vertical_speed = y_speed
        self.screen_res = screen_res
        self.rect = Rect((0, 0), screen_res)

        self.x_bound = self.level_rect.width - self.rect.width
        self.y_bound = self.level_rect.height - self.rect.height

        self.right_threshold = self.rect.width * right_threshold / 100
        self.left_threshold = self.rect.width * left_threshold / 100
        self.up_threshold = self.rect.height * up_threshold / 100
        self.down_threshold = self.rect.height * down_threshold / 100

    def pan_left(self, h_speed):
        if self.rect.x == 0:
            return
        if self.rect.move(-h_speed, 0).x < 0:
            self.rect.move_ip(-self.rect.x, 0)
        else:
            self.rect.move_ip(-h_speed, 0)

    def pan_right(self, h_speed):
        if self.rect.x == self.x_bound:
            return
        if self.rect.x + h_speed + self.rect.width > self.level_rect.width:
            self.rect.move_ip((self.level_rect.width - (self.rect.x + self.rect.width)), 0)
        else:
            self.rect.move_ip(h_speed, 0)

    def pan_down(self, v_speed):
        if self.rect.y == self.y_bound:
            return
        if self.rect.y + v_speed + self.rect.height > self.level_rect.height:
            self.rect.move_ip(0, (self.level_rect.height - self.rect.y - self.rect.height))
        else:
            self.rect.move_ip(0, v_speed)

    def pan_up(self, v_speed):
        if self.rect.y == 0:
            return
        if self.rect.move(0, -v_speed).y < 0:
            self.rect.move_ip(0, -self.rect.y)
        else:
            self.rect.move_ip(0, -v_speed)

    def snap_to(self, player_rect):
        propose = self.rect.move(0, 0)
        propose.x = min(max(0, player_rect.x - self.screen_res[0] / 2), self.x_bound)
        propose.y = min(max(0, player_rect.y - self.screen_res[1] / 2), self.y_bound)
        self.rect = propose

    def update(self, player_rect, custom_speed=None):
        h_speed, v_speed = self.horizontal_speed, self.vertical_speed
        if custom_speed:
            h_speed, v_speed = custom_speed
        if player_rect.x - self.rect.x > self.right_threshold:
            self.pan_right(h_speed)
        elif player_rect.x - self.rect.x < self.left_threshold:
            self.pan_left(h_speed)
        if player_rect.y - self.rect.y > self.down_threshold:
            self.pan_down(v_speed)
        elif player_rect.y - self.rect.y < self.up_threshold:
            self.pan_up(v_speed)

# 需要导入模块: from pygame.rect import Rect [as 别名]
# 或者: from pygame.rect.Rect import move_ip [as 别名]

#.........这里部分代码省略.........
           rectangle, and (x,y) movement pair.
        """
        Sprite.__init__(self)
        self.movement = [0, 0]
        self.rect = Rect(rect)
        self.lastRect = self.rect
        self.image = image
        self.name = name
        self.frames = []
        self.frameIndex = 0
        self.frameRate = 1
        self.timeDelay = WIDGETFRAMES
        self.lastUpdate = 0
        self.world = None
        self.undone = False
        self.id = self.rect.top + self.rect.left +\
                  self.rect.width + self.rect.height

    def attachToWorld(self, world):
        self.world = world
        self.id = self.world.curWidgetID
        self.world.curWidgetID += 1

    def startAnimation(self, frames, startIndex, frameRate):
        self.frames = frames
        self.frameIndex = startIndex
        self.frameRate = frameRate
        self.image = self.frames[startIndex]
        self.lastUpdate = self.timeDelay

    def __str__(self):
        return str(self.rect.left) + str(self.rect.top) + str(self.id)

    def setMovement(self, vector):
        """Set movement with a pair"""
        if(self.movement != [0,0]
           and vector == [0,0]):
            self.world.dirtyGroup.add(self)
        self.movement = vector

    def getMovement(self):
        """Return movement as a pair"""
        return self.movement

    def setStop(self):
        """Set movement to 0"""
        self.setMovement([0,0])

    def setY(self, y):
        """Set y-component of movement"""
        self.movement[1] = y

    def setX(self, x):
        """Set x-component of movement"""
        self.movement[0] = x

    def getX(self):
        """Get x-component of movement"""
        return self.movement[0]
    def getY(self):
        """Set y-component of movement"""
        return self.movement[1]

    def setPosition(self, pair):
        """Set x and y coords of Widget"""
        self.rect.topleft = pair

    def getPosition(self):
        """Get x and y coords of Widget"""
        return self.rect.topleft

    def update(self):
        """Move sprite according to its movement vector"""
        # Widget needs to be animated
        if (len(self.frames) > 0):
            if self.lastUpdate <= 0:
                self.frameIndex = (self.frameIndex+1)%(len(self.frames))
                self.image = self.frames[self.frameIndex]
                self.lastUpdate = self.timeDelay
                self.world.dirtyGroup.add(self)
            else:
                self.lastUpdate -= 1

        elif(self.getMovement != [0,0]):
            self.lastRect = Rect(self.rect)
            self.rect.move_ip(self.movement)
            self.world.dirtyGroup.add(self)

    def undoUpdate(self):
        """Widget returns to state prior to last update()"""
        self.rect = self.lastRect

    def getShadow(self):
        shadow = Sprite()
        shadow.rect = self.lastRect.move(0,0)
        return shadow

    def getName(self):
        """Get name of Widget"""
        return self.name