Python Rect.move方法代码示例

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move [as 别名]
def make_stats_box(screen, player, dungeon_level, box_x_start, box_heigth, box_width):
    """Create the box displaying the stats
       @param screen: the screen to draw on
       @param player: the player object
       @param dungeon_level: the current dungeon level
       @param box_x_start: rectangle upper left corner x-coordinate 
       @param box_heigth: height of rectangle
       @param box_width: width of rectangle
    """

    #create the rectangle
    stats_box = Rect(box_x_start, 0, box_width, box_heigth)
    #set font type
    stats_font = font.SysFont('arial', 20)
    #render game info
    player_HP = stats_font.render("Hit Points: " + str(player.getHP()), True, Color('white'))
    player_AP = stats_font.render("Attack Power: " + str(player.getAttackPower()), True, Color('white'))
    player_Armor = stats_font.render("Armor: " + str(player.getArmor()), True, Color('white'))
    level = stats_font.render("Dungeon Level: " + str(dungeon_level), True, Color('white'))

    #For each line of text, draw it on the screen and move the rectangle for the next line
    screen.fill(Color('Black'), stats_box)
    screen.blit(player_HP, stats_box)
    screen.blit(player_AP, stats_box.move(0, player_HP.get_height()))
    screen.blit(player_Armor, stats_box.move(0, player_HP.get_height() + player_AP.get_height()))
    screen.blit(level, stats_box.move(0, player_HP.get_height() + player_AP.get_height() + player_Armor.get_height()))

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move [as 别名]
class Star (object):
    def __init__ (self, level, pos, got):
        self.rect = Rect(pos, conf.STAR_SIZE)
        self.got = got
        self.bg = level.game.img('star-bg.png')
        self.fg = level.game.img('star-fg.png')
        self.sfc = pg.Surface(self.fg.get_size()).convert_alpha()
        self.glow = 0
        self.glow_dirn = 1

    def draw (self, screen, offset):
        r = self.rect.move(offset)
        screen.blit(self.bg, r)
        sfc = self.sfc
        g = self.glow
        # draw fg with opacity level from glow
        sfc.fill((255, 255, 255, ir(g * 255)))
        sfc.blit(self.fg, (0, 0), None, pg.BLEND_RGBA_MULT)
        screen.blit(sfc, r)
        # update glow
        d = self.glow_dirn
        g += d * conf.STAR_PULSE_SPEED
        gb = min(1, max(0, g))
        if g != gb:
            d *= -1
        self.glow = gb
        self.glow_dirn = d

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move [as 别名]
    def _prepare_sprite(self, sprite):
        """Prepare a sprite before drawing.

        Return the corresponding rectangle.
        """
        # Aliases
        old_rect_dct = self.spritedict
        use_update = self._use_update
        # Test dirty rects
        try: sprite.dirty_rects
        except AttributeError: sprite.dirty_rects = None
        # Update dirtyness
        if not sprite.dirty and sprite.dirty_rects:
            sprite.dirty = 1
        # Get actual size
        try: size_rect = Rect((0,0), sprite.source_rect.size)
        except AttributeError: size_rect = Rect((0,0), sprite.rect.size)
        # Compare rect
        new_rect = size_rect.move(sprite.rect.topleft)
        has_moved = new_rect != old_rect_dct[sprite]
        # Whole rect is dirty
        if not use_update or has_moved or sprite.dirty_rects is None:
            sprite.dirty_rects = [size_rect]
            return new_rect
        # Clip the dirty rects
        for k, area in enumerate(sprite.dirty_rects):
            sprite.dirty_rects[k] = area.clip(size_rect)
        # Return
        return new_rect

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move [as 别名]
 def test_move( self ):
     r = Rect( 1, 2, 3, 4 )
     move_x = 10
     move_y = 20
     r2 = r.move( move_x, move_y )
     expected_r2 = Rect(r.left+move_x,r.top+move_y,r.width,r.height)
     self.assertEqual( expected_r2, r2 )

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move [as 别名]
 def cache_inventory(self):
   '''Making the assumption that we won't really have that many items'''
   self.inventory_text = []
   add = self.inventory_text.append
   text = self.render_text
   loc = Rect(375,50,0,0)
   for i in self.inventory:
       add(text(i.get_name(),loc))
       loc.move_ip(0,25)
   if len(self.inventory_text) == 0:
       add(text("Your inventory is empty",loc.move(30,0)))

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move [as 别名]
class Player(Sprite):
    def __init__(self, x, y):
        super().__init__()
        self.xvel = 0
        self.yvel = 0
        self.onGround = True
        self.image = Surface((32, 32))
        self.image.fill(Color("#00FFFF"))
        self.image.convert()
        self.rect = Rect(x, y, 32, 32)

    def update(self):
        self.rect = self.rect.move(3, 0)

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move [as 别名]
 def rect (self, rect):
     # need to set dirty in old and new rects (if changed)
     last = self.last_rect
     rect = Rect(rect)
     if rect != last:
         sz = rect.size
         if sz != last.size:
             self.resize(*sz)
         else:
             # handled in resize
             self._rect = rect
             self._postrot_rect = Rect(rect.move(self._rot_offset)[:2],
                                       self._postrot_rect[2:])
             self._mk_dirty()

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move [as 别名]
 def _widgetRect(self, widget, rect=None):
     # simplistic.  doesn't account for scaling or translation.  If you want those, implement the
     # _widgetRect(rect) method on your widget class itself.
     if rect is None:
         rect = Rect(0, 0, widget.w, widget.h)
         
     if widget is self:
         return rect
     elif widget.parent is None:
         return None
     elif hasattr(widget, '_widgetRect'):
         return self._widgetRect(widget.parent, widget._widgetRect(rect))
     elif issubclass(widget.__class__, Translatable):
         return self._widgetRect(widget.parent, rect.move(widget.x, widget.y))
     else:
         return self._widgetRect(widget.parent, rect)

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move [as 别名]
class Widget(sprite.Sprite):
    #a widget has a position
    def __init__(self, x=None, y=None):
        sprite.Sprite.__init__(self)
        self.image, self.rect = self.load_image(self.display,
                                                Color('#FF00FF'))
        self.x = x
        self.y = y
        if self.x is not None:
            if self.y is not None:
                self.rect = Rect(x*50, y*50, 50, 50)

    # functions should be implemented in subclasses
    # if they are relevant to that widget type
    def eaten(self):
        return ("boredom", -1)

    def played(self):
        return ("boredom", -1)

    # if creature tries to walk into widget,
    def intersected(self):
        return ("boredom", -1)

    def mated(self, tako):
        return ("boredom", -1)

    def load_image(self, name, colorkey=None):
        fullname = os.path.join('img', name)
        img = image.load(fullname)
        img = img.convert()
        if colorkey is not None:
            if colorkey is -1:
                colorkey = img.get_at((0,0))
            img.set_colorkey(colorkey, RLEACCEL)
        return img, img.get_rect()

    def update_rect(self):
        self.rect = Rect(self.x*50, self.y*50, 50, 50)

    def move_rect(self, x, y):
        self.rect = self.rect.move(x*50, y*50)

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

