Python Surface.set_alpha方法代码示例

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
    def draw(self):
        """
        Method called each frame to (re)draw the objects and UI
        :return:
        """
        if not self.overlay_drawn:
            overlay = Surface((self.scaled_width, LEVEL_HEIGHT))
            overlay.set_alpha(128)
            overlay.fill((0, 0, 0))
            self.overlay_drawn = True
            self.screen.blit(overlay, (0, 0))

        o_max_width = max([option.get_rect().width for option in self.menu_options])
        width = o_max_width + MENU_PADDING[0] * 2
        height = self.menu_options[0].get_rect().height + MENU_PADDING[1] * 2
        x = self.scaled_width / 2 - width / 2
        y = LEVEL_HEIGHT / 2 - (height * len(self.menu_options)) / 2
        counter = 0
        for option in self.menu_options:
            if counter == self.menu_option:
                used_color = MENU_COLORS[1]
            else:
                used_color = MENU_COLORS[0]
            draw.rect(self.screen, used_color, (x, y + counter * height, width, height), 0)
            option_x = x + MENU_PADDING[0] + (o_max_width - option.get_rect().width) / 2
            self.screen.blit(option, (option_x, y + height * counter + MENU_PADDING[1]))
            counter += 1

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
	def load_transparent_image(self):
		image = Surface((32, 32))
		image.fill(DEFAULT_COLORKEY)
		image.set_colorkey(DEFAULT_COLORKEY)
		image.blit(self.image, (0, 0))
		image.set_alpha(120)
		self.transparent_image = image

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
    def finish_game(self):
        """
        Function triggered on the game end, passed to the Level
        :return:
        """
        self.game_finished = True
        self.end_labels = []
        player1score = self.levels[0].player.score
        player2score = self.levels[1].player.score
        if player1score > player2score:
            self.end_labels.append(Assets.menu_font.render("Player 1 wins!", 1, (255, 255, 255)))
        elif player1score < player2score:
            self.end_labels.append(Assets.menu_font.render("Player 2 wins!", 1, (255, 255, 255)))
        else:
            self.end_labels.append(Assets.menu_font.render("Draw!", 1, (255, 255, 255)))
        self.end_labels.append(Assets.font.render("Player 1 score: " + str(player1score), 1,
                                                  (255, 255, 255)))
        self.end_labels.append(Assets.font.render("Player 2 score: " + str(player2score), 1,
                                                  (255, 255, 255)))
        self.end_labels.append(Assets.font.render("Press enter to return to menu", 1,
                                                  (255, 255, 255)))

        overlay = Surface((LEVEL_WIDTH * 2, LEVEL_HEIGHT))
        overlay.set_alpha(128)
        overlay.fill((0, 0, 0))
        self.screen.blit(overlay, (0, 0))

        y = LEVEL_HEIGHT / 2 - sum([label.get_rect().height / 2 for label in self.end_labels])
        offset = 0
        for label in self.end_labels:
            self.screen.blit(label, (LEVEL_WIDTH - label.get_rect().width / 2, y + offset))
            offset = offset + label.get_rect().height

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
 def _create_image(self):
     grp = Group()
     for word in self.words:
         if len(grp.sprites()) == 0:
             word.scale(self.ratio+0.2)
             pm_w = word.rect.width
             pm_h = word.rect.height
             pm_x, pm_y = place_primary(pm_w, pm_h)
             word.rect.x, word.rect.y = pm_x, pm_y
             arch_x = pm_x + pm_w/2
             arch_y = pm_y + pm_h/2
         else:
             word.scale(self.ratio)
             for x, y in archimedean_spiral(False):
                 if self.debug:
                     rs = Surface((5, 5))
                     rs.fill((0, 0, 255))
                     rs.set_alpha(100)
                     self.sf.blit(rs, (x + arch_x, y + arch_y))
                 word.set_position(x + arch_x, y + arch_y)
                 x_out = CANVAS_WIDTH - CANVAS_PADDING < word.rect.x + word.rect.width or word.rect.x < CANVAS_PADDING
                 y_out = CANVAS_HEIGHT - CANVAS_PADDING < word.rect.y + word.rect.height or word.rect.y < CANVAS_PADDING
                 out_of_bound = x_out or y_out
                 if spritecollideany(word, grp, collide_mask) is None and not out_of_bound:
                     if self.debug:
                         rs = Surface((5, 5))
                         rs.fill((0, 255, 0))
                         rs.set_alpha(100)
                         self.sf.blit(rs, (x + arch_x, y + arch_y))
                     break
         self.sf.blit(word.image, word.rect)
         grp.add(word)

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
class Nest(Entity):
	"""
	Encapsulates a colony of ants
	"""
	def __init__(self, world, id, size, location, ant_count):
		self.id = id
		self.size = size
		self.world = world
		self.ant_count = ant_count
		super(Nest, self).__init__(world, location, size, None)
		self.spawn_ants()
		self.mark_home()
		self.set_image()

	def set_image(self):
		w, h = self.size
		w *= self.world.cell_size
		h *= self.world.cell_size
		self.image = Surface((w,h))
		self.image.fill(YELLOW)
		self.image.set_alpha(196)

	def mark_home(self):
		"""
		Converts the cell at its location to its nest
		"""
		width, height = self.size
		# width /= self.world.settings["cell_size"]
		# height /= self.world.settings["cell_size"]
		x, y = self.location
		for i in range(width):
			for j in range(height):
				self.world[(x+i,y+j)].make_home(self.id)

	def spawn_ants(self):
		"""
		Creates instances of ants and adds them into the world
		"""
		for ant in self.ant_count:
			for i in range(self.ant_count[ant]):
				self.add_new_ant(ant)

	def add_new_ant(self, ant_type):
		x, y = self.location
		width, height = self.size
		direction = randint(1,8)
		location = x+randint(0,width/self.world.settings["cell_size"]), y+randint(0,height/self.world.settings["cell_size"])
		new_ant = ant_type(self.world, self.world.images["ant"], direction, location, self)
		self.world.add_ant(new_ant)

	def add_new_ant_randomly(self):
		num = randint(1,100)
		if num<90:
			ant = WorkerAnt
		elif num<98:
			ant = SoldierAnt
		else:
			ant = QueenAnt
		self.add_new_ant(ant)

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
 def set_alpha(self):
     if self.alpha != 255:
         self.alpha += 10
     if self.alpha != 255:
         surf = Surface(self.rect.size)
         surf.fill(self.anticolor)
         surf.set_colorkey(self.anticolor)
         surf.blit(self.text, (0, 0))
         surf.set_alpha(self.alpha)
         return surf
     else:
         return self.text

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
	def generate_fire_sprite(self):
		if self.upgrade_levels[0] >= 3:
			self.set_fire_ring(None)
			return
		fire_width = self.fire_width
		fire_effect_image = Surface((92, 92))
		fire_effect_image.fill(DEFAULT_COLORKEY)
		fire_effect_image.set_colorkey(DEFAULT_COLORKEY)
		pygame.draw.line(fire_effect_image, self.fire_color, (46, 30), (46, 0), fire_width)
		pygame.draw.line(fire_effect_image, self.fire_color, (30, 46), (0, 46), fire_width)
		pygame.draw.line(fire_effect_image, self.fire_color, (62, 46), (92, 46), fire_width)
		pygame.draw.line(fire_effect_image, self.fire_color, (46, 62), (46, 92), fire_width)
		fire_effect_image.set_alpha(225)
		self.fire_sprite = pygame.sprite.Sprite()		
		self.fire_sprite.image = fire_effect_image
		self.fire_sprite.rect = Rect(self.rect.left - 30, self.rect.top - 30, 92, 92)
		self.fire_sprite.mask = pygame.mask.from_surface(self.fire_sprite.image)

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
class LightColumn(GameObject):
    '''
    This class exists to let the player know where exactly he's aiming.
    '''
    SIZE = Rect(0, 0, 32, config.SCREEN_HEIGHT - 32 * 3)
    
    def __init__(self):
        super().__init__()
        self.image    = Surface(self.__class__.SIZE.size, config.BLIT_FLAGS)
        self.position = [-300.0, -300.0]
        self.rect     = Rect(self.position, self.__class__.SIZE.size)
        self.state    = 1
        
        self.image.fill(color.WHITE)
        self.image.set_alpha(128)
        del self.acceleration, self.velocity
        
    actions = {1 : None}

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
 def __init__(self, config, *args, **kwargs):
     super(Game, self).__init__(config, *args, **kwargs)
     self.background = Surface(config.RESOLUTION)
     self.rendering = sprite.LayeredDirty()
     self.player = sprite.GroupSingle()
     self.creeps = sprite.Group()
     image = Surface((20, 20)).convert(self.display)
     image.fill((255, 255, 255))
     mob.Player(image, 0, config, self.rendering, self.player, self.rendering)
     self.rendering.change_layer(self.player.sprite, 1)
     self.camera = FollowCam(Vector(0, 0), self.player.sprite, config,
                             max_dist=100, max_speed=(60))
     offset = self.camera.get_offset()
     image = Surface((20, 20)).convert(self.display)
     image.fill((0, 128, 0))
     m_image = Surface((100, 100)).convert(self.display)
     m_image.set_alpha(64)
     m_image.fill((128, 64, 192))
     for x in xrange(config.INITIAL_SPAWN):
         mob.Creep(image, m_image, self.player.sprite, offset, config, self.rendering, self.creeps, self.rendering)

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
    def finish_game(self):
        """
        Function triggered on the game end, passed to the Level
        :return:
        """
        self.game_finished = True
        self.end_labels = (
            Assets.menu_font.render("Congratulations!", 1, (255, 255, 255)),
            Assets.font.render("Your final score: " + str(self.level.player.score), 1,
                               (255, 255, 255)),
            Assets.font.render("Press enter to return to menu", 1, (255, 255, 255))
        )

        overlay = Surface((LEVEL_WIDTH, LEVEL_HEIGHT))
        overlay.set_alpha(128)
        overlay.fill((0, 0, 0))
        self.screen.blit(overlay, (0, 0))

        y = LEVEL_HEIGHT / 2 - sum([label.get_rect().height / 2 for label in self.end_labels])
        offset = 0
        for label in self.end_labels:
            self.screen.blit(label, (LEVEL_WIDTH / 2 - label.get_rect().width / 2, y + offset))
            offset = offset + label.get_rect().height

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
class Main(Sprite):
    """
    Main glyph class
    image-- the image that text is set to
    rect-- rect for blitting image to viewing surface
    spacing-- line spacing
    links-- dict of (link, [rects]) pairs
    """


    ##################################################################
    # class methods
    def __init__(self, rect, **kwargs):
        """
        Initialize a glyph object

        rect-- rect object for positioning glyph image on viewing surface
        **kwargs-- dictionary of (env_id, value) pairs
          required kwargs are:
          bkg-- background color
          color-- font color
          font-- font
        """
        self.image = Surface(rect.size)#dodal ALPHA
        self.image.fill(kwargs['bkg'])
        self.image.set_alpha(255)


        self._bkg = kwargs['bkg']
        self.rect = rect
        self.spacing = kwargs['spacing']
        self.links = defaultdict(list)
        self._dest = Rect(0, 0, 0, 0) # rect for blitting a text line to image surface
        # list of (env_id, value) pairs for environments;
        # _envs is used as a stack data structure
        self._envs = [('bkg', kwargs['bkg']),
                      ('color', kwargs['color']),
                      ('font', kwargs['font']),
                      ('link', None)] # link id string
        #print self._envs
        self._buff = deque() # rendered text buffer


    ##################################################################
    # helper methods
    def __read_env(self, _txt_):
        # helper function to interpret
        # accepts the _txt_ iterable at an environment starting point
        # return (environment type, environment) tuple (e.g (font, Font object))

        # re to get env arguments (arguments may be paths and contain \ or /)
        r = re.compile('(\w+)(?:\s+([\w\s\.,=\\\\/]+))?\s*;')
        charbuffer = ''
        # _txt_ is a generator, so iterating consumes the contents for the
        # references to _txt_ in the _interpret function
        for i, char in _txt_:
            charbuffer += char
            s = r.search(charbuffer) # search for environment name arguments
            if s: # if search successful
                env = s.groups() # get environment
                if env[0] in Macros: return Macros[env[0]]
                # new environment types must be added here

                elif env[0] == 'bkg':
                    # return new backgroun color
                    return ('bkg', tuple([int(e) for e in env[1].split(',')]))

                elif env[0] == 'color':
                    # return new font color
                    return ('color', tuple([int(e) for e in env[1].split(',')]))

                elif env[0] == 'font':
                    # return new font
                    path, size = env[1].split(',') # the font location and size
                    return ('font', Font(os.path.realpath(path), int(size)))

                elif env[0] == 'link':
                    # return new link
                    return ('link', env[1].strip())
                elif env[0] == 'id': #moje
                    return('id', env[1].strip())

                else:
                    raise ValueError(env[0] + ' is an unrecognized environment')


    # the space func could take a size and return a surface or rect...
    # really only need to shift tokens.  surfs do that without requiring tokens
    # to have rects
    def __read_func(self, _txt_):
        # helper function to interpret
        # accepts the _txt_ iterable at function starting point
        # returns (function type, function results) tuple
        #   (eg. (space, Surface obejct))
        r = re.compile('(\w+){(.*?)}')
        i, char = _txt_.next()

        if char in SPECIALS: return char
        if char in WHITESPACE: return WHITESPACE[char]

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

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
class MiniMap(object):
   def __init__(self, mapInfo):
      fp = open(mapInfo)
      
      jData = json.load(fp)
      
      fp.close()
      
      self.drawSize = 3
      self.downScale = 2
      self.__blinkCount = 0
      self.__showPlayer = True
      self.__blinkSpeed = 0.003
      self.__alpha = 200
      
      self.__colors = {
         "poi" : (255, 255, 255), "grassland" : (38,200,80),
         "forest" : (0,60,5), "plains" : (150,150,90),
         "mountain" : (117,26,12), "water" : (0,30,100),
         "desert" : (255,255,102), "snow" : (190,190,255)
      }

      self.poiLocs = []

      self.size = [x / self.downScale for x in jData["size"]]

      
      self.__map = Surface([x * self.drawSize for x in self.size])
      self.canvas = Surface([x * self.drawSize for x in self.size])
      
      self.canvas.set_alpha(self.__alpha)
      for x in range(self.size[0]):
         jRows = []
         for i in range(self.downScale):
            jRows.append(jData["tiles"][x * self.downScale + i])
            
         for y in range(self.size[1]):
            # draw each pixel
            tTypes = []
            for jr in jRows:
               for j in range(self.downScale):
                  tTypes.append(jr[y * self.downScale + j])
                  
            color = [0,0,0]
            cCount = 0
            poiFound = False
            
            for t in tTypes:
               if t not in locations.keys():
                  cCount += 1
                  for rgb in range(3):
                     color[rgb] += self.__colors[t][rgb]
               elif not poiFound:
                  if t != "MasterSword":
                     self.poiLocs.append((x,y))
                     poiFound = True
            
            for rgb in range(3):
               color[rgb] /= cCount
               
            area = Rect((x * self.drawSize, y * self.drawSize),
                        (self.drawSize, self.drawSize))
            draw.rect(self.__map, color, area)
            
      
      

   def draw(self, canvas, playerLocation, windowSize=(640,480)):
      
      self.canvas.blit(self.__map, (0,0))
      
      
      if self.__showPlayer:
         
         for poi in self.poiLocs:
            
            area = Rect((poi[0] * self.drawSize, poi[1] * self.drawSize),
                        (self.drawSize, self.drawSize))
            draw.rect(self.canvas, (0,0,0), area)
            
         area = Rect((int(playerLocation[0] / self.downScale) * self.drawSize,
                      int(playerLocation[1] / self.downScale) * self.drawSize),
                     (self.drawSize, self.drawSize))
         draw.rect(self.canvas, (255,0,0), area)
            
      
      canvas.blit(self.canvas, (windowSize[0] - (self.size[0] * self.drawSize),
                                windowSize[1] - (self.size[1] * self.drawSize)))
      
   
   def update(self, ticks):
      self.__blinkCount += self.__blinkSpeed * ticks
      
      if self.__blinkCount > 1:
         self.__blinkCount -= 1
         self.__showPlayer = not self.__showPlayer

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

