Python Rect.move_ip方法代码示例

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move_ip [as 别名]
class Thumbnail():
    """Thumbnail that has a surface, with a background color set"""
    def __init__(self, width=64):
        self.surface_thumb = Rect(0,0,width,width)
        self.rect_thumb = Rect(0,0,width,width)
                    
        # ex [1] the standard pygame.Color("white") , same as Color("#ffffff")
        self.color_bg = Color("white")                
        # ex [2] random color with a filter:
        self.color_bg = random_color('light')
        self.color_border = random_color('dark')
        
        # create empty surface;  fill it
        self.surface_thumb = pygame.Surface([width, width])
        self.surface_thumb.fill(self.color_bg)
    
    def fill(self):
        """clear thumb."""
        self.surface_thumb.fill(self.color_bg)

    def move(self, x, y):
        """move all rects/images together"""
        self.rect_thumb.move_ip(x,y)
  
    def draw(self, screen):        
        screen.blit(self.surface_thumb, self.rect_thumb)
                
    def __str__(self): return "<Thumbnail( bg={bg}, rect_thumb={rect_thumb} >".format(bg=self.color_bg, rect_thumb=self.rect_thumb)

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move_ip [as 别名]
class Projectile(sprite.Sprite):
    def __init__(self, pos, tower, target, image, speed, damage):
        sprite.Sprite.__init__(self)
        self.pos = pos
        self.tower = tower
        self.target = target
        self.image = image
        self.speed = speed
        self.damage = damage
        self.rect = Rect(self.pos, self.image.get_size())

        self.angle = atan2((self.target.rect.centery-self.rect.centery),
                                (self.target.rect.centerx-self.rect.centerx))
        self.x_speed = cos(self.angle)*self.speed
        self.y_speed = sin(self.angle)*self.speed

    def update(self, monsters, screen):

        # Kills the projectile if it doesn't get there before the target dies
        if self.target is None:
            self.kill()
            return

        # Calculates where the projectile needs to go
        self.angle = atan2((self.target.rect.centery-self.rect.centery),
                                (self.target.rect.centerx-self.rect.centerx))

        distance = hypot(self.target.rect.centerx - self.rect.centerx,
                              self.target.rect.centery - self.rect.centery)
        mod = self.target.speed+1
        # Calculates the X and Y speed
        xspeed, yspeed = cos(self.angle)*mod, sin(self.angle)*mod
        self.x_speed = xspeed + xspeed/abs(xspeed) if xspeed != 0 else 0
        self.y_speed = yspeed + yspeed/abs(yspeed) if yspeed != 0 else 0

        # If the projectile is within range, it hit the target
        if abs(self.rect.centerx - self.target.rect.centerx) <= 20:
            if abs(self.rect.centery - self.target.rect.centery) <= 20:
                self.do_damage(monsters)
                self.kill()
            else:
                self.rect.move_ip((self.x_speed, self.y_speed))
        else:
            self.rect.move_ip((self.x_speed, self.y_speed))

        # Destroys the projectile if it goes off screen
        if not screen.contains(self.rect):
            self.kill()

    def do_damage(self, monsters):
        for monster in monsters:
            # Does damage to the target, and adds kills and money rewards if it dies, also adds damage_done to tower
            if monster == self.target:
                # dmg_result returns (None/Value of monster, Damage done by projectile)
                dmg_result = monster.damage(self.damage)
                if dmg_result[0] is not None:
                    self.tower.kills += 1
                    self.tower.turn_yield += dmg_result[0]
                self.tower.damage_done += dmg_result[1]
                break

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move_ip [as 别名]
 def test_move_ip( self ):    
     r = Rect( 1, 2, 3, 4 )
     r2 = Rect( r )
     move_x = 10
     move_y = 20
     r2.move_ip( 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_ip [as 别名]
class Camera(object):
    """Manages current view rectangle and provides methods to convert
    coordinates from/to screen/map coordinate systems."""

    MOVE_SPEED = 0.25

    def __init__(self, view_size):
        self.view_rect = Rect((0, 0), view_size)
        self.move_event = EventManager.new_event_code()

        self._moving = False
        self._move_vector = [0, 0]

        self._last_update = 0

    def update(self, time_passed):
        """Update camera.

        Execute movement and such"""

        if self._moving:
            delta = util.vector_mul(util.vector_normalize(self._move_vector),
                                    Camera.MOVE_SPEED * time_passed)
            self.view_rect.move_ip(delta)
            self._post_move_event()

    def set_move(self, x=None, y=None):
        if x is not None:
            self._move_vector[0] = x
        if y is not None:
            self._move_vector[1] = y
        self._moving = True

    def stop_moving(self):
        self._move_vector = [0, 0]
        self._moving = False

    def move_to(self, x, y):
        self.view_rect.x = x
        self.view_rect.y = y
        self._post_move_event()

    def rect_to_screen(self, rect):
        return rect.move(-self.view_rect.x, -self.view_rect.y)

    def rect_to_map(self, rect):
        return rect.move(self.view_rect.x, self.view_rect.y)

    def point_to_screen(self, p):
        return p[0] - self.view_rect.x, p[1] - self.view_rect.y

    def point_to_map(self, p):
        return p[0] + self.view_rect.x, p[1] + self.view_rect.y

    def _post_move_event(self):
        EventManager.post(self.move_event, cam=self)

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move_ip [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 move_ip [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_ip [as 别名]
 def cache_stats(self):
   self.stats_text = []
   add = self.stats_text.append
   text = self.render_text
   hero = core.game.save_data.hero.get
   label = Rect( 30,50,120,0)
   value = Rect(160,50,  0,0)
   for s in self.character_fields:
       add(text(s.capitalize(),label,align='right'))
       add(text(str(hero(s)),value))
       label.move_ip(0,25)
       value.move_ip(0,25)

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move_ip [as 别名]
class Marquee(BaseAnimation):
    """
    This class animates a surface like a marquee.

    Nothing fancy, just scrolls it back and forth, takes a pause
    when returning to ground zero. This is just intended as a demo
    for testing the rendering.
    """

    smoothfactor = 0.1
    image = None

    def __init__(
        self, rectstyle, surface, step_x=1, fps=25, init_sleep=-1, bg_update=True, bg_wait=False, bg_redraw=False
    ):

        BaseAnimation.__init__(self, rectstyle, fps, bg_update, bg_wait, bg_redraw)

        self.image = surface
        self.step_x = step_x

        self.w, self.h = surface.get_size()
        self.animrect = Rect((0, 0, self.rect.width, self.rect.height))

    def draw(self):
        if self.w < self.rect.width:
            self.surface.blit(self.image, (0, 0))
            return

        ### move and blit
        self.animrect.move_ip(int(self.step_x * self.smoothfactor), 0)
        self.surface.blit(self.image, (0, 0), self.animrect)

        ### recalculate for next pass
        if self.smoothfactor < float(1):
            self.smoothfactor *= 1.1
            if self.smoothfactor > float(1):
                self.smoothfactor = 1

        # at bounds, change direction
        if self.animrect.right > self.w or self.animrect.left < 0:
            self.smoothfactor = 0.08
            if self.step_x < 0:
                self.animrect.left = 0
                self.sleep = True
            else:
                self.animrect.right = self.w

            self.step_x = -self.step_x

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

    PADDING = 3
    HANDLED_KEYS = set(
        [
            pygame.K_DELETE,
            pygame.K_BACKSPACE,
            pygame.K_LEFT,
            pygame.K_RIGHT]).union(
        range(
            pygame.K_a,
            pygame.K_z +
            1)).union(
        range(
            pygame.K_0,
            pygame.K_9 +
            1))

    def __init__(self, dimensions, pos, text="", text_colour=(0, 0, 0),
                 text_font=(None, 50), bg_colour=(255, 255, 255),
                 frame_colour=(0, 0, 0), frame_size=1):
        Rect.__init__(self, (pos[0] - dimensions[0] / 2,
                             pos[1] - dimensions[1] / 2), dimensions)
        self.text = text
        self.text_colour = text_colour
        self.text_font = text_font
        self.create_char_avatars()
        self.bg_colour = bg_colour
        self.frame_colour = frame_colour
        self.frame_size = frame_size
        self.input_cursor = Rect((self.left, self.top + InputBox.PADDING),
                                 (2, (self.height - 2 * InputBox.PADDING)))
        self.put_cursor(self.right)
        self.clicked = False
        self.state = "normal"
        self.char_limit = None
        self.handled_chars = InputBox.HANDLED_KEYS

    def draw(self, surface):
        if self.bg_colour is not None:
            pygame.draw.rect(surface, self.bg_colour, self, 0)
        if self.frame_colour is not None:
            pygame.draw.rect(surface, self.frame_colour, self, self.frame_size)
        shift = 0
        for char in self.char_avatars:
            surface.blit(char, (
                self.left + InputBox.PADDING + shift,
                self.centery - char.get_height() / 2))
            shift += char.get_width()
        if self.state == "active":
            pygame.draw.rect(surface, self.text_colour, self.input_cursor)

    def create_char_avatars(self):
        self.char_avatars = []
        for char in self.text:
            char_avatar = pygame.font.Font(*self.text_font).render(
                char, 20, self.text_colour)
            if char_avatar.get_height() > self.y:
                char_avatar = pygame.transform.scale(
                    char_avatar, (char_avatar.get_width(), self.height))
            self.char_avatars.append(char_avatar)

    def put_cursor(self, cursor_x):
        error = cursor_x - (self.left + InputBox.PADDING)
        self.cursor_index = len(self.char_avatars)
        for index, char in enumerate(self.char_avatars):
            if error < char.get_width() / 2:
                self.cursor_index = index
                break
            error -= char.get_width()
        cursor_x -= error
        self.input_cursor.move_ip(cursor_x - self.input_cursor.left, 0)

    def update_state(self, cursor_pos, event):
        cursor_on_inputbox = self.collidepoint(cursor_pos)
        if self.state is "active":
            if not cursor_on_inputbox:
                if event:
                    self.state = "normal"
                CURSORS["arrow"]()
            if cursor_on_inputbox:
                if event:
                    self.put_cursor(cursor_pos[0])
                CURSORS["textmarker"]()
        elif self.state is "hover":
            if event and cursor_on_inputbox:
                self.state = "active"
                self.put_cursor(cursor_pos[0])
            elif not cursor_on_inputbox:
                self.state = "normal"
                CURSORS["arrow"]()
        else:
            if event and cursor_on_inputbox:
                self.state = "active"
                CURSORS["textmarker"]()
                self.put_cursor(cursor_pos[0])
            elif cursor_on_inputbox:
                self.state = "hover"
                CURSORS["textmarker"]()

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

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

#.........这里部分代码省略.........
        """ scroll the background in pixels

        :param vector: (int, int)
        """
        self.center((vector[0] + self.view_rect.centerx,
                     vector[1] + self.view_rect.centery))

    def center(self, coords):
        """ center the map on a pixel

        float numbers will be rounded.

        :param coords: (number, number)
        """
        x, y = [round(i, 0) for i in coords]
        self.view_rect.center = x, y

        if self.clamp_camera:
            self.view_rect.clamp_ip(self.map_rect)
            x, y = self.view_rect.center

        # calc the new position in tiles and offset
        tw, th = self.data.tile_size
        left, self._x_offset = divmod(x - self._half_width, tw)
        top, self._y_offset = divmod(y - self._half_height, th)

        # adjust the view if the view has changed without a redraw
        dx = int(left - self._tile_view.left)
        dy = int(top - self._tile_view.top)
        view_change = max(abs(dx), abs(dy))

        if view_change <= self._redraw_cutoff:
            self._buffer.scroll(-dx * tw, -dy * th)
            self._tile_view.move_ip((dx, dy))
            self._queue_edge_tiles(dx, dy)
            self._flush_tile_queue()

        elif view_change > self._redraw_cutoff:
            logger.info('scrolling too quickly.  redraw forced')
            self._tile_view.move_ip((dx, dy))
            self.redraw_tiles()

    def _queue_edge_tiles(self, dx, dy):
        """ Queue edge tiles and clear edge areas on buffer if needed

        :param dx: Edge along X axis to enqueue
        :param dy: Edge along Y axis to enqueue
        :return: None
        """
        v = self._tile_view
        fill = partial(self._buffer.fill, self._clear_color)
        tw, th = self.data.tile_size
        self._tile_queue = iter([])

        def append(rect):
            self._tile_queue = chain(self._tile_queue, self.data.get_tile_images_by_rect(rect))
            if self._clear_color:
                fill(((rect[0] - self._tile_view.left) * tw,
                      (rect[1] - self._tile_view.top) * th,
                      rect[2] * tw, rect[3] * th))

        if dx > 0:    # right side
            append((v.right - dx, v.top, dx, v.height))

        elif dx < 0:  # left side
            append((v.left, v.top, -dx, v.height))

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

    def __init__(self, ui, surface, font, x, y, species):
        self.ui = ui
        self.surface = surface
        self.species = species
        self.font = font
        self.x = x
        self.y = y
        self.padding = (10, 10, 10, 10)
        self.line_height = 20
        self.width = info_panel_config.width - 1
        self.height = 300
        self.color = (255, 255, 255)
        self.mutated_param_color = (100, 255, 100)
        self.labels = None
        self.border_rect = Rect(self.x, self.y, self.width, self.height)
        self.border_width = 1
        self.border_color = (255, 255, 255)
        self.bg_rect = Rect(self.x + self.border_width, self.y + self.border_width,
                            self.width - self.border_width * 2, self.height - self.border_width * 2)
        self.bg_color = (30, 30, 30)
        self.y_offset = 0
        self._generate_labels()

    def _generate_labels(self):
        self.labels = []
        self.y_offset = self.y + self.padding[0]
        self._add_label('Type: %s' % str(self.species.life_obj.type))
        self._add_label('Size: %.2f' % float(self.species.life_obj.inheritable_size),
                        'size' in self.species.life_obj.mutated_params)
        self._add_label('Nutritional value: %.2f' % float(self.species.life_obj.inheritable_nutritional_value),
                        'nutritional_value' in self.species.life_obj.mutated_params)
        self._add_label('Defence: %.2f' % float(self.species.life_obj.inheritable_defence),
                        'defence' in self.species.life_obj.mutated_params)
        self._add_label('Attack: %.2f' % float(self.species.life_obj.inheritable_attack),
                        'attack' in self.species.life_obj.mutated_params)
        self._add_label('Speed: %.2f' % float(self.species.life_obj.inheritable_speed *
                                              self.species.life_obj.environment.calculate_speed_factor(
                                                  self.species.life_obj.humidity_likeness,
                                                  self.species.life_obj.temperature_likeness)),
                        'speed' in self.species.life_obj.mutated_params)
        self._add_label('Reproducing interval: %.2f' % float(self.species.life_obj.reproducing_interval),
                        'reproducing_interval' in self.species.life_obj.mutated_params)
        self._add_label('Reproducing probability: %.2f' % float(self.species.life_obj.reproducing_probability),
                        'reproducing_probability' in self.species.life_obj.mutated_params)
        self._add_label('Energy needed to reproduce: %.2f' % float(self.species.life_obj.energy_needed_to_reproduce),
                        'energy_needed_to_reproduce' in self.species.life_obj.mutated_params)
        self._add_label('Energy move cost: %.2f' % float(self.species.life_obj.energy_move_cost),
                        'energy_move_cost' in self.species.life_obj.mutated_params)
        self._add_label('Energy live cost: %.2f' % float(self.species.life_obj.energy_live_cost),
                        'energy_live_cost' in self.species.life_obj.mutated_params)

    def _add_label(self, text, param_has_mutated=False):
        self.labels.append(Label(self.ui, self.surface, text,
                                 self.x + self.padding[3], self.y_offset, self.font,
                                 self.color if not param_has_mutated else self.mutated_param_color))
        self.y_offset += self.line_height

    def draw(self, y):
        if y is not None and y + self.line_height != self.y:
            y += self.line_height
            self.border_rect.move_ip(0, y - self.y)
            self.bg_rect.move_ip(0, y - self.y)
            self.y = y
            self._generate_labels()
        pygame.draw.rect(self.surface, self.border_color, self.border_rect, self.border_width)
        pygame.draw.rect(self.surface, self.bg_color, self.bg_rect, 0)
        for label in self.labels:
            label.draw()

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move_ip [as 别名]
class Monster(sprite.Sprite):
    def __init__(self, move_time, nodes):
        sprite.Sprite.__init__(self)
        self.nodes = nodes
        self.orig_nodes = nodes
        self.move_time = move_time
        self.spawn_time = time.time()
        self.image = Surface((40, 40)).convert()
        self.image_inside = Surface((38, 38)).convert()
        self.image_inside.fill((0, 255, 0))
        self.image.blit(self.image_inside, (1, 1))
        self.pos = (80, 40)
        self.real_pos = (80, 40)
        self.rect = Rect(self.pos, self.image.get_size())
        self.speed = 2
        self.speed_mod = 1
        self.diag_speed = 2
        self.target_pos = (880, 560)
        self.value = 1
        self.cost = 0
        self.health = 100
        self.damage_mod = 1
        self.counter = 0
        self.cur_node = self.nodes[0]
        self.the_dir = (0, 0)
        self.can_move = False

        self.name = "Monster"
        self.description = "A basic monster with slow movement speed and moderate health."

    def update(self, window):

        if time.time() - self.spawn_time >= self.move_time:
            self.can_move = True
            # If it's hit the last block
            if len(self.nodes) < 1:
                self.kill()
                return self.value
            else:

                # Figuring direction
                if self.nodes[0].rect.x > self.cur_node.rect.x:
                    self.the_dir = (1, 0)
                elif self.nodes[0].rect.x < self.cur_node.rect.x:
                    self.the_dir = (-1, 0)
                elif self.nodes[0].rect.y > self.cur_node.rect.y:
                    self.the_dir = (0, 1)
                elif self.nodes[0].rect.y < self.cur_node.rect.y:
                    self.the_dir = (0, -1)

                # Check to see the most the monster can move
                for speed in range(0, self.speed+1):
                    t_dir = tuple([x * speed * self.speed_mod for x in self.the_dir])

                    # Monster can only move this much
                    if self.rect.move(t_dir) == self.nodes[0].rect:
                        self.rect.move_ip(t_dir)
                        self.real_pos = tuple(map(sum, zip(self.real_pos, t_dir)))
                        self.cur_node = self.nodes.pop(0)
                        break
                else:
                    # The monster can move by self.speed
                    a = tuple([x * self.speed * self.speed_mod for x in self.the_dir])
                    self.real_pos = tuple(map(sum, zip(self.real_pos, a)))
                    self.pos = tuple(map(round, self.real_pos))
                    self.rect.x, self.rect.y = self.pos

                # Conditions for the monster to die
                die_conditions = [self.rect.top >= window.get_height(),
                                  self.rect.left >= window.get_width(),
                                  self.rect.bottom <= 0]
                if any(die_conditions):
                    self.kill()
                    return self.value

                # Resetting the modifiers, they'll be changed if the monster is under an effect
                self.speed_mod = 1
                self.damage_mod = 1
        return 0

    # Does damage to the monster and checks if it dies
    def damage(self, damage):
        self.health -= damage*self.damage_mod

        # Returns the amount of money to grant the player if the monster dies and also how much damage was done
        if self.health <= 0:
            self.kill()
            return self.value, damage*self.damage_mod
        else:
            return None, damage*self.damage_mod

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move_ip [as 别名]
    def draw(self, surface, rect):
        onScreen = []

        if self.blank:
            self.blank = False
            self.maprender.blank = True

        visible_shapes = self.area.space.bb_query(toBB(self.extent))

        for child in [ child for child in self.area if child.avatar]:
            shape = child.shapes[0]
            if shape not in visible_shapes:
                continue

            bb = child.bb
            x = bb.left - self.extent.left - child.avatar.axis.x
            y = bb.top - self.extent.top

            if hasattr(shape, "radius"):
                w, h = child.avatar.image.get_size()
                angle = -(math.degrees(shape.body.angle)) % 360
                image = rotozoom(child.avatar.image.convert_alpha(), angle, 1.0)
                ww, hh = image.get_size()
                rrect = Rect(x, y-h, ww, hh)
                rrect.move_ip((w-ww)/2, (h-hh)/2)
            else:
                w, h = child.avatar.image.get_size()
                rrect = Rect(x, y - h, w, h)
                image = child.avatar.image
            onScreen.append((image, rrect, 1))

        if parallax:
            self.parallaxrender.draw(surface, rect, [])

        dirty = self.maprender.draw(surface, rect, onScreen)

        if DEBUG:
            def translate((x, y)):
                return x - self.extent.left, y - self.extent.top

            for shape in self.area.space.shapes:
                try:
                    points = [ translate(i) for i in shape.get_points() ]
                except AttributeError:
                    pass
                else:
                    draw.aalines(surface, (255,100,100), 1, points)
                    continue

                try:
                    radius = shape.radius
                    pos = shape.body.position
                    pos = translate(pos)
                    pos += shape.offset
                except AttributeError:
                    pass
                else:
                    pos = map(int, pos)
                    draw.circle(surface, (255,100,100), pos, int(radius), 1)
                    continue

        return dirty

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

#.........这里部分代码省略.........
		if spritey < scroll_top_point:
			self.move_view(0, spritey - scroll_top_point)
			
		scroll_bottom_point = self.view_rect.bottom - height_space
		if spritey > scroll_bottom_point:
			self.move_view(0, spritey - scroll_bottom_point)

	def update(self, *args):
		self.group.update(*args)
		self.scroll()
		self.check_collisions()
		self.time = self.time - (1.0/FPS)
		self.check_status()
		
	def check_status(self):
		self.finish = self.main_character.death() or self.won or self.time <= 0

	def check_collisions(self):
		tman = self.main_character
		pygame.sprite.groupcollide(self.bullet_group, self.enemies_group, True, True)
		pygame.sprite.groupcollide(self.special_block_group, self.bullet_group, True, True)
		pygame.sprite.groupcollide(self.special_block_group, self.enemy_bullet_group, False, True)
		pygame.sprite.groupcollide(self.enemy_bullet_group, self.bullet_group, True, True)
		enemies = pygame.sprite.spritecollide(tman, self.enemies_group, not tman.blinking)
		bullets = pygame.sprite.spritecollide(tman, self.enemy_bullet_group, not tman.blinking)
		items = pygame.sprite.spritecollide(tman, self.items_group, True)
		special_items = pygame.sprite.spritecollide(tman, self.special_items_group, True)
		
		for enemy in enemies:
			tman.enemy_touched(enemy)
		
		for bullet in bullets:
			tman.bullet_touched()
			
		for item in items:
			tman.item_touched(item)
			
		for item in special_items:
			item.use()
	
	
	def draw(self, surface, draw_position):
		tw, th = self.TILE_SIZE
		tile_x1, tile_y1 = self.pixel_to_tile(self.view_rect.left, self.view_rect.top)
		tile_x2, tile_y2 = self.pixel_to_tile(self.view_rect.right, self.view_rect.bottom)
		
		dx, dy = draw_position
		
		clip_rect = Rect(draw_position, (self.view_rect.width, self.view_rect.height))
		surface.set_clip(clip_rect)
				
		self.actual_rects = []
		self.update_rects = self.previous_rects
		
		if len(self.previous_rects) == 0:
			self.previous_rects.append(clip_rect)
		
		for rect in self.previous_rects:
			area = rect.move(-dx, -dy)
			surface.blit(self.background, rect, area)

		for x in range(tile_x1, tile_x2 + 1):
			for y in range(tile_y1, tile_y2 + 1):
				
				pos_x = dx + x * tw - self.view_rect.left
				pos_y = dy + y * th - self.view_rect.top
				image = self.get_tile(x, y)
				if image is not None and image != 0:
					surface.blit(image, (pos_x, pos_y))
					self.actual_rects.append(image.get_rect().move(pos_x, pos_y))
					
		self.actual_rects += self.group.draw(surface, draw_position)
					
		surface.set_clip(None)
		
		self.update_rects += self.actual_rects
		self.previous_rects = self.actual_rects
		
	def move_view(self, x, y):
		self.view_rect.move_ip(x, y)
		
		self.view_rect.top = max(self.rect.top, self.view_rect.top)
		self.view_rect.left = max(self.rect.left, self.view_rect.left)
		self.view_rect.right = min(self.rect.right, self.view_rect.right)
		self.view_rect.bottom = min(self.rect.bottom, self.view_rect.bottom)
		
	def goto_bottom(self):
		self.view_rect.bottom = self.rect.bottom
		
	def goto_left(self):
		self.view_rect.left = self.rect.left
		
	def goto_right(self):
		self.view_rect.right = self.rect.right

	def goto_top(self):
		self.view_rect.right = self.rect.right
		
	def set_main_character(self, sprite):
		self.main_character = sprite

# 需要导入模块: from pygame import Rect [as 别名]
# 或者: from pygame.Rect import move_ip [as 别名]
class cMsg():
	HOLD_TIME = 2
	
	def __init__(self,string,window):
		font.init()
		self.text = string
        	self.myfont = font.SysFont("Arial", 20)
        	self.render_font = self.myfont.render(string, 1, C.black)
		w = self.render_font.get_width()
		h = self.render_font.get_height()
		self.winh = window.get_height()
		self.rect = Rect(0,self.winh,w,h)
		
		self.movein = False
		self.moveout = False
		self.hold = False
		self.hold_start = 0
	
	def draw(self,window):
		"""
			Draw the current message
		"""
		draw.rect(window, C.white, self.rect)
        	window.blit(self.render_font, (self.rect.x, self.rect.y))

	def update_logic(self,window):
		"""
			Movein and Moveout logic movement
		"""
		if self.movein:
			fh = self.render_font.get_height()
			self.rect.move_ip(0,-1)
			if self.rect.y <= window.get_height()-fh:
				self.move_hold()

		elif self.moveout:
			self.rect.move_ip(0,1)
			if self.rect.y > window.get_height():
				self.move_stop()
		elif self.hold:
			self.update_hold()

	def update_hold(self):
		"""
			Controls how much time the message must stay
			between movein state and moveout state
		"""
		ctime = time.time()
		if (ctime - self.hold_start) > self.HOLD_TIME:
			self.move_out()

	#
	# Flag control for movement
	#
	def move_in(self):
		self.movein = True
		self.moveout = False
		self.hold = False

	def move_out(self):
		self.movein = False
		self.moveout = True
		self.hold = False
	
	def move_hold(self):
		self.movein = False
		self.moveout = False
		self.hold = True
		self.hold_start = time.time()

	def move_stop(self):
		self.movein = False
		self.moveout = False
		self.hold = False

	def set_text(self,string,movein=True):
		"""
			Set a new text for the message.
			Additionally it shows the message. the flag movein controls that True=>Move in, False=> simply set text
		"""
		self.text = string
        	self.render_font = self.myfont.render(string, 1, C.black) 
		w = self.render_font.get_width()
		h = self.render_font.get_height()
		self.rect = Rect(0,self.winh,w,h)

		if movein: self.move_in()