#.........这里部分代码省略.........
        self.loading_timer.reset()
        # Reset animation
        self.timer.reset().start()

    def update_collision(self):
        """Handle wall collisions."""
        collide_dct = dict(self.collide_dct.items())
        # Loop over changes
        while not self.border.rect.contains(self.rect):
            self.fixed = True
            self.save_dir = self.control_dir
            dct = {}
            # Test against the 4 directions.
            for direc, attr in collide_dct.items():
                rect = self.rect.copy()
                value = getattr(self.border.rect, attr)
                setattr(rect, attr, value)
                distance = abs(xytuple(*rect.topleft) - self.rect.topleft)
                dct[distance] = rect, direc, attr
            # Aply the smallest change
            self.rect, self.pos, _ = dct[min(dct)]
            del collide_dct[self.pos]
        # Do not grab the wall when KO
        if self.ko and self.pos != Dir.DOWN:
            self.fixed = False

    @property
    def loading_ratio(self):
        """Loading ratio between 0 and 1."""
        res = float(self.loading_speed - self.init_speed)
        return res / (self.max_loading_speed - self.init_speed)

    @property
    def current_dir(self):
        """Current direction with x and y in (-1, 0, 1)."""
        # Static case
        if self.fixed:
            if not any(self.save_dir) or \
               sum(self.save_dir*self.pos) > 0:
                return xytuple(0, 0)
            current_dir = self.save_dir - self.pos
            sign = lambda arg: cmp(arg, 0)
            return current_dir.map(sign)
        # Dynamic case
        return Dir.closest_dir(self.speed)

    def get_rect_from_dir(self, direction):
        """Compute a hitbox inside the player in a given direction."""
        size = xytuple(*self.size) * ((self.hitbox_ratio,)*2)
        attr = Dir.DIR_TO_ATTR[direction]
        rect = Rect((0, 0), size)
        value = getattr(self.rect, attr)
        setattr(rect, attr, value)
        return rect

    @property
    def head(self):
        """Head hitbox. Currently not used."""
        if self.ko:
            return Rect(0, 0, 0, 0)
        if self.fixed:
            return self.get_rect_from_dir(self.pos * (-1, -1))
        return self.get_rect_from_dir(self.current_dir * (-1, -1))

    @property
    def body(self):
        """Body hitbox. Currently not used."""
        if self.ko:
            return Rect(0, 0, 0, 0)
        return self.get_rect_from_dir(Dir.NONE)

    @property
    def legs(self):
        """Legs hitbox."""
        if self.ko or self.fixed:
            return Rect(0, 0, 0, 0)
        return self.get_rect_from_dir(self.current_dir)

    def update(self):
        """Update the player state."""
        # Get acc
        acc = -self.speed * self.air_friction
        acc += self.gravity
        # Update speed
        self.speed += self.delta_tuple * acc
        if self.fixed:
            self.speed *= 0, 0
        # Get step
        step = self.delta_tuple * self.speed
        step += self.remainder
        intstep = step.map(round)
        self.remainder = step - intstep
        # Register steps
        args = Rect(self.rect), self.rect.move(intstep)
        self.steps = list(Dir.generate_rects(*args))
        # Update timer
        if self.loading:
            delta = self.load_factor_max - self.load_factor_min
            ratio = self.load_factor_min + self.loading_ratio * delta
            self.timer.start(ratio)

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move [as 别名]
class Player( Entity ):
	def __init__( self, lives, score, bulletMan, maxSpeed, sprite, viewBox, bulletSprite, bulletBox ):
		# position vars
		self.SPAWN_X = 300
		self.SPAWN_Y = 600
		self.xpos = self.SPAWN_X
		self.ypos = self.SPAWN_Y
		Entity.__init__( self, 400 , 300, sprite, Rect( self.xpos - 10,
							self.ypos - 10, self.xpos + 54, self.ypos + 54 ) )

		# movement vars
		self._maxSpeed = maxSpeed
		self._focusedSpeed = maxSpeed /  2.0
		self._xSpeed = 0
		self._ySpeed = 0

		# Game vars
		self.lives = lives
		self.score = score
		self.invincible = False
		self._invincibilityTime = 5000
		self._bulletMan = bulletMan
		self._FIRE_COOL_MAX = 10
		self._fireCoolDown = 0

		# sprite vars
		self._itemBox = Rect( self.xpos, self.ypos, self.xpos + 64,
									self.ypos + 64 )
		self._viewBox = viewBox
		self._bulletSprite = bulletSprite
		self._bulletBox = bulletBox

	def act( self ):
		"""
		Handles movement and other actions for the player
		"""

		#TODO possibly think of a more elegant way to handle this
		focused = False
		up = False
		down = False
		left = False
		right = False
		focus = False
		fire = False
		bomb = False

		if pygame.key.get_focused():
			keys = pygame.key.get_pressed()
			up = keys[K_UP]
			down = keys[K_DOWN]
			right = keys[K_RIGHT]
			left = keys[K_LEFT]
			focus = keys[K_LSHIFT]
			fire = keys[K_z]
			bomb = keys[K_x]
		# Get if focused here
		if focused == True:
			if up == True:
				self._ySpeed = -1 * self._focusedSpeed
			elif down == True:
				self._ySpeed = self._focusedSpeed
			else:
				self._ySpeed = 0

			if left == True:
				self._xSpeed = -1 * self._focusedSpeed
			elif right == True:
				self._xSpeed = self._focusedSpeed
			else:
				self._xSpeed = 0
		else:
			if up == True:
				self._ySpeed = -1 * self._maxSpeed
			elif down == True:
				self._ySpeed = self._maxSpeed
			else:
				self._ySpeed = 0

			if left == True:
				self._xSpeed = -1 * self._maxSpeed
			elif right == True:
				self._xSpeed = self._maxSpeed
			else:
				self._xSpeed = 0

		if self._viewBox.x < 0 and self._xSpeed < 0:
			self._xSpeed = 0
		elif self._viewBox.x >= 800 - 64 and self._xSpeed > 0:
			self._xSpeed = 0

		if self._viewBox.y < 0 and self._ySpeed < 0:
			self._ySpeed = 0
		elif self._viewBox.y >= 600 - 64 and self._ySpeed > 0:
			self._ySpeed = 0

		if fire and self._fireCoolDown <= 0:
			self._fire()
			self._fireCoolDown = self._FIRE_COOL_MAX
		elif self._fireCoolDown > 0:
