Python Surface.set_colorkey方法代码示例

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [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_colorkey [as 别名]
class Impact(Meteor):
    size = (100,100)
    COLOR = 0,140,0
    duration = 5
    dir = 0
    damage = 10
    
    def __init__(self,loc, bounds, duration, kind, dir = 0):
        
        #print "explosion!"
        self.dir = dir
        # Ice should have moving impacts
        Sprite.__init__(self)
        self.image = Surface(self.size)
        self.rect = self.image.get_rect()
        self.rect.center = loc
        self.image.fill(self.COLOR)
        self.bounds = bounds
        self.duration = duration
        self.kind = kind
        self.get_sprite()
        self.get_sound()
        self.impact_sfx.stop()

        self.impact_sfx.play()
    def get_sprite(self):
        #return

        #-----------This will attempt to load an image, and fill if it fails.
        try:
            self.image = load_image('explosion_'+self.kind)
            print "impact explosion yay"
        except:
            self.image.fill(self.COLOR)
            print "failed to find explosion"
        #Scale the image to the proper size and add random rotation
        #if randint(0,2) == 0:
        #    self.image = pygame.transform.flip(self.image, True, False)
        #self.image = pygame.transform.rotate(self.image, randint(-360,360))
        
        self.image = pygame.transform.scale(self.image, self.size) #temp
        #Anything that's pure white will be transparent
        self.image.set_colorkey((255,255,255))
        #-------
        
    def get_sound(self):
         self.impact_sfx = load_sfx("stockmeteorhit")
        
        
    def update(self):
        self.duration -= 1
        if self.duration <= 0:
            self.coord_x, self.coord_y = self.rect.center
            self.kill()
            
    #def collision(self, robot):
        
        
    def kill (self):
        Sprite.kill(self)

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [as 别名]
class Shield(Sprite):
    color = 255,255,255
    transparent = 0,0,0
    size = 120,120
    kind = "null"
    
    def __init__(self, parent, kind):
        self.parent=parent
        Sprite.__init__(self)
        self.kind = kind
        self.hiss_sfx = load_sfx("hiss")
        if kind == "baseball":
            self.color = 0,90,90
        elif kind == "cigar":
            self.color = 255,100,0
        elif kind == "health":
            self.color = 180, 200, 180
        self.image = Surface(self.size)
        self.rect = self.image.get_rect()
        self.rect.center = self.parent.rect.center
        self.image.fill(self.transparent)
        self.image.set_colorkey(self.transparent)
        pygame.draw.ellipse(self.image, (self.color), self.image.get_rect())
        pygame.draw.ellipse(self.image, self.transparent, self.image.get_rect().inflate(-10, -10))
        #pygame.draw.ellispe(self.image, (30,255,30), self.rect.center, ((self.rect.width)/2))
            
    def update(self):
        
        if not self.parent.alive():
            self.kill()
        
        self.rect.center = self.parent.rect.center

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [as 别名]
class WorldObject(object):
	def __init__(self):
		self.buffer = 0
		self.buffer_needs_update = 1
		self.name = ""

	def render_to(self, screen):
		'''client-side'''
		if self.buffer_needs_update:
			self.update_buffer(screen.get_size())
			self.buffer_needs_update = 0
		screen.blit(self.buffer, (0, 0))


	def update_buffer(self, size):
		self.buffer = Surface(size)
		self.buffer.set_colorkey(transparent)
		self.buffer.fill(transparent)
		self.redraw()

	def redraw(self):
		pass

	def update(self, dt):
		pass

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [as 别名]
class Track(pygame.sprite.Sprite):
	def __init__(self):
		pygame.sprite.Sprite.__init__(self)
		self.equation = test_equation
		self.color = Color("#C98C57")
		self.generate_track_image()
		self.rect = Rect(0, 0, WIN_WIDTH, WIN_HEIGHT)
		self.mask = pygame.mask.from_surface(self.image)

	def generate_track_image(self):
		self.image = Surface((WIN_WIDTH, WIN_HEIGHT))
		self.image.fill(DEFAULT_COLORKEY)
		self.image.set_colorkey(DEFAULT_COLORKEY)
		track_painter = Surface((32, 32))
		track_painter.fill(self.color)
		x, y = self.coordinates(0)
		for i in xrange(1000):
			dest_x, dest_y = self.coordinates(i)
			while(abs(x - dest_x) > 1 or abs(y - dest_y) > 1):
				vec_x, vec_y = dest_x - x, dest_y - y
				length = math.pow( math.pow(vec_x, 2) + math.pow(vec_y, 2), 0.5)
				add_x, add_y = vec_x/length, vec_y/length
				x += add_x
				y += add_y
				self.image.blit(track_painter, (x, y))
			if x < -1*MAX_OUTSIDE_DISTANCE or x > WIN_WIDTH + MAX_OUTSIDE_DISTANCE or y < -1*MAX_OUTSIDE_DISTANCE or y > WIN_HEIGHT + MAX_OUTSIDE_DISTANCE: break

	def coordinates(self, t):
		return self.equation(t)

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [as 别名]
    def render(self, text):
        """ Renders the text using the options first used. """

        lines = text.splitlines()
        img = Surface(self._calculate_image_size(self.font, 
                             self.text, self.size, self.line_spacer, self.layers))
        if self.bg_transparent:
            img.set_colorkey(self.background)
        full_rect = img.get_rect()
        
        y = 0
        for l in lines:
            r = self.font.render(l, self.size, self.background, self.bg_transparent, self.layers)
            r_rect = r.get_rect()
            if self.bg_transparent:
                r.set_colorkey(self.background)
            if self.align == self.A_CENTER:
                x = self._center_rect_inside_rect(r_rect, full_rect)
            elif self.align == self.A_LEFT:
                x = 0
            elif self.align == self.A_RIGHT:
                x = full_rect[3] - r_rect[3]
            img.blit(r, (x, y))
            y += self.line_spacer + r_rect[3]
        
        return img

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [as 别名]
class Enemy(Sprite):
    width = 40
    height = 40
    
    y = -40
    
    def __init__(self):
        self.x = randrange(0,scrWidth-self.width)
        Sprite.__init__(self)

        #Self.rect and self.image
        self.rect = Rect((self.x,self.y),(self.width,self.height))
        self.image = Surface(self.rect.size)
        self.image.fill((0,0,0))
        self.image.set_colorkey((0,0,0))

        #Draw stuff
        pygame.draw.ellipse(self.image,red,self.image.get_rect())
        pygame.draw.ellipse(self.image,blue2,self.image.get_rect(),15)

        #Randomly picking trajectory
        self.down = randrange(1,5)
        self.side = randrange(-6,6,4)
    def update(self):
        "Movement behavior"
        
        self.rect.y += self.down
        self.rect.x += self.side
        
        if self.rect.right > scrWidth or self.rect.left < 0:
            self.side *=-1
        if self.rect.top > scrHeight:
            self.kill()

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [as 别名]
class RoboImages(Sprite):
    color = 0,0,0
    size = 60,60
    def __init__(self, parent):
        Sprite.__init__(self)
        self.parent = parent
        self.name = parent.name
        if parent.name == "baby":
            self.size = 40,40
        self.color = parent.color
        self.image = Surface(self.size)
        self.rect = self.image.get_rect()
        self.rect.centerx = self.parent.rect.centerx
        self.rect.centery = self.parent.rect.centery
        self.dir = dir
        
    

        try:
            self.image = load_image(self.name+'bot')
            print "found family sprite"
        except:
            self.image.fill(self.color)
            print "failed to load family image"
        
        
        self.image = pygame.transform.scale(self.image, self.size)
        self.image.set_colorkey((255,255,255))
        
   
    def update(self):
        self.rect.center = self.parent.rect.center
        if not self.parent.alive():
            self.kill()

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [as 别名]
	def rotated_bolt_image(self, angle):
		image = Surface((32, 32))
		image.set_colorkey(DEFAULT_COLORKEY)
		image.fill(DEFAULT_COLORKEY)
		image.blit(self.projectile_image, (0, 0))
		image = pygame.transform.rotate(image, angle)
		return image

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [as 别名]
def get_blank_surf(size):
    """Gets the kind of Surface we want to work with.
    Allows for sprites and fonts to be treated the same
    by the opacity methods in the view object.
    """
    NewSurf = Surface(size).convert()
    NewSurf.set_colorkey(NewSurf.get_at((0, 0)), RLEACCEL)
    return NewSurf

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [as 别名]
 def draw_range_circle(self, screen, radius, pos = None):
     if pos == None: pos = self.mouse_position
     if radius <= 0: return
     range_circle_image = Surface((radius*2, radius*2))
     range_circle_image.fill(DEFAULT_COLORKEY)
     range_circle_image.set_colorkey(DEFAULT_COLORKEY)
     pygame.draw.circle(range_circle_image, GREY, (radius, radius), radius - 1, 2)
     screen.blit(range_circle_image, (pos[0] - radius, pos[1] - radius))

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [as 别名]
	def draw_target_pointer(self):
		target = self.monsters.monsters[self.target_index]
		width, height =  target.image.get_width(), target.image.get_height()
		monster_offset = (20 + 100*self.target_index, height)
		pointer_x, pointer_y = monster_offset[0] + width/2 - 8, MONSTER_FLOOR_Y - height - 20
		pointer = Surface((16, 16))
		pointer.set_colorkey(BLACK)
		pygame.draw.polygon(pointer, RED, [(0, 0), (16, 0), (8, 16)])
		self.screen_image.blit(pointer, (pointer_x, pointer_y))

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [as 别名]
def void_frame(size, bck):
    surface = Surface(size)
    try:
        surface.fill(bck)
        surface.set_colorkey(bck, RLEACCEL)
    except TypeError:
        surface.fill(WHITE)
        surface.set_colorkey(constants.WHITE, RLEACCEL)
    return surface.convert()

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [as 别名]
 def __init__(self, x, y, **kwargs):
     img = Surface((50,50))
     img = img.convert()
     img.fill(PINK_TRANSPARENT)
     img.set_colorkey(PINK_TRANSPARENT)
     col_rect = Rect(24,24,2,2)
     TryParticle.__init__(self, x=x, y=y, gravity = 0.5, has_gravity=True, image = img, col_rect=col_rect, life_time=100, collides=True)
     FadeOutParticle.__init__(self, fade_out_time = 30, life_time = 30)
     RandomSpeedParticle.__init__(self, max_speed = 10, delta_ang = 360, min_speed=5)

# 需要导入模块: from pygame import Surface [as 别名]
# 或者: from pygame.Surface import set_colorkey [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