Python Rect.size方法代码示例

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import size [as 别名]
    def update(self, image, basePos, width, height):
        xb, yb = basePos
        if self.ship.armor != self.hp1:
            if abs(self.ship.armor - self.hp1) > 5:
                # new damage
                self.hp2 = self.hp1
                self.hp1 = self.ship.armor
                self.t = 0
            else:
                self.hp1 = self.ship.armor
        if self.t < self.maxT1:
            if self.t + self.dt >= self.maxT1:
                self.dhp = (self.hp1 - self.hp2) / (self.maxT2 - self.maxT1)
        elif self.t < self.maxT2:
            self.hp2 += self.dhp * self.dt
        else:
            self.hp2 = self.hp1
        self.t += self.dt

        hp1, hp2 = self.hp1, self.hp2
        rect = Rect((0, 0), (width, hp1/config.MaxArmor * height))
        rect.bottomleft = (xb, yb)
        pygame.draw.rect(image, self.HPColor, rect)
        if hp1 < hp2:
            rect.size = (width, (hp2 - hp1)/config.MaxArmor * height)
            rect.bottomleft = (xb,1 + yb - hp1/config.MaxArmor * height)
            pygame.draw.rect(image, self.HPColorDamage, rect)

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import size [as 别名]
 def test_size( self ):
     "Changing the size resizes the rect from the top-left corner"
     r = Rect( 1, 2, 3, 4 )
     new_size = (10,20)
     old_topleft = r.topleft
     
     r.size = new_size
     self.assertEqual( new_size, r.size )
     self.assertEqual( old_topleft, r.topleft )

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import size [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 size [as 别名]
 def on_msg(self, data):
     msgtype, name = data['msg_type'], data['name']
     global myname, mybox
     
     if msgtype == 'welcome':
         for state in data['pellets']:  # create all pellets
             left, top, width, height = tuple(state)
             pellets.append(Rect(left, top, width, height))
         for pname, state in data['players'].items():  # create all players
             left, top, width, height = tuple(state)
             players[pname] = Rect(left, top, width, height)
         myname, mybox = name, players[name] 
             
     elif msgtype == 'join' and name != myname:  # ignore my join message
         left, top, width, height = tuple(data['state']) 
         players[name] = Rect(left, top, width, height)
         
     elif msgtype == 'leave':
         del players[name]
         
     elif msgtype == 'move' and name != myname:  # ignore my move messages
         if players[name]:  # other player is not dead locally 
             left, top, width, height = tuple(data['state'])
             players[name] = Rect(left, top, width, height)
         
     elif msgtype == 'eat_pellet':
         if players[name]:  # None if I haven't receive his die msg yet
             players[name].size = tuple(data['size'])
         pellets[data['pellet_index']] = data['new_pellet']
     
     elif msgtype == 'grow':
         players[name].size = tuple(data['size'])  
         
     elif msgtype == 'die':
         left, top, width, height = tuple(data['state'])
         players[name] = Rect(left, top, width, height)
         if name == myname:
             mybox = players[myname]

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import size [as 别名]
class Camera(Component, IDrawer):
    """
    Class that represents a camera in game. This class is a initial simple camera. In future, hopefully,
    this will have lots of more features.
    A camera is used to draw just a portion of a level or object. A scene can have multiple Cameras.
    A camera will draw all objects that it is on sight (inside the rect that represents this camera).
    The camera itself doesn't have to fill all screen (it does by default), it can fill just a portion of the screen
    by changing its size and position.
    """

    def __init__(self, size=(0, 0)):
        super(Camera, self).__init__()
        self._rect = Rect()
        self._rect.size(size)

    def in_sight(self, game_object):

        """
        Validate if a game object is visible by this camera.
        :param game_object: Game object to validate if it is on sight
        :return: True if it is visible. False otherwise.
        """

        return game_object.get_component(IDrawable) is not None and self.transform.collidedict(
            game_object.get_component(IDrawable).get_rect)

    def update(self):
        self._rect.x = self.transform.x
        self._rect.y = self.transform.y

    def draw(self):
        """
        Draws a game object (only when 'in_camera' is true) using this camera.
        """
        game_objects_drawable = Game.instance().scene.get_drawables
        for game_object in game_objects_drawable:
            self.draw_game_object(game_object, True)

    def draw_game_object(self, game_object, validate_in_camera=True):
        """
        Draw a game object using this camera.
        :param game_object: Game object to be draw.
        :param validate_in_camera: If true, only draws the object if 'in_sight' is True.
        """
        if not validate_in_camera and self.in_sight(game_object) and game_object.get_component(IDrawable).is_drawing:
            pass
        Game.instance().surface.blit(game_object.get_component(IDrawable).drawable,
                                     game_object.get_component(IDrawable).get_rect,
                                     game_object.get_component(IDrawable).get_rect.clip(self._rect))

    @property
    def size(self):
        return self._rect.size

    @size.setter
    def size(self, size):
        self._rect = size

    def full_surface(self):
        self.transform.x = 0
        self.transform.y = 0
        self.transform.width = Configuration.instance().screen_size.width
        self.transform.height = Configuration.instance().screen_size.height