#.........这里部分代码省略.........

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move [as 别名]
class PlayerCommand:
    """ Display pannel for player input/output
        Controls display area for player input/output """

    def __init__(self):
        self.msg1 = "text area 1"
        self.msg2 = "text area 2"
        self.msg3 = "text area 3"
        self.x = 50
        self.width = 20
        self.offset = 0
        self.back_color = "black"
        self.message_rect = Rect(600, 0, SCREEN_WIDTH, SCREEN_HEIGHT)
        self.message_size = (int(self.message_rect[2]) - self.message_rect[0], int(self.message_rect[3]))
        self.unit_group_rect = Rect(630, 150, 15, 15)
        self.player_msg = "Player message here"
        self.tick_counter = "Ticks here"

    def msg_to_player(self, screen):
        """ tracks and handles messages to player """
        message1_sf = DEFAULT_GAME_FONT.render(self.player_msg, True, Color("white"))
        screen.blit(message1_sf, (20, 550, SCREEN_WIDTH, SCREEN_HEIGHT))
        """ tick counter """
        message2_sf = DEFAULT_GAME_FONT.render(self.tick_counter, True, Color("white"))
        screen.blit(message2_sf, (20, 20, SCREEN_WIDTH, SCREEN_HEIGHT))

    def draw_messageboard(self, screen):
        self.draw_rimmed_box(screen, self.message_rect, (self.x, self.width, self.offset), 4, Color(self.back_color))
        DEFAULT_GAME_FONT = pygame.font.SysFont("arial", 18)
        message1_sf = DEFAULT_GAME_FONT.render(self.msg1, True, Color("white"))
        message2_sf = DEFAULT_GAME_FONT.render(self.msg2, True, Color("white"))
        message3_sf = DEFAULT_GAME_FONT.render(self.msg3, True, Color("white"))
        message4 = "Heroes: " + str(HERO_WINS)
        message4_sf = DEFAULT_GAME_FONT.render(message4, True, Color("white"))
        message5 = "Enemies: " + str(ENEMY_WINS)
        message5_sf = DEFAULT_GAME_FONT.render(message5, True, Color("white"))
        screen.blit(message1_sf, self.message_rect.move(0, message1_sf.get_height()))
        screen.blit(message2_sf, self.message_rect.move(0, message2_sf.get_height() * 2))
        screen.blit(message3_sf, self.message_rect.move(0, message2_sf.get_height() * 3))
        screen.blit(message4_sf, self.message_rect.move(0, message4_sf.get_height() * 4))
        screen.blit(message5_sf, self.message_rect.move(0, message5_sf.get_height() * 5))
        self.msg_to_player(screen)

    def draw_player_units(self, screen, unit_group):
        """ blits player unit text to output display window """
        self.draw_rimmed_box(
            screen,
            Rect(600, 150, SCREEN_WIDTH, SCREEN_HEIGHT),
            (self.x, self.width, self.offset),
            4,
            Color(self.back_color),
        )
        DEFAULT_GAME_FONT = pygame.font.SysFont("arial", 12)
        offset = 0
        for unit in unit_group:
            message1_sf = DEFAULT_GAME_FONT.render(unit.info_msg1, True, Color("white"))
            message1_status = DEFAULT_GAME_FONT.render(unit.txt_status, True, Color("white"))
            message2_sf = DEFAULT_GAME_FONT.render(unit.info_msg2, True, Color("white"))
            screen.blit(message1_sf, self.unit_group_rect.move(0, message1_sf.get_height() * 1 + offset * 24))
            screen.blit(message1_status, self.unit_group_rect.move(100, message1_status.get_height() * 1 + offset * 24))
            screen.blit(message2_sf, self.unit_group_rect.move(0, message2_sf.get_height() * 2 + offset * 24))
            for button in unit.unit_btns:
                button.draw(screen)
            offset += 2

    def draw_rimmed_box(self, screen, box_rect, box_color, rim_width=0, rim_color=Color("black")):
        """ Draw a rimmed box on the given surface. 
            The rim is drawn outside the box rect. 
        """
        if rim_width:
            rim_rect = Rect(
                box_rect.left - rim_width,
                box_rect.top - rim_width,
                box_rect.width + rim_width * 2,
                box_rect.height + rim_width * 2,
            )
            pygame.draw.rect(screen, rim_color, rim_rect)
        pygame.draw.rect(screen, box_color, box_rect)

    def in_field(self, pos):
        """ verify if clicked pos is in playable grid area  - returns True/False """
        loc = self.coord_to_grid(pos)
        if loc[0] < 0 or loc[0] >= self.x or loc[1] < 0 or loc[1] >= GRID_SIZE[1]:
            # print("you missed the player_command grid")
            return False
        else:
            return True

    def grid_clicked(self, pos):
        """ tells what grid was clicked on and reports for testing purposes 
            pos: the passed mouse coordinates variable passed through 
        """
        if self.in_field(pos):
            # print("click is in player_command field")
            # print("pos clicked:", pos)
            dummy = False

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move [as 别名]
class Animation(Sprite):
    
    __mElapsedTime = None
    __mLooping = None
    __mRunning = None
    __mIsDone = None
    
    __mCurrentFrame = None
    __mCurrentRow = None
    __mDrawRect = None
    
    def __init__(self, sprite, framesX, framesY, animationtime, size, looping = True, running = True):
        super(Animation, self).__init__(sprite)
        
        self.__mElapsedTime = 0.0
        self.__mLooping = looping
        self.__mRunning = running
        self.__mIsDone = False
        self.__mCurrentFrame = 0
        self.__mCurrentRow = 0
        self.__mDrawRect = None
        
        Sprite.setSize(self, size)
        self.__mFramesX = framesX
        self.__mFramesY = framesY
        self.__mFrameHeight = Sprite.getHeight(self) / framesY
        self.__mFrameWidth = Sprite.getWidth(self) / framesX
        self.__mMaxTime = animationtime / self.__mFramesX
        self.__mDrawRect = Rect(self.__mCurrentFrame * self.__mFrameWidth, self.__mCurrentRow * self.__mFrameHeight, self.__mFrameWidth, self.__mFrameHeight)
    
    def draw(self, delta, position):
        if self.__mRunning:
            self.__mElapsedTime += delta
        
            if self.__mElapsedTime > self.__mMaxTime:
                
                self.__mCurrentFrame += 1
                
                if self.__mCurrentFrame >= self.__mFramesX:
                    self.__mCurrentFrame = 0
                    
                    if not self.__mLooping:
                        self.__mIsDone = True
                        self.__mRunning = False
            
                self.__mElapsedTime = 0.0
        
        Sprite.draw(self, position, self.__mDrawRect.move(self.__mCurrentFrame * self.__mFrameWidth, self.__mCurrentRow * self.__mFrameHeight))
    
    def freeze(self, frameX, frameY = 0):
        self.__mRunning = False
        self.__mCurrentFrame = frameX
        self.__mCurrentRow = frameY
    
    def continueAnimation(self):
        self.__mRunning = True
    
    def setLooping(self, looping):
        self.__mLooping = looping
        
    def gotoRow(self, row):
        if row <= self.__mFramesY:
            self.__mCurrentRow = row
            
    def getRect(self):
        return Rect(self.__mCurrentFrame * self.__mFrameWidth, self.__mCurrentRow * self.__mFrameHeight, self.__mFrameWidth, self.__mFrameHeight)
            
    def getFrame(self):
        return self.__mCurrentFrame
    
    def getRow(self):
        return self.__mCurrentRow
    
    def isAnimationDone(self):
        return self.__mIsDone
    
    def reset(self):
        self.__mIsDone = False
        self.__mCurrentFrame = 0
        self.__mCurrentRow = 0
        self.__mRunning = True
        
    def isLooping(self):
        return self.__mLooping

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

    def __init__(self, text, options=None):
        self.options = options
        if options is not None:
            self.selection = 0
        else:
            self.selection = None

        self.fg = pygame.color.Color('white')
        self.bg = pygame.color.Color('blue')
        self.tr = pygame.color.Color('black')

        half = core.screen.get_width() * 4 / 5
        self.rect = Rect(0,0,half,0)
        self.text = text
        self.font = pygame.font.Font(None, 20)
        self.split_text()
        self.render_text()

        self.window = core.wm.window(half,self.rect.height,'center','center')
        self.window.update = self.update
        self.window.handle_event = self.handle_event
        self.screen = self.window.image
        self.screen.set_colorkey(self.tr, RLEACCEL)

        self.rect = Rect(self.window.rect)
        self.rect.center = self.screen.get_rect().center

        r = self.rect.inflate(-6,-6)
        self.bgwin = core.wm.window(r.width,r.height,'center','center',z=3)
        self.bgwin.image.fill(self.bg)
        self.bgwin.image.set_alpha(128)

        self.borderwin = core.wm.window(self.rect.width,self.rect.height, \
            'center','center', z=2)
        self.borderwin.image.fill(self.tr)
        dialog.draw_round_border(self.borderwin.image,color=self.fg)
        self.borderwin.image.set_colorkey(self.tr, RLEACCEL)

    def hide(self):
        self.window.hide()
        self.bgwin.hide()
        self.borderwin.hide()

    def nop(self): pass
    def update(self):
        self.window.update = self.nop
        self.screen.fill(self.tr)
        draw_round_border(self.screen,color=self.fg)
        current_y = 10
        for line in self.rendered:
            self.screen.blit(line, self.rect.move(10,current_y))
            current_y = current_y + self.font.get_linesize()
        current_y = current_y + self.font.get_linesize()
        first_option_y = current_y
        for option in self.rendered_opts:
            self.screen.blit(option, self.rect.move(20,current_y))
            current_y = current_y + self.font.get_linesize()
        if self.selection is not None:
            y_pos = first_option_y + self.selection * self.font.get_linesize()
            y_pos = y_pos + self.font.get_linesize() / 2 # Center it in line
            rect = self.rect.move(10, y_pos)
            center = (rect.left, rect.top)
            draw.circle(self.screen, self.fg, center, 5)

    def render_one_line(self, line):
        return self.font.render(line, True, self.fg).convert_alpha()

    def render_text(self):
        self.rendered = map(self.render_one_line, self.lines)
        if self.options is not None:
            self.rendered_opts = map(self.render_one_line, self.options)
            line_count = len(self.rendered) + len(self.rendered_opts) + 1
        else:
            self.rendered_opts = []
            line_count = len(self.rendered)
        self.rect.height = self.font.get_linesize() * line_count + 20

    def split_text(self):
        self.lines = []
        current = ''
        for chunk in re.split(' ', self.text):
            width, height = self.font.size(current + chunk + ' ')
            if width < self.rect.width - 10:
                current = current + chunk + ' '
            else:
                self.lines.append(current)
                current = chunk + ' '
        if len(current) > 1:
            self.lines.append(current)

    def selection_up(self):
        if self.selection is not None:
            if self.selection == 0:
              self.selection = len(self.options)-1
            else:
              self.selection = self.selection - 1
        self.window.update = self.update