#.........这里部分代码省略.........
            return
        
        if (event.signal == SIG_FOCUSED) and (event.data != self):
            self.focus = False
        elif (event.signal == SIG_ENTER) and (event.data != self):
            self.entered = False

    def update (self, **kwargs):
        """W.update (...) -> None

        Updates the widget.

        Updates the widget and causes its parent to update itself on
        demand.
        """
        if self.locked:
            return

        oldrect = Rect (self._oldrect)
        resize = kwargs.get ("resize", False)

        if not self.dirty:
            children = kwargs.get ("children", {})
            blit = self.image.blit
            items = children.items ()

            # Clean up the dirty areas on the widget.
            for child, rect in items:
                blit (self._bg, rect, rect)
            # Blit the changes.
            for child, rect in items:
                blit (child.image, child.rect)

            self._image.set_alpha (self.opacity)
            # If a parent's available, reassign the child rects, so that
            # they point to the absolute position on the widget and build
            # one matching them all for an update.
            if self.parent:
                vals = children.values ()
                rect = oldrect
                if len (vals) != 0:
                    rect = vals[0]
                    x = self.x
                    y = self.y
                    for r in vals:
                        r.x += x
                        r.y += y
                    rect.unionall (vals[1:])
                self.parent.update (children={ self : rect }, resize=resize)
            self._lock = max (self._lock - 1, 0)
            return

        # Acquire lock to prevent recursion on drawing.
        self._lock += 1

        # Draw the widget.
        self.draw ()
        self._image.set_alpha (self.opacity)
        if self.parent != None:
            resize = oldrect != self._rect
            self.parent.update (children={ self : oldrect }, resize=resize)

        # Release previously set lock.
        self._lock = max (self._lock - 1, 0)
        self.dirty = False

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
def render_tooltips():
    """Render the tooltip for the object under the mouse."""
    obj = object_under_mouse()
    if obj:
        if obj.__class__.__name__ == "ClientMonster":
            hp_bar = True
        else:
            hp_bar = False

        bar_len = 100

        if CS.u.fov_map.in_fov(obj.x, obj.y):
            text = "You see: " + obj.name
        else:
            text = "You remember seeing: " + obj.name

        text_img = CS.font.render(text, True, CLR["white"])
        text_rect = text_img.get_rect()

        if hp_bar and text_rect.w < bar_len:
            surf_w = bar_len
        else:
            surf_w = text_rect.w

        surf_w += cfg.PADDING * 2 + cfg.BORDER_W * 2

        surf_h = text_rect.h + cfg.PADDING * 2 + cfg.BORDER_W * 2
        if hp_bar:
            surf_h += CS.font_h

        # pylint: disable=E1121
        tooltip_surf = Surface((surf_w, surf_h)).convert()
        # pylint: enable=E1121
        tooltip_surf.fill(CLR["black"])

        text_rect.centerx = surf_w / 2
        text_rect.top = cfg.BORDER_W + cfg.PADDING
        tooltip_surf.blit(text_img, text_rect)

        if hp_bar:
            render_bar(
                tooltip_surf,
                cfg.BORDER_W + cfg.PADDING,
                cfg.BORDER_W + cfg.PADDING + text_rect.h,
                bar_len,
                obj.hp,
                obj.max_hp,
                CS.hp_bar_color,
                CS.hp_bar_bg_color,
            )
            hp_img = CS.font.render(str(obj.hp) + " / " + str(obj.max_hp), True, CLR["white"])
            hp_rect = hp_img.get_rect()
            hp_rect.centerx = cfg.BORDER_W + cfg.PADDING + bar_len / 2
            hp_rect.top = cfg.BORDER_W + cfg.PADDING + text_rect.h
            tooltip_surf.blit(hp_img, hp_rect)

        rect = tooltip_surf.get_rect()
        x, rect.bottom = pygame.mouse.get_pos()

        # The lower left corner of the tooltip is next to the mouse, unless
        # doing so would print the tooltip off the right side of the screen.
        if x + rect.w > CS.screen_rect.w:
            rect.right = x
        else:
            rect.left = x

        add_surface_border(tooltip_surf)
        tooltip_surf.set_colorkey(CLR["floor_blue"])
        tooltip_surf.set_alpha(cfg.TOOLTIP_ALPHA)
        CS.screen.blit(tooltip_surf, rect)

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_alpha [as 别名]
def generateDefaultImage(size):
    i = Surface(size)
    i.fill((0, 128, 128))
    i.set_alpha(128)
    return i