Python Rect.center方法代码示例

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import center [as 别名]
    def _draw_animation(self, entity):
        height = entity.cliche.surface.get_height()
        dest = Rect(0, 0, height, height)
        dest.center = self._on_screen(entity.position)

        self.screen.blit(entity.cliche.surface, dest,
                         entity.cliche.active_rect)

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import center [as 别名]
    def draw_sprite(self, sprite, ratio=None):
        if ratio is None:
            ratio = self.ratio

        # calculate the size of the shadow
        w = sprite.rect.width * ratio + 1
        h = w/2
        rect = Rect(0,0,w,h)
        
        # shrink the shadow according to height
        if hasattr(sprite, "height"):
            height0 = sprite.__class__.height
            ratio = (height0 - sprite.height) / float(height0)
            rect.width = max(8, rect.width * ratio)
            rect.height = max(4, rect.height * ratio)

        # move the the midbottom of the sprite
        rect.center = sprite.rect.midbottom
        rect.x -= 1
        rect.y -= 3

        # if the sprite has a height property, use it to move the shadow
        if hasattr(sprite, "height"):
            rect.y += sprite.height


        # draw to the layer
        pygame.draw.ellipse(self._layer, self.color, rect)

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import center [as 别名]
 def __init__ (self, real, within, player, vel, dirn, pos):
     Entity.__init__(self, vel)
     self.size = conf.MINE['size']
     r = Rect((0, 0), self.size)
     r.center = pos
     self.graphics.pos = r.clamp(within).topleft
     self.real = real
     self.player = player
     self.placed = None

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import center [as 别名]
    def change_map(self):
        pos = list(next(self.hotspots)[:])
        r = Rect((0,0), sd.get_size()).inflate((48, 48))
        r.center = pos
        clip = Surface(r.size)
        clip.blit(self.overworld, (0,0), r)

        self.surfaceQueue.put(clip)
        self.thread = SubPixelThread(self.surfaceQueue, self.subpixelQueue)
        self.thread.start()

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import center [as 别名]
 def spawn_wave(self, number):
     """ a collection of beasts """
     beasts = []
     if 0 <= number < len(self.waves):
         wave = self.waves[number]
         for genus, west, south in wave:
             location = Rect(0,0,1,1)
             location.center = (west, south)
             beasts.append(getattr(bestiary, genus)(location))
     return beasts

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import center [as 别名]
 def _update (self, col, row, tile_type_id, tile_rect=None):
     if self._cache_graphic:
         if tile_type_id in self._cache:
             g = self._cache[tile_type_id]
         else:
             g = self._type_to_graphic(tile_type_id)
             self._cache[tile_type_id] = g
     else:
         g = self._type_to_graphic(tile_type_id)
     dest = self._orig_sfc
     if tile_rect is None:
         tile_rect = self.grid.tile_rect(col, row)
     if isinstance(g, (Graphic, pg.Surface, basestring)):
         g = (g,)
     if (g is not None and
         isinstance(g[0], (Graphic, pg.Surface, basestring))):
         sfc = g[0]
         if isinstance(sfc, basestring):
             sfc = self._load_img(sfc)
         elif isinstance(sfc, Graphic):
             sfc = sfc.surface
         if len(g) == 1:
             alignment = rect = None
         else:
             if isinstance(g[1], int) or len(g[1]) == 2:
                 alignment = g[1]
                 rect = None
             else:
                 alignment = None
                 rect = g[1]
             if len(g) == 3:
                 if rect is None:
                     rect = g[2]
                 else:
                     alignment = g[2]
         if alignment is None:
             alignment = 0
         if rect is None:
             rect = sfc.get_rect()
         # clip rect to fit in tile_rect
         dest_rect = Rect(rect)
         dest_rect.center = tile_rect.center
         fit = dest_rect.clip(tile_rect)
         rect = Rect(rect)
         rect.move_ip(fit.x - dest_rect.x, fit.y - dest_rect.y)
         rect.size = dest_rect.size
         # copy rect to tile_rect with alignment
         pos = gameutil.align_rect(rect, tile_rect, alignment)
         dest.blit(sfc, pos, rect)
     else:
         if g is None:
             g = (0, 0, 0, 0)
         # now we have a colour
         dest.fill(gameutil.normalise_colour(g), tile_rect)
     return tile_rect

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import center [as 别名]
    def _compute_target_subsurface(self):
        screen = display.get_surface()
        screen.fill(self.bg_color)
        self_rect = self.get_rect()
        display_rect = screen.get_rect()

        if self._scale_type == 'pixelperfect':
            factor = min(float(display_rect.w) / self_rect.w,
                         float(display_rect.h) / self_rect.h)
            if factor >= 1.0:
                factor = int(factor)
            w = int(factor * self_rect.w)
            h = int(factor * self_rect.h)
            r = Rect(0, 0, w, h)
            r.center = display_rect.center
            target = screen.subsurface(r)
        elif self._scale_type == 'scale2x':
            factor = min(display_rect.w // self_rect.w,
                         display_rect.h // self_rect.h)
            pow2 = 0
            while (2 << pow2) <= factor:  # yes, 2<<pow2.
                pow2 += 1
            factor = (1 << pow2)
            w = factor * self_rect.w
            h = factor * self_rect.h
            r = Rect(0, 0, w, h)
            r.center = display_rect.center
            if display_rect.contains(r):
                target = screen.subsurface(r)
            else:
                target = screen
        elif self._scale_type == 'proportional':
            target = screen.subsurface(self_rect.fit(display_rect))
        elif self._scale_type == 'stretch':
            target = screen
        else:  # elif self._scale_type == 'centered':
            self_rect.center = display_rect.center
            if display_rect.contains(self_rect):
                target = screen.subsurface(self_rect)
            else:
                target = screen.subsurface(self_rect.fit(display_rect))
        return target

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import center [as 别名]
 def test_center( self ):
     """Changing the center attribute moves the rect and does not change
        the rect's size
     """
     r = Rect( 1, 2, 3, 4 )
     new_center = (r.centerx+20,r.centery+30)
     expected_topleft = (r.left+20,r.top+30)
     old_size = r.size
     
     r.center = new_center
     self.assertEqual( new_center, r.center )
     self.assertEqual( expected_topleft, r.topleft )
     self.assertEqual( old_size, r.size )

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import center [as 别名]
  def test_calculate_tile_coverage(self):
    v = Rect(0,0,11,11)
    m = map.MapBase(50,50)
    e = map.MapEntity(1)
    m.place_character(e,(25,25))
    c = m.map_tile_coverage

    #Normal centered
    e.move_to((25,25))
    v.center = (25,25)
    m.calculate_tile_coverage(v)
    self.assertEqual(16,c.width)
    self.assertEqual(16,c.height)
    self.assertEqual((25,25),c.center)

    #Not enough map on up and left
    e.move_to((1,1))
    v.center = (6,6)
    m.calculate_tile_coverage(v)
    self.assertEqual(0,c.left)
    self.assertEqual(0,c.top)

    #Not enough map on down and right
    e.move_to((48,48))
    v.right = 50
    v.bottom = 50
    m.calculate_tile_coverage(v)
    self.assertEqual(50,c.right)
    self.assertEqual(50,c.bottom)

    #Refresh while walking north
    e.move_to((25,21))
    v.center = (25,25)
    m.calculate_tile_coverage(v)
    self.assertEqual(v.bottom + 1,c.bottom)
    self.assertEqual(25,c.centerx)

    #Refresh while walking south
    e.move_to((25,29))
    v.center = (25,25)
    m.calculate_tile_coverage(v)
    self.assertEqual(v.top - 1,c.top)
    self.assertEqual(25,c.centerx)

    #Refresh while walking east
    e.move_to((29,25))
    v.center = (25,25)
    m.calculate_tile_coverage(v)
    self.assertEqual(v.left - 1,c.left)
    self.assertEqual(25,c.centery)

    #Refresh while walking west
    e.move_to((21,25))
    v.center = (25,25)
    m.calculate_tile_coverage(v)
    self.assertEqual(v.right + 1,c.right)
    self.assertEqual(25,c.centery)

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import center [as 别名]
 def draw_tabs(self, surf):
     font = self.tab_font
     fg = self.tab_fg_color
     b = self.tab_border_width
     if b:
         surf.fill(fg, (0, self.tab_height - b, self.width, b))
     for i, title, page, selected, rect in self.iter_tabs():
         x0 = rect.left
         w = rect.width
         h = rect.height
         r = rect
         if not selected:
             r = Rect(r)
             r.bottom -= b
         self.draw_tab_bg(surf, page, selected, r)
         if b:
             surf.fill(fg, (x0, 0, b, h))
             surf.fill(fg, (x0 + b, 0, w - 2 * b, b))
             surf.fill(fg, (x0 + w - b, 0, b, h))
         buf = font.render(title, True, page.fg_color or fg)
         r = buf.get_rect()
         r.center = (x0 + w // 2, h // 2)
         surf.blit(buf, r)

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import center [as 别名]
def draw_vector_on(surface, color, pos, vec):
    vec = (pos[0] + vec[0], pos[1] + vec[1])
    pygame.draw.line(surface, color, pos, vec)
    r = Rect(0, 0, 3, 3)
    r.center = vec
    pygame.draw.rect(surface, color, r)

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import center [as 别名]
    def custom_update_actions(self, platforms, new_sprites_group, player):
        """ Some Player special actions. """

        ######
        # other stuff: shoot, actions, etc...
        ######
        if self.use and self.col_down:
            self.use = False
            if self.match_position:
                #~ match_p = (self.match_position[0] + self.rect[0],self.match_position[1] + self.rect[1] - 1)
                match_rect = Rect(0,0,self.match_rect_size, self.match_rect_size)
                match_rect.center = (self.match_position[0] + self.rect[0],self.match_position[1] + self.rect[1] - 1)
                l = [spr for spr in self.groups()[0].sprites() if isinstance(spr,FireworkLauncher)]
                for f in l:
                    if f.col_rect.colliderect(match_rect) and \
                        not f.lit and self.vx == 0:
                        f.lit = True
                        glo.score += f.SCORE_LIT
                        size = 12
                        self.score_particle['x'] = self.rect.left
                        self.score_particle['y'] = self.rect.top
                        self.score_particle['text'] = f.SCORE_LIT
                        self.properly_add_ontop(ScoreText(**self.score_particle))
                        f.ignite_sound.play()

        if abs(self.vx) >= self.max_speed:
            if self.running_timer.finished:
                self.multiplier += 0.015 if self.multiplier <= self.max_multiplier else 0.0
                self.max_speed = self.base_max_speed * self.multiplier
        else:
            self.multiplier = 1.
            self.max_speed = self.base_max_speed
            self.running_timer.reset()

        # Draw the match fire particles
        if self.match_position:
            mp = self.match_particle
            mp['x'] = self.match_position[0] + self.rect[0]
            mp['y'] = self.match_position[1] + self.rect[1] - 1
            if self.lit:
                for i in xrange(int(ceil(self.lit /200))):
                    p=RandColorParticle(**mp)
                    player.properly_add_below(p)

        too_fast = hypot(self.vx, self.vy) - self.speed_limit
        if too_fast > 0:
            self.lit -= too_fast * self.damage_factor

        # Falling stuff
        if self.falling:
            self.fallen_updates += 1
        else:
            self.fallen_updates = 0

        # Reduce 'lit' every 'updates_per_lit_unit' updates and 
        # apply modifiers (pigeon attacks)
        if not self.winning:
            self.lit_counter += 1
            if self.lit_counter % self.updates_per_lit_unit == 0:
                self.lit_counter = 0
                self.lit -= 1
            # Apply lit modifiers
            self.lit -= self.lit_taken
            self.lit_taken = 0

        # Damage stuff
        # Look inside the mob classes to see how damage is applied
        if (self.half_platform_damage > 0 or self.inmunity_damage > 0) and not self.winning:
            self.damage_counter += 1
            self.half_platform_damage -= 1 if self.half_platform_damage > 0 else self.half_platform_damage
            self.inmunity_damage -= 1 if self.inmunity_damage > 0 else self.inmunity_damage

            # Need to copy the image. Not copying the image permanently
            # modifies player animations.
            self.image = self.image.copy()
            self.image.set_alpha(int(255*(self.damage_counter % self.damage_period) / (self.damage_period -1)))

        #########
        # Sounds
        if self.just_col_down:
            fall_sound.play()

        # Walking sounds
        if self.moving and self.col_down and \
            self.moved_x:
            self.step_counter += 1
            if self.step_counter % self.updates_per_step == 0:
                if self.step_counter == self.updates_per_step:
                    step1_sound.play()
                else:
                    step2_sound.play()
                    self.step_counter = 0

        # Braking sound
#         print "in custom update options:", self.braking
        if self.braking:
            if self.brake_counter % self.updates_per_brake == 0:
                brake_sounds[2].play()
            self.brake_counter += 1
        else:
#.........这里部分代码省略.........

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import center [as 别名]
 def rect(self, position):
     rect = Rect(0, 0, self.width, self.height)
     rect.center = (round(position.x), round(position.y))
     return rect