#.........这里部分代码省略.........

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

#.........这里部分代码省略.........
		self._top_rect = Rect(pos[0], pos[1], Character.WIDTH, 1)
		self._bottom_rect = Rect(pos[0], pos[1] + Character.HEIGHT - 1, Character.WIDTH, 1)
		self._left_rect = Rect(pos[0], pos[1], 1, Character.HEIGHT - 1)
		self._right_rect = Rect(pos[0] + Character.WIDTH - 1, pos[1], 1, Character.HEIGHT - 1)

		self._collect_sound = SoundManager.MANAGER.get_sound("coin.wav")

	def draw(self, surface, tick, camera, size):
		""" The drawing method.

		This method draws the character on the given surface.

		Args:
			surface: The surface the character will be drawn on.
			tick: The current tick of the game.
			camera: The position of the camera.
			size: The size of the window. This argument is not used at the moment.
		"""
		if self._state == Character.STANDING:
			self._stand_animation.draw(surface, self._collision_rect.x - camera[0], self._collision_rect.y - camera[1],
									   tick)
		elif self._state == Character.WALKING:
			self._walk_animation.draw(surface, self._collision_rect.x - camera[0], self._collision_rect.y - camera[1],
									  tick, self._direction == Character.LEFT)
		elif self._state == Character.JUMPING:
			if self._direction == Character.NONE:
				self._jump_animation.draw(surface, self._collision_rect.x - camera[0],
										  self._collision_rect.y - camera[1], tick)
			else:
				self._jump_right_animation.draw(surface, self._collision_rect.x - camera[0],
												self._collision_rect.y - camera[1], tick,
												self._direction == Character.LEFT)
		if Character.DEBUG:
			move = camera[:]
			move[0] *= -1
			move[1] *= -1
			pygame.draw.rect(surface, (255, 255, 255), self._collision_rect.move(move), 2)
			pygame.draw.rect(surface, (255, 0, 0), self._top_rect.move(move), 1)
			pygame.draw.rect(surface, (255, 0, 0), self._bottom_rect.move(move), 1)
			pygame.draw.rect(surface, (0, 0, 255), self._left_rect.move(move), 1)
			pygame.draw.rect(surface, (0, 0, 255), self._right_rect.move(move), 1)

	def tick(self, platforms, collectables):
		""" Method for handling game ticks.

		This method should be called every tick to calculate the character changes.

		Args:
			platforms: The platforms of the level.
			collectables: The collectables, like coins, of the level.
		"""
		self._direction = Character.NONE
		if self._invincible > 0:
			self._invincible -= 1
		self._state = Character.STANDING
		if self._is_falling:
			if self._dy < Character.MAX_FALLING:
				self._dy += Character.V_FALLING
			self._state = Character.JUMPING
		else:
			self._dy = 0
		self._pos[1] += self._dy
		self._adjust_rects()

		movedX = 0
		movedY = 0